void write() { c0 = c0 + 1; c1 = c1 + 1; if (c0 != c1) printf ("writer error\n"); do_some_work(); }
/////////////////////////////////////////////////////////////////////// // create a new thread and schedule it if the initial state is equal to // pending thread_id_type create_thread(thread_init_data& data, thread_state_enum initial_state, bool run_now, std::size_t num_thread, error_code& ec) { if (run_now) { mutex_type::scoped_lock lk(mtx_); HPX_STD_UNIQUE_PTR<threads::thread_data> thrd ( new (memory_pool_) threads::thread_data( data, memory_pool_, initial_state)); // add a new entry in the map for this thread thread_id_type id = thrd->get_thread_id(); std::pair<thread_map_type::iterator, bool> p = thread_map_.insert(id, thrd.get()); if (HPX_UNLIKELY(!p.second)) { HPX_THROWS_IF(ec, hpx::out_of_memory, "threadmanager::register_thread", "Couldn't add new thread to the map of threads"); return invalid_thread_id; } // push the new thread in the pending queue thread if (initial_state == pending) schedule_thread(thrd.get(), num_thread); // this thread has to be in the map now BOOST_ASSERT(thread_map_.find(id) != thread_map_.end()); BOOST_ASSERT(thrd->is_created_from(&memory_pool_)); do_some_work(); // try to execute the new work item thrd.release(); // release ownership to the map if (&ec != &throws) ec = make_success_code(); // return the thread_id of the newly created thread return id; } // do not execute the work, but register a task description for // later thread creation #if HPX_THREAD_MAINTAIN_QUEUE_WAITTIME new_tasks_.enqueue(new task_description( boost::move(data), initial_state, util::high_resolution_clock::now() )); #else new_tasks_.enqueue(new task_description( boost::move(data), initial_state)); #endif ++new_tasks_count_; if (&ec != &throws) ec = make_success_code(); return invalid_thread_id; // thread has not been created yet }
/// Schedule the passed thread void schedule_thread(threads::thread_data_base* thrd, std::size_t num_thread) { #if HPX_THREAD_MAINTAIN_QUEUE_WAITTIME work_items_.enqueue( new thread_description(thrd, util::high_resolution_clock::now())); #else work_items_.enqueue(thrd); #endif ++work_items_count_; do_some_work(); // wake up sleeping threads }
void* thread_function (void*) { try { do_some_work (); } catch (ThreadExitException ex) { /* Some function indicated that we should exit the thread. */ ex.DoThreadExit (); } return NULL; }
void *js_PropertyCacheFill(void *pointer) { int i = 0; struct JSPropertyCache *cache = (struct JSPropertyCache *)pointer; while (i++ < ITERATION) { pthread_mutex_lock(&g_lock); cache->table = 1; pthread_mutex_unlock(&g_lock); do_some_work(); pthread_mutex_lock(&g_lock); cache->empty = false; pthread_mutex_unlock(&g_lock); usleep(i % 5); } return 0L; }
void *js_FlushPropertyCache(void *pointer) { struct JSPropertyCache *cache = (struct JSPropertyCache *)pointer; int i = 0; int violated = 0; while (i++ < ITERATION) { pthread_mutex_lock(&g_lock); cache->table = 0; pthread_mutex_unlock(&g_lock); do_some_work(); pthread_mutex_lock(&g_lock); cache->empty = true; pthread_mutex_unlock(&g_lock); usleep(i % 2); /* Do some checking */ pthread_mutex_lock(&g_lock); if ((cache->table != 0) && (cache->empty == false)) { violated = 1; pthread_mutex_unlock(&g_lock); break; } pthread_mutex_unlock(&g_lock); } if (violated == 1) { printf("atomicity violation in multivariable detected.\n"); } else { printf("no violation found!\n"); } return 0L; }
int main(int argc, const char *argv[]) { intercept_signal(SIGSEGV, signal_handler, true/*sigstack*/); print("pre-DR init\n"); dr_app_setup(); assert(!dr_app_running_under_dynamorio()); dr_app_start(); assert(dr_app_running_under_dynamorio()); if (do_some_work() < 0) print("error in computation\n"); print("pre-DR stop\n"); dr_app_stop_and_cleanup(); assert(!dr_app_running_under_dynamorio()); print("all done\n"); return 0; }
int main(int argc, const char *argv[]) { static int outer_iters = 2048; /* We trace a 4-iter burst of execution. */ static int iter_start = outer_iters/3; static int iter_stop = iter_start + 4; if (!my_setenv("DYNAMORIO_OPTIONS", "-stderr_mask 0xc -client_lib ';;-offline'")) std::cerr << "failed to set env var!\n"; /* We use an outer loop to test re-attaching (i#2157). */ for (int j = 0; j < 3; ++j) { std::cerr << "pre-DR init\n"; dr_app_setup(); assert(!dr_app_running_under_dynamorio()); for (int i = 0; i < outer_iters; ++i) { if (i == iter_start) { std::cerr << "pre-DR start\n"; dr_app_start(); } if (i >= iter_start && i <= iter_stop) assert(dr_app_running_under_dynamorio()); else assert(!dr_app_running_under_dynamorio()); if (do_some_work(i) < 0) std::cerr << "error in computation\n"; if (i == iter_stop) { std::cerr << "pre-DR detach\n"; dr_app_stop_and_cleanup(); } } std::cerr << "all done\n"; } return 0; }
void gem_program() { sting_drivers = (DRV_LIST *) Supexec (get_sting_cookie); if (sting_drivers == 0L) { form_alert (1, not_there); return; } if (strcmp (sting_drivers->magic, MAGIC) != 0) { form_alert (1, corrupted); return; } tpl = (TPL *) (*sting_drivers->get_dftab) (TRANSPORT_DRIVER); if (tpl != (TPL *) NULL) { sprintf (alert, found_it, tpl->module, tpl->author, tpl->version); form_alert (1, alert); do_some_work(); } else form_alert (1, no_module); }
unsigned int __stdcall #else void * #endif thread_func(void *arg) { unsigned int idx = (unsigned int)(uintptr_t)arg; static const int reattach_iters = 4; static const int outer_iters = 2048; /* We trace a 4-iter burst of execution. */ static const int iter_start = outer_iters / 3; static const int iter_stop = iter_start + 4; #ifdef UNIX /* We test sigaltstack with attach+detach to avoid bugs like i#3116 */ stack_t sigstack; # define ALT_STACK_SIZE (SIGSTKSZ * 2) sigstack.ss_sp = (char *)malloc(ALT_STACK_SIZE); sigstack.ss_size = ALT_STACK_SIZE; sigstack.ss_flags = SS_ONSTACK; int res = sigaltstack(&sigstack, NULL); assert(res == 0); #endif /* We use an outer loop to test re-attaching (i#2157). */ for (int j = 0; j < reattach_iters; ++j) { if (idx == burst_owner) { std::cerr << "pre-DR init\n"; dr_app_setup(); assert(!dr_app_running_under_dynamorio()); } for (int i = 0; i < outer_iters; ++i) { if (idx == burst_owner && i == iter_start) { std::cerr << "pre-DR start\n"; dr_app_start(); } if (idx == burst_owner) { if (i >= iter_start && i <= iter_stop) assert(dr_app_running_under_dynamorio()); else assert(!dr_app_running_under_dynamorio()); } if (do_some_work(i) < 0) std::cerr << "error in computation\n"; if (idx == burst_owner && i == iter_stop) { std::cerr << "pre-DR detach\n"; dr_app_stop_and_cleanup(); } } } #ifdef UNIX stack_t check_stack; res = sigaltstack(NULL, &check_stack); assert(res == 0 && check_stack.ss_sp == sigstack.ss_sp && check_stack.ss_size == sigstack.ss_size); sigstack.ss_flags = SS_DISABLE; res = sigaltstack(&sigstack, NULL); assert(res == 0); free(sigstack.ss_sp); #endif if (idx == burst_owner) { signal_cond_var(burst_owner_finished); } else { /* Avoid having < 1 thread per core in the output. */ wait_cond_var(burst_owner_finished); } finished[idx] = true; return 0; }
void read() { if (c0 != c1) printf ("reader error\n"); do_some_work(); }
void operator()() const { do_some_work(); }
void main() { int message[8], flag; char string[6]; gl_apid = appl_init(); if (! _app) { menu_register (gl_apid, " Super Server"); evnt_timer (1000, 0); } if (! rsrc_load ("IND.RSC")) { form_alert (1, "[1][ | Cannot find IND.RSC ! ][ Cancel ]"); terminate(); return; } get_path(); if (initialise_windows (4, ICONIFY) == 0) { leave_windows(); rsrc_free(); terminate(); return; } if (get_version (string) > 0) { form_alert (1, "[1][ | STiK is not loaded, | | or corrupted !][ Cancel ]"); leave_windows(); rsrc_free(); terminate(); return; } change_freestring (START, ST_VERS, -1, string, 5); change_freestring (START, SS_VERS, -1, version, 5); set_api_struct(); if (init_modules() == 0) { leave_windows(); rsrc_free(); terminate(); return; } set_callbacks (CB_EVENT, (FUNC) check_modules, (FUNC) 0L); init_configs(); graf_mouse (ARROW, NULL); if (_app) { do_some_work(); while (! exit_inetd) { evnt_mesag (message); message_handler (message); while ((flag = operate_events()) >= 0); if (flag == -4) exit_inetd = TRUE; } } else { FOREVER { evnt_mesag (message); message_handler (message); } } if (strings) Mfree (strings); terminate_modules(); leave_windows(); rsrc_free(); appl_exit(); }
void eat(void) { do_some_work(); }
static void test_timing(void) { rtems_interrupt_lock lock; rtems_interrupt_lock_context lock_context; size_t data_size = sizeof(data); uint64_t d[3]; uint32_t cache_level; size_t cache_size; rtems_interrupt_lock_initialize(&lock, "test"); printf( "data cache line size %zi bytes\n" "data cache size %zi bytes\n", rtems_cache_get_data_line_size(), rtems_cache_get_data_cache_size(0) ); cache_level = 1; cache_size = rtems_cache_get_data_cache_size(cache_level); while (cache_size > 0) { printf( "data cache level %" PRIu32 " size %zi bytes\n", cache_level, cache_size ); ++cache_level; cache_size = rtems_cache_get_data_cache_size(cache_level); } rtems_interrupt_lock_acquire(&lock, &lock_context); d[0] = load(); d[1] = load(); rtems_cache_flush_entire_data(); d[2] = load(); rtems_interrupt_lock_release(&lock, &lock_context); printf( "load %zi bytes with flush entire data\n" " duration with normal cache %" PRIu64 " ns\n" " duration with warm cache %" PRIu64 " ns\n" " duration with flushed cache %" PRIu64 " ns\n", data_size, d[0], d[1], d[2] ); rtems_interrupt_lock_acquire(&lock, &lock_context); d[0] = load(); d[1] = load(); rtems_cache_flush_multiple_data_lines(&data[0], sizeof(data)); d[2] = load(); rtems_interrupt_lock_release(&lock, &lock_context); printf( "load %zi bytes with flush multiple data\n" " duration with normal cache %" PRIu64 " ns\n" " duration with warm cache %" PRIu64 " ns\n" " duration with flushed cache %" PRIu64 " ns\n", data_size, d[0], d[1], d[2] ); rtems_interrupt_lock_acquire(&lock, &lock_context); d[0] = load(); d[1] = load(); rtems_cache_invalidate_multiple_data_lines(&data[0], sizeof(data)); d[2] = load(); rtems_interrupt_lock_release(&lock, &lock_context); printf( "load %zi bytes with invalidate multiple data\n" " duration with normal cache %" PRIu64 " ns\n" " duration with warm cache %" PRIu64 " ns\n" " duration with invalidated cache %" PRIu64 " ns\n", data_size, d[0], d[1], d[2] ); rtems_interrupt_lock_acquire(&lock, &lock_context); d[0] = store(); d[1] = store(); rtems_cache_flush_entire_data(); d[2] = store(); rtems_interrupt_lock_release(&lock, &lock_context); printf( "store %zi bytes with flush entire data\n" " duration with normal cache %" PRIu64 " ns\n" " duration with warm cache %" PRIu64 " ns\n" " duration with flushed cache %" PRIu64 " ns\n", data_size, d[0], d[1], d[2] ); rtems_interrupt_lock_acquire(&lock, &lock_context); d[0] = store(); d[1] = store(); rtems_cache_flush_multiple_data_lines(&data[0], sizeof(data)); d[2] = store(); rtems_interrupt_lock_release(&lock, &lock_context); printf( "store %zi bytes with flush multiple data\n" " duration with normal cache %" PRIu64 " ns\n" " duration with warm cache %" PRIu64 " ns\n" " duration with flushed cache %" PRIu64 " ns\n", data_size, d[0], d[1], d[2] ); rtems_interrupt_lock_acquire(&lock, &lock_context); d[0] = store(); d[1] = store(); rtems_cache_invalidate_multiple_data_lines(&data[0], sizeof(data)); d[2] = store(); rtems_interrupt_lock_release(&lock, &lock_context); printf( "store %zi bytes with invalidate multiple data\n" " duration with normal cache %" PRIu64 " ns\n" " duration with warm cache %" PRIu64 " ns\n" " duration with invalidated cache %" PRIu64 " ns\n", data_size, d[0], d[1], d[2] ); printf( "instruction cache line size %zi bytes\n" "instruction cache size %zi bytes\n", rtems_cache_get_instruction_line_size(), rtems_cache_get_instruction_cache_size(0) ); cache_level = 1; cache_size = rtems_cache_get_instruction_cache_size(cache_level); while (cache_size > 0) { printf( "instruction cache level %" PRIu32 " size %zi bytes\n", cache_level, cache_size ); ++cache_level; cache_size = rtems_cache_get_instruction_cache_size(cache_level); } rtems_interrupt_lock_acquire(&lock, &lock_context); d[0] = do_some_work(); d[1] = do_some_work(); rtems_cache_invalidate_entire_instruction(); d[2] = do_some_work(); rtems_interrupt_lock_release(&lock, &lock_context); printf( "invalidate entire instruction\n" " duration with normal cache %" PRIu64 " ns\n" " duration with warm cache %" PRIu64 " ns\n" " duration with invalidated cache %" PRIu64 " ns\n", d[0], d[1], d[2] ); rtems_interrupt_lock_acquire(&lock, &lock_context); d[0] = do_some_work(); d[1] = do_some_work(); rtems_cache_invalidate_multiple_instruction_lines(do_some_work, 4096); d[2] = do_some_work(); rtems_interrupt_lock_release(&lock, &lock_context); printf( "invalidate multiple instruction\n" " duration with normal cache %" PRIu64 " ns\n" " duration with warm cache %" PRIu64 " ns\n" " duration with invalidated cache %" PRIu64 " ns\n", d[0], d[1], d[2] ); rtems_interrupt_lock_destroy(&lock); }