Subversion Repositories planix.SVN

#include "stdinc.h"
#include "dat.h"
#include "fns.h"

int collectstats = 1;

/* keep in sync with dat.h:/NStat */
Statdesc statdesc[NStat] =
{
        { "rpc total", },
        { "rpc reads", },
        { "rpc reads ok", },
        { "rpc reads failed", },
        { "rpc read bytes", },
        { "rpc read time", },
        { "rpc read cached", },
        { "rpc read cached time", },
        { "rpc read uncached", },
        { "rpc read uncached time "},
        
        { "rpc writes", },
        { "rpc writes new", },
        { "rpc writes old", },
        { "rpc writes failed", },
        { "rpc write bytes", },
        { "rpc write time", },
        { "rpc write new time", },
        { "rpc write old time", },

        { "lump cache hits", },
        { "lump cache misses", },
        { "lump cache reads", },
        { "lump cache writes", },
        { "lump cache size", },
        { "lump cache stall", },
        { "lump cache read time", },

        { "disk cache hits", },
        { "disk cache misses", },
        { "disk cache lookups", },
        { "disk cache reads", },
        { "disk cache writes", },
        { "disk cache dirty", },
        { "disk cache size", },
        { "disk cache flushes", },
        { "disk cache stalls", },
        { "disk cache lookup time", },

        { "disk block stalls", },
        { "lump stalls", },

        { "index cache hits", },
        { "index cache misses", },
        { "index cache reads", },
        { "index cache writes", },
        { "index cache fills", },
        { "index cache prefetches", },
        { "index cache dirty", },
        { "index cache size", },
        { "index cache flushes", },
        { "index cache stalls", },
        { "index cache read time", },
        { "index cache lookups" },
        { "index cache summary hits" },
        { "index cache summary prefetches" },

        { "bloom filter hits", },
        { "bloom filter misses", },
        { "bloom filter false misses", },
        { "bloom filter lookups", },
        { "bloom filter ones", },
        { "bloom filter bits", },

        { "arena block reads", },
        { "arena block read bytes", },
        { "arena block writes", },
        { "arena block write bytes", },

        { "isect block reads", },
        { "isect block read bytes", },
        { "isect block writes", },
        { "isect block write bytes", },

        { "sum reads", },
        { "sum read bytes", },
        
        { "cig loads" },
        { "cig load time" },
};

QLock statslock;
Stats stats;
Stats *stathist;
int nstathist;
ulong statind;
ulong stattime;

void
statsproc(void *v)
{
        USED(v);

        for(;;){
                stats.now = time(0);
                stathist[stattime%nstathist] = stats;
                stattime++;
                sleep(1000);
        }
}

void
statsinit(void)
{
        nstathist = 90000;
        stathist = MKNZ(Stats, nstathist);
        vtproc(statsproc, nil);
}

void
setstat(int index, long val)
{
        qlock(&statslock);
        stats.n[index] = val;
        qunlock(&statslock);
}

void
addstat(int index, int inc)
{
        if(!collectstats)
                return;
        qlock(&statslock);
        stats.n[index] += inc;
        qunlock(&statslock);
}

void
addstat2(int index, int inc, int index1, int inc1)
{
        if(!collectstats)
                return;
        qlock(&statslock);
        stats.n[index] += inc;
        stats.n[index1] += inc1;
        qunlock(&statslock);
}

void
printstats(void)
{
}

void
binstats(long (*fn)(Stats *s0, Stats *s1, void *arg), void *arg,
        long t0, long t1, Statbin *bin, int nbin)
{
        long xt0, t, te, v;
        int i, j, lo, hi, m;
        vlong tot;
        Statbin *b;
        
        t = stats.now;
        
        /* negative times mean relative to now. */
        if(t0 <= 0)
                t0 += t;
        if(t1 <= 0)
                t1 += t;
        /* ten minute range if none given */
        if(t1 <= t0)
                t0 = t1 - 60*10;
        if(0) fprint(2, "stats %ld-%ld\n", t0, t1);
        
        /* binary search to find t0-1 or close */
        lo = stattime;
        hi = stattime+nstathist;
        while(lo+1 < hi){
                m = (lo+hi)/2;
                if(stathist[m%nstathist].now >= t0)
                        hi = m;
                else
                        lo = m;
        }
        xt0 = stathist[lo%nstathist].now;
        if(xt0 >= t1){
                /* no samples */
                memset(bin, 0, nbin*sizeof bin[0]);
                return;
        }

        hi = stattime+nstathist;
        j = lo+1;
        for(i=0; i<nbin; i++){
                te = t0 + (t1-t0)*i/nbin;
                b = &bin[i];
                memset(b, 0, sizeof *b);
                tot = 0;
                for(; j<hi && stathist[j%nstathist].now<te; j++){
                        v = fn(&stathist[(j-1)%nstathist], &stathist[j%nstathist], arg);
                        if(b->nsamp==0 || v < b->min)
                                b->min = v;
                        if(b->nsamp==0 || v > b->max)
                                b->max = v;
                        tot += v;
                        b->nsamp++;
                }
                if(b->nsamp)
                        b->avg = tot / b->nsamp;
                if(b->nsamp==0 && i>0)
                        *b = bin[i-1];
        }       
}