Debian Codegraph @

libgomp/testsuite/libgomp.fortran/target-memcpy-rect-1.f90

raw
1 program main
2 use iso_c_binding
3 use omp_lib
4 implicit none (type, external)
5
6 integer(c_size_t), parameter :: sizeof_int = 4
7 integer, parameter :: sk = c_size_t
8 logical, allocatable :: isshared(:)
9 integer, allocatable :: maxdim(:,:)
10 integer :: ndev
11
12 ndev = omp_get_num_devices()
13 call init_isshared
14 call init_maxdim
15
16 call one
17 call two
18 call three
19 call four
20
21 deallocate(isshared, maxdim)
22 contains
23
24 subroutine init_maxdim
25 integer :: dev, dev2, r
26 integer(c_size_t), parameter :: nl = 0
27
28 allocate(maxdim(0:ndev,0:ndev))
29 do dev = 0, ndev
30 do dev2 = 0, ndev
31 r = omp_target_memcpy_rect (c_null_ptr, c_null_ptr, nl, &
32 num_dims=1_c_int, volume=[nl], &
33 dst_offsets=[nl], src_offsets=[nl], &
34 dst_dimensions=[nl], src_dimensions=[nl], &
35 dst_device_num=dev, src_device_num=omp_initial_device)
36 if (r < 3) stop 1 ! OpenMP requirement
37 if (r < huge(0_c_int)) stop 2 ! GCC implementation
38 maxdim(dev2,dev) = r
39 end do
40 end do
41 end subroutine
42
43 subroutine init_isshared
44 integer :: dev
45 logical :: dev_isshared
46
47 allocate(isshared(0:ndev))
48 do dev = 0, ndev
49 dev_isshared = .false.
50 !$omp target device(dev) map(to: dev_isshared)
51 dev_isshared = .true.
52 !$omp end target
53 isshared(dev) = dev_isshared
54 end do
55 end subroutine
56
57
58 subroutine one
59 integer(c_size_t), parameter :: N1 = 30
60 integer, target :: host_data(N1)
61 type(c_ptr) :: dev_cptr(0:ndev), cptr, tmp_cptr
62 integer :: dev, dev2, i, r
63
64 do dev = 0, ndev
65 dev_cptr(dev) = omp_target_alloc (N1*sizeof_int, dev)
66 if (.not. c_associated (dev_cptr(dev))) stop 11
67 end do
68
69 do i = 1, N1
70 host_data(i) = i
71 end do
72
73 ! copy full array host -> all devices + check value + set per-device value
74 do dev = 0, ndev
75 r = omp_target_memcpy_rect (dev_cptr(dev), c_loc(host_data), sizeof_int, &
76 num_dims=1_c_int, volume=[N1], &
77 dst_offsets=[0_sk], src_offsets=[0_sk], &
78 dst_dimensions=[N1], src_dimensions=[N1], &
79 dst_device_num=dev, src_device_num=omp_initial_device)
80 if (r /= 0) stop 12
81 cptr = dev_cptr(dev)
82 !$omp target device(dev) is_device_ptr(cptr)
83 block
84 integer, pointer, contiguous :: fptr(:)
85 call c_f_pointer(cptr, fptr, [N1])
86 do i = 1, N1
87 if (fptr(i) /= i) stop 13
88 fptr(i) = i*100 + 10000 * (dev+3)
89 end do
90 end block
91 end do
92
93 ! Test strided data - forth and back - same array sizes
94 do dev = 0, ndev
95 do dev2 = 0, ndev
96 tmp_cptr = omp_target_alloc (N1*sizeof_int, dev)
97 if (.not. c_associated (tmp_cptr)) stop 14
98
99 !$omp target device(dev) is_device_ptr(tmp_cptr)
100 block
101 integer, pointer, contiguous :: fptr(:)
102 call c_f_pointer(tmp_cptr, fptr, [N1])
103 do i = 1, N1
104 fptr(i) = i*100 + 10000*(dev+1)
105 end do
106 end block
107
108 if (N1-17 > N1 - max(12,13)) stop 18
109 r = omp_target_memcpy_rect (dev_cptr(dev2), tmp_cptr, sizeof_int, &
110 num_dims=1_c_int, volume=[N1-17], &
111 dst_offsets=[12_sk], src_offsets=[13_sk], &
112 dst_dimensions=[N1], src_dimensions=[N1], &
113 dst_device_num=dev2, src_device_num=dev)
114 if (r /= 0) stop 15
115
116 cptr = dev_cptr(dev2)
117 !$omp target device(dev2) is_device_ptr(cptr)
118 block
119 logical :: checked(N1)
120 integer, pointer, contiguous :: fptr(:)
121 call c_f_pointer(cptr, fptr, [N1])
122 checked = .false.
123 do i = 1, N1-17
124 if (fptr(i+12) /= (i+13)*100 + 10000 * (dev+1)) stop 16
125 checked(i+12) = .true.
126 end do
127 ! original device value
128 do i = 1, N1
129 if (.not. checked(i)) then
130 if (fptr(i) /= i*100 + 10000 * (dev2+3)) stop 17
131 end if
132 end do
133 end block
134 call omp_target_free (tmp_cptr, dev)
135 end do
136
137 ! reset to original value
138 do dev2 = 0, ndev
139 cptr = dev_cptr(dev2)
140 !$omp target device(dev2) is_device_ptr(cptr)
141 block
142 integer, pointer, contiguous :: fptr(:)
143 call c_f_pointer(cptr, fptr, [N1])
144 do i = 1, N1
145 fptr(i) = i*100 + 10000 * (dev2+3)
146 end do
147 end block
148 end do
149 end do
150
151 do dev = 0, ndev
152 call omp_target_free (dev_cptr(dev), dev)
153 end do
154 end subroutine
155
156
157 subroutine two
158 integer(c_size_t), parameter :: N = 10, M = 30
159 integer, target :: host_data(N,M)
160 type(c_ptr) :: dev_cptr(0:ndev), cptr, tmp_cptr
161 integer :: dev, dev2, i, j, r
162
163 do dev = 0, ndev
164 dev_cptr(dev) = omp_target_alloc (N*M*sizeof_int, dev)
165 if (.not. c_associated (dev_cptr(dev))) stop 21
166 end do
167
168 do i = 1, M
169 do j = 1, N
170 host_data(j,i) = i*100 + j
171 end do
172 end do
173
174 ! copy full array host -> all devices + check value + set per-device value
175 do dev = 0, ndev
176 r = omp_target_memcpy_rect (dev_cptr(dev), c_loc(host_data), sizeof_int, &
177 num_dims=2_c_int, volume=[M, N], &
178 dst_offsets=[0_sk, 0_sk], src_offsets=[0_sk, 0_sk], &
179 dst_dimensions=[M, N], src_dimensions=[M,N], &
180 dst_device_num=dev, src_device_num=omp_initial_device)
181 if (r /= 0) stop 22
182 cptr = dev_cptr(dev)
183 !$omp target device(dev) is_device_ptr(cptr)
184 block
185 integer, pointer, contiguous :: fptr(:,:)
186 call c_f_pointer(cptr, fptr, [N,M])
187 do i = 1, M
188 do j = 1, N
189 if (fptr(j,i) /= i*100 + j) stop 23
190 fptr(j,i) = i*100 + j + 1000 * dev
191 end do
192 end do
193 end block
194 end do
195
196 ! Test strided data - forth and back - same array sizes
197 do dev = 0, ndev
198 do dev2 = 0, ndev
199 tmp_cptr = omp_target_alloc (N*M*sizeof_int, dev)
200 if (.not. c_associated (tmp_cptr)) stop 24
201
202 !$omp target device(dev) is_device_ptr(tmp_cptr)
203 block
204 integer, pointer, contiguous :: fptr(:,:)
205 call c_f_pointer(tmp_cptr, fptr, [N,M])
206 do i = 1, M
207 do j = 1, N
208 fptr(j,i) = i*100 + j + 100000 * (dev+1)
209 end do
210 end do
211 end block
212
213 if (M-14 > M - max(5,2) &
214 .or. N-3 > N - max(2,1)) stop 28
215 r = omp_target_memcpy_rect (dev_cptr(dev2), tmp_cptr, sizeof_int, &
216 num_dims=2_c_int, volume=[M-14, N-3], &
217 dst_offsets=[5_sk, 3_sk], src_offsets=[2_sk, 1_sk], &
218 dst_dimensions=[M, N], src_dimensions=[M,N], &
219 dst_device_num=dev2, src_device_num=dev)
220 if (r /= 0) stop 25
221
222 cptr = dev_cptr(dev2)
223 !$omp target device(dev2) is_device_ptr(cptr)
224 block
225 logical :: checked(N,M)
226 integer, pointer, contiguous :: fptr(:,:)
227 call c_f_pointer(cptr, fptr, [N,M])
228 checked = .false.
229 do i = 1, M-14
230 do j = 1, N-3
231 if (fptr(j+3, i+5) /= (i+2)*100 + (j+1) + 100000 * (dev+1)) stop 26
232 checked(j+3, i+5) = .true.
233 end do
234 end do
235 ! original device value
236 do i = 1, M
237 do j = 1, N
238 if (.not. checked(j,i)) then
239 if (fptr(j,i) /= i*100 + j + 1000 * dev2) stop 27
240 end if
241 end do
242 end do
243 end block
244 call omp_target_free (tmp_cptr, dev)
245 end do
246
247 ! reset to original value
248 do dev2 = 0, ndev
249 cptr = dev_cptr(dev2)
250 !$omp target device(dev2) is_device_ptr(cptr)
251 block
252 integer, pointer, contiguous :: fptr(:,:)
253 call c_f_pointer(cptr, fptr, [N,M])
254 do i = 1, M
255 do j = 1, N
256 fptr(j,i) = i*100 + j + 1000 * dev2
257 end do
258 end do
259 end block
260 end do
261 end do
262
263 do dev = 0, ndev
264 call omp_target_free (dev_cptr(dev), dev)
265 end do
266 end subroutine
267
268
269 subroutine three
270 integer(c_size_t), parameter :: N1 = 10, N2 = 30, N3 = 15
271 integer, target :: host_data(N3,N2,N1)
272 type(c_ptr) :: dev_cptr(0:ndev), cptr, tmp_cptr
273 integer :: dev, dev2, i, j, k, r
274
275 do dev = 0, ndev
276 dev_cptr(dev) = omp_target_alloc (N1*N2*N3*sizeof_int, dev)
277 if (.not. c_associated (dev_cptr(dev))) stop 31
278 end do
279
280 do i = 1, N1
281 do j = 1, N2
282 do k = 1, N3
283 host_data(k, j,i) = i*1000 + 100*j + k
284 end do
285 end do
286 end do
287
288 ! copy full array host -> all devices + check value + set per-device value
289 do dev = 0, ndev
290 r = omp_target_memcpy_rect (dev_cptr(dev), c_loc(host_data), sizeof_int, &
291 num_dims=3_c_int, volume=[N1, N2, N3], &
292 dst_offsets=[0_sk, 0_sk, 0_sk], src_offsets=[0_sk, 0_sk, 0_sk], &
293 dst_dimensions=[N1, N2, N3], src_dimensions=[N1, N2, N3], &
294 dst_device_num=dev, src_device_num=omp_initial_device)
295 if (r /= 0) stop 32
296 cptr = dev_cptr(dev)
297 !$omp target device(dev) is_device_ptr(cptr)
298 block
299 integer, pointer, contiguous :: fptr(:,:,:)
300 call c_f_pointer(cptr, fptr, [N3,N2,N1])
301 do i = 1, N1
302 do j = 1, N2
303 do k = 1, N3
304 if (fptr(k, j,i) /= i*1000 + 100*j + k) stop 33
305 fptr(k,j,i) = i*1000 + 100*j + k + 1000 * dev
306 end do
307 end do
308 end do
309 end block
310 end do
311
312 ! Test strided data - forth and back - same array sizes
313 do dev = 0, ndev
314 do dev2 = 0, ndev
315 tmp_cptr = omp_target_alloc (N1*N2*N3*sizeof_int, dev)
316 if (.not. c_associated (tmp_cptr)) stop 34
317
318 !$omp target device(dev) is_device_ptr(tmp_cptr)
319 block
320 integer, pointer, contiguous :: fptr(:,:,:)
321 call c_f_pointer(tmp_cptr, fptr, [N3,N2,N1])
322 do i = 1, N1
323 do j = 1, N2
324 do k = 1, N3
325 fptr(k,j,i) = i*1000 + 100*j + k + 100000 * (dev+1)
326 end do
327 end do
328 end do
329 end block
330
331 if (N1-5 > N1 - max(5,2) &
332 .or. N2-13 > N2 - max(3,1) &
333 .or. N3-5 > N3 - max(2,4)) stop 38
334 r = omp_target_memcpy_rect (dev_cptr(dev2), tmp_cptr, sizeof_int, &
335 num_dims=3_c_int, volume=[N1-5, N2-13,N3-5], &
336 dst_offsets=[5_sk, 3_sk,2_sk], src_offsets=[2_sk, 1_sk,4_sk], &
337 dst_dimensions=[N1,N2,N3], src_dimensions=[N1,N2,N3], &
338 dst_device_num=dev2, src_device_num=dev)
339 if (r /= 0) stop 35
340
341 cptr = dev_cptr(dev2)
342 !$omp target device(dev2) is_device_ptr(cptr)
343 block
344 logical :: checked(N3,N2,N1)
345 integer, pointer, contiguous :: fptr(:,:,:)
346 call c_f_pointer(cptr, fptr, [N3,N2,N1])
347 checked = .false.
348 do i = 1, N1-5
349 do j = 1, N2-13
350 do k = 1, N3-5
351 if (fptr(k+2, j+3, i+5) /= (i+2)*1000 + 100*(j+1) + (k+4) + 100000 * (dev+1)) stop 36
352 checked(k+2, j+3, i+5) = .true.
353 end do
354 end do
355 end do
356 ! original device value
357 do i = 1, N1
358 do j = 1, N2
359 do k = 1, N3
360 if (.not. checked(k,j,i)) then
361 if (fptr(k,j,i) /= i*1000 + 100*j + k + 1000 * dev2) stop 37
362 end if
363 end do
364 end do
365 end do
366 end block
367 call omp_target_free (tmp_cptr, dev)
368 end do
369
370 ! reset to original value
371 do dev2 = 0, ndev
372 cptr = dev_cptr(dev2)
373 !$omp target device(dev2) is_device_ptr(cptr)
374 block
375 integer, pointer, contiguous :: fptr(:,:,:)
376 call c_f_pointer(cptr, fptr, [N3,N2,N1])
377 do i = 1, N1
378 do j = 1, N2
379 do k = 1, N3
380 fptr(k,j,i) = i*1000 + 100*j + k + 1000 * dev2
381 end do
382 end do
383 end do
384 end block
385 end do
386 end do
387
388 do dev = 0, ndev
389 call omp_target_free (dev_cptr(dev), dev)
390 end do
391 end subroutine
392
393
394 subroutine four
395 integer(c_size_t), parameter :: N1 = 10, N2 = 30, N3 = 15, N4 = 25
396 integer, target :: host_data(N4, N3,N2,N1)
397 type(c_ptr) :: dev_cptr(0:ndev), cptr, tmp_cptr
398 integer :: dev, dev2, i, j, k, ll, r
399
400 do dev = 0, ndev
401 dev_cptr(dev) = omp_target_alloc (N1*N2*N3*N4*sizeof_int, dev)
402 if (.not. c_associated (dev_cptr(dev))) stop 41
403 end do
404
405 do i = 1, N1
406 do j = 1, N2
407 do k = 1, N3
408 do ll = 1, N4
409 host_data(ll, k, j,i) = i*1000 + 100*j + k*10 + ll
410 end do
411 end do
412 end do
413 end do
414
415 ! copy full array host -> all devices + check value + set per-device value
416 do dev = 0, ndev
417 r = omp_target_memcpy_rect (dev_cptr(dev), c_loc(host_data), sizeof_int, &
418 num_dims=4_c_int, volume=[N1, N2, N3, N4], &
419 dst_offsets=[0_sk, 0_sk, 0_sk, 0_sk], src_offsets=[0_sk, 0_sk, 0_sk, 0_sk], &
420 dst_dimensions=[N1, N2, N3, N4], src_dimensions=[N1, N2, N3, N4], &
421 dst_device_num=dev, src_device_num=omp_initial_device)
422 if (r /= 0) stop 42
423 cptr = dev_cptr(dev)
424 !$omp target device(dev) is_device_ptr(cptr)
425 block
426 integer, pointer, contiguous :: fptr(:,:,:,:)
427 call c_f_pointer(cptr, fptr, [N4,N3,N2,N1])
428 do i = 1, N1
429 do j = 1, N2
430 do k = 1, N3
431 do ll = 1, N4
432 if (fptr(ll, k, j,i) /= i*1000 + 100*j + k*10 + ll) stop 43
433 fptr(ll,k,j,i) = i*1000 + 100*j + k*10 + ll + 1000 * dev
434 end do
435 end do
436 end do
437 end do
438 end block
439 end do
440
441 ! Test strided data - forth and back - same array sizes
442 do dev = 0, ndev
443 do dev2 = 0, ndev
444 tmp_cptr = omp_target_alloc (N1*N2*N3*N4*sizeof_int, dev)
445 if (.not. c_associated (tmp_cptr)) stop 44
446
447 !$omp target device(dev) is_device_ptr(tmp_cptr)
448 block
449 integer, pointer, contiguous :: fptr(:,:,:,:)
450 call c_f_pointer(tmp_cptr, fptr, [N4,N3,N2,N1])
451 do i = 1, N1
452 do j = 1, N2
453 do k = 1, N3
454 do ll = 1, N4
455 fptr(ll,k,j,i) = i*1000 + 100*j + k*10 + ll + 100000 * (dev+1)
456 end do
457 end do
458 end do
459 end do
460 end block
461
462 if (N1-5 > N1 - max(5,2) &
463 .or. N2-13 > N2 - max(3,1) &
464 .or. N3-5 > N3 - max(2,4) &
465 .or. N4-11 > N4 - max(7,5)) stop 48
466 r = omp_target_memcpy_rect (dev_cptr(dev2), tmp_cptr, sizeof_int, &
467 num_dims=4_c_int, volume=[N1-5, N2-13,N3-5,N4-11], &
468 dst_offsets=[5_sk, 3_sk,2_sk,7_sk], src_offsets=[2_sk, 1_sk,4_sk,5_sk], &
469 dst_dimensions=[N1,N2,N3,N4], src_dimensions=[N1,N2,N3,N4], &
470 dst_device_num=dev2, src_device_num=dev)
471 if (r /= 0) stop 45
472
473 cptr = dev_cptr(dev2)
474 !$omp target device(dev2) is_device_ptr(cptr)
475 block
476 logical, allocatable :: checked(:,:,:,:) ! allocatble to reduce stack size
477 integer, pointer, contiguous :: fptr(:,:,:,:)
478 call c_f_pointer(cptr, fptr, [N4,N3,N2,N1])
479 allocate (checked(N4,N3,N2,N1), source=.false.)
480 do i = 1, N1-5
481 do j = 1, N2-13
482 do k = 1, N3-5
483 do ll = 1, N4-11
484 if (fptr(ll+7, k+2, j+3, i+5) /= (i+2)*1000 + 100*(j+1) + (k+4)*10 + ll+5 + 100000 * (dev+1)) stop 46
485 checked(ll+7, k+2, j+3, i+5) = .true.
486 end do
487 end do
488 end do
489 end do
490 ! original device value
491 do i = 1, N1
492 do j = 1, N2
493 do k = 1, N3
494 do ll = 1, N4
495 if (.not. checked(ll,k,j,i)) then
496 if (fptr(ll,k,j,i) /= i*1000 + 100*j + k*10 + ll + 1000 * dev2) stop 47
497 end if
498 end do
499 end do
500 end do
501 end do
502 deallocate (checked)
503 end block
504 call omp_target_free (tmp_cptr, dev)
505 end do
506
507 ! reset to original value
508 do dev2 = 0, ndev
509 cptr = dev_cptr(dev2)
510 !$omp target device(dev2) is_device_ptr(cptr)
511 block
512 integer, pointer, contiguous :: fptr(:,:,:,:)
513 call c_f_pointer(cptr, fptr, [N4,N3,N2,N1])
514 do i = 1, N1
515 do j = 1, N2
516 do k = 1, N3
517 do ll = 1, N4
518 fptr(ll,k,j,i) = i*1000 + 100*j + k*10 + ll + 1000 * dev2
519 end do
520 end do
521 end do
522 end do
523 end block
524 end do
525 end do
526
527 do dev = 0, ndev
528 call omp_target_free (dev_cptr(dev), dev)
529 end do
530 end subroutine
531 end program