void queue::after(
dispatch_time_t time,
operation *op
)
{
dispatch_after_f( time, d->native, op, _xdispatch_run_operation );
}
void
func_outer(void* context)
{
UNREFERENCED_PARAMETER(context);
time_a_min = dispatch_time(0, (int64_t)5.5*NSEC_PER_SEC);
time_a = dispatch_time(0, 6*NSEC_PER_SEC);
time_a_max = dispatch_time(0, (int64_t)6.5*NSEC_PER_SEC);
dispatch_after_f(time_a, dispatch_get_current_queue(), NULL, func_a);
}
static void dispatch_start(void* context) {
dispatch_time_t time_a;
time_delta_t* delta = (time_delta_t*)malloc(sizeof(time_delta_t));
delta->min = dispatch_time(0, NSEC_PER_SEC*5.5);
time_a = dispatch_time(0, NSEC_PER_SEC*6.0);
delta->max = dispatch_time(0, NSEC_PER_SEC*6.5);
delta->start = dispatch_time(0,0);
dispatch_after_f(time_a, dispatch_get_current_queue(), delta, dispatch_6);
}
/*
* call-seq:
* gcdq.after(delay) { block }
*
* Runs the passed block after the given delay (in seconds) using
* dispatch_after(3)[http://developer.apple.com/mac/library/DOCUMENTATION/Darwin/Reference/ManPages/man3/dispatch_after.3.html],
*
* gcdq.after(0.5) { puts 'wait is over :)' }
*
*/
static VALUE
rb_queue_dispatch_after(VALUE self, SEL sel, VALUE delay)
{
dispatch_time_t offset = NIL_P(delay) ? DISPATCH_TIME_NOW : rb_num2timeout(delay);
rb_vm_block_t *block = get_prepared_block();
dispatch_after_f(offset, RQueue(self)->queue, (void *)block,
rb_block_dispatcher);
return Qnil;
}
void
func_a(void* context)
{
dispatch_time_t now_a = dispatch_time(0, 0);
UNREFERENCED_PARAMETER(context);
test_time_less_than("can't finish faster than 5.5s", 0, now_a - time_a_min);
test_time_less_than("must finish faster than 6.5s", 0, time_a_max - now_a);
time_b_min = dispatch_time(0, (int64_t)1.5*NSEC_PER_SEC);
time_b = dispatch_time(0, 2*NSEC_PER_SEC);
time_b_max = dispatch_time(0, (int64_t)2.5*NSEC_PER_SEC);
dispatch_after_f(time_b, dispatch_get_current_queue(), NULL, func_b);
}
static void collect(void *context)
{
MU_MESSAGE("All workers done.");
// give the threads some time to settle before test_stop() runs "leaks"
// ...also note, this is a total cheat. dispatch_after lets this
// thread go idle, so dispatch cleans up the continuations cache.
// Doign the "old style" sleep left that stuff around and leaks
// took a LONG TIME to complete. Long enough that the test harness
// decided to kill us.
dispatch_after_f(dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC), dispatch_get_main_queue(), NULL, MU_PASS_AFTER_DELAY);
}
static void dispatch_6(void* context) {
dispatch_time_t time_b;
time_delta_t* previous = (time_delta_t*)context;
time_delta_t* delta = (time_delta_t*)malloc(sizeof(time_delta_t));
dispatch_time_t now_a = dispatch_time(0, 0);
MU_MESSAGE("must finish between 5.5s and 6.5s: %f",(now_a-previous->start)/(float)NSEC_PER_SEC);
MU_ASSERT_TRUE(0<=(now_a - previous->min));
MU_ASSERT_TRUE(0<=(previous->max - now_a));
delta->min = dispatch_time(0, 1.5*NSEC_PER_SEC);
time_b = dispatch_time(0, 2*NSEC_PER_SEC);
delta->max = dispatch_time(0, 2.5*NSEC_PER_SEC);
delta->start = dispatch_time(0,0);
dispatch_after_f(time_b, dispatch_get_current_queue(), delta, dispatch_2);
}
void
rwsched_dispatch_after_f(rwsched_tasklet_ptr_t sched_tasklet,
dispatch_time_t when,
rwsched_dispatch_queue_t queue,
void *context,
dispatch_function_t handler)
{
// Validate input paraemters
RW_CF_TYPE_VALIDATE(sched_tasklet, rwsched_tasklet_ptr_t);
rwsched_instance_ptr_t instance = sched_tasklet->instance;
RW_CF_TYPE_VALIDATE(instance, rwsched_instance_ptr_t);
RW_ASSERT_TYPE(queue, rwsched_dispatch_queue_t);
// If libdispatch is enabled for the entire instance, then call the libdispatch routine
if (instance->use_libdispatch_only) {
RW_ASSERT(queue->header.libdispatch_object._dq);
if (queue == instance->main_rwqueue &&
sched_tasklet->blocking_mode.blocked) {
//RW_CRASH();
rwsched_dispatch_what_ptr_t what = (rwsched_dispatch_what_ptr_t) RW_MALLOC0_TYPE(sizeof(*what), rwsched_dispatch_what_ptr_t); /* always leaked! */
what->type = RWSCHED_DISPATCH_ASYNC;
what->closure.handler = handler;
what->closure.context = context;
what->queue = queue;
g_array_append_val(sched_tasklet->dispatch_what_array, what);
}
else {
rwsched_dispatch_what_ptr_t what = (rwsched_dispatch_what_ptr_t) RW_MALLOC0_TYPE(sizeof(*what), rwsched_dispatch_what_ptr_t);
what->type = RWSCHED_DISPATCH_ASYNC;
what->closure.handler = handler;
what->closure.context = context;
what->queue = queue;
rwsched_tasklet_ref(sched_tasklet);
what->tasklet_info = sched_tasklet;
dispatch_after_f(when, queue->header.libdispatch_object._dq, (void*)what, rwsched_dispatch_intercept);
}
return;
}
// Not yet implemented
RW_CRASH();
}
static void
collect(void *context)
{
uint64_t delta;
long double math;
size_t i;
if (--count_down) {
return;
}
delta = dispatch_time(0,0) - start;
math = (long double)delta;
math /= COUNT * COUNT * 2ul + COUNT * 2ul;
MU_MESSAGE("lap: %ld", lap_count_down);
MU_MESSAGE("count: %lu", COUNT);
MU_MESSAGE("delta: %llu ns", (uintmax_t)delta);
MU_MESSAGE("math: %Lf ns / lap", math);
for (i = 0; i < COUNT; i++) {
dispatch_release(queues[i]);
}
// our malloc could be a lot better,
// this result is really a malloc torture test
MU_ASSERT_TRUE((unsigned long)math<10000);
if (--lap_count_down) {
do_test();
return;
}
// give the threads some time to settle before test_stop() runs "leaks"
// ...also note, this is a total cheat. dispatch_after lets this
// thread go idle, so dispatch cleans up the continuations cache.
// Doign the "old style" sleep left that stuff around and leaks
// took a LONG TIME to complete. Long enough that the test harness
// decided to kill us.
dispatch_after_f(dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC), dispatch_get_main_queue(), NULL, MU_PASS_AFTER_DELAY);
}
static void
fd_tcpinfo_carbon_tick(void *arg)
{
struct carbon_ctx *ctx = arg;
dispatch_time_t milestone;
struct tcp_info i = {0};
struct tcp_info *info = &i;
if (ctx->fd < 0) {
printf("noconn\n");
goto resched;
}
if (fd_tcpinfo(ctx->fd, info) == 0) {
time_t ts;
time(&ts);
const char *qname = dispatch_queue_get_label(ctx->queue);
char label[1024];
snprintf(label, sizeof(label), "%s.rtt", qname);
carbon_dispatch(ctx->queue, ctx->io, label, info->tcpi_rttcur, ts);
snprintf(label, sizeof(label), "%s.rxpackets", qname);
carbon_dispatch(ctx->queue, ctx->io, label, info->tcpi_rxpackets, ts);
snprintf(label, sizeof(label), "%s.txpackets", qname);
carbon_dispatch(ctx->queue, ctx->io, label, info->tcpi_txpackets, ts);
printf("%s rtt: %u rxpackets: %llu txpackets: %llu\n", qname, info->tcpi_rttcur, info->tcpi_rxpackets, info->tcpi_txpackets);
} else {
perror("getsockopt");
}
resched:
milestone = dispatch_time(DISPATCH_TIME_NOW, T_TIMEOUT);
dispatch_after_f(milestone, ctx->queue, ctx, fd_tcpinfo_carbon_tick);
}
void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delay)
{
dispatch_time_t delayTime = dispatch_time(DISPATCH_TIME_NOW, delay * NSEC_PER_SEC);
dispatch_after_f(delayTime, m_dispatchQueue, new Function<void()>(function), executeFunction);
}
void WorkQueue::scheduleWorkAfterDelay(PassOwnPtr<WorkItem> item, double delay)
{
dispatch_time_t delayTime = dispatch_time(DISPATCH_TIME_NOW, delay * NSEC_PER_SEC);
dispatch_after_f(delayTime, m_dispatchQueue, item.leakPtr(), executeWorkItem);
}
