int main(int argc, char **argv) { int op, ret; run_func = rc_test; while ((op = getopt(argc, argv, "p:c:")) != -1) { switch (op) { case 'p': port = optarg; break; case 'c': if (set_qpt(tolower(optarg[0]))) goto err; break; default: goto err; } } printf("%s: start\n", argv[0]); ret = run_func(); printf("%s: end %d\n", argv[0], ret); return ret; err: printf("usage: %s\n", argv[0]); printf("\t[-p port_number]\n"); printf("\t[-c communication type]\n"); printf("\t r - RC: reliable-connected (default)\n"); PRINT_XRC_OPT; exit(1); }
void BaseTest::run( int start_from ) { int test_case_idx, count = get_test_case_count(); int64 t_start = cvGetTickCount(); double freq = cv::getTickFrequency(); bool ff = can_do_fast_forward(); int progress = 0, code; int64 t1 = t_start; for( test_case_idx = ff && start_from >= 0 ? start_from : 0; count < 0 || test_case_idx < count; test_case_idx++ ) { ts->update_context( this, test_case_idx, ff ); progress = update_progress( progress, test_case_idx, count, (double)(t1 - t_start)/(freq*1000) ); code = prepare_test_case( test_case_idx ); if( code < 0 || ts->get_err_code() < 0 ) return; if( code == 0 ) continue; run_func(); if( ts->get_err_code() < 0 ) return; if( validate_test_results( test_case_idx ) < 0 || ts->get_err_code() < 0 ) return; } }
static gboolean prompt_cb(ObPrompt *p, gint result, gpointer options) { Options *o = options; if (result) run_func(o->data, o); return TRUE; /* call the cleanup func */ }
bool ShadingContext::execute (ShaderUse use, ShaderGroup &sgroup, ShaderGlobals &ssg, bool run) { DASSERT (use == ShadUseSurface); // FIXME m_curuse = use; m_attribs = &sgroup; // Optimize if we haven't already if (sgroup.nlayers()) { sgroup.start_running (); if (! sgroup.optimized()) { shadingsys().optimize_group (sgroup); if (shadingsys().m_greedyjit && shadingsys().m_groups_to_compile_count) { // If we are greedily JITing, optimize/JIT everything now shadingsys().optimize_all_groups (); } } if (sgroup.does_nothing()) return false; } else { // empty shader - nothing to do! return false; } // Allocate enough space on the heap size_t heap_size_needed = sgroup.llvm_groupdata_size(); if (heap_size_needed > m_heap.size()) { if (shadingsys().debug()) shadingsys().info (" ShadingContext %p growing heap to %llu", this, (unsigned long long) heap_size_needed); m_heap.resize (heap_size_needed); } // Zero out the heap memory we will be using if (shadingsys().m_clearmemory) memset (&m_heap[0], 0, heap_size_needed); // Set up closure storage m_closure_pool.clear(); // Clear the message blackboard m_messages.clear (); // Clear miscellaneous scratch space m_scratch_pool.clear (); if (run) { ssg.context = this; ssg.Ci = NULL; RunLLVMGroupFunc run_func = sgroup.llvm_compiled_version(); DASSERT (run_func); DASSERT (sgroup.llvm_groupdata_size() <= m_heap.size()); run_func (&ssg, &m_heap[0]); } return true; }
/* This function calls the user-supplied thread-startup function. */ static void * kthread_start_internal(void *internal_arg) { void **arg_array = (void **) internal_arg; void (*run_func)(struct kthread *, void *) = (void (*)(struct kthread *, void *)) arg_array[0]; struct kthread *thread = (struct kthread *) arg_array[1]; void *user_arg = arg_array[2]; thread->pid = getpid(); run_func(thread, user_arg); kfree(internal_arg); return NULL; }
int main(int argc, char **argv) { sg_log_init("libstatgrab-test", "SGTEST_LOG_PROPERTIES", argc ? argv[0] : NULL); sg_init(1); if( 0 != get_params( opt_def, argc, argv ) ) { help(argv[0]); return 1; } if( opt_def[OPT_HLP].optarg.b ) { help(argv[0]); return 0; } else if( opt_def[OPT_LIST].optarg.b ) { print_testable_functions(0); return 0; } else if( opt_def[OPT_RUN].optarg.str ) { size_t *test_routines = NULL; size_t entries = funcnames_to_indices(opt_def[OPT_RUN].optarg.str, &test_routines, 0); int errors = 0; if( 0 == entries ) { die( ESRCH, "no functions to test" ); return 255; } while( opt_def[OPT_NLOOPS].optarg.u-- > 0 ) { size_t func_rel_idx; for( func_rel_idx = 0; func_rel_idx < entries; ++func_rel_idx ) { mark_func(test_routines[func_rel_idx]); if( !run_func( test_routines[func_rel_idx], 0 ) ) { done_func(test_routines[func_rel_idx], 0); ++errors; } else { done_func(test_routines[func_rel_idx], 1); } } } (void)report_testable_functions(0); free(test_routines); return errors; } help(argv[0]); return 1; }
static void *suite_thread2(void *arg) { run_function run_func = (run_function)arg; if (ofp_init_local()) { OFP_ERR("Error: OFP local init failed.\n"); return NULL; } (void)run_func(fd_thread2); return NULL; }
int BadArgTest::run_test_case( int expected_code, const string& _descr ) { int errcount = 0; bool thrown = false; const char* descr = _descr.c_str() ? _descr.c_str() : ""; try { run_func(); } catch(const cv::Exception& e) { thrown = true; if (e.code != expected_code && e.code != cv::Error::StsError && e.code != cv::Error::StsAssert // Exact error codes support will be dropped. Checks should provide proper text messages intead. ) { ts->printf(TS::LOG, "%s (test case #%d): the error code %d is different from the expected %d\n", descr, test_case_idx, e.code, expected_code); errcount = 1; } } catch(...) { thrown = true; ts->printf(TS::LOG, "%s (test case #%d): unknown exception was thrown (the function has likely crashed)\n", descr, test_case_idx); errcount = 1; } if(!thrown) { ts->printf(TS::LOG, "%s (test case #%d): no expected exception was thrown\n", descr, test_case_idx); errcount = 1; } test_case_idx++; return errcount; }
void * threadfunc(void *parm) { int rc, success; size_t func_idx = *((size_t *)parm); rc = pthread_mutex_lock(&mutex); prove_libcall("pthread_mutex_lock", rc); ++test_counter; while (!conditionMet) { TRACE_LOG( "multi_threaded", "Thread blocked" ); rc = pthread_cond_wait(&cond, &mutex); prove_libcall("pthread_cond_wait", rc); } if( !opt_def[OPT_SEQ].optarg.b ) { rc = pthread_mutex_unlock(&mutex); prove_libcall("pthread_mutex_unlock", rc); } success = run_func( func_idx, 0 ); if( !opt_def[OPT_SEQ].optarg.b ) { rc = pthread_mutex_lock(&mutex); prove_libcall("pthread_mutex_lock", rc); } done_func(func_idx, success); rc = pthread_mutex_unlock(&mutex); prove_libcall("pthread_mutex_unlock", rc); pthread_cond_signal(&cond); return NULL; }
int BadArgTest::run_test_case( int expected_code, const string& _descr ) { int errcount = 0; bool thrown = false; const char* descr = _descr.c_str() ? _descr.c_str() : ""; try { run_func(); } catch(const cv::Exception& e) { thrown = true; if( e.code != expected_code ) { ts->printf(TS::LOG, "%s (test case #%d): the error code %d is different from the expected %d\n", descr, test_case_idx, e.code, expected_code); errcount = 1; } } catch(...) { thrown = true; ts->printf(TS::LOG, "%s (test case #%d): unknown exception was thrown (the function has likely crashed)\n", descr, test_case_idx); errcount = 1; } if(!thrown) { ts->printf(TS::LOG, "%s (test case #%d): no expected exception was thrown\n", descr, test_case_idx); errcount = 1; } test_case_idx++; return errcount; }
int main() { Pstring p1; Pstring p2; int len; int opt; // initialize first pstring scanf("%s", p1.str); scanf("%d", &len); p1.len = len; // initialize second pstring scanf("%s", p2.str); scanf("%d", &len); p2.len = len; // select which function to run scanf("%d", &opt); run_func(opt, &p1, &p2); return 0; }
bool ShadingContext::execute (ShaderGroup &sgroup, ShaderGlobals &ssg, bool run) { m_attribs = &sgroup; // Optimize if we haven't already if (sgroup.nlayers()) { sgroup.start_running (); if (! sgroup.optimized()) { shadingsys().optimize_group (sgroup); if (shadingsys().m_greedyjit && shadingsys().m_groups_to_compile_count) { // If we are greedily JITing, optimize/JIT everything now shadingsys().optimize_all_groups (); } } if (sgroup.does_nothing()) return false; } else { // empty shader - nothing to do! return false; } int profile = shadingsys().m_profile; OIIO::Timer timer (profile); // Allocate enough space on the heap size_t heap_size_needed = sgroup.llvm_groupdata_size(); if (heap_size_needed > m_heap.size()) { if (shadingsys().debug()) info (" ShadingContext %p growing heap to %llu", this, (unsigned long long) heap_size_needed); m_heap.resize (heap_size_needed); } // Zero out the heap memory we will be using if (shadingsys().m_clearmemory) memset (&m_heap[0], 0, heap_size_needed); // Set up closure storage m_closure_pool.clear(); // Clear the message blackboard m_messages.clear (); // Clear miscellaneous scratch space m_scratch_pool.clear (); if (run) { ssg.context = this; ssg.renderer = renderer(); ssg.Ci = NULL; RunLLVMGroupFunc run_func = sgroup.llvm_compiled_version(); DASSERT (run_func); DASSERT (sgroup.llvm_groupdata_size() <= m_heap.size()); run_func (&ssg, &m_heap[0]); } // Process any queued up error messages, warnings, printfs from shaders process_errors (); if (profile) { long long ticks = timer.ticks(); shadingsys().m_stat_total_shading_time_ticks += ticks; sgroup.m_stat_total_shading_time_ticks += ticks; } return true; }
/* * __wt_cond_wait_signal -- * Wait on a mutex, optionally timing out. If we get it before the time * out period expires, let the caller know. */ void __wt_cond_wait_signal(WT_SESSION_IMPL *session, WT_CONDVAR *cond, uint64_t usecs, bool (*run_func)(WT_SESSION_IMPL *), bool *signalled) { BOOL sleepret; DWORD milliseconds, windows_error; bool locked; uint64_t milliseconds64; locked = false; /* Fast path if already signalled. */ *signalled = true; if (__wt_atomic_addi32(&cond->waiters, 1) == 0) return; __wt_verbose(session, WT_VERB_MUTEX, "wait %s", cond->name); WT_STAT_CONN_INCR(session, cond_wait); EnterCriticalSection(&cond->mtx); locked = true; /* * It's possible to race with threads waking us up. That's not a problem * if there are multiple wakeups because the next wakeup will get us, or * if we're only pausing for a short period. It's a problem if there's * only a single wakeup, our waker is likely waiting for us to exit. * After acquiring the mutex (so we're guaranteed to be awakened by any * future wakeup call), optionally check if we're OK to keep running. * This won't ensure our caller won't just loop and call us again, but * at least it's not our fault. * * Assert we're not waiting longer than a second if not checking the * run status. */ WT_ASSERT(session, run_func != NULL || usecs <= WT_MILLION); if (run_func != NULL && !run_func(session)) goto skipping; if (usecs > 0) { milliseconds64 = usecs / WT_THOUSAND; /* * Check for 32-bit unsigned integer overflow * INFINITE is max unsigned int on Windows */ if (milliseconds64 >= INFINITE) milliseconds64 = INFINITE - 1; milliseconds = (DWORD)milliseconds64; /* * 0 would mean the CV sleep becomes a TryCV which we do not * want */ if (milliseconds == 0) milliseconds = 1; sleepret = SleepConditionVariableCS( &cond->cond, &cond->mtx, milliseconds); } else sleepret = SleepConditionVariableCS( &cond->cond, &cond->mtx, INFINITE); /* * SleepConditionVariableCS returns non-zero on success, 0 on timeout * or failure. */ if (sleepret == 0) { windows_error = __wt_getlasterror(); if (windows_error == ERROR_TIMEOUT) { skipping: *signalled = false; sleepret = 1; } } (void)__wt_atomic_subi32(&cond->waiters, 1); if (locked) LeaveCriticalSection(&cond->mtx); if (sleepret != 0) return; __wt_err(session, __wt_map_windows_error(windows_error), "SleepConditionVariableCS: %s: %s", cond->name, __wt_formatmessage(session, windows_error)); WT_PANIC_MSG(session, __wt_map_windows_error(windows_error), "SleepConditionVariableCS: %s", cond->name); }