src/lib/gscplftaaux/rts_udaf.c

   1 /* ------------------------------------------------\r
   2 Copyright 2014 AT&T Intellectual Property\r
   3    Licensed under the Apache License, Version 2.0 (the "License");\r
   4    you may not use this file except in compliance with the License.\r
   5    You may obtain a copy of the License at\r
   6 \r
   7      http://www.apache.org/licenses/LICENSE-2.0\r
   8 \r
   9    Unless required by applicable law or agreed to in writing, software\r
  10    distributed under the License is distributed on an "AS IS" BASIS,\r
  11    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  12    See the License for the specific language governing permissions and\r
  13    limitations under the License.\r
  14  ------------------------------------------- */\r
  15 \r
  16 #include "rts_udaf.h"\r
  17 #include "gsconfig.h"\r
  18 #include "gstypes.h"\r
  19 #include <stdio.h>\r
  20 #include <limits.h>\r
  21 #include <math.h>\r
  22 \r
  23 \r
  24 #define max(a,b) ((a) > (b) ? (a) : (b))\r
  25 #define MAX_BUFSIZE     128\r
  26 \r
  27 \r
  28 /****************************************************************/\r
  29 /* LFTA functions                                               */\r
  30 /****************************************************************/\r
  31 \r
  32 \r
  33 ////////////////////////////////////////////////////////////////////////\r
  34 ////            avg_udaf\r
  35 \r
  36 typedef struct avg_udaf_lfta_struct_t{\r
  37         gs_int64_t sum;\r
  38         gs_uint32_t cnt;\r
  39 } avg_udaf_lfta_struct_t;\r
  40 \r
  41 void avg_udaf_lfta_LFTA_AGGR_INIT_(gs_sp_t b){\r
  42         avg_udaf_lfta_struct_t *s = (avg_udaf_lfta_struct_t *)b;\r
  43         s->sum = 0;\r
  44         s->cnt = 0;\r
  45 }\r
  46 \r
  47 void avg_udaf_lfta_LFTA_AGGR_UPDATE_(gs_sp_t  b,gs_uint32_t v){\r
  48         avg_udaf_lfta_struct_t *s = (avg_udaf_lfta_struct_t *)b;\r
  49         s->sum += v;\r
  50         s->cnt++;\r
  51 }\r
  52 \r
  53 gs_retval_t avg_udaf_lfta_LFTA_AGGR_FLUSHME_(gs_sp_t b){\r
  54         return 0;\r
  55 }\r
  56 \r
  57 void avg_udaf_lfta_LFTA_AGGR_OUTPUT_(struct gs_string *r,gs_sp_t b){\r
  58         r->length = 12;\r
  59         r->data = b;\r
  60 }\r
  61 \r
  62 void avg_udaf_lfta_LFTA_AGGR_DESTROY_(gs_sp_t b){\r
  63         return;\r
  64 }\r
  65 \r
  66 /////////////////////////////////////////////////////////\r
  67 //              Moving sum\r
  68 \r
  69 typedef struct moving_sum_lfta_struct{\r
  70         gs_uint32_t sum;\r
  71         gs_uint32_t N;\r
  72 } moving_sum_lfta_struct;\r
  73 \r
  74 void moving_sum_lfta_LFTA_AGGR_INIT_(gs_sp_t b){\r
  75         moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b;\r
  76         s->sum = 0;\r
  77         s->N = 0;\r
  78 }\r
  79 \r
  80 void moving_sum_lfta_LFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v, gs_uint32_t N){\r
  81         moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b;\r
  82         s->sum += v;\r
  83         s->N = N;\r
  84 }\r
  85         \r
  86 gs_retval_t moving_sum_lfta_LFTA_AGGR_FLUSHME_(gs_sp_t b){\r
  87         return 0;\r
  88 }\r
  89 \r
  90 void moving_sum_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t *r, gs_sp_t b){\r
  91         moving_sum_lfta_struct *s = (moving_sum_lfta_struct *)b;\r
  92         *r = ((gs_uint64_t)(s->N) << 32) | (gs_uint64_t)(s->sum);\r
  93 }\r
  94 \r
  95 gs_retval_t moving_sum_lfta_LFTA_AGGR_DESTROY_(gs_sp_t b){\r
  96         return 0;\r
  97 }\r
  98 \r
  99 /////////////////////////////////////////////////////////\r
 100 //              FIRST and LAST aggregates\r
 101 \r
 102 void FIRST_lfta_LFTA_AGGR_INIT_(gs_uint32_t* scratch) {\r
 103         *scratch = UINT_MAX;            // we will encode uninitialized value of UINT_MAX\r
 104         return;\r
 105 }\r
 106 \r
 107 void FIRST_lfta_LFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val) {\r
 108         if (*scratch == UINT_MAX)\r
 109                 *scratch = val;\r
 110         return;\r
 111 }\r
 112 \r
 113 gs_retval_t FIRST_lfta_LFTA_AGGR_FLUSHME_( gs_uint32_t* scratch) { return 0; }\r
 114 \r
 115 void FIRST_lfta_LFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch) {\r
 116         *res = *scratch;\r
 117 }\r
 118 \r
 119 void FIRST_lfta_LFTA_AGGR_DESTROY_(gs_uint32_t* scratch) { return; }\r
 120 \r
 121 void FIRST_ULL_lfta_LFTA_AGGR_INIT_(gs_uint64_t* scratch) {\r
 122         *scratch = ULLONG_MAX;          // we will encode uninitialized value of ULLONG_MAX\r
 123         return;\r
 124 }\r
 125 \r
 126 void FIRST_ULL_lfta_LFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val) {\r
 127         if (*scratch == ULLONG_MAX)\r
 128                 *scratch = val;\r
 129         return;\r
 130 }\r
 131 \r
 132 gs_retval_t FIRST_ULL_lfta_LFTA_AGGR_FLUSHME_( gs_uint64_t* scratch) { return 0; }\r
 133 \r
 134 void FIRST_ULL_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch) {\r
 135         *res = *scratch;\r
 136 }\r
 137 \r
 138 void FIRST_ULL_lfta_LFTA_AGGR_DESTROY_(gs_uint64_t* scratch) { return; }\r
 139 \r
 140 \r
 141 \r
 142 void FIRST_STR_lfta_LFTA_AGGR_INIT_(struct gs_string* scratch) {\r
 143         scratch->data = NULL;\r
 144         return;\r
 145 }\r
 146 \r
 147 void FIRST_STR_lfta_LFTA_AGGR_UPDATE_(struct gs_string* scratch, struct gs_string* val) {\r
 148         if (!scratch->data) {\r
 149                 str_assign_with_copy(NULL, scratch, val);\r
 150         }\r
 151         return;\r
 152 }\r
 153 \r
 154 gs_retval_t FIRST_STR_lfta_LFTA_AGGR_FLUSHME_(struct gs_string* scratch) { return 0; }\r
 155 \r
 156 void FIRST_STR_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, struct gs_string* scratch) {\r
 157         *res = *scratch;\r
 158 }\r
 159 \r
 160 void FIRST_STR_lfta_LFTA_AGGR_DESTROY_(struct gs_string* scratch) { \r
 161         if (scratch->data) \r
 162                 fta_free(NULL, scratch->data);\r
 163 }\r
 164 \r
 165 void LAST_lfta_LFTA_AGGR_INIT_(gs_uint32_t* scratch) { }\r
 166 \r
 167 void LAST_lfta_LFTA_AGGR_UPDATE_(gs_uint32_t* scratch, gs_uint32_t val) {\r
 168         *scratch = val;\r
 169         return;\r
 170 }\r
 171 \r
 172 gs_retval_t LAST_lfta_LFTA_AGGR_FLUSHME_( gs_uint32_t* scratch) { return 0; }\r
 173 \r
 174 void LAST_lfta_LFTA_AGGR_OUTPUT_(gs_uint32_t* res, gs_uint32_t* scratch) {\r
 175         *res = *scratch;\r
 176 }\r
 177 \r
 178 void LAST_lfta_LFTA_AGGR_DESTROY_(gs_uint32_t* scratch) { return; }\r
 179 \r
 180 void LAST_ULL_lfta_LFTA_AGGR_INIT_(gs_uint64_t* scratch) { }\r
 181 \r
 182 void LAST_ULL_lfta_LFTA_AGGR_UPDATE_(gs_uint64_t* scratch, gs_uint64_t val) {\r
 183         *scratch = val;\r
 184         return;\r
 185 }\r
 186 \r
 187 gs_retval_t LAST_ULL_lfta_LFTA_AGGR_FLUSHME_( gs_uint64_t* scratch) { return 0; }\r
 188 \r
 189 void LAST_ULL_lfta_LFTA_AGGR_OUTPUT_(gs_uint64_t* res, gs_uint64_t* scratch) {\r
 190         *res = *scratch;\r
 191 }\r
 192 \r
 193 void LAST_ULL_lfta_LFTA_AGGR_DESTROY_(gs_uint64_t* scratch) { return; }\r
 194 \r
 195 \r
 196 \r
 197 void LAST_STR_lfta_LFTA_AGGR_INIT_(struct gs_string* scratch) {\r
 198         scratch->data = NULL;\r
 199         return;\r
 200 }\r
 201 \r
 202 void LAST_STR_lfta_LFTA_AGGR_UPDATE_(struct gs_string* scratch, struct gs_string* val) {\r
 203         if (!scratch->data) {\r
 204                 str_assign_with_copy(NULL, scratch, val);\r
 205         } else {\r
 206                 if (!str_compare(scratch, val)) {\r
 207                         fta_free(NULL, scratch->data);\r
 208                         str_assign_with_copy(NULL, scratch, val);\r
 209                 }\r
 210         }\r
 211         return;\r
 212 }\r
 213 \r
 214 gs_retval_t LAST_STR_lfta_LFTA_AGGR_FLUSHME_(struct gs_string* scratch) { return 0; }\r
 215 \r
 216 void LAST_STR_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, struct gs_string* scratch) {\r
 217         *res = *scratch;\r
 218 }\r
 219 \r
 220 void LAST_STR_lfta_LFTA_AGGR_DESTROY_(struct gs_string* scratch) { \r
 221         if (scratch->data) \r
 222                 fta_free(NULL, scratch->data);\r
 223 }\r
 224 \r
 225 \r
 226 /////////////////////////////////////////////////////////\r
 227 //              running_array_aggr aggregate\r
 228 \r
 229 struct running_array_aggr_str{\r
 230         gs_uint32_t num_list[4];\r
 231         gs_uint8_t n_num;\r
 232 };\r
 233 \r
 234 void running_array_aggr_lfta_LFTA_AGGR_INIT_(char* scratch) {\r
 235         struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch;\r
 236         aggr->n_num = 0;\r
 237 }\r
 238 \r
 239 void running_array_aggr_lfta_LFTA_AGGR_UPDATE_(char* scratch, gs_uint32_t val) {\r
 240         struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch;\r
 241         aggr->num_list[aggr->n_num++] = val;\r
 242 }\r
 243 \r
 244 gs_retval_t running_array_aggr_lfta_LFTA_AGGR_FLUSHME_(char* scratch) {\r
 245         struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch;\r
 246         return (aggr->n_num == 4);\r
 247 }\r
 248 void running_array_aggr_lfta_LFTA_AGGR_OUTPUT_(struct gs_string* res, char* scratch) {\r
 249         struct running_array_aggr_str* aggr = (struct running_array_aggr_str*)scratch;  \r
 250         res->data = scratch;\r
 251         res->length = aggr->n_num * sizeof(gs_uint32_t);\r
 252         res->owner = NULL;\r
 253 }\r
 254 \r
 255 void running_array_aggr_lfta_LFTA_AGGR_DESTROY_(char* scratch) { }\r
 256 \r