--- /dev/null
+#include <libkern/OSAtomic.h>
+#include <sys/sysctl.h>
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+#include <pthread.h>
+#include <math.h>
+#include <libproc.h>
+#include <sys/proc_info.h>
+#include <dispatch/dispatch.h>
+// #include "../src/private.h"
+#include <Block.h>
+
+// "normal" loop size
+#define LOOP 100000
+#define SMALL_LOOP 1000
+
+void report(const char *func, char *full_name, double x, unsigned long loops, char *unit) {
+ // XXX: make cols pretty & stuff
+ const char *prefix = "bench_";
+ const int plen = strlen(prefix);
+ assert(!strncmp(func, prefix, plen));
+ func += plen;
+ char *name;
+ asprintf(&name, "[%s] %s", func, full_name);
+ assert(name);
+
+ x /= loops;
+
+ if (!strcmp("mach", unit)) {
+ static mach_timebase_info_data_t mtb;
+ if (!mtb.denom) {
+ (void)mach_timebase_info(&mtb);
+ }
+ x = (x * mtb.numer) / mtb.denom;
+ unit = "ns";
+ }
+
+ printf("%-64s %13f%-2s\n", name, x, unit);
+ free(name);
+}
+
+void bench_queue_mem_use(void) {
+ struct proc_taskinfo pti;
+ uint64_t target_size;
+
+ // The 1st call eats a little memory that isn't accounted for
+ // until the 2nd call. Also the _first_ printf eats >1M, so
+ // if you insert some for debugging make sure it isn't the first!
+ proc_pidinfo(getpid(), PROC_PIDTASKINFO, 0, &pti, sizeof(pti));
+ proc_pidinfo(getpid(), PROC_PIDTASKINFO, 0, &pti, sizeof(pti));
+ target_size = pti.pti_virtual_size + 1024*1024;
+ int n;
+
+ for(n = 0; target_size >= pti.pti_virtual_size; n++) {
+ dispatch_queue_t leak = dispatch_queue_create("to be deleted", NULL);
+ assert(leak);
+ proc_pidinfo(getpid(), PROC_PIDTASKINFO, 0, &pti, sizeof(pti));
+ //printf("pti_virtual_size %qd; togo %qd, n %d\n", pti.pti_virtual_size, target_size - pti.pti_virtual_size, n);
+ }
+
+ report(__FUNCTION__, "#queues to grow VSIZE 1Mbyte", n-1, 1, "x");
+}
+
+void bench_message_round_trip(void) {
+ dispatch_queue_t q1 = dispatch_queue_create("q1", NULL);
+ dispatch_queue_t q2 = dispatch_queue_create("q2", NULL);
+ uint64_t start = mach_absolute_time();
+
+ int i;
+ for(i = 0; i < LOOP; i++) {
+ // make sure we don't build up too much of a backlog
+ if (i && !(i & 0x3ff)) {
+ dispatch_sync(q2, ^{});
+ }
+ dispatch_queue_retain(q2);
+ dispatch_async(q1, ^{
+ dispatch_async(q2, ^{
+ dispatch_queue_release(q2);
+ });
+ });
+ }
+
+ // Make sure eveything has drained before we take the end timestamp
+ dispatch_sync(q1, ^{});
+ dispatch_sync(q2, ^{});
+
+ uint64_t end = mach_absolute_time();
+ report(__FUNCTION__, "round trip (async async - implicit copy)", (end - start), LOOP, "mach");
+ dispatch_queue_release(q1);
+ dispatch_queue_release(q2);
+}
+
+void bench_precopy_message_round_trip(void) {
+ dispatch_queue_t q1 = dispatch_queue_create("q1", NULL);
+ dispatch_queue_t q2 = dispatch_queue_create("q2", NULL);
+ assert(q1 && q2);
+
+ unsigned long rc;
+
+ dispatch_block_t b2 = Block_copy(^{
+ });
+ dispatch_block_t b1 = Block_copy(^{
+ unsigned long rc = dispatch_async(q2, b2);
+ assert(!rc);
+ dispatch_queue_release(q2);
+ });
+ dispatch_block_t be = Block_copy(^{});
+ assert(b1 && b2);
+ uint64_t start = mach_absolute_time();
+
+ int i;
+ for(i = 0; i < LOOP; i++) {
+ // make sure we don't build up too much of a backlog
+ if (i && !(i & 0x3ff)) {
+ dispatch_sync(q2, be);
+ }
+ dispatch_queue_retain(q2);
+ rc = dispatch_async(q1, b1);
+ assert(!rc);
+ }
+
+ // Make sure eveything has drained before we take the end timestamp
+ dispatch_sync(q1, be);
+ dispatch_sync(q2, be);
+
+ uint64_t end = mach_absolute_time();
+ report(__FUNCTION__, "round trip (a/a - precopy)", (end - start), LOOP, "mach");
+ dispatch_queue_release(q1);
+ dispatch_queue_release(q2);
+}
+
+void bench_message_round_type_syncasync(void) {
+ dispatch_queue_t q1 = dispatch_queue_create("q1", NULL);
+ dispatch_queue_t q2 = dispatch_queue_create("q2", NULL);
+ uint64_t start = mach_absolute_time();
+
+ int i;
+ for(i = 0; i < LOOP; i++) {
+ dispatch_queue_retain(q2);
+ dispatch_sync(q1, ^{
+ dispatch_async(q2, ^{
+ dispatch_queue_release(q2);
+ });
+ });
+ }
+
+ // Make sure eveything has drained before we take the end timestamp
+ dispatch_sync(q1, ^{});
+ dispatch_sync(q2, ^{});
+
+ uint64_t end = mach_absolute_time();
+ report(__FUNCTION__, "round trip (s/a - implicit copy)", (end - start), LOOP, "mach");
+ dispatch_queue_release(q1);
+ dispatch_queue_release(q2);
+}
+
+void nothing_f(void *ignored) {
+}
+
+void brt_f_q1(void *vq2) {
+ unsigned long rc = dispatch_async_f((dispatch_queue_t)vq2, NULL, nothing_f);
+ assert(!rc);
+}
+
+void bench_message_round_trip_f(void) {
+ dispatch_queue_t q1 = dispatch_queue_create("q1", NULL);
+ dispatch_queue_t q2 = dispatch_queue_create("q2", NULL);
+ uint64_t start = mach_absolute_time();
+ unsigned long rc;
+
+ int i;
+ for(i = 0; i < LOOP; i++) {
+ // make sure we don't build up too much of a backlog
+ if (i && !(i & 0x3ff)) {
+ dispatch_sync_f(q2, NULL, nothing_f);
+ }
+ rc = dispatch_async_f(q1, q2, brt_f_q1);
+ assert(!rc);
+ }
+
+ // Make sure eveything has drained before we take the end timestamp
+ dispatch_sync_f(q1, NULL, nothing_f);
+ dispatch_sync_f(q2, NULL, nothing_f);
+
+ uint64_t end = mach_absolute_time();
+ report(__FUNCTION__, "round trip (a/a - no blocks)", (end - start), LOOP, "mach");
+ dispatch_queue_release(q1);
+ dispatch_queue_release(q2);
+}
+
+void bench_message_round_type_syncasync_f(void) {
+}
+
+struct baton {
+ // should extend to keep data on times for latency calc
+ int passes_left;
+ int at_q;
+ int baton_number;
+
+ // Avoid false ache line shares. Big speed difference on a Mac Pro
+ char pad[128 - sizeof(int)*3];
+};
+
+pthread_mutex_t kludge;
+static int n_baton_kludge;
+
+void pass(dispatch_queue_t *q, struct baton *bat, const int n_queues, dispatch_queue_t complete_q) {
+ //fprintf(stderr, "bat#%d q#%d, passes left: %d\n", bat->baton_number, bat->at_q, bat->baton_number);
+ if (0 == --(bat->passes_left)) {
+ dispatch_queue_resume(complete_q);
+ // XXX: atomic
+ if (!__sync_sub_and_fetch(&n_baton_kludge, 1)) {
+ pthread_mutex_unlock(&kludge);
+ }
+ return;
+ }
+ bat->at_q = (bat->at_q + 1) % n_queues;
+ unsigned long rc = dispatch_async(q[bat->at_q], ^{ pass(q, bat, n_queues, complete_q); });
+ assert(rc == 0);
+}
+
+void bench_baton() {
+ const int n_queues = 128;
+ const int q_div_b = 4;
+ const int n_batons = n_queues / q_div_b;
+ assert(q_div_b * n_batons == n_queues);
+ n_baton_kludge = n_batons;
+ dispatch_queue_t *q;
+ dispatch_queue_t complete_q = dispatch_queue_create("completion q", NULL);;
+ char *q_labels[n_queues];
+ int i;
+ unsigned long rc;
+
+ // creting a queue ("C"), suspending it, blocking in a dispatch_sync, and
+ // having another queue resume C does not appear to ever unblock the
+ // dispatch_sync. XXX: make test case and file radar. (if it still
+ // works that way on recent builds, with dispatch inside libsystem, and
+ // such)
+
+
+ pthread_mutex_init(&kludge, NULL);
+ rc = pthread_mutex_trylock(&kludge);
+ assert(!rc);
+ q = alloca(n_queues * sizeof(dispatch_queue_t));
+
+ for(i = 0; i < n_queues; i++) {
+ asprintf(q_labels + i, "relay#%d (%s)", i, __FUNCTION__);
+ assert(q_labels[i]);
+ q[i] = dispatch_queue_create(q_labels[i], NULL);
+ assert(q[i]);
+ }
+
+ uint64_t start_time = mach_absolute_time();
+
+ for(i = 0; i < n_queues; i += q_div_b) {
+ struct baton *bat = valloc(sizeof(struct baton));
+ assert(bat);
+ bat->passes_left = SMALL_LOOP;
+ bat->at_q = i;
+ bat->baton_number = i / q_div_b;
+ dispatch_queue_suspend(complete_q);
+ rc = dispatch_async(q[i], ^{
+ pass(q, bat, n_queues, complete_q);
+ });
+ assert(rc == 0);
+ }
+
+ // XXX: dispatch_sync(complete_q, ^{});
+ rc = pthread_mutex_lock(&kludge);
+ assert(!rc);
+ uint64_t end_time = mach_absolute_time();
+ report(__FUNCTION__, "baton pass", (end_time - start_time), SMALL_LOOP*n_batons, "mach");
+ // dispatch_queue_release(q);
+}
+
+void bench_overload2() {
+ const int n_queues = 128;
+ const int q_div_b = 1;
+ const int n_batons = n_queues / q_div_b;
+ n_baton_kludge = n_batons;
+ assert(q_div_b * n_batons == n_queues);
+ dispatch_queue_t *q = alloca(n_queues * sizeof(dispatch_queue_t));
+ dispatch_source_t *ds = alloca(n_queues * sizeof(dispatch_source_t));
+ dispatch_queue_t complete_q = dispatch_queue_create("completion q", NULL);
+ __block uint64_t start_time = 0;
+ uint64_t time_to_start;
+ uint64_t end_time;
+ char *q_labels[n_queues];
+ int i;
+ unsigned int rc;
+
+ rc = pthread_mutex_unlock(&kludge);
+ assert(!rc);
+ rc = pthread_mutex_trylock(&kludge);
+ assert(!rc);
+
+ // Start all batons one to two seconds from now.
+ time_to_start = (2 + time(NULL)) * 1000000000;
+
+ for(i = 0; i < n_queues; i++) {
+ asprintf(q_labels + i, "queue#%d (%s)", i, __FUNCTION__);
+ assert(q_labels[i]);
+ q[i] = dispatch_queue_create(q_labels[i], NULL);
+ assert(q[i]);
+ struct baton *bat = valloc(sizeof(struct baton));
+ assert(bat);
+ bat->passes_left = SMALL_LOOP;
+ bat->at_q = i;
+ bat->baton_number = i / q_div_b;
+ dispatch_queue_suspend(complete_q);
+ ds[i] = dispatch_source_timer_create(DISPATCH_TIMER_ABSOLUTE, time_to_start, 0, NULL, q[i], ^(dispatch_event_t event){
+ assert(!dispatch_event_get_error(event, NULL));
+ // We want to measure the time from the first
+ // baton pass, and NOT include hte wait time
+ // for eveyone to start to fire
+ if (!start_time) {
+ uint64_t s = mach_absolute_time();
+ __sync_bool_compare_and_swap(&start_time, 0, s);
+ }
+ pass(q, bat, n_queues, complete_q);
+ });
+ assert(ds[i]);
+ }
+
+ // XXX: dispatch_sync(complete_q, ^{});
+ rc = pthread_mutex_lock(&kludge);
+ assert(!rc);
+
+ end_time = mach_absolute_time();
+ report(__FUNCTION__, "overload#2", (end_time - start_time), SMALL_LOOP*n_batons, "mach");
+ // Many releases and free()s
+
+}
+
+void bench_overload1() {
+ const int n_queues = 128;
+ const int q_div_b = 1;
+ const int n_batons = n_queues / q_div_b;
+ n_baton_kludge = n_batons;
+ assert(q_div_b * n_batons == n_queues);
+ dispatch_queue_t *q = alloca(n_queues * sizeof(dispatch_queue_t));
+ dispatch_queue_t complete_q = dispatch_queue_create("completion q", NULL);
+ __block uint64_t start_time = 0;
+ struct timeval time_to_start;
+ uint64_t end_time;
+ char *q_labels[n_queues];
+ int i;
+ unsigned int rc;
+
+ rc = pthread_mutex_unlock(&kludge);
+ assert(!rc);
+ rc = pthread_mutex_trylock(&kludge);
+ assert(!rc);
+
+ // Start all batons one to two seconds from now.
+ gettimeofday(&time_to_start, NULL);
+ time_to_start.tv_sec += 2;
+
+ for(i = 0; i < n_queues; i++) {
+ asprintf(q_labels + i, "queue#%d (%s)", i, __FUNCTION__);
+ assert(q_labels[i]);
+ q[i] = dispatch_queue_create(q_labels[i], NULL);
+ assert(q[i]);
+ struct baton *bat = valloc(sizeof(struct baton));
+ assert(bat);
+ bat->passes_left = SMALL_LOOP;
+ bat->at_q = i;
+ bat->baton_number = i / q_div_b;
+ dispatch_queue_suspend(complete_q);
+ dispatch_async(q[i], ^(void) {
+ struct timeval now;
+ gettimeofday(&now, NULL);
+ int sec = time_to_start.tv_sec - now.tv_sec;
+ if (sec >= 0) {
+ int usec = time_to_start.tv_usec + now.tv_usec;
+ if (usec > 0 || sec > 0) {
+ usleep(1000000 * sec + usec);
+ } else {
+ // XXX: log here
+ }
+ }
+
+ // We want to measure the time from the first
+ // baton pass, and NOT include hte wait time
+ // for eveyone to start to fire
+ if (!start_time) {
+ uint64_t s = mach_absolute_time();
+ __sync_bool_compare_and_swap(&start_time, 0, s);
+ }
+
+ pass(q, bat, n_queues, complete_q);
+ });
+ }
+
+ // XXX: dispatch_sync(complete_q, ^{});
+ rc = pthread_mutex_lock(&kludge);
+ assert(!rc);
+
+ end_time = mach_absolute_time();
+ report(__FUNCTION__, "overload#1", (end_time - start_time), SMALL_LOOP*n_batons, "mach");
+ // Many releases and free()s
+
+}
+
+int main(int argc, char *argv[]) {
+ // Someday we will be able to take a list of tests to run, or exclude, or something.
+
+ // There are somewhat diffrent perfomance chararistics when using the
+ // main queue, so we use a "normal" queue for all our tests.
+ dispatch_queue_t bench_q = dispatch_queue_create("benhmark Q", NULL);
+
+ dispatch_async(bench_q, ^{
+ // These two aren't as intresting in duel core, they queue all
+ // the calls before making them which isn't really what we
+ // want to test, is it? It also limites the number of loops
+ // we can spin around.
+#if 1
+ bench_message_round_trip();
+ bench_precopy_message_round_trip();
+
+ bench_message_round_type_syncasync();
+ bench_message_round_trip_f();
+ bench_message_round_type_syncasync_f();
+#endif
+ bench_baton();
+ bench_overload1();
+ bench_overload2();
+
+ // This leaks, so we run it last. Also it gives
+ // wrong results if stdio hasn't been started already,
+ // so we definitly don't want to run it first even if
+ // the leaks are fixed (or ignored)
+ bench_queue_mem_use();
+
+ exit(0);
+ });
+
+ dispatch_main();
+}
projects / apple / libdispatch.git / blobdiff