1 /*
2  * omp-icv.cpp -- OMPD Internal Control Variable handling
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 // clang-format off
13 /* clang-format expect kmp.h before omp.h which results in build break
14  * due to a few redeclarations.
15  */
16 #include "omp-debug.h"
17 // NOLINTNEXTLINE "to avoid clang tidy warning for the same reason as above."
18 #include "omp.h"
19 #include "ompd-private.h"
20 #include "TargetValue.h"
21 #include "kmp.h"
22 #include <cstring>
23 
24 /* The ICVs ompd-final-var and ompd-implicit-var below are for backward
25  * compatibility with 5.0.
26  */
27 
28 #define FOREACH_OMPD_ICV(macro)                                                     \
29   macro(dyn_var, "dyn-var", ompd_scope_thread, 0)                                   \
30   macro(run_sched_var, "run-sched-var", ompd_scope_task, 0)                         \
31   macro(stacksize_var, "stacksize-var", ompd_scope_address_space, 0)                \
32   macro(cancel_var, "cancel-var", ompd_scope_address_space, 0)                      \
33   macro(max_task_priority_var, "max-task-priority-var", ompd_scope_address_space, 0)\
34   macro(debug_var, "debug-var", ompd_scope_address_space, 0)                        \
35   macro(nthreads_var, "nthreads-var", ompd_scope_thread, 0)                         \
36   macro(display_affinity_var, "display-affinity-var", ompd_scope_address_space, 0)  \
37   macro(affinity_format_var, "affinity-format-var", ompd_scope_address_space, 0)    \
38   macro(default_device_var, "default-device-var", ompd_scope_thread, 0)             \
39   macro(tool_var, "tool-var", ompd_scope_address_space, 0)                          \
40   macro(tool_libraries_var, "tool-libraries-var", ompd_scope_address_space, 0)      \
41   macro(tool_verbose_init_var, "tool-verbose-init-var", ompd_scope_address_space, 0)\
42   macro(levels_var, "levels-var", ompd_scope_parallel, 1)                           \
43   macro(active_levels_var, "active-levels-var", ompd_scope_parallel, 0)             \
44   macro(thread_limit_var, "thread-limit-var", ompd_scope_task, 0)                   \
45   macro(max_active_levels_var, "max-active-levels-var", ompd_scope_task, 0)         \
46   macro(bind_var, "bind-var", ompd_scope_task, 0)                                   \
47   macro(num_procs_var, "num-procs-var", ompd_scope_address_space, 0)                \
48   macro(ompd_num_procs_var, "ompd-num-procs-var", ompd_scope_address_space, 0)      \
49   macro(thread_num_var, "thread-num-var", ompd_scope_thread, 1)                     \
50   macro(ompd_thread_num_var, "ompd-thread-num-var", ompd_scope_thread, 1)           \
51   macro(final_var, "final-task-var", ompd_scope_task, 0)                            \
52   macro(ompd_final_var, "ompd-final-var", ompd_scope_task, 0)                       \
53   macro(ompd_final_task_var, "ompd-final-task-var", ompd_scope_task, 0)             \
54   macro(implicit_var, "implicit-task-var", ompd_scope_task, 0)                      \
55   macro(ompd_implicit_var, "ompd-implicit-var", ompd_scope_task, 0)                 \
56   macro(ompd_implicit_task_var, "ompd-implicit-task-var", ompd_scope_task, 0)       \
57   macro(team_size_var, "team-size-var", ompd_scope_parallel, 1)                     \
58   macro(ompd_team_size_var, "ompd-team-size-var", ompd_scope_parallel, 1)
59 
60 void __ompd_init_icvs(const ompd_callbacks_t *table) { callbacks = table; }
61 
62 enum ompd_icv {
63   ompd_icv_undefined_marker =
64       0, // ompd_icv_undefined is already defined in ompd.h
65 #define ompd_icv_macro(v, n, s, d) ompd_icv_##v,
66   FOREACH_OMPD_ICV(ompd_icv_macro)
67 #undef ompd_icv_macro
68       ompd_icv_after_last_icv
69 };
70 
71 static const char *ompd_icv_string_values[] = {"undefined",
72 #define ompd_icv_macro(v, n, s, d) n,
73   FOREACH_OMPD_ICV(ompd_icv_macro)
74 #undef ompd_icv_macro
75 };
76 
77 static const ompd_scope_t ompd_icv_scope_values[] = {
78     ompd_scope_global, // undefined marker
79 #define ompd_icv_macro(v, n, s, d) s,
80     FOREACH_OMPD_ICV(ompd_icv_macro)
81 #undef ompd_icv_macro
82 };
83 
84 // clang-format on
85 ompd_rc_t ompd_enumerate_icvs(ompd_address_space_handle_t *handle,
86                               ompd_icv_id_t current, ompd_icv_id_t *next_id,
87                               const char **next_icv_name,
88                               ompd_scope_t *next_scope, int *more) {
89   if (!handle) {
90     return ompd_rc_stale_handle;
91   }
92   if (!next_id || !next_icv_name || !next_scope || !more) {
93     return ompd_rc_bad_input;
94   }
95   if (current + 1 >= ompd_icv_after_last_icv) {
96     return ompd_rc_bad_input;
97   }
98 
99   *next_id = current + 1;
100 
101   char *icv_name = NULL;
102   ompd_rc_t ret = callbacks->alloc_memory(
103       std::strlen(ompd_icv_string_values[*next_id]) + 1, (void **)&icv_name);
104   *next_icv_name = icv_name;
105   if (ret != ompd_rc_ok) {
106     return ret;
107   }
108   std::strcpy(icv_name, ompd_icv_string_values[*next_id]);
109 
110   *next_scope = ompd_icv_scope_values[*next_id];
111 
112   if ((*next_id) + 1 >= ompd_icv_after_last_icv) {
113     *more = 0;
114   } else {
115     *more = 1;
116   }
117 
118   return ompd_rc_ok;
119 }
120 
121 static ompd_rc_t create_empty_string(const char **empty_string_ptr) {
122   char *empty_str;
123   ompd_rc_t ret;
124 
125   if (!callbacks) {
126     return ompd_rc_callback_error;
127   }
128   ret = callbacks->alloc_memory(1, (void **)&empty_str);
129   if (ret != ompd_rc_ok) {
130     return ret;
131   }
132   empty_str[0] = '\0';
133   *empty_string_ptr = empty_str;
134   return ompd_rc_ok;
135 }
136 
137 static ompd_rc_t ompd_get_dynamic(
138     ompd_thread_handle_t *thread_handle, /* IN: OpenMP thread handle */
139     ompd_word_t *dyn_val /* OUT: Dynamic adjustment of threads */
140 ) {
141   if (!thread_handle)
142     return ompd_rc_stale_handle;
143   if (!thread_handle->ah)
144     return ompd_rc_stale_handle;
145   ompd_address_space_context_t *context = thread_handle->ah->context;
146   if (!context)
147     return ompd_rc_stale_handle;
148   if (!callbacks) {
149     return ompd_rc_callback_error;
150   }
151 
152   int8_t dynamic;
153   ompd_rc_t ret =
154       TValue(context, thread_handle->th) /*__kmp_threads[t]->th*/
155           .cast("kmp_base_info_t")
156           .access("th_current_task") /*__kmp_threads[t]->th.th_current_task*/
157           .cast("kmp_taskdata_t", 1)
158           .access("td_icvs") /*__kmp_threads[t]->th.th_current_task->td_icvs*/
159           .cast("kmp_internal_control_t", 0)
160           .access(
161               "dynamic") /*__kmp_threads[t]->th.th_current_task->td_icvs.dynamic*/
162           .castBase()
163           .getValue(dynamic);
164   *dyn_val = dynamic;
165   return ret;
166 }
167 
168 static ompd_rc_t
169 ompd_get_stacksize(ompd_address_space_handle_t
170                        *addr_handle, /* IN: handle for the address space */
171                    ompd_word_t *stacksize_val /* OUT: per thread stack size */
172 ) {
173   ompd_address_space_context_t *context = addr_handle->context;
174   if (!context)
175     return ompd_rc_stale_handle;
176   ompd_rc_t ret;
177   if (!callbacks) {
178     return ompd_rc_callback_error;
179   }
180 
181   size_t stacksize;
182   ret = TValue(context, "__kmp_stksize")
183             .castBase("__kmp_stksize")
184             .getValue(stacksize);
185   *stacksize_val = stacksize;
186   return ret;
187 }
188 
189 static ompd_rc_t ompd_get_cancellation(
190     ompd_address_space_handle_t
191         *addr_handle,             /* IN: handle for the address space */
192     ompd_word_t *cancellation_val /* OUT: cancellation value */
193 ) {
194   ompd_address_space_context_t *context = addr_handle->context;
195   if (!context)
196     return ompd_rc_stale_handle;
197   if (!callbacks) {
198     return ompd_rc_callback_error;
199   }
200   ompd_rc_t ret;
201 
202   int omp_cancellation;
203   ret = TValue(context, "__kmp_omp_cancellation")
204             .castBase("__kmp_omp_cancellation")
205             .getValue(omp_cancellation);
206   *cancellation_val = omp_cancellation;
207   return ret;
208 }
209 
210 static ompd_rc_t ompd_get_max_task_priority(
211     ompd_address_space_handle_t
212         *addr_handle,                  /* IN: handle for the address space */
213     ompd_word_t *max_task_priority_val /* OUT: max task priority value */
214 ) {
215   ompd_address_space_context_t *context = addr_handle->context;
216   if (!context)
217     return ompd_rc_stale_handle;
218   if (!callbacks) {
219     return ompd_rc_callback_error;
220   }
221   ompd_rc_t ret;
222 
223   int max_task_priority;
224   ret = TValue(context, "__kmp_max_task_priority")
225             .castBase("__kmp_max_task_priority")
226             .getValue(max_task_priority);
227   *max_task_priority_val = max_task_priority;
228   return ret;
229 }
230 
231 static ompd_rc_t
232 ompd_get_debug(ompd_address_space_handle_t
233                    *addr_handle,      /* IN: handle for the address space */
234                ompd_word_t *debug_val /* OUT: debug value */
235 ) {
236   ompd_address_space_context_t *context = addr_handle->context;
237   if (!context)
238     return ompd_rc_stale_handle;
239   if (!callbacks) {
240     return ompd_rc_callback_error;
241   }
242   ompd_rc_t ret;
243 
244   uint64_t ompd_state_val;
245   ret = TValue(context, "ompd_state")
246             .castBase("ompd_state")
247             .getValue(ompd_state_val);
248   if (ompd_state_val > 0) {
249     *debug_val = 1;
250   } else {
251     *debug_val = 0;
252   }
253   return ret;
254 }
255 
256 /* Helper routine for the ompd_get_nthreads routines */
257 static ompd_rc_t ompd_get_nthreads_aux(ompd_thread_handle_t *thread_handle,
258                                        uint32_t *used,
259                                        uint32_t *current_nesting_level,
260                                        uint32_t *nproc) {
261   if (!thread_handle)
262     return ompd_rc_stale_handle;
263   if (!thread_handle->ah)
264     return ompd_rc_stale_handle;
265   ompd_address_space_context_t *context = thread_handle->ah->context;
266   if (!context)
267     return ompd_rc_stale_handle;
268   if (!callbacks) {
269     return ompd_rc_callback_error;
270   }
271 
272   ompd_rc_t ret = TValue(context, "__kmp_nested_nth")
273                       .cast("kmp_nested_nthreads_t")
274                       .access("used")
275                       .castBase(ompd_type_int)
276                       .getValue(*used);
277   if (ret != ompd_rc_ok)
278     return ret;
279 
280   TValue taskdata =
281       TValue(context, thread_handle->th) /*__kmp_threads[t]->th*/
282           .cast("kmp_base_info_t")
283           .access("th_current_task") /*__kmp_threads[t]->th.th_current_task*/
284           .cast("kmp_taskdata_t", 1);
285 
286   ret = taskdata
287             .access("td_team") /*__kmp_threads[t]->th.th_current_task.td_team*/
288             .cast("kmp_team_p", 1)
289             .access("t") /*__kmp_threads[t]->th.th_current_task.td_team->t*/
290             .cast("kmp_base_team_t", 0) /*t*/
291             .access("t_level")          /*t.t_level*/
292             .castBase(ompd_type_int)
293             .getValue(*current_nesting_level);
294   if (ret != ompd_rc_ok)
295     return ret;
296 
297   ret = taskdata.cast("kmp_taskdata_t", 1)
298             .access("td_icvs") /*__kmp_threads[t]->th.th_current_task->td_icvs*/
299             .cast("kmp_internal_control_t", 0)
300             .access(
301                 "nproc") /*__kmp_threads[t]->th.th_current_task->td_icvs.nproc*/
302             .castBase(ompd_type_int)
303             .getValue(*nproc);
304   if (ret != ompd_rc_ok)
305     return ret;
306 
307   return ompd_rc_ok;
308 }
309 
310 static ompd_rc_t ompd_get_nthreads(
311     ompd_thread_handle_t *thread_handle, /* IN: handle for the thread */
312     ompd_word_t *nthreads_var_val        /* OUT: nthreads-var (of integer type)
313                                             value */
314 ) {
315   uint32_t used;
316   uint32_t nproc;
317   uint32_t current_nesting_level;
318 
319   ompd_rc_t ret;
320   ret = ompd_get_nthreads_aux(thread_handle, &used, &current_nesting_level,
321                               &nproc);
322   if (ret != ompd_rc_ok)
323     return ret;
324 
325   /*__kmp_threads[t]->th.th_current_task->td_icvs.nproc*/
326   *nthreads_var_val = nproc;
327   /* If the nthreads-var is a list with more than one element, then the value of
328      this ICV cannot be represented by an integer type. In this case,
329      ompd_rc_incomplete is returned. The tool can check the return value and
330      can choose to invoke ompd_get_icv_string_from_scope() if needed. */
331   if (current_nesting_level < used - 1) {
332     return ompd_rc_incomplete;
333   }
334   return ompd_rc_ok;
335 }
336 
337 static ompd_rc_t ompd_get_nthreads(
338     ompd_thread_handle_t *thread_handle, /* IN: handle for the thread */
339     const char **nthreads_list_string    /* OUT: string list of comma separated
340                                             nthreads values */
341 ) {
342   uint32_t used;
343   uint32_t nproc;
344   uint32_t current_nesting_level;
345 
346   ompd_rc_t ret;
347   ret = ompd_get_nthreads_aux(thread_handle, &used, &current_nesting_level,
348                               &nproc);
349   if (ret != ompd_rc_ok)
350     return ret;
351 
352   uint32_t num_list_elems;
353   if (used == 0 || current_nesting_level >= used) {
354     num_list_elems = 1;
355   } else {
356     num_list_elems = used - current_nesting_level;
357   }
358   size_t buffer_size = 16 /* digits per element including the comma separator */
359                            * num_list_elems +
360                        1; /* string terminator NULL */
361   char *nthreads_list_str;
362   ret = callbacks->alloc_memory(buffer_size, (void **)&nthreads_list_str);
363   if (ret != ompd_rc_ok)
364     return ret;
365 
366   /* The nthreads-var list would be:
367   [__kmp_threads[t]->th.th_current_task->td_icvs.nproc,
368    __kmp_nested_nth.nth[current_nesting_level + 1],
369    __kmp_nested_nth.nth[current_nesting_level + 2],
370     …,
371    __kmp_nested_nth.nth[used - 1]]*/
372 
373   sprintf(nthreads_list_str, "%d", nproc);
374   *nthreads_list_string = nthreads_list_str;
375   if (num_list_elems == 1) {
376     return ompd_rc_ok;
377   }
378 
379   char temp_value[16];
380   uint32_t nth_value;
381 
382   for (current_nesting_level++; /* the list element for this nesting
383                                  * level has already been accounted for
384                                    by nproc */
385        current_nesting_level < used; current_nesting_level++) {
386 
387     ret = TValue(thread_handle->ah->context, "__kmp_nested_nth")
388               .cast("kmp_nested_nthreads_t")
389               .access("nth")
390               .cast("int", 1)
391               .getArrayElement(current_nesting_level)
392               .castBase(ompd_type_int)
393               .getValue(nth_value);
394 
395     if (ret != ompd_rc_ok)
396       return ret;
397 
398     sprintf(temp_value, ",%d", nth_value);
399     strcat(nthreads_list_str, temp_value);
400   }
401 
402   return ompd_rc_ok;
403 }
404 
405 static ompd_rc_t ompd_get_display_affinity(
406     ompd_address_space_handle_t
407         *addr_handle,                 /* IN: handle for the address space */
408     ompd_word_t *display_affinity_val /* OUT: display affinity value */
409 ) {
410   ompd_address_space_context_t *context = addr_handle->context;
411   if (!context)
412     return ompd_rc_stale_handle;
413   ompd_rc_t ret;
414 
415   if (!callbacks) {
416     return ompd_rc_callback_error;
417   }
418   ret = TValue(context, "__kmp_display_affinity")
419             .castBase("__kmp_display_affinity")
420             .getValue(*display_affinity_val);
421   return ret;
422 }
423 
424 static ompd_rc_t ompd_get_affinity_format(
425     ompd_address_space_handle_t *addr_handle, /* IN: address space handle*/
426     const char **affinity_format_string       /* OUT: affinity format string */
427 ) {
428   ompd_address_space_context_t *context = addr_handle->context;
429   if (!context)
430     return ompd_rc_stale_handle;
431 
432   if (!callbacks) {
433     return ompd_rc_callback_error;
434   }
435   ompd_rc_t ret;
436   ret = TValue(context, "__kmp_affinity_format")
437             .cast("char", 1)
438             .getString(affinity_format_string);
439   return ret;
440 }
441 
442 static ompd_rc_t ompd_get_tool_libraries(
443     ompd_address_space_handle_t *addr_handle, /* IN: address space handle*/
444     const char **tool_libraries_string        /* OUT: tool libraries string */
445 ) {
446   if (!tool_libraries_string)
447     return ompd_rc_bad_input;
448 
449   ompd_address_space_context_t *context = addr_handle->context;
450   if (!context)
451     return ompd_rc_stale_handle;
452 
453   if (!callbacks) {
454     return ompd_rc_callback_error;
455   }
456   ompd_rc_t ret;
457   ret = TValue(context, "__kmp_tool_libraries")
458             .cast("char", 1)
459             .getString(tool_libraries_string);
460   if (ret == ompd_rc_unsupported) {
461     ret = create_empty_string(tool_libraries_string);
462   }
463   return ret;
464 }
465 
466 static ompd_rc_t ompd_get_default_device(
467     ompd_thread_handle_t *thread_handle, /* IN: handle for the thread */
468     ompd_word_t *default_device_val      /* OUT: default device value */
469 ) {
470   if (!thread_handle)
471     return ompd_rc_stale_handle;
472   if (!thread_handle->ah)
473     return ompd_rc_stale_handle;
474   ompd_address_space_context_t *context = thread_handle->ah->context;
475   if (!context)
476     return ompd_rc_stale_handle;
477   if (!callbacks)
478     return ompd_rc_callback_error;
479 
480   ompd_rc_t ret =
481       TValue(context, thread_handle->th) /*__kmp_threads[t]->th*/
482           .cast("kmp_base_info_t")
483           .access("th_current_task") /*__kmp_threads[t]->th.th_current_task*/
484           .cast("kmp_taskdata_t", 1)
485           .access("td_icvs") /*__kmp_threads[t]->th.th_current_task->td_icvs*/
486           .cast("kmp_internal_control_t", 0)
487           /*__kmp_threads[t]->th.th_current_task->td_icvs.default_device*/
488           .access("default_device")
489           .castBase()
490           .getValue(*default_device_val);
491   return ret;
492 }
493 
494 static ompd_rc_t
495 ompd_get_tool(ompd_address_space_handle_t
496                   *addr_handle,     /* IN: handle for the address space */
497               ompd_word_t *tool_val /* OUT: tool value */
498 ) {
499   ompd_address_space_context_t *context = addr_handle->context;
500   if (!context)
501     return ompd_rc_stale_handle;
502   if (!callbacks) {
503     return ompd_rc_callback_error;
504   }
505   ompd_rc_t ret;
506 
507   ret =
508       TValue(context, "__kmp_tool").castBase("__kmp_tool").getValue(*tool_val);
509   return ret;
510 }
511 
512 static ompd_rc_t ompd_get_tool_verbose_init(
513     ompd_address_space_handle_t *addr_handle, /* IN: address space handle*/
514     const char **tool_verbose_init_string /* OUT: tool verbose init string */
515 ) {
516   ompd_address_space_context_t *context = addr_handle->context;
517   if (!context)
518     return ompd_rc_stale_handle;
519 
520   if (!callbacks) {
521     return ompd_rc_callback_error;
522   }
523   ompd_rc_t ret;
524   ret = TValue(context, "__kmp_tool_verbose_init")
525             .cast("char", 1)
526             .getString(tool_verbose_init_string);
527   if (ret == ompd_rc_unsupported) {
528     ret = create_empty_string(tool_verbose_init_string);
529   }
530   return ret;
531 }
532 
533 static ompd_rc_t ompd_get_level(
534     ompd_parallel_handle_t *parallel_handle, /* IN: OpenMP parallel handle */
535     ompd_word_t *val                         /* OUT: nesting level */
536 ) {
537   if (!parallel_handle->ah)
538     return ompd_rc_stale_handle;
539   ompd_address_space_context_t *context = parallel_handle->ah->context;
540   if (!context)
541     return ompd_rc_stale_handle;
542 
543   if (!callbacks) {
544     return ompd_rc_callback_error;
545   }
546 
547   uint32_t res;
548 
549   ompd_rc_t ret = TValue(context, parallel_handle->th)
550                       .cast("kmp_base_team_t", 0) /*t*/
551                       .access("t_level")          /*t.t_level*/
552                       .castBase()
553                       .getValue(res);
554   *val = res;
555   return ret;
556 }
557 
558 static ompd_rc_t ompd_get_active_level(
559     ompd_parallel_handle_t *parallel_handle, /* IN: OpenMP parallel handle */
560     ompd_word_t *val                         /* OUT: active nesting level */
561 ) {
562   if (!parallel_handle->ah)
563     return ompd_rc_stale_handle;
564   ompd_address_space_context_t *context = parallel_handle->ah->context;
565   if (!context)
566     return ompd_rc_stale_handle;
567   if (!callbacks) {
568     return ompd_rc_callback_error;
569   }
570 
571   uint32_t res;
572 
573   ompd_rc_t ret = TValue(context, parallel_handle->th)
574                       .cast("kmp_base_team_t", 0) /*t*/
575                       .access("t_active_level")   /*t.t_active_level*/
576                       .castBase()
577                       .getValue(res);
578   *val = res;
579   return ret;
580 }
581 
582 static ompd_rc_t
583 ompd_get_num_procs(ompd_address_space_handle_t
584                        *addr_handle, /* IN: handle for the address space */
585                    ompd_word_t *val  /* OUT: number of processes */
586 ) {
587   ompd_address_space_context_t *context = addr_handle->context;
588   if (!context)
589     return ompd_rc_stale_handle;
590   if (!callbacks) {
591     return ompd_rc_callback_error;
592   }
593 
594   if (!val)
595     return ompd_rc_bad_input;
596   ompd_rc_t ret;
597 
598   int nth;
599   ret = TValue(context, "__kmp_avail_proc")
600             .castBase("__kmp_avail_proc")
601             .getValue(nth);
602   *val = nth;
603   return ret;
604 }
605 
606 static ompd_rc_t ompd_get_thread_limit(
607     ompd_task_handle_t *task_handle, /* IN: OpenMP task handle*/
608     ompd_word_t *val                 /* OUT: max number of threads */
609 ) {
610   if (!task_handle->ah)
611     return ompd_rc_stale_handle;
612   ompd_address_space_context_t *context = task_handle->ah->context;
613   if (!context)
614     return ompd_rc_stale_handle;
615   if (!callbacks) {
616     return ompd_rc_callback_error;
617   }
618 
619   ompd_rc_t ret = TValue(context, task_handle->th)
620                       .cast("kmp_taskdata_t") // td
621                       .access("td_icvs")      // td->td_icvs
622                       .cast("kmp_internal_control_t", 0)
623                       .access("thread_limit") // td->td_icvs.thread_limit
624                       .castBase()
625                       .getValue(*val);
626 
627   return ret;
628 }
629 
630 static ompd_rc_t ompd_get_thread_num(
631     ompd_thread_handle_t *thread_handle, /* IN: OpenMP thread handle*/
632     ompd_word_t *val /* OUT: number of the thread within the team */
633 ) {
634   if (!thread_handle)
635     return ompd_rc_stale_handle;
636   if (!thread_handle->ah)
637     return ompd_rc_stale_handle;
638   ompd_address_space_context_t *context = thread_handle->ah->context;
639   if (!context)
640     return ompd_rc_stale_handle;
641   if (!callbacks) {
642     return ompd_rc_callback_error;
643   }
644 
645   ompd_rc_t ret =
646       TValue(context, thread_handle->th) /*__kmp_threads[t]->th*/
647           .cast("kmp_base_info_t")
648           .access("th_info") /*__kmp_threads[t]->th.th_info*/
649           .cast("kmp_desc_t")
650           .access("ds") /*__kmp_threads[t]->th.th_info.ds*/
651           .cast("kmp_desc_base_t")
652           .access("ds_tid") /*__kmp_threads[t]->th.th_info.ds.ds_tid*/
653           .castBase()
654           .getValue(*val);
655   return ret;
656 }
657 
658 static ompd_rc_t
659 ompd_in_final(ompd_task_handle_t *task_handle, /* IN: OpenMP task handle*/
660               ompd_word_t *val                 /* OUT: max number of threads */
661 ) {
662   if (!task_handle->ah)
663     return ompd_rc_stale_handle;
664   ompd_address_space_context_t *context = task_handle->ah->context;
665   if (!context)
666     return ompd_rc_stale_handle;
667   if (!callbacks) {
668     return ompd_rc_callback_error;
669   }
670 
671   ompd_rc_t ret = TValue(context, task_handle->th)
672                       .cast("kmp_taskdata_t") // td
673                       .access("td_flags")     // td->td_flags
674                       .cast("kmp_tasking_flags_t")
675                       .check("final", val); // td->td_flags.tasktype
676 
677   return ret;
678 }
679 
680 static ompd_rc_t ompd_get_max_active_levels(
681     ompd_task_handle_t *task_handle, /* IN: OpenMP task handle*/
682     ompd_word_t *val                 /* OUT: max number of threads */
683 ) {
684   if (!task_handle->ah)
685     return ompd_rc_stale_handle;
686   ompd_address_space_context_t *context = task_handle->ah->context;
687   if (!context)
688     return ompd_rc_stale_handle;
689   if (!callbacks) {
690     return ompd_rc_callback_error;
691   }
692 
693   ompd_rc_t ret =
694       TValue(context, task_handle->th)
695           .cast("kmp_taskdata_t") // td
696           .access("td_icvs")      // td->td_icvs
697           .cast("kmp_internal_control_t", 0)
698           .access("max_active_levels") // td->td_icvs.max_active_levels
699           .castBase()
700           .getValue(*val);
701 
702   return ret;
703 }
704 
705 static ompd_rc_t ompd_get_run_schedule(
706     ompd_task_handle_t *task_handle, /* IN: OpenMP task handle*/
707     const char **run_sched_string    /* OUT: Run Schedule String
708                                         consisting of kind and modifier */
709 ) {
710   if (!task_handle->ah)
711     return ompd_rc_stale_handle;
712   ompd_address_space_context_t *context = task_handle->ah->context;
713   if (!context)
714     return ompd_rc_stale_handle;
715   if (!callbacks) {
716     return ompd_rc_callback_error;
717   }
718 
719   int kind;
720 
721   TValue sched = TValue(context, task_handle->th)
722                      .cast("kmp_taskdata_t") // td
723                      .access("td_icvs")      // td->td_icvs
724                      .cast("kmp_internal_control_t", 0)
725                      .access("sched") // td->td_icvs.sched
726                      .cast("kmp_r_sched_t", 0);
727 
728   ompd_rc_t ret = sched
729                       .access("r_sched_type") // td->td_icvs.sched.r_sched_type
730                       .castBase()
731                       .getValue(kind);
732   if (ret != ompd_rc_ok) {
733     return ret;
734   }
735   int chunk = 0;
736   ret = sched
737             .access("chunk") // td->td_icvs.sched.chunk
738             .castBase()
739             .getValue(chunk);
740   if (ret != ompd_rc_ok) {
741     return ret;
742   }
743   char *run_sched_var_string;
744   ret = callbacks->alloc_memory(100, (void **)&run_sched_var_string);
745   if (ret != ompd_rc_ok) {
746     return ret;
747   }
748   run_sched_var_string[0] = '\0';
749   if (SCHEDULE_HAS_MONOTONIC(kind)) {
750     strcpy(run_sched_var_string, "monotonic:");
751   } else if (SCHEDULE_HAS_NONMONOTONIC(kind)) {
752     strcpy(run_sched_var_string, "nonmonotonic:");
753   }
754 
755   bool static_unchunked = false;
756   switch (SCHEDULE_WITHOUT_MODIFIERS(kind)) {
757   case kmp_sch_static:
758   case kmp_sch_static_greedy:
759   case kmp_sch_static_balanced:
760     static_unchunked = true;
761     strcat(run_sched_var_string, "static");
762     break;
763   case kmp_sch_static_chunked:
764     strcat(run_sched_var_string, "static");
765     break;
766   case kmp_sch_dynamic_chunked:
767     strcat(run_sched_var_string, "dynamic");
768     break;
769   case kmp_sch_guided_chunked:
770   case kmp_sch_guided_iterative_chunked:
771   case kmp_sch_guided_analytical_chunked:
772     strcat(run_sched_var_string, "guided");
773     break;
774   case kmp_sch_auto:
775     strcat(run_sched_var_string, "auto");
776     break;
777   case kmp_sch_trapezoidal:
778     strcat(run_sched_var_string, "trapezoidal");
779     break;
780   case kmp_sch_static_steal:
781     strcat(run_sched_var_string, "static_steal");
782     break;
783   default:
784     ret = callbacks->free_memory((void *)(run_sched_var_string));
785     if (ret != ompd_rc_ok) {
786       return ret;
787     }
788     ret = create_empty_string(run_sched_string);
789     return ret;
790   }
791 
792   if (static_unchunked == true) {
793     // To be in sync with what OMPT returns.
794     // Chunk was not set. Shown with a zero value.
795     chunk = 0;
796   }
797 
798   char temp_str[16];
799   sprintf(temp_str, ",%d", chunk);
800   strcat(run_sched_var_string, temp_str);
801   *run_sched_string = run_sched_var_string;
802   return ret;
803 }
804 
805 /* Helper routine for the ompd_get_proc_bind routines */
806 static ompd_rc_t ompd_get_proc_bind_aux(ompd_task_handle_t *task_handle,
807                                         uint32_t *used,
808                                         uint32_t *current_nesting_level,
809                                         uint32_t *proc_bind) {
810   if (!task_handle->ah)
811     return ompd_rc_stale_handle;
812   ompd_address_space_context_t *context = task_handle->ah->context;
813   if (!context)
814     return ompd_rc_stale_handle;
815   if (!callbacks) {
816     return ompd_rc_callback_error;
817   }
818 
819   ompd_rc_t ret = TValue(context, "__kmp_nested_proc_bind")
820                       .cast("kmp_nested_proc_bind_t")
821                       .access("used")
822                       .castBase(ompd_type_int)
823                       .getValue(*used);
824   if (ret != ompd_rc_ok)
825     return ret;
826 
827   TValue taskdata = TValue(context, task_handle->th) /* td */
828                         .cast("kmp_taskdata_t");
829 
830   ret = taskdata
831             .access("td_team") /* td->td_team*/
832             .cast("kmp_team_p", 1)
833             .access("t")                /* td->td_team->t*/
834             .cast("kmp_base_team_t", 0) /*t*/
835             .access("t_level")          /*t.t_level*/
836             .castBase(ompd_type_int)
837             .getValue(*current_nesting_level);
838   if (ret != ompd_rc_ok)
839     return ret;
840 
841   ret = taskdata
842             .access("td_icvs") /* td->td_icvs */
843             .cast("kmp_internal_control_t", 0)
844             .access("proc_bind") /* td->td_icvs.proc_bind */
845             .castBase()
846             .getValue(*proc_bind);
847   return ret;
848 }
849 
850 static ompd_rc_t
851 ompd_get_proc_bind(ompd_task_handle_t *task_handle, /* IN: OpenMP task handle */
852                    ompd_word_t *bind /* OUT: Kind of proc-binding */
853 ) {
854   uint32_t used;
855   uint32_t proc_bind;
856   uint32_t current_nesting_level;
857 
858   ompd_rc_t ret;
859   ret = ompd_get_proc_bind_aux(task_handle, &used, &current_nesting_level,
860                                &proc_bind);
861   if (ret != ompd_rc_ok)
862     return ret;
863 
864   *bind = proc_bind;
865   /* If bind-var is a list with more than one element, then the value of
866      this ICV cannot be represented by an integer type. In this case,
867      ompd_rc_incomplete is returned. The tool can check the return value and
868      can choose to invoke ompd_get_icv_string_from_scope() if needed. */
869   if (current_nesting_level < used - 1) {
870     return ompd_rc_incomplete;
871   }
872   return ompd_rc_ok;
873 }
874 
875 static ompd_rc_t ompd_get_proc_bind(
876     ompd_task_handle_t *task_handle,   /* IN: OpenMP task handle */
877     const char **proc_bind_list_string /* OUT: string list of comma separated
878                                           bind-var values */
879 ) {
880   uint32_t used;
881   uint32_t proc_bind;
882   uint32_t current_nesting_level;
883 
884   ompd_rc_t ret;
885   ret = ompd_get_proc_bind_aux(task_handle, &used, &current_nesting_level,
886                                &proc_bind);
887   if (ret != ompd_rc_ok)
888     return ret;
889 
890   uint32_t num_list_elems;
891   if (used == 0 || current_nesting_level >= used) {
892     num_list_elems = 1;
893   } else {
894     num_list_elems = used - current_nesting_level;
895   }
896   size_t buffer_size = 16 /* digits per element including the comma separator */
897                            * num_list_elems +
898                        1; /* string terminator NULL */
899   char *proc_bind_list_str;
900   ret = callbacks->alloc_memory(buffer_size, (void **)&proc_bind_list_str);
901   if (ret != ompd_rc_ok)
902     return ret;
903 
904   /* The bind-var list would be:
905   [td->td_icvs.proc_bind,
906    __kmp_nested_proc_bind.bind_types[current_nesting_level + 1],
907    __kmp_nested_proc_bind.bind_types[current_nesting_level + 2],
908     …,
909    __kmp_nested_proc_bind.bind_types[used - 1]]*/
910 
911   sprintf(proc_bind_list_str, "%d", proc_bind);
912   *proc_bind_list_string = proc_bind_list_str;
913   if (num_list_elems == 1) {
914     return ompd_rc_ok;
915   }
916 
917   char temp_value[16];
918   uint32_t bind_types_value;
919 
920   for (current_nesting_level++; /* the list element for this nesting
921                                    level has already been accounted for
922                                    by proc_bind */
923        current_nesting_level < used; current_nesting_level++) {
924 
925     ret = TValue(task_handle->ah->context, "__kmp_nested_proc_bind")
926               .cast("kmp_nested_proc_bind_t")
927               .access("bind_types")
928               .cast("int", 1)
929               .getArrayElement(current_nesting_level)
930               .castBase(ompd_type_int)
931               .getValue(bind_types_value);
932 
933     if (ret != ompd_rc_ok)
934       return ret;
935 
936     sprintf(temp_value, ",%d", bind_types_value);
937     strcat(proc_bind_list_str, temp_value);
938   }
939 
940   return ompd_rc_ok;
941 }
942 
943 static ompd_rc_t
944 ompd_is_implicit(ompd_task_handle_t *task_handle, /* IN: OpenMP task handle*/
945                  ompd_word_t *val /* OUT: max number of threads */
946 ) {
947   if (!task_handle)
948     return ompd_rc_stale_handle;
949   if (!task_handle->ah)
950     return ompd_rc_stale_handle;
951   ompd_address_space_context_t *context = task_handle->ah->context;
952   if (!context)
953     return ompd_rc_stale_handle;
954   if (!callbacks) {
955     return ompd_rc_callback_error;
956   }
957 
958   ompd_rc_t ret = TValue(context, task_handle->th)
959                       .cast("kmp_taskdata_t") // td
960                       .access("td_flags")     // td->td_flags
961                       .cast("kmp_tasking_flags_t")
962                       .check("tasktype", val); // td->td_flags.tasktype
963   *val ^= 1; // tasktype: explicit = 1, implicit = 0 => invert the value
964   return ret;
965 }
966 
967 ompd_rc_t ompd_get_num_threads(
968     ompd_parallel_handle_t *parallel_handle, /* IN: OpenMP parallel handle */
969     ompd_word_t *val                         /* OUT: number of threads */
970 ) {
971   if (!parallel_handle->ah)
972     return ompd_rc_stale_handle;
973   ompd_address_space_context_t *context = parallel_handle->ah->context;
974   if (!context)
975     return ompd_rc_stale_handle;
976   if (!callbacks) {
977     return ompd_rc_callback_error;
978   }
979 
980   ompd_rc_t ret = ompd_rc_ok;
981   if (parallel_handle->lwt.address != 0) {
982     *val = 1;
983   } else {
984     uint32_t res;
985     ret = TValue(context, parallel_handle->th)
986               .cast("kmp_base_team_t", 0) /*t*/
987               .access("t_nproc")          /*t.t_nproc*/
988               .castBase()
989               .getValue(res);
990     *val = res;
991   }
992   return ret;
993 }
994 
995 ompd_rc_t ompd_get_icv_from_scope(void *handle, ompd_scope_t scope,
996                                   ompd_icv_id_t icv_id,
997                                   ompd_word_t *icv_value) {
998   if (!handle) {
999     return ompd_rc_stale_handle;
1000   }
1001   if (icv_id >= ompd_icv_after_last_icv || icv_id == 0) {
1002     return ompd_rc_bad_input;
1003   }
1004   if (scope != ompd_icv_scope_values[icv_id]) {
1005     return ompd_rc_bad_input;
1006   }
1007 
1008   ompd_device_t device_kind;
1009 
1010   switch (scope) {
1011   case ompd_scope_thread:
1012     device_kind = ((ompd_thread_handle_t *)handle)->ah->kind;
1013     break;
1014   case ompd_scope_parallel:
1015     device_kind = ((ompd_parallel_handle_t *)handle)->ah->kind;
1016     break;
1017   case ompd_scope_address_space:
1018     device_kind = ((ompd_address_space_handle_t *)handle)->kind;
1019     break;
1020   case ompd_scope_task:
1021     device_kind = ((ompd_task_handle_t *)handle)->ah->kind;
1022     break;
1023   default:
1024     return ompd_rc_bad_input;
1025   }
1026 
1027   if (device_kind == OMPD_DEVICE_KIND_HOST) {
1028     switch (icv_id) {
1029     case ompd_icv_dyn_var:
1030       return ompd_get_dynamic((ompd_thread_handle_t *)handle, icv_value);
1031     case ompd_icv_run_sched_var:
1032       return ompd_rc_incompatible;
1033     case ompd_icv_stacksize_var:
1034       return ompd_get_stacksize((ompd_address_space_handle_t *)handle,
1035                                 icv_value);
1036     case ompd_icv_cancel_var:
1037       return ompd_get_cancellation((ompd_address_space_handle_t *)handle,
1038                                    icv_value);
1039     case ompd_icv_max_task_priority_var:
1040       return ompd_get_max_task_priority((ompd_address_space_handle_t *)handle,
1041                                         icv_value);
1042     case ompd_icv_debug_var:
1043       return ompd_get_debug((ompd_address_space_handle_t *)handle, icv_value);
1044     case ompd_icv_nthreads_var:
1045       return ompd_get_nthreads((ompd_thread_handle_t *)handle, icv_value);
1046     case ompd_icv_display_affinity_var:
1047       return ompd_get_display_affinity((ompd_address_space_handle_t *)handle,
1048                                        icv_value);
1049     case ompd_icv_affinity_format_var:
1050       return ompd_rc_incompatible;
1051     case ompd_icv_tool_libraries_var:
1052       return ompd_rc_incompatible;
1053     case ompd_icv_default_device_var:
1054       return ompd_get_default_device((ompd_thread_handle_t *)handle, icv_value);
1055     case ompd_icv_tool_var:
1056       return ompd_get_tool((ompd_address_space_handle_t *)handle, icv_value);
1057     case ompd_icv_tool_verbose_init_var:
1058       return ompd_rc_incompatible;
1059     case ompd_icv_levels_var:
1060       return ompd_get_level((ompd_parallel_handle_t *)handle, icv_value);
1061     case ompd_icv_active_levels_var:
1062       return ompd_get_active_level((ompd_parallel_handle_t *)handle, icv_value);
1063     case ompd_icv_thread_limit_var:
1064       return ompd_get_thread_limit((ompd_task_handle_t *)handle, icv_value);
1065     case ompd_icv_max_active_levels_var:
1066       return ompd_get_max_active_levels((ompd_task_handle_t *)handle,
1067                                         icv_value);
1068     case ompd_icv_bind_var:
1069       return ompd_get_proc_bind((ompd_task_handle_t *)handle, icv_value);
1070     case ompd_icv_num_procs_var:
1071     case ompd_icv_ompd_num_procs_var:
1072       return ompd_get_num_procs((ompd_address_space_handle_t *)handle,
1073                                 icv_value);
1074     case ompd_icv_thread_num_var:
1075     case ompd_icv_ompd_thread_num_var:
1076       return ompd_get_thread_num((ompd_thread_handle_t *)handle, icv_value);
1077     case ompd_icv_final_var:
1078     case ompd_icv_ompd_final_var:
1079     case ompd_icv_ompd_final_task_var:
1080       return ompd_in_final((ompd_task_handle_t *)handle, icv_value);
1081     case ompd_icv_implicit_var:
1082     case ompd_icv_ompd_implicit_var:
1083     case ompd_icv_ompd_implicit_task_var:
1084       return ompd_is_implicit((ompd_task_handle_t *)handle, icv_value);
1085     case ompd_icv_team_size_var:
1086     case ompd_icv_ompd_team_size_var:
1087       return ompd_get_num_threads((ompd_parallel_handle_t *)handle, icv_value);
1088     default:
1089       return ompd_rc_unsupported;
1090     }
1091   }
1092   return ompd_rc_unsupported;
1093 }
1094 
1095 ompd_rc_t ompd_get_icv_string_from_scope(void *handle, ompd_scope_t scope,
1096                                          ompd_icv_id_t icv_id,
1097                                          const char **icv_string) {
1098   if (!handle) {
1099     return ompd_rc_stale_handle;
1100   }
1101   if (icv_id >= ompd_icv_after_last_icv || icv_id == 0) {
1102     return ompd_rc_bad_input;
1103   }
1104   if (scope != ompd_icv_scope_values[icv_id]) {
1105     return ompd_rc_bad_input;
1106   }
1107 
1108   ompd_device_t device_kind;
1109 
1110   switch (scope) {
1111   case ompd_scope_thread:
1112     device_kind = ((ompd_thread_handle_t *)handle)->ah->kind;
1113     break;
1114   case ompd_scope_parallel:
1115     device_kind = ((ompd_parallel_handle_t *)handle)->ah->kind;
1116     break;
1117   case ompd_scope_address_space:
1118     device_kind = ((ompd_address_space_handle_t *)handle)->kind;
1119     break;
1120   case ompd_scope_task:
1121     device_kind = ((ompd_task_handle_t *)handle)->ah->kind;
1122     break;
1123   default:
1124     return ompd_rc_bad_input;
1125   }
1126 
1127   if (device_kind == OMPD_DEVICE_KIND_HOST) {
1128     switch (icv_id) {
1129     case ompd_icv_run_sched_var:
1130       return ompd_get_run_schedule((ompd_task_handle_t *)handle, icv_string);
1131     case ompd_icv_nthreads_var:
1132       return ompd_get_nthreads((ompd_thread_handle_t *)handle, icv_string);
1133     case ompd_icv_bind_var:
1134       return ompd_get_proc_bind((ompd_task_handle_t *)handle, icv_string);
1135     case ompd_icv_affinity_format_var:
1136       return ompd_get_affinity_format((ompd_address_space_handle_t *)handle,
1137                                       icv_string);
1138     case ompd_icv_tool_libraries_var:
1139       return ompd_get_tool_libraries((ompd_address_space_handle_t *)handle,
1140                                      icv_string);
1141     case ompd_icv_tool_verbose_init_var:
1142       return ompd_get_tool_verbose_init((ompd_address_space_handle_t *)handle,
1143                                         icv_string);
1144     default:
1145       return ompd_rc_unsupported;
1146     }
1147   }
1148   return ompd_rc_unsupported;
1149 }
1150 
1151 static ompd_rc_t __ompd_get_tool_data(TValue &dataValue, ompd_word_t *value,
1152                                       ompd_address_t *ptr) {
1153   ompd_rc_t ret = dataValue.getError();
1154   if (ret != ompd_rc_ok)
1155     return ret;
1156   ret = dataValue.access("value").castBase().getValue(*value);
1157   if (ret != ompd_rc_ok)
1158     return ret;
1159   ptr->segment = OMPD_SEGMENT_UNSPECIFIED;
1160   ret = dataValue.access("ptr").castBase().getValue(ptr->address);
1161   return ret;
1162 }
1163 
1164 ompd_rc_t ompd_get_task_data(ompd_task_handle_t *task_handle,
1165                              ompd_word_t *value, ompd_address_t *ptr) {
1166   ompd_address_space_context_t *context = task_handle->ah->context;
1167   if (!context)
1168     return ompd_rc_stale_handle;
1169   if (!callbacks) {
1170     return ompd_rc_callback_error;
1171   }
1172 
1173   TValue dataValue;
1174   if (task_handle->lwt.address) {
1175     dataValue = TValue(context, task_handle->lwt)
1176                     .cast("ompt_lw_taskteam_t") /*lwt*/
1177                     .access("ompt_task_info")   // lwt->ompt_task_info
1178                     .cast("ompt_task_info_t")
1179                     .access("task_data") // lwt->ompd_task_info.task_data
1180                     .cast("ompt_data_t");
1181   } else {
1182     dataValue = TValue(context, task_handle->th)
1183                     .cast("kmp_taskdata_t")   /*td*/
1184                     .access("ompt_task_info") // td->ompt_task_info
1185                     .cast("ompt_task_info_t")
1186                     .access("task_data") // td->ompd_task_info.task_data
1187                     .cast("ompt_data_t");
1188   }
1189   return __ompd_get_tool_data(dataValue, value, ptr);
1190 }
1191 
1192 ompd_rc_t ompd_get_parallel_data(ompd_parallel_handle_t *parallel_handle,
1193                                  ompd_word_t *value, ompd_address_t *ptr) {
1194   ompd_address_space_context_t *context = parallel_handle->ah->context;
1195   if (!context)
1196     return ompd_rc_stale_handle;
1197   if (!callbacks) {
1198     return ompd_rc_callback_error;
1199   }
1200 
1201   TValue dataValue;
1202   if (parallel_handle->lwt.address) {
1203     dataValue =
1204         TValue(context, parallel_handle->lwt)
1205             .cast("ompt_lw_taskteam_t") /*lwt*/
1206             .access("ompt_team_info")   // lwt->ompt_team_info
1207             .cast("ompt_team_info_t")
1208             .access("parallel_data") // lwt->ompt_team_info.parallel_data
1209             .cast("ompt_data_t");
1210   } else {
1211     dataValue = TValue(context, parallel_handle->th)
1212                     .cast("kmp_base_team_t")  /*t*/
1213                     .access("ompt_team_info") // t->ompt_team_info
1214                     .cast("ompt_team_info_t")
1215                     .access("parallel_data") // t->ompt_team_info.parallel_data
1216                     .cast("ompt_data_t");
1217   }
1218   return __ompd_get_tool_data(dataValue, value, ptr);
1219 }
1220 
1221 ompd_rc_t ompd_get_thread_data(ompd_thread_handle_t *thread_handle,
1222                                ompd_word_t *value, ompd_address_t *ptr) {
1223   ompd_address_space_context_t *context = thread_handle->ah->context;
1224   if (!context)
1225     return ompd_rc_stale_handle;
1226   if (!callbacks) {
1227     return ompd_rc_callback_error;
1228   }
1229 
1230   TValue dataValue =
1231       TValue(context, thread_handle->th)
1232           .cast("kmp_base_info_t")    /*th*/
1233           .access("ompt_thread_info") // th->ompt_thread_info
1234           .cast("ompt_thread_info_t")
1235           .access("thread_data") // th->ompt_thread_info.thread_data
1236           .cast("ompt_data_t");
1237   return __ompd_get_tool_data(dataValue, value, ptr);
1238 }
1239 
1240 ompd_rc_t ompd_get_tool_data(void *handle, ompd_scope_t scope,
1241                              ompd_word_t *value, ompd_address_t *ptr) {
1242   if (!handle) {
1243     return ompd_rc_stale_handle;
1244   }
1245 
1246   ompd_device_t device_kind;
1247 
1248   switch (scope) {
1249   case ompd_scope_thread:
1250     device_kind = ((ompd_thread_handle_t *)handle)->ah->kind;
1251     break;
1252   case ompd_scope_parallel:
1253     device_kind = ((ompd_parallel_handle_t *)handle)->ah->kind;
1254     break;
1255   case ompd_scope_task:
1256     device_kind = ((ompd_task_handle_t *)handle)->ah->kind;
1257     break;
1258   default:
1259     return ompd_rc_bad_input;
1260   }
1261 
1262   if (device_kind == OMPD_DEVICE_KIND_HOST) {
1263     switch (scope) {
1264     case ompd_scope_thread:
1265       return ompd_get_thread_data((ompd_thread_handle_t *)handle, value, ptr);
1266     case ompd_scope_parallel:
1267       return ompd_get_parallel_data((ompd_parallel_handle_t *)handle, value,
1268                                     ptr);
1269     case ompd_scope_task:
1270       return ompd_get_task_data((ompd_task_handle_t *)handle, value, ptr);
1271     default:
1272       return ompd_rc_unsupported;
1273     }
1274   }
1275   return ompd_rc_unsupported;
1276 }
1277