Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 1 
#include "stdinc.h"
2 
#include "dat.h"
3 
#include "fns.h"
4 
 
5 
int collectstats = 1;
6 
 
7 
/* keep in sync with dat.h:/NStat */
8 
Statdesc statdesc[NStat] =
9 
{
10 
	{ "rpc total", },
11 
	{ "rpc reads", },
12 
	{ "rpc reads ok", },
13 
	{ "rpc reads failed", },
14 
	{ "rpc read bytes", },
15 
	{ "rpc read time", },
16 
	{ "rpc read cached", },
17 
	{ "rpc read cached time", },
18 
	{ "rpc read uncached", },
19 
	{ "rpc read uncached time "},
20 
 
21 
	{ "rpc writes", },
22 
	{ "rpc writes new", },
23 
	{ "rpc writes old", },
24 
	{ "rpc writes failed", },
25 
	{ "rpc write bytes", },
26 
	{ "rpc write time", },
27 
	{ "rpc write new time", },
28 
	{ "rpc write old time", },
29 
 
30 
	{ "lump cache hits", },
31 
	{ "lump cache misses", },
32 
	{ "lump cache reads", },
33 
	{ "lump cache writes", },
34 
	{ "lump cache size", },
35 
	{ "lump cache stall", },
36 
	{ "lump cache read time", },
37 
 
38 
	{ "disk cache hits", },
39 
	{ "disk cache misses", },
40 
	{ "disk cache lookups", },
41 
	{ "disk cache reads", },
42 
	{ "disk cache writes", },
43 
	{ "disk cache dirty", },
44 
	{ "disk cache size", },
45 
	{ "disk cache flushes", },
46 
	{ "disk cache stalls", },
47 
	{ "disk cache lookup time", },
48 
 
49 
	{ "disk block stalls", },
50 
	{ "lump stalls", },
51 
 
52 
	{ "index cache hits", },
53 
	{ "index cache misses", },
54 
	{ "index cache reads", },
55 
	{ "index cache writes", },
56 
	{ "index cache fills", },
57 
	{ "index cache prefetches", },
58 
	{ "index cache dirty", },
59 
	{ "index cache size", },
60 
	{ "index cache flushes", },
61 
	{ "index cache stalls", },
62 
	{ "index cache read time", },
63 
	{ "index cache lookups" },
64 
	{ "index cache summary hits" },
65 
	{ "index cache summary prefetches" },
66 
 
67 
	{ "bloom filter hits", },
68 
	{ "bloom filter misses", },
69 
	{ "bloom filter false misses", },
70 
	{ "bloom filter lookups", },
71 
	{ "bloom filter ones", },
72 
	{ "bloom filter bits", },
73 
 
74 
	{ "arena block reads", },
75 
	{ "arena block read bytes", },
76 
	{ "arena block writes", },
77 
	{ "arena block write bytes", },
78 
 
79 
	{ "isect block reads", },
80 
	{ "isect block read bytes", },
81 
	{ "isect block writes", },
82 
	{ "isect block write bytes", },
83 
 
84 
	{ "sum reads", },
85 
	{ "sum read bytes", },
86 
 
87 
	{ "cig loads" },
88 
	{ "cig load time" },
89 
};
90 
 
91 
QLock statslock;
92 
Stats stats;
93 
Stats *stathist;
94 
int nstathist;
95 
ulong statind;
96 
ulong stattime;
97 
 
98 
void
99 
statsproc(void *v)
100 
{
101 
	USED(v);
102 
 
103 
	for(;;){
104 
		stats.now = time(0);
105 
		stathist[stattime%nstathist] = stats;
106 
		stattime++;
107 
		sleep(1000);
108 
	}
109 
}
110 
 
111 
void
112 
statsinit(void)
113 
{
114 
	nstathist = 90000;
115 
	stathist = MKNZ(Stats, nstathist);
116 
	vtproc(statsproc, nil);
117 
}
118 
 
119 
void
120 
setstat(int index, long val)
121 
{
122 
	qlock(&statslock);
123 
	stats.n[index] = val;
124 
	qunlock(&statslock);
125 
}
126 
 
127 
void
128 
addstat(int index, int inc)
129 
{
130 
	if(!collectstats)
131 
		return;
132 
	qlock(&statslock);
133 
	stats.n[index] += inc;
134 
	qunlock(&statslock);
135 
}
136 
 
137 
void
138 
addstat2(int index, int inc, int index1, int inc1)
139 
{
140 
	if(!collectstats)
141 
		return;
142 
	qlock(&statslock);
143 
	stats.n[index] += inc;
144 
	stats.n[index1] += inc1;
145 
	qunlock(&statslock);
146 
}
147 
 
148 
void
149 
printstats(void)
150 
{
151 
}
152 
 
153 
void
154 
binstats(long (*fn)(Stats *s0, Stats *s1, void *arg), void *arg,
155 
	long t0, long t1, Statbin *bin, int nbin)
156 
{
157 
	long xt0, t, te, v;
158 
	int i, j, lo, hi, m;
159 
	vlong tot;
160 
	Statbin *b;
161 
 
162 
	t = stats.now;
163 
 
164 
	/* negative times mean relative to now. */
165 
	if(t0 <= 0)
166 
		t0 += t;
167 
	if(t1 <= 0)
168 
		t1 += t;
169 
	/* ten minute range if none given */
170 
	if(t1 <= t0)
171 
		t0 = t1 - 60*10;
172 
	if(0) fprint(2, "stats %ld-%ld\n", t0, t1);
173 
 
174 
	/* binary search to find t0-1 or close */
175 
	lo = stattime;
176 
	hi = stattime+nstathist;
177 
	while(lo+1 < hi){
178 
		m = (lo+hi)/2;
179 
		if(stathist[m%nstathist].now >= t0)
180 
			hi = m;
181 
		else
182 
			lo = m;
183 
	}
184 
	xt0 = stathist[lo%nstathist].now;
185 
	if(xt0 >= t1){
186 
		/* no samples */
187 
		memset(bin, 0, nbin*sizeof bin[0]);
188 
		return;
189 
	}
190 
 
191 
	hi = stattime+nstathist;
192 
	j = lo+1;
193 
	for(i=0; i<nbin; i++){
194 
		te = t0 + (t1-t0)*i/nbin;
195 
		b = &bin[i];
196 
		memset(b, 0, sizeof *b);
197 
		tot = 0;
198 
		for(; j<hi && stathist[j%nstathist].now<te; j++){
199 
			v = fn(&stathist[(j-1)%nstathist], &stathist[j%nstathist], arg);
200 
			if(b->nsamp==0 || v < b->min)
201 
				b->min = v;
202 
			if(b->nsamp==0 || v > b->max)
203 
				b->max = v;
204 
			tot += v;
205 
			b->nsamp++;
206 
		}
207 
		if(b->nsamp)
208 
			b->avg = tot / b->nsamp;
209 
		if(b->nsamp==0 && i>0)
210 
			*b = bin[i-1];
211 
	}
212 
}