| #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; |
| } |
