Line data Source code
1 : // **************************************************************************
2 : // * This file is property of and copyright by the ALICE HLT Project *
3 : // * All rights reserved. *
4 : // * *
5 : // * Primary Authors: *
6 : // * Copyright 2009 Matthias Kretz <kretz@kde.org> *
7 : // * *
8 : // * Permission to use, copy, modify and distribute this software and its *
9 : // * documentation strictly for non-commercial purposes is hereby granted *
10 : // * without fee, provided that the above copyright notice appears in all *
11 : // * copies and that both the copyright notice and this permission notice *
12 : // * appear in the supporting documentation. The authors make no claims *
13 : // * about the suitability of this software for any purpose. It is *
14 : // * provided "as is" without express or implied warranty. *
15 : // **************************************************************************
16 :
17 : #ifndef ALIHLTTPCCASLICEDATA_H
18 : #define ALIHLTTPCCASLICEDATA_H
19 :
20 : #include "AliHLTTPCCADef.h"
21 : #include "AliHLTTPCCARow.h"
22 : #include "AliHLTTPCCAMath.h"
23 : #if !(defined(HLTCA_GPUCODE) && defined(__OPENCL__) && !defined(HLTCA_HOSTCODE))
24 : #include "AliHLTArray.h"
25 : #endif
26 : #include "AliHLTTPCCAGPUConfig.h"
27 :
28 : typedef int int_v;
29 : typedef unsigned int uint_v;
30 : typedef short short_v;
31 : typedef unsigned short ushort_v;
32 : typedef float float_v;
33 :
34 : class AliHLTTPCCAClusterData;
35 : #if !defined(__OPENCL__) || defined(HLTCA_HOSTCODE)
36 0 : template<typename T, int Dim> class AliHLTArray;
37 : #endif
38 : class AliHLTTPCCAHit;
39 : MEM_CLASS_PRE() class AliHLTTPCCAParam;
40 :
41 : /**
42 : * Data abstraction class for the Slice Tracker.
43 : *
44 : * Different architectures implement this for the most efficient loads and stores. All access to the
45 : * data happens through inline functions so that access to the data has no extra costs.
46 : */
47 : MEM_CLASS_PRE() class AliHLTTPCCASliceData
48 : {
49 : public:
50 : AliHLTTPCCASliceData()
51 : :
52 0 : fIsGpuSliceData(0), fGPUSharedDataReq(0), fFirstRow( 0 ), fLastRow( HLTCA_ROW_COUNT - 1), fNumberOfHits( 0 ), fNumberOfHitsPlusAlign( 0 ), fMemorySize( 0 ), fGpuMemorySize( 0 ), fMemory( 0 ), fGPUTextureBase( 0 )
53 0 : ,fRows( NULL ), fLinkUpData( 0 ), fLinkDownData( 0 ), fHitData( 0 ), fClusterDataIndex( 0 )
54 0 : , fFirstHitInBin( 0 ), fHitWeights( 0 )
55 0 : {
56 0 : }
57 :
58 : #ifndef HLTCA_GPUCODE
59 : ~AliHLTTPCCASliceData();
60 : #endif //!HLTCA_GPUCODE
61 :
62 : MEM_CLASS_PRE2() void InitializeRows( const MEM_LG2(AliHLTTPCCAParam) ¶meters );
63 :
64 : /**
65 : * (Re)Create the data that is tuned for optimal performance of the algorithm from the cluster
66 : * data.
67 : */
68 :
69 : void SetGPUSliceDataMemory(void* const pSliceMemory, void* const pRowMemory);
70 : size_t SetPointers(const AliHLTTPCCAClusterData *data, bool allocate = false);
71 : void InitFromClusterData( const AliHLTTPCCAClusterData &data );
72 :
73 : /**
74 : * Clear the slice data (e.g. for an empty slice)
75 : */
76 : void Clear();
77 :
78 : /**
79 : * Return the number of hits in this slice.
80 : */
81 0 : GPUhd() int NumberOfHits() const { return fNumberOfHits; }
82 0 : GPUhd() int NumberOfHitsPlusAlign() const { return fNumberOfHitsPlusAlign; }
83 :
84 : /**
85 : * Access to the hit links.
86 : *
87 : * The links values give the hit index in the row above/below. Or -1 if there is no link.
88 : */
89 : MEM_TEMPLATE() GPUd() short_v HitLinkUpData ( const MEM_TYPE(AliHLTTPCCARow) &row, const short_v &hitIndex ) const;
90 : MEM_TEMPLATE() GPUd() short_v HitLinkDownData( const MEM_TYPE(AliHLTTPCCARow) &row, const short_v &hitIndex ) const;
91 :
92 0 : MEM_TEMPLATE() GPUhd() GPUglobalref() const ushort2 *HitData( const MEM_TYPE(AliHLTTPCCARow) &row ) const {return &fHitData[row.fHitNumberOffset];}
93 0 : GPUhd() GPUglobalref() const ushort2* HitData() const { return(fHitData); }
94 0 : MEM_TEMPLATE() GPUd() GPUglobalref() const short_v *HitLinkUpData ( const MEM_TYPE(AliHLTTPCCARow) &row ) const {return &fLinkUpData[row.fHitNumberOffset];}
95 0 : MEM_TEMPLATE() GPUd() GPUglobalref() const short_v *HitLinkDownData( const MEM_TYPE(AliHLTTPCCARow) &row ) const {return &fLinkDownData[row.fHitNumberOffset];}
96 0 : MEM_TEMPLATE() GPUd() GPUglobalref() const ushort_v *FirstHitInBin( const MEM_TYPE( AliHLTTPCCARow) &row ) const {return &fFirstHitInBin[row.fFirstHitInBinOffset];}
97 :
98 : MEM_TEMPLATE() GPUd() void SetHitLinkUpData ( const MEM_TYPE(AliHLTTPCCARow) &row, const short_v &hitIndex,
99 : const short_v &value );
100 : MEM_TEMPLATE() GPUd() void SetHitLinkDownData( const MEM_TYPE(AliHLTTPCCARow) &row, const short_v &hitIndex,
101 : const short_v &value );
102 :
103 : /**
104 : * Reset all links to -1.
105 : */
106 : void ClearLinks();
107 :
108 : /**
109 : * Return the y and z coordinate(s) of the given hit(s).
110 : */
111 : // TODO return float_v
112 : MEM_TEMPLATE() GPUd() ushort_v HitDataY( const MEM_TYPE( AliHLTTPCCARow) &row, const uint_v &hitIndex ) const;
113 : MEM_TEMPLATE() GPUd() ushort_v HitDataZ( const MEM_TYPE( AliHLTTPCCARow) &row, const uint_v &hitIndex ) const;
114 : MEM_TEMPLATE() GPUd() ushort2 HitData( const MEM_TYPE( AliHLTTPCCARow) &row, const uint_v &hitIndex ) const;
115 :
116 : /**
117 : * For a given bin index, content tells how many hits there are in the preceding bins. This maps
118 : * directly to the hit index in the given row.
119 : *
120 : * \param binIndexes in the range 0 to row.Grid.N + row.Grid.Ny + 3.
121 : */
122 : MEM_TEMPLATE() GPUd() ushort_v FirstHitInBin( const MEM_TYPE( AliHLTTPCCARow)&row, ushort_v binIndexes ) const;
123 :
124 : /**
125 : * If the given weight is higher than what is currently stored replace with the new weight.
126 : */
127 : MEM_TEMPLATE() GPUd() void MaximizeHitWeight( const MEM_TYPE( AliHLTTPCCARow)&row, uint_v hitIndex, int_v weight );
128 : MEM_TEMPLATE() GPUd() void SetHitWeight( const MEM_TYPE( AliHLTTPCCARow)&row, uint_v hitIndex, int_v weight );
129 :
130 : /**
131 : * Return the maximal weight the given hit got from one tracklet
132 : */
133 : MEM_TEMPLATE() GPUd() int_v HitWeight( const MEM_TYPE( AliHLTTPCCARow)&row, uint_v hitIndex ) const;
134 :
135 : /**
136 : * Reset all hit weights to 0.
137 : */
138 : void ClearHitWeights();
139 :
140 : /**
141 : * Returns the index in the original AliHLTTPCCAClusterData object of the given hit
142 : */
143 : MEM_TEMPLATE() GPUhd() int_v ClusterDataIndex( const MEM_TYPE( AliHLTTPCCARow)&row, uint_v hitIndex ) const;
144 :
145 : /**
146 : * Return the row object for the given row index.
147 : */
148 0 : GPUhd() GPUglobalref() const MEM_GLOBAL(AliHLTTPCCARow)& Row( int rowIndex ) const {return fRows[rowIndex];}
149 0 : GPUhd() GPUglobalref() MEM_GLOBAL(AliHLTTPCCARow)* Rows() const {return fRows;}
150 :
151 0 : GPUhd() GPUglobalref() int* HitWeights() const {return(fHitWeights); }
152 :
153 0 : GPUhd() void SetGPUTextureBase(char* const val) {fGPUTextureBase = val;}
154 0 : GPUhd() char* GPUTextureBase() const { return(fGPUTextureBase); }
155 0 : GPUhd() char* GPUTextureBaseConst() const { return(fGPUTextureBase); }
156 :
157 : #if !defined(__OPENCL__) || defined(HLTCA_HOSTCODE)
158 0 : GPUh() char* Memory() const {return(fMemory); }
159 0 : GPUh() size_t MemorySize() const {return(fMemorySize); }
160 0 : GPUh() size_t GpuMemorySize() const {return(fGpuMemorySize); }
161 0 : GPUh() int GPUSharedDataReq() const { return fGPUSharedDataReq; }
162 : #endif
163 :
164 0 : void SetGpuSliceData() { fIsGpuSliceData = 1; }
165 :
166 : private:
167 : AliHLTTPCCASliceData( const AliHLTTPCCASliceData & )
168 : :
169 : fIsGpuSliceData(0), fGPUSharedDataReq(0), fFirstRow(0), fLastRow(HLTCA_ROW_COUNT - 1), fNumberOfHits( 0 ), fNumberOfHitsPlusAlign( 0 ), fMemorySize( 0 ), fGpuMemorySize( 0 ), fMemory( 0 ), fGPUTextureBase( 0 )
170 : ,fRows( NULL ), fLinkUpData( 0 ), fLinkDownData( 0 ), fHitData( 0 ), fClusterDataIndex( 0 )
171 : , fFirstHitInBin( 0 ), fHitWeights( 0 )
172 : {
173 : }
174 : AliHLTTPCCASliceData& operator=( const AliHLTTPCCASliceData & ) {
175 : return *this;
176 : }
177 :
178 : #if !defined(__OPENCL__) || defined(HLTCA_HOSTCODE)
179 : void CreateGrid( AliHLTTPCCARow *row, const float2* data, int ClusterDataHitNumberOffset );
180 : void PackHitData( AliHLTTPCCARow *row, const AliHLTArray<AliHLTTPCCAHit, 1> &binSortedHits );
181 : #endif
182 :
183 : int fIsGpuSliceData; //Slice Data for GPU Tracker?
184 : int fGPUSharedDataReq; //Size of shared memory required for GPU Reconstruction
185 :
186 : int fFirstRow; //First non-empty row
187 : int fLastRow; //Last non-empty row
188 :
189 : int fNumberOfHits; // the number of hits in this slice
190 : int fNumberOfHitsPlusAlign;
191 :
192 : int fMemorySize; // size of the allocated memory in bytes
193 : int fGpuMemorySize; // size of Memory needed to be transfered to GPU
194 : GPUglobalref() char *fMemory; // pointer to the allocated memory where all the following arrays reside in
195 : GPUglobalref() char *fGPUTextureBase; // pointer to start of GPU texture
196 :
197 : GPUglobalref() MEM_GLOBAL(AliHLTTPCCARow) *fRows; // The row objects needed for most accessor functions
198 :
199 : GPUglobalref() short *fLinkUpData; // hit index in the row above which is linked to the given (global) hit index
200 : GPUglobalref() short *fLinkDownData; // hit index in the row below which is linked to the given (global) hit index
201 :
202 : GPUglobalref() ushort2 *fHitData; // packed y,z coordinate of the given (global) hit index
203 :
204 : GPUglobalref() int *fClusterDataIndex; // see ClusterDataIndex()
205 :
206 : /*
207 : * The size of the array is row.Grid.N + row.Grid.Ny + 3. The row.Grid.Ny + 3 is an optimization
208 : * to remove the need for bounds checking. The last values are the same as the entry at [N - 1].
209 : */
210 : GPUglobalref() unsigned short *fFirstHitInBin; // see FirstHitInBin
211 :
212 : GPUglobalref() int *fHitWeights; // the weight of the longest tracklet crossed the cluster
213 :
214 : };
215 :
216 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUd() inline short_v MEM_LG(AliHLTTPCCASliceData)::HitLinkUpData ( const MEM_TYPE( AliHLTTPCCARow)&row, const short_v &hitIndex ) const
217 : {
218 0 : return fLinkUpData[row.fHitNumberOffset + hitIndex];
219 : }
220 :
221 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUd() inline short_v MEM_LG(AliHLTTPCCASliceData)::HitLinkDownData( const MEM_TYPE( AliHLTTPCCARow)&row, const short_v &hitIndex ) const
222 : {
223 0 : return fLinkDownData[row.fHitNumberOffset + hitIndex];
224 : }
225 :
226 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUd() inline void MEM_LG(AliHLTTPCCASliceData)::SetHitLinkUpData ( const MEM_TYPE( AliHLTTPCCARow)&row, const short_v &hitIndex, const short_v &value )
227 : {
228 0 : fLinkUpData[row.fHitNumberOffset + hitIndex] = value;
229 0 : }
230 :
231 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUd() inline void MEM_LG(AliHLTTPCCASliceData)::SetHitLinkDownData( const MEM_TYPE( AliHLTTPCCARow)&row, const short_v &hitIndex, const short_v &value )
232 : {
233 0 : fLinkDownData[row.fHitNumberOffset + hitIndex] = value;
234 0 : }
235 :
236 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUd() inline ushort_v MEM_LG(AliHLTTPCCASliceData)::HitDataY( const MEM_TYPE( AliHLTTPCCARow)&row, const uint_v &hitIndex ) const
237 : {
238 0 : return fHitData[row.fHitNumberOffset + hitIndex].x;
239 : }
240 :
241 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUd() inline ushort_v MEM_LG(AliHLTTPCCASliceData)::HitDataZ( const MEM_TYPE( AliHLTTPCCARow)&row, const uint_v &hitIndex ) const
242 : {
243 0 : return fHitData[row.fHitNumberOffset + hitIndex].y;
244 : }
245 :
246 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUd() inline ushort2 MEM_LG(AliHLTTPCCASliceData)::HitData( const MEM_TYPE( AliHLTTPCCARow)&row, const uint_v &hitIndex ) const
247 : {
248 0 : return fHitData[row.fHitNumberOffset + hitIndex];
249 : }
250 :
251 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUd() inline ushort_v MEM_LG(AliHLTTPCCASliceData)::FirstHitInBin( const MEM_TYPE( AliHLTTPCCARow)&row, ushort_v binIndexes ) const
252 : {
253 0 : return fFirstHitInBin[row.fFirstHitInBinOffset + binIndexes];
254 : }
255 :
256 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUhd() inline int_v MEM_LG(AliHLTTPCCASliceData)::ClusterDataIndex( const MEM_TYPE( AliHLTTPCCARow)&row, uint_v hitIndex ) const
257 : {
258 0 : return fClusterDataIndex[row.fHitNumberOffset + hitIndex];
259 : }
260 :
261 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUd() inline void MEM_LG(AliHLTTPCCASliceData)::MaximizeHitWeight( const MEM_TYPE( AliHLTTPCCARow)&row, uint_v hitIndex, int_v weight )
262 : {
263 0 : CAMath::AtomicMax( &fHitWeights[row.fHitNumberOffset + hitIndex], weight );
264 0 : }
265 :
266 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUd() inline void MEM_LG(AliHLTTPCCASliceData)::SetHitWeight( const MEM_TYPE( AliHLTTPCCARow)&row, uint_v hitIndex, int_v weight )
267 : {
268 0 : fHitWeights[row.fHitNumberOffset + hitIndex] = weight;
269 0 : }
270 :
271 : MEM_CLASS_PRE() MEM_TEMPLATE() GPUd() inline int_v MEM_LG(AliHLTTPCCASliceData)::HitWeight( const MEM_TYPE( AliHLTTPCCARow)&row, uint_v hitIndex ) const
272 : {
273 0 : return fHitWeights[row.fHitNumberOffset + hitIndex];
274 : }
275 :
276 : //typedef AliHLTTPCCASliceData SliceData;
277 :
278 : #endif // ALIHLTTPCCASLICEDATA_H
|
