Changeset 24ceace for benchmark

Timestamp:

May 2, 2022, 3:19:03 AM (4 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

12bb5ab1, 49a1684

Parents:

9e7236f4 (diff), 4b4f95f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

benchmark

Files:

• Cargo.toml.in (modified) (1 diff)
• Makefile.am (modified) (1 diff)
• c.c (deleted)
• plot.py (modified) (4 diffs)
• process-mutilate.py (added)
• readyQ/churn.cfa (modified) (7 diffs)
• readyQ/churn.rs (added)
• rmit.py (modified) (1 diff)

benchmark/Cargo.toml.in

@@ -4 +4 @@
 authors = ["Cforall"]
 edition = "2018"
+
+[[bin]]
+name = "rdq-churn-tokio"
+path = "@abs_srcdir@/readyQ/churn.rs"
 
 [[bin]]

benchmark/Makefile.am

@@ -614 +614 @@
 RDQBENCHES = \
         rdq-churn-cfa \
+        rdq-churn-tokio \
+        rdq-churn-go \
+        rdq-churn-fibre \
         rdq-cycle-cfa \
         rdq-cycle-tokio \

benchmark/plot.py

@@ -15 +15 @@
 import numpy
 import re
+import statistics
 import sys
 
@@ -21 +22 @@
 
 class Field:
-        def __init__(self, unit, _min):
+        def __init__(self, unit, _min, _log):
                 self.unit = unit
                 self.min  = _min
+                self.log  = _log
 
 field_names = {
-        "ns per ops"           : Field('ns'    , 0),
-        "Number of processors" : Field(''      , 1),
-        "Ops per procs"        : Field('Ops'   , 0),
-        "Ops per threads"      : Field('Ops'   , 0),
-        "ns per ops/procs"     : Field('ns'    , 0),
-        "Number of threads"    : Field('thrd'  , 1),
-        "Total Operations(ops)": Field('Ops'   , 0),
-        "Ops/sec/procs"        : Field('Ops'   , 0),
-        "Total blocks"         : Field('Blocks', 0),
-        "Ops per second"       : Field('Ops'   , 0),
-        "Cycle size (# thrds)" : Field('thrd'  , 1),
-        "Duration (ms)"        : Field('ms'    , 0),
+        "ns per ops"            : Field('ns'    , 0, False),
+        "Number of processors"  : Field(''      , 1, False),
+        "Ops per procs"         : Field('Ops'   , 0, False),
+        "Ops per threads"       : Field('Ops'   , 0, False),
+        "ns per ops/procs"      : Field('ns'    , 0, False),
+        "Number of threads"     : Field('thrd'  , 1, False),
+        "Total Operations(ops)" : Field('Ops'   , 0, False),
+        "Ops/sec/procs"         : Field('Ops'   , 0, False),
+        "Total blocks"          : Field('Blocks', 0, False),
+        "Ops per second"        : Field('Ops'   , 0, False),
+        "Cycle size (# thrds)"  : Field('thrd'  , 1, False),
+        "Duration (ms)"         : Field('ms'    , 0, False),
+        "Target QPS"            : Field('QPS'   , 0, False),
+        "Actual QPS"            : Field('QPS'   , 0, False),
+        "Median Read Latency"   : Field('us'    , 0, True),
+        "Tail Read Latency"     : Field('us'    , 0, True),
+        "Median Update Latency" : Field('us'    , 0, True),
+        "Tail Update Latency"   : Field('us'    , 0, True),
 }
 
-def plot(data, x, y, out):
+def plot(in_data, x, y, out):
         fig, ax = plt.subplots()
         colors = itertools.cycle(['#0095e3','#006cb4','#69df00','#0aa000','#fb0300','#e30002','#fd8f00','#ff7f00','#8f00d6','#4b009a','#ffff00','#b13f00'])
-        series = {}
-        for entry in data:
-                if not entry[0] in series:
-                        series[entry[0]] = {'x':[], 'y':[]}
+        series = {} # scatter data for each individual data point
+        groups = {} # data points for x value
+
+        print("Preparing Data")
+
+        for entry in in_data:
+                name = entry[0]
+                if not name in series:
+                        series[name] = {'x':[], 'y':[]}
+
+                if not name in groups:
+                        groups[name] = {}
 
                 if x in entry[2] and y in entry[2]:
-                        series[entry[0]]['x'].append(entry[2][x])
-                        series[entry[0]]['y'].append(entry[2][y])
+                        xval = entry[2][x]
+                        yval = entry[2][y]
+                        series[name]['x'].append(xval)
+                        series[name]['y'].append(yval)
+
+                        if not xval in groups[name]:
+                                groups[name][xval] = []
+
+                        groups[name][xval].append(yval)
+
+        print("Preparing Lines")
+
+        lines = {} # lines from groups with min, max, median, etc.
+        for name, data in groups.items():
+                if not name in lines:
+                        lines[name] = { 'x': [], 'min':[], 'max':[], 'med':[], 'avg':[] }
+
+                for xkey in sorted(data):
+                        ys = data[xkey]
+                        lines[name]['x']  .append(xkey)
+                        lines[name]['min'].append(min(ys))
+                        lines[name]['max'].append(max(ys))
+                        lines[name]['med'].append(statistics.median(ys))
+                        lines[name]['avg'].append(statistics.mean(ys))
+
+        print("Making Plots")
 
         for name, data in series.items():
-                plt.scatter(data['x'], data['y'], color=next(colors), label=name, marker='x')
+                _col = next(colors)
+                plt.scatter(data['x'], data['y'], color=_col, label=name, marker='x')
+                plt.plot(lines[name]['x'], lines[name]['min'], '--', color=_col)
+                plt.plot(lines[name]['x'], lines[name]['max'], '--', color=_col)
+                plt.plot(lines[name]['x'], lines[name]['med'], '-', color=_col)
+
+        print("Calculating Extremums")
 
         mx = max([max(s['x']) for s in series.values()])
         my = max([max(s['y']) for s in series.values()])
 
+        print("Finishing Plots")
+
         plt.ylabel(y)
-        plt.xlim(field_names[x].min, mx + 0.25)
-        plt.xticks(range(1, math.ceil(mx) + 1))
+        # plt.xticks(range(1, math.ceil(mx) + 1))
         plt.xlabel(x)
-        plt.ylim(field_names[y].min, my*1.2)
         plt.grid(b = True)
         ax.xaxis.set_major_formatter( EngFormatter(unit=field_names[x].unit) )
+        if field_names[x].log:
+                ax.set_xscale('log')
+        else:
+                plt.xlim(field_names[x].min, mx + 0.25)
+
         ax.yaxis.set_major_formatter( EngFormatter(unit=field_names[y].unit) )
+        if field_names[y].log:
+                ax.set_yscale('log')
+        else:
+                plt.ylim(field_names[y].min, my*1.2)
+
         plt.legend(loc='upper left')
+
+        print("Results Ready")
         if out:
                 plt.savefig(out)
@@ -76 +134 @@
         # ================================================================================
         # parse command line arguments
-        parser = parser = argparse.ArgumentParser(description='Python Script to draw R.M.I.T. results')
-        parser.add_argument('-f', '--file', nargs='?', type=argparse.FileType('r'), default=sys.stdin)
-        parser.add_argument('-o', '--out', nargs='?', type=str, default=None)
-        parser.add_argument('-y', nargs='?', type=str, default="")
+        parser = argparse.ArgumentParser(description='Python Script to draw R.M.I.T. results')
+        parser.add_argument('-f', '--file', nargs='?', type=argparse.FileType('r'), default=sys.stdin, help="Input file")
+        parser.add_argument('-o', '--out', nargs='?', type=str, default=None, help="Output file")
+        parser.add_argument('-y', nargs='?', type=str, default="", help="Which field to use as the Y axis")
+        parser.add_argument('-x', nargs='?', type=str, default="", help="Which field to use as the X axis")
 
-        try:
-                options =  parser.parse_args()
-        except:
-                print('ERROR: invalid arguments', file=sys.stderr)
-                parser.print_help(sys.stderr)
-                sys.exit(1)
+        options =  parser.parse_args()
 
         # ================================================================================
@@ -110 +164 @@
         if not options.out :
                 print(series)
-                print("fields")
-                for f in fields:
-                        print("{}".format(f))
+                print("fields: ", ' '.join(fields))
 
-        if options.y and options.y in field_names.keys():
-                plot(data, "Number of processors", options.y, options.out)
-        else:
-                if options.y:
-                        print("Could not find key '{}', defaulting to 'ns per ops'".format(options.y))
-                plot(data, "Number of processors", "ns per ops", options.out)
+        wantx = "Number of processors"
+        wanty = "ns per ops"
+
+        if options.x:
+                if options.x in field_names.keys():
+                        wantx = options.x
+                else:
+                        print("Could not find X key '{}', defaulting to '{}'".format(options.x, wantx))
+
+        if options.y:
+                if options.y in field_names.keys():
+                        wanty = options.y
+                else:
+                        print("Could not find Y key '{}', defaulting to '{}'".format(options.y, wanty))
+
+
+        plot(data, wantx, wanty, options.out)

benchmark/readyQ/churn.cfa

@@ -1 +1 @@
 #include "rq_bench.hfa"
 
+#include <locks.hfa>
+
 unsigned spot_cnt = 2;
-bench_sem * volatile * spots;
+semaphore * spots;
 
 thread BThrd {
         unsigned long long count;
         unsigned long long blocks;
-        bench_sem sem;
+        bool skip;
 };
 
@@ -14 +16 @@
         this.count  = 0;
         this.blocks = 0;
+        this.skip = false;
 }
 
@@ -19 +22 @@
 
 void main( BThrd & this ) with( this ) {
-        wait( sem );
+        park();
         for() {
-                uint32_t r = prng();
-                bench_sem * next = __atomic_exchange_n(&spots[r % spot_cnt], &sem, __ATOMIC_SEQ_CST);
-                if(next) post( *next );
-                blocks += wait( sem );
+                uint32_t r = prng(this);
+                semaphore & sem = spots[r % spot_cnt];
+                if(!skip) V( sem );
+                blocks += P( sem );
+                skip = false;
+
                 count ++;
                 if( clock_mode && stop) break;
@@ -49 +54 @@
                         spots = aalloc(spot_cnt);
                         for(i; spot_cnt) {
-                                spots[i] = 0p;
+                                (spots[i]){ 0 };
                         }
 
@@ -55 +60 @@
                         BThrd * threads[nthreads];
                         for(i; nthreads ) {
-                                threads[i] = malloc();
-                                (*threads[i]){};
+                                BThrd & t = *(threads[i] = malloc());
+                                (t){};
+                                t.skip = i < spot_cnt;
                         }
                         printf("Starting\n");
@@ -64 +70 @@
 
                         for(i; nthreads) {
-                                post( threads[i]->sem );
+                                unpark( *threads[i] );
                         }
                         wait(start, is_tty);
@@ -72 +78 @@
                         printf("\nDone\n");
 
+                        for(i; spot_cnt) {
+                                for(10000) V( spots[i] );
+                        }
+
                         for(i; nthreads) {
-                                post( threads[i]->sem );
                                 BThrd & thrd = join( *threads[i] );
                                 global_counter += thrd.count;

benchmark/rmit.py

@@ -281 +281 @@
 
         if options.file != sys.stdout:
-                print("Done                                                                                ")
+                print("Done");                                                                                ")