// @(#) $Id: AliHLTTPCCATrackletSelector.cxx 27042 2008-07-02 12:06:02Z richterm $
-//***************************************************************************
-// This file is property of and copyright by the ALICE HLT Project *
+// **************************************************************************
+// This file is property of and copyright by the ALICE HLT Project *
// ALICE Experiment at CERN, All rights reserved. *
// *
// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
// appear in the supporting documentation. The authors make no claims *
// about the suitability of this software for any purpose. It is *
// provided "as is" without express or implied warranty. *
+// *
//***************************************************************************
+
#include "AliHLTTPCCATrackletSelector.h"
#include "AliHLTTPCCATrack.h"
#include "AliHLTTPCCATracker.h"
#include "AliHLTTPCCATrackParam.h"
+#include "AliHLTTPCCATracklet.h"
#include "AliHLTTPCCAMath.h"
-GPUd() void AliHLTTPCCATrackletSelector::Thread
-( Int_t nBlocks, Int_t nThreads, Int_t iBlock, Int_t iThread, Int_t iSync,
- AliHLTTPCCASharedMemory &s, AliHLTTPCCATracker &tracker )
+GPUdi() void AliHLTTPCCATrackletSelector::Thread
+( int nBlocks, int nThreads, int iBlock, int iThread, int iSync,
+ GPUsharedref() MEM_LOCAL(AliHLTTPCCASharedMemory) &s, GPUconstant() MEM_CONSTANT(AliHLTTPCCATracker) &tracker )
{
- // select best tracklets and kill clones
+ // select best tracklets and kill clones
- if( iSync==0 )
- {
- if( iThread==0 ){
- if(iBlock==0){
- CAMath::atomicExch(&(tracker.NTracks()),0);
- CAMath::atomicExch(tracker.TrackHits(),0);
- }
- s.fNTracklets = tracker.Tracklets()[0];
- s.fNThreadsTotal = nThreads*nBlocks;
- s.fItr0 = nThreads*iBlock;
- //if( iBlock==0 ) tracker.StartHits()[0] = 0;//SG!!!
- }
- }
- else if( iSync==1 )
- {
- AliHLTTPCCATrack tout;
- Int_t trackHits[160];
-
- for( Int_t itr= s.fItr0 + iThread; itr<s.fNTracklets; itr+=s.fNThreadsTotal ){
- Int_t *t = tracker.Tracklets() + 1 + itr*(5+ sizeof(AliHLTTPCCATrackParam)/4 + 160 );
- Int_t tNHits = *t;
- if( tNHits<=0 ) continue;
-
- CAMath::atomicAdd( tracker.StartHits(), 1);//SG!!!
- tout.NHits() = 0;
- Int_t *hitstore = t + 5+ sizeof(AliHLTTPCCATrackParam)/4 ;
- Int_t w = (tNHits<<16)+itr;
- Int_t nRows = tracker.Param().NRows();
- for( Int_t irow=0; irow<nRows; irow++ ){
- Int_t ih = hitstore[irow];
- if( ih<0 ) continue;
- AliHLTTPCCARow &row = tracker.Rows()[irow];
- Int_t ihTot = row.FirstHit()+ih;
- if( tracker.HitIsUsed()[ihTot] > w ) continue;
- Int_t th = AliHLTTPCCATracker::IRowIHit2ID(irow,ih);
- trackHits[tout.NHits()] = th;
- tout.NHits()++;
- }
- if( tout.NHits()<10 ) continue;//SG!!!
- Int_t itrout = CAMath::atomicAdd(&(tracker.NTracks()),1);
- tout.FirstHitID() = CAMath::atomicAdd( tracker.TrackHits(), tout.NHits() ) + 1;
- tout.Param() = *( (AliHLTTPCCATrackParam*)( t+5) );
- tout.Alive() = 1;
- tracker.Tracks()[itrout] = tout;
- for( Int_t ih=0; ih<tout.NHits(); ih++ ){//SG
- tracker.TrackHits()[tout.FirstHitID() + ih] = trackHits[ih];
+ if ( iSync == 0 ) {
+ if ( iThread == 0 ) {
+ s.fNTracklets = *tracker.NTracklets();
+ s.fNThreadsTotal = nThreads * nBlocks;
+ s.fItr0 = nThreads * iBlock;
+ }
+ } else if ( iSync == 1 ) {
+ int nHits, nFirstTrackHit;
+ AliHLTTPCCAHitId trackHits[160 - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE];
+
+ for ( int itr = s.fItr0 + iThread; itr < s.fNTracklets; itr += s.fNThreadsTotal ) {
+
+#ifdef HLTCA_GPU_EMULATION_DEBUG_TRACKLET
+ if (itr == HLTCA_GPU_EMULATION_DEBUG_TRACKLET)
+ {
+ tracker.GPUParameters()->fGPUError = 1;
+ }
+#endif //HLTCA_GPU_EMULATION_DEBUG_TRACKLET
+
+ while (tracker.Tracklets()[itr].NHits() == 0)
+ {
+ itr += s.fNThreadsTotal;
+ if (itr >= s.fNTracklets) return;
+ }
+
+ GPUglobalref() MEM_GLOBAL(AliHLTTPCCATracklet) &tracklet = tracker.Tracklets()[itr];
+ const int kMaxRowGap = 4;
+ const float kMaxShared = .1;
+
+ int firstRow = tracklet.FirstRow();
+ int lastRow = tracklet.LastRow();
+ if (firstRow < 0 || lastRow > tracker.Param().NRows() || tracklet.NHits() < 0)
+ {
+#ifdef HLTCA_GPU_ALTERNATIVE_SCHEDULER
+ //tracker.GPUParameters()->fGPUError = HLTCA_GPU_ERROR_WRONG_ROW;
+ //return;
+#else
+ continue;
+#endif
+ }
+
+ const int w = tracklet.HitWeight();
+
+ //int w = (tNHits<<16)+itr;
+ //int nRows = tracker.Param().NRows();
+ //std::cout<<" store tracklet: "<<firstRow<<" "<<lastRow<<std::endl;
+
+ int irow = firstRow;
+
+ int gap = 0;
+ int nShared = 0;
+ nHits = 0;
+
+ for (irow = firstRow; irow <= lastRow && lastRow - irow + nHits >= TRACKLET_SELECTOR_MIN_HITS; irow++ )
+ {
+ gap++;
+#ifdef EXTERN_ROW_HITS
+ int ih = tracker.TrackletRowHits()[irow * s.fNTracklets + itr];
+#else
+ int ih = tracklet.RowHit( irow );
+#endif //EXTERN_ROW_HITS
+ if ( ih >= 0 ) {
+ GPUglobalref() const MEM_GLOBAL(AliHLTTPCCARow) &row = tracker.Row( irow );
+#ifdef GLOBAL_TRACKING_ONLY_UNASSIGNED_HITS
+ bool own = ( abs(tracker.HitWeight( row, ih )) <= w );
+#else
+ bool own = ( tracker.HitWeight( row, ih ) <= w );
+#endif
+ bool sharedOK = ( ( nShared < nHits * kMaxShared ) );
+ if ( own || sharedOK ) {//SG!!!
+ gap = 0;
+#if HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+ if (nHits < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
+ s.fHits[iThread][nHits].Set( irow, ih );
+ else
+#endif //HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+ trackHits[nHits - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE].Set( irow, ih );
+ nHits++;
+ if ( !own ) nShared++;
+ }
+ }
+
+ if ( gap > kMaxRowGap || irow == lastRow ) { // store
+ if ( nHits >= TRACKLET_SELECTOR_MIN_HITS ) { //SG!!!
+ int itrout = CAMath::AtomicAdd( tracker.NTracks(), 1 );
+#ifdef HLTCA_GPUCODE
+ if (itrout >= HLTCA_GPU_MAX_TRACKS)
+ {
+ tracker.GPUParameters()->fGPUError = HLTCA_GPU_ERROR_TRACK_OVERFLOW;
+ CAMath::AtomicExch( tracker.NTracks(), 0 );
+ return;
+ }
+#endif //HLTCA_GPUCODE
+ nFirstTrackHit = CAMath::AtomicAdd( tracker.NTrackHits(), nHits );
+ tracker.Tracks()[itrout].SetAlive(1);
+ tracker.Tracks()[itrout].SetLocalTrackId(itrout);
+ tracker.Tracks()[itrout].SetParam(tracklet.Param());
+ tracker.Tracks()[itrout].SetFirstHitID(nFirstTrackHit);
+ tracker.Tracks()[itrout].SetNHits(nHits);
+ for ( int jh = 0; jh < nHits; jh++ ) {
+#if HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+ if (jh < HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE)
+ {
+ tracker.TrackHits()[nFirstTrackHit + jh] = s.fHits[iThread][jh];
+#ifdef GLOBAL_TRACKING_ONLY_UNASSIGNED_HITS
+ tracker.SetHitWeight( tracker.Row( s.fHits[iThread][jh].RowIndex() ), s.fHits[iThread][jh].HitIndex(), -w );
+#endif
+ }
+ else
+#endif //HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+ {
+ tracker.TrackHits()[nFirstTrackHit + jh] = trackHits[jh - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE];
+#ifdef GLOBAL_TRACKING_ONLY_UNASSIGNED_HITS
+ tracker.SetHitWeight( tracker.Row( trackHits[jh - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE].RowIndex() ), trackHits[jh - HLTCA_GPU_TRACKLET_SELECTOR_HITS_REG_SIZE].HitIndex(), -w );
+#endif
+ }
+ }
+ }
+ nHits = 0;
+ gap = 0;
+ nShared = 0;
+ }
+ }
+ }
}
- }
- }
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff