446 lines · cpp
1//===- OmptCallbackHandler.cpp - OMPT Callback handling impl. ---*- C++ -*-===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8///9/// \file10/// This file contains the OMPT callback handling implementations.11///12//===----------------------------------------------------------------------===//13 14#include "OmptCallbackHandler.h"15 16using namespace omptest;17 18OmptCallbackHandler *Handler = nullptr;19 20OmptCallbackHandler &OmptCallbackHandler::get() {21 if (Handler == nullptr)22 Handler = new OmptCallbackHandler();23 24 return *Handler;25}26 27void OmptCallbackHandler::subscribe(OmptListener *Listener) {28 Subscribers.push_back(Listener);29}30 31void OmptCallbackHandler::clearSubscribers() {32 replay();33 34 Subscribers.clear();35}36 37void OmptCallbackHandler::replay() {38 if (!RecordAndReplay)39 return;40 41 for (auto &E : RecordedEvents)42 for (const auto &S : Subscribers)43 S->notify(std::move(E));44}45 46void OmptCallbackHandler::handleThreadBegin(ompt_thread_t ThreadType,47 ompt_data_t *ThreadData) {48 if (RecordAndReplay) {49 recordEvent(OmptAssertEvent::ThreadBegin(50 "Thread Begin", "", ObserveState::Generated, ThreadType));51 return;52 }53 54 // Initial thread event likely to preceed assertion registration, so skip55 if (ThreadType == ompt_thread_initial)56 return;57 for (const auto &S : Subscribers)58 S->notify(OmptAssertEvent::ThreadBegin(59 "Thread Begin", "", ObserveState::Generated, ThreadType));60}61 62void OmptCallbackHandler::handleThreadEnd(ompt_data_t *ThreadData) {63 if (RecordAndReplay) {64 recordEvent(65 OmptAssertEvent::ThreadEnd("Thread End", "", ObserveState::Generated));66 return;67 }68 69 for (const auto &S : Subscribers)70 S->notify(71 OmptAssertEvent::ThreadEnd("Thread End", "", ObserveState::Generated));72}73 74void OmptCallbackHandler::handleTaskCreate(75 ompt_data_t *EncounteringTaskData,76 const ompt_frame_t *EncounteringTaskFrame, ompt_data_t *NewTaskData,77 int Flags, int HasDependences, const void *CodeptrRA) {78 if (RecordAndReplay) {79 recordEvent(OmptAssertEvent::TaskCreate(80 "Task Create", "", ObserveState::Generated, EncounteringTaskData,81 EncounteringTaskFrame, NewTaskData, Flags, HasDependences, CodeptrRA));82 return;83 }84 85 for (const auto &S : Subscribers)86 S->notify(OmptAssertEvent::TaskCreate(87 "Task Create", "", ObserveState::Generated, EncounteringTaskData,88 EncounteringTaskFrame, NewTaskData, Flags, HasDependences, CodeptrRA));89}90 91void OmptCallbackHandler::handleTaskSchedule(ompt_data_t *PriorTaskData,92 ompt_task_status_t PriorTaskStatus,93 ompt_data_t *NextTaskData) {94 if (RecordAndReplay) {95 recordEvent(OmptAssertEvent::TaskSchedule("Task Schedule", "",96 ObserveState::Generated));97 return;98 }99 100 for (const auto &S : Subscribers)101 S->notify(OmptAssertEvent::TaskSchedule("Task Schedule", "",102 ObserveState::Generated));103}104 105void OmptCallbackHandler::handleImplicitTask(ompt_scope_endpoint_t Endpoint,106 ompt_data_t *ParallelData,107 ompt_data_t *TaskData,108 unsigned int ActualParallelism,109 unsigned int Index, int Flags) {110 if (RecordAndReplay) {111 recordEvent(OmptAssertEvent::ImplicitTask(112 "Implicit Task", "", ObserveState::Generated, Endpoint, ParallelData,113 TaskData, ActualParallelism, Index, Flags));114 return;115 }116 117 for (const auto &S : Subscribers)118 S->notify(OmptAssertEvent::ImplicitTask(119 "Implicit Task", "", ObserveState::Generated, Endpoint, ParallelData,120 TaskData, ActualParallelism, Index, Flags));121}122 123void OmptCallbackHandler::handleParallelBegin(124 ompt_data_t *EncounteringTaskData,125 const ompt_frame_t *EncounteringTaskFrame, ompt_data_t *ParallelData,126 unsigned int RequestedParallelism, int Flags, const void *CodeptrRA) {127 if (RecordAndReplay) {128 recordEvent(OmptAssertEvent::ParallelBegin(129 "Parallel Begin", "", ObserveState::Generated, RequestedParallelism));130 return;131 }132 133 for (const auto &S : Subscribers)134 S->notify(OmptAssertEvent::ParallelBegin(135 "Parallel Begin", "", ObserveState::Generated, RequestedParallelism));136}137 138void OmptCallbackHandler::handleParallelEnd(ompt_data_t *ParallelData,139 ompt_data_t *EncounteringTaskData,140 int Flags, const void *CodeptrRA) {141 if (RecordAndReplay) {142 recordEvent(OmptAssertEvent::ParallelEnd("Parallel End", "",143 ObserveState::Generated));144 return;145 }146 147 for (const auto &S : Subscribers)148 S->notify(OmptAssertEvent::ParallelEnd("Parallel End", "",149 ObserveState::Generated));150}151 152void OmptCallbackHandler::handleDeviceInitialize(153 int DeviceNum, const char *Type, ompt_device_t *Device,154 ompt_function_lookup_t LookupFn, const char *DocumentationStr) {155 if (RecordAndReplay) {156 recordEvent(OmptAssertEvent::DeviceInitialize(157 "Device Inititalize", "", ObserveState::Generated, DeviceNum, Type,158 Device, LookupFn, DocumentationStr));159 return;160 }161 162 for (const auto &S : Subscribers)163 S->notify(OmptAssertEvent::DeviceInitialize(164 "Device Inititalize", "", ObserveState::Generated, DeviceNum, Type,165 Device, LookupFn, DocumentationStr));166}167 168void OmptCallbackHandler::handleDeviceFinalize(int DeviceNum) {169 if (RecordAndReplay) {170 recordEvent(OmptAssertEvent::DeviceFinalize(171 "Device Finalize", "", ObserveState::Generated, DeviceNum));172 return;173 }174 175 for (const auto &S : Subscribers)176 S->notify(OmptAssertEvent::DeviceFinalize(177 "Device Finalize", "", ObserveState::Generated, DeviceNum));178}179 180void OmptCallbackHandler::handleTarget(ompt_target_t Kind,181 ompt_scope_endpoint_t Endpoint,182 int DeviceNum, ompt_data_t *TaskData,183 ompt_id_t TargetId,184 const void *CodeptrRA) {185 if (RecordAndReplay) {186 recordEvent(OmptAssertEvent::Target("Target", "", ObserveState::Generated,187 Kind, Endpoint, DeviceNum, TaskData,188 TargetId, CodeptrRA));189 return;190 }191 192 for (const auto &S : Subscribers)193 S->notify(OmptAssertEvent::Target("Target", "", ObserveState::Generated,194 Kind, Endpoint, DeviceNum, TaskData,195 TargetId, CodeptrRA));196}197 198void OmptCallbackHandler::handleTargetEmi(ompt_target_t Kind,199 ompt_scope_endpoint_t Endpoint,200 int DeviceNum, ompt_data_t *TaskData,201 ompt_data_t *TargetTaskData,202 ompt_data_t *TargetData,203 const void *CodeptrRA) {204 if (RecordAndReplay) {205 recordEvent(OmptAssertEvent::TargetEmi(206 "Target EMI", "", ObserveState::Generated, Kind, Endpoint, DeviceNum,207 TaskData, TargetTaskData, TargetData, CodeptrRA));208 return;209 }210 211 for (const auto &S : Subscribers)212 S->notify(OmptAssertEvent::TargetEmi(213 "Target EMI", "", ObserveState::Generated, Kind, Endpoint, DeviceNum,214 TaskData, TargetTaskData, TargetData, CodeptrRA));215}216 217void OmptCallbackHandler::handleTargetSubmit(ompt_id_t TargetId,218 ompt_id_t HostOpId,219 unsigned int RequestedNumTeams) {220 if (RecordAndReplay) {221 recordEvent(OmptAssertEvent::TargetSubmit("Target Submit", "",222 ObserveState::Generated, TargetId,223 HostOpId, RequestedNumTeams));224 return;225 }226 227 for (const auto &S : Subscribers)228 S->notify(OmptAssertEvent::TargetSubmit("Target Submit", "",229 ObserveState::Generated, TargetId,230 HostOpId, RequestedNumTeams));231}232 233void OmptCallbackHandler::handleTargetSubmitEmi(234 ompt_scope_endpoint_t Endpoint, ompt_data_t *TargetData,235 ompt_id_t *HostOpId, unsigned int RequestedNumTeams) {236 if (RecordAndReplay) {237 recordEvent(OmptAssertEvent::TargetSubmitEmi(238 "Target Submit EMI", "", ObserveState::Generated, Endpoint, TargetData,239 HostOpId, RequestedNumTeams));240 return;241 }242 243 for (const auto &S : Subscribers)244 S->notify(OmptAssertEvent::TargetSubmitEmi(245 "Target Submit EMI", "", ObserveState::Generated, Endpoint, TargetData,246 HostOpId, RequestedNumTeams));247}248 249void OmptCallbackHandler::handleTargetDataOp(250 ompt_id_t TargetId, ompt_id_t HostOpId, ompt_target_data_op_t OpType,251 void *SrcAddr, int SrcDeviceNum, void *DstAddr, int DstDeviceNum,252 size_t Bytes, const void *CodeptrRA) {253 if (RecordAndReplay) {254 recordEvent(OmptAssertEvent::TargetDataOp(255 "Target Data Op", "", ObserveState::Generated, TargetId, HostOpId,256 OpType, SrcAddr, SrcDeviceNum, DstAddr, DstDeviceNum, Bytes,257 CodeptrRA));258 return;259 }260 261 for (const auto &S : Subscribers)262 S->notify(OmptAssertEvent::TargetDataOp(263 "Target Data Op", "", ObserveState::Generated, TargetId, HostOpId,264 OpType, SrcAddr, SrcDeviceNum, DstAddr, DstDeviceNum, Bytes,265 CodeptrRA));266}267 268void OmptCallbackHandler::handleTargetDataOpEmi(269 ompt_scope_endpoint_t Endpoint, ompt_data_t *TargetTaskData,270 ompt_data_t *TargetData, ompt_id_t *HostOpId, ompt_target_data_op_t OpType,271 void *SrcAddr, int SrcDeviceNum, void *DstAddr, int DstDeviceNum,272 size_t Bytes, const void *CodeptrRA) {273 if (RecordAndReplay) {274 recordEvent(OmptAssertEvent::TargetDataOpEmi(275 "Target Data Op EMI", "", ObserveState::Generated, Endpoint,276 TargetTaskData, TargetData, HostOpId, OpType, SrcAddr, SrcDeviceNum,277 DstAddr, DstDeviceNum, Bytes, CodeptrRA));278 return;279 }280 281 for (const auto &S : Subscribers)282 S->notify(OmptAssertEvent::TargetDataOpEmi(283 "Target Data Op EMI", "", ObserveState::Generated, Endpoint,284 TargetTaskData, TargetData, HostOpId, OpType, SrcAddr, SrcDeviceNum,285 DstAddr, DstDeviceNum, Bytes, CodeptrRA));286}287 288void OmptCallbackHandler::handleDeviceLoad(int DeviceNum, const char *Filename,289 int64_t OffsetInFile,290 void *VmaInFile, size_t Bytes,291 void *HostAddr, void *DeviceAddr,292 uint64_t ModuleId) {293 if (RecordAndReplay) {294 recordEvent(OmptAssertEvent::DeviceLoad(295 "Device Load", "", ObserveState::Generated, DeviceNum, Filename,296 OffsetInFile, VmaInFile, Bytes, HostAddr, DeviceAddr, ModuleId));297 return;298 }299 300 for (const auto &S : Subscribers)301 S->notify(OmptAssertEvent::DeviceLoad(302 "Device Load", "", ObserveState::Generated, DeviceNum, Filename,303 OffsetInFile, VmaInFile, Bytes, HostAddr, DeviceAddr, ModuleId));304}305 306void OmptCallbackHandler::handleDeviceUnload(int DeviceNum, uint64_t ModuleId) {307 if (RecordAndReplay) {308 recordEvent(OmptAssertEvent::DeviceUnload("Device Unload", "",309 ObserveState::Generated));310 return;311 }312 313 for (const auto &S : Subscribers)314 S->notify(OmptAssertEvent::DeviceUnload("Device Unload", "",315 ObserveState::Generated));316}317 318void OmptCallbackHandler::handleBufferRequest(int DeviceNum,319 ompt_buffer_t **Buffer,320 size_t *Bytes) {321 if (RecordAndReplay) {322 recordEvent(OmptAssertEvent::BufferRequest("Buffer Request", "",323 ObserveState::Generated,324 DeviceNum, Buffer, Bytes));325 return;326 }327 328 for (const auto &S : Subscribers)329 S->notify(OmptAssertEvent::BufferRequest("Buffer Request", "",330 ObserveState::Generated, DeviceNum,331 Buffer, Bytes));332}333 334void OmptCallbackHandler::handleBufferComplete(int DeviceNum,335 ompt_buffer_t *Buffer,336 size_t Bytes,337 ompt_buffer_cursor_t Begin,338 int BufferOwned) {339 if (RecordAndReplay) {340 recordEvent(OmptAssertEvent::BufferComplete(341 "Buffer Complete", "", ObserveState::Generated, DeviceNum, Buffer,342 Bytes, Begin, BufferOwned));343 return;344 }345 346 for (const auto &S : Subscribers)347 S->notify(OmptAssertEvent::BufferComplete(348 "Buffer Complete", "", ObserveState::Generated, DeviceNum, Buffer,349 Bytes, Begin, BufferOwned));350}351 352void OmptCallbackHandler::handleBufferRecord(ompt_record_ompt_t *Record) {353 if (RecordAndReplay) {354 recordEvent(OmptAssertEvent::BufferRecord("Buffer Record", "",355 ObserveState::Generated, Record));356 return;357 }358 359 for (const auto &S : Subscribers)360 S->notify(OmptAssertEvent::BufferRecord("Buffer Record", "",361 ObserveState::Generated, Record));362}363 364void OmptCallbackHandler::handleBufferRecordDeallocation(365 ompt_buffer_t *Buffer) {366 if (RecordAndReplay) {367 recordEvent(OmptAssertEvent::BufferRecordDeallocation(368 "Buffer Deallocation", "", ObserveState::Generated, Buffer));369 return;370 }371 372 for (const auto &S : Subscribers)373 S->notify(OmptAssertEvent::BufferRecordDeallocation(374 "Buffer Deallocation", "", ObserveState::Generated, Buffer));375}376 377void OmptCallbackHandler::handleWork(ompt_work_t WorkType,378 ompt_scope_endpoint_t Endpoint,379 ompt_data_t *ParallelData,380 ompt_data_t *TaskData, uint64_t Count,381 const void *CodeptrRA) {382 if (RecordAndReplay) {383 recordEvent(OmptAssertEvent::Work("Work", "", ObserveState::Generated,384 WorkType, Endpoint, ParallelData,385 TaskData, Count, CodeptrRA));386 return;387 }388 389 for (const auto &S : Subscribers)390 S->notify(OmptAssertEvent::Work("Work", "", ObserveState::Generated,391 WorkType, Endpoint, ParallelData, TaskData,392 Count, CodeptrRA));393}394 395void OmptCallbackHandler::handleSyncRegion(ompt_sync_region_t Kind,396 ompt_scope_endpoint_t Endpoint,397 ompt_data_t *ParallelData,398 ompt_data_t *TaskData,399 const void *CodeptrRA) {400 if (RecordAndReplay) {401 recordEvent(OmptAssertEvent::SyncRegion(402 "SyncRegion", "", ObserveState::Generated, Kind, Endpoint, ParallelData,403 TaskData, CodeptrRA));404 return;405 }406 407 for (const auto &S : Subscribers)408 S->notify(OmptAssertEvent::SyncRegion(409 "SyncRegion", "", ObserveState::Generated, Kind, Endpoint, ParallelData,410 TaskData, CodeptrRA));411}412 413void OmptCallbackHandler::handleDispatch(ompt_data_t *ParallelData,414 ompt_data_t *TaskData,415 ompt_dispatch_t Kind,416 ompt_data_t Instance) {417 if (RecordAndReplay) {418 recordEvent(OmptAssertEvent::Dispatch("Dispatch", "",419 ObserveState::Generated, ParallelData,420 TaskData, Kind, Instance));421 return;422 }423 424 for (const auto &S : Subscribers)425 S->notify(OmptAssertEvent::Dispatch("Dispatch", "", ObserveState::Generated,426 ParallelData, TaskData, Kind,427 Instance));428}429 430void OmptCallbackHandler::handleAssertionSyncPoint(431 const std::string &SyncPointName) {432 if (RecordAndReplay) {433 recordEvent(OmptAssertEvent::AssertionSyncPoint(434 "Assertion SyncPoint", "", ObserveState::Generated, SyncPointName));435 return;436 }437 438 for (const auto &S : Subscribers)439 S->notify(OmptAssertEvent::AssertionSyncPoint(440 "Assertion SyncPoint", "", ObserveState::Generated, SyncPointName));441}442 443void OmptCallbackHandler::recordEvent(OmptAssertEvent &&Event) {444 RecordedEvents.emplace_back(std::forward<OmptAssertEvent>(Event));445}446