[global] Interval element struct

diff --git a/analyze.c b/analyze.c
index 89aef2b702a967b9b6ffa4e4ae221d92f1e79786..b6bee9769acefdb4b47e905c3e8c3efce85a79ee 100644 (file)
--- a/analyze.c
+++ b/analyze.c
@@ -179,24 +179,33 @@ struct cycle_framework {
     tsc_t first_tsc, last_tsc, total_cycles;
 };
 
+struct interval_element {
+    int count;
+    long long cycles;
+    long long instructions;
+};
+
 struct event_cycle_summary {
-    int count, cycles_count, interval_count;
-    long long cycles, interval_cycles;
+    int count, cycles_count;
+    long long cycles;
     long long *cycles_sample;
+    struct interval_element interval;
 };
 
 struct cycle_summary {
-    int count, interval_count;
-    unsigned long long cycles, interval_cycles;
+    int count;
+    unsigned long long cycles;
     long long *sample;
+    struct interval_element interval;
 };
 
 struct weighted_cpi_summary {
-    int count, interval_count;
-    unsigned long long instructions, interval_instructions;
-    unsigned long long cycles, interval_cycles;
+    int count;
+    unsigned long long instructions;
+    unsigned long long cycles;
     float *cpi;
     unsigned long long *cpi_weight;
+    struct interval_element interval;
 };
 
 /* -- Symbol list information -- */
@@ -1968,15 +1977,15 @@ static inline void update_summary(struct event_cycle_summary *s, long long c) {
         s->cycles_count++;
         s->cycles += c;
 
-        s->interval_count++;
-        s->interval_cycles += c;
+        s->interval.count++;
+        s->interval.cycles += c;
     }
     s->count++;
 }
 
 static inline void clear_interval_summary(struct event_cycle_summary *s) {
-    s->interval_count = 0;
-    s->interval_cycles = 0;
+    s->interval.count = 0;
+    s->interval.cycles = 0;
 }
 
 static inline void update_cycles(struct cycle_summary *s, long long c) {
@@ -2006,18 +2015,19 @@ static inline void update_cycles(struct cycle_summary *s, long long c) {
 
     if(c > 0) {
         s->cycles += c;
-        s->interval_cycles += c;
+        s->interval.cycles += c;
     } else {
         s->cycles += -c;
-        s->interval_cycles += -c;
+        s->interval.cycles += -c;
     }
     s->count++;
-    s->interval_count++;
+    s->interval.count++;
 }
 
-static inline void clear_interval_cycles(struct cycle_summary *s) {
-    s->interval_cycles = 0;
-    s->interval_count = 0;
+static inline void clear_interval_cycles(struct interval_element *e) {
+    e->cycles = 0;
+    e->count = 0;
+    e->instructions = 0;
 }
 
 static inline void update_cpi(struct weighted_cpi_summary *s,
@@ -2055,15 +2065,15 @@ static inline void update_cpi(struct weighted_cpi_summary *s,
     s->cycles += c;
     s->count++;
 
-    s->interval_instructions += i;
-    s->interval_cycles += c;
-    s->interval_count++;
+    s->interval.instructions += i;
+    s->interval.cycles += c;
+    s->interval.count++;
 }
 
 static inline void clear_interval_cpi(struct weighted_cpi_summary *s) {
-    s->interval_cycles = 0;
-    s->interval_count = 0;
-    s->interval_instructions = 0;
+    s->interval.cycles = 0;
+    s->interval.count = 0;
+    s->interval.instructions = 0;
 }
 
 static inline void print_cpu_affinity(struct cycle_summary *s, char *p) {
@@ -2210,14 +2220,19 @@ static inline void print_cycle_summary(struct cycle_summary *s, char *p) {
         }                                                               \
     } while(0)
 
-void __interval_cycle_percent_output(struct cycle_summary *s, tsc_t cycles) {
+struct interval_list {
+    struct interval_element *elem;
+    struct interval_list *next;
+};
+
+void __interval_cycle_percent_output(struct interval_element *e, tsc_t cycles) {
     printf(" %.02lf",
-           __cycles_percent(s->interval_cycles, cycles));
-    clear_interval_cycles(s);
+           __cycles_percent(e->cycles, cycles));
+    clear_interval_cycles(e);
 }
 
-void interval_cycle_percent_output(struct cycle_summary *s) {
-    __interval_cycle_percent_output(s, opt.interval.cycles);
+void interval_cycle_percent_output(struct interval_element *e) {
+    __interval_cycle_percent_output(e, opt.interval.cycles);
 }
 
 void interval_time_output(void) {
@@ -2283,9 +2298,9 @@ void interval_cr3_schedule_time_output(void) {
             cr3 = P.interval.cr3.array[i];
             if(cr3) {
                 printf(" %.02lf",
-                       __cycles_percent(cr3->total_time.interval_cycles,
+                       __cycles_percent(cr3->total_time.interval.cycles,
                                         opt.interval.cycles));
-                clear_interval_cycles(&cr3->total_time);
+                clear_interval_cycles(&cr3->total_time.interval);
             } else {
                 printf(" 0.0");
             }
@@ -2294,9 +2309,9 @@ void interval_cr3_schedule_time_output(void) {
         struct cr3_value_struct *cr3;
         for(cr3 = P.cr3.head; cr3; cr3 = cr3->gnext) {
             printf(" %.02lf",
-                   __cycles_percent(cr3->total_time.interval_cycles,
+                   __cycles_percent(cr3->total_time.interval.cycles,
                                     opt.interval.cycles));
-            clear_interval_cycles(&cr3->total_time);
+            clear_interval_cycles(&cr3->total_time.interval);
         }
     }
     printf("\n");
@@ -2313,12 +2328,12 @@ void interval_cr3_schedule_ordered_output(void) {
         struct cr3_value_struct *a=*(typeof(&a))_a;
         struct cr3_value_struct *b=*(typeof(&a))_b;
 
-        if(a->total_time.interval_cycles < b->total_time.interval_cycles)
+        if(a->total_time.interval.cycles < b->total_time.interval.cycles)
             return 1;
-        else if(b->total_time.interval_cycles == a->total_time.interval_cycles) {
-            if(a->total_time.interval_count < b->total_time.interval_count)
+        else if(b->total_time.interval.cycles == a->total_time.interval.cycles) {
+            if(a->total_time.interval.count < b->total_time.interval.count)
                 return 1;
-            else if(a->total_time.interval_count == b->total_time.interval_count)
+            else if(a->total_time.interval.count == b->total_time.interval.count)
                 return 0;
             else
                 return -1;
@@ -2345,14 +2360,14 @@ void interval_cr3_schedule_ordered_output(void) {
     for(i=0; i<N; i++) {
         p = qsort_array[i];
         /* Rounding down means this will get ..1]% */
-        if(p->total_time.interval_cycles > 0) {
+        if(p->total_time.interval.cycles > 0) {
             printf(" %8llx: %.02lf %c\n",
                    p->gmfn,
-                   __cycles_percent(p->total_time.interval_cycles,
+                   __cycles_percent(p->total_time.interval.cycles,
                                     opt.interval.cycles),
                    (p->first_time > P.interval.start_tsc)?'*':' ');
         }
-        clear_interval_cycles(&p->total_time);
+        clear_interval_cycles(&p->total_time.interval);
     }
 
     free(qsort_array);
@@ -2379,14 +2394,14 @@ void interval_cr3_short_summary_output(void) {
         hss_array = p->hvm.s;
 
         printf(" %.02lf",
-               __cycles_percent(p->total_time.interval_cycles,
+               __cycles_percent(p->total_time.interval.cycles,
                                 opt.interval.cycles));
 
         for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) 
-            __interval_cycle_percent_output(hss_array + i,
-                                            p->total_time.interval_cycles);
+            __interval_cycle_percent_output(&hss_array[i].interval,
+                                            p->total_time.interval.cycles);
 
-        clear_interval_cycles(&p->total_time);
+        clear_interval_cycles(&p->total_time.interval);
 
         printf("\n");
     }
@@ -2410,14 +2425,14 @@ void interval_domain_short_summary_output(void) {
 
         d=P.interval.domain.d;
 
-        interval_cycles = d->total_time.interval_cycles;
+        interval_cycles = d->total_time.interval.cycles;
 
         interval_time_output();
 
-        interval_cycle_percent_output(&d->total_time);
+        interval_cycle_percent_output(&d->total_time.interval);
 
         for(i=0; i<HVM_SHORT_SUMMARY_MAX; i++) 
-            __interval_cycle_percent_output(d->hvm_short.s + i,
+            __interval_cycle_percent_output(&d->hvm_short.s[i].interval,
                                             interval_cycles);
 
         printf("\n");