#include #include #include #include #include #include #include #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2. #include 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 2 #include 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 2 #include 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 2 #include 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 2 #include 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 2. #include 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 2 #include 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 2 #include 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 2 #include 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 2 #include 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 2. #include 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 2 #include 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 2 #include 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 2. #include 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 2 #include 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 2. #include 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; }