1 // @(#) $Id: AliHLTTPCCATracker.cxx 34611 2009-09-04 00:22:05Z sgorbuno $
2 // **************************************************************************
3 // This file is property of and copyright by the ALICE HLT Project *
4 // ALICE Experiment at CERN, All rights reserved. *
6 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
7 // Ivan Kisel <kisel@kip.uni-heidelberg.de> *
8 // for The ALICE HLT Project. *
10 // Permission to use, copy, modify and distribute this software and its *
11 // documentation strictly for non-commercial purposes is hereby granted *
12 // without fee, provided that the above copyright notice appears in all *
13 // copies and that both the copyright notice and this permission notice *
14 // appear in the supporting documentation. The authors make no claims *
15 // about the suitability of this software for any purpose. It is *
16 // provided "as is" without express or implied warranty. *
18 //***************************************************************************
20 #include "AliHLTTPCCADef.h"
21 #include "AliHLTTPCCAGPUConfig.h"
22 #include "AliHLTTPCCATrackerFramework.h"
23 #include "AliHLTTPCCAGPUTracker.h"
24 #include "AliHLTTPCCATracker.h"
25 #include "AliHLTTPCCAMath.h"
26 #include "AliHLTTPCCAClusterData.h"
35 #ifdef HLTCA_STANDALONE
39 ClassImp( AliHLTTPCCATrackerFramework )
41 int AliHLTTPCCATrackerFramework::InitGPU(int sliceCount, int forceDeviceID)
43 //Initialize GPU Tracker and determine if GPU available
45 if (!fGPULibAvailable)
47 HLTError("GPU Library not loaded\n");
50 if (fGPUTrackerAvailable && (retVal = ExitGPU())) return(retVal);
51 retVal = fGPUTracker->InitGPU(sliceCount, forceDeviceID);
52 fUseGPUTracker = fGPUTrackerAvailable = retVal == 0;
56 int AliHLTTPCCATrackerFramework::ExitGPU()
58 //Uninitialize GPU Tracker
59 if (!fGPUTrackerAvailable) return(0);
60 fUseGPUTracker = false;
61 fGPUTrackerAvailable = false;
62 return(fGPUTracker->ExitGPU());
65 void AliHLTTPCCATrackerFramework::SetGPUDebugLevel(int Level, std::ostream *OutFile, std::ostream *GPUOutFile)
67 //Set Debug Level for GPU Tracker and also for CPU Tracker for comparison reasons
68 fGPUTracker->SetDebugLevel(Level, GPUOutFile);
69 fGPUDebugLevel = Level;
70 for (int i = 0;i < fgkNSlices;i++)
72 fCPUTrackers[i].SetGPUDebugLevel(Level, OutFile);
76 int AliHLTTPCCATrackerFramework::SetGPUTracker(bool enable)
78 //Enable / disable GPU Tracker
79 if (enable && !fGPUTrackerAvailable)
81 fUseGPUTracker = false;
84 fUseGPUTracker = enable;
88 GPUhd() void AliHLTTPCCATrackerFramework::SetOutputControl( AliHLTTPCCASliceOutput::outputControlStruct* val)
90 //Set Output Control Pointers
92 fGPUTracker->SetOutputControl(val);
93 for (int i = 0;i < fgkNSlices;i++)
95 fCPUTrackers[i].SetOutputControl(val);
99 int AliHLTTPCCATrackerFramework::ProcessSlices(int firstSlice, int sliceCount, AliHLTTPCCAClusterData* pClusterData, AliHLTTPCCASliceOutput** pOutput)
101 int useGlobalTracking = fGlobalTracking;
102 if (fGlobalTracking && (firstSlice || sliceCount != fgkNSlices))
104 HLTWarning("Global Tracking only available if all slices are processed!");
105 useGlobalTracking = 0;
108 //Process sliceCount slices starting from firstslice, in is pClusterData array, out pOutput array
111 if (fGPUTracker->Reconstruct(pOutput, pClusterData, firstSlice, CAMath::Min(sliceCount, fgkNSlices - firstSlice))) return(1);
115 #ifdef HLTCA_STANDALONE
116 if (fOutputControl->fOutputPtr && omp_get_max_threads() > 1)
118 HLTError("fOutputPtr must not be used with OpenMP\n");
121 int nLocalTracks = 0, nGlobalTracks = 0, nOutputTracks = 0, nLocalHits = 0, nGlobalHits = 0;
123 #pragma omp parallel for
125 for (int iSlice = 0;iSlice < CAMath::Min(sliceCount, fgkNSlices - firstSlice);iSlice++)
127 #ifdef HLTCA_STANDALONE
128 fCPUTrackers[firstSlice + iSlice].StandalonePerfTime(0);
130 fCPUTrackers[firstSlice + iSlice].ReadEvent(&pClusterData[iSlice]);
131 fCPUTrackers[firstSlice + iSlice].SetOutput(&pOutput[iSlice]);
132 fCPUTrackers[firstSlice + iSlice].Reconstruct();
133 fCPUTrackers[firstSlice + iSlice].CommonMemory()->fNLocalTracks = fCPUTrackers[firstSlice + iSlice].CommonMemory()->fNTracks;
134 fCPUTrackers[firstSlice + iSlice].CommonMemory()->fNLocalTrackHits = fCPUTrackers[firstSlice + iSlice].CommonMemory()->fNTrackHits;
135 if (!useGlobalTracking)
137 fCPUTrackers[firstSlice + iSlice].ReconstructOutput();
138 #ifdef HLTCA_STANDALONE
139 nOutputTracks += (*fCPUTrackers[firstSlice + iSlice].Output())->NTracks();
140 nLocalTracks += fCPUTrackers[firstSlice + iSlice].CommonMemory()->fNTracks;
144 fCPUTrackers[firstSlice + iSlice].SetupCommonMemory();
149 if (useGlobalTracking)
151 for (int iSlice = 0;iSlice < CAMath::Min(sliceCount, fgkNSlices - firstSlice);iSlice++)
153 int sliceLeft = (iSlice + (fgkNSlices / 2 - 1)) % (fgkNSlices / 2);
154 int sliceRight = (iSlice + 1) % (fgkNSlices / 2);
155 if (iSlice >= fgkNSlices / 2)
157 sliceLeft += fgkNSlices / 2;
158 sliceRight += fgkNSlices / 2;
160 fCPUTrackers[iSlice].PerformGlobalTracking(fCPUTrackers[sliceLeft], fCPUTrackers[sliceRight], CAMath::Min(fCPUTrackers[sliceLeft].CommonMemory()->fNTracklets, fCPUTrackers[sliceRight].CommonMemory()->fNTracklets) * 2);
162 for (int iSlice = 0;iSlice < CAMath::Min(sliceCount, fgkNSlices - firstSlice);iSlice++)
164 fCPUTrackers[firstSlice + iSlice].ReconstructOutput();
165 #ifdef HLTCA_STANDALONE
166 //printf("Slice %d - Tracks: Local %d Global %d - Hits: Local %d Global %d\n", iSlice, fCPUTrackers[iSlice].CommonMemory()->fNLocalTracks, fCPUTrackers[iSlice].CommonMemory()->fNTracks, fCPUTrackers[iSlice].CommonMemory()->fNLocalTrackHits, fCPUTrackers[iSlice].CommonMemory()->fNTrackHits);
167 nLocalTracks += fCPUTrackers[iSlice].CommonMemory()->fNLocalTracks;
168 nGlobalTracks += fCPUTrackers[iSlice].CommonMemory()->fNTracks;
169 nLocalHits += fCPUTrackers[iSlice].CommonMemory()->fNLocalTrackHits;
170 nGlobalHits += fCPUTrackers[iSlice].CommonMemory()->fNTrackHits;
171 nOutputTracks += (*fCPUTrackers[iSlice].Output())->NTracks();
175 fCPUTrackers[firstSlice + iSlice].SetupCommonMemory();
179 #ifdef HLTCA_STANDALONE
180 //printf("Slice Tracks Output %d: - Tracks: %d local, %d global - Hits: %d local, %d global\n", nOutputTracks, nLocalTracks, nGlobalTracks, nLocalHits, nGlobalHits);
181 /*for (int i = firstSlice;i < firstSlice + sliceCount;i++)
183 fCPUTrackers[i].DumpOutput(stdout);
188 if (fGPUDebugLevel >= 6 && fUseGPUTracker)
191 ProcessSlices(firstSlice, sliceCount, pClusterData, pOutput);
198 unsigned long long int* AliHLTTPCCATrackerFramework::PerfTimer(int GPU, int iSlice, int iTimer)
200 //Performance information for slice trackers
201 return(GPU ? fGPUTracker->PerfTimer(iSlice, iTimer) : fCPUTrackers[iSlice].PerfTimer(iTimer));
204 int AliHLTTPCCATrackerFramework::InitializeSliceParam(int iSlice, AliHLTTPCCAParam ¶m)
206 //Initialize Tracker Parameters for a slice
207 if (fGPUTrackerAvailable && fGPUTracker->InitializeSliceParam(iSlice, param)) return(1);
208 fCPUTrackers[iSlice].Initialize(param);
212 #ifdef HLTCA_STANDALONE
213 #define GPULIBNAME "libAliHLTTPCCAGPUSA"
215 #define GPULIBNAME "libAliHLTTPCCAGPU"
218 AliHLTTPCCATrackerFramework::AliHLTTPCCATrackerFramework(int allowGPU, const char* GPU_Library) : fGPULibAvailable(false), fGPUTrackerAvailable(false), fUseGPUTracker(false), fGPUDebugLevel(0), fGPUTracker(NULL), fGPULib(NULL), fOutputControl( NULL ), fKeepData(false), fGlobalTracking(false)
221 if (GPU_Library && !GPU_Library[0]) GPU_Library = NULL;
223 HMODULE hGPULib = LoadLibraryEx(GPU_Library == NULL ? (GPULIBNAME ".dll") : GPU_Library, NULL, NULL);
225 void* hGPULib = dlopen(GPU_Library == NULL ? (GPULIBNAME ".so") : GPU_Library, RTLD_NOW);
232 HLTInfo("The following error occured during dlopen: %s", dlerror());
234 HLTError("Error Opening cagpu library for GPU Tracker, will fallback to CPU");
238 HLTDebug("Cagpu library was not found, Tracking on GPU will not be available");
240 fGPUTracker = new AliHLTTPCCAGPUTracker;
245 FARPROC createFunc = GetProcAddress(hGPULib, "AliHLTTPCCAGPUTrackerNVCCCreate");
247 void* createFunc = (void*) dlsym(hGPULib, "AliHLTTPCCAGPUTrackerNVCCCreate");
249 if (createFunc == NULL)
251 HLTError("Error Creating GPU Tracker\n");
253 FreeLibrary(hGPULib);
257 fGPUTracker = new AliHLTTPCCAGPUTracker;
261 AliHLTTPCCAGPUTracker* (*tmp)() = (AliHLTTPCCAGPUTracker* (*)()) createFunc;
263 fGPULibAvailable = true;
264 fGPULib = (void*) (size_t) hGPULib;
265 HLTImportant("GPU Tracker library loaded and GPU tracker object created sucessfully (%sactive)", allowGPU ? "" : "in");
269 if (allowGPU && fGPULibAvailable)
271 fUseGPUTracker = (fGPUTrackerAvailable = (fGPUTracker->InitGPU() == 0));
272 HLTInfo("GPU Tracker Initialized and available in framework");
276 AliHLTTPCCATrackerFramework::~AliHLTTPCCATrackerFramework()
279 HMODULE hGPULib = (HMODULE) (size_t) fGPULib;
281 void* hGPULib = fGPULib;
289 FARPROC destroyFunc = GetProcAddress(hGPULib, "AliHLTTPCCAGPUTrackerNVCCDestroy");
291 void* destroyFunc = (void*) dlsym(hGPULib, "AliHLTTPCCAGPUTrackerNVCCDestroy");
293 if (destroyFunc == NULL)
295 HLTError("Error Freeing GPU Tracker\n");
299 void (*tmp)(AliHLTTPCCAGPUTracker*) = (void (*)(AliHLTTPCCAGPUTracker*)) destroyFunc;
305 FreeLibrary(hGPULib);
310 else if (fGPUTracker)