ATLAS Offline Software
F110StreamIntegrationAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3  */
4 
5 #include "EFTrackingFPGAPipeline/F110StreamIntegrationAlg.h"
6 #include "AthenaKernel/Chrono.h"
7 #include "AthenaKernel/SlotSpecificObj.h"
8 #include <xrt/xrt_bo.h>
9 #include <xrt/xrt_device.h>
10 #include <xrt/xrt_kernel.h>
11 #include <xrt/xrt_uuid.h>
12 
13 namespace EFTrackingFPGAIntegration
14 {
15  StatusCode F110StreamIntegrationAlg::initialize()
16  {
17  ATH_MSG_INFO("Running on the FPGA accelerator");
18 
19  ATH_CHECK(IntegrationBase::precheck({m_xclbin}));
20 
21  ATH_CHECK(m_chronoSvc.retrieve());
22 
23  {
24  Athena::Chrono chrono("Platform and device initlize", m_chronoSvc.get());
25  ATH_CHECK(IntegrationBase::initialize());
26  }
27 
28  {
29  Athena::Chrono chrono("CL::loadProgram", m_chronoSvc.get());
30  ATH_CHECK(IntegrationBase::loadProgram(m_xclbin));
31  }
32  ATH_MSG_INFO("loading "<<m_xclbin);
33 
34 
35  ATH_CHECK(m_FPGAStripRDO.initialize());
36  ATH_CHECK(m_FPGAPixelRDO.initialize());
37 
38  ATH_CHECK(m_FPGAStripOutput.initialize());
39  ATH_CHECK(m_FPGAPixelOutput.initialize());
40 
41  std::vector<std::string> listofCUs;
42 
43  getListofCUs(listofCUs);
44 
45  cl_int err = 0;
46 
47  unsigned int nthreads = m_FPGAThreads.value();
48 
49  if(m_FPGAThreads.value() < 1){
50  nthreads = SG::getNSlots();
51  }
52 
53  // create the buffers
54  for(unsigned int i = 0; i < nthreads; i++)
55  {
56  m_acc_queues.emplace_back(m_context, m_accelerator, CL_QUEUE_PROFILING_ENABLE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, &err);
57 
58  // Input
59  m_pixelClusterInputBufferList.push_back(cl::Buffer(m_context, CL_MEM_READ_ONLY, EFTrackingTransient::PIXEL_CONTAINER_INPUT_BUF_SIZE * sizeof(uint64_t), NULL, &err));
60  m_stripClusterInputBufferList.push_back(cl::Buffer(m_context, CL_MEM_READ_ONLY, EFTrackingTransient::STRIP_CONTAINER_INPUT_BUF_SIZE * sizeof(uint64_t), NULL, &err));
61 
62  // Clustering
63  m_stripClusterOutputBufferList.push_back(cl::Buffer(m_context, CL_MEM_READ_WRITE, EFTrackingTransient::STRIP_BLOCK_BUF_SIZE * sizeof(uint64_t), NULL, &err));
64  m_pixelClusterEDMOutputBufferList.push_back(cl::Buffer(m_context, CL_MEM_READ_WRITE,EFTrackingTransient::PIXEL_BLOCK_BUF_SIZE * sizeof(uint64_t), NULL, &err));
65  m_stripClusterEDMOutputBufferList.push_back(cl::Buffer(m_context, CL_MEM_READ_WRITE, EFTrackingTransient::STRIP_BLOCK_BUF_SIZE * sizeof(uint64_t), NULL, &err));
66 
67  // L2G
68  m_stripL2GOutputBufferList.push_back(cl::Buffer(m_context, CL_MEM_READ_WRITE, EFTrackingTransient::STRIP_BLOCK_BUF_SIZE * sizeof(uint64_t), NULL, &err));
69  m_stripL2GEDMOutputBufferList.push_back(cl::Buffer(m_context, CL_MEM_READ_WRITE, EFTrackingTransient::STRIP_BLOCK_BUF_SIZE * sizeof(uint64_t), NULL, &err));
70 
71  // EDMPrep
72  m_edmPixelOutputBufferList.push_back(cl::Buffer(m_context, CL_MEM_READ_WRITE, EFTrackingTransient::PIXEL_CONTAINER_BUF_SIZE * sizeof(uint64_t), NULL, &err));
73  m_edmStripOutputBufferList.push_back(cl::Buffer(m_context, CL_MEM_READ_WRITE, EFTrackingTransient::STRIP_CONTAINER_BUF_SIZE * sizeof(uint64_t), NULL, &err));
74  }
75 
76  // Create kernels for each one of CUs that is inside device
77  for (const auto& cuName: listofCUs)
78  {
79  // Pixel clustering
80  if(cuName.find(m_pixelEndClusterKernelName.value()) != std::string::npos) m_pixelEndClusteringKernels.emplace_back(cl::Kernel(m_program, cuName.c_str()));
81  else if(cuName.find(m_pixelStartClusterKernelName.value()) != std::string::npos) m_pixelStartClusteringKernels.emplace_back(cl::Kernel(m_program, cuName.c_str()));
82 
83  // Strip clustering
84  else if(cuName.find(m_stripEndClusterKernelName.value()) != std::string::npos) m_stripEndClusteringKernels.emplace_back(cl::Kernel(m_program, cuName.c_str()));
85  else if(cuName.find(m_stripStartClusterKernelName.value()) != std::string::npos) m_stripStartClusteringKernels.emplace_back(cl::Kernel(m_program, cuName.c_str()));
86 
87  // Strip L2G
88  else if(cuName.find(m_stripL2GKernelName.value()) != std::string::npos) m_stripL2GKernels.emplace_back(cl::Kernel(m_program, cuName.c_str()));
89 
90  // EDM prep
91  else if(cuName.find(m_pixelEdmKernelName.value()) != std::string::npos) m_pixelEdmPrepKernels.emplace_back(cl::Kernel(m_program, cuName.c_str()));
92 
93  else if(cuName.find(m_stripEdmKernelName.value()) != std::string::npos) m_stripEdmPrepKernels.emplace_back(cl::Kernel(m_program, cuName.c_str()));
94  else
95  {
96  ATH_MSG_WARNING("Do not recognize kernel name: "<<cuName);
97  }
98  }
99 
100  ATH_MSG_INFO(m_pixelStartClusterKernelName.value()<<" size: "<<m_pixelStartClusteringKernels.size());
101  ATH_MSG_INFO(m_pixelEndClusterKernelName.value()<<" size: "<<m_pixelEndClusteringKernels.size());
102  ATH_MSG_INFO(m_stripStartClusterKernelName.value()<<" size: "<<m_stripStartClusteringKernels.size());
103  ATH_MSG_INFO(m_stripEndClusterKernelName.value()<<" size: "<<m_stripEndClusteringKernels.size());
104  ATH_MSG_INFO(m_stripL2GKernelName.value()<<" size: "<<m_stripL2GKernels.size());
105  ATH_MSG_INFO(m_pixelEdmKernelName.value()<<" size: "<<m_pixelEdmPrepKernels.size());
106  ATH_MSG_INFO(m_stripEdmKernelName.value()<<" size: "<<m_stripEdmPrepKernels.size());
107 
108 
109  return StatusCode::SUCCESS;
110  }
111 
112  StatusCode F110StreamIntegrationAlg::execute(const EventContext &ctx) const
113  {
114  ATH_MSG_DEBUG("Executing F110StreamIntegrationAlg");
115  m_numEvents++;
116 
118  const std::vector<uint64_t>* pixelInput{nullptr}, *stripInput{nullptr};
119  ATH_CHECK(SG::get(pixelInput, m_FPGAPixelRDO, ctx));
120  ATH_CHECK(SG::get(stripInput, m_FPGAStripRDO, ctx));
121 
122 
123  // logic
124  unsigned int nthreads = m_FPGAThreads.value();
125 
126  if(m_FPGAThreads.value() < 1){
127  nthreads = SG::getNSlots();
128  }
129 
130  size_t bufferIndex = ctx.slot() % nthreads;
131 
132  // Get index for each of the kernels
133  size_t pixelStartClusterIndex = ctx.slot() % m_pixelStartClusteringKernels.size();
134  size_t pixelEndClusterIndex = ctx.slot() % m_pixelEndClusteringKernels.size();
135  size_t stripStartClusterIndex = ctx.slot() % m_stripStartClusteringKernels.size();
136  size_t stripEndClusterIndex = ctx.slot() % m_stripEndClusteringKernels.size();
137  size_t stripL2GIndex = ctx.slot() % m_stripL2GKernels.size();
138  size_t pixelEDMIndex = m_pixelEdmPrepKernels.size() ? ctx.slot() % m_pixelEdmPrepKernels.size() : 0;
139  size_t stripEDMIndex = m_stripEdmPrepKernels.size() ? ctx.slot() % m_stripEdmPrepKernels.size() : 0;
140 
141  const cl::CommandQueue &acc_queue = m_acc_queues[bufferIndex];
142 
143  ATH_MSG_INFO("Thread number "<<ctx.slot()<<" running on buffer "<<bufferIndex<<" pixelStartClusterIndex: "<< pixelStartClusterIndex<<" stripStartClusterIndex: "<< stripStartClusterIndex<<" stripEndClusterIndex: "<< stripEndClusterIndex<<" stripL2GIndex: "<< stripL2GIndex<<" pixelEDMIndex: "<< pixelEDMIndex<<" stripEDMIndex: "<< stripEDMIndex);
144 
145  cl::Kernel &pixelStartClusteringKernel = m_pixelStartClusteringKernels[pixelStartClusterIndex];
146  cl::Kernel &pixelEndClusteringKernel = m_pixelEndClusteringKernels[pixelEndClusterIndex];
147  cl::Kernel &stripStartClusteringKernel = m_stripStartClusteringKernels[stripStartClusterIndex];
148  cl::Kernel &stripEndClusteringKernel = m_stripEndClusteringKernels[stripEndClusterIndex];
149  cl::Kernel &stripL2GKernel = m_stripL2GKernels[stripL2GIndex];
150 
151  cl::Kernel &pixelEdmPrepKernel = m_pixelEdmPrepKernels[pixelEDMIndex];
152  cl::Kernel &stripEdmPrepKernel = m_stripEdmPrepKernels[stripEDMIndex];
153 
154 
155  // Set kernel arguments
156  pixelStartClusteringKernel.setArg(0, m_pixelClusterInputBufferList[bufferIndex]);
157  pixelStartClusteringKernel.setArg(2, static_cast<unsigned long long>((*pixelInput).size()));
158 
159  pixelEndClusteringKernel.setArg(1, m_pixelClusterEDMOutputBufferList[bufferIndex]);
160 
161 
162  stripStartClusteringKernel.setArg(0, m_stripClusterInputBufferList[bufferIndex]);
163  stripStartClusteringKernel.setArg(2, static_cast<unsigned long long>((*stripInput).size()));
164 
165  stripEndClusteringKernel.setArg(1, m_stripClusterOutputBufferList[bufferIndex]);
166 
167 
168  stripL2GKernel.setArg(0, m_stripClusterOutputBufferList[bufferIndex]);
169  stripL2GKernel.setArg(1, m_stripClusterEDMOutputBufferList[bufferIndex]);
170  stripL2GKernel.setArg(2, m_stripL2GOutputBufferList[bufferIndex]);
171  stripL2GKernel.setArg(3, m_stripL2GEDMOutputBufferList[bufferIndex]);
172 
173  pixelEdmPrepKernel.setArg(0, m_pixelClusterEDMOutputBufferList[bufferIndex]);
174  pixelEdmPrepKernel.setArg(1, m_edmPixelOutputBufferList[bufferIndex]);
175  stripEdmPrepKernel.setArg(0, m_stripL2GEDMOutputBufferList[bufferIndex]);
176  stripEdmPrepKernel.setArg(1, m_edmStripOutputBufferList[bufferIndex]);
177 
178 
179 
180  // Start the transfers
181  cl::Event evt_write_pixel_input;
182  cl::Event evt_write_strip_input;
183 
184  acc_queue.enqueueWriteBuffer(m_pixelClusterInputBufferList[bufferIndex], CL_FALSE, 0, sizeof(uint64_t) * (*pixelInput).size(), (*pixelInput).data(), NULL, &evt_write_pixel_input);
185  acc_queue.enqueueWriteBuffer(m_stripClusterInputBufferList[bufferIndex], CL_FALSE, 0, sizeof(uint64_t) * (*stripInput).size(), (*stripInput).data(), NULL, &evt_write_strip_input);
186  std::vector<cl::Event> evt_vec_pixel_input{evt_write_pixel_input};
187  std::vector<cl::Event> evt_vec_strip_input{evt_write_strip_input};
188 
189 
190  cl::Event evt_pixel_start_clustering;
191  cl::Event evt_pixel_end_clustering;
192  cl::Event evt_strip_start_clustering;
193  cl::Event evt_strip_end_clustering;
194  cl::Event evt_strip_l2g;
195  cl::Event evt_pixel_l2g;
196  cl::Event evt_edm_prep;
197  cl::Event evt_pixel_edm_prep;
198  cl::Event evt_strip_edm_prep;
199  {
200  Athena::Chrono chrono("Kernel execution", m_chronoSvc.get());
201  acc_queue.enqueueTask(pixelStartClusteringKernel, &evt_vec_pixel_input, &evt_pixel_start_clustering);
202  acc_queue.enqueueTask(pixelEndClusteringKernel, NULL , &evt_pixel_end_clustering);
203  acc_queue.enqueueTask(stripStartClusteringKernel, &evt_vec_strip_input, &evt_strip_start_clustering);
204  acc_queue.enqueueTask(stripEndClusteringKernel, NULL, &evt_strip_end_clustering);
205 
206  std::vector<cl::Event> evt_vec_pixel_clustering{evt_pixel_end_clustering};
207  std::vector<cl::Event> evt_vec_strip_clustering{evt_strip_end_clustering};
208 
209  acc_queue.enqueueTask(stripL2GKernel, &evt_vec_strip_clustering, &evt_strip_l2g);
210 
211  std::vector<cl::Event> evt_vec_strip_l2g{evt_strip_l2g};
212  acc_queue.enqueueTask(pixelEdmPrepKernel, &evt_vec_pixel_clustering, &evt_pixel_edm_prep);
213  acc_queue.enqueueTask(stripEdmPrepKernel, &evt_vec_strip_l2g, &evt_strip_edm_prep);
214 
215  }
216 
217  cl::Event evt_pixel_cluster_output;
218  cl::Event evt_strip_cluster_output;
219 
220  std::vector<cl::Event> evt_vec_pixel_edm_prep;
221  std::vector<cl::Event> evt_vec_strip_edm_prep;
222 
223  evt_vec_pixel_edm_prep.push_back(evt_pixel_edm_prep);
224  evt_vec_strip_edm_prep.push_back(evt_strip_edm_prep);
225 
226 
227  // output handles
228 
229  SG::WriteHandle<std::vector<uint64_t>> FPGAPixelOutput(m_FPGAPixelOutput, ctx);
230  ATH_CHECK(FPGAPixelOutput.record(std::make_unique<std::vector<uint64_t> >(EFTrackingTransient::PIXEL_CONTAINER_BUF_SIZE, 0)));
231 
232  SG::WriteHandle<std::vector<uint64_t>> FPGAStripOutput(m_FPGAStripOutput, ctx);
233  ATH_CHECK(FPGAStripOutput.record(std::make_unique<std::vector<uint64_t> >(EFTrackingTransient::STRIP_CONTAINER_BUF_SIZE, 0)));
234 
235  acc_queue.enqueueReadBuffer(m_edmPixelOutputBufferList[bufferIndex], CL_FALSE, 0, sizeof(uint64_t) * (*FPGAPixelOutput).size(), (*FPGAPixelOutput).data(), &evt_vec_pixel_edm_prep, &evt_pixel_cluster_output);
236  acc_queue.enqueueReadBuffer(m_edmStripOutputBufferList[bufferIndex], CL_FALSE, 0, sizeof(uint64_t) * (*FPGAStripOutput).size(), (*FPGAStripOutput).data(), &evt_vec_strip_edm_prep, &evt_strip_cluster_output);
237 
238  std::vector<cl::Event> wait_for_reads = { evt_pixel_cluster_output, evt_strip_cluster_output };
239  cl::Event::waitForEvents(wait_for_reads);
240 
241 
242  if(pixelInput->size() == 6) (*FPGAPixelOutput)[0] = 0; // if no pixel input, set the first element to 0
243  if(stripInput->size() == 6) (*FPGAStripOutput)[0] = 0; // if no strip input, set the first element to 0
244 
245 
246  // calculate the time for the kernel execution
247  // get the time of writing pixel input buffer
248  cl_ulong pixel_input_time = evt_write_pixel_input.getProfilingInfo<CL_PROFILING_COMMAND_END>() - evt_write_pixel_input.getProfilingInfo<CL_PROFILING_COMMAND_START>();
249  m_pixelInputTime += pixel_input_time;
250  ATH_MSG_DEBUG("Pixel input buffer write time: " << pixel_input_time / 1e6 << " ms");
251 
252  // get the time of writing strip input buffer
253  cl_ulong strip_input_time = evt_write_strip_input.getProfilingInfo<CL_PROFILING_COMMAND_END>() - evt_write_strip_input.getProfilingInfo<CL_PROFILING_COMMAND_START>();
254  m_stripInputTime += strip_input_time;
255  ATH_MSG_DEBUG("Strip input buffer write time: " << strip_input_time / 1e6 << " ms");
256 
257  // get the time of pixel clustering
258  cl_ulong pixel_clustering_time = evt_pixel_end_clustering.getProfilingInfo<CL_PROFILING_COMMAND_END>() - evt_pixel_start_clustering.getProfilingInfo<CL_PROFILING_COMMAND_START>();
259  m_pixelClusteringTime += pixel_clustering_time;
260  ATH_MSG_DEBUG("Pixel clustering time: " << pixel_clustering_time / 1e6 << " ms");
261 
262  // get the time of strip clustering
263  cl_ulong strip_clustering_time = evt_strip_end_clustering.getProfilingInfo<CL_PROFILING_COMMAND_END>() - evt_strip_start_clustering.getProfilingInfo<CL_PROFILING_COMMAND_START>();
264  m_stripClusteringTime += strip_clustering_time;
265  ATH_MSG_DEBUG("Strip clustering time: " << strip_clustering_time / 1e6 << " ms");
266 
267  // get the time of strip L2G
268  cl_ulong strip_l2g_time = evt_strip_l2g.getProfilingInfo<CL_PROFILING_COMMAND_END>() - evt_strip_l2g.getProfilingInfo<CL_PROFILING_COMMAND_START>();
269  m_stripL2GTime += strip_l2g_time;
270  ATH_MSG_DEBUG("Strip L2G time: " << strip_l2g_time / 1e6 << " ms");
271 
272  // get the time of EDMPrep
273  cl_ulong pixel_edm_prep_time = evt_pixel_edm_prep.getProfilingInfo<CL_PROFILING_COMMAND_END>() - evt_pixel_edm_prep.getProfilingInfo<CL_PROFILING_COMMAND_START>();
274  cl_ulong strip_edm_prep_time = evt_strip_edm_prep.getProfilingInfo<CL_PROFILING_COMMAND_END>() - evt_strip_edm_prep.getProfilingInfo<CL_PROFILING_COMMAND_START>();
275 
276  m_pixelEdmPrepTime += pixel_edm_prep_time;
277  ATH_MSG_DEBUG("PixelEDMPrep time: " << pixel_edm_prep_time / 1e6 << " ms");
278 
279  m_stripEdmPrepTime += strip_edm_prep_time;
280  ATH_MSG_DEBUG("StripEDMPrep time: " << strip_edm_prep_time / 1e6 << " ms");
281 
282 
283  // get the time of the whole kernel execution
284  cl_ulong kernel_start = evt_pixel_start_clustering.getProfilingInfo<CL_PROFILING_COMMAND_QUEUED>();
285  cl_ulong kernel_end = std::max(evt_pixel_edm_prep.getProfilingInfo<CL_PROFILING_COMMAND_END>(), evt_strip_edm_prep.getProfilingInfo<CL_PROFILING_COMMAND_END>());
286  m_kernelTime += (kernel_end - kernel_start);
287  ATH_MSG_DEBUG("Kernel execution time: " << (kernel_end - kernel_start) / 1e6 << " ms");
288 
289  // get the time of reading pixel output buffer
290  cl_ulong pixel_output_time = evt_pixel_cluster_output.getProfilingInfo<CL_PROFILING_COMMAND_END>() - evt_pixel_cluster_output.getProfilingInfo<CL_PROFILING_COMMAND_START>();
291  m_pixelOutputTime += pixel_output_time;
292  ATH_MSG_DEBUG("Pixel output buffer read time: " << pixel_output_time / 1e6 << " ms");
293 
294  // get the time of reading strip output buffer
295  cl_ulong strip_output_time = evt_strip_cluster_output.getProfilingInfo<CL_PROFILING_COMMAND_END>() - evt_strip_cluster_output.getProfilingInfo<CL_PROFILING_COMMAND_START>();
296  m_stripOutputTime += strip_output_time;
297  ATH_MSG_DEBUG("Strip output buffer read time: " << strip_output_time / 1e6 << " ms");
298 
299  return StatusCode::SUCCESS;
300  }
301 
302  StatusCode F110StreamIntegrationAlg::finalize()
303  {
304 
305  ATH_MSG_INFO("Finalizing F110StreamIntegrationAlg");
306  ATH_MSG_INFO("Number of events: " << m_numEvents);
307 
308  if(m_numEvents > 0){
309  ATH_MSG_INFO("Pixel input ave time: " << m_pixelInputTime / m_numEvents / 1e6 << " ms");
310  ATH_MSG_INFO("Strip input ave time: " << m_stripInputTime / m_numEvents / 1e6 << " ms");
311  ATH_MSG_INFO("Pixel clustering ave time: " << m_pixelClusteringTime / m_numEvents / 1e6 << " ms");
312  ATH_MSG_INFO("Strip clustering ave time: " << m_stripClusteringTime / m_numEvents / 1e6 << " ms");
313  ATH_MSG_INFO("Strip L2G ave time: " << m_stripL2GTime / m_numEvents / 1e6 << " ms");
314  ATH_MSG_INFO("PixelEDMPrep ave time: " << m_pixelEdmPrepTime / m_numEvents / 1e6 << " ms");
315  ATH_MSG_INFO("StripEDMPrep ave time: " << m_stripEdmPrepTime / m_numEvents / 1e6 << " ms");
316  ATH_MSG_INFO("Kernel execution ave time: " << m_kernelTime / m_numEvents / 1e6 << " ms");
317  ATH_MSG_INFO("Pixel output ave time: " << m_pixelOutputTime / m_numEvents / 1e6 << " ms");
318  ATH_MSG_INFO("Strip output ave time: " << m_stripOutputTime / m_numEvents / 1e6 << " ms");
319  }
320 
321  return StatusCode::SUCCESS;
322  }
323 
324  void F110StreamIntegrationAlg::getListofCUs(std::vector<std::string>& cuNames)
325  {
326  xrt::xclbin xrt_xclbin(m_xclbin.value());
327 
328  ATH_MSG_INFO("xsa name: "<<xrt_xclbin.get_xsa_name());
329  ATH_MSG_INFO("fpga name: "<<xrt_xclbin.get_fpga_device_name());
330  ATH_MSG_INFO("uuid: "<<xrt_xclbin.get_uuid().to_string());
331 
332  for (const xrt::xclbin::kernel &kernel : xrt_xclbin.get_kernels()) {
333  const std::string& kernelName = kernel.get_name();
334 
335  ATH_MSG_INFO("kernelName: "<<kernelName);
336 
337 
338  for (const xrt::xclbin::ip &computeUnit : kernel.get_cus()) {
339  const std::string& computeUnitName = computeUnit.get_name();
340  const std::string computeUnitIsolatedName = computeUnitName.substr(kernelName.size() + 1);
341 
342  const std::string computeUnitUsableName = kernelName + ":{" + computeUnitIsolatedName + "}";
343 
344  ATH_MSG_INFO("CU name: "<<computeUnitUsableName);
345  cuNames.push_back(computeUnitUsableName);
346  }
347  }
348  }
349 
350 } // namespace EFTrackingFPGAIntegration
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripClusterOutputBufferList
std::vector< cl::Buffer > m_stripClusterOutputBufferList
Definition: F110StreamIntegrationAlg.h:100
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_chronoSvc
ServiceHandle< IChronoSvc > m_chronoSvc
Service for timing the algorithm.
Definition: F110StreamIntegrationAlg.h:42
IntegrationBase::m_accelerator
cl::Device m_accelerator
Device object for the accelerator card.
Definition: IntegrationBase.h:66
IntegrationBase::initialize
virtual StatusCode initialize() override
Detect the OpenCL devices and prepare OpenCL context.
Definition: IntegrationBase.cxx:16
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_pixelStartClusterKernelName
Gaudi::Property< std::string > m_pixelStartClusterKernelName
Name of the pixel clustering kernel start.
Definition: F110StreamIntegrationAlg.h:59
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::initialize
virtual StatusCode initialize() override final
Detect the OpenCL devices and prepare OpenCL context.
Definition: F110StreamIntegrationAlg.cxx:15
EFTrackingTransient::PIXEL_CONTAINER_BUF_SIZE
constexpr unsigned long PIXEL_CONTAINER_BUF_SIZE
Definition: EFTrackingTransient.h:38
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_acc_queues
std::vector< cl::CommandQueue > m_acc_queues
Definition: F110StreamIntegrationAlg.h:111
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripL2GOutputBufferList
std::vector< cl::Buffer > m_stripL2GOutputBufferList
Definition: F110StreamIntegrationAlg.h:104
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_FPGAPixelRDO
SG::ReadHandleKey< std::vector< uint64_t > > m_FPGAPixelRDO
Definition: F110StreamIntegrationAlg.h:44
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_FPGAThreads
Gaudi::Property< int > m_FPGAThreads
Definition: F110StreamIntegrationAlg.h:50
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::finalize
virtual StatusCode finalize() override final
Definition: F110StreamIntegrationAlg.cxx:302
make_unique
std::unique_ptr< T > make_unique(Args &&... args)
Definition: SkimmingToolEXOT5.cxx:23
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripClusteringTime
std::atomic< cl_ulong > m_stripClusteringTime
Time for strip clustering.
Definition: F110StreamIntegrationAlg.h:74
JiveXML::Event
struct Event_t Event
Definition: ONCRPCServer.h:65
IntegrationBase::m_context
cl::Context m_context
Context object for the application.
Definition: IntegrationBase.h:67
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_pixelClusterInputBufferList
std::vector< cl::Buffer > m_pixelClusterInputBufferList
Definition: F110StreamIntegrationAlg.h:97
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_kernelTime
std::atomic< cl_ulong > m_kernelTime
Time for kernel execution.
Definition: F110StreamIntegrationAlg.h:80
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_pixelOutputTime
std::atomic< cl_ulong > m_pixelOutputTime
Time for pixel output buffer read.
Definition: F110StreamIntegrationAlg.h:78
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripL2GEDMOutputBufferList
std::vector< cl::Buffer > m_stripL2GEDMOutputBufferList
Definition: F110StreamIntegrationAlg.h:105
Chrono.h
Exception-safe IChronoSvc caller.
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_numEvents
std::atomic< ulonglong > m_numEvents
Number of events processed.
Definition: F110StreamIntegrationAlg.h:70
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripClusterInputBufferList
std::vector< cl::Buffer > m_stripClusterInputBufferList
Definition: F110StreamIntegrationAlg.h:98
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_xclbin
Gaudi::Property< std::string > m_xclbin
Path and name of the xclbin file.
Definition: F110StreamIntegrationAlg.h:52
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_pixelClusterEDMOutputBufferList
std::vector< cl::Buffer > m_pixelClusterEDMOutputBufferList
Definition: F110StreamIntegrationAlg.h:101
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_pixelClusteringTime
std::atomic< cl_ulong > m_pixelClusteringTime
Time for pixel clustering.
Definition: F110StreamIntegrationAlg.h:73
EFTrackingTransient::PIXEL_BLOCK_BUF_SIZE
constexpr unsigned long PIXEL_BLOCK_BUF_SIZE
Definition: EFTrackingTransient.h:36
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripStartClusterKernelName
Gaudi::Property< std::string > m_stripStartClusterKernelName
Name of the strip clustering kernel start.
Definition: F110StreamIntegrationAlg.h:62
EFTrackingTransient::STRIP_CONTAINER_BUF_SIZE
constexpr unsigned long STRIP_CONTAINER_BUF_SIZE
Definition: EFTrackingTransient.h:39
Athena::Chrono
Exception-safe IChronoSvc caller.
Definition: Chrono.h:50
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:183
lumiFormat.i
int i
Definition: lumiFormat.py:85
SG::get
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
Definition: ReadCondHandle.h:287
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
EFTrackingTransient::PIXEL_CONTAINER_INPUT_BUF_SIZE
constexpr unsigned long PIXEL_CONTAINER_INPUT_BUF_SIZE
Definition: EFTrackingTransient.h:47
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripClusterEDMOutputBufferList
std::vector< cl::Buffer > m_stripClusterEDMOutputBufferList
Definition: F110StreamIntegrationAlg.h:102
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_pixelEdmPrepTime
std::atomic< cl_ulong > m_pixelEdmPrepTime
Time for pixel EDM preparation.
Definition: F110StreamIntegrationAlg.h:76
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_FPGAPixelOutput
SG::WriteHandleKey< std::vector< uint64_t > > m_FPGAPixelOutput
Definition: F110StreamIntegrationAlg.h:47
IntegrationBase::precheck
StatusCode precheck(const std::vector< Gaudi::Property< std::string >> &inputs) const
Check if the the desired Gaudi properties are set.
Definition: IntegrationBase.cxx:154
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
EFTrackingFPGAIntegration
The class for enconding RDO to FPGA format.
Definition: BenchmarkAlg.h:28
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_pixelEndClusterKernelName
Gaudi::Property< std::string > m_pixelEndClusterKernelName
Name of the pixel clustering kernel start.
Definition: F110StreamIntegrationAlg.h:60
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_FPGAStripOutput
SG::WriteHandleKey< std::vector< uint64_t > > m_FPGAStripOutput
Definition: F110StreamIntegrationAlg.h:48
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripInputTime
std::atomic< cl_ulong > m_stripInputTime
Time for strip input buffer write.
Definition: F110StreamIntegrationAlg.h:72
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_pixelInputTime
std::atomic< cl_ulong > m_pixelInputTime
Time for pixel input buffer write.
Definition: F110StreamIntegrationAlg.h:71
IntegrationBase::loadProgram
StatusCode loadProgram(const std::string &xclbin)
Find the xclbin file and load it into the OpenCL program object.
Definition: IntegrationBase.cxx:115
EFTrackingTransient::STRIP_CONTAINER_INPUT_BUF_SIZE
constexpr unsigned long STRIP_CONTAINER_INPUT_BUF_SIZE
Definition: EFTrackingTransient.h:48
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripL2GTime
std::atomic< cl_ulong > m_stripL2GTime
Time for strip L2G.
Definition: F110StreamIntegrationAlg.h:75
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_edmPixelOutputBufferList
std::vector< cl::Buffer > m_edmPixelOutputBufferList
Definition: F110StreamIntegrationAlg.h:107
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripEdmPrepTime
std::atomic< cl_ulong > m_stripEdmPrepTime
Time for strip EDM preparation.
Definition: F110StreamIntegrationAlg.h:77
EFTrackingTransient::STRIP_BLOCK_BUF_SIZE
constexpr unsigned long STRIP_BLOCK_BUF_SIZE
Definition: EFTrackingTransient.h:37
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripL2GKernelName
Gaudi::Property< std::string > m_stripL2GKernelName
Name of the strip L2G kernelS.
Definition: F110StreamIntegrationAlg.h:66
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripEndClusterKernelName
Gaudi::Property< std::string > m_stripEndClusterKernelName
Name of the strip clustering kernel start.
Definition: F110StreamIntegrationAlg.h:63
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::execute
virtual StatusCode execute(const EventContext &ctx) const override final
Should be overriden by derived classes to perform meaningful work.
Definition: F110StreamIntegrationAlg.cxx:112
F110StreamIntegrationAlg.h
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_edmStripOutputBufferList
std::vector< cl::Buffer > m_edmStripOutputBufferList
Definition: F110StreamIntegrationAlg.h:108
SG::getNSlots
size_t getNSlots()
Return the number of event slots.
Definition: SlotSpecificObj.cxx:64
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_pixelEdmKernelName
Gaudi::Property< std::string > m_pixelEdmKernelName
Name of the FPGA kernel.
Definition: F110StreamIntegrationAlg.h:55
SlotSpecificObj.h
Maintain a set of objects, one per slot.
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripEdmKernelName
Gaudi::Property< std::string > m_stripEdmKernelName
Name of the FPGA kernel.
Definition: F110StreamIntegrationAlg.h:57
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_stripOutputTime
std::atomic< cl_ulong > m_stripOutputTime
Time for strip output buffer read.
Definition: F110StreamIntegrationAlg.h:79
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::getListofCUs
void getListofCUs(std::vector< std::string > &cuNames)
Definition: F110StreamIntegrationAlg.cxx:324
EFTrackingFPGAIntegration::F110StreamIntegrationAlg::m_FPGAStripRDO
SG::ReadHandleKey< std::vector< uint64_t > > m_FPGAStripRDO
Definition: F110StreamIntegrationAlg.h:45
IntegrationBase::m_program
cl::Program m_program
Program object containing the kernel.
Definition: IntegrationBase.h:68
Generated on Sun Oct 26 2025 21:10:00 for ATLAS Offline Software by   doxygen 1.8.18