1 /* Copyright (C) 2017-2023 Free Software Foundation, Inc.
2 Contributed by Mentor Embedded.
3
4 This file is part of the GNU Offloading and Multi Processing Library
5 (libgomp).
6
7 Libgomp is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
14 FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 more details.
16
17 Under Section 7 of GPL version 3, you are granted additional
18 permissions described in the GCC Runtime Library Exception, version
19 3.1, as published by the Free Software Foundation.
20
21 You should have received a copy of the GNU General Public License and
22 a copy of the GCC Runtime Library Exception along with this program;
23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 <http://www.gnu.org/licenses/>. */
25
26 /* This file handles maintenance of threads on AMD GCN. */
27
28 #include "libgomp.h"
29 #include <stdlib.h>
30 #include <string.h>
31
32 static void gomp_thread_start (struct gomp_thread_pool *);
33
34 /* This externally visible function handles target region entry. It
35 sets up a per-team thread pool and transfers control by returning to
36 the kernel in the master thread or gomp_thread_start in other threads.
37
38 The name of this function is part of the interface with the compiler: for
39 each OpenMP kernel the compiler configures the stack, then calls here.
40
41 Likewise, gomp_gcn_exit_kernel is called during the kernel epilogue. */
42
43 void
44 gomp_gcn_enter_kernel (void)
45 {
46 int threadid = __builtin_gcn_dim_pos (1);
47
48 if (threadid == 0)
49 {
50 int numthreads = __builtin_gcn_dim_size (1);
51 int teamid = __builtin_gcn_dim_pos(0);
52
53 /* Set up the global state.
54 Every team will do this, but that should be harmless. */
55 gomp_global_icv.nthreads_var = 16;
56 gomp_global_icv.thread_limit_var = numthreads;
57 /* Starting additional threads is not supported. */
58 gomp_global_icv.dyn_var = true;
59
60 /* Initialize the team arena for optimized memory allocation.
61 The arena has been allocated on the host side, and the address
62 passed in via the kernargs. Each team takes a small slice of it. */
63 struct kernargs_abi *kernargs =
64 (struct kernargs_abi*) __builtin_gcn_kernarg_ptr ();
65 void *team_arena = ((void*)kernargs->arena_ptr
66 + kernargs->arena_size_per_team * teamid);
67 void * __lds *arena_start = (void * __lds *)TEAM_ARENA_START;
68 void * __lds *arena_free = (void * __lds *)TEAM_ARENA_FREE;
69 void * __lds *arena_end = (void * __lds *)TEAM_ARENA_END;
70 *arena_start = team_arena;
71 *arena_free = team_arena;
72 *arena_end = team_arena + kernargs->arena_size_per_team;
73
74 /* Allocate and initialize the team-local-storage data. */
75 struct gomp_thread *thrs = team_malloc_cleared (sizeof (*thrs)
76 * numthreads);
77 set_gcn_thrs (thrs);
78
79 /* Allocate and initialize a pool of threads in the team.
80 The threads are already running, of course, we just need to manage
81 the communication between them. */
82 struct gomp_thread_pool *pool = team_malloc (sizeof (*pool));
83 pool->threads = team_malloc (sizeof (void *) * numthreads);
84 for (int tid = 0; tid < numthreads; tid++)
85 pool->threads[tid] = &thrs[tid];
86 pool->threads_size = numthreads;
87 pool->threads_used = numthreads;
88 pool->threads_busy = 1;
89 pool->last_team = NULL;
90 gomp_simple_barrier_init (&pool->threads_dock, numthreads);
91 thrs->thread_pool = pool;
92
93 asm ("s_barrier" ::: "memory");
94 return; /* Return to kernel. */
95 }
96 else
97 {
98 asm ("s_barrier" ::: "memory");
99 gomp_thread_start (gcn_thrs ()[0].thread_pool);
100 /* gomp_thread_start does not return. */
101 }
102 }
103
104 void
105 gomp_gcn_exit_kernel (void)
106 {
107 gomp_free_thread (gcn_thrs ());
108 team_free (gcn_thrs ());
109 }
110
111 /* This function contains the idle loop in which a thread waits
112 to be called up to become part of a team. */
113
114 static void
115 gomp_thread_start (struct gomp_thread_pool *pool)
116 {
117 struct gomp_thread *thr = gomp_thread ();
118
119 gomp_sem_init (&thr->release, 0);
120 thr->thread_pool = pool;
121
122 /* The loop exits only when "fn" is assigned "gomp_free_pool_helper",
123 which contains "s_endpgm", or an infinite no-op loop is
124 suspected (this happens when the thread master crashes). */
125 int nul_limit = 99;
126 do
127 {
128 gomp_simple_barrier_wait (&pool->threads_dock);
129 if (!thr->fn)
130 {
131 if (nul_limit-- > 0)
132 continue;
133 else
134 {
135 const char msg[] = ("team master not responding;"
136 " slave thread aborting");
137 write (2, msg, sizeof (msg)-1);
138 abort();
139 }
140 }
141 thr->fn (thr->data);
142 thr->fn = NULL;
143
144 struct gomp_task *task = thr->task;
145 gomp_team_barrier_wait_final (&thr->ts.team->barrier);
146 gomp_finish_task (task);
147 }
148 while (1);
149 }
150
151 /* Launch a team. */
152
153 void
154 gomp_team_start (void (*fn) (void *), void *data, unsigned nthreads,
155 unsigned flags, struct gomp_team *team,
156 struct gomp_taskgroup *taskgroup)
157 {
158 struct gomp_thread *thr, *nthr;
159 struct gomp_task *task;
160 struct gomp_task_icv *icv;
161 struct gomp_thread_pool *pool;
162 unsigned long nthreads_var;
163
164 thr = gomp_thread ();
165 pool = thr->thread_pool;
166 task = thr->task;
167 icv = task ? &task->icv : &gomp_global_icv;
168
169 /* Always save the previous state, even if this isn't a nested team.
170 In particular, we should save any work share state from an outer
171 orphaned work share construct. */
172 team->prev_ts = thr->ts;
173
174 thr->ts.team = team;
175 thr->ts.team_id = 0;
176 ++thr->ts.level;
177 if (nthreads > 1)
178 ++thr->ts.active_level;
179 thr->ts.work_share = &team->work_shares[0];
180 thr->ts.last_work_share = NULL;
181 thr->ts.single_count = 0;
182 thr->ts.static_trip = 0;
183 thr->task = &team->implicit_task[0];
184 nthreads_var = icv->nthreads_var;
185 gomp_init_task (thr->task, task, icv);
186 team->implicit_task[0].icv.nthreads_var = nthreads_var;
187 team->implicit_task[0].taskgroup = taskgroup;
188
189 if (nthreads == 1)
190 return;
191
192 /* Release existing idle threads. */
193 for (unsigned i = 1; i < nthreads; ++i)
194 {
195 nthr = pool->threads[i];
196 nthr->ts.team = team;
197 nthr->ts.work_share = &team->work_shares[0];
198 nthr->ts.last_work_share = NULL;
199 nthr->ts.team_id = i;
200 nthr->ts.level = team->prev_ts.level + 1;
201 nthr->ts.active_level = thr->ts.active_level;
202 nthr->ts.single_count = 0;
203 nthr->ts.static_trip = 0;
204 nthr->task = &team->implicit_task[i];
205 gomp_init_task (nthr->task, task, icv);
206 team->implicit_task[i].icv.nthreads_var = nthreads_var;
207 team->implicit_task[i].taskgroup = taskgroup;
208 nthr->fn = fn;
209 nthr->data = data;
210 team->ordered_release[i] = &nthr->release;
211 }
212
213 gomp_simple_barrier_wait (&pool->threads_dock);
214 }
215
216 #include "../../team.c"