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