Commit 3de2faa9 authored by Markus Armbruster's avatar Markus Armbruster
Browse files

tcg: Simplify how dump_exec_info() prints 



dump_exec_info() takes an fprintf()-like callback and a FILE * to pass
to it.

Its only caller hmp_info_jit() passes monitor_fprintf() and the
current monitor cast to FILE *.  monitor_fprintf() casts it right
back, and is otherwise identical to monitor_printf().  The
type-punning is ugly.

Drop the callback, and call qemu_printf() instead.

Signed-off-by: default avatarMarkus Armbruster <armbru@redhat.com>
Reviewed-by: default avatarDr. David Alan Gilbert <dgilbert@redhat.com>
Message-Id: <20190417191805.28198-5-armbru@redhat.com>
parent d4c51a0a

accel/tcg/translate-all.c

+23 −22
Original line number Diff line number Diff line
@@ -50,6 +50,7 @@ 
#include "translate-all.h"

#include "qemu/bitmap.h"

#include "qemu/error-report.h"

#include "qemu/qemu-print.h"

#include "qemu/timer.h"

#include "qemu/main-loop.h"

#include "exec/log.h"
@@ -2214,8 +2215,7 @@ void tb_flush_jmp_cache(CPUState *cpu, target_ulong addr) 
    tb_jmp_cache_clear_page(cpu, addr);

}



static void print_qht_statistics(FILE *f, fprintf_function cpu_fprintf,

                                 struct qht_stats hst)

static void print_qht_statistics(struct qht_stats hst)

{

    uint32_t hgram_opts;

    size_t hgram_bins;
@@ -2224,7 +2224,7 @@ static void print_qht_statistics(FILE *f, fprintf_function cpu_fprintf, 
    if (!hst.head_buckets) {

        return;

    }

    cpu_fprintf(f, "TB hash buckets     %zu/%zu (%0.2f%% head buckets used)\n",

    qemu_printf("TB hash buckets     %zu/%zu (%0.2f%% head buckets used)\n",

                hst.used_head_buckets, hst.head_buckets,

                (double)hst.used_head_buckets / hst.head_buckets * 100);
@@ -2234,7 +2234,7 @@ static void print_qht_statistics(FILE *f, fprintf_function cpu_fprintf, 
        hgram_opts |= QDIST_PR_NODECIMAL;

    }

    hgram = qdist_pr(&hst.occupancy, 10, hgram_opts);

    cpu_fprintf(f, "TB hash occupancy   %0.2f%% avg chain occ. Histogram: %s\n",

    qemu_printf("TB hash occupancy   %0.2f%% avg chain occ. Histogram: %s\n",

                qdist_avg(&hst.occupancy) * 100, hgram);

    g_free(hgram);
@@ -2247,7 +2247,7 @@ static void print_qht_statistics(FILE *f, fprintf_function cpu_fprintf, 
        hgram_opts |= QDIST_PR_NODECIMAL | QDIST_PR_NOBINRANGE;

    }

    hgram = qdist_pr(&hst.chain, hgram_bins, hgram_opts);

    cpu_fprintf(f, "TB hash avg chain   %0.3f buckets. Histogram: %s\n",

    qemu_printf("TB hash avg chain   %0.3f buckets. Histogram: %s\n",

                qdist_avg(&hst.chain), hgram);

    g_free(hgram);

}
@@ -2285,7 +2285,7 @@ static gboolean tb_tree_stats_iter(gpointer key, gpointer value, gpointer data) 
    return false;

}



void dump_exec_info(FILE *f, fprintf_function cpu_fprintf)

void dump_exec_info(void)

{

    struct tb_tree_stats tst = {};

    struct qht_stats hst;
@@ -2294,43 +2294,44 @@ void dump_exec_info(FILE *f, fprintf_function cpu_fprintf) 
    tcg_tb_foreach(tb_tree_stats_iter, &tst);

    nb_tbs = tst.nb_tbs;

    /* XXX: avoid using doubles ? */

    cpu_fprintf(f, "Translation buffer state:\n");

    qemu_printf("Translation buffer state:\n");

    /*

     * Report total code size including the padding and TB structs;

     * otherwise users might think "-tb-size" is not honoured.

     * For avg host size we use the precise numbers from tb_tree_stats though.

     */

    cpu_fprintf(f, "gen code size       %zu/%zu\n",

    qemu_printf("gen code size       %zu/%zu\n",

                tcg_code_size(), tcg_code_capacity());

    cpu_fprintf(f, "TB count            %zu\n", nb_tbs);

    cpu_fprintf(f, "TB avg target size  %zu max=%zu bytes\n",

    qemu_printf("TB count            %zu\n", nb_tbs);

    qemu_printf("TB avg target size  %zu max=%zu bytes\n",

                nb_tbs ? tst.target_size / nb_tbs : 0,

                tst.max_target_size);

    cpu_fprintf(f, "TB avg host size    %zu bytes (expansion ratio: %0.1f)\n",

    qemu_printf("TB avg host size    %zu bytes (expansion ratio: %0.1f)\n",

                nb_tbs ? tst.host_size / nb_tbs : 0,

                tst.target_size ? (double)tst.host_size / tst.target_size : 0);

    cpu_fprintf(f, "cross page TB count %zu (%zu%%)\n", tst.cross_page,

    qemu_printf("cross page TB count %zu (%zu%%)\n", tst.cross_page,

                nb_tbs ? (tst.cross_page * 100) / nb_tbs : 0);

    cpu_fprintf(f, "direct jump count   %zu (%zu%%) (2 jumps=%zu %zu%%)\n",

    qemu_printf("direct jump count   %zu (%zu%%) (2 jumps=%zu %zu%%)\n",

                tst.direct_jmp_count,

                nb_tbs ? (tst.direct_jmp_count * 100) / nb_tbs : 0,

                tst.direct_jmp2_count,

                nb_tbs ? (tst.direct_jmp2_count * 100) / nb_tbs : 0);



    qht_statistics_init(&tb_ctx.htable, &hst);

    print_qht_statistics(f, cpu_fprintf, hst);

    print_qht_statistics(hst);

    qht_statistics_destroy(&hst);



    cpu_fprintf(f, "\nStatistics:\n");

    cpu_fprintf(f, "TB flush count      %u\n",

    qemu_printf("\nStatistics:\n");

    qemu_printf("TB flush count      %u\n",

                atomic_read(&tb_ctx.tb_flush_count));

    cpu_fprintf(f, "TB invalidate count %zu\n", tcg_tb_phys_invalidate_count());

    qemu_printf("TB invalidate count %zu\n",

                tcg_tb_phys_invalidate_count());



    tlb_flush_counts(&flush_full, &flush_part, &flush_elide);

    cpu_fprintf(f, "TLB full flushes    %zu\n", flush_full);

    cpu_fprintf(f, "TLB partial flushes %zu\n", flush_part);

    cpu_fprintf(f, "TLB elided flushes  %zu\n", flush_elide);

    tcg_dump_info(f, cpu_fprintf);

    qemu_printf("TLB full flushes    %zu\n", flush_full);

    qemu_printf("TLB partial flushes %zu\n", flush_part);

    qemu_printf("TLB elided flushes  %zu\n", flush_elide);

    tcg_dump_info();

}



void dump_opcount_info(void)

include/exec/cpu-all.h

+1 −1
Original line number Diff line number Diff line
@@ -362,7 +362,7 @@ static inline bool tlb_hit(target_ulong tlb_addr, target_ulong addr) 
    return tlb_hit_page(tlb_addr, addr & TARGET_PAGE_MASK);

}



void dump_exec_info(FILE *f, fprintf_function cpu_fprintf);

void dump_exec_info(void);

void dump_opcount_info(void);

#endif /* !CONFIG_USER_ONLY */

monitor.c

+1 −1
Original line number Diff line number Diff line
@@ -1318,7 +1318,7 @@ static void hmp_info_jit(Monitor *mon, const QDict *qdict) 
        return;

    }



    dump_exec_info((FILE *)mon, monitor_fprintf);

    dump_exec_info();

    dump_drift_info((FILE *)mon, monitor_fprintf);

}

tcg/tcg.c

+21 −20
Original line number Diff line number Diff line
@@ -4015,7 +4015,7 @@ int tcg_gen_code(TCGContext *s, TranslationBlock *tb) 
}



#ifdef CONFIG_PROFILER

void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf)

void tcg_dump_info(void)

{

    TCGProfile prof = {};

    const TCGProfile *s;
@@ -4029,52 +4029,53 @@ void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf) 
    tb_div_count = tb_count ? tb_count : 1;

    tot = s->interm_time + s->code_time;



    cpu_fprintf(f, "JIT cycles          %" PRId64 " (%0.3f s at 2.4 GHz)\n",

    qemu_printf("JIT cycles          %" PRId64 " (%0.3f s at 2.4 GHz)\n",

                tot, tot / 2.4e9);

    cpu_fprintf(f, "translated TBs      %" PRId64 " (aborted=%" PRId64 " %0.1f%%)\n", 

    qemu_printf("translated TBs      %" PRId64 " (aborted=%" PRId64

                " %0.1f%%)\n",

                tb_count, s->tb_count1 - tb_count,

                (double)(s->tb_count1 - s->tb_count)

                / (s->tb_count1 ? s->tb_count1 : 1) * 100.0);

    cpu_fprintf(f, "avg ops/TB          %0.1f max=%d\n", 

    qemu_printf("avg ops/TB          %0.1f max=%d\n",

                (double)s->op_count / tb_div_count, s->op_count_max);

    cpu_fprintf(f, "deleted ops/TB      %0.2f\n",

    qemu_printf("deleted ops/TB      %0.2f\n",

                (double)s->del_op_count / tb_div_count);

    cpu_fprintf(f, "avg temps/TB        %0.2f max=%d\n",

    qemu_printf("avg temps/TB        %0.2f max=%d\n",

                (double)s->temp_count / tb_div_count, s->temp_count_max);

    cpu_fprintf(f, "avg host code/TB    %0.1f\n",

    qemu_printf("avg host code/TB    %0.1f\n",

                (double)s->code_out_len / tb_div_count);

    cpu_fprintf(f, "avg search data/TB  %0.1f\n",

    qemu_printf("avg search data/TB  %0.1f\n",

                (double)s->search_out_len / tb_div_count);

    

    cpu_fprintf(f, "cycles/op           %0.1f\n", 

    qemu_printf("cycles/op           %0.1f\n",

                s->op_count ? (double)tot / s->op_count : 0);

    cpu_fprintf(f, "cycles/in byte      %0.1f\n", 

    qemu_printf("cycles/in byte      %0.1f\n",

                s->code_in_len ? (double)tot / s->code_in_len : 0);

    cpu_fprintf(f, "cycles/out byte     %0.1f\n", 

    qemu_printf("cycles/out byte     %0.1f\n",

                s->code_out_len ? (double)tot / s->code_out_len : 0);

    cpu_fprintf(f, "cycles/search byte     %0.1f\n",

    qemu_printf("cycles/search byte     %0.1f\n",

                s->search_out_len ? (double)tot / s->search_out_len : 0);

    if (tot == 0) {

        tot = 1;

    }

    cpu_fprintf(f, "  gen_interm time   %0.1f%%\n", 

    qemu_printf("  gen_interm time   %0.1f%%\n",

                (double)s->interm_time / tot * 100.0);

    cpu_fprintf(f, "  gen_code time     %0.1f%%\n", 

    qemu_printf("  gen_code time     %0.1f%%\n",

                (double)s->code_time / tot * 100.0);

    cpu_fprintf(f, "optim./code time    %0.1f%%\n",

    qemu_printf("optim./code time    %0.1f%%\n",

                (double)s->opt_time / (s->code_time ? s->code_time : 1)

                * 100.0);

    cpu_fprintf(f, "liveness/code time  %0.1f%%\n", 

    qemu_printf("liveness/code time  %0.1f%%\n",

                (double)s->la_time / (s->code_time ? s->code_time : 1) * 100.0);

    cpu_fprintf(f, "cpu_restore count   %" PRId64 "\n",

    qemu_printf("cpu_restore count   %" PRId64 "\n",

                s->restore_count);

    cpu_fprintf(f, "  avg cycles        %0.1f\n",

    qemu_printf("  avg cycles        %0.1f\n",

                s->restore_count ? (double)s->restore_time / s->restore_count : 0);

}

#else

void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf)

void tcg_dump_info(void)

{

    cpu_fprintf(f, "[TCG profiler not compiled]\n");

    qemu_printf("[TCG profiler not compiled]\n");

}

#endif

tcg/tcg.h

+1 −1
Original line number Diff line number Diff line
@@ -1017,7 +1017,7 @@ int tcg_check_temp_count(void); 
#endif



int64_t tcg_cpu_exec_time(void);

void tcg_dump_info(FILE *f, fprintf_function cpu_fprintf);

void tcg_dump_info(void);

void tcg_dump_op_count(void);



#define TCG_CT_ALIAS  0x80