#include "AliHLTTPCCADef.h"
#include "AliHLTTPCCAGPUConfig.h"
#include "AliHLTTPCCAParam.h"
-#include "AliHLTTPCCARow.h"
-#include "AliHLTTPCCAHit.h"
#include <iostream>
-#include "AliHLTArray.h"
#include "AliHLTTPCCAHitId.h"
#include "AliHLTTPCCASliceData.h"
-#include "AliHLTTPCCATracklet.h"
-#include "AliHLTTPCCAOutTrack.h"
#include "AliHLTTPCCASliceOutput.h"
#include "AliHLTTPCCATrackletConstructor.h"
+#include "AliHLTTPCCATracklet.h"
class AliHLTTPCCATrack;
class AliHLTTPCCATrackParam;
class AliHLTTPCCAClusterData;
+class AliHLTTPCCARow;
+
+#include "TStopwatch.h"
/**
* @class AliHLTTPCCATracker
{
public:
- AliHLTTPCCATracker()
- : fParam(),
- fClusterData( 0 ),
- fData(),
- fIsGPUTracker( false ),
- fGPUDebugLevel( 0 ),
- fGPUDebugOut( 0 ),
- fRowStartHitCountOffset( NULL ),
- fTrackletTmpStartHits( NULL ),
- fGPUTrackletTemp( NULL ),
- fRowBlockTracklets( NULL ),
- fRowBlockPos( NULL ),
- fBlockStartingTracklet( NULL ),
- fGPUParametersConst(),
- fCommonMem( 0 ),
- fHitMemory( 0 ),
- fHitMemorySize( 0 ),
- fTrackletMemory( 0 ),
- fTrackletMemorySize( 0 ),
- fTrackMemory( 0 ),
- fTrackMemorySize( 0 ),
- fTrackletStartHits( 0 ),
- fTracklets( 0 ),
- fTrackletRowHits( NULL ),
- fTracks( 0 ),
- fTrackHits( 0 ),
- fOutput( 0 )
- {
- // constructor
- }
- ~AliHLTTPCCATracker();
-
- struct StructGPUParameters
- {
- int fScheduleFirstDynamicTracklet; //Last Tracklet with fixed position in sheduling
- int fGPUError; //Signalizes error on GPU during GPU Reconstruction, kind of return value
- };
-
- struct StructGPUParametersConst
- {
- int fGPUFixedBlockCount; //Count of blocks that is used for this tracker in fixed schedule situations
- int fGPUiSlice;
- int fGPUnSlices;
- };
-
- struct commonMemoryStruct
- {
- int fNTracklets; // number of tracklets
- int fNTracks; // number of reconstructed tracks
- int fNTrackHits; // number of track hits
- StructGPUParameters fGPUParameters;
- };
-
- void Initialize( const AliHLTTPCCAParam ¶m );
-
- void StartEvent();
-
- int CheckEmptySlice();
- void WriteOutput();
-
-#if !defined(HLTCA_GPUCODE)
- void Reconstruct();
+ AliHLTTPCCATracker()
+ :
+#ifdef HLTCA_STANDALONE
+ fStageAtSync( NULL ),
+ fLinkTmpMemory( NULL ),
#endif
-
- //Make Reconstruction steps directly callable (Used for GPU debugging)
- void RunNeighboursFinder();
- void RunNeighboursCleaner();
- void RunStartHitsFinder();
- void RunTrackletConstructor();
- void RunTrackletSelector();
-
- //GPU Tracker Interface
- void SetGPUTracker();
- void SetGPUDebugLevel(int Level, std::ostream *NewDebugOut = NULL) {fGPUDebugLevel = Level;if (NewDebugOut) fGPUDebugOut = NewDebugOut;}
-
- char* SetGPUTrackerCommonMemory(char* pGPUMemory);
- char* SetGPUTrackerHitsMemory(char* pGPUMemory, int MaxNHits);
- char* SetGPUTrackerTrackletsMemory(char* pGPUMemory, int MaxNTracklets);
- char* SetGPUTrackerTracksMemory(char* pGPUMemory, int MaxNTracks, int MaxNHits );
-
- //Debugging Stuff
- void DumpSliceData(std::ostream &out); //Dump Input Slice Data
- void DumpLinks(std::ostream &out); //Dump all links to file (for comparison after NeighboursFinder/Cleaner)
- void DumpStartHits(std::ostream &out); //Same for Start Hits
- void DumpHitWeights(std::ostream &out); //....
- void DumpTrackHits(std::ostream &out); //Same for Track Hits
- void DumpTrackletHits(std::ostream &out); //Same for Track Hits
-
- GPUd() void GetErrors2( int iRow, const AliHLTTPCCATrackParam &t, float &Err2Y, float &Err2Z ) const;
- GPUd() void GetErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const;
-
- void FitTrack( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;
- void FitTrackFull( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;
-
- void SetupCommonMemory();
- void SetPointersHits( int MaxNHits );
- void SetPointersTracklets ( int MaxNTracklets );
- void SetPointersTracks( int MaxNTracks, int MaxNHits );
-
- void SetOutput( AliHLTTPCCASliceOutput** out ) { fOutput = out; }
-
- void ReadEvent( AliHLTTPCCAClusterData *clusterData );
-
+ fParam(),
+ fOutputControl(),
+ fClusterData( 0 ),
+ fData(),
+ fIsGPUTracker( false ),
+ fGPUDebugLevel( 0 ),
+ fGPUDebugOut( 0 ),
+ fRowStartHitCountOffset( NULL ),
+ fTrackletTmpStartHits( NULL ),
+ fGPUTrackletTemp( NULL ),
+ fRowBlockTracklets( NULL ),
+ fRowBlockPos( NULL ),
+ fBlockStartingTracklet( NULL ),
+ fGPUParametersConst(),
+ fCommonMem( 0 ),
+ fHitMemory( 0 ),
+ fHitMemorySize( 0 ),
+ fTrackletMemory( 0 ),
+ fTrackletMemorySize( 0 ),
+ fTrackMemory( 0 ),
+ fTrackMemorySize( 0 ),
+ fTrackletStartHits( 0 ),
+ fTracklets( 0 ),
+ fTrackletRowHits( NULL ),
+ fTracks( 0 ),
+ fTrackHits( 0 ),
+ fOutput( 0 )
+ {
+ // constructor
+ for( int i=0; i<10; i++ ) fTimers[i] = 0;
+ for( int i=0; i<16; i++ ) fPerfTimers[i] = 0;
+ }
+ ~AliHLTTPCCATracker();
+
+ struct StructGPUParameters
+ {
+ StructGPUParameters() : fNextTracklet(0), fScheduleFirstDynamicTracklet( 0 ), fGPUError( 0 ) {}
+ int fNextTracklet; //Next Tracklet to process
+ int fScheduleFirstDynamicTracklet; //Last Tracklet with fixed position in sheduling
+ int fGPUError; //Signalizes error on GPU during GPU Reconstruction, kind of return value
+ };
+
+ struct StructGPUParametersConst
+ {
+ StructGPUParametersConst() : fGPUFixedBlockCount( 0 ), fGPUiSlice( 0 ), fGPUnSlices( 0 ) {}
+ int fGPUFixedBlockCount; //Count of blocks that is used for this tracker in fixed schedule situations
+ int fGPUiSlice; // slice number processed by running GPU MP
+ int fGPUnSlices; // n of slices to be processed in parallel
+ };
+
+ struct commonMemoryStruct
+ {
+ commonMemoryStruct() : fNTracklets( 0 ), fNTracks( 0 ), fNLocalTracks( 0 ), fNTrackHits( 0 ), fNLocalTrackHits( 0 ), fGPUParameters() {}
+ int fNTracklets; // number of tracklets
+ int fNTracks; // number of reconstructed tracks
+ int fNLocalTracks; //number of reconstructed tracks before global tracking
+ int fNTrackHits; // number of track hits
+ int fNLocalTrackHits; //see above
+ StructGPUParameters fGPUParameters; // GPU parameters
+ };
+
+ void Initialize( const AliHLTTPCCAParam ¶m );
+
+ void StartEvent();
+
+ int CheckEmptySlice() const;
+ void WriteOutputPrepare();
+ void WriteOutput();
+
+#if !defined(HLTCA_GPUCODE)
+ void Reconstruct();
+ void ReconstructOutput();
+#endif //!HLTCA_GPUCODE
+ void DoTracking();
+
+ //Make Reconstruction steps directly callable (Used for GPU debugging)
+ void RunNeighboursFinder();
+ void RunNeighboursCleaner();
+ void RunStartHitsFinder();
+ void RunTrackletConstructor();
+ void RunTrackletSelector();
+
+ //GPU Tracker Interface
+ void SetGPUTracker();
+ void SetGPUDebugLevel(int Level, std::ostream *NewDebugOut = NULL) {fGPUDebugLevel = Level;if (NewDebugOut) fGPUDebugOut = NewDebugOut;}
+
+ char* SetGPUTrackerCommonMemory(char* const pGPUMemory);
+ char* SetGPUTrackerHitsMemory(char* pGPUMemory, int MaxNHits);
+ char* SetGPUTrackerTrackletsMemory(char* pGPUMemory, int MaxNTracklets, int constructorBlockCount);
+ char* SetGPUTrackerTracksMemory(char* pGPUMemory, int MaxNTracks, int MaxNHits );
+
+ //Debugging Stuff
+ void DumpSliceData(std::ostream &out); //Dump Input Slice Data
+ void DumpLinks(std::ostream &out); //Dump all links to file (for comparison after NeighboursFinder/Cleaner)
+ void DumpStartHits(std::ostream &out); //Same for Start Hits
+ void DumpHitWeights(std::ostream &out); //....
+ void DumpTrackHits(std::ostream &out); //Same for Track Hits
+ void DumpTrackletHits(std::ostream &out); //Same for Track Hits
+ void DumpOutput(FILE* out); //Similar for output
+
+ GPUd() void GetErrors2( int iRow, const AliHLTTPCCATrackParam &t, float &Err2Y, float &Err2Z ) const;
+ GPUd() void GetErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const;
+
+ void FitTrack( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;
+ void FitTrackFull( const AliHLTTPCCATrack &track, float *t0 = 0 ) const;
+
+ void SetupCommonMemory();
+ void SetPointersHits( int MaxNHits );
+ void SetPointersTracklets ( int MaxNTracklets );
+ void SetPointersTracks( int MaxNTracks, int MaxNHits );
+ size_t SetPointersSliceData(const AliHLTTPCCAClusterData *data, bool allocate = false) { return(fData.SetPointers(data, allocate)); }
+
+ void SetOutput( AliHLTTPCCASliceOutput** out ) { fOutput = out; }
+
+ void ReadEvent( AliHLTTPCCAClusterData *clusterData );
+
#if !defined(HLTCA_GPUCODE)
- GPUh() void WriteEvent( std::ostream &out );
- GPUh() void WriteTracks( std::ostream &out ) ;
- GPUh() void ReadTracks( std::istream &in );
+ GPUh() void WriteEvent( std::ostream &out );
+ GPUh() void WriteTracks( std::ostream &out ) ;
+ GPUh() void ReadTracks( std::istream &in );
+#endif //!HLTCA_GPUCODE
+
+ GPUhd() const AliHLTTPCCAParam &Param() const { return fParam; }
+ GPUhd() const AliHLTTPCCAParam *pParam() const { return &fParam; }
+ GPUhd() void SetParam( const AliHLTTPCCAParam &v ) { fParam = v; }
+
+ GPUhd() const AliHLTTPCCASliceOutput::outputControlStruct* OutputControl() const { return fOutputControl; }
+ GPUh() void SetOutputControl( AliHLTTPCCASliceOutput::outputControlStruct* const val) { fOutputControl = val; }
+
+ GPUhd() AliHLTTPCCAClusterData *ClusterData() const { return fClusterData; }
+ GPUhd() const AliHLTTPCCASliceData &Data() const { return fData; }
+
+ GPUh() void ClearSliceDataHitWeights() {fData.ClearHitWeights();}
+
+ GPUhd() const AliHLTTPCCARow &Row( int rowIndex ) const { return fData.Row( rowIndex ); }
+ GPUh() const AliHLTTPCCARow &Row( const AliHLTTPCCAHitId &HitId ) const { return fData.Row( HitId.RowIndex() ); }
+
+ GPUhd() double Timer( int i ) const { return fTimers[i]; }
+ GPUhd() void SetTimer( int i, double v ) { fTimers[i] = v; }
+
+ GPUhd() int NHitsTotal() const { return fData.NumberOfHits(); }
+
+ GPUd() void SetHitLinkUpData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkUpData( row, hitIndex, v ); }
+ GPUd() void SetHitLinkDownData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkDownData( row, hitIndex, v ); }
+ GPUd() short HitLinkUpData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkUpData( row, hitIndex ); }
+ GPUd() short HitLinkDownData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkDownData( row, hitIndex ); }
+
+ GPUd() const ushort2 *HitData( const AliHLTTPCCARow &row ) const { return fData.HitData(row); }
+ GPUd() const short_v *HitLinkUpData ( const AliHLTTPCCARow &row ) const { return fData.HitLinkUpData(row); }
+ GPUd() const short_v *HitLinkDownData( const AliHLTTPCCARow &row ) const { return fData.HitLinkDownData(row); }
+ GPUd() const ushort_v *FirstHitInBin( const AliHLTTPCCARow &row ) const { return fData.FirstHitInBin(row); }
+
+ GPUd() int FirstHitInBin( const AliHLTTPCCARow &row, int binIndex ) const { return fData.FirstHitInBin( row, binIndex ); }
+
+ GPUd() unsigned short HitDataY( const AliHLTTPCCARow &row, int hitIndex ) const {
+ return fData.HitDataY( row, hitIndex );
+ }
+ GPUd() unsigned short HitDataZ( const AliHLTTPCCARow &row, int hitIndex ) const {
+ return fData.HitDataZ( row, hitIndex );
+ }
+ GPUd() ushort2 HitData( const AliHLTTPCCARow &row, int hitIndex ) const {
+ return fData.HitData( row, hitIndex );
+ }
+
+ GPUhd() int HitInputID( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.ClusterDataIndex( row, hitIndex ); }
+
+ /**
+ * The hit weight is used to determine whether a hit belongs to a certain tracklet or another one
+ * competing for the same hit. The tracklet that has a higher weight wins. Comparison is done
+ * using the the number of hits in the tracklet (the more hits it has the more it keeps). If
+ * tracklets have the same number of hits then it doesn't matter who gets it, but it should be
+ * only one. So a unique number (row index is good) is added in the least significant part of
+ * the weight
+ */
+ GPUd() static int CalculateHitWeight( int NHits, float chi2, int ) {
+ const float chi2_suppress = 6.f;
+ float weight = (((float) NHits * (chi2_suppress - chi2 / 500.f)) * (1e9 / chi2_suppress / 160.));
+ if (weight < 0 || weight > 2e9) weight = 0;
+ return ( (int) weight );
+ //return( (NHits << 16) + num);
+ }
+ GPUd() void MaximizeHitWeight( const AliHLTTPCCARow &row, int hitIndex, int weight ) {
+ fData.MaximizeHitWeight( row, hitIndex, weight );
+ }
+ GPUd() void SetHitWeight( const AliHLTTPCCARow &row, int hitIndex, int weight ) {
+ fData.SetHitWeight( row, hitIndex, weight );
+ }
+ GPUd() int HitWeight( const AliHLTTPCCARow &row, int hitIndex ) const {
+ return fData.HitWeight( row, hitIndex );
+ }
+
+ GPUhd() int *NTracklets() const { return &fCommonMem->fNTracklets; }
+
+ GPUhd() const AliHLTTPCCAHitId &TrackletStartHit( int i ) const { return fTrackletStartHits[i]; }
+ GPUhd() AliHLTTPCCAHitId *TrackletStartHits() const { return fTrackletStartHits; }
+ GPUhd() AliHLTTPCCAHitId *TrackletTmpStartHits() const { return fTrackletTmpStartHits; }
+ GPUhd() const AliHLTTPCCATracklet &Tracklet( int i ) const { return fTracklets[i]; }
+ GPUhd() AliHLTTPCCATracklet *Tracklets() const { return fTracklets;}
+ GPUhd() int* TrackletRowHits() const { return fTrackletRowHits; }
+
+ GPUhd() int *NTracks() const { return &fCommonMem->fNTracks; }
+ GPUhd() AliHLTTPCCATrack *Tracks() const { return fTracks; }
+ GPUhd() int *NTrackHits() const { return &fCommonMem->fNTrackHits; }
+ GPUhd() AliHLTTPCCAHitId *TrackHits() const { return fTrackHits; }
+
+ GPUhd() AliHLTTPCCASliceOutput** Output() const { return fOutput; }
+
+ GPUh() commonMemoryStruct *CommonMemory() const {return(fCommonMem); }
+ GPUh() static size_t CommonMemorySize() { return(sizeof(AliHLTTPCCATracker::commonMemoryStruct)); }
+ GPUh() char* HitMemory() const {return(fHitMemory); }
+ GPUh() size_t HitMemorySize() const {return(fHitMemorySize); }
+ GPUh() char* TrackletMemory() {return(fTrackletMemory); }
+ GPUh() size_t TrackletMemorySize() const {return(fTrackletMemorySize); }
+ GPUh() char* TrackMemory() {return(fTrackMemory); }
+ GPUh() size_t TrackMemorySize() const {return(fTrackMemorySize); }
+ GPUhd() AliHLTTPCCARow* SliceDataRows() const {return(fData.Rows()); }
+
+ GPUhd() uint3* RowStartHitCountOffset() const {return(fRowStartHitCountOffset);}
+ GPUhd() AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory* GPUTrackletTemp() const {return(fGPUTrackletTemp);}
+ GPUhd() int* RowBlockTracklets(int reverse, int iRowBlock) const {return(&fRowBlockTracklets[(reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock) * fCommonMem->fNTracklets]);}
+ GPUhd() int* RowBlockTracklets() const {return(fRowBlockTracklets);}
+ GPUhd() int4* RowBlockPos(int reverse, int iRowBlock) const {return(&fRowBlockPos[reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock]);}
+ GPUhd() int4* RowBlockPos() const {return(fRowBlockPos);}
+ GPUhd() uint2* BlockStartingTracklet() const {return(fBlockStartingTracklet);}
+ GPUhd() StructGPUParameters* GPUParameters() const {return(&fCommonMem->fGPUParameters);}
+ GPUhd() StructGPUParametersConst* GPUParametersConst() {return(&fGPUParametersConst);}
+ GPUhd() void SetGPUTextureBase(char* val) { fData.SetGPUTextureBase(val); }
+ GPUh() void SetGPUSliceDataMemory(void* const pSliceMemory, void* const pRowMemory) { fData.SetGPUSliceDataMemory(pSliceMemory, pRowMemory); }
+
+ GPUh() unsigned long long int* PerfTimer(unsigned int i) {return &fPerfTimers[i]; }
+
+#ifdef HLTCA_STANDALONE
+ GPUhd() char* StageAtSync() {return(fStageAtSync);}
+ GPUh() const char* LinkTmpMemory() const {return(fLinkTmpMemory);}
#endif
- GPUhd() const AliHLTTPCCAParam &Param() const { return fParam; }
- GPUhd() void SetParam( const AliHLTTPCCAParam &v ) { fParam = v; }
-
- GPUhd() AliHLTTPCCAClusterData *ClusterData() const { return fClusterData; }
- GPUhd() const AliHLTTPCCASliceData &Data() const { return fData; }
- GPUhd() AliHLTTPCCASliceData *pData() {return &fData; }
-
- GPUh() void ClearSliceDataHitWeights() {fData.ClearHitWeights();}
-
- GPUhd() const AliHLTTPCCARow &Row( int rowIndex ) const { return fData.Row( rowIndex ); }
- GPUh() const AliHLTTPCCARow &Row( const AliHLTTPCCAHitId &HitId ) const { return fData.Row( HitId.RowIndex() ); }
-
- GPUhd() double Timer( int i ) const { return fTimers[i]; }
- GPUhd() void SetTimer( int i, double v ) { fTimers[i] = v; }
-
- GPUhd() int NHitsTotal() const { return fData.NumberOfHits(); }
-
- GPUd() void SetHitLinkUpData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkUpData( row, hitIndex, v ); }
- GPUd() void SetHitLinkDownData( const AliHLTTPCCARow &row, int hitIndex, short v ) { fData.SetHitLinkDownData( row, hitIndex, v ); }
- GPUd() short HitLinkUpData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkUpData( row, hitIndex ); }
- GPUd() short HitLinkDownData( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.HitLinkDownData( row, hitIndex ); }
-
- GPUd() const ushort2 *HitData( const AliHLTTPCCARow &row ) const { return fData.HitData(row); }
- GPUd() const short_v *HitLinkUpData ( const AliHLTTPCCARow &row ) const { return fData.HitLinkUpData(row); }
- GPUd() const short_v *HitLinkDownData( const AliHLTTPCCARow &row ) const { return fData.HitLinkDownData(row); }
- GPUd() const ushort_v *FirstHitInBin( const AliHLTTPCCARow &row ) const { return fData.FirstHitInBin(row); }
-
- GPUd() int FirstHitInBin( const AliHLTTPCCARow &row, int binIndex ) const { return fData.FirstHitInBin( row, binIndex ); }
-
- GPUd() unsigned short HitDataY( const AliHLTTPCCARow &row, int hitIndex ) const {
- return fData.HitDataY( row, hitIndex );
- }
- GPUd() unsigned short HitDataZ( const AliHLTTPCCARow &row, int hitIndex ) const {
- return fData.HitDataZ( row, hitIndex );
- }
- GPUd() ushort2 HitData( const AliHLTTPCCARow &row, int hitIndex ) const {
- return fData.HitData( row, hitIndex );
- }
-
- GPUhd() int HitInputID( const AliHLTTPCCARow &row, int hitIndex ) const { return fData.ClusterDataIndex( row, hitIndex ); }
-
- /**
- * The hit weight is used to determine whether a hit belongs to a certain tracklet or another one
- * competing for the same hit. The tracklet that has a higher weight wins. Comparison is done
- * using the the number of hits in the tracklet (the more hits it has the more it keeps). If
- * tracklets have the same number of hits then it doesn't matter who gets it, but it should be
- * only one. So a unique number (row index is good) is added in the least significant part of
- * the weight
- */
- static int CalculateHitWeight( int NHits, int unique ) {
- return ( NHits << 16 ) + unique;
- }
- GPUd() void MaximizeHitWeight( const AliHLTTPCCARow &row, int hitIndex, int weight ) {
- fData.MaximizeHitWeight( row, hitIndex, weight );
- }
- GPUd() int HitWeight( const AliHLTTPCCARow &row, int hitIndex ) const {
- return fData.HitWeight( row, hitIndex );
- }
-
- GPUhd() int NTracklets() const { return fCommonMem->fNTracklets; }
- GPUhd() int *NTracklets() { return &fCommonMem->fNTracklets; }
-
- GPUhd() const AliHLTTPCCAHitId &TrackletStartHit( int i ) const { return fTrackletStartHits[i]; }
- GPUhd() AliHLTTPCCAHitId *TrackletStartHits() const { return fTrackletStartHits; }
- GPUhd() AliHLTTPCCAHitId *TrackletTmpStartHits() const { return fTrackletTmpStartHits; }
- GPUhd() const AliHLTTPCCATracklet &Tracklet( int i ) const { return fTracklets[i]; }
- GPUhd() AliHLTTPCCATracklet *Tracklets() const { return fTracklets;}
- GPUhd() int* TrackletRowHits() { return fTrackletRowHits; }
-
- GPUhd() int *NTracks() const { return &fCommonMem->fNTracks; }
- GPUhd() AliHLTTPCCATrack *Tracks() const { return fTracks; }
- GPUhd() int *NTrackHits() const { return &fCommonMem->fNTrackHits; }
- GPUhd() AliHLTTPCCAHitId *TrackHits() const { return fTrackHits; }
-
- GPUhd() AliHLTTPCCASliceOutput** Output() const { return fOutput; }
-
- GPUh() commonMemoryStruct *CommonMemory() {return(fCommonMem); }
- static GPUh() size_t CommonMemorySize() { return(sizeof(AliHLTTPCCATracker::commonMemoryStruct)); }
- GPUh() char* &HitMemory() {return(fHitMemory); }
- GPUh() size_t HitMemorySize() const {return(fHitMemorySize); }
- GPUh() char* &TrackletMemory() {return(fTrackletMemory); }
- GPUh() size_t TrackletMemorySize() const {return(fTrackletMemorySize); }
- GPUh() char* &TrackMemory() {return(fTrackMemory); }
- GPUh() size_t TrackMemorySize() const {return(fTrackMemorySize); }
- GPUhd() AliHLTTPCCARow* SliceDataRows() {return(fData.Rows()); }
-
- GPUhd() uint3* RowStartHitCountOffset() const {return(fRowStartHitCountOffset);}
- GPUhd() AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory* GPUTrackletTemp() const {return(fGPUTrackletTemp);}
- GPUhd() int* RowBlockTracklets(int reverse, int iRowBlock) const {return(&fRowBlockTracklets[(reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock) * fCommonMem->fNTracklets]);}
- GPUhd() int* RowBlockTracklets() const {return(fRowBlockTracklets);}
- GPUhd() int4* RowBlockPos(int reverse, int iRowBlock) const {return(&fRowBlockPos[reverse * ((fParam.NRows() / HLTCA_GPU_SCHED_ROW_STEP) + 1) + iRowBlock]);}
- GPUhd() int4* RowBlockPos() const {return(fRowBlockPos);}
- GPUhd() uint2* BlockStartingTracklet() const {return(fBlockStartingTracklet);}
- GPUhd() StructGPUParameters* GPUParameters() const {return(&fCommonMem->fGPUParameters);}
- GPUhd() StructGPUParametersConst* GPUParametersConst() {return(&fGPUParametersConst);}
-
- GPUh() unsigned long long int* PerfTimer(unsigned int i) {return &fPerfTimers[i]; }
-
-#ifdef HLTCA_GPU_TRACKLET_CONSTRUCTOR_DO_PROFILE
- char* fStageAtSync; //Pointer to array storing current stage for every thread at every sync point
- int* fThreadTimes;
+#ifdef HLTCA_STANDALONE
+ static inline void StandaloneQueryTime(unsigned long long int *i);
+ static inline void StandaloneQueryFreq(unsigned long long int *i);
+#endif //HLTCA_STANDALONE
+ void StandalonePerfTime(int i);
+
+ struct trackSortData
+ {
+ int fTtrack; //Track ID
+ float fSortVal; //Value to sort for
+ };
+ GPUh() static int SortComparison(const void* a, const void* b);
+
+ void PerformGlobalTracking(AliHLTTPCCATracker& sliceLeft, AliHLTTPCCATracker& sliceRight, int MaxTracks);
+
+private:
+ GPUh() int PerformGlobalTrackingRun(AliHLTTPCCATracker& sliceNeighbour, int iTrack, int rowIndex, float angle, int direction);
+
+ //Temporary Variables for Standalone measurements
+#ifdef HLTCA_STANDALONE
+public:
+ char* fStageAtSync; //Pointer to array storing current stage for every thread at every sync point
+ char *fLinkTmpMemory; //tmp memory for hits after neighbours finder
+private:
#endif
-
- private:
- AliHLTTPCCAParam fParam; // parameters
- double fTimers[10];
- unsigned long long int fPerfTimers[16]; // running CPU time for different parts of the algorithm
- void StandalonePerfTime(int i);
-
- /** A pointer to the ClusterData object that the SliceData was created from. This can be used to
- * merge clusters from inside the SliceTracker code and recreate the SliceData. */
- AliHLTTPCCAClusterData *fClusterData; // ^
- AliHLTTPCCASliceData fData; // The SliceData object. It is used to encapsulate the storage in memory from the access
-
- bool fIsGPUTracker; // is it GPU tracker object
- int fGPUDebugLevel; // debug level
- std::ostream *fGPUDebugOut; // debug stream
-
- //GPU Temp Arrays
- uint3* fRowStartHitCountOffset; //Offset, length and new offset of start hits in row
- AliHLTTPCCAHitId *fTrackletTmpStartHits; //Unsorted start hits
- AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory *fGPUTrackletTemp; //Temp Memory for GPU Tracklet Constructor
- int* fRowBlockTracklets; //Reference which tracklet is processed in which rowblock next
- int4* fRowBlockPos; //x is last tracklet to be processed, y is last tracklet already processed, z is last tracklet to be processed in next iteration, w is initial x value to check if tracklet must be initialized
- uint2* fBlockStartingTracklet;
-
- StructGPUParametersConst fGPUParametersConst;
-
- // event
-
- commonMemoryStruct *fCommonMem; // common event memory
-
- char *fHitMemory; // event memory for hits
- size_t fHitMemorySize; // size of the event memory [bytes]
-
- char *fTrackletMemory;
- size_t fTrackletMemorySize;
-
- char *fTrackMemory; // event memory for tracks
- size_t fTrackMemorySize; // size of the event memory [bytes]
-
- AliHLTTPCCAHitId *fTrackletStartHits; // start hits for the tracklets
- AliHLTTPCCATracklet *fTracklets; // tracklets
- int *fTrackletRowHits;
-
- //
- AliHLTTPCCATrack *fTracks; // reconstructed tracks
- AliHLTTPCCAHitId *fTrackHits; // array of track hit numbers
-
- // output
-
- AliHLTTPCCASliceOutput **fOutput;
-
- // disable copy
- AliHLTTPCCATracker( const AliHLTTPCCATracker& );
- AliHLTTPCCATracker &operator=( const AliHLTTPCCATracker& );
-
- static int starthitSortComparison(const void*a, const void* b);
+
+ AliHLTTPCCAParam fParam; // parameters
+ double fTimers[10]; // timers
+ unsigned long long int fPerfTimers[16]; // running CPU time for different parts of the algorithm
+
+ AliHLTTPCCASliceOutput::outputControlStruct* fOutputControl; // output control
+
+ /** A pointer to the ClusterData object that the SliceData was created from. This can be used to
+ * merge clusters from inside the SliceTracker code and recreate the SliceData. */
+ AliHLTTPCCAClusterData *fClusterData; // ^
+ AliHLTTPCCASliceData fData; // The SliceData object. It is used to encapsulate the storage in memory from the access
+
+ bool fIsGPUTracker; // is it GPU tracker object
+ int fGPUDebugLevel; // debug level
+ std::ostream *fGPUDebugOut; // debug stream
+
+ //GPU Temp Arrays
+ uint3* fRowStartHitCountOffset; //Offset, length and new offset of start hits in row
+ AliHLTTPCCAHitId *fTrackletTmpStartHits; //Unsorted start hits
+ AliHLTTPCCATrackletConstructor::AliHLTTPCCAGPUTempMemory *fGPUTrackletTemp; //Temp Memory for GPU Tracklet Constructor
+ int* fRowBlockTracklets; //Reference which tracklet is processed in which rowblock next
+ int4* fRowBlockPos; //x is last tracklet to be processed, y is last tracklet already processed, z is last tracklet to be processed in next iteration, w is initial x value to check if tracklet must be initialized
+ uint2* fBlockStartingTracklet; // First Tracklet that is to be processed by current GPU MP
+
+ StructGPUParametersConst fGPUParametersConst; // Parameters for GPU if this is a GPU tracker
+
+ // event
+
+ commonMemoryStruct *fCommonMem; // common event memory
+
+ char *fHitMemory; // event memory for hits
+ size_t fHitMemorySize; // size of the event memory for hits [bytes]
+
+ char *fTrackletMemory; //event memory for tracklets
+ size_t fTrackletMemorySize; //size of the event memory for tracklets
+
+ char *fTrackMemory; // event memory for tracks
+ size_t fTrackMemorySize; // size of the event memory for tracks [bytes]
+
+ AliHLTTPCCAHitId *fTrackletStartHits; // start hits for the tracklets
+ AliHLTTPCCATracklet *fTracklets; // tracklets
+ int *fTrackletRowHits; //Hits for each Tracklet in each row
+
+ //
+ AliHLTTPCCATrack *fTracks; // reconstructed tracks
+ AliHLTTPCCAHitId *fTrackHits; // array of track hit numbers
+
+ // output
+
+ AliHLTTPCCASliceOutput **fOutput; //address of pointer pointing to SliceOutput Object
+
+ // disable copy
+ AliHLTTPCCATracker( const AliHLTTPCCATracker& );
+ AliHLTTPCCATracker &operator=( const AliHLTTPCCATracker& );
+
+ static int StarthitSortComparison(const void*a, const void* b);
};
+#ifdef HLTCA_STANDALONE
+ void AliHLTTPCCATracker::StandaloneQueryTime(unsigned long long int *i)
+ {
+ #ifdef R__WIN32
+ QueryPerformanceCounter((LARGE_INTEGER*) i);
+ #else
+ timespec t;
+ clock_gettime(CLOCK_REALTIME, &t);
+ *i = (unsigned long long int) t.tv_sec * (unsigned long long int) 1000000000 + (unsigned long long int) t.tv_nsec;
+ #endif //R__WIN32
+ }
+
+ void AliHLTTPCCATracker::StandaloneQueryFreq(unsigned long long int *i)
+ {
+ #ifdef R__WIN32
+ QueryPerformanceFrequency((LARGE_INTEGER*) i);
+ #else
+ *i = 1000000000;
+ #endif //R__WIN32
+ }
+#endif //HLTCA_STANDALONE
-#endif
+#endif //ALIHLTTPCCATRACKER_H