X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftdb2%2Fsummary.c;h=56d365883030dce6e85961022c7ac3d7f7e694aa;hp=e9f986e7727a4775928617256ed65e11e0dbaa5c;hb=a42bba8ec446284256a7c9146ba3525404de474c;hpb=8c7516decc0a0921b4fd45eef401e07eb58e0b01 diff --git a/ccan/tdb2/summary.c b/ccan/tdb2/summary.c index e9f986e7..56d36588 100644 --- a/ccan/tdb2/summary.c +++ b/ccan/tdb2/summary.c @@ -19,25 +19,6 @@ #include #include -static void sizes_for_bucket(unsigned bucket, size_t *min, size_t *max) -{ - if (bucket <= 8) { - *min = *max = TDB_MIN_DATA_LEN + bucket * 8; - } else if (bucket == 9) { - /* FIXME: This is twisted; fix size_to_bucket. */ - *min = TDB_MIN_DATA_LEN + (1ULL << (bucket - 3)) + 8; - *max = TDB_MIN_DATA_LEN + (1ULL << (bucket - 2)) - 8; - } else { - *min = TDB_MIN_DATA_LEN + (1ULL << (bucket - 3)); - *max = TDB_MIN_DATA_LEN + (1ULL << (bucket - 2)) - 8; - } - assert(size_to_bucket(63, *min) == bucket); - assert(size_to_bucket(63, *max) == bucket); - if (bucket > 8) - assert(size_to_bucket(63, *min - 8) == bucket - 1); - assert(size_to_bucket(63, *max + 8) == bucket + 1); -} - static int count_hash(struct tdb_context *tdb, tdb_off_t hash_off, unsigned bits) { @@ -54,48 +35,45 @@ static int count_hash(struct tdb_context *tdb, return count; } -static tdb_len_t summarize_zone(struct tdb_context *tdb, tdb_off_t zone_off, - struct tally *zones, - struct tally *hashes, - struct tally *free, - struct tally *keys, - struct tally *data, - struct tally *extra, - struct tally *uncoal, - uint64_t bucketlen[], - unsigned int *num_buckets) +static bool summarize(struct tdb_context *tdb, + struct tally *hashes, + struct tally *ftables, + struct tally *free, + struct tally *keys, + struct tally *data, + struct tally *extra, + struct tally *uncoal, + struct tally *buckets, + struct tally *chains) { - struct free_zone_header zhdr; tdb_off_t off; tdb_len_t len; - unsigned int hdrlen; tdb_len_t unc = 0; - if (tdb_read_convert(tdb, zone_off, &zhdr, sizeof(zhdr)) == -1) - return TDB_OFF_ERR; - - tally_add(zones, 1ULL << zhdr.zone_bits); - *num_buckets = BUCKETS_FOR_ZONE(zhdr.zone_bits); - - hdrlen = sizeof(zhdr) - + (BUCKETS_FOR_ZONE(zhdr.zone_bits) + 1) * sizeof(tdb_off_t); - for (off = zone_off + hdrlen; - off < zone_off + (1ULL << zhdr.zone_bits); - off += len) { - union { + for (off = sizeof(struct tdb_header); off < tdb->map_size; off += len) { + const union { struct tdb_used_record u; struct tdb_free_record f; - } pad, *p; - p = tdb_get(tdb, off, &pad, sizeof(pad)); + struct tdb_recovery_record r; + } *p; + /* We might not be able to get the whole thing. */ + p = tdb_access_read(tdb, off, sizeof(p->f), true); if (!p) - return TDB_OFF_ERR; - if (frec_magic(&p->f) == TDB_FREE_MAGIC) { - len = p->f.data_len; + return false; + if (p->r.magic == TDB_RECOVERY_INVALID_MAGIC + || p->r.magic == TDB_RECOVERY_MAGIC) { + if (unc) { + tally_add(uncoal, unc); + unc = 0; + } + len = sizeof(p->r) + p->r.max_len; + } else if (frec_magic(&p->f) == TDB_FREE_MAGIC) { + len = frec_len(&p->f); tally_add(free, len); - bucketlen[size_to_bucket(frec_zone_bits(&p->f), len)]++; + tally_add(buckets, size_to_bucket(len)); len += sizeof(p->u); unc++; - } else { + } else if (rec_magic(&p->u) == TDB_USED_MAGIC) { if (unc) { tally_add(uncoal, unc); unc = 0; @@ -105,29 +83,43 @@ static tdb_len_t summarize_zone(struct tdb_context *tdb, tdb_off_t zone_off, + rec_data_length(&p->u) + rec_extra_padding(&p->u); - /* FIXME: Use different magic for hashes? */ - if (!rec_key_length(&p->u) && !rec_hash(&p->u)) { - int count = count_hash(tdb, off + sizeof(p->u), - TDB_SUBLEVEL_HASH_BITS); - if (count == -1) - return TDB_OFF_ERR; - tally_add(hashes, count); - } else { - tally_add(keys, rec_key_length(&p->u)); - tally_add(data, rec_data_length(&p->u)); - } + tally_add(keys, rec_key_length(&p->u)); + tally_add(data, rec_data_length(&p->u)); + tally_add(extra, rec_extra_padding(&p->u)); + } else if (rec_magic(&p->u) == TDB_HTABLE_MAGIC) { + int count = count_hash(tdb, + off + sizeof(p->u), + TDB_SUBLEVEL_HASH_BITS); + if (count == -1) + return false; + tally_add(hashes, count); + tally_add(extra, rec_extra_padding(&p->u)); + len = sizeof(p->u) + + rec_data_length(&p->u) + + rec_extra_padding(&p->u); + } else if (rec_magic(&p->u) == TDB_FTABLE_MAGIC) { + len = sizeof(p->u) + + rec_data_length(&p->u) + + rec_extra_padding(&p->u); + tally_add(ftables, rec_data_length(&p->u)); + tally_add(extra, rec_extra_padding(&p->u)); + } else if (rec_magic(&p->u) == TDB_CHAIN_MAGIC) { + len = sizeof(p->u) + + rec_data_length(&p->u) + + rec_extra_padding(&p->u); + tally_add(chains, 1); tally_add(extra, rec_extra_padding(&p->u)); - } + } else + len = dead_space(tdb, off); + tdb_access_release(tdb, p); } if (unc) tally_add(uncoal, unc); - return 1ULL << zhdr.zone_bits; + return true; } #define SUMMARY_FORMAT \ "Size of file/data: %zu/%zu\n" \ - "Number of zones: %zu\n" \ - "Smallest/average/largest zone size: %zu/%zu/%zu\n%s" \ "Number of records: %zu\n" \ "Smallest/average/largest keys: %zu/%zu/%zu\n%s" \ "Smallest/average/largest data: %zu/%zu/%zu\n%s" \ @@ -136,10 +128,12 @@ static tdb_len_t summarize_zone(struct tdb_context *tdb, tdb_off_t zone_off, "Smallest/average/largest free records: %zu/%zu/%zu\n%s" \ "Number of uncoalesced records: %zu\n" \ "Smallest/average/largest uncoalesced runs: %zu/%zu/%zu\n%s" \ + "Number of free lists: %zu\n%s" \ "Toplevel hash used: %u of %u\n" \ + "Number of chains: %zu\n" \ "Number of subhashes: %zu\n" \ "Smallest/average/largest subhash entries: %zu/%zu/%zu\n%s" \ - "Percentage keys/data/padding/free/rechdrs/zonehdrs/hashes: %.0f/%.0f/%.0f/%.0f/%.0f/%.0f/%.0f\n" + "Percentage keys/data/padding/free/rechdrs/freehdrs/hashes: %.0f/%.0f/%.0f/%.0f/%.0f/%.0f/%.0f\n" #define BUCKET_SUMMARY_FORMAT_A \ "Free bucket %zu: total entries %zu.\n" \ @@ -153,17 +147,13 @@ static tdb_len_t summarize_zone(struct tdb_context *tdb, tdb_off_t zone_off, char *tdb_summary(struct tdb_context *tdb, enum tdb_summary_flags flags) { - tdb_off_t off; tdb_len_t len; - unsigned int i, num_buckets, max_bucket = 0; - uint64_t total_buckets = 0; - struct tally *zones, *hashes, *freet, *keys, *data, *extra, *uncoal, - *buckets[BUCKETS_FOR_ZONE(63)+1] = { NULL }; - char *zonesg, *hashesg, *freeg, *keysg, *datag, *extrag, *uncoalg, - *bucketsg[BUCKETS_FOR_ZONE(63)+1] = { NULL }; + struct tally *ftables, *hashes, *freet, *keys, *data, *extra, *uncoal, + *buckets, *chains; + char *hashesg, *freeg, *keysg, *datag, *extrag, *uncoalg, *bucketsg; char *ret = NULL; - zonesg = hashesg = freeg = keysg = datag = extrag = uncoalg = NULL; + hashesg = freeg = keysg = datag = extrag = uncoalg = bucketsg = NULL; if (tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false) != 0) return NULL; @@ -174,71 +164,45 @@ char *tdb_summary(struct tdb_context *tdb, enum tdb_summary_flags flags) } /* Start stats off empty. */ - zones = tally_new(HISTO_HEIGHT); + ftables = tally_new(HISTO_HEIGHT); hashes = tally_new(HISTO_HEIGHT); freet = tally_new(HISTO_HEIGHT); keys = tally_new(HISTO_HEIGHT); data = tally_new(HISTO_HEIGHT); extra = tally_new(HISTO_HEIGHT); uncoal = tally_new(HISTO_HEIGHT); - if (!zones || !hashes || !freet || !keys || !data || !extra - || !uncoal) { - tdb->ecode = TDB_ERR_OOM; + buckets = tally_new(HISTO_HEIGHT); + chains = tally_new(HISTO_HEIGHT); + if (!ftables || !hashes || !freet || !keys || !data || !extra + || !uncoal || !buckets || !chains) { + tdb_logerr(tdb, TDB_ERR_OOM, TDB_DEBUG_ERROR, + "tdb_summary: failed to allocate tally structures"); goto unlock; } - for (i = 0; i < sizeof(buckets)/sizeof(buckets[0]); i++) { - buckets[i] = tally_new(HISTO_HEIGHT); - if (!buckets[i]) { - tdb->ecode = TDB_ERR_OOM; - goto unlock; - } - } - - for (off = sizeof(struct tdb_header); - off < tdb->map_size - 1; - off += len) { - uint64_t bucketlen[BUCKETS_FOR_ZONE(63)+1] = { 0 }; - len = summarize_zone(tdb, off, zones, hashes, freet, keys, - data, extra, uncoal, bucketlen, - &num_buckets); - if (len == TDB_OFF_ERR) - goto unlock; - for (i = 0; i < num_buckets; i++) - tally_add(buckets[i], bucketlen[i]); - if (num_buckets > max_bucket) - max_bucket = num_buckets; - total_buckets += num_buckets; - } + if (!summarize(tdb, hashes, ftables, freet, keys, data, extra, uncoal, + buckets, chains)) + goto unlock; if (flags & TDB_SUMMARY_HISTOGRAMS) { - zonesg = tally_histogram(zones, HISTO_WIDTH, HISTO_HEIGHT); hashesg = tally_histogram(hashes, HISTO_WIDTH, HISTO_HEIGHT); freeg = tally_histogram(freet, HISTO_WIDTH, HISTO_HEIGHT); keysg = tally_histogram(keys, HISTO_WIDTH, HISTO_HEIGHT); datag = tally_histogram(data, HISTO_WIDTH, HISTO_HEIGHT); extrag = tally_histogram(extra, HISTO_WIDTH, HISTO_HEIGHT); uncoalg = tally_histogram(uncoal, HISTO_WIDTH, HISTO_HEIGHT); - for (i = 0; i < sizeof(buckets)/sizeof(buckets[0]); i++) { - bucketsg[i] = tally_histogram(buckets[i], - HISTO_WIDTH, - HISTO_HEIGHT); - } + bucketsg = tally_histogram(buckets, HISTO_WIDTH, HISTO_HEIGHT); } /* 20 is max length of a %llu. */ len = strlen(SUMMARY_FORMAT) + 33*20 + 1 - + (zonesg ? strlen(zonesg) : 0) + (hashesg ? strlen(hashesg) : 0) + (freeg ? strlen(freeg) : 0) + (keysg ? strlen(keysg) : 0) + (datag ? strlen(datag) : 0) + (extrag ? strlen(extrag) : 0) - + (uncoalg ? strlen(uncoalg) : 0); - for (i = 0; i < max_bucket; i++) { - len += strlen(BUCKET_SUMMARY_FORMAT_B) + 6 * 20 - + (bucketsg[i] ? strlen(bucketsg[i]) : 0); - } + + (uncoalg ? strlen(uncoalg) : 0) + + (bucketsg ? strlen(bucketsg) : 0); ret = malloc(len); if (!ret) @@ -247,9 +211,6 @@ char *tdb_summary(struct tdb_context *tdb, enum tdb_summary_flags flags) len = sprintf(ret, SUMMARY_FORMAT, (size_t)tdb->map_size, tally_num(keys) + tally_num(data), - tally_num(zones), - tally_min(zones), tally_mean(zones), tally_max(zones), - zonesg ? zonesg : "", tally_num(keys), tally_min(keys), tally_mean(keys), tally_max(keys), keysg ? keysg : "", @@ -263,9 +224,12 @@ char *tdb_summary(struct tdb_context *tdb, enum tdb_summary_flags flags) tally_total(uncoal, NULL), tally_min(uncoal), tally_mean(uncoal), tally_max(uncoal), uncoalg ? uncoalg : "", + tally_num(buckets), + bucketsg ? bucketsg : "", count_hash(tdb, offsetof(struct tdb_header, hashtable), TDB_TOPLEVEL_HASH_BITS), 1 << TDB_TOPLEVEL_HASH_BITS, + tally_num(chains), tally_num(hashes), tally_min(hashes), tally_mean(hashes), tally_max(hashes), hashesg ? hashesg : "", @@ -275,53 +239,31 @@ char *tdb_summary(struct tdb_context *tdb, enum tdb_summary_flags flags) tally_total(freet, NULL) * 100.0 / tdb->map_size, (tally_num(keys) + tally_num(freet) + tally_num(hashes)) * sizeof(struct tdb_used_record) * 100.0 / tdb->map_size, - (tally_num(zones) * sizeof(struct free_zone_header) - + total_buckets * sizeof(tdb_off_t)) + tally_num(ftables) * sizeof(struct tdb_freetable) * 100.0 / tdb->map_size, (tally_num(hashes) * (sizeof(tdb_off_t) << TDB_SUBLEVEL_HASH_BITS) - + (sizeof(tdb_off_t) << TDB_TOPLEVEL_HASH_BITS)) + + (sizeof(tdb_off_t) << TDB_TOPLEVEL_HASH_BITS) + + sizeof(struct tdb_chain) * tally_num(chains)) * 100.0 / tdb->map_size); - for (i = 0; i < max_bucket; i++) { - size_t min, max; - sizes_for_bucket(i, &min, &max); - if (min == max) { - len += sprintf(ret + len, BUCKET_SUMMARY_FORMAT_A, - min, tally_total(buckets[i], NULL), - tally_min(buckets[i]), - tally_mean(buckets[i]), - tally_max(buckets[i]), - bucketsg[i] ? bucketsg[i] : ""); - } else { - len += sprintf(ret + len, BUCKET_SUMMARY_FORMAT_B, - min, max, tally_total(buckets[i], NULL), - tally_min(buckets[i]), - tally_mean(buckets[i]), - tally_max(buckets[i]), - bucketsg[i] ? bucketsg[i] : ""); - } - } - unlock: - free(zonesg); free(hashesg); free(freeg); free(keysg); free(datag); free(extrag); free(uncoalg); - free(zones); + free(bucketsg); free(hashes); + free(buckets); free(freet); free(keys); free(data); free(extra); free(uncoal); - for (i = 0; i < sizeof(buckets)/sizeof(buckets[0]); i++) { - free(buckets[i]); - free(bucketsg[i]); - } + free(ftables); + free(chains); tdb_allrecord_unlock(tdb, F_RDLCK); tdb_unlock_expand(tdb, F_RDLCK);