qsp: support call site coalescing

};

void qsp_report(FILE *f, fprintf_function cpu_fprintf, size_t max,

                enum QSPSortBy sort_by);

                enum QSPSortBy sort_by, bool callsite_coalesce);

bool qsp_is_enabled(void);

void qsp_enable(void);

 * Reports are generated as a table where each row represents a call site. A

 * call site is the triplet formed by the __file__ and __LINE__ of the caller

 * as well as the address of the "object" (i.e. mutex, rec. mutex or condvar)

 * being operated on. Focusing on call sites instead of just on objects might

 * seem puzzling. However, it is a sensible choice since otherwise dealing with

 * dynamically-allocated objects becomes difficult (e.g. what to do when an

 * object is destroyed, or reused?). Furthermore, the call site info is of most

 * importance, since it is callers, and not objects, what cause wait time.

 * being operated on. Optionally, call sites that operate on different objects

 * of the same type can be coalesced, which can be particularly useful when

 * profiling dynamically-allocated objects.

 *

 * Alternative designs considered:

 *

    const QSPCallSite *callsite;

    uint64_t n_acqs;

    uint64_t ns;

    unsigned int n_objs; /* count of coalesced objs; only used for reporting */

#ifndef CONFIG_ATOMIC64

    /*

     * If we cannot update the counts atomically, then use a seqlock.

    return do_qsp_entry_hash(entry, 0);

}

/* without the objects we need to hash the file name to get a decent hash */

static uint32_t qsp_entry_no_thread_obj_hash(const QSPEntry *entry)

{

    const QSPCallSite *callsite = entry->callsite;

    uint64_t a = g_str_hash(callsite->file);

    uint64_t b = callsite->line;

    uint32_t e = callsite->type;

    return tb_hash_func7(a, b, e, 0, 0);

}

static bool qsp_callsite_cmp(const void *ap, const void *bp)

{

    const QSPCallSite *a = ap;

         (a->file == b->file || !strcmp(a->file, b->file)));

}

static bool qsp_callsite_no_obj_cmp(const void *ap, const void *bp)

{

    const QSPCallSite *a = ap;

    const QSPCallSite *b = bp;

    return a == b ||

        (a->line == b->line &&

         a->type == b->type &&

         (a->file == b->file || !strcmp(a->file, b->file)));

}

static bool qsp_entry_no_thread_cmp(const void *ap, const void *bp)

{

    const QSPEntry *a = ap;

    return qsp_callsite_cmp(a->callsite, b->callsite);

}

static bool qsp_entry_no_thread_obj_cmp(const void *ap, const void *bp)

{

    const QSPEntry *a = ap;

    const QSPEntry *b = bp;

    return qsp_callsite_no_obj_cmp(a->callsite, b->callsite);

}

static bool qsp_entry_cmp(const void *ap, const void *bp)

{

    const QSPEntry *a = ap;

    qht_iter(orig, qsp_iter_diff, new);

}

static void

qsp_iter_callsite_coalesce(struct qht *orig, void *p, uint32_t h, void *htp)

{

    struct qht *ht = htp;

    QSPEntry *old = p;

    QSPEntry *e;

    uint32_t hash;

    hash = qsp_entry_no_thread_obj_hash(old);

    e = qht_lookup(ht, old, hash);

    if (e == NULL) {

        e = qsp_entry_create(ht, old, hash);

        e->n_objs = 1;

    } else if (e->callsite->obj != old->callsite->obj) {

        e->n_objs++;

    }

    e->ns += old->ns;

    e->n_acqs += old->n_acqs;

}

static void qsp_ht_delete(struct qht *ht, void *p, uint32_t h, void *htp)

{

    g_free(p);

}

static void qsp_mktree(GTree *tree)

static void qsp_mktree(GTree *tree, bool callsite_coalesce)

{

    QSPSnapshot *snap;

    struct qht ht;

    struct qht ht, coalesce_ht;

    struct qht *htp;

    /*

     * First, see if there's a prior snapshot, so that we read the global hash

    /* done with the snapshot; RCU can reclaim it */

    rcu_read_unlock();

    htp = &ht;

    if (callsite_coalesce) {

        qht_init(&coalesce_ht, qsp_entry_no_thread_obj_cmp, QSP_INITIAL_SIZE,

                 QHT_MODE_AUTO_RESIZE | QHT_MODE_RAW_MUTEXES);

        qht_iter(&ht, qsp_iter_callsite_coalesce, &coalesce_ht);

        /* free the previous hash table, and point htp to coalesce_ht */

        qht_iter(&ht, qsp_ht_delete, NULL);

        qht_destroy(&ht);

        htp = &coalesce_ht;

    }

    /* sort the hash table elements by using a tree */

    qht_iter(&ht, qsp_sort, tree);

    qht_iter(htp, qsp_sort, tree);

    /* free the hash table, but keep the elements (those are in the tree now) */

    qht_destroy(&ht);

    qht_destroy(htp);

}

/* free string with g_free */

    double time_s;

    double ns_avg;

    uint64_t n_acqs;

    unsigned int n_objs;

};

typedef struct QSPReportEntry QSPReportEntry;

    report->n_entries++;

    entry->obj = e->callsite->obj;

    entry->n_objs = e->n_objs;

    entry->callsite_at = qsp_at(e->callsite);

    entry->typename = qsp_typenames[e->callsite->type];

    entry->time_s = e->ns * 1e-9;

    for (i = 0; i < rep->n_entries; i++) {

        const QSPReportEntry *e = &rep->entries[i];

        GString *s = g_string_new(NULL);

        pr(f, "%-9s  %14p  %s%*s  %13.5f  %12" PRIu64 "  %12.2f\n", e->typename,

           e->obj, e->callsite_at, callsite_len - (int)strlen(e->callsite_at),

           "", e->time_s, e->n_acqs, e->ns_avg * 1e-3);

        g_string_append_printf(s, "%-9s  ", e->typename);

        if (e->n_objs > 1) {

            g_string_append_printf(s, "[%12u]", e->n_objs);

        } else {

            g_string_append_printf(s, "%14p", e->obj);

        }

        g_string_append_printf(s, "  %s%*s  %13.5f  %12" PRIu64 "  %12.2f\n",

                               e->callsite_at,

                               callsite_len - (int)strlen(e->callsite_at), "",

                               e->time_s, e->n_acqs, e->ns_avg * 1e-3);

        pr(f, "%s", s->str);

        g_string_free(s, TRUE);

    }

    pr(f, "%s\n", dashes);

}

void qsp_report(FILE *f, fprintf_function cpu_fprintf, size_t max,

                enum QSPSortBy sort_by)

                enum QSPSortBy sort_by, bool callsite_coalesce)

{

    GTree *tree = g_tree_new_full(qsp_tree_cmp, &sort_by, g_free, NULL);

    QSPReport rep;

    rep.n_entries = 0;

    rep.max_n_entries = max;

    qsp_mktree(tree);

    qsp_mktree(tree, callsite_coalesce);

    g_tree_foreach(tree, qsp_tree_report, &rep);

    g_tree_destroy(tree);