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_ULL_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
  86 void FIRST_ULL_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
  87 void FIRST_ULL_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
  88 void FIRST_ULL_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
  89 void FIRST_ULL_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
  90
  91 void FIRST_STR_HFTA_AGGR_INIT_(vstring* scratch);
  92 void FIRST_STR_HFTA_AGGR_REINIT_(vstring* scratch);
  93 void FIRST_STR_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
  94 void FIRST_STR_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
  95 void FIRST_STR_HFTA_AGGR_DESTROY_(vstring* scratch);
  96 // hfts-lfta split
  97 void FIRST_hfta_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
  98 void FIRST_hfta_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
  99 void FIRST_hfta_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
 100 void FIRST_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
 101 void FIRST_hfta_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
 102
 103 void FIRST_ULL_hfta_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
 104 void FIRST_ULL_hfta_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
 105 void FIRST_ULL_hfta_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
 106 void FIRST_ULL_hfta_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
 107 void FIRST_ULL_hfta_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
 108
 109 void FIRST_STR_hfta_HFTA_AGGR_INIT_(vstring* scratch);
 110 void FIRST_STR_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
 111 void FIRST_STR_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
 112 void FIRST_STR_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
 113 void FIRST_STR_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
 114
 115 //      last aggregate
 116 //  hfta only
 117 void LAST_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
 118 void LAST_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
 119 void LAST_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
 120 void LAST_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
 121 void LAST_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
 122
 123 void LAST_ULL_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
 124 void LAST_ULL_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
 125 void LAST_ULL_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
 126 void LAST_ULL_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
 127 void LAST_ULL_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
 128
 129 void LAST_STR_HFTA_AGGR_INIT_(vstring* scratch);
 130 void LAST_STR_HFTA_AGGR_REINIT_(vstring* scratch);
 131 void LAST_STR_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
 132 void LAST_STR_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
 133 void LAST_STR_HFTA_AGGR_DESTROY_(vstring* scratch);
 134
 135 // hfta/lfta split
 136 void LAST_hfta_HFTA_AGGR_INIT_(gs_uint32_t* scratch);
 137 void LAST_hfta_HFTA_AGGR_REINIT_(gs_uint32_t* scratch);
 138 void LAST_hfta_HFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val);
 139 void LAST_hfta_HFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch);
 140 void LAST_hfta_HFTA_AGGR_DESTROY_(gs_uint32_t* scratch);
 141
 142 void LAST_ULL_hfta_HFTA_AGGR_INIT_(gs_uint64_t* scratch);
 143 void LAST_ULL_hfta_HFTA_AGGR_REINIT_(gs_uint64_t* scratch);
 144 void LAST_ULL_hfta_HFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val);
 145 void LAST_ULL_hfta_HFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch);
 146 void LAST_ULL_hfta_HFTA_AGGR_DESTROY_(gs_uint64_t* scratch);
 147
 148 void LAST_STR_hfta_HFTA_AGGR_INIT_(vstring* scratch);
 149 void LAST_STR_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
 150 void LAST_STR_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
 151 void LAST_STR_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
 152 void LAST_STR_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
 153
 154 //              running_array_aggr aggregate
 155 void running_array_aggr_hfta_HFTA_AGGR_INIT_(vstring* scratch);
 156 void running_array_aggr_hfta_HFTA_AGGR_REINIT_(vstring* scratch);
 157 void running_array_aggr_hfta_HFTA_AGGR_UPDATE_(vstring* scratch, vstring* val);
 158 void running_array_aggr_hfta_HFTA_AGGR_OUTPUT_(vstring* res, vstring* scratch);
 159 void running_array_aggr_hfta_HFTA_AGGR_DESTROY_(vstring* scratch);
 160
 161 ////////////////////////////////////////////////////////////////
 162 ///             Flip's sample-based quantiles
 163
 164 /****************************************************************/
 165 /* HFTA functions                                               */
 166 /****************************************************************/
 167
 168 void quant_udaf_hfta3_HFTA_AGGR_INIT_(gs_sp_t);
 169 void quant_udaf_hfta3_HFTA_AGGR_UPDATE_(gs_sp_t, vstring *);
 170 void quant_udaf_hfta3_HFTA_AGGR_OUTPUT_(vstring *, gs_sp_t);
 171 void quant_udaf_hfta3_HFTA_AGGR_DESTROY_(gs_sp_t);
 172 gs_uint32_t extr_quant_hfta3_fcn(vstring *, gs_float_t);
 173 gs_uint32_t extr_med_hfta3_fcn(vstring *);
 174 gs_uint32_t extr_quant_hfta3_space(vstring *);
 175
 176 /****************************************************************/
 177 /* HFTA-only functions                                          */
 178 /****************************************************************/
 179 void quant_udaf_hfta0_HFTA_AGGR_INIT_(gs_sp_t);
 180 void quant_udaf_hfta0_HFTA_AGGR_UPDATE_(gs_sp_t, gs_uint32_t);
 181 void quant_udaf_hfta0_HFTA_AGGR_OUTPUT_(vstring *, gs_sp_t);
 182 void quant_udaf_hfta0_HFTA_AGGR_DESTROY_(gs_sp_t);
 183 gs_uint32_t extr_quant_hfta0_fcn(vstring *, gs_float_t);
 184 gs_uint32_t extr_med_hfta0_fcn(vstring *);
 185 gs_uint32_t extr_quant_hfta0_space(vstring *);
 186
 187 #endif