]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - contrib/llvm-project/openmp/runtime/src/ompt-specific.cpp
MFC r355940:
[FreeBSD/FreeBSD.git] / contrib / llvm-project / openmp / runtime / src / ompt-specific.cpp
1 /*
2  * ompt-specific.cpp -- OMPT internal functions
3  */
4
5 //===----------------------------------------------------------------------===//
6 //
7 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
8 // See https://llvm.org/LICENSE.txt for license information.
9 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
10 //
11 //===----------------------------------------------------------------------===//
12
13 //******************************************************************************
14 // include files
15 //******************************************************************************
16
17 #include "kmp.h"
18 #include "ompt-specific.h"
19
20 #if KMP_OS_UNIX
21 #include <dlfcn.h>
22 #endif
23
24 #if KMP_OS_WINDOWS
25 #define THREAD_LOCAL __declspec(thread)
26 #else
27 #define THREAD_LOCAL __thread
28 #endif
29
30 #define OMPT_WEAK_ATTRIBUTE KMP_WEAK_ATTRIBUTE
31
32 //******************************************************************************
33 // macros
34 //******************************************************************************
35
36 #define LWT_FROM_TEAM(team) (team)->t.ompt_serialized_team_info
37
38 #define OMPT_THREAD_ID_BITS 16
39
40 //******************************************************************************
41 // private operations
42 //******************************************************************************
43
44 //----------------------------------------------------------
45 // traverse the team and task hierarchy
46 // note: __ompt_get_teaminfo and __ompt_get_task_info_object
47 //       traverse the hierarchy similarly and need to be
48 //       kept consistent
49 //----------------------------------------------------------
50
51 ompt_team_info_t *__ompt_get_teaminfo(int depth, int *size) {
52   kmp_info_t *thr = ompt_get_thread();
53
54   if (thr) {
55     kmp_team *team = thr->th.th_team;
56     if (team == NULL)
57       return NULL;
58
59     ompt_lw_taskteam_t *next_lwt = LWT_FROM_TEAM(team), *lwt = NULL;
60
61     while (depth > 0) {
62       // next lightweight team (if any)
63       if (lwt)
64         lwt = lwt->parent;
65
66       // next heavyweight team (if any) after
67       // lightweight teams are exhausted
68       if (!lwt && team) {
69         if (next_lwt) {
70           lwt = next_lwt;
71           next_lwt = NULL;
72         } else {
73           team = team->t.t_parent;
74           if (team) {
75             next_lwt = LWT_FROM_TEAM(team);
76           }
77         }
78       }
79
80       depth--;
81     }
82
83     if (lwt) {
84       // lightweight teams have one task
85       if (size)
86         *size = 1;
87
88       // return team info for lightweight team
89       return &lwt->ompt_team_info;
90     } else if (team) {
91       // extract size from heavyweight team
92       if (size)
93         *size = team->t.t_nproc;
94
95       // return team info for heavyweight team
96       return &team->t.ompt_team_info;
97     }
98   }
99
100   return NULL;
101 }
102
103 ompt_task_info_t *__ompt_get_task_info_object(int depth) {
104   ompt_task_info_t *info = NULL;
105   kmp_info_t *thr = ompt_get_thread();
106
107   if (thr) {
108     kmp_taskdata_t *taskdata = thr->th.th_current_task;
109     ompt_lw_taskteam_t *lwt = NULL,
110                        *next_lwt = LWT_FROM_TEAM(taskdata->td_team);
111
112     while (depth > 0) {
113       // next lightweight team (if any)
114       if (lwt)
115         lwt = lwt->parent;
116
117       // next heavyweight team (if any) after
118       // lightweight teams are exhausted
119       if (!lwt && taskdata) {
120         if (next_lwt) {
121           lwt = next_lwt;
122           next_lwt = NULL;
123         } else {
124           taskdata = taskdata->td_parent;
125           if (taskdata) {
126             next_lwt = LWT_FROM_TEAM(taskdata->td_team);
127           }
128         }
129       }
130       depth--;
131     }
132
133     if (lwt) {
134       info = &lwt->ompt_task_info;
135     } else if (taskdata) {
136       info = &taskdata->ompt_task_info;
137     }
138   }
139
140   return info;
141 }
142
143 ompt_task_info_t *__ompt_get_scheduling_taskinfo(int depth) {
144   ompt_task_info_t *info = NULL;
145   kmp_info_t *thr = ompt_get_thread();
146
147   if (thr) {
148     kmp_taskdata_t *taskdata = thr->th.th_current_task;
149
150     ompt_lw_taskteam_t *lwt = NULL,
151                        *next_lwt = LWT_FROM_TEAM(taskdata->td_team);
152
153     while (depth > 0) {
154       // next lightweight team (if any)
155       if (lwt)
156         lwt = lwt->parent;
157
158       // next heavyweight team (if any) after
159       // lightweight teams are exhausted
160       if (!lwt && taskdata) {
161         // first try scheduling parent (for explicit task scheduling)
162         if (taskdata->ompt_task_info.scheduling_parent) {
163           taskdata = taskdata->ompt_task_info.scheduling_parent;
164         } else if (next_lwt) {
165           lwt = next_lwt;
166           next_lwt = NULL;
167         } else {
168           // then go for implicit tasks
169           taskdata = taskdata->td_parent;
170           if (taskdata) {
171             next_lwt = LWT_FROM_TEAM(taskdata->td_team);
172           }
173         }
174       }
175       depth--;
176     }
177
178     if (lwt) {
179       info = &lwt->ompt_task_info;
180     } else if (taskdata) {
181       info = &taskdata->ompt_task_info;
182     }
183   }
184
185   return info;
186 }
187
188 //******************************************************************************
189 // interface operations
190 //******************************************************************************
191
192 //----------------------------------------------------------
193 // thread support
194 //----------------------------------------------------------
195
196 ompt_data_t *__ompt_get_thread_data_internal() {
197   if (__kmp_get_gtid() >= 0) {
198     kmp_info_t *thread = ompt_get_thread();
199     if (thread == NULL)
200       return NULL;
201     return &(thread->th.ompt_thread_info.thread_data);
202   }
203   return NULL;
204 }
205
206 //----------------------------------------------------------
207 // state support
208 //----------------------------------------------------------
209
210 void __ompt_thread_assign_wait_id(void *variable) {
211   kmp_info_t *ti = ompt_get_thread();
212
213   if (ti)
214     ti->th.ompt_thread_info.wait_id = (ompt_wait_id_t)(uintptr_t)variable;
215 }
216
217 int __ompt_get_state_internal(ompt_wait_id_t *omp_wait_id) {
218   kmp_info_t *ti = ompt_get_thread();
219
220   if (ti) {
221     if (omp_wait_id)
222       *omp_wait_id = ti->th.ompt_thread_info.wait_id;
223     return ti->th.ompt_thread_info.state;
224   }
225   return ompt_state_undefined;
226 }
227
228 //----------------------------------------------------------
229 // parallel region support
230 //----------------------------------------------------------
231
232 int __ompt_get_parallel_info_internal(int ancestor_level,
233                                       ompt_data_t **parallel_data,
234                                       int *team_size) {
235   if (__kmp_get_gtid() >= 0) {
236     ompt_team_info_t *info;
237     if (team_size) {
238       info = __ompt_get_teaminfo(ancestor_level, team_size);
239     } else {
240       info = __ompt_get_teaminfo(ancestor_level, NULL);
241     }
242     if (parallel_data) {
243       *parallel_data = info ? &(info->parallel_data) : NULL;
244     }
245     return info ? 2 : 0;
246   } else {
247     return 0;
248   }
249 }
250
251 //----------------------------------------------------------
252 // lightweight task team support
253 //----------------------------------------------------------
254
255 void __ompt_lw_taskteam_init(ompt_lw_taskteam_t *lwt, kmp_info_t *thr, int gtid,
256                              ompt_data_t *ompt_pid, void *codeptr) {
257   // initialize parallel_data with input, return address to parallel_data on
258   // exit
259   lwt->ompt_team_info.parallel_data = *ompt_pid;
260   lwt->ompt_team_info.master_return_address = codeptr;
261   lwt->ompt_task_info.task_data.value = 0;
262   lwt->ompt_task_info.frame.enter_frame = ompt_data_none;
263   lwt->ompt_task_info.frame.exit_frame = ompt_data_none;
264   lwt->ompt_task_info.scheduling_parent = NULL;
265   lwt->ompt_task_info.deps = NULL;
266   lwt->ompt_task_info.ndeps = 0;
267   lwt->heap = 0;
268   lwt->parent = 0;
269 }
270
271 void __ompt_lw_taskteam_link(ompt_lw_taskteam_t *lwt, kmp_info_t *thr,
272                              int on_heap) {
273   ompt_lw_taskteam_t *link_lwt = lwt;
274   if (thr->th.th_team->t.t_serialized >
275       1) { // we already have a team, so link the new team and swap values
276     if (on_heap) { // the lw_taskteam cannot stay on stack, allocate it on heap
277       link_lwt =
278           (ompt_lw_taskteam_t *)__kmp_allocate(sizeof(ompt_lw_taskteam_t));
279     }
280     link_lwt->heap = on_heap;
281
282     // would be swap in the (on_stack) case.
283     ompt_team_info_t tmp_team = lwt->ompt_team_info;
284     link_lwt->ompt_team_info = *OMPT_CUR_TEAM_INFO(thr);
285     *OMPT_CUR_TEAM_INFO(thr) = tmp_team;
286
287     ompt_task_info_t tmp_task = lwt->ompt_task_info;
288     link_lwt->ompt_task_info = *OMPT_CUR_TASK_INFO(thr);
289     *OMPT_CUR_TASK_INFO(thr) = tmp_task;
290
291     // link the taskteam into the list of taskteams:
292     ompt_lw_taskteam_t *my_parent =
293         thr->th.th_team->t.ompt_serialized_team_info;
294     link_lwt->parent = my_parent;
295     thr->th.th_team->t.ompt_serialized_team_info = link_lwt;
296   } else {
297     // this is the first serialized team, so we just store the values in the
298     // team and drop the taskteam-object
299     *OMPT_CUR_TEAM_INFO(thr) = lwt->ompt_team_info;
300     *OMPT_CUR_TASK_INFO(thr) = lwt->ompt_task_info;
301   }
302 }
303
304 void __ompt_lw_taskteam_unlink(kmp_info_t *thr) {
305   ompt_lw_taskteam_t *lwtask = thr->th.th_team->t.ompt_serialized_team_info;
306   if (lwtask) {
307     thr->th.th_team->t.ompt_serialized_team_info = lwtask->parent;
308
309     ompt_team_info_t tmp_team = lwtask->ompt_team_info;
310     lwtask->ompt_team_info = *OMPT_CUR_TEAM_INFO(thr);
311     *OMPT_CUR_TEAM_INFO(thr) = tmp_team;
312
313     ompt_task_info_t tmp_task = lwtask->ompt_task_info;
314     lwtask->ompt_task_info = *OMPT_CUR_TASK_INFO(thr);
315     *OMPT_CUR_TASK_INFO(thr) = tmp_task;
316
317     if (lwtask->heap) {
318       __kmp_free(lwtask);
319       lwtask = NULL;
320     }
321   }
322   //    return lwtask;
323 }
324
325 //----------------------------------------------------------
326 // task support
327 //----------------------------------------------------------
328
329 int __ompt_get_task_info_internal(int ancestor_level, int *type,
330                                   ompt_data_t **task_data,
331                                   ompt_frame_t **task_frame,
332                                   ompt_data_t **parallel_data,
333                                   int *thread_num) {
334   if (__kmp_get_gtid() < 0)
335     return 0;
336
337   if (ancestor_level < 0)
338     return 0;
339
340   // copied from __ompt_get_scheduling_taskinfo
341   ompt_task_info_t *info = NULL;
342   ompt_team_info_t *team_info = NULL;
343   kmp_info_t *thr = ompt_get_thread();
344   int level = ancestor_level;
345
346   if (thr) {
347     kmp_taskdata_t *taskdata = thr->th.th_current_task;
348     if (taskdata == NULL)
349       return 0;
350     kmp_team *team = thr->th.th_team, *prev_team = NULL;
351     if (team == NULL)
352       return 0;
353     ompt_lw_taskteam_t *lwt = NULL,
354                        *next_lwt = LWT_FROM_TEAM(taskdata->td_team),
355                        *prev_lwt = NULL;
356
357     while (ancestor_level > 0) {
358       // needed for thread_num
359       prev_team = team;
360       prev_lwt = lwt;
361       // next lightweight team (if any)
362       if (lwt)
363         lwt = lwt->parent;
364
365       // next heavyweight team (if any) after
366       // lightweight teams are exhausted
367       if (!lwt && taskdata) {
368         // first try scheduling parent (for explicit task scheduling)
369         if (taskdata->ompt_task_info.scheduling_parent) {
370           taskdata = taskdata->ompt_task_info.scheduling_parent;
371         } else if (next_lwt) {
372           lwt = next_lwt;
373           next_lwt = NULL;
374         } else {
375           // then go for implicit tasks
376           taskdata = taskdata->td_parent;
377           if (team == NULL)
378             return 0;
379           team = team->t.t_parent;
380           if (taskdata) {
381             next_lwt = LWT_FROM_TEAM(taskdata->td_team);
382           }
383         }
384       }
385       ancestor_level--;
386     }
387
388     if (lwt) {
389       info = &lwt->ompt_task_info;
390       team_info = &lwt->ompt_team_info;
391       if (type) {
392         *type = ompt_task_implicit;
393       }
394     } else if (taskdata) {
395       info = &taskdata->ompt_task_info;
396       team_info = &team->t.ompt_team_info;
397       if (type) {
398         if (taskdata->td_parent) {
399           *type = (taskdata->td_flags.tasktype ? ompt_task_explicit
400                                                : ompt_task_implicit) |
401                   TASK_TYPE_DETAILS_FORMAT(taskdata);
402         } else {
403           *type = ompt_task_initial;
404         }
405       }
406     }
407     if (task_data) {
408       *task_data = info ? &info->task_data : NULL;
409     }
410     if (task_frame) {
411       // OpenMP spec asks for the scheduling task to be returned.
412       *task_frame = info ? &info->frame : NULL;
413     }
414     if (parallel_data) {
415       *parallel_data = team_info ? &(team_info->parallel_data) : NULL;
416     }
417     if (thread_num) {
418       if (level == 0)
419         *thread_num = __kmp_get_tid();
420       else if (prev_lwt)
421         *thread_num = 0;
422       else
423         *thread_num = prev_team->t.t_master_tid;
424       //        *thread_num = team->t.t_master_tid;
425     }
426     return info ? 2 : 0;
427   }
428   return 0;
429 }
430
431 int __ompt_get_task_memory_internal(void **addr, size_t *size, int blocknum) {
432   if (blocknum != 0)
433     return 0; // support only a single block
434
435   kmp_info_t *thr = ompt_get_thread();
436   if (!thr)
437     return 0;
438
439   kmp_taskdata_t *taskdata = thr->th.th_current_task;
440   kmp_task_t *task = KMP_TASKDATA_TO_TASK(taskdata);
441
442   if (taskdata->td_flags.tasktype != TASK_EXPLICIT)
443     return 0; // support only explicit task
444
445   void *ret_addr;
446   int64_t ret_size = taskdata->td_size_alloc - sizeof(kmp_taskdata_t);
447
448   // kmp_task_t->data1 is an optional member
449   if (taskdata->td_flags.destructors_thunk)
450     ret_addr = &task->data1 + 1;
451   else
452     ret_addr = &task->part_id + 1;
453
454   ret_size -= (char *)(ret_addr) - (char *)(task);
455   if (ret_size < 0)
456     return 0;
457
458   *addr = ret_addr;
459   *size = ret_size;
460   return 1;
461 }
462
463 //----------------------------------------------------------
464 // team support
465 //----------------------------------------------------------
466
467 void __ompt_team_assign_id(kmp_team_t *team, ompt_data_t ompt_pid) {
468   team->t.ompt_team_info.parallel_data = ompt_pid;
469 }
470
471 //----------------------------------------------------------
472 // misc
473 //----------------------------------------------------------
474
475 static uint64_t __ompt_get_unique_id_internal() {
476   static uint64_t thread = 1;
477   static THREAD_LOCAL uint64_t ID = 0;
478   if (ID == 0) {
479     uint64_t new_thread = KMP_TEST_THEN_INC64((kmp_int64 *)&thread);
480     ID = new_thread << (sizeof(uint64_t) * 8 - OMPT_THREAD_ID_BITS);
481   }
482   return ++ID;
483 }
484
485 ompt_sync_region_t __ompt_get_barrier_kind(enum barrier_type bt,
486                                            kmp_info_t *thr) {
487   if (bt == bs_forkjoin_barrier)
488     return ompt_sync_region_barrier_implicit;
489
490   if (bt != bs_plain_barrier)
491     return ompt_sync_region_barrier_implementation;
492
493   if (!thr->th.th_ident)
494     return ompt_sync_region_barrier;
495
496   kmp_int32 flags = thr->th.th_ident->flags;
497
498   if ((flags & KMP_IDENT_BARRIER_EXPL) != 0)
499     return ompt_sync_region_barrier_explicit;
500
501   if ((flags & KMP_IDENT_BARRIER_IMPL) != 0)
502     return ompt_sync_region_barrier_implicit;
503
504   return ompt_sync_region_barrier_implementation;
505 }