src/lib/gscplftaaux/flip_udaf.cc

   1 #include <stdio.h>
   2 #include <limits.h>
   3 #include <math.h>
   4 #include "rts_udaf.h"
   5 #include "gsconfig.h"
   6 #include "gstypes.h"
   7
   8
   9 #include "udaf_common.h"
  10
  11
  12 /*      Full size
  13 //      NOTE: does not seem to be stable or correct with this setting
  14 //              compress only activates with this one, so compress is broken?
  15 #define QUANT_LFTA1_SIZE 729
  16 #define QUANT_LFTA2_SIZE 181
  17 #define QUANT_LFTA3_SIZE 100
  18 */
  19
  20 /*      half size
  21 */
  22 // #define QUANT_LFTA1_SIZE 378
  23 // #define QUANT_LFTA2_SIZE 93
  24 // #define QUANT_LFTA3_SIZE 50
  25
  26 /*      quarter size
  27 #define QUANT_LFTA1_SIZE 202
  28 #define QUANT_LFTA2_SIZE 49
  29 #define QUANT_LFTA3_SIZE 25
  30 */
  31
  32
  33 // #define QUANT_EPS 0.01
  34 // #define SKIPDIR_SIZE 100
  35 // #define SKIPDIR_HEIGHT_MAX 7
  36 //#define max(a,b) ((a) > (b) ? (a) : (b))
  37
  38 #define COMPRESSED_XFER
  39
  40 /****************************************************************/
  41 /* Data Structures                                              */
  42 /****************************************************************/
  43 template <class T> struct tuple_t {
  44         T val;
  45         gs_uint32_t gap;
  46         gs_uint32_t del;
  47         gs_uint32_t next;
  48 };
  49
  50 // For skip list
  51
  52 template <class T> struct skipnode_t {
  53         T val;
  54         gs_uint32_t next;
  55         gs_uint32_t down;
  56 };
  57
  58 template <class T>  struct skipdir_t {
  59         gs_uint32_t height;                             // height of tree
  60         gs_uint32_t freeptr;                            // cursor space stack
  61         gs_uint32_t headptr[SKIPDIR_HEIGHT_MAX+1];      // ptrs to levels
  62         skipnode_t<T> list[SKIPDIR_SIZE+1];
  63 } ;
  64
  65
  66 /****************************************************************/
  67
  68 // fstring(5+(QUANT_LFTA3_SIZE+1)*4 +
  69 //         (2+lg(QUANT_LFTA3_SIZE)+(QUANT_LFTA3_SIZE+1)*3)*4)
  70 template <class T> struct quant_udaf_lfta3_struct_t {
  71         gs_uint32_t nelts;      // # stream elements
  72         gs_uint32_t freeptr;    // ptr to cursor stack
  73         gs_uint32_t usedptr;    // ptr to allocated memory
  74         gs_uint32_t circptr;    // circulating ptr used for compression
  75         gs_uint32_t size;
  76         tuple_t<T> t[QUANT_LFTA3_SIZE+1];       // samples + auxiliary info
  77         skipdir_t<T> sd;                // directory for searching tuples
  78 } ;
  79
  80 /****************************************************************/
  81 /* Skip List Functions                                          */
  82 /****************************************************************/
  83
  84 // Skip list cursor stack operations
  85 template <class T> gs_uint32_t skipdir_alloc(skipdir_t<T> *sd)
  86 {
  87         gs_uint32_t ptr = sd->freeptr;
  88         if (sd->freeptr != 0)
  89                 sd->freeptr = sd->list[ptr].next;
  90 //printf("skipdir_alloc %d\n",ptr);
  91         return ptr;
  92 }
  93
  94 template <class T> void skipdir_free(skipdir_t<T> *sd, gs_uint32_t ptr)
  95 {
  96         sd->list[ptr].val = 0;
  97         sd->list[ptr].down = 0;
  98         sd->list[ptr].next = sd->freeptr;
  99         sd->freeptr = ptr;
 100 //printf("skipdir_free %d\n",ptr);
 101 }
 102
 103
 104 template <class T> void skipdir_create(skipdir_t<T> *sd)
 105 {
 106         gs_int32_t i;
 107
 108         sd->height = 0;
 109         sd->freeptr = 1;
 110         for (i=0; i < SKIPDIR_HEIGHT_MAX; i++)
 111                 sd->headptr[i] = 0;
 112         for (i=1; i < SKIPDIR_SIZE; i++)
 113                 sd->list[i].next = i+1;
 114         sd->list[SKIPDIR_SIZE].next = 0;
 115 }
 116
 117 template <class T> void skipdir_destroy(skipdir_t<T> *sd)
 118 {
 119         sd->height = 0;
 120 }
 121
 122
 123 template <class T> void skipdir_search(skipdir_t<T> *sd, T val, gs_uint32_t *ptrstack)
 124 {
 125         gs_uint32_t ptr;
 126         gs_int32_t l;
 127
 128         if (sd->height == 0) {
 129                 ptrstack[0] = ptrstack[1] = 0;
 130                 return;
 131         }
 132         // search nonleaf nodes
 133         ptr = sd->headptr[sd->height-1];
 134         for (l=sd->height-1; l >= 0; l--) {
 135                 if (ptr == 0) {
 136                         ptrstack[l+1] = 0;
 137                         ptr = (l > 0) ? sd->headptr[l-1] : 0;
 138                 }
 139                 else if (val <= sd->list[ptr].val) {
 140                         ptrstack[l+1] = 0;
 141                         ptr = (l > 0) ? sd->headptr[l-1] : 0;
 142                 }
 143                 else {
 144                         while ((sd->list[ptr].next != 0) &&
 145                         (sd->list[sd->list[ptr].next].val < val))
 146                                 ptr = sd->list[ptr].next;
 147                         ptrstack[l+1] = ptr;
 148                         ptr = sd->list[ptr].down;
 149                 }
 150         }
 151         ptrstack[0] = ptr;
 152 }
 153
 154
 155 template <class T> void skipdir_insert(skipdir_t<T> *sd, gs_uint32_t *ptrstack,
 156                         gs_uint32_t leafptr, T val)
 157 {
 158         gs_uint32_t newptr, oldptr;
 159         gs_int32_t l;
 160
 161         // if path already existed then point to new duplicate
 162         if ((ptrstack[1] == 0) && (sd->headptr[0] != 0)
 163         && (sd->list[sd->headptr[0]].val == val)) {
 164                 sd->list[sd->headptr[0]].down = leafptr;
 165                 return;
 166         }
 167         if ((ptrstack[1] != 0) && (sd->list[ptrstack[1]].next != 0)
 168         && (sd->list[sd->list[ptrstack[1]].next].val == val)) {
 169                 sd->list[sd->list[ptrstack[1]].next].down = leafptr;
 170                 return;
 171         }
 172
 173         for (l=0; l < SKIPDIR_HEIGHT_MAX; l++) {
 174                 if (random() % 2) break;
 175                 newptr = skipdir_alloc<T>(sd);
 176                 if (!newptr) break;     // out of memory
 177                 sd->list[newptr].val = val;
 178                 //copy(&val, &list[newptr[l]].val);
 179                 // link new directory node to level below
 180                 if (l > 0)
 181                         sd->list[newptr].down = oldptr;
 182                 else
 183                         sd->list[newptr].down = leafptr;
 184                 // insert node into current level
 185                 if ((l >= sd->height) || (ptrstack[l+1] == 0)) {
 186                         sd->list[newptr].next = sd->headptr[l];
 187                         sd->headptr[l] = newptr;
 188                 }
 189                 else {
 190                         sd->list[newptr].next = sd->list[ptrstack[l+1]].next;
 191                         sd->list[ptrstack[l+1]].next = newptr;
 192                 }
 193                 oldptr = newptr;
 194         }
 195         if (l > sd->height) sd->height = l;
 196         //fprintf(stderr,"new height = %u\n",sd->height);
 197 }
 198
 199
 200 template <class T> void  skipdir_delete(skipdir_t<T> *sd, gs_uint32_t *ptrstack, T val)
 201 {
 202         gs_uint32_t delptr;
 203         gs_int32_t l;
 204
 205         for (l=0; l < sd->height; l++) {
 206                 if (ptrstack[l+1] == 0) {
 207                         delptr = sd->headptr[l];
 208                         if (delptr == 0) break;
 209                         if (sd->list[delptr].val == val) {
 210                                 sd->headptr[l] = sd->list[delptr].next;
 211                                 skipdir_free<T>(sd, delptr);
 212                         }
 213                         else
 214                                 break;
 215                 }
 216                 else {
 217                         delptr = sd->list[ptrstack[l+1]].next;
 218                         if (delptr == 0) break;
 219                         if (sd->list[delptr].val == val) {
 220                                 sd->list[ptrstack[l+1]].next = sd->list[delptr].next;
 221                                 skipdir_free<T>(sd, delptr);
 222                         }
 223                         else
 224                                 break;
 225                 }
 226         }
 227 }
 228
 229 // For Debugging
 230 template <class T> void skipdir_print(skipdir_t<T> *sd)
 231 {
 232         gs_uint32_t ptr;
 233         gs_int32_t l;
 234
 235         for (l=sd->height-1; l >= 0; l--) {
 236                 for (ptr=sd->headptr[l]; ptr != 0; ptr=sd->list[ptr].next)
 237                         fprintf(stderr,"%u ", sd->list[ptr].val);
 238                 fprintf(stderr,"\n");
 239         }
 240         fprintf(stderr,"-------\n");
 241         for (l=sd->height-1; l > 0; l--) {
 242                 for (ptr=sd->headptr[l]; ptr != 0; ptr=sd->list[ptr].next)
 243                         fprintf(stderr,"%u ", sd->list[sd->list[ptr].down].val);
 244                 fprintf(stderr,"\n");
 245         }
 246         fprintf(stderr,"-------\n");
 247 }
 248
 249
 250
 251
 252 /*************************** Version 3 **************************/
 253 /* Version 3: LFTA-medium                                       */
 254 /*                                                              */
 255 /* NIC performs O(log n) operations at each update.             */
 256 /****************************************************************/
 257
 258 /****************************************************************/
 259 /* Helper functions                                             */
 260 /****************************************************************/
 261 template <class T> gs_uint32_t quant_udaf_lfta3_cursor_alloc(quant_udaf_lfta3_struct_t<T> *s)
 262 {
 263         gs_uint32_t ptr = s->freeptr;
 264         if (s->freeptr != 0) s->freeptr = s->t[ptr].next;
 265         s->size++;
 266 // printf("quant_udaf_lfta3_cursor_alloc %d freeptr %d\n",ptr, s->freeptr);
 267         return ptr;
 268 }
 269
 270 template <class T> void quant_udaf_lfta3_cursor_free(quant_udaf_lfta3_struct_t<T> *s, gs_uint32_t ptr)
 271 {
 272         s->t[ptr].next = s->freeptr;
 273         s->freeptr = ptr;
 274         s->size--;
 275 //printf("quant_udaf_lfta3_cursor_free %d\n",ptr);
 276 }
 277
 278 template <class T> void quant_lfta3_print(quant_udaf_lfta3_struct_t<T> *s)
 279 {
 280         tuple_t<T> *t=s->t;
 281         gs_uint32_t ptr = s->usedptr;
 282
 283         if (ptr == 0) {
 284                 fprintf(stderr,"<empty>\n");
 285                 return;
 286         }
 287         //skipdir_print(&s->sd);
 288         for (; ptr != 0; ptr=t[ptr].next) {
 289                 fprintf(stderr,"(%u, %u, %u) ",t[ptr].val,t[ptr].gap,t[ptr].del);
 290         }
 291         fprintf(stderr,"\n");
 292 }
 293
 294 template <class T> void quant_lfta3_compress(quant_udaf_lfta3_struct_t<T> *s)
 295 {
 296         tuple_t<T> *t = s->t;
 297         gs_uint32_t delptr;
 298         gs_uint32_t threshold;
 299         gs_uint32_t ptrstack[SKIPDIR_HEIGHT_MAX+5];
 300
 301         threshold = (gs_uint32_t)ceil(2.0 * QUANT_EPS * (gs_float_t)s->nelts);
 302 //if(s->circptr < 0 || s->circptr >= QUANT_LFTA3_SIZE)
 303 // printf("1) s->circptr = %d\n",s->circptr);
 304 //if(t[s->circptr].next < 0 || t[s->circptr].next >= QUANT_LFTA3_SIZE)
 305 // printf("t[s->circptr].next = %d\n",t[s->circptr].next);
 306         if ((s->circptr == 0) || (t[s->circptr].next == 0)
 307         || (t[t[s->circptr].next].next == 0))
 308                 s->circptr = s->usedptr;
 309         //if ((s->size % 10) != 0) return;
 310         if (s->nelts > 2) {
 311 //if(s->circptr < 0 || s->circptr >= QUANT_LFTA3_SIZE)
 312 // printf("2) s->circptr = %d\n",s->circptr);
 313                 delptr = t[s->circptr].next;
 314 //if(delptr < 0 || delptr >= QUANT_LFTA3_SIZE)
 315 // printf("delptr = %d\n",delptr);
 316 //if(t[delptr].next < 0 || t[delptr].next >= QUANT_LFTA3_SIZE)
 317 // printf("t[delptr].next = %d\n",t[delptr].next);
 318                 if (t[delptr].gap+t[t[delptr].next].gap+t[t[delptr].next].del < threshold) {
 319                         // delete from directory
 320                         if (t[s->circptr].val != t[delptr].val) {
 321                                 // leftmost duplicate (if multiplicity)
 322                                 skipdir_search<T>(&(s->sd), t[delptr].val, ptrstack);
 323                                 if (t[delptr].val == t[t[delptr].next].val) {
 324 //if(s->sd.headptr[0] < 0 || s->sd.headptr[0] >= QUANT_LFTA3_SIZE)
 325 // printf("s->sd.headptr[0] = %d\n",s->sd.headptr[0]);
 326                                         // duplicates case
 327                                         if ((ptrstack[1] == 0)
 328                                         && (s->sd.headptr[0] != 0)
 329                                         && (s->sd.list[s->sd.headptr[0]].val == t[delptr].val))
 330                                                 s->sd.list[s->sd.headptr[0]].down = t[delptr].next;
 331                                         else if ((ptrstack[1] != 0)
 332                                         && (s->sd.list[ptrstack[1]].next != 0)
 333                                         && (s->sd.list[s->sd.list[ptrstack[1]].next].val == t[delptr].val))
 334                                                 s->sd.list[s->sd.list[ptrstack[1]].next].down = t[delptr].next;
 335                                 }
 336                                 else {
 337                                         // non-duplicates case
 338                                         skipdir_delete<T>(&(s->sd), ptrstack, t[delptr].val);
 339                                 }
 340                         }
 341                         // delete from list
 342                         //fprintf(stderr,"DELETED %u\n", t[delptr].val);
 343                         t[s->circptr].next = t[delptr].next;
 344                         quant_udaf_lfta3_cursor_free<T>(s, delptr);
 345                 }
 346                 else {
 347                         s->circptr = t[s->circptr].next;
 348                 }
 349         }
 350 }
 351
 352
 353 /****************************************************************/
 354 /* LFTA3 functions                                              */
 355 /****************************************************************/
 356 template <class T> void quant_udaf_lfta3_LFTA_AGGR_INIT_(gs_sp_t b) {
 357         gs_uint32_t i;
 358 //printf("LFTA, sizeof(quant_udaf_lfta3_struct_t) is %lu\n",sizeof(quant_udaf_lfta3_struct_t<T>));
 359         quant_udaf_lfta3_struct_t<T> *s = (quant_udaf_lfta3_struct_t<T> *)b;
 360         s->nelts = 0;
 361         s->usedptr = 0;         // NULL ptr
 362         s->circptr = 0;
 363         // initialize cursor stack
 364         s->freeptr = 1;
 365         s->size = 0;
 366         for (i=1; i < QUANT_LFTA3_SIZE; i++)
 367                 s->t[i].next = i+1;
 368         s->t[QUANT_LFTA3_SIZE].next = 0;
 369         skipdir_create<T>(&(s->sd));
 370
 371 //printf("sizeof(quant_udaf_lfta3_struct_t)=%lu\n",sizeof(quant_udaf_lfta3_struct_t<T>));
 372 }
 373
 374 template <class T> void quant_udaf_lfta3_LFTA_AGGR_UPDATE_(gs_sp_t b, T v)
 375 {
 376         quant_udaf_lfta3_struct_t<T> *s = (quant_udaf_lfta3_struct_t<T> *)b;
 377         tuple_t<T> *t = s->t;
 378         gs_uint32_t ptr = s->usedptr;
 379         gs_uint32_t newptr, delptr;
 380         gs_uint32_t obj;        // objective function
 381         gs_uint32_t threshold;
 382         gs_uint32_t ptrstack[SKIPDIR_HEIGHT_MAX+5];
 383         gs_uint32_t debugptr;
 384
 385 //printf("AGGR_UPDATE start\n");
 386         s->nelts++;
 387         //fprintf(stderr,"nelts = %u\n",s->nelts);
 388         // left boundary case
 389         if ((ptr == 0) || (v < t[ptr].val)) {
 390                 if (t[ptr].val == v) {
 391                         t[ptr].gap++;
 392 //printf("AGGR_UPDATE END 1\n");
 393                         return;
 394                 }
 395 //printf("allocating (1) for %u   ",v);
 396                 newptr = quant_udaf_lfta3_cursor_alloc<T>(s);
 397                 if (newptr == 0) {
 398                         gslog(LOG_ALERT, "Out of space in quant_udaf_lfta3_LFTA_AGGR_UPDATE_ (1).\n");
 399                         return;
 400                 }
 401                 t[newptr].val = v;
 402                 t[newptr].gap = 1;
 403                 t[newptr].del = 0;
 404                 t[newptr].next = s->usedptr;
 405                 s->usedptr = newptr;
 406 //printf("AGGR_UPDATE END 2\n");
 407                 return;
 408         }
 409
 410         // locate $i$ such that (v_i-1 < v <= v_i)
 411         skipdir_search<T>(&(s->sd), v, ptrstack);
 412
 413         //ptr = (ptrstack[0] == 0) ? s->usedptr : s->sd.list[ptrstack[0]].down;
 414         ptr = (ptrstack[0] == 0) ? s->usedptr : ptrstack[0];
 415         while ((t[ptr].next != 0) && (t[t[ptr].next].val < v))
 416                 ptr = t[ptr].next;
 417
 418 /*
 419         // duplicate value
 420         if ((t[ptr].next != 0) && (t[t[ptr].next].val == v)) {
 421                 t[t[ptr].next].gap++;
 422 printf("AGGR_UPDATE END 3\n");
 423                 return;
 424         }
 425 */
 426
 427         // right boundary case
 428         if (t[ptr].next == 0) {
 429 //printf("allocating (2) for %u   ",v);
 430                 newptr = quant_udaf_lfta3_cursor_alloc<T>(s);
 431                 if (newptr == 0) {
 432                         gslog(LOG_ALERT, "Out of space in quant_udaf_lfta3_LFTA_AGGR_UPDATE_ (2).\n");
 433                         return;
 434                 }
 435                 t[newptr].val = v;
 436                 t[newptr].gap = 1;
 437                 t[newptr].del = 0;
 438                 t[newptr].next = 0;
 439                 t[ptr].next = newptr;
 440 //printf("AGGR_UPDATE END 4\n");
 441                 return;
 442         }
 443
 444         // non-boundary case
 445 //printf("1) t[ptr].next =%d, ptr=%d\n",t[ptr].next,ptr);
 446         obj = t[ptr].gap+t[t[ptr].next].gap+t[t[ptr].next].del;
 447         threshold = (gs_uint32_t)ceil(2.0 * QUANT_EPS * (gs_float_t)s->nelts);
 448         if (obj > threshold) {
 449 //printf("allocating (3) for %u   ",v);
 450                 newptr = quant_udaf_lfta3_cursor_alloc<T>(s);
 451                 if (newptr == 0) {
 452                         gslog(LOG_ALERT, "Out of space in quant_udaf_lfta3_LFTA_AGGR_UPDATE_ (3).\n");
 453                         return;
 454                 }
 455 //printf("newptr=%d\n",newptr);
 456                 t[newptr].val = v;
 457                 t[newptr].gap = 1;
 458                 t[newptr].del = t[t[ptr].next].gap+t[t[ptr].next].del - 1;
 459                 t[newptr].next = t[ptr].next;
 460                 t[ptr].next = newptr;
 461                 skipdir_insert<T>(&(s->sd), ptrstack, newptr, v);
 462         }
 463         else {
 464                 // insert into existing bucket
 465 //printf("t[ptr].next =%d\n",t[ptr].next);
 466                 t[t[ptr].next].gap++;
 467         }
 468         quant_lfta3_compress<T>(s);
 469 //printf("AGGR_UPDATE END 5\n");
 470 }
 471
 472 template <class T> gs_int32_t quant_udaf_lfta3_LFTA_AGGR_FLUSHME_(gs_sp_t b) {
 473         quant_udaf_lfta3_struct_t<T> *s = (quant_udaf_lfta3_struct_t<T> *)b;
 474
 475
 476         if (s->freeptr == 0)
 477                 return 1;
 478         else
 479                 return 0;
 480 }
 481
 482 template <class T> void quant_udaf_lfta3_LFTA_AGGR_OUTPUT_(struct gs_string *r, gs_sp_t b)
 483 {
 484 #ifdef COMPRESSED_XFER
 485         quant_udaf_lfta3_struct_t<T> *s = (quant_udaf_lfta3_struct_t<T> *)b;
 486         tuple_t<T> tmp[QUANT_LFTA3_SIZE+1];
 487         gs_uint32_t ptr=s->usedptr;
 488         gs_int32_t i=0,j;
 489
 490         for (; ptr != 0; ptr=s->t[ptr].next) {
 491                 tmp[i].val = s->t[ptr].val;
 492                 tmp[i].gap = s->t[ptr].gap;
 493                 tmp[i].del = s->t[ptr].del;
 494                 i++;
 495         }
 496         for (j=1; j <= i; j++) {
 497                 s->t[j].val = tmp[j-1].val;
 498                 s->t[j].gap = tmp[j-1].gap;
 499                 s->t[j].del = tmp[j-1].del;
 500                 s->t[j].next = j+1;
 501         }
 502         s->t[i].next = 0;
 503         s->usedptr = 1;
 504
 505 //      r->length = (5 + 4*(i+1))*sizeof(gs_uint32_t);
 506         r->length = 5*sizeof(gs_uint32_t) + (i+1)*sizeof(tuple_t<T>);
 507 #endif
 508 #ifndef COMPRESSED_XFER
 509         r->length = sizeof(quant_udaf_lfta3_struct_t<T>);
 510 #endif
 511 //printf("OUTPUT, size is %d\n",r->length);
 512         r->data = b;
 513 }
 514
 515 template <class T> void quant_udaf_lfta3_LFTA_AGGR_DESTROY_(gs_sp_t b)
 516 {
 517         return;
 518 }
 519
 520
 521 // -----------------------------------------------------------------
 522 //              Instantiations
 523
 524 //      unsigned int
 525 void quant_ui_udaf_lfta3_LFTA_AGGR_INIT_(gs_sp_t b){
 526         quant_udaf_lfta3_LFTA_AGGR_INIT_<gs_uint32_t>(b);
 527 }
 528 void quant_ui_udaf_lfta3_LFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint32_t v){
 529         quant_udaf_lfta3_LFTA_AGGR_UPDATE_<gs_uint32_t>(b, v);
 530 }
 531 gs_int32_t quant_ui_udaf_lfta3_LFTA_AGGR_FLUSHME_(gs_sp_t b){
 532         return quant_udaf_lfta3_LFTA_AGGR_FLUSHME_<gs_uint32_t>(b);
 533 }
 534 void quant_ui_udaf_lfta3_LFTA_AGGR_OUTPUT_(struct gs_string *r, gs_sp_t b){
 535         quant_udaf_lfta3_LFTA_AGGR_OUTPUT_<gs_uint32_t>(r, b);
 536 }
 537 void quant_ui_udaf_lfta3_LFTA_AGGR_DESTROY_(gs_sp_t b){
 538         quant_udaf_lfta3_LFTA_AGGR_DESTROY_<gs_uint32_t>(b);
 539 }
 540
 541 //      int
 542 void quant_i_udaf_lfta3_LFTA_AGGR_INIT_(gs_sp_t b){
 543         quant_udaf_lfta3_LFTA_AGGR_INIT_<gs_int32_t>(b);
 544 }
 545 void quant_i_udaf_lfta3_LFTA_AGGR_UPDATE_(gs_sp_t b, gs_int32_t v){
 546         quant_udaf_lfta3_LFTA_AGGR_UPDATE_<gs_int32_t>(b, v);
 547 }
 548 gs_int32_t quant_i_udaf_lfta3_LFTA_AGGR_FLUSHME_(gs_sp_t b){
 549         return quant_udaf_lfta3_LFTA_AGGR_FLUSHME_<gs_int32_t>(b);
 550 }
 551 void quant_i_udaf_lfta3_LFTA_AGGR_OUTPUT_(struct gs_string *r, gs_sp_t b){
 552         quant_udaf_lfta3_LFTA_AGGR_OUTPUT_<gs_int32_t>(r, b);
 553 }
 554 void quant_i_udaf_lfta3_LFTA_AGGR_DESTROY_(gs_sp_t b){
 555         quant_udaf_lfta3_LFTA_AGGR_DESTROY_<gs_int32_t>(b);
 556 }
 557
 558 // unsigned long
 559 void quant_ul_udaf_lfta3_LFTA_AGGR_INIT_(gs_sp_t b){
 560         quant_udaf_lfta3_LFTA_AGGR_INIT_<gs_uint64_t>(b);
 561 }
 562 void quant_ul_udaf_lfta3_LFTA_AGGR_UPDATE_(gs_sp_t b, gs_uint64_t v){
 563         quant_udaf_lfta3_LFTA_AGGR_UPDATE_<gs_uint64_t>(b, v);
 564 }
 565 gs_int32_t quant_ul_udaf_lfta3_LFTA_AGGR_FLUSHME_(gs_sp_t b){
 566         return quant_udaf_lfta3_LFTA_AGGR_FLUSHME_<gs_uint64_t>(b);
 567 }
 568 void quant_ul_udaf_lfta3_LFTA_AGGR_OUTPUT_(struct gs_string *r, gs_sp_t b){
 569         quant_udaf_lfta3_LFTA_AGGR_OUTPUT_<gs_uint64_t>(r, b);
 570 }
 571 void quant_ul_udaf_lfta3_LFTA_AGGR_DESTROY_(gs_sp_t b){
 572         quant_udaf_lfta3_LFTA_AGGR_DESTROY_<gs_uint64_t>(b);
 573 }
 574
 575
 576 // long
 577 void quant_l_udaf_lfta3_LFTA_AGGR_INIT_(gs_sp_t b){
 578         quant_udaf_lfta3_LFTA_AGGR_INIT_<gs_int64_t>(b);
 579 }
 580 void quant_l_udaf_lfta3_LFTA_AGGR_UPDATE_(gs_sp_t b, gs_int64_t v){
 581         quant_udaf_lfta3_LFTA_AGGR_UPDATE_<gs_int64_t>(b, v);
 582 }
 583 gs_int32_t quant_l_udaf_lfta3_LFTA_AGGR_FLUSHME_(gs_sp_t b){
 584         return quant_udaf_lfta3_LFTA_AGGR_FLUSHME_<gs_int64_t>(b);
 585 }
 586 void quant_l_udaf_lfta3_LFTA_AGGR_OUTPUT_(struct gs_string *r, gs_sp_t b){
 587         quant_udaf_lfta3_LFTA_AGGR_OUTPUT_<gs_int64_t>(r, b);
 588 }
 589 void quant_l_udaf_lfta3_LFTA_AGGR_DESTROY_(gs_sp_t b){
 590         quant_udaf_lfta3_LFTA_AGGR_DESTROY_<gs_int64_t>(b);
 591 }
 592
 593
 594 // float
 595 void quant_f_udaf_lfta3_LFTA_AGGR_INIT_(gs_sp_t b){
 596         quant_udaf_lfta3_LFTA_AGGR_INIT_<gs_float_t>(b);
 597 }
 598 void quant_f_udaf_lfta3_LFTA_AGGR_UPDATE_(gs_sp_t b, gs_float_t v){
 599         quant_udaf_lfta3_LFTA_AGGR_UPDATE_<gs_float_t>(b, v);
 600 }
 601 gs_int32_t quant_f_udaf_lfta3_LFTA_AGGR_FLUSHME_(gs_sp_t b){
 602         return quant_udaf_lfta3_LFTA_AGGR_FLUSHME_<gs_float_t>(b);
 603 }
 604 void quant_f_udaf_lfta3_LFTA_AGGR_OUTPUT_(struct gs_string *r, gs_sp_t b){
 605         quant_udaf_lfta3_LFTA_AGGR_OUTPUT_<gs_float_t>(r, b);
 606 }
 607 void quant_f_udaf_lfta3_LFTA_AGGR_DESTROY_(gs_sp_t b){
 608         quant_udaf_lfta3_LFTA_AGGR_DESTROY_<gs_float_t>(b);
 609 }
 610
 611