.duration_sec = 5,
        .affinity = false,
        .quiet = false,
-       .consumer_cnt = 1,
+       .consumer_cnt = 0,
        .producer_cnt = 1,
 };
 
 
 
 static void validate(void)
 {
-       if (env.consumer_cnt != 1) {
+       if (env.consumer_cnt != 0) {
                fprintf(stderr,
-                       "The bloom filter benchmarks do not support multi-consumer use\n");
+                       "The bloom filter benchmarks do not support consumer\n");
                exit(1);
        }
 }
        last_false_hits = total_false_hits;
 }
 
-static void *consumer(void *input)
-{
-       return NULL;
-}
-
 const struct bench bench_bloom_lookup = {
        .name = "bloom-lookup",
        .argp = &bench_bloom_map_argp,
        .validate = validate,
        .setup = bloom_lookup_setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = validate,
        .setup = bloom_update_setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = validate,
        .setup = false_positive_setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = false_hits_report_progress,
        .report_final = false_hits_report_final,
        .validate = validate,
        .setup = hashmap_no_bloom_setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = validate,
        .setup = hashmap_with_bloom_setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
 
 
 static void validate(void)
 {
-       if (env.consumer_cnt != 1) {
-               fprintf(stderr, "benchmark doesn't support multi-consumer!\n");
+       if (env.consumer_cnt != 0) {
+               fprintf(stderr, "benchmark doesn't support consumer!\n");
                exit(1);
        }
 }
        return NULL;
 }
 
-static void *consumer(void *input)
-{
-       return NULL;
-}
-
 static void measure(struct bench_res *res)
 {
 }
        .validate = validate,
        .setup = setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = NULL,
        .report_final = hashmap_report_final,
 
 
 static void validate(void)
 {
-       if (env.consumer_cnt != 1) {
-               fprintf(stderr, "benchmark doesn't support multi-consumer!\n");
+       if (env.consumer_cnt != 0) {
+               fprintf(stderr, "benchmark doesn't support consumer!\n");
                exit(1);
        }
 
        return NULL;
 }
 
-static void *consumer(void *input)
-{
-       return NULL;
-}
-
 static void measure(struct bench_res *res)
 {
 }
        .validate = validate,
        .setup = setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = NULL,
        .report_final = hashmap_report_final,
 
 
 static void validate(void)
 {
-       if (env.consumer_cnt != 1) {
-               fprintf(stderr, "benchmark doesn't support multi-consumer!\n");
+       if (env.consumer_cnt != 0) {
+               fprintf(stderr, "benchmark doesn't support consumer!\n");
                exit(1);
        }
 }
        return NULL;
 }
 
-static void *consumer(void *input)
-{
-       return NULL;
-}
-
 static void measure(struct bench_res *res)
 {
        res->hits = atomic_swap(&ctx.skel->bss->hits, 0);
        .validate = validate,
        .setup = setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = ops_report_progress,
        .report_final = ops_report_final,
 
        return NULL;
 }
 
-static void *count_global_consumer(void *input)
-{
-       return NULL;
-}
-
 static void count_global_measure(struct bench_res *res)
 {
        struct count_global_ctx *ctx = &count_global_ctx;
        return NULL;
 }
 
-static void *count_local_consumer(void *input)
-{
-       return NULL;
-}
-
 static void count_local_measure(struct bench_res *res)
 {
        struct count_local_ctx *ctx = &count_local_ctx;
 const struct bench bench_count_global = {
        .name = "count-global",
        .producer_thread = count_global_producer,
-       .consumer_thread = count_global_consumer,
        .measure = count_global_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .name = "count-local",
        .setup = count_local_setup,
        .producer_thread = count_local_producer,
-       .consumer_thread = count_local_consumer,
        .measure = count_local_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
 
                fprintf(stderr, "benchmark doesn't support multi-producer!\n");
                exit(1);
        }
-       if (env.consumer_cnt != 1) {
-               fprintf(stderr, "benchmark doesn't support multi-consumer!\n");
+       if (env.consumer_cnt != 0) {
+               fprintf(stderr, "benchmark doesn't support consumer!\n");
                exit(1);
        }
 
        syscall(__NR_getpgid);
 }
 
-static void *consumer(void *input)
-{
-       return NULL;
-}
-
 static void *producer(void *input)
 {
        while (true)
        .validate = validate,
        .setup = local_storage_cache_get_setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = local_storage_report_progress,
        .report_final = local_storage_report_final,
        .validate = validate,
        .setup = local_storage_cache_get_interleaved_setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = local_storage_report_progress,
        .report_final = local_storage_report_final,
        .validate = validate,
        .setup = hashmap_setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = local_storage_report_progress,
        .report_final = local_storage_report_final,
 
 
 static void validate(void)
 {
-       if (env.consumer_cnt > 1) {
+       if (env.consumer_cnt != 0) {
                fprintf(stderr,
                        "local-storage-create benchmark does not need consumer\n");
                exit(1);
        res->drops = atomic_swap(&skel->bss->kmalloc_cnts, 0);
 }
 
-static void *consumer(void *input)
-{
-       return NULL;
-}
-
 static void *sk_producer(void *input)
 {
        struct thread *t = &threads[(long)(input)];
        .validate = validate,
        .setup = setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = report_progress,
        .report_final = report_final,
 
                fprintf(stderr, "benchmark doesn't support multi-producer!\n");
                exit(1);
        }
-       if (env.consumer_cnt != 1) {
-               fprintf(stderr, "benchmark doesn't support multi-consumer!\n");
+       if (env.consumer_cnt != 0) {
+               fprintf(stderr, "benchmark doesn't support consumer!\n");
                exit(1);
        }
 
        ctx.prev_kthread_stime = ticks;
 }
 
-static void *consumer(void *input)
-{
-       return NULL;
-}
-
 static void *producer(void *input)
 {
        while (true)
        .validate = validate,
        .setup = local_storage_tasks_trace_setup,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = report_progress,
        .report_final = report_final,
 
                fprintf(stderr, "benchmark doesn't support multi-producer!\n");
                exit(1);
        }
-       if (env.consumer_cnt != 1) {
-               fprintf(stderr, "benchmark doesn't support multi-consumer!\n");
+       if (env.consumer_cnt != 0) {
+               fprintf(stderr, "benchmark doesn't support consumer!\n");
                exit(1);
        }
 }
        attach_bpf(ctx.skel->progs.prog5);
 }
 
-static void *consumer(void *input)
-{
-       return NULL;
-}
-
 const struct bench bench_rename_base = {
        .name = "rename-base",
        .validate = validate,
        .setup = setup_base,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = validate,
        .setup = setup_kprobe,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = validate,
        .setup = setup_kretprobe,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = validate,
        .setup = setup_rawtp,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = validate,
        .setup = setup_fentry,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = validate,
        .setup = setup_fexit,
        .producer_thread = producer,
-       .consumer_thread = consumer,
        .measure = measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
 
 static void bufs_validate(void)
 {
        if (env.consumer_cnt != 1) {
-               fprintf(stderr, "rb-libbpf benchmark doesn't support multi-consumer!\n");
+               fprintf(stderr, "rb-libbpf benchmark needs one consumer!\n");
                exit(1);
        }
 
 
 
 static void strncmp_validate(void)
 {
-       if (env.consumer_cnt != 1) {
-               fprintf(stderr, "strncmp benchmark doesn't support multi-consumer!\n");
+       if (env.consumer_cnt != 0) {
+               fprintf(stderr, "strncmp benchmark doesn't support consumer!\n");
                exit(1);
        }
 }
        return NULL;
 }
 
-static void *strncmp_consumer(void *ctx)
-{
-       return NULL;
-}
-
 static void strncmp_measure(struct bench_res *res)
 {
        res->hits = atomic_swap(&ctx.skel->bss->hits, 0);
        .validate = strncmp_validate,
        .setup = strncmp_no_helper_setup,
        .producer_thread = strncmp_producer,
-       .consumer_thread = strncmp_consumer,
        .measure = strncmp_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = strncmp_validate,
        .setup = strncmp_helper_setup,
        .producer_thread = strncmp_producer,
-       .consumer_thread = strncmp_consumer,
        .measure = strncmp_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
 
 
 static void trigger_validate(void)
 {
-       if (env.consumer_cnt != 1) {
-               fprintf(stderr, "benchmark doesn't support multi-consumer!\n");
+       if (env.consumer_cnt != 0) {
+               fprintf(stderr, "benchmark doesn't support consumer!\n");
                exit(1);
        }
 }
        attach_bpf(ctx.skel->progs.bench_trigger_fmodret);
 }
 
-static void *trigger_consumer(void *input)
-{
-       return NULL;
-}
-
 /* make sure call is not inlined and not avoided by compiler, so __weak and
  * inline asm volatile in the body of the function
  *
        .name = "trig-base",
        .validate = trigger_validate,
        .producer_thread = trigger_base_producer,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_base_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = trigger_validate,
        .setup = trigger_tp_setup,
        .producer_thread = trigger_producer,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = trigger_validate,
        .setup = trigger_rawtp_setup,
        .producer_thread = trigger_producer,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = trigger_validate,
        .setup = trigger_kprobe_setup,
        .producer_thread = trigger_producer,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = trigger_validate,
        .setup = trigger_fentry_setup,
        .producer_thread = trigger_producer,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = trigger_validate,
        .setup = trigger_fentry_sleep_setup,
        .producer_thread = trigger_producer,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .validate = trigger_validate,
        .setup = trigger_fmodret_setup,
        .producer_thread = trigger_producer,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .name = "trig-uprobe-base",
        .setup = NULL, /* no uprobe/uretprobe is attached */
        .producer_thread = uprobe_base_producer,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_base_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .name = "trig-uprobe-with-nop",
        .setup = uprobe_setup_with_nop,
        .producer_thread = uprobe_producer_with_nop,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .name = "trig-uretprobe-with-nop",
        .setup = uretprobe_setup_with_nop,
        .producer_thread = uprobe_producer_with_nop,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .name = "trig-uprobe-without-nop",
        .setup = uprobe_setup_without_nop,
        .producer_thread = uprobe_producer_without_nop,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
        .name = "trig-uretprobe-without-nop",
        .setup = uretprobe_setup_without_nop,
        .producer_thread = uprobe_producer_without_nop,
-       .consumer_thread = trigger_consumer,
        .measure = trigger_measure,
        .report_progress = hits_drops_report_progress,
        .report_final = hits_drops_report_final,
 
 
 set -eufo pipefail
 
+RUN_RB_BENCH="$RUN_BENCH -c1"
+
 header "Single-producer, parallel producer"
 for b in rb-libbpf rb-custom pb-libbpf pb-custom; do
-       summarize $b "$($RUN_BENCH $b)"
+       summarize $b "$($RUN_RB_BENCH $b)"
 done
 
 header "Single-producer, parallel producer, sampled notification"
 for b in rb-libbpf rb-custom pb-libbpf pb-custom; do
-       summarize $b "$($RUN_BENCH --rb-sampled $b)"
+       summarize $b "$($RUN_RB_BENCH --rb-sampled $b)"
 done
 
 header "Single-producer, back-to-back mode"
 for b in rb-libbpf rb-custom pb-libbpf pb-custom; do
-       summarize $b "$($RUN_BENCH --rb-b2b $b)"
-       summarize $b-sampled "$($RUN_BENCH --rb-sampled --rb-b2b $b)"
+       summarize $b "$($RUN_RB_BENCH --rb-b2b $b)"
+       summarize $b-sampled "$($RUN_RB_BENCH --rb-sampled --rb-b2b $b)"
 done
 
 header "Ringbuf back-to-back, effect of sample rate"
 for b in 1 5 10 25 50 100 250 500 1000 2000 3000; do
-       summarize "rb-sampled-$b" "$($RUN_BENCH --rb-b2b --rb-batch-cnt $b --rb-sampled --rb-sample-rate $b rb-custom)"
+       summarize "rb-sampled-$b" "$($RUN_RB_BENCH --rb-b2b --rb-batch-cnt $b --rb-sampled --rb-sample-rate $b rb-custom)"
 done
 header "Perfbuf back-to-back, effect of sample rate"
 for b in 1 5 10 25 50 100 250 500 1000 2000 3000; do
-       summarize "pb-sampled-$b" "$($RUN_BENCH --rb-b2b --rb-batch-cnt $b --rb-sampled --rb-sample-rate $b pb-custom)"
+       summarize "pb-sampled-$b" "$($RUN_RB_BENCH --rb-b2b --rb-batch-cnt $b --rb-sampled --rb-sample-rate $b pb-custom)"
 done
 
 header "Ringbuf back-to-back, reserve+commit vs output"
-summarize "reserve" "$($RUN_BENCH --rb-b2b                 rb-custom)"
-summarize "output"  "$($RUN_BENCH --rb-b2b --rb-use-output rb-custom)"
+summarize "reserve" "$($RUN_RB_BENCH --rb-b2b                 rb-custom)"
+summarize "output"  "$($RUN_RB_BENCH --rb-b2b --rb-use-output rb-custom)"
 
 header "Ringbuf sampled, reserve+commit vs output"
-summarize "reserve-sampled" "$($RUN_BENCH --rb-sampled                 rb-custom)"
-summarize "output-sampled"  "$($RUN_BENCH --rb-sampled --rb-use-output rb-custom)"
+summarize "reserve-sampled" "$($RUN_RB_BENCH --rb-sampled                 rb-custom)"
+summarize "output-sampled"  "$($RUN_RB_BENCH --rb-sampled --rb-use-output rb-custom)"
 
 header "Single-producer, consumer/producer competing on the same CPU, low batch count"
 for b in rb-libbpf rb-custom pb-libbpf pb-custom; do
-       summarize $b "$($RUN_BENCH --rb-batch-cnt 1 --rb-sample-rate 1 --prod-affinity 0 --cons-affinity 0 $b)"
+       summarize $b "$($RUN_RB_BENCH --rb-batch-cnt 1 --rb-sample-rate 1 --prod-affinity 0 --cons-affinity 0 $b)"
 done
 
 header "Ringbuf, multi-producer contention"
 for b in 1 2 3 4 8 12 16 20 24 28 32 36 40 44 48 52; do
-       summarize "rb-libbpf nr_prod $b" "$($RUN_BENCH -p$b --rb-batch-cnt 50 rb-libbpf)"
+       summarize "rb-libbpf nr_prod $b" "$($RUN_RB_BENCH -p$b --rb-batch-cnt 50 rb-libbpf)"
 done