include/hfta/hfta_udaf.h

   1 /* ------------------------------------------------
   2 Copyright 2014 AT&T Intellectual Property
   3    Licensed under the Apache License, Version 2.0 (the "License");
   4    you may not use this file except in compliance with the License.
   5    You may obtain a copy of the License at
   6
   7      http://www.apache.org/licenses/LICENSE-2.0
   8
   9    Unless required by applicable law or agreed to in writing, software
  10    distributed under the License is distributed on an "AS IS" BASIS,
  11    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12    See the License for the specific language governing permissions and
  13    limitations under the License.
  14  ------------------------------------------- */
  15
  16 #ifndef _HFTA_UDAF_H_INCLUDED_
  17 #define _HFTA_UDAF_H_INCLUDED_
  18
  19 #include "vstring.h"
  20 #include "host_tuple.h"
  21 #include "gsconfig.h"
  22
  23 // -------------------------------------------------------------------
  24 //              sum over 3 intervals : test rUDAF
  25 void sum3_HFTA_AGGR_INIT_(gs_sp_t buf) ;
  26 void sum3_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint32_t s) ;
  27 void sum3_HFTA_AGGR_OUTPUT_(gs_uint32_t *result, gs_sp_t buf) ;
  28 void sum3_HFTA_AGGR_DESTROY_(gs_sp_t buf) ;
  29 void sum3_HFTA_AGGR_REINIT_( gs_sp_t buf) ;
  30
  31
  32 // -------------------------------------------------------------------
  33 //              running sum over arbitrary intervals.
  34 void moving_sum_udaf_HFTA_AGGR_INIT_(gs_sp_t buf) ;
  35 void moving_sum_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint32_t s, gs_uint32_t N) ;
  36 void moving_sum_udaf_HFTA_AGGR_OUTPUT_(gs_uint64_t *result, gs_sp_t buf) ;
  37 void moving_sum_udaf_HFTA_AGGR_DESTROY_(gs_sp_t buf) ;
  38 void moving_sum_udaf_HFTA_AGGR_REINIT_( gs_sp_t buf) ;
  39
  40 #define super_moving_sum_udaf_HFTA_AGGR_INIT_ moving_sum_udaf_HFTA_AGGR_INIT_
  41 void super_moving_sum_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_uint64_t s) ;
  42 #define super_moving_sum_udaf_HFTA_AGGR_OUTPUT_ moving_sum_udaf_HFTA_AGGR_OUTPUT_
  43 #define super_moving_sum_udaf_HFTA_AGGR_DESTROY_ moving_sum_udaf_HFTA_AGGR_DESTROY_
  44 #define super_moving_sum_udaf_HFTA_AGGR_REINIT_ moving_sum_udaf_HFTA_AGGR_REINIT_
  45
  46 gs_uint32_t moving_sum_extract(gs_uint64_t result);
  47 gs_float_t moving_sum_extract_exp(gs_uint64_t result, gs_float_t alpha);
  48
  49
  50 /////////////////////////////////////////////////////////////////////////
  51 /////   Calculate the average of all positive float numbers
  52
  53 void POSAVG_HFTA_AGGR_INIT_(gs_sp_t buf);
  54 void POSAVG_HFTA_AGGR_UPDATE_(gs_sp_t buf, gs_float_t v);
  55 void POSAVG_HFTA_AGGR_OUTPUT_(gs_float_t * v, gs_sp_t buf);
  56 void POSAVG_HFTA_AGGR_DESTROY_(gs_sp_t buf);
  57
  58
  59 ///////////////////////////////////////////////////////////////////
  60 /////                   avg_udaf (simple example)
  61
  62 //              hfta avg_udaf
  63 void avg_udaf_HFTA_AGGR_INIT_(gs_sp_t b);
  64 void avg_udaf_HFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v);
  65 void avg_udaf_HFTA_AGGR_OUTPUT_(vstring *r,gs_sp_t b);
  66 void avg_udaf_HFTA_AGGR_DESTROY_(gs_sp_t b);
  67
  68 //              avg_udaf superaggregate
  69 void avg_udaf_hfta_HFTA_AGGR_INIT_(gs_sp_t b);
  70 void avg_udaf_hfta_HFTA_AGGR_UPDATE_(gs_sp_t b, vstring *v);
  71 void avg_udaf_hfta_HFTA_AGGR_OUTPUT_(vstring *r,gs_sp_t b);
  72 void avg_udaf_hfta_HFTA_AGGR_DESTROY_(gs_sp_t b);
  73
  74 //              Extraction function
  75 gs_float_t extr_avg_fcn(vstring *v);
  76
  77 //      first aggregate
  78 // hfta only
  79 void FIRST_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
  80 void FIRST_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
  81 void FIRST_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
  82 void FIRST_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
  83 void FIRST_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
  84
  85 void FIRST_HFTA_AGGR_INIT_(gs_int32_t* scratch);
  86 void FIRST_HFTA_AGGR_REINIT_(gs_int32_t* scratch);
  87 void FIRST_HFTA_AGGR_UPDATE_(gs_int32_t* scratch, gs_int32_t val);
  88 void FIRST_HFTA_AGGR_OUTPUT_(gs_int32_t* res, gs_int32_t* scratch);
  89 void FIRST_HFTA_AGGR_DESTROY_(gs_int32_t* scratch);
  90
  91 void FIRST_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
  92 void FIRST_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
  93 void FIRST_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
  94 void FIRST_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
  95 void FIRST_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
  96
  97 void FIRST_HFTA_AGGR_INIT_(gs_int64_t* scratch);
  98 void FIRST_HFTA_AGGR_REINIT_(gs_int64_t* scratch);
  99 void FIRST_HFTA_AGGR_UPDATE_(gs_int64_t* scratch, gs_int64_t val);
 100 void FIRST_HFTA_AGGR_OUTPUT_(gs_int64_t* res, gs_int64_t* scratch);
 101 void FIRST_HFTA_AGGR_DESTROY_(gs_int64_t* scratch);
 102
 103 void FIRST_HFTA_AGGR_INIT_(vstring* scratch);
 104 void FIRST_HFTA_AGGR_REINIT_(vstring* scratch);
 105 void FIRST_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
 106 void FIRST_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
 107 void FIRST_HFTA_AGGR_DESTROY_(vstring* scratch);
 108 // hfts-lfta split
 109 void FIRST_hfta_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
 110 void FIRST_hfta_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
 111 void FIRST_hfta_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
 112 void FIRST_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
 113 void FIRST_hfta_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
 114
 115 void FIRST_INT_hfta_HFTA_AGGR_INIT_(gs_int32_t* scratch);
 116 void FIRST_INT_hfta_HFTA_AGGR_REINIT_(gs_int32_t* scratch);
 117 void FIRST_INT_hfta_HFTA_AGGR_UPDATE_(gs_int32_t* scratch, gs_int32_t val);
 118 void FIRST_INT_hfta_HFTA_AGGR_OUTPUT_(gs_int32_t* res, gs_int32_t* scratch);
 119 void FIRST_INT_hfta_HFTA_AGGR_DESTROY_(gs_int32_t* scratch);
 120
 121 void FIRST_ULL_hfta_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
 122 void FIRST_ULL_hfta_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
 123 void FIRST_ULL_hfta_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
 124 void FIRST_ULL_hfta_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
 125 void FIRST_ULL_hfta_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
 126
 127 void FIRST_LL_hfta_HFTA_AGGR_INIT_(gs_int64_t* scratch);
 128 void FIRST_LL_hfta_HFTA_AGGR_REINIT_(gs_int64_t* scratch);
 129 void FIRST_LL_hfta_HFTA_AGGR_UPDATE_(gs_int64_t* scratch, gs_int64_t val);
 130 void FIRST_LL_hfta_HFTA_AGGR_OUTPUT_(gs_int64_t* res, gs_int64_t* scratch);
 131 void FIRST_LL_hfta_HFTA_AGGR_DESTROY_(gs_int64_t* scratch);
 132
 133 void FIRST_STR_hfta_HFTA_AGGR_INIT_(vstring* scratch);
 134 void FIRST_STR_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
 135 void FIRST_STR_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
 136 void FIRST_STR_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
 137 void FIRST_STR_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
 138
 139 //      last aggregate
 140 //  hfta only
 141 void LAST_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
 142 void LAST_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
 143 void LAST_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
 144 void LAST_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
 145 void LAST_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
 146
 147 void LAST_HFTA_AGGR_INIT_(gs_int32_t* scratch);
 148 void LAST_HFTA_AGGR_REINIT_(gs_int32_t* scratch);
 149 void LAST_HFTA_AGGR_UPDATE_(gs_int32_t* scratch, gs_int32_t val);
 150 void LAST_HFTA_AGGR_OUTPUT_(gs_int32_t* res, gs_int32_t* scratch);
 151 void LAST_HFTA_AGGR_DESTROY_(gs_int32_t* scratch);
 152
 153 void LAST_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
 154 void LAST_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
 155 void LAST_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
 156 void LAST_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
 157 void LAST_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
 158
 159 void LAST_HFTA_AGGR_INIT_(gs_int64_t* scratch);
 160 void LAST_HFTA_AGGR_REINIT_(gs_int64_t* scratch);
 161 void LAST_HFTA_AGGR_UPDATE_(gs_int64_t* scratch, gs_int64_t val);
 162 void LAST_HFTA_AGGR_OUTPUT_(gs_int64_t* res, gs_int64_t* scratch);
 163 void LAST_HFTA_AGGR_DESTROY_(gs_int64_t* scratch);
 164
 165 void LAST_HFTA_AGGR_INIT_(vstring* scratch);
 166 void LAST_HFTA_AGGR_REINIT_(vstring* scratch);
 167 void LAST_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
 168 void LAST_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
 169 void LAST_HFTA_AGGR_DESTROY_(vstring* scratch);
 170
 171
 172 // hfta/lfta split
 173 void LAST_hfta_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
 174 void LAST_hfta_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
 175 void LAST_hfta_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
 176 void LAST_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
 177 void LAST_hfta_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
 178
 179 void LAST_INT_hfta_HFTA_AGGR_INIT_(gs_int32_t* scratch);
 180 void LAST_INT_hfta_HFTA_AGGR_REINIT_(gs_int32_t* scratch);
 181 void LAST_INT_hfta_HFTA_AGGR_UPDATE_(gs_int32_t* scratch, gs_int32_t val);
 182 void LAST_INT_hfta_HFTA_AGGR_OUTPUT_(gs_int32_t* res, gs_int32_t* scratch);
 183 void LAST_INT_hfta_HFTA_AGGR_DESTROY_(gs_int32_t* scratch);
 184
 185 void LAST_ULL_hfta_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
 186 void LAST_ULL_hfta_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
 187 void LAST_ULL_hfta_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
 188 void LAST_ULL_hfta_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
 189 void LAST_ULL_hfta_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
 190
 191 void LAST_LL_hfta_HFTA_AGGR_INIT_(gs_int64_t* scratch);
 192 void LAST_LL_hfta_HFTA_AGGR_REINIT_(gs_int64_t* scratch);
 193 void LAST_LL_hfta_HFTA_AGGR_UPDATE_(gs_int64_t* scratch, gs_int64_t val);
 194 void LAST_LL_hfta_HFTA_AGGR_OUTPUT_(gs_int64_t* res, gs_int64_t* scratch);
 195 void LAST_LL_hfta_HFTA_AGGR_DESTROY_(gs_int64_t* scratch);
 196
 197 void LAST_STR_hfta_HFTA_AGGR_INIT_(vstring* scratch);
 198 void LAST_STR_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
 199 void LAST_STR_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
 200 void LAST_STR_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
 201 void LAST_STR_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
 202
 203 ///////////////////////////////////////////////////////////////
 204 //      count_diff aggregate
 205 ///////////////////////////////////////////////////////////////
 206
 207 void count_diff_HFTA_AGGR_INIT_(gs_sp_t scratch);
 208 void count_diff_HFTA_AGGR_REINIT_(gs_sp_t scratch);
 209 void count_diff_HFTA_AGGR_UPDATE_(gs_sp_t scratch, gs_uint32_t val);
 210 void count_diff_HFTA_AGGR_UPDATE_(gs_sp_t scratch, gs_int32_t val);
 211 void count_diff_HFTA_AGGR_UPDATE_(gs_sp_t scratch, gs_uint64_t val);
 212 void count_diff_HFTA_AGGR_UPDATE_(gs_sp_t scratch, gs_int64_t val);
 213 void count_diff_HFTA_AGGR_UPDATE_(gs_sp_t scratch, vstring *val);
 214 void count_diff_HFTA_AGGR_OUTPUT_(gs_uint32_t *res, gs_sp_t scratch);
 215 void count_diff_HFTA_AGGR_DESTROY_(gs_sp_t scratch);
 216
 217 void count_diff_hfta_HFTA_AGGR_INIT_(gs_sp_t s);
 218 void count_diff_hfta_HFTA_AGGR_REINIT_(gs_sp_t s);
 219 void count_diff_hfta_HFTA_AGGR_UPDATE_(gs_sp_t s, vstring *val);
 220 void count_diff_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t *res, gs_sp_t s);
 221 void count_diff_hfta_HFTA_AGGR_DESTROY_(gs_sp_t scratch);
 222
 223 //////////////////////////////////////////////
 224 //      CAT_aggr, aggregate strings by catenation
 225 //////////////////////////////////////////////
 226 void CAT_aggr_HFTA_AGGR_INIT_(gs_sp_t s);
 227 void CAT_aggr_HFTA_AGGR_REINIT_(gs_sp_t s);
 228 void CAT_aggr_HFTA_AGGR_UPDATE_(gs_sp_t s, vstring *sep, vstring *str);
 229 void CAT_aggr_HFTA_AGGR_OUTPUT_(vstring *res, gs_sp_t s);
 230 void CAT_aggr_HFTA_AGGR_DESTROY_(gs_sp_t s);
 231
 232 /////////////////////////////////////////////////////////
 233 //      time-averaged sum, from aperiodic reports
 234 ////////////////////////////////////////////////////////
 235
 236 void time_avg_HFTA_AGGR_INIT_(gs_sp_t s);
 237 void time_avg_HFTA_AGGR_DESTROY_(gs_sp_t s);
 238 void time_avg_HFTA_AGGR_REINIT_(gs_sp_t s);
 239 void time_avg_HFTA_AGGR_OUTPUT_(gs_float_t *result, gs_sp_t s);
 240 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_float_t val, gs_int64_t ts, gs_int64_t window);
 241 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint32_t val, gs_int64_t ts, gs_int64_t window);
 242 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int32_t val, gs_int64_t ts, gs_int64_t window);
 243 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint64_t val, gs_int64_t ts, gs_int64_t window);
 244 void time_avg_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int64_t val, gs_int64_t ts, gs_int64_t window);
 245
 246 // ------------------------------------------------------------
 247 //              running_sum_max : get the running sum of an int,
 248 //              be able to report this sum and also its max value
 249 //              during the time window
 250 // ------------------------------------------------------------
 251
 252 void run_sum_max_HFTA_AGGR_INIT_(gs_sp_t s);
 253 void run_sum_max_HFTA_AGGR_REINIT_(gs_sp_t s);
 254 void run_sum_max_HFTA_AGGR_OUTPUT_(vstring *r,gs_sp_t b);
 255 void run_sum_max_HFTA_AGGR_DESTROY_(gs_sp_t b);
 256 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint64_t v);
 257 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int64_t v);
 258 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_uint32_t v);
 259 void run_sum_max_HFTA_AGGR_UPDATE_(gs_sp_t s, gs_int32_t v);
 260 gs_int64_t extr_running_sum(vstring *v);
 261 gs_int64_t extr_running_sum_max(vstring *v);
 262
 263
 264
 265
 266 ///////////////////////////////////////////////////////////////
 267 //              running_array_aggr aggregate
 268 ///////////////////////////////////////////////////////////////
 269 void running_array_aggr_hfta_HFTA_AGGR_INIT_(vstring* scratch);
 270 void running_array_aggr_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
 271 void running_array_aggr_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
 272 void running_array_aggr_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
 273 void running_array_aggr_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
 274
 275 ////////////////////////////////////////////////////////////////
 276 ///             Flip's sample-based quantiles
 277
 278 /****************************************************************/
 279 /* HFTA functions                                               */
 280 /****************************************************************/
 281
 282 void quant_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t);
 283 void quant_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t, vstring *);
 284 void quant_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *, gs_sp_t);
 285 void quant_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t);
 286 gs_uint32_t extr_quant_hfta3_fcn(vstring *, gs_float_t);
 287 gs_uint32_t extr_med_hfta3_fcn(vstring *);
 288 gs_uint32_t extr_quant_hfta3_space(vstring *);
 289
 290 /****************************************************************/
 291 /* HFTA-only functions                                          */
 292 /****************************************************************/
 293 void quant_udaf_hfta0_HFTA_AGGR_INIT_(gs_sp_t);
 294 void quant_udaf_hfta0_HFTA_AGGR_UPDATE_(gs_sp_t, gs_uint32_t);
 295 void quant_udaf_hfta0_HFTA_AGGR_OUTPUT_(vstring *, gs_sp_t);
 296 void quant_udaf_hfta0_HFTA_AGGR_DESTROY_(gs_sp_t);
 297 gs_uint32_t extr_quant_hfta0_fcn(vstring *, gs_float_t);
 298 gs_uint32_t extr_med_hfta0_fcn(vstring *);
 299 gs_uint32_t extr_quant_hfta0_space(vstring *);
 300
 301
 302 /****************************************************************/
 303 //              Approximate count distinct.
 304 //              Rely on the minhashing approach.
 305 //              Currently HFTA-only
 306 //              Uses a 32-bit hash, tested up to 100,000,000 elements
 307 //              and it gave good results (within 7%)
 308 /****************************************************************/
 309
 310 // ---------------------------------------------
 311 //      HFTA-only
 312 void approx_count_distinct_udaf_HFTA_AGGR_INIT_(gs_sp_t buf);
 313 void approx_count_distinct_udaf_HFTA_AGGR_REINIT_(gs_sp_t buf);
 314 void approx_count_distinct_udaf_HFTA_AGGR_DESTROY_(gs_sp_t buf);
 315 void approx_count_distinct_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, vstring *val);
 316 void approx_count_distinct_udaf_HFTA_AGGR_OUTPUT_(vstring *res, gs_sp_t buf);
 317
 318 void running_approx_count_distinct_udaf_HFTA_AGGR_INIT_(gs_sp_t buf);
 319 void running_approx_count_distinct_udaf_HFTA_AGGR_REINIT_(gs_sp_t buf);
 320 void running_approx_count_distinct_udaf_HFTA_AGGR_DESTROY_(gs_sp_t buf);
 321 void running_approx_count_distinct_udaf_HFTA_AGGR_UPDATE_(gs_sp_t buf, vstring *val);
 322 void running_approx_count_distinct_udaf_HFTA_AGGR_OUTPUT_(vstring *res, gs_sp_t buf);
 323
 324 gs_float_t extr_approx_count_distinct(vstring *v);
 325
 326
 327
 328 #endif