Debian Codegraph @

rts/python/opencl.py

raw
1 # Stub code for OpenCL setup.
2
3 import pyopencl as cl
4 import numpy as np
5 import sys
6
7 if cl.version.VERSION < (2015, 2):
8 raise Exception(
9 "Futhark requires at least PyOpenCL version 2015.2. Installed version is %s."
10 % cl.version.VERSION_TEXT
11 )
12
13 TR_BLOCK_DIM = 16
14 TR_TILE_DIM = TR_BLOCK_DIM * 2
15 TR_ELEMS_PER_THREAD = 8
16
17
18 def parse_preferred_device(s):
19 pref_num = 0
20 if len(s) > 1 and s[0] == "#":
21 i = 1
22 while i < len(s):
23 if not s[i].isdigit():
24 break
25 else:
26 pref_num = pref_num * 10 + int(s[i])
27 i += 1
28 while i < len(s) and s[i].isspace():
29 i += 1
30 return (s[i:], pref_num)
31 else:
32 return (s, 0)
33
34
35 def get_prefered_context(
36 interactive=False, platform_pref=None, device_pref=None
37 ):
38 if device_pref != None:
39 (device_pref, device_num) = parse_preferred_device(device_pref)
40 else:
41 device_num = 0
42
43 if interactive:
44 return cl.create_some_context(interactive=True)
45
46 def blacklisted(p, d):
47 return (
48 platform_pref == None
49 and device_pref == None
50 and p.name == "Apple"
51 and d.name.find("Intel(R) Core(TM)") >= 0
52 )
53
54 def platform_ok(p):
55 return not platform_pref or p.name.find(platform_pref) >= 0
56
57 def device_ok(d):
58 return not device_pref or d.name.find(device_pref) >= 0
59
60 device_matches = 0
61
62 for p in cl.get_platforms():
63 if not platform_ok(p):
64 continue
65 for d in p.get_devices():
66 if blacklisted(p, d) or not device_ok(d):
67 continue
68 if device_matches == device_num:
69 return cl.Context(devices=[d])
70 else:
71 device_matches += 1
72 raise Exception(
73 "No OpenCL platform and device matching constraints found."
74 )
75
76
77 def param_assignment(s):
78 name, value = s.split("=")
79 return (name, int(value))
80
81
82 def check_types(self, required_types):
83 if "f64" in required_types:
84 if (
85 self.device.get_info(cl.device_info.PREFERRED_VECTOR_WIDTH_DOUBLE)
86 == 0
87 ):
88 raise Exception(
89 "Program uses double-precision floats, but this is not supported on chosen device: %s"
90 % self.device.name
91 )
92
93
94 def apply_size_heuristics(self, size_heuristics, sizes):
95 for platform_name, device_type, size, valuef in size_heuristics:
96 if (
97 sizes[size] == None
98 and self.platform.name.find(platform_name) >= 0
99 and (self.device.type & device_type) == device_type
100 ):
101 sizes[size] = valuef(self.device)
102 return sizes
103
104
105 def to_c_str_rep(x):
106 if type(x) is bool or type(x) is np.bool_:
107 if x:
108 return "true"
109 else:
110 return "false"
111 else:
112 return str(x)
113
114
115 def initialise_opencl_object(
116 self,
117 program_src="",
118 build_options=[],
119 command_queue=None,
120 interactive=False,
121 platform_pref=None,
122 device_pref=None,
123 default_group_size=None,
124 default_num_groups=None,
125 default_tile_size=None,
126 default_reg_tile_size=None,
127 default_threshold=None,
128 size_heuristics=[],
129 required_types=[],
130 all_sizes={},
131 user_sizes={},
132 constants=[],
133 ):
134 if command_queue is None:
135 self.ctx = get_prefered_context(
136 interactive, platform_pref, device_pref
137 )
138 self.queue = cl.CommandQueue(self.ctx)
139 else:
140 self.ctx = command_queue.context
141 self.queue = command_queue
142 self.device = self.queue.device
143 self.platform = self.device.platform
144 self.pool = cl.tools.MemoryPool(cl.tools.ImmediateAllocator(self.queue))
145 device_type = self.device.type
146
147 check_types(self, required_types)
148
149 max_group_size = int(self.device.max_work_group_size)
150 max_tile_size = int(np.sqrt(self.device.max_work_group_size))
151
152 self.max_thread_block_size = max_group_size
153 self.max_tile_size = max_tile_size
154 self.max_threshold = 0
155 self.max_grid_size = 0
156
157 self.max_shared_memory = int(self.device.local_mem_size)
158
159 # Futhark reserves 4 bytes of local memory for its own purposes.
160 self.max_shared_memory -= 4
161
162 # See comment in rts/c/opencl.h.
163 if self.platform.name.find("NVIDIA CUDA") >= 0:
164 self.max_shared_memory -= 12
165 elif self.platform.name.find("AMD") >= 0:
166 self.max_shared_memory -= 16
167
168 self.max_registers = int(2**16) # Not sure how to query for this.
169
170 self.max_cache = self.device.get_info(cl.device_info.GLOBAL_MEM_CACHE_SIZE)
171
172 if self.max_cache == 0:
173 self.max_cache = 1024 * 1024
174
175 self.free_list = {}
176
177 self.global_failure = self.pool.allocate(np.int32().itemsize)
178 cl.enqueue_fill_buffer(
179 self.queue, self.global_failure, np.int32(-1), 0, np.int32().itemsize
180 )
181 self.global_failure_args = self.pool.allocate(
182 np.int64().itemsize * (self.global_failure_args_max + 1)
183 )
184 self.failure_is_an_option = np.int32(0)
185
186 if "default_group_size" in sizes:
187 default_group_size = sizes["default_group_size"]
188 del sizes["default_group_size"]
189
190 if "default_num_groups" in sizes:
191 default_num_groups = sizes["default_num_groups"]
192 del sizes["default_num_groups"]
193
194 if "default_tile_size" in sizes:
195 default_tile_size = sizes["default_tile_size"]
196 del sizes["default_tile_size"]
197
198 if "default_reg_tile_size" in sizes:
199 default_reg_tile_size = sizes["default_reg_tile_size"]
200 del sizes["default_reg_tile_size"]
201
202 if "default_threshold" in sizes:
203 default_threshold = sizes["default_threshold"]
204 del sizes["default_threshold"]
205
206 default_group_size_set = default_group_size != None
207 default_tile_size_set = default_tile_size != None
208 default_sizes = apply_size_heuristics(
209 self,
210 size_heuristics,
211 {
212 "group_size": default_group_size,
213 "tile_size": default_tile_size,
214 "reg_tile_size": default_reg_tile_size,
215 "num_groups": default_num_groups,
216 "lockstep_width": None,
217 "threshold": default_threshold,
218 },
219 )
220 default_group_size = default_sizes["group_size"]
221 default_num_groups = default_sizes["num_groups"]
222 default_threshold = default_sizes["threshold"]
223 default_tile_size = default_sizes["tile_size"]
224 default_reg_tile_size = default_sizes["reg_tile_size"]
225 lockstep_width = default_sizes["lockstep_width"]
226
227 if default_group_size > max_group_size:
228 if default_group_size_set:
229 sys.stderr.write(
230 "Note: Device limits group size to {} (down from {})\n".format(
231 max_tile_size, default_group_size
232 )
233 )
234 default_group_size = max_group_size
235
236 if default_tile_size > max_tile_size:
237 if default_tile_size_set:
238 sys.stderr.write(
239 "Note: Device limits tile size to {} (down from {})\n".format(
240 max_tile_size, default_tile_size
241 )
242 )
243 default_tile_size = max_tile_size
244
245 for k, v in user_sizes.items():
246 if k in all_sizes:
247 all_sizes[k]["value"] = v
248 else:
249 raise Exception(
250 "Unknown size: {}\nKnown sizes: {}".format(
251 k, " ".join(all_sizes.keys())
252 )
253 )
254
255 self.sizes = {}
256 for k, v in all_sizes.items():
257 if v["class"] == "thread_block_size":
258 max_value = max_group_size
259 default_value = default_group_size
260 elif v["class"] == "grid_size":
261 max_value = max_group_size # Intentional!
262 default_value = default_num_groups
263 elif v["class"] == "tile_size":
264 max_value = max_tile_size
265 default_value = default_tile_size
266 elif v["class"] == "reg_tile_size":
267 max_value = None
268 default_value = default_reg_tile_size
269 elif v["class"].startswith("shared_memory"):
270 max_value = self.max_shared_memory
271 default_value = self.max_shared_memory
272 elif v["class"].startswith("cache"):
273 max_value = self.max_cache
274 default_value = self.max_cache
275 elif v["class"].startswith("threshold"):
276 max_value = None
277 default_value = default_threshold
278 else:
279 # Bespoke sizes have no limit or default.
280 max_value = None
281 if v["value"] == None:
282 self.sizes[k] = default_value
283 elif max_value != None and v["value"] > max_value:
284 sys.stderr.write(
285 "Note: Device limits {} to {} (down from {}\n".format(
286 k, max_value, v["value"]
287 )
288 )
289 self.sizes[k] = max_value
290 else:
291 self.sizes[k] = v["value"]
292
293 # XXX: we perform only a subset of z-encoding here. Really, the
294 # compiler should provide us with the variables to which
295 # parameters are mapped.
296 if len(program_src) >= 0:
297 build_options += ["-DLOCKSTEP_WIDTH={}".format(lockstep_width)]
298
299 build_options += [
300 "-D{}={}".format("max_thread_block_size", max_group_size)
301 ]
302
303 build_options += [
304 "-D{}={}".format(
305 s.replace("z", "zz")
306 .replace(".", "zi")
307 .replace("#", "zh")
308 .replace("'", "zq"),
309 v,
310 )
311 for (s, v) in self.sizes.items()
312 ]
313
314 build_options += [
315 "-D{}={}".format(s, to_c_str_rep(f())) for (s, f) in constants
316 ]
317
318 if self.platform.name == "Oclgrind":
319 build_options += ["-DEMULATE_F16"]
320
321 build_options += [
322 f"-DTR_BLOCK_DIM={TR_BLOCK_DIM}",
323 f"-DTR_TILE_DIM={TR_TILE_DIM}",
324 f"-DTR_ELEMS_PER_THREAD={TR_ELEMS_PER_THREAD}",
325 ]
326
327 program = cl.Program(self.ctx, program_src).build(build_options)
328
329 self.transpose_kernels = {
330 1: {
331 "default": program.map_transpose_1b,
332 "low_height": program.map_transpose_1b_low_height,
333 "low_width": program.map_transpose_1b_low_width,
334 "small": program.map_transpose_1b_small,
335 "large": program.map_transpose_1b_large,
336 },
337 2: {
338 "default": program.map_transpose_2b,
339 "low_height": program.map_transpose_2b_low_height,
340 "low_width": program.map_transpose_2b_low_width,
341 "small": program.map_transpose_2b_small,
342 "large": program.map_transpose_2b_large,
343 },
344 4: {
345 "default": program.map_transpose_4b,
346 "low_height": program.map_transpose_4b_low_height,
347 "low_width": program.map_transpose_4b_low_width,
348 "small": program.map_transpose_4b_small,
349 "large": program.map_transpose_4b_large,
350 },
351 8: {
352 "default": program.map_transpose_8b,
353 "low_height": program.map_transpose_8b_low_height,
354 "low_width": program.map_transpose_8b_low_width,
355 "small": program.map_transpose_8b_small,
356 "large": program.map_transpose_8b_large,
357 },
358 }
359
360 self.copy_kernels = {
361 1: program.lmad_copy_1b,
362 2: program.lmad_copy_2b,
363 4: program.lmad_copy_4b,
364 8: program.lmad_copy_8b,
365 }
366
367 return program
368
369
370 def opencl_alloc(self, min_size, tag):
371 min_size = 4 if min_size == 0 else min_size
372 assert min_size > 0
373 # Round up to a multiple of four.
374 min_size = ((min_size + 3) // 4) * 4
375 return self.pool.allocate(min_size)
376
377
378 def opencl_free_all(self):
379 self.pool.free_held()
380
381
382 def sync(self):
383 failure = np.empty(1, dtype=np.int32)
384 cl.enqueue_copy(self.queue, failure, self.global_failure, is_blocking=True)
385 self.failure_is_an_option = np.int32(0)
386 if failure[0] >= 0:
387 # Reset failure information.
388 cl.enqueue_fill_buffer(
389 self.queue,
390 self.global_failure,
391 np.int32(-1),
392 0,
393 np.int32().itemsize,
394 )
395
396 # Read failure args.
397 failure_args = np.empty(
398 self.global_failure_args_max + 1, dtype=np.int64
399 )
400 cl.enqueue_copy(
401 self.queue,
402 failure_args,
403 self.global_failure_args,
404 is_blocking=True,
405 )
406
407 raise Exception(self.failure_msgs[failure[0]].format(*failure_args))
408
409
410 def map_transpose_gpu2gpu(
411 self, elem_size, dst, dst_offset, src, src_offset, k, n, m
412 ):
413 kernels = self.transpose_kernels[elem_size]
414 kernel = kernels["default"]
415 mulx = TR_BLOCK_DIM / n
416 muly = TR_BLOCK_DIM / m
417
418 group_dims = (TR_TILE_DIM, TR_TILE_DIM // TR_ELEMS_PER_THREAD, 1)
419 dims = (
420 (m + TR_TILE_DIM - 1) // TR_TILE_DIM * group_dims[0],
421 (n + TR_TILE_DIM - 1) // TR_TILE_DIM * group_dims[1],
422 k,
423 )
424
425 k32 = np.int32(k)
426 n32 = np.int32(n)
427 m32 = np.int32(m)
428 mulx32 = np.int32(mulx)
429 muly32 = np.int32(muly)
430
431 kernel.set_args(
432 cl.LocalMemory(TR_TILE_DIM * (TR_TILE_DIM + 1) * elem_size),
433 dst,
434 dst_offset,
435 src,
436 src_offset,
437 k32,
438 m32,
439 n32,
440 mulx32,
441 muly32,
442 np.int32(0),
443 np.int32(0),
444 )
445 cl.enqueue_nd_range_kernel(self.queue, kernel, dims, group_dims)
446
447
448 def copy_elements_gpu2gpu(
449 self,
450 elem_size,
451 dst,
452 dst_offset,
453 dst_strides,
454 src,
455 src_offset,
456 src_strides,
457 shape,
458 ):
459 r = len(shape)
460 if r > 8:
461 raise Exception(
462 "Futhark runtime limitation:\nCannot copy array of greater than rank 8.\n"
463 )
464
465 n = np.prod(shape)
466 zero = np.int64(0)
467 layout_args = [None] * (8 * 3)
468 for i in range(8):
469 if i < r:
470 layout_args[i * 3 + 0] = shape[i]
471 layout_args[i * 3 + 1] = dst_strides[i]
472 layout_args[i * 3 + 2] = src_strides[i]
473 else:
474 layout_args[i * 3 + 0] = zero
475 layout_args[i * 3 + 1] = zero
476 layout_args[i * 3 + 2] = zero
477
478 kernel = self.copy_kernels[elem_size]
479 kernel.set_args(
480 cl.LocalMemory(1),
481 dst,
482 dst_offset,
483 src,
484 src_offset,
485 n,
486 np.int32(r),
487 *layout_args,
488 )
489 w = 256
490 dims = ((n + w - 1) // w * w,)
491 group_dims = (w,)
492 cl.enqueue_nd_range_kernel(self.queue, kernel, dims, group_dims)
493
494
495 def lmad_copy_gpu2gpu(
496 self, pt, dst, dst_offset, dst_strides, src, src_offset, src_strides, shape
497 ):
498 elem_size = ct.sizeof(pt)
499 nbytes = np.prod(shape) * elem_size
500 if nbytes == 0:
501 return None
502 if lmad_memcpyable(dst_strides, src_strides, shape):
503 cl.enqueue_copy(
504 self.queue,
505 dst,
506 src,
507 dst_offset=dst_offset * elem_size,
508 src_offset=src_offset * elem_size,
509 byte_count=nbytes,
510 )
511 else:
512 tr = lmad_map_tr(dst_strides, src_strides, shape)
513 if tr is not None:
514 (k, n, m) = tr
515 map_transpose_gpu2gpu(
516 self, elem_size, dst, dst_offset, src, src_offset, k, m, n
517 )
518 else:
519 copy_elements_gpu2gpu(
520 self,
521 elem_size,
522 dst,
523 dst_offset,
524 dst_strides,
525 src,
526 src_offset,
527 src_strides,
528 shape,
529 )