This is an archive of the discontinued LLVM Phabricator instance.

Differential D101326

[OpenMP][libomptarget][test] Separate lit tests for different offloading targets (2/2)
ClosedPublic

Authored by protze.joachim on Apr 26 2021, 2:27 PM.

Details

Reviewers
pdhaliwal
JonChesterfield
tianshilei1992
Meinersbur
jdoerfert
Commits
rG24f836e8fd6f: [OpenMP][libomptarget] Separate lit tests for different offloading targets (2/2)
Summary

The first part of this patch (D101315) separates libomptarget tests into a lit instance per offloading target.
This allows to fuse the RUN lines for most tests.

This patch updates the RUN lines in libomptarget tests to use a generic run line independent of the offloading target selected for the lit instance.

In cases, where no RUN line was defined for a specific offloading target, the corresponding target is declared as XFAIL. If it turns out that a test actually supports the target, the XFAIL line can be removed.

Diff Detail

Event Timeline

protze.joachim created this revision.Apr 26 2021, 2:27 PM
Herald added subscribers: guansong, yaxunl. · View Herald TranscriptApr 26 2021, 2:27 PM
protze.joachim requested review of this revision.Apr 26 2021, 2:27 PM
Herald added a reviewer: jdoerfert. · View Herald TranscriptApr 26 2021, 2:27 PM
Herald added a subscriber: sstefan1. · View Herald Transcript
protze.joachim added a parent revision: D101315: [OpenMP][libomptarget][test] Separate lit tests for different offloading targets.Apr 26 2021, 2:28 PM
protze.joachim mentioned this in D101315: [OpenMP][libomptarget][test] Separate lit tests for different offloading targets.
protze.joachim mentioned this in D99656: [AMDGPU][OpenMP] Enable Libomptarget runtime tests.Apr 26 2021, 2:35 PM
Harbormaster completed remote builds in B101025: Diff 340649.Apr 26 2021, 3:12 PM
JonChesterfield accepted this revision.Apr 26 2021, 4:01 PM

The signal to noise improvement here is superb, thank you.

It looks like the phabricator stack isn't used for the CI process, so it's probably worth landing D101315 and rebasing before landing this one.

This revision is now accepted and ready to land.Apr 26 2021, 4:01 PM
protze.joachim updated this revision to Diff 340782.Apr 27 2021, 3:35 AM

I rerun the tests for x86_64 and nvptx and removed the XFAIL for all tests succeeding in repeated tests.

With this update of the patch, the same 3 tests continue to fail, which also failed before the patch:

********************
Failed Tests (3):
  libomptarget :: x86_64-pc-linux-gnu :: offloading/bug49334.cpp
  libomptarget :: x86_64-pc-linux-gnu :: offloading/memory_manager.cpp
  libomptarget :: x86_64-pc-linux-gnu :: offloading/parallel_offloading_map.cpp
Harbormaster completed remote builds in B101122: Diff 340782.Apr 27 2021, 3:35 AM
protze.joachim added inline comments.Apr 27 2021, 3:38 AM
openmp/libomptarget/test/offloading/d2d_memcpy.c
1

For this test, only 2 out of 5 RUN lines had -allow-empty. I'm not totally sure, but does the flag make any sense when there is a CHECK line in the tests?

protze.joachim updated this revision to Diff 340785.EditedApr 27 2021, 3:50 AM

Rebased to master, fixing one conflict.

Harbormaster completed remote builds in B101123: Diff 340785.Apr 27 2021, 4:23 AM
Closed by commit rG24f836e8fd6f: [OpenMP][libomptarget] Separate lit tests for different offloading targets (2/2) (authored by protze.joachim). · Explain WhyApr 27 2021, 6:54 AM
This revision was automatically updated to reflect the committed changes.
protze.joachim added a commit: rG24f836e8fd6f: [OpenMP][libomptarget] Separate lit tests for different offloading targets (2/2).
protze.joachim mentioned this in D95976: [OpenMP] Simplify offloading parallel call codegen.Apr 29 2021, 2:04 AM
kkwli0 added a subscriber: kkwli0.Apr 29 2021, 11:02 AM

The following regressions seem to be caused by this patch on Power9+V100.

Unexpectedly Passed Tests (4):
  libomptarget :: nvptx64-nvidia-cuda :: unified_shared_memory/api.c
  libomptarget :: nvptx64-nvidia-cuda :: unified_shared_memory/close_enter_exit.c
  libomptarget :: nvptx64-nvidia-cuda :: unified_shared_memory/close_modifier.c
  libomptarget :: nvptx64-nvidia-cuda :: unified_shared_memory/shared_update.c
protze.joachim added a comment.Apr 29 2021, 12:48 PM

https://reviews.llvm.org/D101498 will fix this by allowing to distinguish
platforms supporting unified shared memory from platforms that don't.
Do you think, that looking at the gpu generation is sufficient, or does the
host architecture matter as well?

Kelvin Li via Phabricator <reviews@reviews.llvm.org> schrieb am Do., 29.
Apr. 2021, 20:02:

kkwli0 added a comment.

The following regressions seem to be caused by this patch on Power9+V100.

Unexpectedly Passed Tests (4):
  libomptarget :: nvptx64-nvidia-cuda :: unified_shared_memory/api.c
  libomptarget :: nvptx64-nvidia-cuda ::

unified_shared_memory/close_enter_exit.c

libomptarget :: nvptx64-nvidia-cuda ::

unified_shared_memory/close_modifier.c

libomptarget :: nvptx64-nvidia-cuda ::

unified_shared_memory/shared_update.c

Repository:

rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION

https://reviews.llvm.org/D101326/new/

https://reviews.llvm.org/D101326

protze.joachim mentioned this in D101498: [OpenMP] Test unified shared memory tests only on systems that support it..Apr 30 2021, 7:14 AM
jdenny mentioned this in D105208: [lit] Extend --xfail/LIT_XFAIL to take full test name.Jun 30 2021, 11:01 AM

Revision Contents

PathSize
openmp/
libomptarget/
test/
api/
3 lines
5 lines
5 lines
env/
7 lines
12 lines
10 lines
mapping/
22 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
14 lines
6 lines
6 lines
6 lines
6 lines
6 lines
present/
17 lines
41 lines
17 lines
41 lines
17 lines
17 lines
17 lines
17 lines
41 lines
83 lines
17 lines
17 lines
17 lines
6 lines
6 lines
41 lines
17 lines
83 lines
offloading/
1 line
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
1 line
6 lines
6 lines
2 lines
6 lines
7 lines
6 lines
6 lines
6 lines
6 lines
6 lines
unified_shared_memory/
6 lines
6 lines
5 lines
6 lines
6 lines

Diff 340825

openmp/libomptarget/test/api/is_initial_device.c

// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu // RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -DUNUSED -Wall -Werror // RUN: %libomptarget-compile-x86_64-pc-linux-gnu -DUNUSED -Wall -Werror
// only run for x86_64 host offloading:
// REQUIRES: x86_64-pc-linux-gnu
#include <omp.h> #include <omp.h>
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int errors = 0; int errors = 0;
#ifdef UNUSED #ifdef UNUSED
// Test if it is OK to leave the variants unused in the header // Test if it is OK to leave the variants unused in the header
#else // UNUSED #else // UNUSED
Show All 19 Lines

openmp/libomptarget/test/api/omp_get_num_devices.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
#include <omp.h> #include <omp.h>
int test_omp_get_num_devices() int test_omp_get_num_devices()
{ {
/* checks that omp_get_num_devices() > 0 */ /* checks that omp_get_num_devices() > 0 */
int num_devices = omp_get_num_devices(); int num_devices = omp_get_num_devices();
Show All 24 Lines

openmp/libomptarget/test/api/omp_get_num_devices_with_empty_target.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
#include <omp.h> #include <omp.h>
#include <stdio.h> #include <stdio.h>
static int test_omp_get_num_devices_with_empty_target() { static int test_omp_get_num_devices_with_empty_target() {
/* checks that omp_get_num_devices() > 0 */ /* checks that omp_get_num_devices() > 0 */
return omp_get_num_devices() > 0; return omp_get_num_devices() > 0;
} }
Show All 18 Lines

openmp/libomptarget/test/env/base_ptr_ref_count.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 | %fcheck-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-generic && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-generic 2>&1 | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-x86_64-pc-linux-gnu 2>&1 | %fcheck-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-nvptx64-nvidia-cuda && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-nvptx64-nvidia-cuda 2>&1 | %fcheck-nvptx64-nvidia-cuda
// REQUIRES: libomptarget-debug // REQUIRES: libomptarget-debug
#include <stdlib.h> #include <stdlib.h>
int *allocate(size_t n) { int *allocate(size_t n) {
int *ptr = malloc(sizeof(int) * n); int *ptr = malloc(sizeof(int) * n);
#pragma omp target enter data map(to : ptr[:n]) #pragma omp target enter data map(to : ptr[:n])
return ptr; return ptr;
Show All 29 Lines#pragma omp target
foo(); foo();
printf("Cnt = %d.\n", *cnt); printf("Cnt = %d.\n", *cnt);
// CHECK: Cnt = 1. // CHECK: Cnt = 1.
free(cnt); free(cnt);
return 0; return 0;
} }

openmp/libomptarget/test/env/omp_target_debug.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 | %fcheck-aarch64-unknown-linux-gnu -allow-empty -check-prefix=DEBUG // RUN: %libomptarget-compile-generic && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-generic 2>&1 | %fcheck-generic -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu && env LIBOMPTARGET_DEBUG=0 %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 | %fcheck-aarch64-unknown-linux-gnu -allow-empty -check-prefix=NDEBUG // RUN: %libomptarget-compile-generic && env LIBOMPTARGET_DEBUG=0 %libomptarget-run-generic 2>&1 | %fcheck-generic -allow-empty -check-prefix=NDEBUG
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 | %fcheck-powerpc64-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=0 %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 | %fcheck-powerpc64-ibm-linux-gnu -allow-empty -check-prefix=NDEBUG
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 | %fcheck-powerpc64le-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=0 %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 | %fcheck-powerpc64le-ibm-linux-gnu -allow-empty -check-prefix=NDEBUG
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-x86_64-pc-linux-gnu 2>&1 | %fcheck-x86_64-pc-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu && env LIBOMPTARGET_DEBUG=0 %libomptarget-run-x86_64-pc-linux-gnu 2>&1 | %fcheck-x86_64-pc-linux-gnu -allow-empty -check-prefix=NDEBUG
// RUN: %libomptarget-compile-nvptx64-nvidia-cuda && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-nvptx64-nvidia-cuda 2>&1 | %fcheck-nvptx64-nvidia-cuda -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-nvptx64-nvidia-cuda && env LIBOMPTARGET_DEBUG=0 %libomptarget-run-nvptx64-nvidia-cuda 2>&1 | %fcheck-nvptx64-nvidia-cuda -allow-empty -check-prefix=NDEBUG
// REQUIRES: libomptarget-debug // REQUIRES: libomptarget-debug
int main(void) { int main(void) {
#pragma omp target #pragma omp target
{} {}
return 0; return 0;
} }
// DEBUG: Libomptarget // DEBUG: Libomptarget
// NDEBUG-NOT: Libomptarget // NDEBUG-NOT: Libomptarget
// NDEBUG-NOT: Target // NDEBUG-NOT: Target

openmp/libomptarget/test/lit.cfg

Show First 20 Lines • Show All 123 Lines • ▼ Show 20 Lines if libomptarget_target == config.libomptarget_current_target:
"%libomptarget-compilexx-" + libomptarget_target + " && " + \ "%libomptarget-compilexx-" + libomptarget_target + " && " + \
"%libomptarget-run-" + libomptarget_target)) "%libomptarget-run-" + libomptarget_target))
config.substitutions.append(("%libomptarget-compile-and-run-" + \ config.substitutions.append(("%libomptarget-compile-and-run-" + \
libomptarget_target, \ libomptarget_target, \
"%libomptarget-compile-" + libomptarget_target + " && " + \ "%libomptarget-compile-" + libomptarget_target + " && " + \
"%libomptarget-run-" + libomptarget_target)) "%libomptarget-run-" + libomptarget_target))
config.substitutions.append(("%libomptarget-compilexx-" + \ config.substitutions.append(("%libomptarget-compilexx-" + \
libomptarget_target, \ libomptarget_target, \
"%clangxx-" + libomptarget_target + " %s -o %t-" + \ "%clangxx-" + libomptarget_target + " %s -o %t"))
libomptarget_target))
config.substitutions.append(("%libomptarget-compile-" + \ config.substitutions.append(("%libomptarget-compile-" + \
libomptarget_target, \ libomptarget_target, \
"%clang-" + libomptarget_target + " %s -o %t-" + \ "%clang-" + libomptarget_target + " %s -o %t"))
libomptarget_target))
config.substitutions.append(("%libomptarget-run-" + \ config.substitutions.append(("%libomptarget-run-" + \
libomptarget_target, \ libomptarget_target, \
"%t-" + libomptarget_target)) "%t"))
config.substitutions.append(("%libomptarget-run-fail-" + \ config.substitutions.append(("%libomptarget-run-fail-" + \
libomptarget_target, \ libomptarget_target, \
"%not --crash %t-" + libomptarget_target)) "%not --crash %t"))
config.substitutions.append(("%clangxx-" + libomptarget_target, \ config.substitutions.append(("%clangxx-" + libomptarget_target, \
"%clangxx %openmp_flags %flags -fopenmp-targets=" + libomptarget_target)) "%clangxx %openmp_flags %flags -fopenmp-targets=" + libomptarget_target))
config.substitutions.append(("%clang-" + libomptarget_target, \ config.substitutions.append(("%clang-" + libomptarget_target, \
"%clang %openmp_flags %flags -fopenmp-targets=" + libomptarget_target)) "%clang %openmp_flags %flags -fopenmp-targets=" + libomptarget_target))
config.substitutions.append(("%fcheck-" + libomptarget_target, \ config.substitutions.append(("%fcheck-" + libomptarget_target, \
config.libomptarget_filecheck + " %s")) config.libomptarget_filecheck + " %s"))
else: else:
config.substitutions.append(("%libomptarget-compile-run-and-check-" + \ config.substitutions.append(("%libomptarget-compile-run-and-check-" + \
Show All 35 Lines

openmp/libomptarget/test/mapping/alloc_fail.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-generic
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-nvptx64-nvidia-cuda
// RUN: %libomptarget-run-fail-nvptx64-nvidia-cuda 2>&1 \
// RUN: | %fcheck-nvptx64-nvidia-cuda
// CHECK: Libomptarget message: explicit extension not allowed: host address specified is 0x{{.*}} (8 bytes), but device allocation maps to host at 0x{{.*}} (8 bytes) // CHECK: Libomptarget message: explicit extension not allowed: host address specified is 0x{{.*}} (8 bytes), but device allocation maps to host at 0x{{.*}} (8 bytes)
// CHECK: Libomptarget error: Call to getOrAllocTgtPtr returned null pointer (device failure or illegal mapping). // CHECK: Libomptarget error: Call to getOrAllocTgtPtr returned null pointer (device failure or illegal mapping).
// CHECK: Libomptarget fatal error 1: failure of target construct while offloading is mandatory // CHECK: Libomptarget fatal error 1: failure of target construct while offloading is mandatory
int main() { int main() {
int arr[4] = {0, 1, 2, 3}; int arr[4] = {0, 1, 2, 3};
#pragma omp target data map(alloc: arr[0:2]) #pragma omp target data map(alloc: arr[0:2])
#pragma omp target data map(alloc: arr[1:2]) #pragma omp target data map(alloc: arr[1:2])
; ;
return 0; return 0;
} }

openmp/libomptarget/test/mapping/data_absent_at_exit.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
#include <stdio.h> #include <stdio.h>
// OpenMP 5.1, sec. 2.21.7.1 "map Clause", p. 351 L14-16: // OpenMP 5.1, sec. 2.21.7.1 "map Clause", p. 351 L14-16:
// "If the map clause appears on a target, target data, or target exit data // "If the map clause appears on a target, target data, or target exit data
// construct and a corresponding list item of the original list item is not // construct and a corresponding list item of the original list item is not
// present in the device data environment on exit from the region then the // present in the device data environment on exit from the region then the
// list item is ignored." // list item is ignored."
Show All 20 Lines

openmp/libomptarget/test/mapping/data_member_ref.cpp

// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-run-and-check-generic
// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
#include <stdio.h> #include <stdio.h>
struct View { struct View {
int Data; int Data;
}; };
struct ViewPtr { struct ViewPtr {
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

openmp/libomptarget/test/mapping/declare_mapper_api.cpp

// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-run-and-check-generic
// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <vector> #include <vector>
#include <cinttypes> #include <cinttypes>
// Data structure definitions copied from OpenMP RTL. // Data structure definitions copied from OpenMP RTL.
struct MapComponentInfoTy { struct MapComponentInfoTy {
Show All 38 Lines

openmp/libomptarget/test/mapping/declare_mapper_nested_default_mappers.cpp

// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-run-and-check-generic
// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
typedef struct { typedef struct {
int a; int a;
double *b; double *b;
} C1; } C1;
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

openmp/libomptarget/test/mapping/declare_mapper_nested_mappers.cpp

// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-run-and-check-generic
// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
typedef struct { typedef struct {
int a; int a;
double *b; double *b;
} C; } C;
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

openmp/libomptarget/test/mapping/declare_mapper_target.cpp

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#define NUM 1024 #define NUM 1024
class C { class C {
public: public:
Show All 24 Lines

openmp/libomptarget/test/mapping/declare_mapper_target_data.cpp

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#define NUM 1024 #define NUM 1024
class C { class C {
public: public:
int *a; int *a;
}; };
#pragma omp declare mapper(id: C s) map(s.a[0:NUM]) #pragma omp declare mapper(id: C s) map(s.a[0:NUM])
int main() { int main() {
C c; C c;
c.a = (int*) malloc(sizeof(int)*NUM); c.a = (int*) malloc(sizeof(int)*NUM);
for (int i = 0; i < NUM; i++) { for (int i = 0; i < NUM; i++) {
c.a[i] = 1; c.a[i] = 1;
} }
#pragma omp target data map(mapper(id),tofrom: c) #pragma omp target data map(mapper(id),tofrom: c)
{ {
#pragma omp target teams distribute parallel for #pragma omp target teams distribute parallel for
for (int i = 0; i < NUM; i++) { for (int i = 0; i < NUM; i++) {
++c.a[i]; ++c.a[i];
} }
} }
int sum = 0; int sum = 0;
for (int i = 0; i < NUM; i++) { for (int i = 0; i < NUM; i++) {
sum += c.a[i]; sum += c.a[i];
} }
// CHECK: Sum = 2048 // CHECK: Sum = 2048
printf("Sum = %d\n", sum); printf("Sum = %d\n", sum);
return 0; return 0;
} }

openmp/libomptarget/test/mapping/declare_mapper_target_data_enter_exit.cpp

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#define NUM 1024 #define NUM 1024
class C { class C {
public: public:
Show All 26 Lines

openmp/libomptarget/test/mapping/declare_mapper_target_update.cpp

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#define NUM 1024 #define NUM 1024
class C { class C {
public: public:
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

openmp/libomptarget/test/mapping/delete_inf_refcount.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
#include <stdio.h> #include <stdio.h>
#include <omp.h> #include <omp.h>
#pragma omp declare target #pragma omp declare target
int isHost; int isHost;
#pragma omp end declare target #pragma omp end declare target
Show All 20 Lines

openmp/libomptarget/test/mapping/lambda_mapping.cpp

// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-run-and-check-generic
// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
#include <iostream> #include <iostream>
template <typename LOOP_BODY> template <typename LOOP_BODY>
inline void forall(int Begin, int End, LOOP_BODY LoopBody) { inline void forall(int Begin, int End, LOOP_BODY LoopBody) {
#pragma omp target parallel for schedule(static) #pragma omp target parallel for schedule(static)
for (int I = Begin; I < End; ++I) { for (int I = Begin; I < End; ++I) {
LoopBody(I); LoopBody(I);
Show All 40 Lines

openmp/libomptarget/test/mapping/pr38704.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
// Clang 6.0 doesn't use the new map interface, undefined behavior when // Clang 6.0 doesn't use the new map interface, undefined behavior when
// the compiler emits "old" interface code for structures. // the compiler emits "old" interface code for structures.
// UNSUPPORTED: clang-6 // UNSUPPORTED: clang-6
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
Show All 35 Lines

openmp/libomptarget/test/mapping/present/target.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu -fopenmp-version=51 // RUN: %libomptarget-compile-generic -fopenmp-version=51
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int i; int i;
// CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]] // CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]]
fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i); fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i);
Show All 22 Lines

openmp/libomptarget/test/mapping/present/target_array_extension.c

// -------------------------------------------------- // --------------------------------------------------
// Check extends before // Check extends before
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE // RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// -------------------------------------------------- // --------------------------------------------------
// Check extends after // Check extends after
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER // RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// END. // END.
#include <stdio.h> #include <stdio.h>
#define BEFORE 0 #define BEFORE 0
#define AFTER 1 #define AFTER 1
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

openmp/libomptarget/test/mapping/present/target_data.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu -fopenmp-version=51 // RUN: %libomptarget-compile-generic -fopenmp-version=51
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int i; int i;
// CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]] // CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]]
fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i); fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i);
Show All 19 Lines

openmp/libomptarget/test/mapping/present/target_data_array_extension.c

// -------------------------------------------------- // --------------------------------------------------
// Check extends before // Check extends before
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE // RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// -------------------------------------------------- // --------------------------------------------------
// Check extends after // Check extends after
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER // RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// END. // END.
#include <stdio.h> #include <stdio.h>
#define BEFORE 0 #define BEFORE 0
#define AFTER 1 #define AFTER 1
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

openmp/libomptarget/test/mapping/present/target_data_at_exit.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu -fopenmp-version=51 // RUN: %libomptarget-compile-generic -fopenmp-version=51
// RUN: %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int i; int i;
#pragma omp target enter data map(alloc:i) #pragma omp target enter data map(alloc:i)
Show All 14 Lines

openmp/libomptarget/test/mapping/present/target_enter_data.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu -fopenmp-version=51 // RUN: %libomptarget-compile-generic -fopenmp-version=51
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int i; int i;
// CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]] // CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]]
fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i); fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i);
Show All 19 Lines

openmp/libomptarget/test/mapping/present/target_exit_data_delete.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu -fopenmp-version=51 // RUN: %libomptarget-compile-generic -fopenmp-version=51
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int i; int i;
// CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]] // CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]]
fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i); fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i);
Show All 17 Lines

openmp/libomptarget/test/mapping/present/target_exit_data_release.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu -fopenmp-version=51 // RUN: %libomptarget-compile-generic -fopenmp-version=51
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int i; int i;
// CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]] // CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]]
fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i); fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i);
Show All 17 Lines

openmp/libomptarget/test/mapping/present/target_update.c

// -------------------------------------------------- // --------------------------------------------------
// Check 'to' // Check 'to'
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DCLAUSE=to // RUN: -fopenmp-version=51 -DCLAUSE=to
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=to
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=to
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=to
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// -------------------------------------------------- // --------------------------------------------------
// Check 'from' // Check 'from'
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DCLAUSE=from // RUN: -fopenmp-version=51 -DCLAUSE=from
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=from
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=from
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=from
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int i; int i;
// CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]] // CHECK: addr=0x[[#%x,HOST_ADDR:]], size=[[#%u,SIZE:]]
fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i); fprintf(stderr, "addr=%p, size=%ld\n", &i, sizeof i);
Show All 18 Lines

openmp/libomptarget/test/mapping/present/target_update_array_extension.c

// -------------------------------------------------- // --------------------------------------------------
// Check 'to' and extends before // Check 'to' and extends before
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DCLAUSE=to -DEXTENDS=BEFORE // RUN: -fopenmp-version=51 -DCLAUSE=to -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=to -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=to -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=to -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// -------------------------------------------------- // --------------------------------------------------
// Check 'from' and extends before // Check 'from' and extends before
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DCLAUSE=from -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=from -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=from -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=from -DEXTENDS=BEFORE // RUN: -fopenmp-version=51 -DCLAUSE=from -DEXTENDS=BEFORE
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu // RUN: | %fcheck-generic
// -------------------------------------------------- // --------------------------------------------------
// Check 'to' and extends after // Check 'to' and extends after
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DCLAUSE=to -DEXTENDS=AFTER // RUN: -fopenmp-version=51 -DCLAUSE=to -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=to -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=to -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=to -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// -------------------------------------------------- // --------------------------------------------------
// Check 'from' and extends after // Check 'from' and extends after
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DCLAUSE=from -DEXTENDS=AFTER // RUN: -fopenmp-version=51 -DCLAUSE=from -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=from -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=from -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DCLAUSE=from -DEXTENDS=AFTER
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// END. // END.
#include <stdio.h> #include <stdio.h>
#define BEFORE 0 #define BEFORE 0
#define AFTER 1 #define AFTER 1
Show All 37 Lines

openmp/libomptarget/test/mapping/present/unified_shared_memory.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu -fopenmp-version=51 // RUN: %libomptarget-compile-generic -fopenmp-version=51
// RUN: %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
// The runtime considers unified shared memory to be always present. // The runtime considers unified shared memory to be always present.
#pragma omp requires unified_shared_memory #pragma omp requires unified_shared_memory
int main() { int main() {
int i; int i;
Show All 18 Lines

openmp/libomptarget/test/mapping/present/zero_length_array_section.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu -fopenmp-version=51 // RUN: %libomptarget-compile-generic -fopenmp-version=51
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int arr[5]; int arr[5];
// CHECK: addr=0x[[#%x,HOST_ADDR:]] // CHECK: addr=0x[[#%x,HOST_ADDR:]]
fprintf(stderr, "addr=%p\n", arr); fprintf(stderr, "addr=%p\n", arr);
Show All 25 Lines

openmp/libomptarget/test/mapping/present/zero_length_array_section_exit.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu -fopenmp-version=51 // RUN: %libomptarget-compile-generic -fopenmp-version=51
// RUN: %libomptarget-run-fail-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-fail-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -fopenmp-version=51
// RUN: %libomptarget-run-fail-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int arr[5]; int arr[5];
// CHECK: addr=0x[[#%x,HOST_ADDR:]] // CHECK: addr=0x[[#%x,HOST_ADDR:]]
fprintf(stderr, "addr=%p\n", arr); fprintf(stderr, "addr=%p\n", arr);
Show All 20 Lines

openmp/libomptarget/test/mapping/private_mapping.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int data1[3] = {1}, data2[3] = {2}, data3[3] = {3}; int data1[3] = {1}, data2[3] = {2}, data3[3] = {3};
int sum[16] = {0}; int sum[16] = {0};
#pragma omp target teams distribute parallel for map(tofrom \ #pragma omp target teams distribute parallel for map(tofrom \
Show All 20 Lines

openmp/libomptarget/test/mapping/ptr_and_obj_motion.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
#include <stdio.h> #include <stdio.h>
typedef struct { typedef struct {
double *dataptr; double *dataptr;
int dummy1; int dummy1;
int dummy2; int dummy2;
} DV; } DV;
Show All 35 Lines

openmp/libomptarget/test/mapping/target_data_array_extension_at_exit.c

// -------------------------------------------------- // --------------------------------------------------
// Check extends before // Check extends before
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE // RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=BEFORE
// RUN: %libomptarget-run-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// -------------------------------------------------- // --------------------------------------------------
// Check extends after // Check extends after
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER // RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -fopenmp-version=51 -DEXTENDS=AFTER
// RUN: %libomptarget-run-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// END. // END.
#include <stdio.h> #include <stdio.h>
#define BEFORE 0 #define BEFORE 0
#define AFTER 1 #define AFTER 1
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

openmp/libomptarget/test/mapping/target_implicit_partial_map.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-generic
// RUN: %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu
// RUN: %libomptarget-run-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
//
// END. // END.
#include <omp.h> #include <omp.h>
#include <stdio.h> #include <stdio.h>
int main() { int main() {
int arr[100]; int arr[100];
Show All 15 Lines

openmp/libomptarget/test/mapping/target_update_array_extension.c

// -------------------------------------------------- // --------------------------------------------------
// Check 'to' and extends before // Check 'to' and extends before
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -DCLAUSE=to -DEXTENDS=BEFORE // RUN: -DCLAUSE=to -DEXTENDS=BEFORE
// RUN: %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -DCLAUSE=to -DEXTENDS=BEFORE
// RUN: %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -DCLAUSE=to -DEXTENDS=BEFORE
// RUN: %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -DCLAUSE=to -DEXTENDS=BEFORE
// RUN: %libomptarget-run-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// -------------------------------------------------- // --------------------------------------------------
// Check 'from' and extends before // Check 'from' and extends before
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -DCLAUSE=from -DEXTENDS=BEFORE
// RUN: %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -DCLAUSE=from -DEXTENDS=BEFORE
// RUN: %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -DCLAUSE=from -DEXTENDS=BEFORE
// RUN: %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -DCLAUSE=from -DEXTENDS=BEFORE // RUN: -DCLAUSE=from -DEXTENDS=BEFORE
// RUN: %libomptarget-run-x86_64-pc-linux-gnu 2>&1 \ // RUN: %libomptarget-run-generic 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu // RUN: | %fcheck-generic
// -------------------------------------------------- // --------------------------------------------------
// Check 'to' and extends after // Check 'to' and extends after
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -DCLAUSE=to -DEXTENDS=AFTER // RUN: -DCLAUSE=to -DEXTENDS=AFTER
// RUN: %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -DCLAUSE=to -DEXTENDS=AFTER
// RUN: %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -DCLAUSE=to -DEXTENDS=AFTER
// RUN: %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -DCLAUSE=to -DEXTENDS=AFTER
// RUN: %libomptarget-run-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// -------------------------------------------------- // --------------------------------------------------
// Check 'from' and extends after // Check 'from' and extends after
// -------------------------------------------------- // --------------------------------------------------
// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu \ // RUN: %libomptarget-compile-generic \
// RUN: -DCLAUSE=from -DEXTENDS=AFTER // RUN: -DCLAUSE=from -DEXTENDS=AFTER
// RUN: %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 \ // RUN: %libomptarget-run-generic 2>&1 \
// RUN: | %fcheck-aarch64-unknown-linux-gnu // RUN: | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu \
// RUN: -DCLAUSE=from -DEXTENDS=AFTER
// RUN: %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu \
// RUN: -DCLAUSE=from -DEXTENDS=AFTER
// RUN: %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 \
// RUN: | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu \
// RUN: -DCLAUSE=from -DEXTENDS=AFTER
// RUN: %libomptarget-run-x86_64-pc-linux-gnu 2>&1 \
// RUN: | %fcheck-x86_64-pc-linux-gnu
// END. // END.
#include <stdio.h> #include <stdio.h>
#define BEFORE 0 #define BEFORE 0
#define AFTER 1 #define AFTER 1
Show All 33 Lines

openmp/libomptarget/test/offloading/assert.cpp

// RUN: %libomptarget-compilexx-nvptx64-nvidia-cuda && %libomptarget-run-fail-nvptx64-nvidia-cuda // RUN: %libomptarget-compilexx-nvptx64-nvidia-cuda && %libomptarget-run-fail-nvptx64-nvidia-cuda
// REQUIRES: nvptx64-nvidia-cuda
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
#pragma omp target #pragma omp target
{ __builtin_trap(); } { __builtin_trap(); }
return 0; return 0;
} }

openmp/libomptarget/test/offloading/bug47654.cpp

// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-run-and-check-generic
// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
#include <cassert> #include <cassert>
#include <iostream> #include <iostream>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
int i = 0, j = 0; int i = 0, j = 0;
#pragma omp target map(tofrom : i, j) nowait #pragma omp target map(tofrom : i, j) nowait
Show All 16 Lines

openmp/libomptarget/test/offloading/bug49021.cpp

// RUN: %libomptarget-compilexx-aarch64-unknown-linux-gnu -O3 && %libomptarget-run-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-generic -O3 && %libomptarget-run-generic
// RUN: %libomptarget-compilexx-powerpc64-ibm-linux-gnu -O3 && %libomptarget-run-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-powerpc64le-ibm-linux-gnu -O3 && %libomptarget-run-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-x86_64-pc-linux-gnu -O3 && %libomptarget-run-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-nvptx64-nvidia-cuda -O3 && %libomptarget-run-nvptx64-nvidia-cuda
#include <iostream> #include <iostream>
template <typename T> int test_map() { template <typename T> int test_map() {
std::cout << "map(complex<>)" << std::endl; std::cout << "map(complex<>)" << std::endl;
T a(0.2), a_check; T a(0.2), a_check;
#pragma omp target map(from : a_check) #pragma omp target map(from : a_check)
{ a_check = a; } { a_check = a; }
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

openmp/libomptarget/test/offloading/bug49334.cpp

// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-run-and-check-generic
// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
#include <cassert> #include <cassert>
#include <iostream> #include <iostream>
#include <memory> #include <memory>
#include <vector> #include <vector>
class BlockMatrix { class BlockMatrix {
private: private:
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

openmp/libomptarget/test/offloading/d2d_memcpy.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu && env OMP_MAX_ACTIVE_LEVELS=2 %libomptarget-run-aarch64-unknown-linux-gnu | %fcheck-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-generic && env OMP_MAX_ACTIVE_LEVELS=2 %libomptarget-run-generic | %fcheck-generic -allow-empty
protze.joachimAuthorUnsubmitted
Done
ReplyInline Actions

For this test, only 2 out of 5 RUN lines had -allow-empty. I'm not totally sure, but does the flag make any sense when there is a CHECK line in the tests?

protze.joachim: For this test, only 2 out of 5 RUN lines had `-allow-empty`. I'm not totally sure, but does the…
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu && env OMP_MAX_ACTIVE_LEVELS=2 %libomptarget-run-powerpc64-ibm-linux-gnu | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu && env OMP_MAX_ACTIVE_LEVELS=2 %libomptarget-run-powerpc64le-ibm-linux-gnu | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu && env OMP_MAX_ACTIVE_LEVELS=2 %libomptarget-run-x86_64-pc-linux-gnu | %fcheck-x86_64-pc-linux-gnu -allow-empty
// RUN: %libomptarget-compile-nvptx64-nvidia-cuda && env OMP_MAX_ACTIVE_LEVELS=2 %libomptarget-run-nvptx64-nvidia-cuda | %fcheck-nvptx64-nvidia-cuda -allow-empty
#include <assert.h> #include <assert.h>
#include <omp.h> #include <omp.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
const int magic_num = 7; const int magic_num = 7;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

openmp/libomptarget/test/offloading/dynamic_module.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu -DSHARED -fPIC -shared -o %t.so && %libomptarget-compile-aarch64-unknown-linux-gnu %t.so && %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 | %fcheck-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-generic -DSHARED -fPIC -shared -o %t.so && %libomptarget-compile-generic %t.so && %libomptarget-run-generic 2>&1 | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu -DSHARED -fPIC -shared -o %t.so && %libomptarget-compile-powerpc64-ibm-linux-gnu %t.so && %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu -DSHARED -fPIC -shared -o %t.so && %libomptarget-compile-powerpc64le-ibm-linux-gnu %t.so && %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -DSHARED -fPIC -shared -o %t.so && %libomptarget-compile-x86_64-pc-linux-gnu %t.so && %libomptarget-run-x86_64-pc-linux-gnu 2>&1 | %fcheck-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-nvptx64-nvidia-cuda -DSHARED -fPIC -shared -o %t.so && %libomptarget-compile-nvptx64-nvidia-cuda %t.so && %libomptarget-run-nvptx64-nvidia-cuda 2>&1 | %fcheck-nvptx64-nvidia-cuda
#ifdef SHARED #ifdef SHARED
void foo() {} void foo() {}
#else #else
#include <stdio.h> #include <stdio.h>
int main() { int main() {
#pragma omp target #pragma omp target
; ;
// CHECK: DONE. // CHECK: DONE.
printf("%s\n", "DONE."); printf("%s\n", "DONE.");
return 0; return 0;
} }
#endif #endif

openmp/libomptarget/test/offloading/dynamic_module_load.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu -DSHARED -fPIC -shared -o %t.so && %clang %flags %s -o %t-aarch64-unknown-linux-gnu -ldl && %libomptarget-run-aarch64-unknown-linux-gnu %t.so 2>&1 | %fcheck-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-generic -DSHARED -fPIC -shared -o %t.so && %clang %flags %s -o %t -ldl && %libomptarget-run-generic %t.so 2>&1 | %fcheck-generic
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu -DSHARED -fPIC -shared -o %t.so && %clang %flags %s -o %t-powerpc64-ibm-linux-gnu -ldl && %libomptarget-run-powerpc64-ibm-linux-gnu %t.so 2>&1 | %fcheck-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu -DSHARED -fPIC -shared -o %t.so && %clang %flags %s -o %t-powerpc64le-ibm-linux-gnu -ldl && %libomptarget-run-powerpc64le-ibm-linux-gnu %t.so 2>&1 | %fcheck-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu -DSHARED -fPIC -shared -o %t.so && %clang %flags %s -o %t-x86_64-pc-linux-gnu -ldl && %libomptarget-run-x86_64-pc-linux-gnu %t.so 2>&1 | %fcheck-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-nvptx64-nvidia-cuda -DSHARED -fPIC -shared -o %t.so && %clang %flags %s -o %t-nvptx64-nvidia-cuda -ldl && %libomptarget-run-nvptx64-nvidia-cuda %t.so 2>&1 | %fcheck-nvptx64-nvidia-cuda
#ifdef SHARED #ifdef SHARED
#include <stdio.h> #include <stdio.h>
int foo() { int foo() {
#pragma omp target #pragma omp target
; ;
printf("%s\n", "DONE."); printf("%s\n", "DONE.");
return 0; return 0;
Show All 22 Lines

openmp/libomptarget/test/offloading/host_as_target.c

// Check that specifying device as omp_get_initial_device(): // Check that specifying device as omp_get_initial_device():
// - Doesn't cause the runtime to fail. // - Doesn't cause the runtime to fail.
// - Offloads code to the host. // - Offloads code to the host.
// - Doesn't transfer data. In this case, just check that neither host data nor // - Doesn't transfer data. In this case, just check that neither host data nor
// default device data are affected by the specified transfers. // default device data are affected by the specified transfers.
// - Works whether it's specified directly or as the default device. // - Works whether it's specified directly or as the default device.
// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
#include <stdio.h> #include <stdio.h>
#include <omp.h> #include <omp.h>
static void check(char *X, int Dev) { static void check(char *X, int Dev) {
printf(" host X = %c\n", *X); printf(" host X = %c\n", *X);
#pragma omp target device(Dev) #pragma omp target device(Dev)
printf("device X = %c\n", *X); printf("device X = %c\n", *X);
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

openmp/libomptarget/test/offloading/info.c

// RUN: %libomptarget-compile-nvptx64-nvidia-cuda -gline-tables-only && env LIBOMPTARGET_INFO=31 %libomptarget-run-nvptx64-nvidia-cuda 2>&1 | %fcheck-nvptx64-nvidia-cuda -allow-empty -check-prefix=INFO // RUN: %libomptarget-compile-nvptx64-nvidia-cuda -gline-tables-only && env LIBOMPTARGET_INFO=31 %libomptarget-run-nvptx64-nvidia-cuda 2>&1 | %fcheck-nvptx64-nvidia-cuda -allow-empty -check-prefix=INFO
// REQUIRES: nvptx64-nvidia-cuda
#include <stdio.h> #include <stdio.h>
#include <omp.h> #include <omp.h>
#define N 64 #define N 64
extern void __tgt_set_info_flag(unsigned); extern void __tgt_set_info_flag(unsigned);
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

openmp/libomptarget/test/offloading/lone_target_exit_data.c

// Check that a target exit data directive behaves correctly when the runtime // Check that a target exit data directive behaves correctly when the runtime
// has not yet been initialized. // has not yet been initialized.
// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
#include <stdio.h> #include <stdio.h>
int main() { int main() {
// CHECK: x = 98 // CHECK: x = 98
int x = 98; int x = 98;
#pragma omp target exit data map(from:x) #pragma omp target exit data map(from:x)
printf("x = %d\n", x); printf("x = %d\n", x);
return 0; return 0;
} }

openmp/libomptarget/test/offloading/looptripcnt.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 | %fcheck-aarch64-unknown-linux-gnu -allow-empty -check-prefix=DEBUG // RUN: %libomptarget-compile-generic && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-generic 2>&1 | %fcheck-generic -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 | %fcheck-powerpc64-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 | %fcheck-powerpc64le-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-x86_64-pc-linux-gnu 2>&1 | %fcheck-x86_64-pc-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-nvptx64-nvidia-cuda && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-nvptx64-nvidia-cuda 2>&1 | %fcheck-nvptx64-nvidia-cuda -allow-empty -check-prefix=DEBUG
// REQUIRES: libomptarget-debug // REQUIRES: libomptarget-debug
/* /*
Test for looptripcount being popped from runtime stack. Test for looptripcount being popped from runtime stack.
*/ */
#include <stdio.h> #include <stdio.h>
#include <omp.h> #include <omp.h>
int main() int main()
Show All 24 Lines

openmp/libomptarget/test/offloading/mandatory_but_no_devices.c

Show All 36 Lines
// RUN: %fcheck-nvptx64-nvidia-cuda // RUN: %fcheck-nvptx64-nvidia-cuda
// RUN: %libomptarget-compile-nvptx64-nvidia-cuda \ // RUN: %libomptarget-compile-nvptx64-nvidia-cuda \
// RUN: -DDIR='target update from(X)' // RUN: -DDIR='target update from(X)'
// RUN: env OMP_TARGET_OFFLOAD=mandatory CUDA_VISIBLE_DEVICES= \ // RUN: env OMP_TARGET_OFFLOAD=mandatory CUDA_VISIBLE_DEVICES= \
// RUN: %libomptarget-run-fail-nvptx64-nvidia-cuda 2>&1 | \ // RUN: %libomptarget-run-fail-nvptx64-nvidia-cuda 2>&1 | \
// RUN: %fcheck-nvptx64-nvidia-cuda // RUN: %fcheck-nvptx64-nvidia-cuda
// REQUIRES: nvptx64-nvidia-cuda
#include <omp.h> #include <omp.h>
#include <stdio.h> #include <stdio.h>
// CHECK: Libomptarget fatal error 1: failure of target construct while offloading is mandatory // CHECK: Libomptarget fatal error 1: failure of target construct while offloading is mandatory
int main(void) { int main(void) {
int X; int X;
#pragma omp DIR device(omp_get_initial_device()) #pragma omp DIR device(omp_get_initial_device())
; ;
return 0; return 0;
} }

openmp/libomptarget/test/offloading/memory_manager.cpp

// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-run-and-check-generic
// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
#include <omp.h> #include <omp.h>
#include <cassert> #include <cassert>
#include <iostream> #include <iostream>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
#pragma omp parallel for #pragma omp parallel for
Show All 34 Lines

openmp/libomptarget/test/offloading/non_contiguous_update.cpp

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 | %fcheck-aarch64-unknown-linux-gnu -allow-empty -check-prefix=DEBUG // RUN: %libomptarget-compile-generic && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-generic 2>&1 | %fcheck-generic -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 | %fcheck-powerpc64-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 | %fcheck-powerpc64le-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-x86_64-pc-linux-gnu 2>&1 | %fcheck-x86_64-pc-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-nvptx64-nvidia-cuda && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-nvptx64-nvidia-cuda 2>&1 | %fcheck-nvptx64-nvidia-cuda -allow-empty -check-prefix=DEBUG
// REQUIRES: libomptarget-debug // REQUIRES: libomptarget-debug
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
// Data structure definitions copied from OpenMP RTL. // Data structure definitions copied from OpenMP RTL.
struct __tgt_target_non_contig { struct __tgt_target_non_contig {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines __tgt_target_data_update(/*device_id*/ -1, /*arg_num*/ 1, &base, &begin,
sizes, types); sizes, types);
// DEBUG: offset 144 // DEBUG: offset 144
// DEBUG: offset 264 // DEBUG: offset 264
// DEBUG: offset 384 // DEBUG: offset 384
// DEBUG: offset 624 // DEBUG: offset 624
// DEBUG: offset 744 // DEBUG: offset 744
// DEBUG: offset 864 // DEBUG: offset 864
// case 2 // case 2
// double darr[3][4][5]; // double darr[3][4][5];
// #pragma omp target update to(darr[0:2:2][2:2][:2:2]) // #pragma omp target update to(darr[0:2:2][2:2][:2:2])
// set up descriptor // set up descriptor
__tgt_target_non_contig non_contig_2[4] = { __tgt_target_non_contig non_contig_2[4] = {
{0, 2, 320}, {2, 2, 40}, {0, 2, 16}, {0, 1, 8}}; {0, 2, 320}, {2, 2, 40}, {0, 2, 16}, {0, 1, 8}};
int64_t size_2 = 4, type_2 = OMP_TGT_MAPTYPE_NON_CONTIG; int64_t size_2 = 4, type_2 = OMP_TGT_MAPTYPE_NON_CONTIG;
Show All 27 Lines

openmp/libomptarget/test/offloading/offloading_success.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compile-run-and-check-nvptx64-nvidia-cuda
#include <stdio.h> #include <stdio.h>
#include <omp.h> #include <omp.h>
int main(void) { int main(void) {
int isHost = -1; int isHost = -1;
#pragma omp target map(from: isHost) #pragma omp target map(from: isHost)
Show All 11 Lines

openmp/libomptarget/test/offloading/offloading_success.cpp

// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-run-and-check-generic
// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
#include <stdio.h> #include <stdio.h>
#include <omp.h> #include <omp.h>
int main(void) { int main(void) {
int isHost = 0; int isHost = 0;
#pragma omp target map(from: isHost) #pragma omp target map(from: isHost)
Show All 11 Lines

openmp/libomptarget/test/offloading/parallel_offloading_map.cpp

// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-run-and-check-generic
// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
#include <cassert> #include <cassert>
#include <iostream> #include <iostream>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
constexpr const int num_threads = 64, N = 128; constexpr const int num_threads = 64, N = 128;
int array[num_threads] = {0}; int array[num_threads] = {0};
Show All 30 Lines

openmp/libomptarget/test/offloading/requires.c

// RUN: %libomptarget-compile-aarch64-unknown-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-aarch64-unknown-linux-gnu 2>&1 | %fcheck-aarch64-unknown-linux-gnu -allow-empty -check-prefix=DEBUG // RUN: %libomptarget-compile-generic && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-generic 2>&1 | %fcheck-generic -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-powerpc64-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64-ibm-linux-gnu 2>&1 | %fcheck-powerpc64-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-powerpc64le-ibm-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-powerpc64le-ibm-linux-gnu 2>&1 | %fcheck-powerpc64le-ibm-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-x86_64-pc-linux-gnu && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-x86_64-pc-linux-gnu 2>&1 | %fcheck-x86_64-pc-linux-gnu -allow-empty -check-prefix=DEBUG
// RUN: %libomptarget-compile-nvptx64-nvidia-cuda && env LIBOMPTARGET_DEBUG=1 %libomptarget-run-nvptx64-nvidia-cuda 2>&1 | %fcheck-nvptx64-nvidia-cuda -allow-empty -check-prefix=DEBUG
// REQUIRES: libomptarget-debug // REQUIRES: libomptarget-debug
/* /*
Test for the 'requires' clause check. Test for the 'requires' clause check.
When a target region is used, the requires flags are set in the When a target region is used, the requires flags are set in the
runtime for the entire compilation unit. If the flags are set again, runtime for the entire compilation unit. If the flags are set again,
(for whatever reason) the set must be consistent with previously (for whatever reason) the set must be consistent with previously
set values. set values.
Show All 34 Lines

openmp/libomptarget/test/offloading/target_depend_nowait.cpp

// RUN: %libomptarget-compilexx-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compilexx-run-and-check-generic
// RUN: %libomptarget-compilexx-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-x86_64-pc-linux-gnu
// RUN: %libomptarget-compilexx-run-and-check-nvptx64-nvidia-cuda
#include <omp.h> #include <omp.h>
#include <stdio.h> #include <stdio.h>
#define N 1024 #define N 1024
int A[N]; int A[N];
int B[N]; int B[N];
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

openmp/libomptarget/test/unified_shared_memory/api.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu // XFAIL: nvptx64-nvidia-cuda
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
#include <omp.h> #include <omp.h>
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Various definitions copied from OpenMP RTL // Various definitions copied from OpenMP RTL
extern void __tgt_register_requires(int64_t); extern void __tgt_register_requires(int64_t);
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

openmp/libomptarget/test/unified_shared_memory/close_enter_exit.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// UNSUPPORTED: clang-6, clang-7, clang-8, clang-9 // UNSUPPORTED: clang-6, clang-7, clang-8, clang-9
// XFAIL: nvptx64-nvidia-cuda
#include <omp.h> #include <omp.h>
#include <stdio.h> #include <stdio.h>
#pragma omp requires unified_shared_memory #pragma omp requires unified_shared_memory
#define N 1024 #define N 1024
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

openmp/libomptarget/test/unified_shared_memory/close_manual.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
#include <omp.h> #include <omp.h>
#include <stdio.h> #include <stdio.h>
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Various definitions copied from OpenMP RTL // Various definitions copied from OpenMP RTL
extern void __tgt_register_requires(int64_t); extern void __tgt_register_requires(int64_t);
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

openmp/libomptarget/test/unified_shared_memory/close_modifier.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu // XFAIL: nvptx64-nvidia-cuda
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
// UNSUPPORTED: clang-6, clang-7, clang-8, clang-9 // UNSUPPORTED: clang-6, clang-7, clang-8, clang-9
#include <omp.h> #include <omp.h>
#include <stdio.h> #include <stdio.h>
#pragma omp requires unified_shared_memory #pragma omp requires unified_shared_memory
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

openmp/libomptarget/test/unified_shared_memory/shared_update.c

// RUN: %libomptarget-compile-run-and-check-aarch64-unknown-linux-gnu // RUN: %libomptarget-compile-run-and-check-generic
// RUN: %libomptarget-compile-run-and-check-powerpc64-ibm-linux-gnu // XFAIL: nvptx64-nvidia-cuda
// RUN: %libomptarget-compile-run-and-check-powerpc64le-ibm-linux-gnu
// RUN: %libomptarget-compile-run-and-check-x86_64-pc-linux-gnu
#include <stdio.h> #include <stdio.h>
#include <omp.h> #include <omp.h>
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Various definitions copied from OpenMP RTL // Various definitions copied from OpenMP RTL
extern void __tgt_register_requires(int64_t); extern void __tgt_register_requires(int64_t);
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines