336 lines
5.5 KiB
C
336 lines
5.5 KiB
C
#include <u.h>
|
|
#include <libc.h>
|
|
#include <venti.h>
|
|
#include <libsec.h>
|
|
#include <thread.h>
|
|
|
|
|
|
enum { STACK = 32768 };
|
|
void xxxsrand(long);
|
|
long xxxlrand(void);
|
|
|
|
Channel *cw;
|
|
Channel *cr;
|
|
char *host;
|
|
int blocksize, seed, randpct;
|
|
int doread, dowrite, packets, permute;
|
|
vlong totalbytes, cur;
|
|
VtConn *z;
|
|
int multi;
|
|
int maxpackets;
|
|
int sequence;
|
|
int doublecheck = 1;
|
|
uint *order;
|
|
|
|
void
|
|
usage(void)
|
|
{
|
|
fprint(2, "usage: randtest [-q] [-h host] [-s seed] [-b blocksize] [-p randpct] [-n totalbytes] [-M maxblocks] [-P] [-r] [-w]\n");
|
|
threadexitsall("usage");
|
|
}
|
|
|
|
void
|
|
wr(char *buf, char *buf2)
|
|
{
|
|
uchar score[VtScoreSize], score2[VtScoreSize];
|
|
DigestState ds;
|
|
|
|
USED(buf2);
|
|
memset(&ds, 0, sizeof ds);
|
|
if(doublecheck)
|
|
sha1((uchar*)buf, blocksize, score, &ds);
|
|
if(vtwrite(z, score2, VtDataType, (uchar*)buf, blocksize) < 0)
|
|
sysfatal("vtwrite %V at %,lld: %r", score, cur);
|
|
if(doublecheck && memcmp(score, score2, VtScoreSize) != 0)
|
|
sysfatal("score mismatch! %V %V", score, score2);
|
|
}
|
|
|
|
void
|
|
wrthread(void *v)
|
|
{
|
|
char *p;
|
|
|
|
USED(v);
|
|
while((p = recvp(cw)) != nil){
|
|
wr(p, nil);
|
|
free(p);
|
|
}
|
|
}
|
|
|
|
void
|
|
rd(char *buf, char *buf2)
|
|
{
|
|
uchar score[VtScoreSize];
|
|
DigestState ds;
|
|
|
|
memset(&ds, 0, sizeof ds);
|
|
sha1((uchar*)buf, blocksize, score, &ds);
|
|
if(vtread(z, score, VtDataType, (uchar*)buf2, blocksize) < 0)
|
|
sysfatal("vtread %V at %,lld: %r", score, cur);
|
|
if(memcmp(buf, buf2, blocksize) != 0)
|
|
sysfatal("bad data read! %V", score);
|
|
}
|
|
|
|
void
|
|
rdthread(void *v)
|
|
{
|
|
char *p, *buf2;
|
|
|
|
buf2 = vtmalloc(blocksize);
|
|
USED(v);
|
|
while((p = recvp(cr)) != nil){
|
|
rd(p, buf2);
|
|
free(p);
|
|
}
|
|
}
|
|
|
|
char *template;
|
|
|
|
void
|
|
run(void (*fn)(char*, char*), Channel *c)
|
|
{
|
|
int i, t, j, packets;
|
|
char *buf2, *buf;
|
|
|
|
buf2 = vtmalloc(blocksize);
|
|
buf = vtmalloc(blocksize);
|
|
cur = 0;
|
|
packets = totalbytes/blocksize;
|
|
if(maxpackets == 0)
|
|
maxpackets = packets;
|
|
order = vtmalloc(packets*sizeof order[0]);
|
|
for(i=0; i<packets; i++)
|
|
order[i] = i;
|
|
if(permute){
|
|
for(i=1; i<packets; i++){
|
|
j = nrand(i+1);
|
|
t = order[i];
|
|
order[i] = order[j];
|
|
order[j] = t;
|
|
}
|
|
}
|
|
for(i=0; i<packets && i<maxpackets; i++){
|
|
memmove(buf, template, blocksize);
|
|
*(uint*)buf = order[i];
|
|
if(c){
|
|
sendp(c, buf);
|
|
buf = vtmalloc(blocksize);
|
|
}else
|
|
(*fn)(buf, buf2);
|
|
cur += blocksize;
|
|
}
|
|
free(order);
|
|
}
|
|
|
|
#define TWID64 ((u64int)~(u64int)0)
|
|
|
|
u64int
|
|
unittoull(char *s)
|
|
{
|
|
char *es;
|
|
u64int n;
|
|
|
|
if(s == nil)
|
|
return TWID64;
|
|
n = strtoul(s, &es, 0);
|
|
if(*es == 'k' || *es == 'K'){
|
|
n *= 1024;
|
|
es++;
|
|
}else if(*es == 'm' || *es == 'M'){
|
|
n *= 1024*1024;
|
|
es++;
|
|
}else if(*es == 'g' || *es == 'G'){
|
|
n *= 1024*1024*1024;
|
|
es++;
|
|
}else if(*es == 't' || *es == 'T'){
|
|
n *= 1024*1024;
|
|
n *= 1024*1024;
|
|
}
|
|
if(*es != '\0')
|
|
return TWID64;
|
|
return n;
|
|
}
|
|
|
|
void
|
|
threadmain(int argc, char *argv[])
|
|
{
|
|
int i, max;
|
|
vlong t0;
|
|
double t;
|
|
|
|
blocksize = 8192;
|
|
seed = 0;
|
|
randpct = 50;
|
|
host = nil;
|
|
doread = 0;
|
|
dowrite = 0;
|
|
totalbytes = 1*1024*1024*1024;
|
|
fmtinstall('V', vtscorefmt);
|
|
fmtinstall('F', vtfcallfmt);
|
|
|
|
ARGBEGIN{
|
|
case 'b':
|
|
blocksize = unittoull(EARGF(usage()));
|
|
break;
|
|
case 'h':
|
|
host = EARGF(usage());
|
|
break;
|
|
case 'M':
|
|
maxpackets = unittoull(EARGF(usage()));
|
|
break;
|
|
case 'm':
|
|
multi = atoi(EARGF(usage()));
|
|
break;
|
|
case 'n':
|
|
totalbytes = unittoull(EARGF(usage()));
|
|
break;
|
|
case 'p':
|
|
randpct = atoi(EARGF(usage()));
|
|
break;
|
|
case 'P':
|
|
permute = 1;
|
|
break;
|
|
case 'S':
|
|
doublecheck = 0;
|
|
ventidoublechecksha1 = 0;
|
|
break;
|
|
case 's':
|
|
seed = atoi(EARGF(usage()));
|
|
break;
|
|
case 'r':
|
|
doread = 1;
|
|
break;
|
|
case 'w':
|
|
dowrite = 1;
|
|
break;
|
|
case 'V':
|
|
chattyventi++;
|
|
break;
|
|
default:
|
|
usage();
|
|
}ARGEND
|
|
|
|
if(doread==0 && dowrite==0){
|
|
doread = 1;
|
|
dowrite = 1;
|
|
}
|
|
|
|
z = vtdial(host);
|
|
if(z == nil)
|
|
sysfatal("could not connect to server: %r");
|
|
if(vtconnect(z) < 0)
|
|
sysfatal("vtconnect: %r");
|
|
|
|
if(multi){
|
|
cr = chancreate(sizeof(void*), 0);
|
|
cw = chancreate(sizeof(void*), 0);
|
|
for(i=0; i<multi; i++){
|
|
proccreate(wrthread, nil, STACK);
|
|
proccreate(rdthread, nil, STACK);
|
|
}
|
|
}
|
|
|
|
template = vtmalloc(blocksize);
|
|
xxxsrand(seed);
|
|
max = (256*randpct)/100;
|
|
if(max == 0)
|
|
max = 1;
|
|
for(i=0; i<blocksize; i++)
|
|
template[i] = xxxlrand()%max;
|
|
if(dowrite){
|
|
t0 = nsec();
|
|
run(wr, cw);
|
|
for(i=0; i<multi; i++)
|
|
sendp(cw, nil);
|
|
t = (nsec() - t0)/1.e9;
|
|
print("write: %lld bytes / %.3f seconds = %.6f MB/s\n",
|
|
totalbytes, t, (double)totalbytes/1e6/t);
|
|
}
|
|
if(doread){
|
|
t0 = nsec();
|
|
run(rd, cr);
|
|
for(i=0; i<multi; i++)
|
|
sendp(cr, nil);
|
|
t = (nsec() - t0)/1.e9;
|
|
print("read: %lld bytes / %.3f seconds = %.6f MB/s\n",
|
|
totalbytes, t, (double)totalbytes/1e6/t);
|
|
}
|
|
threadexitsall(nil);
|
|
}
|
|
|
|
|
|
/*
|
|
* algorithm by
|
|
* D. P. Mitchell & J. A. Reeds
|
|
*/
|
|
|
|
#define LEN 607
|
|
#define TAP 273
|
|
#define MASK 0x7fffffffL
|
|
#define A 48271
|
|
#define M 2147483647
|
|
#define Q 44488
|
|
#define R 3399
|
|
#define NORM (1.0/(1.0+MASK))
|
|
|
|
static ulong rng_vec[LEN];
|
|
static ulong* rng_tap = rng_vec;
|
|
static ulong* rng_feed = 0;
|
|
|
|
static void
|
|
isrand(long seed)
|
|
{
|
|
long lo, hi, x;
|
|
int i;
|
|
|
|
rng_tap = rng_vec;
|
|
rng_feed = rng_vec+LEN-TAP;
|
|
seed = seed%M;
|
|
if(seed < 0)
|
|
seed += M;
|
|
if(seed == 0)
|
|
seed = 89482311;
|
|
x = seed;
|
|
/*
|
|
* Initialize by x[n+1] = 48271 * x[n] mod (2**31 - 1)
|
|
*/
|
|
for(i = -20; i < LEN; i++) {
|
|
hi = x / Q;
|
|
lo = x % Q;
|
|
x = A*lo - R*hi;
|
|
if(x < 0)
|
|
x += M;
|
|
if(i >= 0)
|
|
rng_vec[i] = x;
|
|
}
|
|
}
|
|
|
|
void
|
|
xxxsrand(long seed)
|
|
{
|
|
isrand(seed);
|
|
}
|
|
|
|
long
|
|
xxxlrand(void)
|
|
{
|
|
ulong x;
|
|
|
|
rng_tap--;
|
|
if(rng_tap < rng_vec) {
|
|
if(rng_feed == 0) {
|
|
isrand(1);
|
|
rng_tap--;
|
|
}
|
|
rng_tap += LEN;
|
|
}
|
|
rng_feed--;
|
|
if(rng_feed < rng_vec)
|
|
rng_feed += LEN;
|
|
x = (*rng_feed + *rng_tap) & MASK;
|
|
*rng_feed = x;
|
|
|
|
return x;
|
|
}
|
|
|