void
worker(processor_t proc, processor_t shared)
{
void ***args;
clos_type_t *arg_types;
priv_queue_t q = NULL;
for (int i = 0; i < num_iters; i++)
{
q = proc_get_queue(proc, shared);
closure_t clos =
closure_new(action,
closure_void_type(),
1,
&args,
&arg_types);
arg_types[0] = closure_pointer_type();
*args[0] = shared;
priv_queue_lock(q, proc);
priv_queue_routine(q, clos, proc);
priv_queue_unlock(q, proc);
}
if( __sync_add_and_fetch(&num_finished, 1) == num_each)
{
proc_shutdown(shared, proc);
}
}
void
wait_worker(processor_t proc, processor_t shared, uint64_t flag)
{
void ***args;
clos_type_t *arg_types;
priv_queue_t q = NULL;
assert(proc->stask.executor != NULL);
for (int i = 0; i < num_iters; i++)
{
int val;
closure_t clos;
q = proc_get_queue (proc, shared);
priv_queue_lock(q, proc);
priv_queue_sync(q, proc);
priv_queue_set_in_wait(q);
val = x;
while (val % 2 != flag)
{
priv_queue_unlock(q, proc);
proc_wait_for_available(shared, proc);
q = proc_get_queue (proc, shared);
priv_queue_lock(q, proc);
priv_queue_sync(q, proc);
priv_queue_set_in_wait(q);
val = x;
}
priv_queue_set_in_body(q);
clos =
closure_new((void*)action,
closure_void_type(),
1,
&args,
&arg_types);
arg_types[0] = closure_pointer_type();
*args[0] = shared;
priv_queue_routine(q, clos, proc);
priv_queue_unlock(q, proc);
}
if( __sync_add_and_fetch(&num_finished, 1) == num_each)
{
proc_shutdown(shared, proc);
}
}
static pobject define(pobject env, pobject params)
{
pobject p = cons_car(params);
if (is_symbol(p)) {
return env_define(env,
cons_car(params),
eval(env, cons_car(cons_cdr(params))));
} else if (is_cons(p)) {
return env_define(env,
cons_car(p),
gc_add(closure_new(env, cons_cdr(p), cons_cdr(params))));
}
return NIL;
}
void
proc_main(processor_t proc)
{
processor_t shared = proc_new_from_other(proc);
global_shared = shared;
printf("root: %p\n", proc);
printf("shared: %p\n", shared);
for (int i = 0; i < 2*num_each; i++)
{
processor_t worker_proc = proc_new_from_other(proc);
/* printf("worker: %p\n", worker_proc); */
priv_queue_t q = proc_get_queue(proc, worker_proc);
void ***args;
clos_type_t *arg_types;
closure_t clos =
closure_new(worker,
closure_void_type(),
3,
&args,
&arg_types);
arg_types[0] = closure_pointer_type();
arg_types[1] = closure_pointer_type();
arg_types[2] = closure_sint_type();
*args[0] = worker_proc;
*args[1] = shared;
*args[2] = i % 2 == 0;
/* printf("root: lock\n"); */
priv_queue_lock(q, proc);
/* printf("root: routine\n"); */
priv_queue_routine(q, clos, proc);
/* printf("root: unlock\n"); */
priv_queue_unlock(q, proc);
}
// proc_deref_priv_queues(proc);
}
void
root_wait(processor_t proc)
{
processors = (processor_t*) malloc((num_each + 1) * sizeof(processor_t));
processor_t shared = proc_new_from_other(proc);
processors[num_each] = shared;
for (int i = 0; i < num_each; i++)
{
processor_t worker_proc = proc_new_from_other(proc);
processors[i] = worker_proc;
priv_queue_t q = proc_get_queue(proc, worker_proc);
int64_t flag = i % 2 == 0;
void ***args;
clos_type_t *arg_types;
closure_t clos =
closure_new((void*)wait_worker,
closure_void_type(),
3,
&args,
&arg_types);
arg_types[0] = closure_pointer_type();
arg_types[1] = closure_pointer_type();
arg_types[2] = closure_sint_type();
*args[0] = worker_proc;
*args[1] = shared;
*args[2] = (void*)flag;
priv_queue_lock(q, proc);
priv_queue_routine(q, clos, proc);
priv_queue_unlock(q, proc);
proc_shutdown(worker_proc, proc);
}
}
void
root_create(processor_t proc)
{
processors = (processor_t*) malloc((num_each + 1) * sizeof(processor_t));
processor_t shared = proc_new_from_other(proc);
processors[num_each] = shared;
for (int i = 0; i < num_each; i++)
{
processor_t worker_proc = proc_new_from_other(proc);
processors[i] = worker_proc;
priv_queue_t q = proc_get_queue(proc, worker_proc);
assert(worker_proc->stask.executor != NULL);
void ***args;
clos_type_t *arg_types;
printf("creating worker\n");
closure_t clos =
closure_new((void*)worker,
closure_void_type(),
2,
&args,
&arg_types);
arg_types[0] = closure_pointer_type();
arg_types[1] = closure_pointer_type();
*args[0] = worker_proc;
*args[1] = shared;
priv_queue_lock(q, proc);
priv_queue_routine(q, clos, proc);
priv_queue_unlock(q, proc);
proc_shutdown(worker_proc, proc);
}
}
void worker(processor_t proc, processor_t shared, int flag)
{
fprintf(stderr, "%p worker with %d\n", proc, flag);
void ***args;
clos_type_t *arg_types;
priv_queue_t q = NULL;
for (int i = 0; i < num_iters; i++)
{
int val;
closure_t clos;
q = proc_get_queue (proc, shared);
/* printf("worker locking: %p %d\n", proc, i); */
priv_queue_lock(q, proc);
/* printf("worker syncing: %p\n", proc); */
priv_queue_sync(q, proc);
priv_queue_set_in_wait(q);
val = get_value(shared);
while (val % 2 != flag)
{
/* printf("worker unlocking: %p\n", proc); */
priv_queue_unlock(q, proc);
/* printf("worker waiting for available: %p\n", proc); */
proc_wait_for_available(shared, proc);
q = proc_get_queue (proc, shared);
/* printf("worker inner locking: %p\n", proc); */
priv_queue_lock(q, proc);
/* printf("worker syncing: %p\n", proc); */
priv_queue_sync(q, proc);
val = get_value(shared);
}
priv_queue_set_in_body(q);
/* printf("worker in body: %p\n", proc); */
clos =
closure_new(action,
closure_void_type(),
1,
&args,
&arg_types);
arg_types[0] = closure_pointer_type();
*args[0] = shared;
priv_queue_routine(q, clos, proc);
priv_queue_unlock(q, proc);
}
/* printf("worker pre shutdown\n"); */
// proc_shutdown(proc, proc);
printf("worker shutdown\n");
if( __sync_add_and_fetch(&num_finished, 1) == 2*num_each)
{
printf("shared shutdown %p\n", shared);
printf ("x is: %d\n", x);
exit(0);
// proc_shutdown(shared, proc);
}
}
static pobject lambda(pobject env, pobject params)
{
return gc_add(closure_new(env, cons_car(params), cons_cdr(params)));
}
closure_t *closure_new_ref(scheme *sc, pointer code)
{
closure_t *clx = closure_new(sc, code);
closure_ref(clx);
return clx;
}
