openmp/runtime/src/kmp_taskdeps.h

   1 /*
   2  * kmp_taskdeps.h
   3  */
   4
   5
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   9 // See https://llvm.org/LICENSE.txt for license information.
  10 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14
  15 #ifndef KMP_TASKDEPS_H
  16 #define KMP_TASKDEPS_H
  17
  18 #include "kmp.h"
  19
  20 #define KMP_ACQUIRE_DEPNODE(gtid, n) __kmp_acquire_lock(&(n)->dn.lock, (gtid))
  21 #define KMP_RELEASE_DEPNODE(gtid, n) __kmp_release_lock(&(n)->dn.lock, (gtid))
  22
  23 static inline void __kmp_node_deref(kmp_info_t *thread, kmp_depnode_t *node) {
  24   if (!node)
  25     return;
  26
  27   kmp_int32 n = KMP_ATOMIC_DEC(&node->dn.nrefs) - 1;
  28   if (n == 0) {
  29     KMP_ASSERT(node->dn.nrefs == 0);
  30 #if USE_FAST_MEMORY
  31     __kmp_fast_free(thread, node);
  32 #else
  33     __kmp_thread_free(thread, node);
  34 #endif
  35   }
  36 }
  37
  38 static inline void __kmp_depnode_list_free(kmp_info_t *thread,
  39                                            kmp_depnode_list *list) {
  40   kmp_depnode_list *next;
  41
  42   for (; list; list = next) {
  43     next = list->next;
  44
  45     __kmp_node_deref(thread, list->node);
  46 #if USE_FAST_MEMORY
  47     __kmp_fast_free(thread, list);
  48 #else
  49     __kmp_thread_free(thread, list);
  50 #endif
  51   }
  52 }
  53
  54 static inline void __kmp_dephash_free_entries(kmp_info_t *thread,
  55                                               kmp_dephash_t *h) {
  56   for (size_t i = 0; i < h->size; i++) {
  57     if (h->buckets[i]) {
  58       kmp_dephash_entry_t *next;
  59       for (kmp_dephash_entry_t *entry = h->buckets[i]; entry; entry = next) {
  60         next = entry->next_in_bucket;
  61         __kmp_depnode_list_free(thread, entry->last_ins);
  62         __kmp_depnode_list_free(thread, entry->last_mtxs);
  63         __kmp_node_deref(thread, entry->last_out);
  64         if (entry->mtx_lock) {
  65           __kmp_destroy_lock(entry->mtx_lock);
  66           __kmp_free(entry->mtx_lock);
  67         }
  68 #if USE_FAST_MEMORY
  69         __kmp_fast_free(thread, entry);
  70 #else
  71         __kmp_thread_free(thread, entry);
  72 #endif
  73       }
  74       h->buckets[i] = 0;
  75     }
  76   }
  77 }
  78
  79 static inline void __kmp_dephash_free(kmp_info_t *thread, kmp_dephash_t *h) {
  80   __kmp_dephash_free_entries(thread, h);
  81 #if USE_FAST_MEMORY
  82   __kmp_fast_free(thread, h);
  83 #else
  84   __kmp_thread_free(thread, h);
  85 #endif
  86 }
  87
  88 static inline void __kmp_release_deps(kmp_int32 gtid, kmp_taskdata_t *task) {
  89   kmp_info_t *thread = __kmp_threads[gtid];
  90   kmp_depnode_t *node = task->td_depnode;
  91
  92   if (task->td_dephash) {
  93     KA_TRACE(
  94         40, ("__kmp_release_deps: T#%d freeing dependencies hash of task %p.\n",
  95              gtid, task));
  96     __kmp_dephash_free(thread, task->td_dephash);
  97     task->td_dephash = NULL;
  98   }
  99
 100   if (!node)
 101     return;
 102
 103   KA_TRACE(20, ("__kmp_release_deps: T#%d notifying successors of task %p.\n",
 104                 gtid, task));
 105
 106   KMP_ACQUIRE_DEPNODE(gtid, node);
 107   node->dn.task =
 108       NULL; // mark this task as finished, so no new dependencies are generated
 109   KMP_RELEASE_DEPNODE(gtid, node);
 110
 111   kmp_depnode_list_t *next;
 112   for (kmp_depnode_list_t *p = node->dn.successors; p; p = next) {
 113     kmp_depnode_t *successor = p->node;
 114     kmp_int32 npredecessors = KMP_ATOMIC_DEC(&successor->dn.npredecessors) - 1;
 115
 116     // successor task can be NULL for wait_depends or because deps are still
 117     // being processed
 118     if (npredecessors == 0) {
 119       KMP_MB();
 120       if (successor->dn.task) {
 121         KA_TRACE(20, ("__kmp_release_deps: T#%d successor %p of %p scheduled "
 122                       "for execution.\n",
 123                       gtid, successor->dn.task, task));
 124         __kmp_omp_task(gtid, successor->dn.task, false);
 125       }
 126     }
 127
 128     next = p->next;
 129     __kmp_node_deref(thread, p->node);
 130 #if USE_FAST_MEMORY
 131     __kmp_fast_free(thread, p);
 132 #else
 133     __kmp_thread_free(thread, p);
 134 #endif
 135   }
 136
 137   __kmp_node_deref(thread, node);
 138
 139   KA_TRACE(
 140       20,
 141       ("__kmp_release_deps: T#%d all successors of %p notified of completion\n",
 142        gtid, task));
 143 }
 144
 145 #endif // KMP_TASKDEPS_H