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 146