Skip to content
Snippets Groups Projects
Select Git revision
0 results
Search by author
  • Any Author
0 authors
  1. Jun 07, 2020
    • Sergey Linev's avatar
      Include standard includes where required · f1872663
      Sergey Linev authored 
      Includes like "strlcpy.h" and "snprintf.h" are provided via Rtypes.h,
but really used only in part of the sources. Before removing them
from Rtypes.h (in dev builds) provide them all in required places
      f1872663
  3. Jun 06, 2017
    • Vassil Vassilev's avatar
      Do not confuse clang-format. · 68a8a335
      Vassil Vassilev authored 
      ClassImp is a macro defined in Rtypes.h. It can be written without trailing
semicolon. However, clang-format is based on lexing and it doesn't know at
all about preprocessors and how to expand macros. When visiting ClassImp(X)
it thinks this is not a completed entity (as it doesn't expand macros) and
considers the next line as continuation of the previous.

Inserting a semicolon fixes the issue and makes formatting with clang-format
in the ROOT codebase less tricky.
      68a8a335
  5. Jun 26, 2015
  7. Aug 05, 2014
  9. Aug 11, 2011
    • Philippe Canal's avatar
      From ideas provided by Mike Marino, introduce TClonesArray::ConstructedAt which · c2038667
      Philippe Canal authored 
      always returns an already constructed object.   If the slot is being used for the
first time, it calls the default constructor otherwise it returns the object as 
is (unless a string is passed as the 2nd argument to the function in which case,
it also calls Clear(second_argument) on the object).
This allows replace code like:
   for (int i = 0; i < ev->Ntracks; i++) {
       new(a[i]) TTrack(x,y,z,...);
       ...
       ...
   }
   ...
   a.Delete(); // or a.Clear("C")
with the simpler and more efficient:
   for (int i = 0; i < ev->Ntracks; i++) {   
       TTrack *track = (TTrack*)a.ConstructedAt(i);
       track->Set(x,y,z,....);
       ...                                                          
       ...                                                          
   }                                                               
   ...                                                             
   a.Clear();
even in case where the TTrack class allocates memory.


git-svn-id: http://root.cern.ch/svn/root/trunk@40562 27541ba8-7e3a-0410-8455-c3a389f83636
      c2038667
  11. Aug 10, 2011
  13. Mar 18, 2011
  15. Oct 12, 2010
  17. Aug 02, 2010
  19. Jul 31, 2010
  21. Jul 30, 2010
  23. Sep 19, 2007
  25. May 09, 2006
  27. Jan 19, 2005
  29. Jan 25, 2004
    • Rene Brun's avatar
      New Linear Algebra package from Eddy Offermann. · 90627628
      Rene Brun authored 
      This new package reimplements the previous classes TMatrix and TMatrixD.
The new classes should be back compatible with the previous version except
the function GetElements.
New classes have been introduced for symmetric matrices,
lazy matrices.
New algorithms (LU, SVD) have been introduced.
A new test suite test/stressLinear.cxx is introduced.
A complete description of this package will be posted in the coming days.
The classes are well documented in the implementation headers.


git-svn-id: http://root.cern.ch/svn/root/trunk@8013 27541ba8-7e3a-0410-8455-c3a389f83636
      90627628
  31. Jan 10, 2004
    • 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
  33. Jan 06, 2004
  35. Dec 27, 2003
  37. Aug 23, 2003
  39. Aug 22, 2003
  41. Jan 30, 2003
    • Rene Brun's avatar
      From Philippe: · 275f3f2c
      Rene Brun authored 
      This patch adds systematic test for the ability of TTree::Draw to draw TBits objects.
It also fixes all the bug discovered during the tests.
It also adds a test for split level 2.


git-svn-id: http://root.cern.ch/svn/root/trunk@6011 27541ba8-7e3a-0410-8455-c3a389f83636
      275f3f2c
  43. Aug 20, 2002
  45. Aug 07, 2002
  47. Aug 01, 2002
  49. Dec 02, 2001
  51. Nov 28, 2001
  53. Nov 22, 2001
  55. Oct 10, 2001
  57. Oct 07, 2001
  59. Oct 05, 2001
    • Rene Brun's avatar
      Modify the test program to illustrate the new classes TRef and TRefArray. · 549b0ea1
      Rene Brun authored 
      The following members have been added to Event.h
   TRefArray     *fHighPt;       //array of High Pt tracks only
   TRefArray     *fMuons;        //array of Muon tracks only
   TRef           fLastTrack;    //pointer to last track

In MainEvent (write part) the two arrays are filled in the loop
making the tracks. fLastTrack is set directly in AddTrack.

Split mode can be used to store in separate branches the original
tracks and the two selected track arrays. Only one copy of a track
is stored in the file. When the file is read back, one can read
in any order the TClonesArray of tracks or the other arrays.
If the array fMuons is read and the TClonesArray branches are not
read, fMuons->At(i) will return 0. When the TClonesArray is read,
fMuons->at(i) will return a pointer to the selected track number i
in the TRefArray fMuons. This will point directly to one of the
tracks in the TClonesArray.

Note that the branches fHighPt, fMuons and fLastTrack could also
be stored in separate files (may be friends of the master file).


git-svn-id: http://root.cern.ch/svn/root/trunk@2987 27541ba8-7e3a-0410-8455-c3a389f83636
      549b0ea1
  61. Nov 23, 2000
  63. Nov 21, 2000
  65. Oct 02, 2000
  67. Sep 29, 2000
  69. Jul 12, 2000
  71. Jul 11, 2000