Keep input type when computing averages (#643)

Author: daboehme

include/caliper/common/Variant.h

@@ -88,6 +88,7 @@ class Variant
 
     Variant& min(const Variant& val);
     Variant& max(const Variant& val);
+    Variant  div(unsigned count);
 
     static void update_minmaxsum(const Variant& val, Variant& min_val, Variant& max_val, Variant& sum_val);
 

src/common/Variant.cpp

@@ -302,6 +302,24 @@ Variant& Variant::max(const Variant& val)
     return *this;
 }
 
+Variant Variant::div(unsigned count)
+{
+    cali_attr_type type = this->type();
+
+    switch (type) {
+    case CALI_TYPE_DOUBLE:
+        return Variant(m_v.value.v_double / static_cast<double>(count));
+    case CALI_TYPE_INT:
+        return Variant(cali_make_variant_from_int64(m_v.value.v_int / static_cast<int64_t>(count)));
+    case CALI_TYPE_UINT:
+        return Variant(cali_make_variant_from_uint(m_v.value.v_uint / count));
+    default:
+        break;
+    }
+
+    return Variant();
+}
+
 void Variant::update_minmaxsum(const Variant& val, Variant& min_val, Variant& max_val, Variant& sum_val)
 {
     if (min_val.empty()) {

src/reader/Aggregator.cpp

@@ -646,11 +646,11 @@ class AvgKernel : public AggregateKernel
 
             int prop = CALI_ATTR_SKIP_EVENTS | CALI_ATTR_ASVALUE;
 
-            m_stat_attrs.avg = db.create_attribute("avg#" + m_target_attr_name, CALI_TYPE_DOUBLE, prop);
+            m_stat_attrs.avg = db.create_attribute("avg#" + m_target_attr_name, m_target_attr.type(), prop);
             m_stat_attrs.count =
                 db.create_attribute("avg.count#" + m_target_attr_name, CALI_TYPE_UINT, prop | CALI_ATTR_HIDDEN);
             m_stat_attrs.sum =
-                db.create_attribute("avg.sum#" + m_target_attr_name, CALI_TYPE_DOUBLE, prop | CALI_ATTR_HIDDEN);
+                db.create_attribute("avg.sum#" + m_target_attr_name, m_target_attr.type(), prop | CALI_ATTR_HIDDEN);
 
             a = m_stat_attrs;
             return true;
@@ -663,7 +663,7 @@ class AvgKernel : public AggregateKernel
         static AggregateKernelConfig* create(const std::vector<std::string>& cfg) { return new Config(cfg.front()); }
     };
 
-    AvgKernel(Config* config) : m_count(0), m_sum(0.0), m_config(config) {}
+    AvgKernel(Config* config) : m_count(0), m_config(config) {}
 
     const AggregateKernelConfig* config() { return m_config; }
 
@@ -679,10 +679,10 @@ class AvgKernel : public AggregateKernel
 
         for (const Entry& e : list) {
             if (e.attribute() == target_attr.id()) {
-                m_sum += e.value().to_double();
+                m_sum += e.value();
                 ++m_count;
             } else if (e.attribute() == stat_attr.sum.id()) {
-                m_sum += e.value().to_double();
+                m_sum += e.value();
             } else if (e.attribute() == stat_attr.count.id()) {
                 m_count += e.value().to_uint();
             }
@@ -697,16 +697,16 @@ class AvgKernel : public AggregateKernel
             if (!m_config->get_statistics_attributes(db, stat_attr))
                 return;
 
-            list.push_back(Entry(stat_attr.avg, Variant(m_sum / m_count)));
-            list.push_back(Entry(stat_attr.sum, Variant(m_sum)));
+            list.push_back(Entry(stat_attr.avg, m_sum.div(m_count)));
+            list.push_back(Entry(stat_attr.sum, m_sum));
             list.push_back(Entry(stat_attr.count, Variant(cali_make_variant_from_uint(m_count))));
         }
     }
 
 private:
 
     unsigned m_count;
-    double   m_sum;
+    Variant  m_sum;
 
     std::mutex m_lock;
 

src/reader/test/test_aggregator.cpp

@@ -723,7 +723,7 @@ TEST(AggregatorTest, StatisticsKernels)
 
     EXPECT_EQ(dict[attr_min.id()].value().to_int(), -4);
     EXPECT_EQ(dict[attr_max.id()].value().to_int(), 36);
-    EXPECT_DOUBLE_EQ(dict[attr_avg.id()].value().to_double(), 16.5);
+    EXPECT_EQ(dict[attr_avg.id()].value().to_int(), 16);
     EXPECT_DOUBLE_EQ(dict[attr_var.id()].value().to_double(), 2018.0 / 4.0 - (16.5 * 16.5));
 }
 

src/services/aggregate/Aggregate.cpp

@@ -116,7 +116,7 @@ class Aggregate
         res.min_attr = c->create_attribute(std::string("min#") + name, type, prop);
         res.max_attr = c->create_attribute(std::string("max#") + name, type, prop);
         res.sum_attr = c->create_attribute(std::string("sum#") + name, type, prop);
-        res.avg_attr = c->create_attribute(std::string("avg#") + name, CALI_TYPE_DOUBLE, prop);
+        res.avg_attr = c->create_attribute(std::string("avg#") + name, type, prop);
 #ifdef CALIPER_ENABLE_HISTOGRAMS
         for (int jj = 0; jj < CALI_AGG_HISTOGRAM_BINS; jj++) {
             res.histogram_attr[jj] = c->create_attribute(

src/services/aggregate/AggregationDB.cpp

@@ -286,12 +286,10 @@ struct AggregationDB::AggregationDBImpl {
                 if (k->count == 0)
                     continue;
 
-                double avg = k->sum.to_double() / k->count;
-
-                rec.push_back(Entry(info.result_attrs[a].min_attr, Variant(k->min)));
-                rec.push_back(Entry(info.result_attrs[a].max_attr, Variant(k->max)));
-                rec.push_back(Entry(info.result_attrs[a].sum_attr, Variant(k->sum)));
-                rec.push_back(Entry(info.result_attrs[a].avg_attr, Variant(avg)));
+                rec.push_back(Entry(info.result_attrs[a].min_attr, k->min));
+                rec.push_back(Entry(info.result_attrs[a].max_attr, k->max));
+                rec.push_back(Entry(info.result_attrs[a].sum_attr, k->sum));
+                rec.push_back(Entry(info.result_attrs[a].avg_attr, k->sum.div(k->count)));
 #ifdef CALIPER_ENABLE_HISTOGRAMS
                 for (int ii = 0; ii < CALI_AGG_HISTOGRAM_BINS; ii++) {
                     rec.push_back(Entry(