LLVM OpenMP 22.0.0git
InternalEventOperators.cpp
Go to the documentation of this file.
1//===- InternalEventOperators.cpp - Operator implementations ----*- 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-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// Defines the internal event operators, like comparators.
11///
12//===----------------------------------------------------------------------===//
13
14#include "InternalEvent.h"
15
16namespace omptest {
17
18namespace internal {
19
20bool operator==(const ParallelBegin &Expected, const ParallelBegin &Observed) {
21 return Expected.NumThreads == Observed.NumThreads;
22}
23
24bool operator==(const Work &Expected, const Work &Observed) {
25 bool isSameWorkType = (Expected.WorkType == Observed.WorkType);
26 bool isSameEndpoint = (Expected.Endpoint == Observed.Endpoint);
27 bool isSameParallelData =
28 (Expected.ParallelData == std::numeric_limits<ompt_data_t *>::min()) ||
29 (Expected.ParallelData == Observed.ParallelData);
30 bool isSameTaskData =
31 (Expected.TaskData == std::numeric_limits<ompt_data_t *>::min()) ||
32 (Expected.TaskData == Observed.TaskData);
33 bool isSameCount = (Expected.Count == std::numeric_limits<uint64_t>::min()) ||
34 (Expected.Count == Observed.Count);
35 return isSameWorkType && isSameEndpoint && isSameParallelData &&
36 isSameTaskData && isSameCount;
37}
38
39bool operator==(const ImplicitTask &Expected, const ImplicitTask &Observed) {
40 bool isSameEndpoint = (Expected.Endpoint == Observed.Endpoint);
41 bool isSameActualParallelism =
42 (Expected.ActualParallelism ==
43 std::numeric_limits<unsigned int>::min()) ||
44 (Expected.ActualParallelism == Observed.ActualParallelism);
45 bool isSameIndex =
46 (Expected.Index == std::numeric_limits<unsigned int>::min()) ||
47 (Expected.Index == Observed.Index);
48 return isSameEndpoint && isSameActualParallelism && isSameIndex;
49}
50
51bool operator==(const SyncRegion &Expected, const SyncRegion &Observed) {
52 bool isSameKind = (Expected.Kind == Observed.Kind);
53 bool isSameEndpoint = (Expected.Endpoint == Observed.Endpoint);
54 bool isSameParallelData =
55 (Expected.ParallelData == std::numeric_limits<ompt_data_t *>::min()) ||
56 (Expected.ParallelData == Observed.ParallelData);
57 bool isSameTaskData =
58 (Expected.TaskData == std::numeric_limits<ompt_data_t *>::min()) ||
59 (Expected.TaskData == Observed.TaskData);
60 return isSameKind && isSameEndpoint && isSameParallelData && isSameTaskData;
61}
62
63bool operator==(const Target &Expected, const Target &Observed) {
64 bool isSameKind = (Expected.Kind == Observed.Kind);
65 bool isSameEndpoint = (Expected.Endpoint == Observed.Endpoint);
66 bool isSameDeviceNum =
67 (Expected.DeviceNum == std::numeric_limits<int>::min()) ||
68 (Expected.DeviceNum == Observed.DeviceNum);
69 return isSameKind && isSameEndpoint && isSameDeviceNum;
70}
71
72bool operator==(const TargetEmi &Expected, const TargetEmi &Observed) {
73 bool isSameKind = (Expected.Kind == Observed.Kind);
74 bool isSameEndpoint = (Expected.Endpoint == Observed.Endpoint);
75 bool isSameDeviceNum =
76 (Expected.DeviceNum == std::numeric_limits<int>::min()) ||
77 (Expected.DeviceNum == Observed.DeviceNum);
78 return isSameKind && isSameEndpoint && isSameDeviceNum;
79}
80
81bool operator==(const TargetDataOp &Expected, const TargetDataOp &Observed) {
82 bool isSameOpType = (Expected.OpType == Observed.OpType);
83 bool isSameSize = (Expected.Bytes == std::numeric_limits<size_t>::min()) ||
84 (Expected.Bytes == Observed.Bytes);
85 bool isSameSrcAddr =
86 (Expected.SrcAddr == std::numeric_limits<void *>::min()) ||
87 (Expected.SrcAddr == Observed.SrcAddr);
88 bool isSameDstAddr =
89 (Expected.DstAddr == std::numeric_limits<void *>::min()) ||
90 (Expected.DstAddr == Observed.DstAddr);
91 bool isSameSrcDeviceNum =
92 (Expected.SrcDeviceNum == std::numeric_limits<int>::min()) ||
93 (Expected.SrcDeviceNum == Observed.SrcDeviceNum);
94 bool isSameDstDeviceNum =
95 (Expected.DstDeviceNum == std::numeric_limits<int>::min()) ||
96 (Expected.DstDeviceNum == Observed.DstDeviceNum);
97 return isSameOpType && isSameSize && isSameSrcAddr && isSameDstAddr &&
98 isSameSrcDeviceNum && isSameDstDeviceNum;
99}
100
101bool operator==(const TargetDataOpEmi &Expected,
102 const TargetDataOpEmi &Observed) {
103 bool isSameOpType = (Expected.OpType == Observed.OpType);
104 bool isSameEndpoint = (Expected.Endpoint == Observed.Endpoint);
105 bool isSameSize = (Expected.Bytes == std::numeric_limits<size_t>::min()) ||
106 (Expected.Bytes == Observed.Bytes);
107 bool isSameSrcAddr =
108 (Expected.SrcAddr == std::numeric_limits<void *>::min()) ||
109 (Expected.SrcAddr == Observed.SrcAddr);
110 bool isSameDstAddr =
111 (Expected.DstAddr == std::numeric_limits<void *>::min()) ||
112 (Expected.DstAddr == Observed.DstAddr);
113 bool isSameSrcDeviceNum =
114 (Expected.SrcDeviceNum == std::numeric_limits<int>::min()) ||
115 (Expected.SrcDeviceNum == Observed.SrcDeviceNum);
116 bool isSameDstDeviceNum =
117 (Expected.DstDeviceNum == std::numeric_limits<int>::min()) ||
118 (Expected.DstDeviceNum == Observed.DstDeviceNum);
119 return isSameOpType && isSameEndpoint && isSameSize && isSameSrcAddr &&
120 isSameDstAddr && isSameSrcDeviceNum && isSameDstDeviceNum;
121}
122
123bool operator==(const TargetSubmit &Expected, const TargetSubmit &Observed) {
124 bool isSameReqNumTeams =
125 (Expected.RequestedNumTeams == Observed.RequestedNumTeams);
126 return isSameReqNumTeams;
127}
128
129bool operator==(const TargetSubmitEmi &Expected,
130 const TargetSubmitEmi &Observed) {
131 bool isSameReqNumTeams =
132 (Expected.RequestedNumTeams == Observed.RequestedNumTeams);
133 bool isSameEndpoint = (Expected.Endpoint == Observed.Endpoint);
134 return isSameReqNumTeams && isSameEndpoint;
135}
136
137bool operator==(const DeviceInitialize &Expected,
138 const DeviceInitialize &Observed) {
139 bool isSameDeviceNum = (Expected.DeviceNum == Observed.DeviceNum);
140 bool isSameType =
141 (Expected.Type == std::numeric_limits<const char *>::min()) ||
142 ((Expected.Type == Observed.Type) ||
143 (strcmp(Expected.Type, Observed.Type) == 0));
144 bool isSameDevice =
145 (Expected.Device == std::numeric_limits<ompt_device_t *>::min()) ||
146 (Expected.Device == Observed.Device);
147 return isSameDeviceNum && isSameType && isSameDevice;
148}
149
150bool operator==(const DeviceFinalize &Expected,
151 const DeviceFinalize &Observed) {
152 bool isSameDeviceNum =
153 (Expected.DeviceNum == std::numeric_limits<int>::min()) ||
154 (Expected.DeviceNum == Observed.DeviceNum);
155 return isSameDeviceNum;
156}
157
158bool operator==(const DeviceLoad &Expected, const DeviceLoad &Observed) {
159 bool isSameDeviceNum =
160 (Expected.DeviceNum == std::numeric_limits<int>::min()) ||
161 (Expected.DeviceNum == Observed.DeviceNum);
162 bool isSameSize = (Expected.Bytes == std::numeric_limits<size_t>::min()) ||
163 (Expected.Bytes == Observed.Bytes);
164 return isSameDeviceNum && isSameSize;
165}
166
167bool operator==(const BufferRequest &Expected, const BufferRequest &Observed) {
168 bool isSameDeviceNum =
169 (Expected.DeviceNum == std::numeric_limits<int>::min()) ||
170 (Expected.DeviceNum == Observed.DeviceNum);
171 bool isSameSize = (Expected.Bytes == std::numeric_limits<size_t *>::min()) ||
172 (Expected.Bytes == Observed.Bytes);
173 return isSameDeviceNum && isSameSize;
174}
175
176bool operator==(const BufferComplete &Expected,
177 const BufferComplete &Observed) {
178 bool isSameDeviceNum =
179 (Expected.DeviceNum == std::numeric_limits<int>::min()) ||
180 (Expected.DeviceNum == Observed.DeviceNum);
181 bool isSameSize = (Expected.Bytes == std::numeric_limits<size_t>::min()) ||
182 (Expected.Bytes == Observed.Bytes);
183 return isSameDeviceNum && isSameSize;
184}
185
186bool operator==(const BufferRecord &Expected, const BufferRecord &Observed) {
187 bool isSameType = (Expected.Record.type == Observed.Record.type);
188 bool isSameTargetId =
189 (Expected.Record.target_id == std::numeric_limits<ompt_id_t>::min()) ||
190 (Expected.Record.target_id == Observed.Record.target_id);
191 if (!(isSameType && isSameTargetId))
192 return false;
193 bool isEqual = true;
194 ompt_device_time_t ObservedDurationNs =
195 Observed.Record.record.target_data_op.end_time - Observed.Record.time;
196 switch (Expected.Record.type) {
197 case ompt_callback_target:
198 isEqual &= (Expected.Record.record.target.kind ==
199 std::numeric_limits<ompt_target_t>::min()) ||
200 (Expected.Record.record.target.kind ==
201 Observed.Record.record.target.kind);
202 isEqual &= (Expected.Record.record.target.endpoint ==
203 std::numeric_limits<ompt_scope_endpoint_t>::min()) ||
204 (Expected.Record.record.target.endpoint ==
205 Observed.Record.record.target.endpoint);
206 isEqual &= (Expected.Record.record.target.device_num ==
207 std::numeric_limits<int>::min()) ||
208 (Expected.Record.record.target.device_num ==
209 Observed.Record.record.target.device_num);
210 break;
211 case ompt_callback_target_data_op:
212 isEqual &= (Expected.Record.record.target_data_op.optype ==
213 std::numeric_limits<ompt_target_data_op_t>::min()) ||
214 (Expected.Record.record.target_data_op.optype ==
215 Observed.Record.record.target_data_op.optype);
216 isEqual &= (Expected.Record.record.target_data_op.bytes ==
217 std::numeric_limits<size_t>::min()) ||
218 (Expected.Record.record.target_data_op.bytes ==
219 Observed.Record.record.target_data_op.bytes);
220 isEqual &= (Expected.Record.record.target_data_op.src_addr ==
221 std::numeric_limits<void *>::min()) ||
222 (Expected.Record.record.target_data_op.src_addr ==
223 Observed.Record.record.target_data_op.src_addr);
224 isEqual &= (Expected.Record.record.target_data_op.dest_addr ==
225 std::numeric_limits<void *>::min()) ||
226 (Expected.Record.record.target_data_op.dest_addr ==
227 Observed.Record.record.target_data_op.dest_addr);
228 isEqual &= (Expected.Record.record.target_data_op.src_device_num ==
229 std::numeric_limits<int>::min()) ||
230 (Expected.Record.record.target_data_op.src_device_num ==
231 Observed.Record.record.target_data_op.src_device_num);
232 isEqual &= (Expected.Record.record.target_data_op.dest_device_num ==
233 std::numeric_limits<int>::min()) ||
234 (Expected.Record.record.target_data_op.dest_device_num ==
235 Observed.Record.record.target_data_op.dest_device_num);
236 isEqual &= (Expected.Record.record.target_data_op.host_op_id ==
237 std::numeric_limits<ompt_id_t>::min()) ||
238 (Expected.Record.record.target_data_op.host_op_id ==
239 Observed.Record.record.target_data_op.host_op_id);
240 isEqual &= (Expected.Record.record.target_data_op.codeptr_ra ==
241 std::numeric_limits<void *>::min()) ||
242 (Expected.Record.record.target_data_op.codeptr_ra ==
243 Observed.Record.record.target_data_op.codeptr_ra);
244 if (Expected.Record.record.target_data_op.end_time !=
245 std::numeric_limits<ompt_device_time_t>::min()) {
246 isEqual &=
247 ObservedDurationNs <= Expected.Record.record.target_data_op.end_time;
248 }
249 isEqual &= ObservedDurationNs >= Expected.Record.time;
250 break;
251 case ompt_callback_target_submit:
252 ObservedDurationNs =
253 Observed.Record.record.target_kernel.end_time - Observed.Record.time;
254 isEqual &= (Expected.Record.record.target_kernel.requested_num_teams ==
255 std::numeric_limits<unsigned int>::min()) ||
256 (Expected.Record.record.target_kernel.requested_num_teams ==
257 Observed.Record.record.target_kernel.requested_num_teams);
258 isEqual &= (Expected.Record.record.target_kernel.granted_num_teams ==
259 std::numeric_limits<unsigned int>::min()) ||
260 (Expected.Record.record.target_kernel.granted_num_teams ==
261 Observed.Record.record.target_kernel.granted_num_teams);
262 isEqual &= (Expected.Record.record.target_kernel.host_op_id ==
263 std::numeric_limits<ompt_id_t>::min()) ||
264 (Expected.Record.record.target_kernel.host_op_id ==
265 Observed.Record.record.target_kernel.host_op_id);
266 if (Expected.Record.record.target_kernel.end_time !=
267 std::numeric_limits<ompt_device_time_t>::min()) {
268 isEqual &=
269 ObservedDurationNs <= Expected.Record.record.target_kernel.end_time;
270 }
271 isEqual &= ObservedDurationNs >= Expected.Record.time;
272 break;
273 default:
274 assert(false && "Encountered invalid record type");
275 }
276 return isEqual;
277}
278
279} // namespace internal
280
281} // namespace omptest
Declares internal event representations along the default CTOR definition.
bool operator==(const ParallelBegin &, const ParallelBegin &)
ompt_scope_endpoint_t Endpoint
ompt_scope_endpoint_t Endpoint
ompt_scope_endpoint_t Endpoint
ompt_target_data_op_t OpType
ompt_scope_endpoint_t Endpoint
ompt_scope_endpoint_t Endpoint
ompt_scope_endpoint_t Endpoint
ompt_data_t * ParallelData
Definition: InternalEvent.h:86
ompt_data_t * TaskData
Definition: InternalEvent.h:87
ompt_scope_endpoint_t Endpoint
Definition: InternalEvent.h:85