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