vasilito
cb424d7448
verify-patch-sanity.py validates every active recipe .patch has internally- consistent hunk line counts — catching the 'malformed patch at line N' failure at commit/CI/preflight time instead of hours into a cook. This cycle hit that class three times (qtwaylandscanner, sddm, xwayland), each only discovered when cookbook tried to apply the patch. Running it across the repo found 29 latent malformed patches (validated against GNU patch: e.g. relibc/P3-sysv-ipc reproduces 'malformed patch at line 22'). They were harmless only because they sit in vendored recipes (baked, not re- applied) — but would fail on any version-bump re-derivation. --fix recounts the hunk headers (body untouched) and repaired all 29. Wired into build-preflight.sh (Phase 1.0D) and redbear-ci.yml, with a unit test (test-patch-sanity.sh). Skips archived/legacy trees and unvalidatable formats (empty placeholders, bare-@@ git hunks).
2596 lines
77 KiB
C
2596 lines
77 KiB
C
#include <Python.h>
|
|
#include <dlfcn.h>
|
|
#include <errno.h>
|
|
#include <omp-tools.h>
|
|
#include <pthread.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
extern void *ompd_library;
|
|
|
|
struct _ompd_aspace_cont {
|
|
int id;
|
|
};
|
|
struct _ompd_thread_cont {
|
|
int id;
|
|
};
|
|
ompd_address_space_context_t context = {42};
|
|
ompd_address_space_context_t invalidcontext = {99};
|
|
|
|
// call back functions for ompd_initialize
|
|
ompd_rc_t _alloc(ompd_size_t bytes, void **ptr);
|
|
ompd_rc_t _free(void *ptr);
|
|
ompd_rc_t _sizes(ompd_address_space_context_t *_acontext,
|
|
ompd_device_type_sizes_t *sizes);
|
|
ompd_rc_t _sym_addr(ompd_address_space_context_t *context,
|
|
ompd_thread_context_t *tcontext, const char *symbol_name,
|
|
ompd_address_t *symbol_addr, const char *file_name);
|
|
ompd_rc_t _read(ompd_address_space_context_t *context,
|
|
ompd_thread_context_t *tcontext, const ompd_address_t *addr,
|
|
ompd_size_t nbytes, void *buffer);
|
|
ompd_rc_t _read_string(ompd_address_space_context_t *context,
|
|
ompd_thread_context_t *tcontext,
|
|
const ompd_address_t *addr, ompd_size_t nbytes,
|
|
void *buffer);
|
|
ompd_rc_t _endianess(ompd_address_space_context_t *address_space_context,
|
|
const void *input, ompd_size_t unit_size,
|
|
ompd_size_t count, void *output);
|
|
ompd_rc_t _thread_context(ompd_address_space_context_t *context,
|
|
ompd_thread_id_t kind, ompd_size_t sizeof_thread_id,
|
|
const void *thread_id,
|
|
ompd_thread_context_t **thread_context);
|
|
ompd_rc_t _print(const char *str, int category);
|
|
|
|
/*
|
|
Test API: ompd_get_thread_handle
|
|
|
|
ompdtestapi threadandparallel
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
c
|
|
ompdtestapi ompd_get_thread_handle
|
|
|
|
for ompd_rc_unavailable:
|
|
ompd init
|
|
ompdtestapi ompd_get_thread_handle
|
|
*/
|
|
|
|
PyObject *test_ompd_get_thread_handle(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_thread_handle\"...\n");
|
|
|
|
PyObject *addrSpaceTup = PyTuple_GetItem(args, 0);
|
|
ompd_address_space_handle_t *addr_handle =
|
|
(ompd_address_space_handle_t *)PyCapsule_GetPointer(addrSpaceTup,
|
|
"AddressSpace");
|
|
|
|
PyObject *threadIdTup = PyTuple_GetItem(args, 1);
|
|
uint64_t threadID = (uint64_t)PyLong_AsLong(threadIdTup);
|
|
|
|
ompd_size_t sizeof_thread_id = sizeof(threadID);
|
|
ompd_thread_handle_t *thread_handle;
|
|
|
|
// should be successful
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_thread_handle(
|
|
addr_handle, 1 /*lwp*/, sizeof_thread_id, &threadID, &thread_handle);
|
|
|
|
if (rc == ompd_rc_unavailable) {
|
|
// ompd_rc_unavailable if the thread is not an OpenMP thread.
|
|
printf("Success. ompd_rc_unavailable, OpenMP is disabled.\n");
|
|
printf("This is not a Parallel Region, No more testing is possible.\n");
|
|
return Py_None;
|
|
} else if (rc != ompd_rc_ok)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// as in ompd-types.h, only 0-3 are valid for thread kind
|
|
// ompd_rc_unsupported if thread kind is not supported.
|
|
printf("Test: Unsupported thread kind.\n");
|
|
rc = ompd_get_thread_handle(addr_handle, 4, sizeof_thread_id, &threadID,
|
|
&thread_handle);
|
|
if (rc != ompd_rc_unsupported)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// ompd_rc_bad_input: if a different value in sizeof_thread_id is expected for
|
|
// a thread kind.
|
|
// sizeof_thread_id is validated at thread_context which is call back function
|
|
// "_thread_context" where we expect size to be sizeof(long int)
|
|
printf("Test: Wrong value for sizeof threadID.\n");
|
|
rc = ompd_get_thread_handle(addr_handle, 1 /*lwp*/, sizeof_thread_id - 1,
|
|
&threadID, &thread_handle);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL thread_handle.\n");
|
|
rc = ompd_get_thread_handle(addr_handle, 1 /*lwp*/, sizeof_thread_id,
|
|
&threadID, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_error or stale_handle for NULL addr_handle.\n");
|
|
rc = ompd_get_thread_handle(NULL, 1 /*lwp*/, sizeof_thread_id, &threadID,
|
|
&thread_handle);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_curr_parallel_handle.
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
omptestapi ompd_get_curr_parallel_handle
|
|
|
|
for ompd_rc_unavailable
|
|
ompd init
|
|
omptestapi ompd_get_curr_parallel_handle (or break at line 4
|
|
before this)
|
|
*/
|
|
|
|
PyObject *test_ompd_get_curr_parallel_handle(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_curr_parallel_handle\"...\n");
|
|
|
|
PyObject *threadHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_thread_handle_t *thread_handle =
|
|
(ompd_thread_handle_t *)(PyCapsule_GetPointer(threadHandlePy,
|
|
"ThreadHandle"));
|
|
|
|
ompd_parallel_handle_t *parallel_handle;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_curr_parallel_handle(thread_handle, ¶llel_handle);
|
|
if (rc == ompd_rc_unavailable) {
|
|
// ompd_rc_unavailable if the thread is not currently part of a team
|
|
|
|
// ToCheck: Even in non parallel region, error code is stale_handle
|
|
// Need to find a test case for ompd_rc_unavailable ?????
|
|
printf("Success. ompd_rc_unavailable, Not in parallel region\n");
|
|
printf("No more testing is possible.\n");
|
|
return Py_None;
|
|
} else if (rc == ompd_rc_stale_handle) {
|
|
printf("Return code is stale_handle, may be in non-parallel region.\n");
|
|
printf("No more testing is possible.\n");
|
|
return Py_None;
|
|
} else if (rc != ompd_rc_ok)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL parallel_handle.\n");
|
|
rc = ompd_get_curr_parallel_handle(thread_handle, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or stale_handle for NULL "
|
|
"thread_handle.\n");
|
|
rc = ompd_get_curr_parallel_handle(NULL, ¶llel_handle);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_thread_in_parallel.
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(3);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
omptestapi ompd_get_thread_in_parallel
|
|
*/
|
|
PyObject *test_ompd_get_thread_in_parallel(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_thread_in_parallel\"...\n");
|
|
|
|
PyObject *parallelHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_parallel_handle_t *parallel_handle =
|
|
(ompd_parallel_handle_t *)(PyCapsule_GetPointer(parallelHandlePy,
|
|
"ParallelHandle"));
|
|
ompd_thread_handle_t *thread_handle;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_thread_in_parallel(
|
|
parallel_handle, 1 /* lesser than team-size-var*/, &thread_handle);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// ompd_rc_bad_input: if the thread_num argument is greater than or equal to
|
|
// the team-size-var ICV or negative
|
|
printf("Test: Invalid thread num (199).\n");
|
|
rc = ompd_get_thread_in_parallel(parallel_handle, 199, &thread_handle);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Invalid thread num (-5).\n");
|
|
rc = ompd_get_thread_in_parallel(parallel_handle, -5, &thread_handle);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL thread_handle.\n");
|
|
rc = ompd_get_thread_in_parallel(parallel_handle, 1, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or stale_handle for NULL "
|
|
"parallel_handle.\n");
|
|
rc = ompd_get_thread_in_parallel(NULL, 1, &thread_handle);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_thread_handle_compare.
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(4);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
omptestapi ompd_thread_handle_compare
|
|
*/
|
|
|
|
PyObject *test_ompd_thread_handle_compare(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_thread_handle_compare\"...\n");
|
|
|
|
PyObject *threadHandlePy1 = PyTuple_GetItem(args, 0);
|
|
ompd_thread_handle_t *thread_handle1 =
|
|
(ompd_thread_handle_t *)(PyCapsule_GetPointer(threadHandlePy1,
|
|
"ThreadHandle"));
|
|
PyObject *threadHandlePy2 = PyTuple_GetItem(args, 1);
|
|
ompd_thread_handle_t *thread_handle2 =
|
|
(ompd_thread_handle_t *)(PyCapsule_GetPointer(threadHandlePy2,
|
|
"ThreadHandle"));
|
|
|
|
int cmp_value;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc =
|
|
ompd_thread_handle_compare(thread_handle1, thread_handle2, &cmp_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
if (cmp_value == 0) {
|
|
printf("Threads are Equal.\n");
|
|
} else {
|
|
// a value less than, equal to, or greater than 0 indicates that the thread
|
|
// corresponding to thread_handle_1 is, respectively, less than, equal to,
|
|
// or greater than that corresponding to thread_handle_2.
|
|
if (cmp_value <= 0) {
|
|
printf("Thread 1 is lesser than thread 2, cmp_val = %d\n", cmp_value);
|
|
printf("Test: Changing the order.\n");
|
|
rc = ompd_thread_handle_compare(thread_handle2, thread_handle1,
|
|
&cmp_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
}
|
|
if (cmp_value >= 0)
|
|
printf("Success now cmp_value is greater, %d.\n", cmp_value);
|
|
else
|
|
printf("Failed.\n");
|
|
} else {
|
|
printf("Thread 1 is greater than thread 2.\n");
|
|
printf("Test: Changing the order.\n");
|
|
rc = ompd_thread_handle_compare(thread_handle2, thread_handle1,
|
|
&cmp_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
}
|
|
if (cmp_value <= 0)
|
|
printf("Success now cmp_value is lesser, %d.\n", cmp_value);
|
|
else
|
|
printf("Failed.\n");
|
|
}
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL cmp_value.\n");
|
|
rc = ompd_thread_handle_compare(thread_handle2, thread_handle1, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or stale_handle for NULL "
|
|
"thread_handle.\n");
|
|
rc = ompd_thread_handle_compare(NULL, thread_handle1, &cmp_value);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
}
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_thread_id.
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
omptestapi ompd_get_thread_id
|
|
*/
|
|
|
|
PyObject *test_ompd_get_thread_id(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_thread_id\"...\n");
|
|
|
|
PyObject *threadHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_thread_handle_t *thread_handle =
|
|
(ompd_thread_handle_t *)(PyCapsule_GetPointer(threadHandlePy,
|
|
"ThreadHandle"));
|
|
|
|
uint64_t threadID;
|
|
ompd_size_t sizeof_thread_id = sizeof(threadID);
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_thread_id(thread_handle, 0 /*OMPD_THREAD_ID_PTHREAD*/,
|
|
sizeof_thread_id, &threadID);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success. Thread id = %ld\n", threadID);
|
|
|
|
// ompd_rc_bad_input: if a different value in sizeof_thread_id is expected for
|
|
// a thread kind of kind
|
|
printf("Test: Wrong sizeof_thread_id.\n");
|
|
rc = ompd_get_thread_id(thread_handle, 0 /*OMPD_THREAD_ID_PTHREAD*/,
|
|
sizeof_thread_id - 1, &threadID);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// ompd_rc_unsupported: if the kind of thread is not supported
|
|
printf("Test: Unsupported thread kind.\n");
|
|
// thread kind currently support from 0-3, refer in ompd-types.h
|
|
rc = ompd_get_thread_id(thread_handle, 4, sizeof_thread_id - 1, &threadID);
|
|
if (rc != ompd_rc_unsupported)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL threadID.\n");
|
|
rc = ompd_get_thread_id(thread_handle, 0 /*OMPD_THREAD_ID_PTHREAD*/,
|
|
sizeof_thread_id, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error for NULL thread_handle.\n");
|
|
rc = ompd_get_thread_id(NULL, 0 /*OMPD_THREAD_ID_PTHREAD*/, sizeof_thread_id,
|
|
&threadID);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_rel_thread_handle
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
omptestapi ompd_rel_thread_handle
|
|
*/
|
|
|
|
// TODO: This might not be the right way to do,as this handle comes from
|
|
// python not generated by ompd API
|
|
|
|
PyObject *test_ompd_rel_thread_handle(PyObject *self, PyObject *args) {
|
|
printf("Testing Not enabled for \"ompd_rel_thread_handle\"...\n");
|
|
printf("Disabled.\n");
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_enclosing_parallel_handle.
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. omp_set_num_threads(3);
|
|
9. #pragma omp parallel
|
|
10. {
|
|
11. printf ("Parallel level 2, thread num = %d",
|
|
omp_get_thread_num());
|
|
12. }
|
|
13. }
|
|
14. return 0;
|
|
15. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 11
|
|
ompdtestapi ompd_get_enclosing_parallel_handle
|
|
|
|
for "ompd_rc_unavailable":
|
|
ompd init
|
|
omptestapi ompd_get_enclosing_parallel_handle
|
|
(or break at line 4 before this)
|
|
*/
|
|
|
|
PyObject *test_ompd_get_enclosing_parallel_handle(PyObject *self,
|
|
PyObject *args) {
|
|
printf("Testing \"ompd_get_enclosing_parallel_handle\"...\n");
|
|
|
|
PyObject *parallelHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_parallel_handle_t *parallel_handle =
|
|
(ompd_parallel_handle_t *)(PyCapsule_GetPointer(parallelHandlePy,
|
|
"ParallelHandle"));
|
|
ompd_parallel_handle_t *enclosing_parallel_handle;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_enclosing_parallel_handle(parallel_handle,
|
|
&enclosing_parallel_handle);
|
|
if (rc == ompd_rc_unavailable) {
|
|
// ompd_rc_unavailable: if no enclosing parallel region exists.
|
|
printf("Success. return code is ompd_rc_unavailable, Not in parallel "
|
|
"region\n");
|
|
printf("No more testing is possible.\n");
|
|
return Py_None;
|
|
} else if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL "
|
|
"enclosing_parallel_handle.\n");
|
|
rc = ompd_get_enclosing_parallel_handle(parallel_handle, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or stale_handle for NULL "
|
|
"parallel_handle.\n");
|
|
rc = ompd_get_enclosing_parallel_handle(NULL, &enclosing_parallel_handle);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_parallel_handle_compare.
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. omp_set_num_threads(3);
|
|
9. #pragma omp parallel
|
|
10. {
|
|
11. printf ("Parallel level 2, thread num = %d",
|
|
omp_get_thread_num());
|
|
12. }
|
|
13. }
|
|
14. return 0;
|
|
15. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 11
|
|
ompdtestapi ompd_parallel_handle_compare
|
|
*/
|
|
|
|
PyObject *test_ompd_parallel_handle_compare(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_parallel_handle_compare\"...\n");
|
|
|
|
PyObject *parallelHandlePy1 = PyTuple_GetItem(args, 0);
|
|
ompd_parallel_handle_t *parallel_handle1 =
|
|
(ompd_parallel_handle_t *)(PyCapsule_GetPointer(parallelHandlePy1,
|
|
"ParallelHandle"));
|
|
PyObject *parallelHandlePy2 = PyTuple_GetItem(args, 1);
|
|
ompd_parallel_handle_t *parallel_handle2 =
|
|
(ompd_parallel_handle_t *)(PyCapsule_GetPointer(parallelHandlePy2,
|
|
"ParallelHandle"));
|
|
|
|
int cmp_value;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_parallel_handle_compare(parallel_handle1,
|
|
parallel_handle2, &cmp_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
if (cmp_value == 0) {
|
|
printf("Parallel regions are Same.\n");
|
|
} else {
|
|
// A value less than, equal to, or greater than 0 indicates that the region
|
|
// corresponding to parallel_handle_1 is, respectively, less than, equal to,
|
|
// or greater than that corresponding to parallel_handle_2
|
|
if (cmp_value <= 0) {
|
|
printf("Parallel handle 1 is lesser than handle 2, cmp_val = %d\n",
|
|
cmp_value);
|
|
printf("Test: Changing the order.\n");
|
|
rc = ompd_parallel_handle_compare(parallel_handle2, parallel_handle1,
|
|
&cmp_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
}
|
|
if (cmp_value >= 0)
|
|
printf("Success now cmp_value is greater, %d.\n", cmp_value);
|
|
else
|
|
printf("Failed.\n");
|
|
} else {
|
|
printf("Parallel 1 is greater than handle 2.\n");
|
|
printf("Test: Changing the order.\n");
|
|
rc = ompd_parallel_handle_compare(parallel_handle2, parallel_handle1,
|
|
&cmp_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
}
|
|
if (cmp_value <= 0)
|
|
printf("Success now cmp_value is lesser, %d.\n", cmp_value);
|
|
else
|
|
printf("Failed.\n");
|
|
}
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL cmp_value.\n");
|
|
rc = ompd_parallel_handle_compare(parallel_handle2, parallel_handle1, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or stale_handle for NULL "
|
|
"thread_handle.\n");
|
|
rc = ompd_parallel_handle_compare(NULL, parallel_handle1, &cmp_value);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
}
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_rel_parallel_handle
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
omptestapi ompd_rel_parallel_handle
|
|
*/
|
|
|
|
// TODO: Same as thread_rel_handle, might not be a right way to test
|
|
// What released should be provided by ompd API, this address is actually from
|
|
// python
|
|
PyObject *test_ompd_rel_parallel_handle(PyObject *self, PyObject *args) {
|
|
printf("Testing NOT enabled for \"ompd_rel_parallel_handle\"...\n");
|
|
printf("Disabled.\n");
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_initialize
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
b 4
|
|
ompdtestapi ompd_initialize\
|
|
*/
|
|
PyObject *test_ompd_initialize(PyObject *self, PyObject *noargs) {
|
|
printf("Testing \"test_ompd_initialize\"...\n");
|
|
|
|
ompd_word_t version;
|
|
ompd_rc_t rc = ompd_get_api_version(&version);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed in \"ompd_get_api_version\".\n");
|
|
return Py_None;
|
|
}
|
|
|
|
static ompd_callbacks_t table = {
|
|
_alloc, _free, _print, _sizes, _sym_addr, _read,
|
|
NULL, _read_string, _endianess, _endianess, _thread_context};
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t (*my_ompd_init)(ompd_word_t version, ompd_callbacks_t *) =
|
|
dlsym(ompd_library, "ompd_initialize");
|
|
rc = my_ompd_init(version, &table);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
static ompd_callbacks_t invalid_table = {
|
|
NULL, /* _alloc, */
|
|
NULL, /* _free, */
|
|
NULL, /* _print,*/
|
|
NULL, /* _sizes, */
|
|
NULL, /* _sym_addr, */
|
|
NULL, /* _read,*/
|
|
NULL, NULL, /* _read_string, */
|
|
NULL, /* _endianess, */
|
|
NULL, /* _endianess, */
|
|
NULL, /* _thread_context */
|
|
};
|
|
|
|
// ompd_rc_bad_input: if invalid callbacks are provided
|
|
printf("Test: Invalid callbacks.\n");
|
|
rc = my_ompd_init(version, &invalid_table);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Warning, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// ompd_rc_unsupported: if the requested API version cannot be provided
|
|
printf("Test: Wrong API version.\n");
|
|
rc = my_ompd_init(150847, &table);
|
|
if (rc != ompd_rc_unsupported)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL table.\n");
|
|
rc = my_ompd_init(version, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or ompd_rc_bad_input for NULL\n");
|
|
rc = my_ompd_init(0, &table);
|
|
if (rc != ompd_rc_unsupported && rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_api_version
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
ompdtestapi ompd_get_version
|
|
|
|
*/
|
|
|
|
PyObject *test_ompd_get_api_version(PyObject *self, PyObject *noargs) {
|
|
printf("Testing \"ompd_get_api_version\"...\n");
|
|
|
|
ompd_word_t version;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_api_version(&version);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success. API version is %ld\n", version);
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_error or ompd_rc_bad_input for NULL version\n");
|
|
rc = ompd_get_api_version(NULL);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_version_string
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
omptestapi ompd_get_version_string
|
|
|
|
*/
|
|
|
|
PyObject *test_ompd_get_version_string(PyObject *self, PyObject *noargs) {
|
|
printf("Testing \"ompd_get_version_string\"...\n");
|
|
|
|
const char *string;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_version_string(&string);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success. API version is %s\n", string);
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_error or ompd_rc_bad_input for NULL version\n");
|
|
rc = ompd_get_version_string(NULL);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_finalize
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
ompdtestapi ompd_finalize
|
|
|
|
|
|
b 4
|
|
r
|
|
ompdtestapi ompd_finalize
|
|
*/
|
|
|
|
PyObject *test_ompd_finalize(PyObject *self, PyObject *noargs) {
|
|
printf("Testing \"ompd_finalize\"...\n");
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_finalize();
|
|
if (rc == ompd_rc_ok)
|
|
printf("Ret code: ompd_rc_ok, Success if ompd is initialized.\n");
|
|
// ompd_rc_unsupported: if the OMPD library is not initialized.
|
|
else if (rc == ompd_rc_unsupported)
|
|
printf(
|
|
"Ret code: ompd_rc_unsupported, Success if ompd is NOT initialized.\n");
|
|
else
|
|
printf("Failed: Return code is %d.\n", rc);
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_process_initialize
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
|
|
*/
|
|
|
|
PyObject *test_ompd_process_initialize(PyObject *self, PyObject *noargs) {
|
|
|
|
printf("Testing \"ompd_process_initialize\"....\n");
|
|
|
|
ompd_address_space_handle_t *addr_handle;
|
|
|
|
// ompd_address_space_context_t context = {42};
|
|
|
|
printf("Test: with correct Args.\n");
|
|
ompd_rc_t rc = ompd_process_initialize(&context, &addr_handle);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: With Unsupported library.\n");
|
|
printf("Warning: Have to test manually with 32 and 64 bit combination.\n");
|
|
|
|
// ompd_address_space_context_t invalidcontext = {99};
|
|
printf("Test: with wrong context value.\n");
|
|
rc = ompd_process_initialize(&invalidcontext, &addr_handle);
|
|
if ((rc != ompd_rc_bad_input) && (rc != ompd_rc_incompatible) &&
|
|
(rc != ompd_rc_stale_handle))
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting stale handle or bad_input for NULL addr_handle.\n");
|
|
rc = ompd_process_initialize(&context, NULL);
|
|
if ((rc != ompd_rc_bad_input) && (rc != ompd_rc_stale_handle))
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_device_initialize
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
|
|
*/
|
|
|
|
PyObject *test_ompd_device_initialize(PyObject *self, PyObject *noargs) {
|
|
printf("Testing Not enabled for \"ompd_device_initialize\".\n");
|
|
printf("Disabled.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_rel_address_space_handle
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
|
|
*/
|
|
PyObject *test_ompd_rel_address_space_handle(PyObject *self, PyObject *noargs) {
|
|
printf("Testing Not enabled for \"ompd_rel_address_space_handle\".\n");
|
|
printf("Disabled.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_omp_version
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
ompdtestapi ompd_get_omp_version
|
|
*/
|
|
PyObject *test_ompd_get_omp_version(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_omp_version\" ...\n");
|
|
|
|
PyObject *addrSpaceTup = PyTuple_GetItem(args, 0);
|
|
ompd_address_space_handle_t *addr_handle =
|
|
(ompd_address_space_handle_t *)PyCapsule_GetPointer(addrSpaceTup,
|
|
"AddressSpace");
|
|
|
|
ompd_word_t omp_version;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_omp_version(addr_handle, &omp_version);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success. API version is %ld\n", omp_version);
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting stale handle or bad_input for NULL addr_handle.\n");
|
|
rc = ompd_get_omp_version(NULL, &omp_version);
|
|
if ((rc != ompd_rc_bad_input) && (rc != ompd_rc_stale_handle))
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or bad_input for NULL omp_version.\n");
|
|
rc = ompd_get_omp_version(addr_handle, NULL);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_omp_version_string
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
ompdtestapi ompd_get_omp_version_string
|
|
*/
|
|
PyObject *test_ompd_get_omp_version_string(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_omp_version_string\" ...\n");
|
|
|
|
PyObject *addrSpaceTup = PyTuple_GetItem(args, 0);
|
|
ompd_address_space_handle_t *addr_handle =
|
|
(ompd_address_space_handle_t *)PyCapsule_GetPointer(addrSpaceTup,
|
|
"AddressSpace");
|
|
|
|
const char *string;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_omp_version_string(addr_handle, &string);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed, with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success. API version is %s\n", string);
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting stale handle or bad_input for NULL addr_handle.\n");
|
|
rc = ompd_get_omp_version_string(NULL, &string);
|
|
if ((rc != ompd_rc_bad_input) && (rc != ompd_rc_stale_handle))
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or bad_input for NULL omp_version.\n");
|
|
rc = ompd_get_omp_version_string(addr_handle, NULL);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_bad_input)
|
|
printf("Failed, with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_curr_task_handle
|
|
|
|
Program:
|
|
1 #include <stdio.h>
|
|
2 #include <omp.h>
|
|
3 int get_fib_num (int num)
|
|
4 {
|
|
5 int t1, t2;
|
|
6 if (num < 2)
|
|
7 return num;
|
|
8 else {
|
|
9 #pragma omp task shared(t1)
|
|
10 t1 = get_fib_num(num-1);
|
|
11 #pragma omp task shared(t2)
|
|
12 t2 = get_fib_num(num-2);
|
|
13 #pragma omp taskwait
|
|
14 return t1+t2;
|
|
15 }
|
|
16 }
|
|
17
|
|
18 int main () {
|
|
19 int ret = 0;
|
|
20 omp_set_num_threads(2);
|
|
21 #pragma omp parallel
|
|
22 {
|
|
23 ret = get_fib_num(10);
|
|
24 }
|
|
25 printf ("Fib of 10 is %d", ret);
|
|
26 return 0;
|
|
27 }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
ompdtestapi ompd_get_curr_task_handle
|
|
*/
|
|
|
|
PyObject *test_ompd_get_curr_task_handle(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_curr_task_handle\"...\n");
|
|
|
|
PyObject *threadHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_thread_handle_t *thread_handle =
|
|
(ompd_thread_handle_t *)(PyCapsule_GetPointer(threadHandlePy,
|
|
"ThreadHandle"));
|
|
|
|
ompd_task_handle_t *task_handle;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_curr_task_handle(thread_handle, &task_handle);
|
|
if (rc == ompd_rc_unavailable) {
|
|
// ompd_rc_unavailable if the thread is not currently executing a task
|
|
|
|
printf(
|
|
"Success. Return code is ompd_rc_unavailable, Not executing a task.\n");
|
|
printf("No more testing is possible.\n");
|
|
return Py_None;
|
|
} else if (rc == ompd_rc_stale_handle) {
|
|
printf("Return code is stale_handle, may be in non parallel region.\n");
|
|
printf("No more testing is possible.\n");
|
|
return Py_None;
|
|
} else if (rc != ompd_rc_ok)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL parallel_handle.\n");
|
|
rc = ompd_get_curr_task_handle(thread_handle, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or stale_handle for NULL "
|
|
"thread_handle.\n");
|
|
rc = ompd_get_curr_task_handle(NULL, &task_handle);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_task_parallel_handle
|
|
|
|
Program:
|
|
1 #include <stdio.h>
|
|
2 #include <omp.h>
|
|
3 int get_fib_num (int num)
|
|
4 {
|
|
5 int t1, t2;
|
|
6 if (num < 2)
|
|
7 return num;
|
|
8 else {
|
|
9 #pragma omp task shared(t1)
|
|
10 t1 = get_fib_num(num-1);
|
|
11 #pragma omp task shared(t2)
|
|
12 t2 = get_fib_num(num-2);
|
|
13 #pragma omp taskwait
|
|
14 return t1+t2;
|
|
15 }
|
|
16 }
|
|
17
|
|
18 int main () {
|
|
19 int ret = 0;
|
|
20 omp_set_num_threads(2);
|
|
21 #pragma omp parallel
|
|
22 {
|
|
23 ret = get_fib_num(10);
|
|
24 }
|
|
25 printf ("Fib of 10 is %d", ret);
|
|
26 return 0;
|
|
27 }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
ompdtestapi ompd_get_task_parallel_handle
|
|
*/
|
|
PyObject *test_ompd_get_task_parallel_handle(PyObject *self, PyObject *args) {
|
|
|
|
printf("Testing \"ompd_get_task_parallel_handle\"...\n");
|
|
|
|
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_task_handle_t *task_handle =
|
|
PyCapsule_GetPointer(taskHandlePy, "TaskHandle");
|
|
|
|
ompd_parallel_handle_t *task_parallel_handle;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc =
|
|
ompd_get_task_parallel_handle(task_handle, &task_parallel_handle);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL task_parallel_handle.\n");
|
|
rc = ompd_get_task_parallel_handle(task_handle, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_error or stale_handle for NULL task_handle.\n");
|
|
rc = ompd_get_task_parallel_handle(NULL, &task_parallel_handle);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_generating_task_handle
|
|
|
|
Program:
|
|
1 #include <stdio.h>
|
|
2 #include <omp.h>
|
|
3 int get_fib_num (int num)
|
|
4 {
|
|
5 int t1, t2;
|
|
6 if (num < 2)
|
|
7 return num;
|
|
8 else {
|
|
9 #pragma omp task shared(t1)
|
|
10 t1 = get_fib_num(num-1);
|
|
11 #pragma omp task shared(t2)
|
|
12 t2 = get_fib_num(num-2);
|
|
13 #pragma omp taskwait
|
|
14 return t1+t2;
|
|
15 }
|
|
16 }
|
|
17
|
|
18 int main () {
|
|
19 int ret = 0;
|
|
20 omp_set_num_threads(2);
|
|
21 #pragma omp parallel
|
|
22 {
|
|
23 ret = get_fib_num(10);
|
|
24 }
|
|
25 printf ("Fib of 10 is %d", ret);
|
|
26 return 0;
|
|
27 }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
c // may or may not be needed
|
|
ompdtestapi ompd_get_generating_task_handle
|
|
*/
|
|
PyObject *test_ompd_get_generating_task_handle(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_generating_task_handle\"...\n");
|
|
|
|
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_task_handle_t *task_handle =
|
|
(ompd_task_handle_t *)(PyCapsule_GetPointer(taskHandlePy, "TaskHandle"));
|
|
ompd_task_handle_t *generating_task_handle;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc =
|
|
ompd_get_generating_task_handle(task_handle, &generating_task_handle);
|
|
if (rc == ompd_rc_unavailable) {
|
|
// ompd_rc_unavailable if no generating task handle exists.
|
|
printf("Success. Return code is ompd_rc_unavailable\n");
|
|
printf("No more testing is possible.\n");
|
|
return Py_None;
|
|
} else if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_bad_input for NULL generating_task_handle.\n");
|
|
rc = ompd_get_generating_task_handle(task_handle, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_error or stale_handle for NULL task_handle.\n");
|
|
rc = ompd_get_generating_task_handle(NULL, &generating_task_handle);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_scheduling_task_handle
|
|
|
|
Program:
|
|
1 #include <stdio.h>
|
|
2 #include <omp.h>
|
|
3 int get_fib_num (int num)
|
|
4 {
|
|
5 int t1, t2;
|
|
6 if (num < 2)
|
|
7 return num;
|
|
8 else {
|
|
9 #pragma omp task shared(t1)
|
|
10 t1 = get_fib_num(num-1);
|
|
11 #pragma omp task shared(t2)
|
|
12 t2 = get_fib_num(num-2);
|
|
13 #pragma omp taskwait
|
|
14 return t1+t2;
|
|
15 }
|
|
16 }
|
|
17
|
|
18 int main () {
|
|
19 int ret = 0;
|
|
20 omp_set_num_threads(2);
|
|
21 #pragma omp parallel
|
|
22 {
|
|
23 ret = get_fib_num(10);
|
|
24 }
|
|
25 printf ("Fib of 10 is %d", ret);
|
|
26 return 0;
|
|
27 }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
ompdtestapi ompd_get_scheduling_task_handle
|
|
*/
|
|
PyObject *test_ompd_get_scheduling_task_handle(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_scheduling_task_handle\"...\n");
|
|
|
|
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_task_handle_t *task_handle =
|
|
(ompd_task_handle_t *)(PyCapsule_GetPointer(taskHandlePy, "TaskHandle"));
|
|
ompd_task_handle_t *scheduling_task_handle;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc =
|
|
ompd_get_scheduling_task_handle(task_handle, &scheduling_task_handle);
|
|
if (rc == ompd_rc_unavailable) {
|
|
// ompd_rc_unavailable if no generating task handle exists.
|
|
printf(
|
|
"Success. Return code is ompd_rc_unavailable, No scheduling task.\n");
|
|
printf("No more testing is possible.\n");
|
|
return Py_None;
|
|
} else if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_bad_input for NULL scheduling_task_handle.\n");
|
|
rc = ompd_get_scheduling_task_handle(task_handle, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_error or stale_handle for NULL task_handle.\n");
|
|
rc = ompd_get_scheduling_task_handle(NULL, &scheduling_task_handle);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_task_in_parallel
|
|
|
|
Program:
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(4);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
c
|
|
ompdtestapi ompd_get_task_in_parallel
|
|
*/
|
|
PyObject *test_ompd_get_task_in_parallel(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_task_in_parallel\"...\n");
|
|
|
|
PyObject *parallelHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_parallel_handle_t *parallel_handle =
|
|
(ompd_parallel_handle_t *)(PyCapsule_GetPointer(parallelHandlePy,
|
|
"ParallelHandle"));
|
|
ompd_task_handle_t *task_handle;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_task_in_parallel(
|
|
parallel_handle, 1 /* lesser than team-size-var*/, &task_handle);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// ompd_rc_bad_input if the thread_num argument is greater than or equal to
|
|
// the team-size-var ICV or negative
|
|
printf("Test: Invalid thread num (199).\n");
|
|
rc = ompd_get_task_in_parallel(parallel_handle, 199, &task_handle);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Invalid thread num (-5).\n");
|
|
rc = ompd_get_task_in_parallel(parallel_handle, -5, &task_handle);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL task_handle.\n");
|
|
rc = ompd_get_task_in_parallel(parallel_handle, 1, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or stale_handle for NULL "
|
|
"parallel_handle.\n");
|
|
rc = ompd_get_task_in_parallel(NULL, 1, &task_handle);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_rel_task_handle
|
|
|
|
Program:
|
|
1 #include <stdio.h>
|
|
2 #include <omp.h>
|
|
3 int get_fib_num (int num)
|
|
4 {
|
|
5 int t1, t2;
|
|
6 if (num < 2)
|
|
7 return num;
|
|
8 else {
|
|
9 #pragma omp task shared(t1)
|
|
10 t1 = get_fib_num(num-1);
|
|
11 #pragma omp task shared(t2)
|
|
12 t2 = get_fib_num(num-2);
|
|
13 #pragma omp taskwait
|
|
14 return t1+t2;
|
|
15 }
|
|
16 }
|
|
17
|
|
18 int main () {
|
|
19 int ret = 0;
|
|
20 omp_set_num_threads(2);
|
|
21 #pragma omp parallel
|
|
22 {
|
|
23 ret = get_fib_num(10);
|
|
24 }
|
|
25 printf ("Fib of 10 is %d", ret);
|
|
26 return 0;
|
|
27 }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
ompdtestapi ompd_rel_task_handle
|
|
*/
|
|
PyObject *test_ompd_rel_task_handle(PyObject *self, PyObject *noargs) {
|
|
printf("Testing Not enabled for \"ompd_rel_task_handle\".\n");
|
|
printf("Disabled.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_task_handle_compare
|
|
|
|
Program:
|
|
1 #include <stdio.h>
|
|
2 #include <omp.h>
|
|
3 int get_fib_num (int num)
|
|
4 {
|
|
5 int t1, t2;
|
|
6 if (num < 2)
|
|
7 return num;
|
|
8 else {
|
|
9 #pragma omp task shared(t1)
|
|
10 t1 = get_fib_num(num-1);
|
|
11 #pragma omp task shared(t2)
|
|
12 t2 = get_fib_num(num-2);
|
|
13 #pragma omp taskwait
|
|
14 return t1+t2;
|
|
15 }
|
|
16 }
|
|
17
|
|
18 int main () {
|
|
19 int ret = 0;
|
|
20 omp_set_num_threads(2);
|
|
21 #pragma omp parallel
|
|
22 {
|
|
23 ret = get_fib_num(10);
|
|
24 }
|
|
25 printf ("Fib of 10 is %d", ret);
|
|
26 return 0;
|
|
27 }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
c
|
|
ompdtestapi ompd_task_handle_compare
|
|
*/
|
|
PyObject *test_ompd_task_handle_compare(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_task_handle_compare\"...\n");
|
|
|
|
PyObject *taskHandlePy1 = PyTuple_GetItem(args, 0);
|
|
ompd_task_handle_t *task_handle1 =
|
|
(ompd_task_handle_t *)(PyCapsule_GetPointer(taskHandlePy1, "TaskHandle"));
|
|
PyObject *taskHandlePy2 = PyTuple_GetItem(args, 1);
|
|
ompd_task_handle_t *task_handle2 =
|
|
(ompd_task_handle_t *)(PyCapsule_GetPointer(taskHandlePy2, "TaskHandle"));
|
|
|
|
int cmp_value;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc =
|
|
ompd_task_handle_compare(task_handle1, task_handle2, &cmp_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
if (cmp_value == 0) {
|
|
printf("Task Handles are Same.\n");
|
|
} else {
|
|
// a value less than, equal to, or greater than 0 indicates that the task
|
|
// that corresponds to task_handle_1 is, respectively, less than, equal to,
|
|
// or greater than the task that corresponds to task_handle_2.
|
|
if (cmp_value <= 0) {
|
|
printf("Task handle 1 is lesser than handle 2, cmp_val = %d\n",
|
|
cmp_value);
|
|
printf("Test: Changing the order.\n");
|
|
rc = ompd_task_handle_compare(task_handle2, task_handle1, &cmp_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
}
|
|
if (cmp_value >= 0)
|
|
printf("Success now cmp_value is greater, %d.\n", cmp_value);
|
|
else
|
|
printf("Failed.\n");
|
|
} else {
|
|
printf("Task 1 is greater than handle 2.\n");
|
|
printf("Test: Changing the order.\n");
|
|
rc = ompd_task_handle_compare(task_handle2, task_handle1, &cmp_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
}
|
|
if (cmp_value <= 0)
|
|
printf("Success now cmp_value is lesser, %d.\n", cmp_value);
|
|
else
|
|
printf("Failed.\n");
|
|
}
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL cmp_value.\n");
|
|
rc = ompd_task_handle_compare(task_handle2, task_handle1, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or stale_handle for NULL "
|
|
"task_handle.\n");
|
|
rc = ompd_task_handle_compare(NULL, task_handle1, &cmp_value);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
}
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_task_function
|
|
|
|
Program:
|
|
1 #include <stdio.h>
|
|
2 #include <omp.h>
|
|
3 int get_fib_num (int num)
|
|
4 {
|
|
5 int t1, t2;
|
|
6 if (num < 2)
|
|
7 return num;
|
|
8 else {
|
|
9 #pragma omp task shared(t1)
|
|
10 t1 = get_fib_num(num-1);
|
|
11 #pragma omp task shared(t2)
|
|
12 t2 = get_fib_num(num-2);
|
|
13 #pragma omp taskwait
|
|
14 return t1+t2;
|
|
15 }
|
|
16 }
|
|
17
|
|
18 int main () {
|
|
19 int ret = 0;
|
|
20 omp_set_num_threads(2);
|
|
21 #pragma omp parallel
|
|
22 {
|
|
23 ret = get_fib_num(10);
|
|
24 }
|
|
25 printf ("Fib of 10 is %d", ret);
|
|
26 return 0;
|
|
27 }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
ompdtestapi ompd_get_task_function
|
|
*/
|
|
PyObject *test_ompd_get_task_function(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_task_function\"...\n");
|
|
|
|
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_task_handle_t *task_handle =
|
|
(ompd_task_handle_t *)(PyCapsule_GetPointer(taskHandlePy, "TaskHandle"));
|
|
|
|
ompd_address_t entry_point;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_task_function(task_handle, &entry_point);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success. Entry point is %lx.\n", entry_point.address);
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL entry_point.\n");
|
|
rc = ompd_get_task_function(task_handle, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_error or stale_handle for NULL task_handle.\n");
|
|
rc = ompd_get_task_function(NULL, &entry_point);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_task_frame
|
|
|
|
Program:
|
|
1 #include <stdio.h>
|
|
2 #include <omp.h>
|
|
3 int get_fib_num (int num)
|
|
4 {
|
|
5 int t1, t2;
|
|
6 if (num < 2)
|
|
7 return num;
|
|
8 else {
|
|
9 #pragma omp task shared(t1)
|
|
10 t1 = get_fib_num(num-1);
|
|
11 #pragma omp task shared(t2)
|
|
12 t2 = get_fib_num(num-2);
|
|
13 #pragma omp taskwait
|
|
14 return t1+t2;
|
|
15 }
|
|
16 }
|
|
17
|
|
18 int main () {
|
|
19 int ret = 0;
|
|
20 omp_set_num_threads(2);
|
|
21 #pragma omp parallel
|
|
22 {
|
|
23 ret = get_fib_num(10);
|
|
24 }
|
|
25 printf ("Fib of 10 is %d", ret);
|
|
26 return 0;
|
|
27 }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
ompdtestapi ompd_get_task_frame
|
|
*/
|
|
PyObject *test_ompd_get_task_frame(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_task_frame\"...\n");
|
|
|
|
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_task_handle_t *task_handle =
|
|
(ompd_task_handle_t *)(PyCapsule_GetPointer(taskHandlePy, "TaskHandle"));
|
|
|
|
ompd_frame_info_t exit_frame;
|
|
ompd_frame_info_t enter_frame;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_task_frame(task_handle, &exit_frame, &enter_frame);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL exit and enter frame.\n");
|
|
rc = ompd_get_task_frame(task_handle, NULL, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_error or stale handle for NULL task_handle.\n");
|
|
rc = ompd_get_task_frame(NULL, &exit_frame, &enter_frame);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_state
|
|
|
|
Program:
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(4);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
c
|
|
ompdtestapi ompd_get_state
|
|
*/
|
|
PyObject *test_ompd_get_state(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_state\"...\n");
|
|
|
|
PyObject *threadHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_thread_handle_t *thread_handle =
|
|
(ompd_thread_handle_t *)(PyCapsule_GetPointer(threadHandlePy,
|
|
"ThreadHandle"));
|
|
|
|
ompd_word_t state;
|
|
ompt_wait_id_t wait_id;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_state(thread_handle, &state, &wait_id);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_error or stale handle for NULL "
|
|
"thread_handle.\n");
|
|
rc = ompd_get_state(NULL, &state, &wait_id);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_display_control_vars
|
|
|
|
Program:
|
|
1 #include <stdio.h>
|
|
2 #include <omp.h>
|
|
3 int get_fib_num (int num)
|
|
4 {
|
|
5 int t1, t2;
|
|
6 if (num < 2)
|
|
7 return num;
|
|
8 else {
|
|
9 #pragma omp task shared(t1)
|
|
10 t1 = get_fib_num(num-1);
|
|
11 #pragma omp task shared(t2)
|
|
12 t2 = get_fib_num(num-2);
|
|
13 #pragma omp taskwait
|
|
14 return t1+t2;
|
|
15 }
|
|
16 }
|
|
17
|
|
18 int main () {
|
|
19 int ret = 0;
|
|
20 omp_set_num_threads(2);
|
|
21 #pragma omp parallel
|
|
22 {
|
|
23 ret = get_fib_num(10);
|
|
24 }
|
|
25 printf ("Fib of 10 is %d", ret);
|
|
26 return 0;
|
|
27 }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
ompdtestapi ompd_get_display_control_vars
|
|
*/
|
|
PyObject *test_ompd_get_display_control_vars(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_display_control_vars\" ...\n");
|
|
|
|
PyObject *addrSpaceTup = PyTuple_GetItem(args, 0);
|
|
ompd_address_space_handle_t *addr_handle =
|
|
(ompd_address_space_handle_t *)PyCapsule_GetPointer(addrSpaceTup,
|
|
"AddressSpace");
|
|
|
|
const char *const *control_vars;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_display_control_vars(addr_handle, &control_vars);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting stale handle or bad_input for NULL addr_handle.\n");
|
|
rc = ompd_get_display_control_vars(NULL, &control_vars);
|
|
if ((rc != ompd_rc_bad_input) && (rc != ompd_rc_stale_handle))
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error or bad_input for NULL control_vars.\n");
|
|
rc = ompd_get_display_control_vars(addr_handle, NULL);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_rel_display_control_vars
|
|
|
|
Program:
|
|
1 #include <stdio.h>
|
|
2 #include <omp.h>
|
|
3 int get_fib_num (int num)
|
|
4 {
|
|
5 int t1, t2;
|
|
6 if (num < 2)
|
|
7 return num;
|
|
8 else {
|
|
9 #pragma omp task shared(t1)
|
|
10 t1 = get_fib_num(num-1);
|
|
11 #pragma omp task shared(t2)
|
|
12 t2 = get_fib_num(num-2);
|
|
13 #pragma omp taskwait
|
|
14 return t1+t2;
|
|
15 }
|
|
16 }
|
|
17
|
|
18 int main () {
|
|
19 int ret = 0;
|
|
20 omp_set_num_threads(2);
|
|
21 #pragma omp parallel
|
|
22 {
|
|
23 ret = get_fib_num(10);
|
|
24 }
|
|
25 printf ("Fib of 10 is %d", ret);
|
|
26 return 0;
|
|
27 }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
ompdtestapi ompd_rel_display_control_vars
|
|
*/
|
|
PyObject *test_ompd_rel_display_control_vars(PyObject *self, PyObject *noargs) {
|
|
printf("Testing Not enabled for \"ompd_rel_display_control_vars\".\n");
|
|
printf("Disabled.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_enumerate_icvs
|
|
|
|
Program:
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(2);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
c
|
|
ompdtestapi ompd_enumerate_icvs
|
|
*/
|
|
|
|
PyObject *test_ompd_enumerate_icvs(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_enumerate_icvs\"...\n");
|
|
|
|
PyObject *addrSpaceTup = PyTuple_GetItem(args, 0);
|
|
ompd_address_space_handle_t *addr_handle =
|
|
(ompd_address_space_handle_t *)PyCapsule_GetPointer(addrSpaceTup,
|
|
"AddressSpace");
|
|
|
|
ompd_icv_id_t current = 0; // To begin enumerating the ICVs, a tool should
|
|
// pass ompd_icv_undefined as the value of current
|
|
ompd_icv_id_t next_id;
|
|
const char *next_icv_name;
|
|
ompd_scope_t next_scope;
|
|
int more;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_enumerate_icvs(addr_handle, current, &next_id,
|
|
&next_icv_name, &next_scope, &more);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// ompd_rc_bad_input if an unknown value is provided in current
|
|
printf("Test: Unknown current value.\n");
|
|
rc = ompd_enumerate_icvs(
|
|
addr_handle,
|
|
99 /*unknown current value: greater than enum "ompd_icvompd_icv" */,
|
|
&next_id, &next_icv_name, &next_scope, &more);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_bad_input for NULL next_id and next_icv_name\n");
|
|
rc =
|
|
ompd_enumerate_icvs(addr_handle, current, NULL, NULL, &next_scope, &more);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf(
|
|
"Test: Expecting ompd_rc_error or stale_handle for NULL addr_handle.\n");
|
|
rc = ompd_enumerate_icvs(NULL, current, &next_id, &next_icv_name, &next_scope,
|
|
&more);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
/*
|
|
Test API: ompd_get_icv_from_scope
|
|
|
|
Program:
|
|
1 #include <stdio.h>
|
|
2 #include <omp.h>
|
|
3 int get_fib_num (int num)
|
|
4 {
|
|
5 int t1, t2;
|
|
6 if (num < 2)
|
|
7 return num;
|
|
8 else {
|
|
9 #pragma omp task shared(t1)
|
|
10 t1 = get_fib_num(num-1);
|
|
11 #pragma omp task shared(t2)
|
|
12 t2 = get_fib_num(num-2);
|
|
13 #pragma omp taskwait
|
|
14 return t1+t2;
|
|
15 }
|
|
16 }
|
|
17
|
|
18 int main () {
|
|
19 int ret = 0;
|
|
20 omp_set_num_threads(2);
|
|
21 #pragma omp parallel
|
|
22 {
|
|
23 ret = get_fib_num(10);
|
|
24 }
|
|
25 printf ("Fib of 10 is %d", ret);
|
|
26 return 0;
|
|
27 }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 10
|
|
c
|
|
ompdtestapi ompd_get_icv_from_scope
|
|
*/
|
|
PyObject *test_ompd_get_icv_from_scope_with_addr_handle(PyObject *self,
|
|
PyObject *args) {
|
|
printf("Testing \"ompd_get_icv_from_scope with addr_handle\"...\n");
|
|
|
|
PyObject *addrSpaceTup = PyTuple_GetItem(args, 0);
|
|
ompd_address_space_handle_t *addr_handle =
|
|
(ompd_address_space_handle_t *)PyCapsule_GetPointer(addrSpaceTup,
|
|
"AddressSpace");
|
|
|
|
ompd_word_t icv_value;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
// cannot import enum ompd_icv from omp-icv.cpp, hardcoding as of now, if enum
|
|
// changes it also requires modification
|
|
ompd_rc_t rc = ompd_get_icv_from_scope(
|
|
addr_handle, ompd_scope_address_space,
|
|
19 /* ompd_icv_num_procs_var: check enum ompd_icv in omp-icv.cpp */,
|
|
&icv_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// ompd_rc_bad_input if an unknown value is provided in icv_id.
|
|
printf("Test: bad_input for unknown icv_id.\n");
|
|
rc = ompd_get_icv_from_scope(addr_handle, ompd_scope_address_space,
|
|
99 /*wrong value*/, &icv_value);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// ompd_rc_incompatible if the ICV cannot be represented as an integer;
|
|
printf("Test: rc_incompatible for ICV that cant be represented as an "
|
|
"integer.\n");
|
|
rc = ompd_get_icv_from_scope(addr_handle, ompd_scope_address_space,
|
|
12 /*ompd_icv_tool_libraries_var*/, &icv_value);
|
|
if (rc != ompd_rc_incompatible)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL icv_value.\n");
|
|
rc = ompd_get_icv_from_scope(addr_handle, ompd_scope_address_space,
|
|
19 /*ompd_icv_num_procs_var*/, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error for NULL handle.\n");
|
|
rc = ompd_get_icv_from_scope(NULL, ompd_scope_address_space,
|
|
19 /*ompd_icv_num_procs_var*/, &icv_value);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
PyObject *test_ompd_get_icv_from_scope_with_thread_handle(PyObject *self,
|
|
PyObject *args) {
|
|
printf("Testing \"ompd_get_icv_from_scope with thread_handle\"...\n");
|
|
|
|
PyObject *threadHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_thread_handle_t *thread_handle =
|
|
(ompd_thread_handle_t *)(PyCapsule_GetPointer(threadHandlePy,
|
|
"ThreadHandle"));
|
|
|
|
ompd_word_t icv_value;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_icv_from_scope(
|
|
thread_handle, ompd_scope_thread,
|
|
22 /* ompd_icv_thread_num_var check enum ompd_icv in omp-icv.cpp */,
|
|
&icv_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: with nthreads_var for ompd_rc_incomplete.\n");
|
|
rc = ompd_get_icv_from_scope(thread_handle, ompd_scope_thread,
|
|
7 /*ompd_icv_nthreads_var*/, &icv_value);
|
|
if (rc != ompd_rc_incomplete) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
PyObject *test_ompd_get_icv_from_scope_with_parallel_handle(PyObject *self,
|
|
PyObject *args) {
|
|
printf("Testing \"ompd_get_icv_from_scope with parallel_handle\"...\n");
|
|
|
|
PyObject *parallelHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_parallel_handle_t *parallel_handle =
|
|
(ompd_parallel_handle_t *)(PyCapsule_GetPointer(parallelHandlePy,
|
|
"ParallelHandle"));
|
|
|
|
ompd_word_t icv_value;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_icv_from_scope(
|
|
parallel_handle, ompd_scope_parallel,
|
|
15 /*ompd_icv_active_levels_var:check enum ompd_icv in omp-icv.cpp */,
|
|
&icv_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
PyObject *test_ompd_get_icv_from_scope_with_task_handle(PyObject *self,
|
|
PyObject *args) {
|
|
printf("Testing \"ompd_get_icv_from_scope with task_handle\"...\n");
|
|
|
|
PyObject *taskHandlePy = PyTuple_GetItem(args, 0);
|
|
ompd_task_handle_t *task_handle =
|
|
(ompd_task_handle_t *)(PyCapsule_GetPointer(taskHandlePy, "TaskHandle"));
|
|
|
|
ompd_word_t icv_value;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_icv_from_scope(
|
|
task_handle, ompd_scope_task,
|
|
16 /*ompd_icv_thread_limit_var: check enum ompd_icv in omp-icv.cpp */,
|
|
&icv_value);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
/*
|
|
Test API: ompd_get_icv_string_from_scope
|
|
|
|
Program:
|
|
1. #include <stdio.h>
|
|
2. #include <omp.h>
|
|
3. int main () {
|
|
4. omp_set_num_threads(4);
|
|
5. #pragma omp parallel
|
|
6. {
|
|
7. printf("Parallel level 1, thread num = %d",
|
|
omp_get_thread_num());
|
|
8. }
|
|
9. return 0;
|
|
10. }
|
|
|
|
GDB Commands:
|
|
ompd init
|
|
b 7
|
|
c
|
|
ompdtestapi ompd_get_icv_string_from_scope
|
|
*/
|
|
PyObject *test_ompd_get_icv_string_from_scope(PyObject *self, PyObject *args) {
|
|
printf("Testing \"ompd_get_icv_string_from_scope\"...\n");
|
|
|
|
PyObject *addrSpaceTup = PyTuple_GetItem(args, 0);
|
|
ompd_address_space_handle_t *addr_handle =
|
|
(ompd_address_space_handle_t *)PyCapsule_GetPointer(addrSpaceTup,
|
|
"AddressSpace");
|
|
|
|
const char *icv_string;
|
|
|
|
printf("Test: With Correct Arguments.\n");
|
|
ompd_rc_t rc = ompd_get_icv_string_from_scope(
|
|
addr_handle, ompd_scope_address_space,
|
|
12 /*ompd_icv_tool_libraries_var: check enum ompd_icv in omp-icv.cpp */,
|
|
&icv_string);
|
|
if (rc != ompd_rc_ok) {
|
|
printf("Failed. with return code = %d\n", rc);
|
|
return Py_None;
|
|
} else
|
|
printf("Success.\n");
|
|
|
|
// ompd_rc_bad_input if an unknown value is provided in icv_id.
|
|
printf("Test: bad_input for unknown icv_id.\n");
|
|
rc = ompd_get_icv_string_from_scope(addr_handle, ompd_scope_address_space,
|
|
99 /*wrong value*/, &icv_string);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
// Random checks with null and invalid args.
|
|
/*
|
|
ompd_rc_stale_handle: is returned when the specified handle is no
|
|
longer valid;
|
|
ompd_rc_bad_input: is returned when the input parameters
|
|
(other than handle) are invalid;
|
|
ompd_rc_error: is returned when a fatal error occurred;
|
|
*/
|
|
|
|
printf("Test: Expecting ompd_rc_bad_input for NULL icv_string.\n");
|
|
rc = ompd_get_icv_string_from_scope(addr_handle, ompd_scope_address_space,
|
|
12 /*ompd_icv_tool_libraries_var*/, NULL);
|
|
if (rc != ompd_rc_bad_input)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
printf("Test: Expecting ompd_rc_error for NULL handle.\n");
|
|
rc = ompd_get_icv_string_from_scope(NULL, ompd_scope_address_space,
|
|
12 /*ompd_icv_tool_libraries_var*/,
|
|
&icv_string);
|
|
if (rc != ompd_rc_error && rc != ompd_rc_stale_handle)
|
|
printf("Failed. with return code = %d\n", rc);
|
|
else
|
|
printf("Success.\n");
|
|
|
|
return Py_None;
|
|
}
|
|
|
|
PyObject *test_ompd_get_tool_data(PyObject *self, PyObject *args) {
|
|
printf("Disabled: Testing Not enabled for \"ompd_get_tool_data\".\n");
|
|
|
|
return Py_None;
|
|
}
|
|
PyObject *test_ompd_enumerate_states(PyObject *self, PyObject *args) {
|
|
printf("Disabled: Testing Not enabled for \"ompd_enumerate_states\".\n");
|
|
|
|
return Py_None;
|
|
}
|