ref: 60ecd07e6d3f5786c8723dc9172c35d580fdadc8
dir: /os/port/devbench.c/
#include "u.h"
#include "../port/lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include <interp.h>
#include "io.h"
#include "../port/error.h"
#include <isa.h>
#include "kernel.h"
/* Builtin module support */
#include "bench.h"
#include "benchmod.h"
typedef enum { None, Calibrate, Base, Op, Intr, Dis, Gc, MS2T, xTest};
static struct {
int inuse; /* reference count */
int test;
void* scratch;
char* buf;
int bufsz;
char* wpos;
void (*op)(void);
vlong tickstart;
} bench;
static void
log(char *msg, ...)
{
va_list ap;
va_start(ap, msg);
bench.wpos = vseprint(bench.wpos, bench.buf+bench.bufsz, msg, ap);
va_end(ap);
}
void
elog(char *msg, ...)
{
va_list ap;
if(bench.buf == 0)
return;
va_start(ap, msg);
bench.wpos = vseprint(bench.wpos, bench.buf+bench.bufsz, msg, ap);
va_end(ap);
}
static void
clear(void)
{
bench.wpos = bench.buf;
}
static long
rep(void *to, long n, ulong offset)
{
long left = bench.wpos - bench.buf - offset;
if(left < 0)
left = 0;
if(n > left)
n = left;
memmove(to, bench.buf+offset, n);
return n;
}
static long
notest(int report, void *va, long n, ulong offset)
{
USED(report, va, n, offset);
if(report)
return rep(va, n, offset);
return 0;
}
// Calibration
static long MS2TS = 0; // time stamps per millisec
static long US2TS = 0; // time stamps per microsecond
static long
cal(int report, void *va, long n, ulong offset)
{
int tot, i, lim, low, max, pl, mdelay;
ulong t;
if(report)
return rep(va, n, offset);
clear();
setpri(PriRealtime);
lim = 1000;
low = 64000000;
max = 0;
tot = 0;
mdelay = 1000;
for(i=0; i<lim; i++){
do{
pl = splhi();
t = archrdtsc32();
microdelay(mdelay);
t = archrdtsc32() - t;
splx(pl);
} while(t < 0);
if(t < low)
low = t;
if(t > max)
max = t;
tot += t;
}
MS2TS = tot/lim;
US2TS = MS2TS/1000;
if(va)
log("mdelay=%lud lim=%lud tot=%lud low=%lud max=%lud\n", mdelay, lim, tot, low, max);
setpri(PriNormal);
return n;
}
/*
* ticks to format string
*/
/*static*/ char *
ts2str(vlong ticks)
{
#define Nbuf 5
static char b[Nbuf][40];
static int n=Nbuf-1;
char *fmt, *unit;
double d;
if(0){
print("ticks=%lld MS2TS=%ld\n", ticks, MS2TS);
d = (double)ticks;
print("1:%f\n", d);
d = (double)ticks*1000;
//print("2:%f\n", d);
d = ((double)ticks)/MS2TS;
//print("3:%f\n", d);
}
n = (n+1)%Nbuf;
if(ticks > MS2TS*1000) {
fmt = "%.2f %s";
unit = "s";
d = ((double)ticks/MS2TS) * 1000.0;
} else if(ticks > MS2TS) {
fmt = "%.2f %s";
unit = "ms";
d = (double)ticks/MS2TS;
} else if(ticks > MS2TS/1000) {
fmt = "%.2f %s";
unit = "us";
d = ((double)ticks*1000)/MS2TS;
} else {
fmt = "%.2f %s";
unit = "ns";
d = ((double)ticks*1000*1000)/MS2TS;
}
sprint(b[n], fmt, d, unit);
return b[n];
}
/*
* ticks to microseconds
*/
static double
ts2us(vlong ticks)
{
return ((double)ticks*1000)/MS2TS;
}
/*
* microseconds timestamp
*/
static vlong
bus(int reset)
{
vlong now;
if(US2TS == 0)
return 0;
if(reset) {
bench.tickstart = archrdtsc();
return 0;
}
now = archrdtsc();
return ((now-bench.tickstart))/US2TS;
}
// Base
static long
base(int report, void *va, long n, ulong offset)
{
int tot, i, lim, low, max, pl;
ulong t;
char *bm;
if(report)
return rep(va, n, offset);
clear();
setpri(PriRealtime);
lim = 1000;
low = 64000000;
max = 0;
tot = 0;
for(i=0; i<lim; i++){
do {
pl = splhi();
t = archrdtsc32();
// do nothing
t = archrdtsc32() - t;
splx(pl);
} while(t < 0);
if(t < low)
low = t;
if(t > max)
max = t;
tot += t;
}
bm = ts2str(tot/lim);
log("%d %lud %lud %lud %lud (%s)\n", up->pid, lim, tot, low, max, bm);
setpri(PriNormal);
return n;
}
// Timeop
typedef struct Psync Psync;
enum {
Maxprocs=3,
};
struct Psync {
Rendez r;
int flag;
int id;
int awaken;
};
static Psync timesync[Maxprocs];
static Ref nactive;
static Ref nbusy;
static RWlock sync;
static void
nilop(void)
{
}
static int
timev(void *a)
{
return *(int*)a;
}
static void
timeop0(void *ap)
{
int tot, i, lim, low, max;
ulong t;
Psync *ps;
char *bm;
ps = ap;
setpri(PriRealtime);
incref(&nactive);
sleep(&ps->r, timev, &ps->flag);
rlock(&sync);
lim = 1000;
low = 64000000;
max = 0;
tot = 0;
for(i=0; i<lim; i++){
do{
t = archrdtsc32();
(*bench.op)();
t = archrdtsc32() - t;
}while(t < 0);
if(t < low)
low = t;
if(t > max)
max = t;
tot += t;
}
bm = ts2str(tot/lim);
log("%d %lud %lud %lud %lud (%s)\n", up->pid, lim, tot, low, max, bm);
runlock(&sync);
pexit("", 0);
}
static long
timeop(int report, void *va, long n, ulong offset)
{
int i, np, pl;
if(report)
return rep(va, n, offset);
clear();
bench.op = 0;
if(strncmp(va, "nil", 3) == 0)
bench.op = nilop;
else if(strncmp(va, "sched", 5) == 0)
bench.op = sched;
else
return 0;
for(np=1; np<=Maxprocs; np++) {
nactive.ref = 0;
wlock(&sync);
log("%d procs\n", np);
setpri(PriRealtime);
for(i=0; i<np; i++) {
timesync[i].id = i;
kproc("timeop", timeop0, ×ync[i], 0);
}
while(nactive.ref < np)
tsleep(&up->sleep, return0, 0, 20);
for(i=0; i<np; i++){
timesync[i].flag = 1;
wakeup(×ync[i].r);
}
sched();
pl = splhi();
setpri(PriNormal);
wunlock(&sync);
// now they run
wlock(&sync); // wait for last reader
wunlock(&sync);
splx(pl);
}
return n;
}
typedef struct Ictr Ictr;
struct Ictr {
ulong base;
ulong sleep;
ulong spllo;
ulong intr;
ulong isave;
ulong arrive;
ulong wakeup;
ulong awake;
};
static Ictr counters[5/*100*/], *curct;
static int intrwant;
static Rendez vous;
int spltbl; /* set by spllo */
int intrtbl; /* set by intrvec() */
int isavetbl; /* set by intrvec() */
static int ienable;
static void
intrwake(void)
{
if(ienable == 0)
return;
ienable = 0;
if(spltbl == 0) // not used here
curct->spllo = curct->intr = curct->isave = archrdtsc32();
else {
curct->spllo = spltbl;
curct->intr = intrtbl;
curct->isave = isavetbl;
}
curct->arrive = archrdtsc32();
intrwant = 0;
wakeup(&vous);
curct->wakeup = archrdtsc32();
}
/*
* sleep calls intrtest with splhi (under lock):
* provoke the interrupt now, so that it is guaranteed
* not to happen until sleep has queued the process,
* forcing wakeup to do something.
*/
static int
intrtest(void*)
{
ienable = 1; /* enable recording on interrupt */
curct->sleep = archrdtsc32();
return intrwant==0;
}
static long
intrtime(int report, void *va, long n, ulong offset)
{
Ictr *ic;
long t;
int i;
char *bm;
if(report)
return rep(va, n, offset);
clear();
setpri(PriRealtime);
sched();
curct = counters;
ienable = 0;
addclock0link(intrwake, MS2HZ);
for(i=0; i<nelem(counters); i++){
curct = &counters[i];
intrwant = 1;
curct->base = archrdtsc32();
sleep(&vous, intrtest, nil);
curct->awake = archrdtsc32();
sched(); /* just to slow it down between trials */
}
log("interrupt\n");
for(i=0; i<nelem(counters); i++){
ic = &counters[i];
t = ic->awake - ic->base;
bm = ts2str(ic->awake - ic->arrive);
ic->awake -= ic->wakeup;
ic->wakeup -= ic->arrive;
ic->arrive -= ic->isave;
ic->isave -= ic->intr;
ic->intr -= ic->spllo;
ic->spllo -= ic->sleep;
ic->sleep -= ic->base;
log("%ld\t%ld\t%ld\t%ld\t%ld\t%ld\t%ld\t%ld (%s)\n", ic->sleep, ic->spllo, ic->intr, ic->isave, ic->arrive, ic->wakeup, ic->awake, t, bm);
}
setpri(PriNormal);
return n;
}
/* DIS operation timing */
typedef struct {
vlong n; /* count */
vlong min;
vlong max;
vlong sum;
vlong sumsq; /* sum of squares */
} Stat;
static void
stat(enum { Reset, Inc } op, Stat *c, vlong val)
{
switch(op) {
case Reset:
c->n = 0;
c->sum = 0;
c->sumsq = 0;
c->min = 0;
c->max = 0;
break;
case Inc:
c->n++;
c->sum += val;
c->sumsq += val*val;
break;
}
if(val < c->min || c->n == 1)
c->min = val;
if(val > c->max || c->n == 1)
c->max = val;
}
static void
statinc(Stat *d, Stat *s)
{
d->n += s->n;
d->sum += s->sum;
d->sumsq += s->sumsq;
if(s->min < d->min || d->n == s->n)
d->min = s->min;
if(s->max > d->max || d->n == s->n)
d->max = s->max;
}
enum
{
HSIZE = 31,
MAXCOUNT = 100000000L,
};
typedef struct {
int op;
int pc;
long count;
Stat t; /* combined dec and execution time */
} Istat;
typedef struct Mstat Mstat;
struct Mstat {
char* name;
char* path;
int ninst;
Istat* inst;
Inst* base;
Mstat* hash;
Mstat* link;
};
struct
{
Mstat* hash[HSIZE];
Mstat* list;
} vmstat;
extern struct /* see ../../interp/tab.h:/keywds/ */
{
char* name;
int op;
int terminal;
}keywds[];
static char *
opname(int op)
{
char *name;
if(op < 0 || op >= MAXDIS)
return "Unknown";
return keywds[op].name;
if(name == 0)
name = "<Noname>";
return name;
}
static void
mreset(void)
{
Mstat *mp, *link;
for(mp=vmstat.list; mp; mp=link) {
link = mp->link;
free(mp->inst);
free(mp);
}
vmstat.list = 0;
memset(vmstat.hash, 0, HSIZE*sizeof(Mstat*));
}
static ulong
hash(void *s)
{
ulong sum = 0;
uchar *a = s;
while(*a)
sum = (sum << 1) + *a++;
return sum%HSIZE;
}
static Mstat *
mlookup(Module *mod)
{
Mstat *m;
ulong h;
for(m=vmstat.hash[hash(mod->name)]; m; m=m->hash)
if(strcmp(m->name, mod->name) == 0
&& strcmp(m->path, mod->path) == 0) {
return m;
}
m = malloc(sizeof(Mstat));
if(m == 0)
return 0;
kstrdup(&m->name, mod->name);
kstrdup(&m->path, mod->path);
m->ninst = mod->nprog;
m->inst = malloc(m->ninst*sizeof(Istat));
if(m->path == 0 || m->inst == 0)
return 0;
m->base = mod->prog;
m->link = vmstat.list;
vmstat.list = m;
h = hash(m->name);
m->hash = vmstat.hash[h];
vmstat.hash[h] = m;
return m;
}
/* interpreted code Dis timing */
void
bxec(Prog *p)
{
int op, pc;
vlong t0, t;
Mstat* ms;
Istat* is;
Module *om;
R = p->R;
R.MP = R.M->MP;
R.IC = p->quanta;
if(p->kill != nil) {
char *m;
m = p->kill;
p->kill = nil;
error(m);
}
if(R.M->compiled)
comvec();
else {
om = 0;
ms = mlookup(R.M->m);
do {
op = R.PC->op;
pc = R.PC-R.M->prog;
if(om != R.M->m) {
om = R.M->m;
ms = mlookup(R.M->m);
}
t0 = archrdtsc();
dec[R.PC->add]();
R.PC++;
optab[op]();
t = archrdtsc();
if(ms) {
is = &ms->inst[pc];
if(is->count < MAXCOUNT) {
if(is->count++ == 0) {
is->op = op;
is->pc = pc;
}
stat(Inc, &is->t, t-t0);
}
}
if(op==ISPAWN || op==IMSPAWN) {
Prog *new = delruntail(Pdebug);
new->xec = bxec;
addrun(new);
}
} while(--R.IC != 0);
}
p->R = R;
}
/* compiled code Dis timing */
static struct { /* compiled code timing */
int set;
int op, pc; /* Dis opcode and program counter */
vlong t0, t; /* time-in and time-out */
vlong base; /* cost of doing the timing */
Mstat *ms;
Module *om;
int timing; /* between "dis timer start" and stop */
} C;
enum { Nop = 0 }; /* opcode value for Dis NOP instruction */
void
dopostcomp(vlong t)
{
Istat* is;
C.t = t;
C.set = 0;
if(C.ms != 0) {
is = &C.ms->inst[C.pc];
if(C.op == Nop) { /* NOP calibration */
vlong newbase = C.t - C.t0;
if(C.base == 0 || newbase < C.base)
C.base = newbase;
}
if(is->count < MAXCOUNT) {
if(is->count++ == 0) {
is->op = C.op;
is->pc = C.pc;
}
stat(Inc, &is->t, C.t-C.t0/*-C.base*/);
}
}
}
void
postcomp(void)
{
vlong t;
t = archrdtsc();
if(C.timing == 0 || C.set == 0)
return;
dopostcomp(t);
}
void
precomp(void)
{
vlong t;
t = archrdtsc();
if(C.timing == 0)
return;
if(C.set)
dopostcomp(t);
C.pc = *(ulong *)R.m;
C.op = *(ulong *)R.s;
if(C.om != R.M->m) {
C.om = R.M->m;
C.ms = mlookup(R.M->m);
}
C.set = 1;
C.t0 = archrdtsc();
}
/* standard deviation */
static vlong
sdev(Stat *s)
{
extern double sqrt(double);
vlong var;
var = s->sum;
var *= var/s->n;
var = (s->sumsq - var)/s->n;
return (vlong)sqrt(var);
}
/*
* Use the sequence:
* 1. "timer startclr" or "timer start", then,
* 2. Any DIS operations, and,
* 3. "timer stop", to stop timing.
* 4. Read the results from the data file after:
* a) "timer report" to get module/pc level results, or
* b) "timer summary" to get opcode level results
*/
static long
distime(int report, void *va, long n, ulong offset)
{
Prog *p;
Mstat *mp;
Istat *ip, *ep;
if(report)
return rep(va, n, offset);
clear();
acquire();
p = currun();
if(strncmp(va, "timer startclr", 14) == 0) {
mreset();
memset(&C, 0, sizeof(C));
C.timing = 1;
p->xec = bxec;
} else if(strncmp(va, "timer start", 11) == 0) {
p->xec = bxec;
C.timing = 1;
} else if(strncmp(va, "timer stop", 10) == 0) {
p->xec = xec; /* bug: stop all xec threads */
C.timing = 0;
} else if(strncmp(va, "timer nilop", 11) == 0) {
} else if(strncmp(va, "timer report", 12) == 0) /* by address */
for(mp=vmstat.list; mp; mp=mp->link) {
ep = mp->inst + mp->ninst;
for(ip=mp->inst; ip<ep; ip++)
if(ip->count > 0) {
char *mean = ts2str(ip->t.sum/ip->count);
char *min = ts2str(ip->t.min);
char *max = ts2str(ip->t.max);
char *std = ts2str(sdev(&ip->t));
log("%s %d %s %ld %s %s %s %s\n", mp->path, ip->pc, opname(ip->op), ip->count, mean, min, max, std);
}
}
else if(strncmp(va, "timer summary", 13) == 0) { /* by opcode */
static Stat T[MAXDIS];
int i;
for(i=0; i<MAXDIS; i++)
stat(Reset, &T[i], 0);
for(mp=vmstat.list; mp; mp=mp->link) {
ep = mp->inst + mp->ninst;
for(ip=mp->inst; ip<ep; ip++)
if(ip->count > 0)
statinc(&T[ip->op], &ip->t);
}
for(i=0; i<MAXDIS; i++) {
Stat *t = &T[i];
char *mean = "0.00 ms";
char *min = "0.00 ms";
char *max = "0.00 ms";
char *std = "0.00 ms";
if(t->n > 0) {
mean = ts2str(t->sum/t->n);
min = ts2str(t->min);
max = ts2str(t->max);
std = ts2str(sdev(t));
}
log("%d %s %lld %s %s %s %s\n", i, opname(i), t->n, mean, min, max, std);
}
} else
n = 0;
R.IC = 1;
release();
return n;
}
/*
* Garbage collection
*/
static int nidle;
int
idlegc(void *p)
{
int done;
Prog *head;
vlong t0, t1, tot;
USED(p);
head = progn(0); /* isched.head */
done = gccolor + 3;
tot = 0;
while(gccolor < done && gcruns()) {
if(tready(nil))
break;
t0 = archrdtsc();
rungc(head);
t1 = archrdtsc();
t1 -= t0;
tot += t1;
// log(" %.2f", ts2us(t1));
}
log(" %.2f", ts2us(tot));
nidle--;
if(nidle == 0) {
log("\n");
return 1;
}
return 0;
}
static long
gctime(int report, void *va, long n, ulong offset)
{
int i;
vlong t0, t1;
Prog *head;
if(report)
return rep(va, n, offset);
clear();
acquire();
head = progn(0); /* isched.head */
/*
if(strncmp(va, "idle", 4) == 0) {
nidle = 100;
log("GCIDLE:1l:Observation:n:Time:us");
atidle(idlegc, 0);
} else if(strncmp(va, "stop", 4) == 0) {
atidledont(idlegc, 0);
} else
*/
if(strncmp(va, "sched", 5) == 0) {
log("GCSCHED:1l:Observation:n:Time:us");
for(i=0; i<1000; i++) {
t0 = archrdtsc();
rungc(head);
t1 = archrdtsc();
log(" %.2f", ts2us(t1-t0));
release();
acquire();
}
log("\n");
} else if(strncmp(va, "acquire", 7) == 0) {
log("GCACQUIRE:1l:Observation:n:Time:us");
for(i=0; i<1000; i++) {
t0 = archrdtsc();
release();
acquire();
head = progn(0); /* isched.head */
rungc(head);
release();
acquire();
t1 = archrdtsc();
log(" %.2f", ts2us(t1-t0));
}
log("\n");
}
release();
return n;
}
/*
* Request the number of time stamp ticks per millisecond
*/
static long
ms2ts(int report, void *va, long n, ulong offset)
{
if(report)
return rep(va, n, offset);
log("%.ld\n", MS2TS);
return n;
}
/*
* test
*/
static long
test(int report, void *va, long n, ulong offset)
{
// vlong v;
double d;
if(report)
return rep(va, n, offset);
// v = 5;
// print("vlong %lld\n", v);
// print("before cast\n");
// d = (double)v;
// print("after cast\n");
// print("before assign\n");
d=100.0;
print("after assign\n");
print("double %f\n", d);
// log("%lld %f\n", v, d);
return n;
}
/*
* $Bench builtin support
*/
void
Bench_reset(void *)
{
bus(1);
}
void
Bench_microsec(void *fp)
{
F_Bench_microsec *f;
f = fp;
*f->ret = bus(0);
}
void
Bench_disablegc(void *)
{
gclock();
}
void
Bench_enablegc(void *)
{
gcunlock();
}
#define fdchk(x) ((x) == (Bench_FD*)H ? -1 : (x)->fd)
void
Bench_read(void *fp)
{
int n;
F_Bench_read *f;
vlong usrelease, uskread, usacquire, ussched;
f = fp;
n = f->n;
if(f->buf == (Array*)H) {
*f->ret = 0;
return;
}
if(n > f->buf->len)
n = f->buf->len;
bus(1);
release();
usrelease = bus(0);
*f->ret = kread(fdchk(f->fd), f->buf->data, n);
uskread = bus(0);
acquire();
usacquire = bus(0);
sched();
ussched = bus(0);
log("%lld %lld %lld %lud %lld\n", usrelease, uskread, usacquire, m->ticks, ussched);
}
/*
* driver support
*/
long (*Test[])(int report, void *va, long n, ulong offset) = {
[None] notest,
[Calibrate] cal,
[Base] base,
[Op] timeop,
[Intr] intrtime,
[Dis] distime,
[Gc] gctime,
[MS2T] ms2ts,
[xTest] test,
};
enum {
Benchdirqid,
Benchdataqid,
Benchctlqid,
Benchusqid,
};
#define Data 0
static Dirtab benchtab[]={
".", {Benchdirqid,0,QTDIR}, 0, 0555,
"bdata", {Benchdataqid}, 0, 0444,
"bctl", {Benchctlqid}, 0, 0660,
"busec", {Benchusqid}, 0, 0660,
};
static void
benchreset(void)
{
builtinmod("$Bench", Benchmodtab);
}
static Chan*
benchattach(char *spec)
{
bench.inuse++;
if(bench.inuse == 1) {
bench.bufsz = 100*READSTR;
bench.buf = xalloc(bench.bufsz);
bench.wpos = bench.buf;
if(bench.buf == 0)
error(Enomem);
bench.test = None;
cal(0, 0, 0, 0);
}
return devattach('x', spec);
}
void
benchshutdown(void)
{
bench.inuse--;
if(bench.inuse == 0)
xfree(bench.buf);
}
static Walkqid*
benchwalk(Chan *c, Chan *nc, char **name, int nname)
{
return devwalk(c, nc, name, nname, benchtab, nelem(benchtab), devgen);
}
static Chan*
benchopen(Chan *c, int omode)
{
if(c->qid.path == Benchdirqid){
if(omode != OREAD)
error(Eperm);
}
c->mode = openmode(omode);
c->flag |= COPEN;
c->offset = 0;
return c;
}
static int
benchstat(Chan *c, uchar *dp, int n)
{
switch((ulong)c->qid.path){
case Benchdataqid:
benchtab[Data].length = bench.wpos - bench.buf;
}
return devstat(c, dp, n, benchtab, nelem(benchtab), devgen);
}
static void
benchclose(Chan*)
{
}
static long
benchread(Chan *c, void *buf, long n, vlong offset)
{
vlong us;
char tmp[64];
switch((ulong)c->qid.path){
case Benchdirqid:
return devdirread(c, buf, n, benchtab, nelem(benchtab), devgen);
case Benchdataqid:
return Test[bench.test](1, buf, n, offset);
case Benchusqid:
us = archrdtsc();
us /= US2TS;
snprint(tmp, sizeof(tmp), "%.lld", us);
return readstr(0, buf, n, tmp);
default:
n = 0;
break;
}
return n;
}
static long
benchwrite(Chan *c, void *buf, long n, vlong offset)
{
int argn = n;
switch((ulong)c->qid.path){
case Benchctlqid:
bench.test = None;
memset((char *)bench.buf, 0, bench.bufsz);
bench.wpos = bench.buf;
if(strncmp(buf, "test", 4) == 0)
bench.test = xTest;
else if(strncmp(buf, "calibrate", 9) == 0)
bench.test = Calibrate;
else if(strncmp(buf, "base", 4) == 0)
bench.test = Base;
else if(strncmp(buf, "intr", 4) == 0)
bench.test = Intr;
else if(strncmp(buf, "op ", 3) == 0) {
bench.test = Op;
buf = (char *)buf + 3;
argn -= 3;
} else if(strncmp(buf, "dis ", 4) == 0) {
bench.test = Dis;
buf = (char *)buf + 4;
argn -= 4;
} else if(strncmp(buf, "gc ", 3) == 0) {
bench.test = Gc;
buf = (char *)buf + 3;
argn -= 3;
} else if(strncmp(buf, "ms2ts", 5) == 0)
bench.test = MS2T;
else
error(Ebadctl);
Test[bench.test](0, buf, argn, offset);
break;
case Benchusqid:
bench.tickstart = archrdtsc();
break;
default:
error(Ebadusefd);
}
return n;
}
Dev benchdevtab = {
'x',
"bench",
benchreset,
devinit,
benchshutdown,
benchattach,
benchwalk,
benchstat,
benchopen,
devcreate,
benchclose,
benchread,
devbread,
benchwrite,
devbwrite,
devremove,
devwstat,
};