1 /*
2  * ompt-specific.cpp -- OMPT internal functions
3  */
4 
5 //===----------------------------------------------------------------------===//
6 //
7 //                     The LLVM Compiler Infrastructure
8 //
9 // This file is dual licensed under the MIT and the University of Illinois Open
10 // Source Licenses. See LICENSE.txt for details.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 //******************************************************************************
15 // include files
16 //******************************************************************************
17 
18 #include "kmp.h"
19 #include "ompt-specific.h"
20 
21 #if KMP_OS_UNIX
22 #include <dlfcn.h>
23 #endif
24 
25 #if KMP_OS_WINDOWS
26 #define THREAD_LOCAL __declspec(thread)
27 #else
28 #define THREAD_LOCAL __thread
29 #endif
30 
31 #define OMPT_WEAK_ATTRIBUTE KMP_WEAK_ATTRIBUTE
32 
33 //******************************************************************************
34 // macros
35 //******************************************************************************
36 
37 #define LWT_FROM_TEAM(team) (team)->t.ompt_serialized_team_info
38 
39 #define OMPT_THREAD_ID_BITS 16
40 
41 //******************************************************************************
42 // private operations
43 //******************************************************************************
44 
45 //----------------------------------------------------------
46 // traverse the team and task hierarchy
47 // note: __ompt_get_teaminfo and __ompt_get_task_info_object
48 //       traverse the hierarchy similarly and need to be
49 //       kept consistent
50 //----------------------------------------------------------
51 
52 ompt_team_info_t *__ompt_get_teaminfo(int depth, int *size) {
53   kmp_info_t *thr = ompt_get_thread();
54 
55   if (thr) {
56     kmp_team *team = thr->th.th_team;
57     if (team == NULL)
58       return NULL;
59 
60     ompt_lw_taskteam_t *next_lwt = LWT_FROM_TEAM(team), *lwt = NULL;
61 
62     while (depth > 0) {
63       // next lightweight team (if any)
64       if (lwt)
65         lwt = lwt->parent;
66 
67       // next heavyweight team (if any) after
68       // lightweight teams are exhausted
69       if (!lwt && team) {
70         if (next_lwt) {
71           lwt = next_lwt;
72           next_lwt = NULL;
73         } else {
74           team = team->t.t_parent;
75           if (team) {
76             next_lwt = LWT_FROM_TEAM(team);
77           }
78         }
79       }
80 
81       depth--;
82     }
83 
84     if (lwt) {
85       // lightweight teams have one task
86       if (size)
87         *size = 1;
88 
89       // return team info for lightweight team
90       return &lwt->ompt_team_info;
91     } else if (team) {
92       // extract size from heavyweight team
93       if (size)
94         *size = team->t.t_nproc;
95 
96       // return team info for heavyweight team
97       return &team->t.ompt_team_info;
98     }
99   }
100 
101   return NULL;
102 }
103 
104 ompt_task_info_t *__ompt_get_task_info_object(int depth) {
105   ompt_task_info_t *info = NULL;
106   kmp_info_t *thr = ompt_get_thread();
107 
108   if (thr) {
109     kmp_taskdata_t *taskdata = thr->th.th_current_task;
110     ompt_lw_taskteam_t *lwt = NULL,
111                        *next_lwt = LWT_FROM_TEAM(taskdata->td_team);
112 
113     while (depth > 0) {
114       // next lightweight team (if any)
115       if (lwt)
116         lwt = lwt->parent;
117 
118       // next heavyweight team (if any) after
119       // lightweight teams are exhausted
120       if (!lwt && taskdata) {
121         if (next_lwt) {
122           lwt = next_lwt;
123           next_lwt = NULL;
124         } else {
125           taskdata = taskdata->td_parent;
126           if (taskdata) {
127             next_lwt = LWT_FROM_TEAM(taskdata->td_team);
128           }
129         }
130       }
131       depth--;
132     }
133 
134     if (lwt) {
135       info = &lwt->ompt_task_info;
136     } else if (taskdata) {
137       info = &taskdata->ompt_task_info;
138     }
139   }
140 
141   return info;
142 }
143 
144 ompt_task_info_t *__ompt_get_scheduling_taskinfo(int depth) {
145   ompt_task_info_t *info = NULL;
146   kmp_info_t *thr = ompt_get_thread();
147 
148   if (thr) {
149     kmp_taskdata_t *taskdata = thr->th.th_current_task;
150 
151     ompt_lw_taskteam_t *lwt = NULL,
152                        *next_lwt = LWT_FROM_TEAM(taskdata->td_team);
153 
154     while (depth > 0) {
155       // next lightweight team (if any)
156       if (lwt)
157         lwt = lwt->parent;
158 
159       // next heavyweight team (if any) after
160       // lightweight teams are exhausted
161       if (!lwt && taskdata) {
162         // first try scheduling parent (for explicit task scheduling)
163         if (taskdata->ompt_task_info.scheduling_parent) {
164           taskdata = taskdata->ompt_task_info.scheduling_parent;
165         } else if (next_lwt) {
166           lwt = next_lwt;
167           next_lwt = NULL;
168         } else {
169           // then go for implicit tasks
170           taskdata = taskdata->td_parent;
171           if (taskdata) {
172             next_lwt = LWT_FROM_TEAM(taskdata->td_team);
173           }
174         }
175       }
176       depth--;
177     }
178 
179     if (lwt) {
180       info = &lwt->ompt_task_info;
181     } else if (taskdata) {
182       info = &taskdata->ompt_task_info;
183     }
184   }
185 
186   return info;
187 }
188 
189 //******************************************************************************
190 // interface operations
191 //******************************************************************************
192 
193 //----------------------------------------------------------
194 // thread support
195 //----------------------------------------------------------
196 
197 ompt_data_t *__ompt_get_thread_data_internal() {
198   if (__kmp_get_gtid() >= 0) {
199     kmp_info_t *thread = ompt_get_thread();
200     if (thread == NULL)
201       return NULL;
202     return &(thread->th.ompt_thread_info.thread_data);
203   }
204   return NULL;
205 }
206 
207 //----------------------------------------------------------
208 // state support
209 //----------------------------------------------------------
210 
211 void __ompt_thread_assign_wait_id(void *variable) {
212   kmp_info_t *ti = ompt_get_thread();
213 
214   ti->th.ompt_thread_info.wait_id = (omp_wait_id_t)variable;
215 }
216 
217 omp_state_t __ompt_get_state_internal(omp_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 omp_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 = NULL;
263   lwt->ompt_task_info.frame.exit_frame = NULL;
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                                   omp_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 //----------------------------------------------------------
432 // team support
433 //----------------------------------------------------------
434 
435 void __ompt_team_assign_id(kmp_team_t *team, ompt_data_t ompt_pid) {
436   team->t.ompt_team_info.parallel_data = ompt_pid;
437 }
438 
439 //----------------------------------------------------------
440 // misc
441 //----------------------------------------------------------
442 
443 static uint64_t __ompt_get_unique_id_internal() {
444   static uint64_t thread = 1;
445   static THREAD_LOCAL uint64_t ID = 0;
446   if (ID == 0) {
447     uint64_t new_thread = KMP_TEST_THEN_INC64((kmp_int64 *)&thread);
448     ID = new_thread << (sizeof(uint64_t) * 8 - OMPT_THREAD_ID_BITS);
449   }
450   return ++ID;
451 }
452