2 #include <ccan/tally/tally.h>
3 #include <ccan/build_assert/build_assert.h>
4 #include <ccan/likely/likely.h>
11 #define SIZET_BITS (sizeof(size_t)*CHAR_BIT)
13 /* We use power of 2 steps. I tried being tricky, but it got buggy. */
17 /* This allows limited frequency analysis. */
18 unsigned buckets, step_bits;
19 size_t counts[1 /* [buckets] */ ];
22 struct tally *tally_new(unsigned buckets)
26 /* Check for overflow. */
27 if (buckets && SIZE_MAX / buckets < sizeof(tally->counts[0]))
29 tally = malloc(sizeof(*tally) + sizeof(tally->counts[0])*buckets);
31 tally->max = ((size_t)1 << (SIZET_BITS - 1));
32 tally->min = ~tally->max;
33 tally->total[0] = tally->total[1] = 0;
34 /* There is always 1 bucket. */
35 tally->buckets = buckets+1;
37 memset(tally->counts, 0, sizeof(tally->counts[0])*(buckets+1));
42 static unsigned bucket_of(ssize_t min, unsigned step_bits, ssize_t val)
44 /* Don't over-shift. */
45 if (step_bits == SIZET_BITS)
47 assert(step_bits < SIZET_BITS);
48 return (size_t)(val - min) >> step_bits;
51 /* Return the min value in bucket b. */
52 static ssize_t bucket_min(ssize_t min, unsigned step_bits, unsigned b)
54 /* Don't over-shift. */
55 if (step_bits == SIZET_BITS)
57 assert(step_bits < SIZET_BITS);
58 return min + ((ssize_t)b << step_bits);
61 /* Does shifting by this many bits truncate the number? */
62 static bool shift_overflows(size_t num, unsigned bits)
67 return ((num << bits) >> 1) != (num << (bits - 1));
70 /* When min or max change, we may need to shuffle the frequency counts. */
71 static void renormalize(struct tally *tally,
72 ssize_t new_min, ssize_t new_max)
75 unsigned int i, old_min;
77 /* Uninitialized? Don't do anything... */
78 if (tally->max < tally->min)
81 /* If we don't have sufficient range, increase step bits until
82 * buckets cover entire range of ssize_t anyway. */
83 range = (new_max - new_min) + 1;
84 while (!shift_overflows(tally->buckets, tally->step_bits)
85 && range > ((size_t)tally->buckets << tally->step_bits)) {
87 for (i = 1; i < tally->buckets; i++) {
88 tally->counts[i/2] += tally->counts[i];
94 /* Now if minimum has dropped, move buckets up. */
95 old_min = bucket_of(new_min, tally->step_bits, tally->min);
96 memmove(tally->counts + old_min,
98 sizeof(tally->counts[0]) * (tally->buckets - old_min));
99 memset(tally->counts, 0, sizeof(tally->counts[0]) * old_min);
101 /* If we moved boundaries, adjust buckets to that ratio. */
102 spill = (tally->min - new_min) % (1 << tally->step_bits);
103 for (i = 0; i < tally->buckets-1; i++) {
104 size_t adjust = (tally->counts[i] >> tally->step_bits) * spill;
105 tally->counts[i] -= adjust;
106 tally->counts[i+1] += adjust;
110 tally->min = new_min;
111 tally->max = new_max;
114 void tally_add(struct tally *tally, ssize_t val)
116 ssize_t new_min = tally->min, new_max = tally->max;
117 bool need_renormalize = false;
119 if (val < tally->min) {
121 need_renormalize = true;
123 if (val > tally->max) {
125 need_renormalize = true;
127 if (need_renormalize)
128 renormalize(tally, new_min, new_max);
130 /* 128-bit arithmetic! If we didn't want exact mean, we could just
131 * pull it out of counts. */
132 if (val > 0 && tally->total[0] + val < tally->total[0])
134 else if (val < 0 && tally->total[0] + val > tally->total[0])
136 tally->total[0] += val;
137 tally->counts[bucket_of(tally->min, tally->step_bits, val)]++;
140 size_t tally_num(const struct tally *tally)
143 for (i = 0; i < tally->buckets; i++)
144 num += tally->counts[i];
148 ssize_t tally_min(const struct tally *tally)
153 ssize_t tally_max(const struct tally *tally)
158 /* FIXME: Own ccan module please! */
159 static unsigned fls64(uint64_t val)
161 #if HAVE_BUILTIN_CLZL
162 if (val <= ULONG_MAX) {
163 /* This is significantly faster! */
164 return val ? sizeof(long) * CHAR_BIT - __builtin_clzl(val) : 0;
171 if (!(val & 0xffffffff00000000ull)) {
175 if (!(val & 0xffff000000000000ull)) {
179 if (!(val & 0xff00000000000000ull)) {
183 if (!(val & 0xf000000000000000ull)) {
187 if (!(val & 0xc000000000000000ull)) {
191 if (!(val & 0x8000000000000000ull)) {
196 #if HAVE_BUILTIN_CLZL
201 /* This is stolen straight from Hacker's Delight. */
202 static uint64_t divlu64(uint64_t u1, uint64_t u0, uint64_t v)
204 const uint64_t b = 4294967296ULL; // Number base (32 bits).
205 uint32_t un[4], // Dividend and divisor
206 vn[2]; // normalized and broken
207 // up into halfwords.
208 uint32_t q[2]; // Quotient as halfwords.
209 uint64_t un1, un0, // Dividend and divisor
210 vn0; // as fullwords.
211 uint64_t qhat; // Estimated quotient digit.
212 uint64_t rhat; // A remainder.
213 uint64_t p; // Product of two digits.
214 int64_t s, i, j, t, k;
216 if (u1 >= v) // If overflow, return the largest
217 return (uint64_t)-1; // possible quotient.
219 s = 64 - fls64(v); // 0 <= s <= 63.
220 vn0 = v << s; // Normalize divisor.
221 vn[1] = vn0 >> 32; // Break divisor up into
222 vn[0] = vn0 & 0xFFFFFFFF; // two 32-bit halves.
224 // Shift dividend left.
225 un1 = ((u1 << s) | (u0 >> (64 - s))) & (-s >> 63);
227 un[3] = un1 >> 32; // Break dividend up into
228 un[2] = un1; // four 32-bit halfwords
229 un[1] = un0 >> 32; // Note: storing into
230 un[0] = un0; // halfwords truncates.
232 for (j = 1; j >= 0; j--) {
233 // Compute estimate qhat of q[j].
234 qhat = (un[j+2]*b + un[j+1])/vn[1];
235 rhat = (un[j+2]*b + un[j+1]) - qhat*vn[1];
237 if (qhat >= b || qhat*vn[0] > b*rhat + un[j]) {
240 if (rhat < b) goto again;
243 // Multiply and subtract.
245 for (i = 0; i < 2; i++) {
247 t = un[i+j] - k - (p & 0xFFFFFFFF);
249 k = (p >> 32) - (t >> 32);
254 q[j] = qhat; // Store quotient digit.
255 if (t < 0) { // If we subtracted too
256 q[j] = q[j] - 1; // much, add back.
258 for (i = 0; i < 2; i++) {
259 t = un[i+j] + vn[i] + k;
263 un[j+2] = un[j+2] + k;
267 return q[1]*b + q[0];
270 static int64_t divls64(int64_t u1, uint64_t u0, int64_t v)
272 int64_t q, uneg, vneg, diff, borrow;
274 uneg = u1 >> 63; // -1 if u < 0.
275 if (uneg) { // Compute the absolute
276 u0 = -u0; // value of the dividend u.
281 vneg = v >> 63; // -1 if v < 0.
282 v = (v ^ vneg) - vneg; // Absolute value of v.
284 if ((uint64_t)u1 >= (uint64_t)v)
287 q = divlu64(u1, u0, v);
289 diff = uneg ^ vneg; // Negate q if signs of
290 q = (q ^ diff) - diff; // u and v differed.
292 if ((diff ^ q) < 0 && q != 0) { // If overflow, return the largest
293 overflow: // possible neg. quotient.
294 q = 0x8000000000000000ULL;
299 ssize_t tally_mean(const struct tally *tally)
301 size_t count = tally_num(tally);
305 if (sizeof(tally->total[0]) == sizeof(uint32_t)) {
306 /* Use standard 64-bit arithmetic. */
307 int64_t total = tally->total[0]
308 | (((uint64_t)tally->total[1]) << 32);
309 return total / count;
311 return divls64(tally->total[1], tally->total[0], count);
314 ssize_t tally_total(const struct tally *tally, ssize_t *overflow)
317 *overflow = tally->total[1];
318 return tally->total[0];
321 /* If result is negative, make sure we can represent it. */
322 if (tally->total[1] & (1 << (SIZET_BITS-1))) {
323 /* Must have only underflowed once, and must be able to
324 * represent result at ssize_t. */
325 if ((~tally->total[1])+1 != 0
326 || (ssize_t)tally->total[0] >= 0) {
327 /* Underflow, return minimum. */
328 return (ssize_t)((size_t)1 << (SIZET_BITS - 1));
331 /* Result is positive, must not have overflowed, and must be
332 * able to represent as ssize_t. */
333 if (tally->total[1] || (ssize_t)tally->total[0] < 0) {
334 /* Overflow. Return maximum. */
335 return (ssize_t)~((size_t)1 << (SIZET_BITS - 1));
338 return tally->total[0];
341 static ssize_t bucket_range(const struct tally *tally, unsigned b, size_t *err)
345 min = bucket_min(tally->min, tally->step_bits, b);
346 if (b == tally->buckets - 1)
349 max = bucket_min(tally->min, tally->step_bits, b+1) - 1;
351 /* FIXME: Think harder about cumulative error; is this enough?. */
352 *err = (max - min + 1) / 2;
353 /* Avoid overflow. */
354 return min + (max - min) / 2;
357 ssize_t tally_approx_median(const struct tally *tally, size_t *err)
359 size_t count = tally_num(tally), total = 0;
362 for (i = 0; i < tally->buckets; i++) {
363 total += tally->counts[i];
364 if (total * 2 >= count)
367 return bucket_range(tally, i, err);
370 ssize_t tally_approx_mode(const struct tally *tally, size_t *err)
372 unsigned int i, min_best = 0, max_best = 0;
374 for (i = 0; i < tally->buckets; i++) {
375 if (tally->counts[i] > tally->counts[min_best]) {
376 min_best = max_best = i;
377 } else if (tally->counts[i] == tally->counts[min_best]) {
382 /* We can have more than one best, making our error huge. */
383 if (min_best != max_best) {
385 min = bucket_range(tally, min_best, err);
386 max = bucket_range(tally, max_best, err);
388 *err += (size_t)(max - min);
389 return min + (max - min) / 2;
392 return bucket_range(tally, min_best, err);
395 static unsigned get_max_bucket(const struct tally *tally)
399 for (i = tally->buckets; i > 0; i--)
400 if (tally->counts[i-1])
405 char *tally_histogram(const struct tally *tally,
406 unsigned width, unsigned height)
408 unsigned int i, count, max_bucket, largest_bucket;
412 assert(width >= TALLY_MIN_HISTO_WIDTH);
413 assert(height >= TALLY_MIN_HISTO_HEIGHT);
415 /* Ignore unused buckets. */
416 max_bucket = get_max_bucket(tally);
418 /* FIXME: It'd be nice to smooth here... */
419 if (height >= max_bucket) {
423 /* We create a temporary then renormalize so < height. */
424 /* FIXME: Antialias properly! */
425 tmp = tally_new(tally->buckets-1);
428 tmp->min = tally->min;
429 tmp->max = tally->max;
430 tmp->step_bits = tally->step_bits;
431 memcpy(tmp->counts, tally->counts,
432 sizeof(tally->counts[0]) * tmp->buckets);
433 while ((max_bucket = get_max_bucket(tmp)) >= height)
434 renormalize(tmp, tmp->min, tmp->max * 2);
436 tmp->max = tally->max;
441 /* Figure out longest line, for scale. */
443 for (i = 0; i < tally->buckets; i++) {
444 if (tally->counts[i] > largest_bucket)
445 largest_bucket = tally->counts[i];
448 p = graph = malloc(height * (width + 1) + 1);
454 for (i = 0; i < height; i++) {
455 unsigned covered = 1;
456 count = (double)tally->counts[i] / largest_bucket * (width-1)+1;
459 covered = snprintf(p, width, "%zi", tally->min);
460 else if (i == height - 1)
461 covered = snprintf(p, width, "%zi", tally->max);
462 else if (i == bucket_of(tally->min, tally->step_bits, 0))
476 memset(p, '*', count);