Skip to content
Snippets Groups Projects
  1. Jan 27, 2004
    • Rene Brun's avatar
      From Philippe: · 6f363575
      Rene Brun authored
      This patches improves the consistency of the naming convention for the TClass
      of STL containers.  Previous, std::vector<float>, vector<float>, etc. could be
      considered as 2 different entities by part of the ROOT code.  This rationalizes these
      cases.  It should fix all reported related bugs.
      
      
      git-svn-id: http://root.cern.ch/svn/root/trunk@8056 27541ba8-7e3a-0410-8455-c3a389f83636
      6f363575
  2. Jan 23, 2004
    • Rene Brun's avatar
      From Philippe: · c58630db
      Rene Brun authored
      With this patch, rootcint is now aware that it is in a windows environment when parsing the header files.
      In particular, this repairs the behavior of std::cout.
      
      
      git-svn-id: http://root.cern.ch/svn/root/trunk@7994 27541ba8-7e3a-0410-8455-c3a389f83636
      c58630db
  3. Jan 21, 2004
  4. Jan 16, 2004
  5. Jan 10, 2004
    • Fons Rademakers's avatar
      the macro $(ROOTCINTTMP) is not known in metautils/Module.mk since make · 89049609
      Fons Rademakers authored
      is reading utils/Module.mk after metautils/Module.mk so effectively the
      rootcint_tmp dependency was lost. Replaced $(ROOTCINTTMP) macro by
      explicit utils/src/rootcint_tmp in metautils/Module.mk.
      
      
      git-svn-id: http://root.cern.ch/svn/root/trunk@7881 27541ba8-7e3a-0410-8455-c3a389f83636
      89049609
    • Rene Brun's avatar
      From Philippe: · 2b412e44
      Rene Brun authored
      This mega patch introduces a new implementation of the STL I/O
      which is backward and forward compatible.  In addition this is more
      exactly a new implementation or an extension of the container I/O.
      
      We are introducing a new abstract interface:
      "TVirtualContainerProxy", which can be implemented to present a
      proxy to any collection which the I/O (and TTreeFormula) can use
      then transparently.
      
      The TVirtualContainerProxy interface allows to the I/O system to
      request some information and to execute some essential function of
      the container:
         what kind of object/data does it contain
         does it contain pointers
         how to insert data into the container
         how to retrieve an array of pointer to the elements inside
         how to create a collection object
         how to clear the collection
         how to resize the collection
         how to streamer the collection (if needed)
         how to calculate the sizeof the collection
         how to calculate the number of elements of the collection.
      
      Using those primitives, the I/O and TTreeFormula should be able to
      access any collection.   The I/O should also be able to handle the
      splitting of collections that can be split (i.e. contains a single
      type of object/data).
      
      The current compromise selected between code duplication,
      performance of the I/O of TClonesArray and vector of pointers and
      the performance of the I/O of other containers, was to have on
      function handle all collection as if they were a C-style array of
      pointers to data.  This implies for example that the I/O of vector
      of object current passes via the construction of temporary array
      of pointer.  The cost of this construction is usually ~Qjust~R the
      cost of calculating the addresses of the elements and assigning it
      to an array element.
      
      Registering a collection proxy will be similar to
           static int dummy = GenerateInitInstance((CollectType*)0x0)-
      >AdoptCollectionProxy(new CollectTypeProxy));
      
      Follows a few details on the modifications made to some of the
      files and classes.
      
      Bytes.h:
         Work around a problem in the MSVC++ 6.0 optimizer.  This should
      not affect other compilers.
      
      String:
         Included the std::string dictionary into G__Base2.cxx, this
      insures its presence at all time.
         Added a new file string.cxx holding the streamer for
      std::string.
      
      RConfig.h
         Added proper ansi stream configuration for AIX, KCC
         Added template specialization defect for MSVC
      
      TBrowser
         Start adding the ability to browser non TObject classes
      
      TBuffer
         To handle the reading and writing array of objects, added:
           Int_t    CheckByteCount(UInt_t startpos, UInt_t bcnt, const
      TClass *clss, const char* classname);
           Int_t    CheckByteCount(UInt_t startpos, UInt_t bcnt, const
      char *classname);
           void     ReadFastArray(void  *start , TClass *cl, Int_t n=1,
      TMemberStreamer *s=0);
           void     ReadFastArray(void **startp, TClass *cl, Int_t n=1,
      Bool_t isPreAlloc=kFALSE, TMemberStreamer *s=0);
           void     WriteFastArray(void  *start,  TClass *cl, Int_t n=1,
      TMemberStreamer *s=0);
           Int_t    WriteFastArray(void **startp, TClass *cl, Int_t n=1,
      Bool_t isPreAlloc=kFALSE, TMemberStreamer *s=0);
      
      TROOT
         Enhancement to make the access to gROOT not dependent for the
      library loading order.  In particular we added:
            ROOT::GetROOT()
         which should be used instead of gROOT.
      
         Improve support for STL.  In particular, now STL containers do
      have a corresponding TClass object
      
      
      TRealData
         Replace SetStreamer by AdoptStreamer that allow to use not only
      a streamer function but also streamer object (allowing streamer
      with a state for Foreign classes)
      
      TString:
         Improve streamer performance
      
      TSystem:
         More consistency of the return value of TSystem::CompileMacro
      
      build/unix/makecintdlls.sh
         Stop making the string.dll
      
      config:
         enhance sgicc makefiles
      
      cont:
         fix TBits::operator=
         TClassTable now warns for duplicate only for non stl classes
         TClonesArray fix a typo
      
      gpad:
         Add a new class TInspectObject to enable inspect non TObject
      classes
         TRootBrowser : enable inspect non TObject classes
      
      TFormula/TTreeFormula
         To enhance performance switch from using one array fOper which
      contained the operation code and its arguments to using 2 arrays
      fActions and fActionParams to store respectively the operation and
      its parameters.
         A new function Convert is used to convert old version from the
      fOper to fActions.  This allows cleaner coding and offer
      optimization opportunities.
      
      TTreePlayer
         Start adding support in MakeClass for STL containers.
      
      TRint/TProofServ
         Insure the loading of the string support
      
      Event.cxx
         make sure to avoid memory over-write
      
      stress.cxx
         Add new parameters
            stress <nevent> <style> <subbench> <portion>
         if <subbench> is 1 or higher, print the benchmark results after
      each test.  This allows understand
         which test is affect by a performance change.
         portion is a binary field to indicate which test to run.  This
      allows to focus on a particular test.
      
      TVirtualCollectionProxy
         Abstract interface used to access any type of containers from
      the I/O system and TTreeFormula. See TVectorProxy and
      TEmulatedVectorProxy for examples.
      
      TEmulatedVectorProxy
         Implementation of a std::vector proxy to be able to read a
      std::vector without any libraries.
      
      TVectorProxy
         Implementation of TVirtualCollectionProxy for a std::vector for
      which we have the library.
      
      TStreamerInfo.cxx
         Split in 3 files:  TStreamerInfo.cxx
      TStreamerInfoReadBuffer.cxx TStreamerInfoWriteBuffer.cxx
      
         All the ReadBuffer, ReadBufferClones and the new ReadBufferSTL
      (similarly for  WriteBuffer) have been factorized into one
      function and 2 short wrappers.  The new main function expect an
      array of pointer to the objects (this array is most often of size
      one).
      
         TClonesArray objects pass GetObjectRef(0) to the common
      ReadBuffer
         vector<bla*> v pass &(v[0])
         vector<bla> needs to create an intermediary array to hold the
      address
      
         This mechanism is sometimes not optimal (vector<blah>) but
      allows extremely flexibly and extension.  Basically, to add
      support for a new container type using the StreamerInfo mechanism
      (in particular allows splitting), one 'just' need to implement a
      TVirtualCollectionProxy, which, in particular, will return an
      array of address to the object it contains.  Even std::map can be
      handled with this mechanism, since, for I/O purposes, it can be
      consider as a container of pairs.
      
         Add a few optimization, including more caching via a new array
      of a new struct (fComp).
      
         Fixed a problem (re)introduced while implementing the Foreign
      class CheckSum.  Doing:
            class Event;
            f = new TFile("Event.root");
         resulted in errors.
      
      TCint
         Add proper support for TClass of STL containers. Fix a memory
      leak.
         Add support for load TClass via a typedef.
         Fix a problem with multiple inheritance
      
      TClass
         Fixed a problem (re)introduced while implementing the Foreign
      class CheckSum.  Doing:
            class Event;
            f = new TFile("Event.root");
         resulted in errors.
         Add a
      
      TClass/TGenericClassInfo/TDataMember
         Add support for a new interface (TVirtualCollectionProxy)
      useable for STL containers or any user defined containers.
         Add support for streamer with are objects (as opposed to free
      standing function or methods).  This allows the user a greater
      flexibility in writing a streamer.
         Add a few optimizations
         Add CanSplit to answer the question for a whole Class (for
      example some collection can not be splitted).
      
      TClassStreamer
         New class to wrap a class wide streamer
      
      ClassStreamerFunc_t
         typedef for a class wide streamer function
      
      TMemberStreamer
         New class to wrap a specific class member streamer
      
      MemberStreamerFunc_t
         typedef for  a specific class member streamer function
      
      RootStreamer
         Macro to specify a free standing streamer object or function
      for a class
         For example:
            RootStreamer(string,std_string_streamer);
      
      TStreamerElement:
         A couple of optimization/simplification.
         Add support for the new STL I/O
         Extend the useful
      
      TBranchElement:
         add a connection to the proper TVirtualCollectionProxy
         add support for STL containers (non-split and split mode)
      
      TTree
         Make the function TTree::GetMakeClass NON-virtual for better
      efficiency
         Add support for STL containers
      
      TBasket
         Left (in comment) a yet unproved improvement proposed by
      Victor.  The preliminary tests were inconclusive performance wise
      and it had (seemingly) problem with backward and forward
      compatibility.
      
      TBranch
         Performance improvements
      
      metautils
         This is a new package for C++ files shared between rootcint and
      meta.
         It contains TClassEdit a class to help determine some property
      of a class given its class name (stl, template, etc).
      
      utils
         Introduced a new file RStl.cxx to start separating rootcint in
      modules.
         Modified rootcint to support the new STL I/O methods.
         In particular a new class RStl is in charge of doing the
      generating of code for STL containers.
      
      
      git-svn-id: http://root.cern.ch/svn/root/trunk@7880 27541ba8-7e3a-0410-8455-c3a389f83636
      2b412e44
  6. Jan 03, 2004
  7. Dec 13, 2003
  8. Dec 12, 2003
  9. Dec 11, 2003
  10. Dec 05, 2003
  11. Dec 04, 2003
  12. Oct 31, 2003
  13. Aug 15, 2003
    • Rene Brun's avatar
      From Philippe: · ec1c1a2f
      Rene Brun authored
      This patch fixes the shadow class generation in case of virtual inheritance.
      This also makes sure that enums are always properly read (when inside an STL container).
      
      
      git-svn-id: http://root.cern.ch/svn/root/trunk@7099 27541ba8-7e3a-0410-8455-c3a389f83636
      ec1c1a2f
  14. Aug 05, 2003
    • Rene Brun's avatar
      Fix by Philippe for a problem reported by Gordon Watts when installing · 3c836c33
      Rene Brun authored
      under VC++7.1.NET (was OK under 7.0)
      
      I finally discovered the source of the problem (library is generated, compiled, linked and loaded properly but the
      symbol are not available).
      
      Because of one bug in rootcint and one bug in CINT and the fact that you are using a period ('.') in one the directory
      name, the DLLID of all your libraries was the same (hence all but the first one thought they were already loaded into
      the CINT dictionaries).
      
      
      git-svn-id: http://root.cern.ch/svn/root/trunk@7039 27541ba8-7e3a-0410-8455-c3a389f83636
      3c836c33
  15. Aug 02, 2003
  16. Jul 29, 2003
  17. Jul 16, 2003
  18. Jul 14, 2003
  19. Jul 10, 2003
  20. Jun 25, 2003
  21. Jun 06, 2003
  22. May 27, 2003
  23. Apr 02, 2003
  24. Mar 05, 2003
    • Rene Brun's avatar
      From Philippe: · 568e67ec
      Rene Brun authored
      This simple patch improve the situation as far as private inheritance is concerned.  In particular this allow usages like :
      class X : Y, public TObject {};
      This also corrects the temporary objects deletion in TClass::BuildRealData which was incorrect for classe inheriting from
      TObject only as 2nd or later inheritances.
      
      
      git-svn-id: http://root.cern.ch/svn/root/trunk@6256 27541ba8-7e3a-0410-8455-c3a389f83636
      568e67ec
  25. Feb 27, 2003
  26. Feb 07, 2003
  27. Feb 05, 2003
  28. Jan 31, 2003
  29. Jan 22, 2003
  30. Jan 16, 2003
    • Rene Brun's avatar
      From Philippe: · 7b3b0795
      Rene Brun authored
      I finally got some time to look at why CINT dictionary kept using __malloc_alloc_template with gcc 2.9x.  The reasons I was
      looking
      into it is that I have been having to filter out the word
      '__malloc_alloc_template' when creating the Shadow (this was leading
      to compiler error).  And today, I discovered that, more subtely, it
      was making most multiple inheritances from a std container wrong.
      
      The content of G__cpp_setup_inheritancedict was something like:
      
           DerivedTemplate<int> *G__Lderived;
           list<int,__malloc_alloc_template> *G__Lpbase=(list<int,__malloc_alloc_template>*)G__Lderived;
              ... (long)G__Lpbase-(long)G__Lderived ...
      
      with DerivedTemplate inheriting from list.  And the result of the substraction was 0!
      
      So I investigated further and discovered that gcc 2.9x uses __malloc_alloc_template
      if and ONLY if the symbol __USE_MALLOC was set.  In the other case it uses
      __default_alloc_template.
      
      This means that in my example DerivedTemplate inherited from
      list<int,__default_alloc_template> and NOT from list<int,__malloc_alloc_template>.
      Hence the error.
      
      The simple solution was to use neither of the 2 alloc_template but to use/rely on the typedef that gcc uses.  So for
      makecint/rootcint ONLY, I modified CINT's memory header (see attachement).
      
      This actually should fix ALL the problems we encountered related to __malloc_alloc_template.
      
      
      git-svn-id: http://root.cern.ch/svn/root/trunk@5920 27541ba8-7e3a-0410-8455-c3a389f83636
      7b3b0795
  31. Jan 11, 2003
  32. Jan 09, 2003
  33. Dec 17, 2002
Loading