nsz Git - libfirm/blob - ir/stat/distrib.c

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/distrib.c
   4  * Purpose:     Statistics for Firm. Distribution tables.
   5  * Author:      Michael Beck
   6  * Created:
   7  * CVS-ID:      $Id$
   8  * Copyright:   (c) 2004 Universität Karlsruhe
   9  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  10  */
  11 #ifdef HAVE_CONFIG_H
  12 # include "config.h"
  13 #endif
  14
  15 #include "hashptr.h"
  16 #include "irtools.h"
  17 #include "xmalloc.h"
  18 #include "firmstat_t.h"
  19
  20 /**
  21  * calculates a hash value for an address
  22  */
  23 static unsigned addr_hash(const void *object)
  24 {
  25   return HASH_PTR(object);
  26 }
  27
  28 /**
  29  * calculates a hash value for an integer
  30  */
  31 static unsigned int_hash(const void *object)
  32 {
  33   return (unsigned)PTR_TO_INT(object);
  34 }
  35
  36 /**
  37  * compare function for integer distribution tables
  38  */
  39 static int int_cmp_fun(const void *elt, const void *key)
  40 {
  41   int p1 = (int)elt;
  42   int p2 = (int)key;
  43
  44   return p1 - p2;
  45 }
  46
  47 /*
  48  * create a new distribution table
  49  */
  50 distrib_tbl_t *stat_new_distrib_tbl(pset_cmp_fun cmp_func, distrib_hash_fun hash_func)
  51 {
  52   distrib_tbl_t *res;
  53
  54   res = xmalloc(sizeof(*res));
  55
  56   obstack_init(&res->cnts);
  57
  58   /* create the hash-table */
  59   res->hash_map  = new_pset(cmp_func, 8);
  60   res->hash_func = hash_func ? hash_func : addr_hash;
  61   res->int_dist  = 0;
  62
  63   return res;
  64 }
  65
  66 /*
  67  * create a new distribution table for an integer distribution
  68  */
  69 distrib_tbl_t *stat_new_int_distrib_tbl(void)
  70 {
  71   distrib_tbl_t *res = stat_new_distrib_tbl(int_cmp_fun, int_hash);
  72
  73   if (res)
  74     res->int_dist = 1;
  75
  76   return res;
  77 }
  78
  79 /*
  80  * destroy a distribution table
  81  */
  82 void stat_delete_distrib_tbl(distrib_tbl_t *tbl)
  83 {
  84   if (tbl) {
  85     /* free all entries */
  86     obstack_free(&tbl->cnts, NULL);
  87
  88     /* delete the hash table */
  89     del_pset(tbl->hash_map);
  90   }
  91 }
  92
  93 /**
  94  * Returns the associates distrib_entry_t for an object
  95  */
  96 static distrib_entry_t *distrib_get_entry(distrib_tbl_t *tbl, const void *object)
  97 {
  98   distrib_entry_t key;
  99   distrib_entry_t *elem;
 100
 101   key.object = object;
 102
 103   elem = pset_find(tbl->hash_map, &key, tbl->hash_func(object));
 104   if (elem)
 105     return elem;
 106
 107   elem = obstack_alloc(&tbl->cnts, sizeof(*elem));
 108
 109   /* clear counter */
 110   cnt_clr(&elem->cnt);
 111
 112   elem->object = object;
 113
 114   return pset_insert(tbl->hash_map, elem, tbl->hash_func(object));
 115 }
 116
 117 /*
 118  * adds a new object count into the distribution table
 119  */
 120 void stat_add_distrib_tbl(distrib_tbl_t *tbl, const void *object, const counter_t *cnt)
 121 {
 122   distrib_entry_t *elem = distrib_get_entry(tbl, object);
 123
 124   cnt_add(&elem->cnt, cnt);
 125 }
 126
 127 /**
 128  * adds a new key count into the integer distribution table
 129  */
 130 void stat_add_int_distrib_tbl(distrib_tbl_t *tbl, int key, const counter_t *cnt)
 131 {
 132    stat_add_distrib_tbl(tbl, (const void *)key, cnt);
 133 }
 134
 135 /*
 136  * calculates the mean value of a distribution
 137  */
 138 double stat_calc_mean_distrib_tbl(distrib_tbl_t *tbl)
 139 {
 140   distrib_entry_t *entry;
 141   unsigned count;
 142   double sum;
 143
 144   if (tbl->int_dist) {
 145     /* integer distribution, need min, max */
 146     int min, max;
 147
 148     entry = pset_first(tbl->hash_map);
 149
 150     if (! entry)
 151       return 0.0;
 152
 153     min =
 154     max = (int)entry->object;
 155     sum = cnt_to_dbl(&entry->cnt);
 156
 157
 158     for (entry = pset_next(tbl->hash_map); entry; entry = pset_next(tbl->hash_map)) {
 159       int value = (int)entry->object;
 160
 161       if (value < min)
 162         min = value;
 163       if (value > max);
 164         max = value;
 165
 166       sum += cnt_to_dbl(&entry->cnt);
 167     }
 168     count = max - min + 1;
 169   }
 170   else {
 171     sum = 0.0;
 172     count = 0;
 173     for (entry = pset_first(tbl->hash_map); entry; entry = pset_next(tbl->hash_map)) {
 174       sum += cnt_to_dbl(&entry->cnt);
 175       ++count;
 176     }
 177   }
 178
 179   return count ? sum / (double)count : 0.0;
 180 }
 181
 182 /**
 183  * iterates over all entries in a distribution table
 184  */
 185 void stat_iterate_distrib_tbl(distrib_tbl_t *tbl, eval_distrib_entry_fun eval)
 186 {
 187   distrib_entry_t *entry;
 188
 189   for (entry = pset_first(tbl->hash_map); entry; entry = pset_next(tbl->hash_map)) {
 190     eval(entry);
 191   }
 192 }