Skip to content
Snippets Groups Projects
  1. Jan 12, 2004
  2. 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
    • Fons Rademakers's avatar
      remove unused function Color(). · ae1fc987
      Fons Rademakers authored
      git-svn-id: http://root.cern.ch/svn/root/trunk@7879 27541ba8-7e3a-0410-8455-c3a389f83636
      ae1fc987
  3. Jan 09, 2004
  4. Jan 08, 2004
  5. Jan 07, 2004
Loading