memory bug fix in SliceOutput

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCADef.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCADef.h
index 9903e792baa88effa2896118ca52626dbabe04a3..171db67c8f75e5d8b6877f6f41b2f34a8adbcf11 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCADef.h
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCADef.h
@@ -27,16 +27,16 @@
 #endif
 
 #if defined(R__WIN32)
-#ifdef INTEL_RUNTIME\r
-#pragma warning(disable : 1786)\r
-#pragma warning(disable : 1478)\r
-#pragma warning(disable : 161)\r
-#endif\r
-\r
-#ifdef VSNET_RUNTIME\r
-#pragma warning(disable : 4616)\r
-#pragma warning(disable : 4996)\r
-#pragma warning(disable : 1684)\r
+#ifdef INTEL_RUNTIME
+#pragma warning(disable : 1786)
+#pragma warning(disable : 1478)
+#pragma warning(disable : 161)
+#endif
+
+#ifdef VSNET_RUNTIME
+#pragma warning(disable : 4616)
+#pragma warning(disable : 4996)
+#pragma warning(disable : 1684)
 #endif
 #endif
 

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.cu b/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.cu
index e5530ceb0993c9a0d1223c260abb917158933f9c..4c208437db3c97ec03f0c9326931a2b003492e32 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.cu
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.cu
@@ -221,11 +221,12 @@ int AliHLTTPCCAGPUTracker::InitGPU(int sliceCount, int forceDeviceID)
          const int useDebugLevel = fDebugLevel;
          fDebugLevel = 0;
          AliHLTTPCCAClusterData tmpCluster;
-         AliHLTTPCCASliceOutput tmpOutput;
+         AliHLTTPCCASliceOutput *tmpOutput = NULL;
          AliHLTTPCCAParam tmpParam;
          tmpParam.SetNRows(HLTCA_ROW_COUNT);
          fSlaveTrackers[0].SetParam(tmpParam);
          Reconstruct(&tmpOutput, &tmpCluster, 0, 1);
+         free(tmpOutput);
          fDebugLevel = useDebugLevel;
   }
 #endif
@@ -380,7 +381,7 @@ __global__ void PreInitRowBlocks(int4* const RowBlockPos, int* const RowBlockTra
                sliceDataHitWeights4[i] = i0;
 }
 
-int AliHLTTPCCAGPUTracker::Reconstruct(AliHLTTPCCASliceOutput* pOutput, AliHLTTPCCAClusterData* pClusterData, int firstSlice, int sliceCountLocal)
+int AliHLTTPCCAGPUTracker::Reconstruct(AliHLTTPCCASliceOutput** pOutput, AliHLTTPCCAClusterData* pClusterData, int firstSlice, int sliceCountLocal)
 {
        //Primary reconstruction function
        cudaStream_t* const cudaStreams = (cudaStream_t*) fpCudaStreams;

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.cxx
index 5c8f67aef8d8d86049c3b03ff004e5e9b02c33db..3e934850ee6a1f907fdcb3055fb26cae68aba499 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.cxx
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.cxx
@@ -26,12 +26,13 @@ int AliHLTTPCCAGPUTracker::InitGPU(int /*sliceCount*/, int /*forceDeviceID*/)
     HLTInfo("CUDA Compiler was not available during build process, omitting CUDA initialization");
     return(1);
 }
-void StandalonePerfTime(int /*iSlice*/, int /*i*/) {}
+void AliHLTTPCCAGPUTracker::StandalonePerfTime(int /*iSlice*/, int /*i*/) {}
 //template <class T> inline T* AliHLTTPCCAGPUTracker::alignPointer(T* ptr, int alignment) {return(NULL);}
 //bool AliHLTTPCCAGPUTracker::CudaFailedMsg(cudaError_t error) {return(true);}
 //int AliHLTTPCCAGPUTracker::CUDASync() {return(1);}
 void AliHLTTPCCAGPUTracker::SetDebugLevel(int /*dwLevel*/, std::ostream* /*NewOutFile*/) {}
 int AliHLTTPCCAGPUTracker::SetGPUTrackerOption(char* /*OptionName*/, int /*OptionValue*/) {return(1);}
-int Reconstruct(AliHLTTPCCASliceOutput* /*pTracker*/, AliHLTTPCCAClusterData* /*pClusterData*/, int /*fFirstSlice*/, int /*fSliceCount*/) {return(1);}
+int AliHLTTPCCAGPUTracker::Reconstruct(AliHLTTPCCASliceOutput** /*pTracker*/, AliHLTTPCCAClusterData* /*pClusterData*/, int /*fFirstSlice*/, int /*fSliceCount*/) {return(1);}
 int AliHLTTPCCAGPUTracker::ExitGPU() {return(0);}
 int AliHLTTPCCAGPUTracker::InitializeSliceParam(int /*iSlice*/, AliHLTTPCCAParam& /*param*/) {}
+

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.h
index fd432e5461cd9d1e815e619d579cbe03c7fead46..fec733703529b785014dc3ce745edc71dbcbed6b 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.h
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCAGPUTracker.h
@@ -30,7 +30,7 @@ public:
          ~AliHLTTPCCAGPUTracker() {};
 
        int InitGPU(int sliceCount = 1, int forceDeviceID = -1);
-       int Reconstruct(AliHLTTPCCASliceOutput* pOutput, AliHLTTPCCAClusterData* pClusterData, int fFirstSlice, int fSliceCount = -1);
+       int Reconstruct(AliHLTTPCCASliceOutput** pOutput, AliHLTTPCCAClusterData* pClusterData, int fFirstSlice, int fSliceCount = -1);
        int ExitGPU();
 
        void SetDebugLevel(const int dwLevel, std::ostream* const NewOutFile = NULL);

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.cxx
index 59d7c694a4ba2699d531525cf5e669c69c32a934..37f401825a68e791b421e29933e559d84837a8db 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.cxx
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.cxx
@@ -32,17 +32,6 @@ GPUhd() int AliHLTTPCCASliceOutput::EstimateSize( int nOfTracks, int nOfTrackClu
 
 #ifndef HLTCA_GPUCODE
 
-void AliHLTTPCCASliceOutput::Clear()
-{
-       //Clear Slice Output and free Memory
-       if (fMemory) delete[] fMemory;
-       fMemory = NULL;
-       fNOutTracks = 0;
-       fNOutTrackHits = 0;
-       fNTracks = 0;
-       fNTrackClusters = 0;
-}
-
 template<typename T> inline void AssignNoAlignment( T *&dst, char *&mem, int count )
 {
   // assign memory to the pointer dst
@@ -50,37 +39,38 @@ template<typename T> inline void AssignNoAlignment( T *&dst, char *&mem, int cou
   mem = ( char * )( dst + count );
 }
 
-void AliHLTTPCCASliceOutput::SetPointers()
+void AliHLTTPCCASliceOutput::SetPointers(int nTracks, int nTrackClusters)
 {
   // set all pointers
+       if (nTracks == -1) nTracks = fNTracks;
+       if (nTrackClusters == -1) nTrackClusters == fNTrackClusters;
 
   char *mem = fMemory;
-  AssignNoAlignment( fTracks,            mem, fNTracks );
-  AssignNoAlignment( fClusterUnpackedYZ, mem, fNTrackClusters );
-  AssignNoAlignment( fClusterUnpackedX,  mem, fNTrackClusters );
-  AssignNoAlignment( fClusterId,         mem, fNTrackClusters );
-  AssignNoAlignment( fClusterPackedYZ,   mem, fNTrackClusters );
-  AssignNoAlignment( fClusterRow,        mem, fNTrackClusters );
-  AssignNoAlignment( fClusterPackedAmp,  mem, fNTrackClusters );
+  AssignNoAlignment( fTracks,            mem, nTracks );
+  AssignNoAlignment( fClusterUnpackedYZ, mem, nTrackClusters );
+  AssignNoAlignment( fClusterUnpackedX,  mem, nTrackClusters );
+  AssignNoAlignment( fClusterId,         mem, nTrackClusters );
+  AssignNoAlignment( fClusterPackedYZ,   mem, nTrackClusters );
+  AssignNoAlignment( fClusterRow,        mem, nTrackClusters );
+  AssignNoAlignment( fClusterPackedAmp,  mem, nTrackClusters );
 
   // memory for output tracks
 
-  AssignMemory( fOutTracks, mem, fNTracks );
+  AssignMemory( fOutTracks, mem, nTracks );
 
   // arrays for track hits
 
-  AssignMemory( fOutTrackHits, mem, fNTrackClusters );
+  AssignMemory( fOutTrackHits, mem, nTrackClusters );
 
 
   fMemorySize = (mem - fMemory);
 }
 
-void AliHLTTPCCASliceOutput::Allocate()
+void AliHLTTPCCASliceOutput::Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits)
 {
        //Allocate All memory needed for slice output
-  if (fMemory) delete[] fMemory;
-  SetPointers(); // to calculate the size
-  fMemory = reinterpret_cast<char*> ( new uint4 [ fMemorySize/sizeof( uint4 ) + 100] );
-  SetPointers(); // set pointers
+  if (ptrOutput) free(ptrOutput);
+  ptrOutput = (AliHLTTPCCASliceOutput*) malloc(EstimateSize(nTracks, nTrackHits) + nTracks * sizeof(AliHLTTPCCAOutTrack) + nTrackHits * sizeof(int) + 1024);
+  ptrOutput->SetPointers(nTracks, nTrackHits); // set pointers
 }
 #endif

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.h
index f20503b2c47b5415406424a5a93dbc50936f7102..8eed00c59db8f7ebdd6853cd887600a547d8bbfd 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.h
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCASliceOutput.h
@@ -30,16 +30,6 @@
 class AliHLTTPCCASliceOutput
 {
   public:
-
-    AliHLTTPCCASliceOutput()
-        : fNTracks( 0 ), fNTrackClusters( 0 ), fTracks( 0 ),  fClusterId( 0 ), fClusterRow( 0 ), fClusterPackedYZ( 0 ), fClusterUnpackedYZ( 0 ), fClusterUnpackedX( 0 ), fClusterPackedAmp( 0 ),
-               fMemorySize( 0 ), fNOutTracks(0), fNOutTrackHits(0), fOutTracks(0), fOutTrackHits(0), fMemory(NULL) {}
-
-       ~AliHLTTPCCASliceOutput()
-       {
-               if (fMemory) delete[] fMemory;
-       }
-
     GPUhd() int NTracks()                    const { return fNTracks;              }
     GPUhd() int NTrackClusters()             const { return fNTrackClusters;       }
 
@@ -52,8 +42,8 @@ class AliHLTTPCCASliceOutput
     GPUhd() float    ClusterUnpackedX  ( int i )  const { return fClusterUnpackedX[i]; }
 
     GPUhd() static int EstimateSize( int nOfTracks, int nOfTrackClusters );
-    void SetPointers();
-       void Allocate();
+    void SetPointers(int nTracks = -1, int nTrackClusters = -1);
+       static void Allocate(AliHLTTPCCASliceOutput* &ptrOutput, int nTracks, int nTrackHits);
 
     GPUhd() void SetNTracks       ( int v )  { fNTracks = v;        }
     GPUhd() void SetNTrackClusters( int v )  { fNTrackClusters = v; }
@@ -66,11 +56,6 @@ class AliHLTTPCCASliceOutput
     GPUhd() void SetClusterUnpackedYZ( int i, float2 v ) {  fClusterUnpackedYZ[i] = v; }
     GPUhd() void SetClusterUnpackedX( int i, float v ) {  fClusterUnpackedX[i] = v; }
 
-       char* Memory() const { return(fMemory); }
-       size_t MemorySize() const { return(fMemorySize); }
-
-       void Clear();
-
        //Obsolete Output
 
     GPUhd()  int NOutTracks() const { return(fNOutTracks); }
@@ -83,7 +68,11 @@ class AliHLTTPCCASliceOutput
     GPUhd()  int OutTrackHit( int i ) const { return  fOutTrackHits[i]; }
 
   private:
+    AliHLTTPCCASliceOutput()
+        : fNTracks( 0 ), fNTrackClusters( 0 ), fTracks( 0 ),  fClusterId( 0 ), fClusterRow( 0 ), fClusterPackedYZ( 0 ), fClusterUnpackedYZ( 0 ), fClusterUnpackedX( 0 ), fClusterPackedAmp( 0 ),
+               fMemorySize( 0 ), fNOutTracks(0), fNOutTrackHits(0), fOutTracks(0), fOutTrackHits(0) {}
 
+       ~AliHLTTPCCASliceOutput() {}
     const AliHLTTPCCASliceOutput& operator=( const AliHLTTPCCASliceOutput& ) const { return *this; }
     AliHLTTPCCASliceOutput( const AliHLTTPCCASliceOutput& );
 
@@ -106,7 +95,8 @@ class AliHLTTPCCASliceOutput
     int *fOutTrackHits;  // output array of ID's of the reconstructed hits
 
        //Must be last element of this class, user has to make sure to allocate anough memory consecutive to class memory!
-    char* fMemory; // the memory where the pointers above point into
+       //This way the whole Slice Output is one consecutive Memory Segment
+    char fMemory[1]; // the memory where the pointers above point into
 
 };
 

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCAStandaloneFramework.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCAStandaloneFramework.cxx
index 1bc93dc317ba9aadf489a638597f9b88597debac..1246c337f99cb36bb78f45889d79df509ed0efdc 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCAStandaloneFramework.cxx
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCAStandaloneFramework.cxx
@@ -46,6 +46,7 @@ AliHLTTPCCAStandaloneFramework::AliHLTTPCCAStandaloneFramework()
     fLastTime[i] = 0;
     fStatTime[i] = 0;
   }
+  for ( int i = 0;i < fgkNSlices;i++) fSliceOutput[i] = NULL;
 }
 
 AliHLTTPCCAStandaloneFramework::AliHLTTPCCAStandaloneFramework( const AliHLTTPCCAStandaloneFramework& )
@@ -62,6 +63,7 @@ const AliHLTTPCCAStandaloneFramework &AliHLTTPCCAStandaloneFramework::operator=(
 
 AliHLTTPCCAStandaloneFramework::~AliHLTTPCCAStandaloneFramework()
 {
+       for (int i = 0;i < fgkNSlices;i++) if (fSliceOutput[i]) free(fSliceOutput[i]);
   //* destructor
 }
 
@@ -158,7 +160,7 @@ void AliHLTTPCCAStandaloneFramework::ProcessEvent(int forceSingleSlice)
   fMerger.SetSliceParam( fTracker.Param(0) );
 
   for ( int i = 0; i < fgkNSlices; i++ ) {
-    fMerger.SetSliceData( i, &fSliceOutput[i] );
+    fMerger.SetSliceData( i, fSliceOutput[i] );
   }
 
   fMerger.Reconstruct();

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCAStandaloneFramework.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCAStandaloneFramework.h
index c9b5edc65511e197d526167b5a265ed84e7f8466..763b7309aa63d6cf932c3bd5566e304332ff961b 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCAStandaloneFramework.h
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCAStandaloneFramework.h
@@ -37,7 +37,7 @@ class AliHLTTPCCAStandaloneFramework
 
        const AliHLTTPCCAParam &Param ( int iSlice ) const { return(fTracker.Param(iSlice)); }
        const AliHLTTPCCARow &Row ( int iSlice, int iRow ) const { return(fTracker.Row(iSlice, iRow)); }
-    const AliHLTTPCCASliceOutput &Output( int iSlice ) const { return fSliceOutput[iSlice]; }
+    const AliHLTTPCCASliceOutput &Output( int iSlice ) const { return *fSliceOutput[iSlice]; }
     AliHLTTPCCAMerger  &Merger()  { return fMerger; }
     AliHLTTPCCAClusterData &ClusterData( int iSlice ) { return fClusterData[iSlice]; }
 
@@ -101,7 +101,7 @@ class AliHLTTPCCAStandaloneFramework
 
     AliHLTTPCCAMerger fMerger;  //* global merger
     AliHLTTPCCAClusterData fClusterData[fgkNSlices];
-       AliHLTTPCCASliceOutput fSliceOutput[fgkNSlices];
+       AliHLTTPCCASliceOutput* fSliceOutput[fgkNSlices];
 
        AliHLTTPCCATrackerFramework fTracker;
 

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
index a2e442c944ca4803dba5492b4df6944461278f8b..d14715210378047bc3aca42a69619ade6c4c352a 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.cxx
@@ -410,11 +410,12 @@ GPUh() int AliHLTTPCCATracker::CheckEmptySlice()
 {
   if ( NHitsTotal() < 1 ) {
     {
-      SetPointersTracks( 1, 1 ); // to calculate the size
-      fTrackMemory = reinterpret_cast<char*> ( new uint4 [ fTrackMemorySize/sizeof( uint4 ) + 100] );
-      SetPointersTracks( 1, 1 ); // set pointers for tracks
-      fOutput->SetNTracks( 0 );
-      fOutput->SetNTrackClusters( 0 );
+         AliHLTTPCCASliceOutput::Allocate(*fOutput, 0, 0);
+         AliHLTTPCCASliceOutput* useOutput = *fOutput;
+      useOutput->SetNTracks( 0 );
+      useOutput->SetNTrackClusters( 0 );
+         useOutput->SetNOutTracks(0);
+         useOutput->SetNOutTrackHits(0);
     }
 
     return 1;
@@ -479,8 +480,6 @@ GPUh() void AliHLTTPCCATracker::Reconstruct()
 
   StandalonePerfTime(0);
 
-  fOutput->Clear();
-
   if (CheckEmptySlice()) return;
 
 #ifdef DRAW1
@@ -620,9 +619,11 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
 
   //cout<<"output: nTracks = "<<*fNTracks<<", nHitsTotal="<<NHitsTotal()<<std::endl;
 
-  fOutput->SetNTracks( fCommonMem->fNTracks );
-  fOutput->SetNTrackClusters( fCommonMem->fNTrackHits );
-  fOutput->Allocate();
+  AliHLTTPCCASliceOutput::Allocate(*fOutput, fCommonMem->fNTracks, fCommonMem->fNTrackHits);
+  AliHLTTPCCASliceOutput* useOutput = *fOutput;
+
+  useOutput->SetNTracks( fCommonMem->fNTracks );
+  useOutput->SetNTrackClusters( fCommonMem->fNTrackHits );
 
   int nStoredHits = 0;
 
@@ -634,7 +635,7 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
     out.SetNClusters( iTrack.NHits() );
     out.SetParam( iTrack.Param() );
 
-    fOutput->SetTrack( iTr, out );
+    useOutput->SetTrack( iTr, out );
 
     int iID = iTrack.FirstHitID();
     for ( int ith = 0; ith < iTrack.NHits(); ith++ ) {
@@ -686,12 +687,12 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
       hUnpackedYZ.y = origZ;
       float hUnpackedX = origX;
 
-      fOutput->SetClusterId( nStoredHits, id  );
-      fOutput->SetClusterRow( nStoredHits, ( unsigned char ) iRow  );
-      fOutput->SetClusterPackedYZ( nStoredHits, hPackedYZ );
-      fOutput->SetClusterPackedAmp( nStoredHits, hPackedAmp );
-      fOutput->SetClusterUnpackedYZ( nStoredHits, hUnpackedYZ );
-      fOutput->SetClusterUnpackedX( nStoredHits, hUnpackedX );
+      useOutput->SetClusterId( nStoredHits, id  );
+      useOutput->SetClusterRow( nStoredHits, ( unsigned char ) iRow  );
+      useOutput->SetClusterPackedYZ( nStoredHits, hPackedYZ );
+      useOutput->SetClusterPackedAmp( nStoredHits, hPackedAmp );
+      useOutput->SetClusterUnpackedYZ( nStoredHits, hUnpackedYZ );
+      useOutput->SetClusterUnpackedX( nStoredHits, hUnpackedX );
       nStoredHits++;
     }
   }
@@ -699,8 +700,8 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
 
   // old stuff
 #ifndef HLTCA_STANDALONE
-  fOutput->SetNOutTrackHits(0);
-  fOutput->SetNOutTracks(0);
+  useOutput->SetNOutTrackHits(0);
+  useOutput->SetNOutTracks(0);
 
 
   for ( int iTr = 0; iTr < fCommonMem->fNTracks; iTr++ ) {
@@ -711,24 +712,24 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
 
     //if( !iTrack.Alive() ) continue;
     if ( iTrack.NHits() < 3 ) continue;
-    AliHLTTPCCAOutTrack &out = fOutput->OutTracks()[fOutput->NOutTracks()];
-    out.SetFirstHitRef( fOutput->NOutTrackHits() );
+    AliHLTTPCCAOutTrack &out = useOutput->OutTracks()[useOutput->NOutTracks()];
+    out.SetFirstHitRef( useOutput->NOutTrackHits() );
     out.SetNHits( 0 );
     out.SetOrigTrackID( iTr );
     out.SetStartPoint( iTrack.Param() );
     out.SetEndPoint( iTrack.Param() );
 
     int iID = iTrack.FirstHitID();
-    int nOutTrackHitsOld = fOutput->NOutTrackHits();
+    int nOutTrackHitsOld = useOutput->NOutTrackHits();
 
     for ( int ith = 0; ith < iTrack.NHits(); ith++ ) {
       const AliHLTTPCCAHitId &ic = fTrackHits[iID + ith];
       const AliHLTTPCCARow &row = Row( ic );
       int ih = ic.HitIndex();
-      fOutput->SetOutTrackHit(fOutput->NOutTrackHits(), HitInputID( row, ih ));
-      fOutput->SetNOutTrackHits(fOutput->NOutTrackHits() + 1 );
+      useOutput->SetOutTrackHit(useOutput->NOutTrackHits(), HitInputID( row, ih ));
+      useOutput->SetNOutTrackHits(useOutput->NOutTrackHits() + 1 );
       //std::cout<<"write i,row,hit,id="<<ith<<", "<<ID2IRow(ic)<<", "<<ih<<", "<<HitInputID( row, ih )<<std::endl;
-      if ( fOutput->NOutTrackHits() >= 10*NHitsTotal() ) {
+      if ( useOutput->NOutTrackHits() >= 10*NHitsTotal() ) {
         std::cout << "fNOutTrackHits>NHitsTotal()" << std::endl;
         //exit(0);
         return;//SG!!!
@@ -736,9 +737,9 @@ GPUh() void AliHLTTPCCATracker::WriteOutput()
       out.SetNHits( out.NHits() + 1 );
     }
     if ( out.NHits() >= 2 ) {
-      fOutput->SetNOutTracks(fOutput->NOutTracks() + 1);
+      useOutput->SetNOutTracks(useOutput->NOutTracks() + 1);
     } else {
-      fOutput->SetNOutTrackHits(nOutTrackHitsOld);
+      useOutput->SetNOutTrackHits(nOutTrackHitsOld);
     }
   }
 #endif
@@ -925,18 +926,19 @@ GPUh() void AliHLTTPCCATracker::WriteEvent( std::ostream &out )
 GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &out )
 {
   //* Write tracks to file
+  AliHLTTPCCASliceOutput* useOutput = *fOutput;
 
   out << fTimers[0] << std::endl;
-  out << fOutput->NOutTrackHits() << std::endl;
-  for ( int ih = 0; ih < fOutput->NOutTrackHits(); ih++ ) {
-    out << fOutput->OutTrackHit(ih) << " ";
+  out << useOutput->NOutTrackHits() << std::endl;
+  for ( int ih = 0; ih < useOutput->NOutTrackHits(); ih++ ) {
+    out << useOutput->OutTrackHit(ih) << " ";
   }
   out << std::endl;
 
-  out << fOutput->NOutTracks() << std::endl;
+  out << useOutput->NOutTracks() << std::endl;
 
-  for ( int itr = 0; itr < fOutput->NOutTracks(); itr++ ) {
-    const AliHLTTPCCAOutTrack &t = fOutput->OutTrack(itr);
+  for ( int itr = 0; itr < useOutput->NOutTracks(); itr++ ) {
+    const AliHLTTPCCAOutTrack &t = useOutput->OutTrack(itr);
     AliHLTTPCCATrackParam p1 = t.StartPoint();
     AliHLTTPCCATrackParam p2 = t.EndPoint();
     out << t.NHits() << " ";
@@ -965,20 +967,23 @@ GPUh() void AliHLTTPCCATracker::WriteTracks( std::ostream &out )
 GPUh() void AliHLTTPCCATracker::ReadTracks( std::istream &in )
 {
   //* Read tracks  from file
-       int tmpval;
+  AliHLTTPCCASliceOutput::Allocate(*fOutput, 4096, 16384);//Just some max values
+  AliHLTTPCCASliceOutput* useOutput = *fOutput;
+
+  int tmpval;
   in >> fTimers[0];
   in >> tmpval;
-  fOutput->SetNOutTrackHits(tmpval);
+  useOutput->SetNOutTrackHits(tmpval);
 
-  for ( int ih = 0; ih < fOutput->NOutTrackHits(); ih++ ) {
+  for ( int ih = 0; ih < useOutput->NOutTrackHits(); ih++ ) {
     in >> tmpval;
-       fOutput->SetOutTrackHit(ih, tmpval);
+       useOutput->SetOutTrackHit(ih, tmpval);
   }
   in >> tmpval;
-  fOutput->SetNOutTracks(tmpval);
+  useOutput->SetNOutTracks(tmpval);
 
-  for ( int itr = 0; itr < fOutput->NOutTracks(); itr++ ) {
-    AliHLTTPCCAOutTrack &t = fOutput->OutTracks()[itr];
+  for ( int itr = 0; itr < useOutput->NOutTracks(); itr++ ) {
+    AliHLTTPCCAOutTrack &t = useOutput->OutTracks()[itr];
     AliHLTTPCCATrackParam p1, p2;
     int i;
     float f;

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.h
index ca2c287f2f78c19119089dcd1e950658626562c0..195929064a8e361b81391ac0502c8e895d969d68 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.h
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCATracker.h
@@ -147,7 +147,7 @@ class AliHLTTPCCATracker
        void SetPointersTracklets ( int MaxNTracklets );
     void SetPointersTracks( int MaxNTracks, int MaxNHits );
 
-       void SetOutput( AliHLTTPCCASliceOutput* out ) { fOutput = out; }
+       void SetOutput( AliHLTTPCCASliceOutput** out ) { fOutput = out; }
 
     void ReadEvent( AliHLTTPCCAClusterData *clusterData );
 
@@ -231,7 +231,7 @@ class AliHLTTPCCATracker
     GPUhd() int *NTrackHits()  const { return &fCommonMem->fNTrackHits; }
     GPUhd() AliHLTTPCCAHitId *TrackHits() const { return fTrackHits; }
 
-    GPUhd() AliHLTTPCCASliceOutput * Output() const { return fOutput; }
+    GPUhd() AliHLTTPCCASliceOutput** Output() const { return fOutput; }
 
        GPUh() commonMemoryStruct *CommonMemory() {return(fCommonMem); }
        static GPUh() size_t CommonMemorySize() { return(sizeof(AliHLTTPCCATracker::commonMemoryStruct)); }
@@ -241,8 +241,6 @@ class AliHLTTPCCATracker
        GPUh() size_t TrackletMemorySize() const {return(fTrackletMemorySize); }
        GPUh() char* &TrackMemory() {return(fTrackMemory); }
        GPUh() size_t TrackMemorySize() const {return(fTrackMemorySize); }
-       GPUh() char* OutputMemory() const {return(fOutput->Memory()); }
-       GPUh() size_t OutputMemorySize() const {return(fOutput->MemorySize()); }
        GPUhd() AliHLTTPCCARow* SliceDataRows() {return(fData.Rows()); }
 
        GPUhd() uint3* RowStartHitCountOffset() const {return(fRowStartHitCountOffset);}
@@ -310,7 +308,7 @@ class AliHLTTPCCATracker
 
     // output
 
-    AliHLTTPCCASliceOutput *fOutput;
+    AliHLTTPCCASliceOutput **fOutput;
 
     // disable copy
     AliHLTTPCCATracker( const AliHLTTPCCATracker& );

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx
index fe9ec4b337168d9c9f7271b1d4722e8690d8e98b..297e24b8283f33f8ea442b0ecd2c1d1fd6ea2394 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerComponent.cxx
@@ -111,7 +111,7 @@ AliHLTTPCCATrackerComponent::~AliHLTTPCCATrackerComponent()
 {
   // see header file for class documentation
   delete fTracker;
-  delete fOutput;
+  if (fOutput) free(fOutput);
 }
 
 //
@@ -329,7 +329,6 @@ int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
 
 
   fTracker = new AliHLTTPCCATrackerFramework();
-  fOutput = new AliHLTTPCCASliceOutput();
 
   TString arguments = "";
   for ( int i = 0; i < argc; i++ ) {
@@ -346,7 +345,7 @@ int AliHLTTPCCATrackerComponent::DoDeinit()
   // see header file for class documentation
   delete fTracker;
   fTracker = NULL;
-  delete fOutput;
+  free(fOutput);
   fOutput = NULL;
   return 0;
 }
@@ -467,7 +466,6 @@ int AliHLTTPCCATrackerComponent::DoEvent
 
   {
     if ( !fTracker ) fTracker = new AliHLTTPCCATrackerFramework;
-       if ( !fOutput ) fOutput = new AliHLTTPCCASliceOutput;
     int iSec = slice;
     float inRmin = 83.65;
     //    float inRmax = 133.3;
@@ -583,7 +581,7 @@ int AliHLTTPCCATrackerComponent::DoEvent
 
   TStopwatch timerReco;
 
-  fTracker->ProcessSlices(slice, 1, &clusterData, fOutput);
+  fTracker->ProcessSlices(slice, 1, &clusterData, &fOutput);
 
   timerReco.Stop();
 

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerFramework.cxx b/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerFramework.cxx
index ed9040e2e4e542605d72b96bbec7f963838688ce..05e260215460f213c14682c7f9acd4a6868718a3 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerFramework.cxx
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerFramework.cxx
@@ -72,7 +72,7 @@ int AliHLTTPCCATrackerFramework::SetGPUTracker(bool enable)
        return(0);
 }
 
-int AliHLTTPCCATrackerFramework::ProcessSlices(int firstSlice, int sliceCount, AliHLTTPCCAClusterData* pClusterData, AliHLTTPCCASliceOutput* pOutput)
+int AliHLTTPCCATrackerFramework::ProcessSlices(int firstSlice, int sliceCount, AliHLTTPCCAClusterData* pClusterData, AliHLTTPCCASliceOutput** pOutput)
 {
        //Process sliceCount slices starting from firstslice, in is pClusterData array, out pOutput array
        if (fUseGPUTracker)

diff --git a/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerFramework.h b/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerFramework.h
index 9cace75d95390ae7a9021a6d85c210cb7a11ec51..6b26542c0f26737acae4cd0a7d9f47dcf6551867 100644 (file)
--- a/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerFramework.h
+++ b/HLT/TPCLib/tracking-ca/AliHLTTPCCATrackerFramework.h
@@ -24,7 +24,9 @@ public:
        AliHLTTPCCATrackerFramework() :
          fGPUTrackerAvailable(false), fUseGPUTracker(false), fGPUDebugLevel(0), fGPUSliceCount(0), fGPUTracker(), fCPUSliceCount(fgkNSlices)
          {
-           fGPUTrackerAvailable = fUseGPUTracker = fGPUSliceCount = (fGPUTracker.InitGPU(1, -1) == 0);
+                 fGPUTrackerAvailable= (fGPUTracker.InitGPU(1, -1) == 0);
+                 fGPUSliceCount = fGPUTrackerAvailable;
+                 fUseGPUTracker = fGPUTrackerAvailable;
          }
     ~AliHLTTPCCATrackerFramework()
          {}
@@ -37,7 +39,7 @@ public:
 
        int InitializeSliceParam(int iSlice, AliHLTTPCCAParam &param);
 
-       int ProcessSlices(int firstSlice, int sliceCount, AliHLTTPCCAClusterData* pClusterData, AliHLTTPCCASliceOutput* pOutput);
+       int ProcessSlices(int firstSlice, int sliceCount, AliHLTTPCCAClusterData* pClusterData, AliHLTTPCCASliceOutput** pOutput);
        unsigned long long int* PerfTimer(int GPU, int iSlice, int iTimer);
 
        int MaxSliceCount() const { return(fUseGPUTracker ? fGPUSliceCount : fCPUSliceCount); }
@@ -63,4 +65,4 @@ private:
 
 };
 
-#endif
+#endif
\ No newline at end of file