* src/vm/jit/i386/emit.c (i386_call_mem): Removed.

[cacao.git] / src / vm / cycles-stats.c

diff --git a/src/vm/cycles-stats.c b/src/vm/cycles-stats.c
index ac8ab7cf5f1077769478478e9a2f4ad468ba738d..cffac210fe6624791aa72d212b50e8c16ac0a8ba 100644 (file)
--- a/src/vm/cycles-stats.c
+++ b/src/vm/cycles-stats.c
@@ -65,7 +65,7 @@ static double cycles_stats_get_cpu_MHz(void)
 {
        FILE *info;
        char line[CYCLES_STATS_MAXLINE + 1];
-       
+
        if (cycles_stats_cpu_MHz != 0.0)
                return cycles_stats_cpu_MHz;
 
@@ -77,7 +77,7 @@ static double cycles_stats_get_cpu_MHz(void)
 
        while (!feof(info) && !ferror(info)) {
                if (fgets(line,CYCLES_STATS_MAXLINE,info)
-                       && sscanf(line,"cpu MHz : %lf",&cycles_stats_cpu_MHz) == 1) 
+                       && sscanf(line,"cpu MHz : %lf",&cycles_stats_cpu_MHz) == 1)
                {
                        fclose(info);
                        fprintf(stderr,"CPU frequency used for statistics: %f MHz\n",
@@ -100,26 +100,29 @@ got_no_cpuinfo:
 
 u8 cycles_stats_measurement_overhead = 0;
 
-static void cycles_stats_print_percentile(FILE *file, const char *name, 
+static void cycles_stats_print_percentile(FILE *file, const char *name,
                                                                                  double percentile, u8 count,
+                                                                                 u8 cumul, double cumulcycles,
                                                                                  bool isoverhead, bool printforall)
 {
        u8 forall;
        double cpuMHz = cycles_stats_get_cpu_MHz();
        u8 cycles_per_ms = cpuMHz * 1000;
-       
+
        if (isoverhead) {
                fprintf(file,"\t\t%14s = %6.1f\n", name, percentile);
        }
        else {
                percentile -= cycles_stats_measurement_overhead;
-               forall = percentile * count;
-               
+
                fprintf(file,"\t\t%14s = %14.1f (+%llu)",
-                               name, percentile, 
+                               name, percentile,
                                (unsigned long long)cycles_stats_measurement_overhead);
                if (printforall) {
-                       fprintf(file," (for all calls: %15llu cycles = %6lu msec)",
+                       forall = cumulcycles - cumul * cycles_stats_measurement_overhead
+                                  + percentile * (count - cumul);
+                       fprintf(file," (%-23s: %15llu cycles = %6lu msec)",
+                                       (count == cumul) ? "total" : "capped here & extrapol.",
                                        (unsigned long long)forall,
                                        (unsigned long)(forall / cycles_per_ms));
                }
@@ -129,7 +132,7 @@ static void cycles_stats_print_percentile(FILE *file, const char *name,
 
 void cycles_stats_print(FILE *file,
                                                const char *name, int nbins, int div,
-                                               u4 *bins, u8 count, u8 min, u8 max,
+                                               u4 *bins, u8 count, u8 total, u8 min, u8 max,
                                                int overhead)
 {
         s4 i;
@@ -137,24 +140,26 @@ void cycles_stats_print(FILE *file,
                u8 floor, ceiling;
                u8 p;
                u8 cumul;
+               double cumulcycles;
                double percentile;
                double cpuMHz = cycles_stats_get_cpu_MHz();
                u8 cycles_per_ms = cpuMHz * 1000;
 
         fprintf(file,"\t%s: %llu calls\n",
-                (overhead) ? "measurement overhead determined by" : name, 
+                (overhead) ? "measurement overhead determined by" : name,
                                (unsigned long long)count);
-               
-        fprintf(file,"\t%s cycles distribution:\n", 
+
+        fprintf(file,"\t%s cycles distribution:\n",
                                (overhead) ? "measurement overhead" : name);
 
-               cycles_stats_print_percentile(file, "min", min, count, overhead, true);
+               cycles_stats_print_percentile(file, "min", min, count, 0, 0, overhead, true);
 
                pcd = cycles_stats_percentile_defs;
                for (; pcd->name; pcd++) {
                        floor   = (count * pcd->pct) / 100;
                        ceiling = (count * pcd->pct + 99) / 100;
                        cumul = 0;
+                       cumulcycles = 0;
                        p = 0;
                        percentile = -1.0;
 
@@ -165,7 +170,7 @@ void cycles_stats_print(FILE *file,
                                /* { invariant: `cumul` samples are < `p` } */
 
                                /* check if percentile lies exactly at the bin boundary */
-                               
+
                                if (floor == cumul && floor == ceiling) {
                                        percentile = p;
                                        break;
@@ -177,13 +182,15 @@ void cycles_stats_print(FILE *file,
                                        percentile = p + (double)div/2.0;
                                        break;
                                }
-                               
+
                                cumul += bins[i];
                                p     += div;
 
+                               cumulcycles += bins[i] * (p - (double)div/2.0);
+
                                /* { invariant: `cumul` samples are < `p` } */
                        }
-                       
+
                        /* check if percentile lies exactly at the bin boundary */
 
                        if (floor == cumul && floor == ceiling) {
@@ -194,7 +201,9 @@ void cycles_stats_print(FILE *file,
                                if (overhead && pcd->pct == 50) {
                                        cycles_stats_measurement_overhead = percentile;
                                }
-                               cycles_stats_print_percentile(file, pcd->name, percentile, count, overhead, true);
+                               cycles_stats_print_percentile(file, pcd->name, percentile,
+                                                                                         count, cumul, cumulcycles,
+                                                                                         overhead, true);
                        }
                        else {
                                if (!overhead)
@@ -202,29 +211,30 @@ void cycles_stats_print(FILE *file,
                                fprintf(file,"\t\t%14s = unknown (> %llu)\n", pcd->name, (unsigned long long)p);
                        }
                }
-               
-               cycles_stats_print_percentile(file, "max", max, count, overhead, false);
+
+               cycles_stats_print_percentile(file, "max", max, count, count,
+                                                                         total, overhead, true);
 
                if (!overhead) {
                        fprintf(file,"\t\t(assuming %llu cycles per ms)\n",
                                        (unsigned long long)cycles_per_ms);
-                       fprintf(file,"\t\t(assuming %llu cycles measurement overhead)\n", 
+                       fprintf(file,"\t\t(assuming %llu cycles measurement overhead)\n",
                                        (unsigned long long)cycles_stats_measurement_overhead);
                }
 
                fprintf(file,"\n");
-               
+
                cumul = 0;
         for (i=0; i<nbins; ++i) {
                        cumul += bins[i];
-            fprintf(file,"\t\t<  %5d: %10lu (%3d%%) %10lu\n",
+            fprintf(file,"\t\t<  %8d: %10lu (%3d%%) %10lu\n",
                     (int)((i+1) * div),
                                        (unsigned long) cumul,
-                                       (int)((cumul * 100) / count),
+                                       (count) ? (int)((cumul * 100) / count) : 0,
                     (unsigned long) bins[i]);
         }
-               
-        fprintf(file,"\t\t>= %5d: %10s (----) %10lu\n",
+
+        fprintf(file,"\t\t>= %8d: %10s (----) %10lu\n",
                 (int)(nbins * div),
                                "OVER",
                 (unsigned long) bins[nbins]);