cfg/external_fcns.def

   1  ///////////////////////////////////////////////////////////\r
   2 //          Matching predicates\r
   3 ///////////////////////////////////////////////////////////\r
   4         PRED [LFTA_LEGAL, COST HIGH]str_exists_substr[string, string];\r
   5         PRED [LFTA_LEGAL, COST HIGH]str_compare[string,string];\r
   6         PRED [LFTA_LEGAL, COST LOW] str_match_offset [uint,string,string];\r
   7         PRED [LFTA_LEGAL, COST LOW] byte_match_offset [uint,uint,string];\r
   8     \r
   9 ///////////////////////////////////////////////////////////\r
  10 //          MIN/MAX functions\r
  11 ///////////////////////////////////////////////////////////\r
  12 \r
  13 \r
  14         ullong FUN [LFTA_LEGAL, COST FREE] LLMIN (ullong,ullong);\r
  15         ullong FUN [LFTA_LEGAL, COST FREE] LLMAX (ullong,ullong); \r
  16         uint FUN [LFTA_LEGAL, COST FREE] UMIN (uint,uint);\r
  17         uint FUN [LFTA_LEGAL, COST FREE] UMAX (uint,uint); \r
  18 \r
  19         IP FUN [LFTA_LEGAL, COST FREE] UMIN (IP,IP);\r
  20         IP FUN [LFTA_LEGAL, COST FREE] UMAX (IP,IP);\r
  21    \r
  22 ///////////////////////////////////////////////////////////\r
  23 //          conditional functions\r
  24 ///////////////////////////////////////////////////////////\r
  25 \r
  26         uint FUN [LFTA_LEGAL, COST FREE] EQ (uint, uint);\r
  27         uint FUN [LFTA_LEGAL, COST FREE] GEQ (uint, uint);\r
  28         uint FUN [LFTA_LEGAL, COST FREE] LEQ (uint, uint);\r
  29 \r
  30 \r
  31 ///////////////////////////////////////////////////////////\r
  32 //          Function for regex matching\r
  33 ///////////////////////////////////////////////////////////\r
  34 \r
  35 \r
  36 uint FUN [LFTA_LEGAL, COST EXPENSIVE]\r
  37                 str_regex_match( string, string HANDLE);\r
  38         uint FUN [LFTA_LEGAL, COST EXPENSIVE] \r
  39                 str_partial_regex_match( string, string HANDLE, uint);\r
  40         string FUN [PARTIAL, COST EXPENSIVE] str_extract_regex( string, string HANDLE);\r
  41   \r
  42 ///////////////////////////////////////////////////////////\r
  43 //         Truncating strings        \r
  44 ///////////////////////////////////////////////////////////\r
  45        \r
  46         string FUN [LFTA_LEGAL,PARTIAL,COST FREE] str_truncate (string, uint);\r
  47  \r
  48 ///////////////////////////////////////////////////////////\r
  49 //          Function for casting\r
  50 ///////////////////////////////////////////////////////////\r
  51 \r
  52     int FUN [LFTA_LEGAL,COST FREE] non_temporal(int);\r
  53         uint FUN [LFTA_LEGAL,COST FREE] non_temporal(uint);\r
  54         llong FUN [LFTA_LEGAL,COST FREE] non_temporal(llong);\r
  55         ullong FUN [LFTA_LEGAL,COST FREE] non_temporal(ullong);\r
  56 \r
  57         int FUN [LFTA_LEGAL,COST FREE]INT(uint);\r
  58         int FUN [LFTA_LEGAL,COST FREE]INT(ullong);\r
  59         int FUN [LFTA_LEGAL,COST FREE]INT(llong);\r
  60  \r
  61         uint FUN [LFTA_LEGAL,COST FREE]UINT(int);\r
  62         uint FUN [LFTA_LEGAL,COST FREE]UINT(ullong);\r
  63         uint FUN [LFTA_LEGAL,COST FREE]UINT(llong);\r
  64         uint FUN [LFTA_LEGAL,COST FREE]UINT(IP);\r
  65 \r
  66         float FUN [LFTA_LEGAL,COST FREE] FLOAT(llong);\r
  67         float FUN [LFTA_LEGAL,COST FREE] FLOAT(ullong);\r
  68         float FUN [LFTA_LEGAL,COST FREE] FLOAT(int);\r
  69         float FUN [LFTA_LEGAL,COST FREE] FLOAT(uint);\r
  70 \r
  71         ullong FUN [LFTA_LEGAL,COST FREE]ULLONG(uint);\r
  72         ullong FUN [LFTA_LEGAL,COST FREE]ULLONG(int);\r
  73 \r
  74 ///////////////////////////////////////////////////////////\r
  75 //          Numeric functions\r
  76 ///////////////////////////////////////////////////////////\r
  77 \r
  78         float FUN [LFTA_LEGAL, COST LOW] sqrt(float); \r
  79 \r
  80 \r
  81 ///////////////////////////////////////////////////////////\r
  82 //          Convert an IPv4 address \r
  83 ///////////////////////////////////////////////////////////\r
  84 \r
  85 \r
  86     uint FUN [PARTIAL,COST HIGH] strtoi(string);\r
  87         IP FUN [PARTIAL,COST HIGH] strtoip(string); \r
  88 \r
  89 //      for constant strings - faster at runtime\r
  90         uint FUN [LFTA_LEGAL,COST LOW] strtoi_c(string HANDLE);\r
  91         IP FUN [LFTA_LEGAL,COST LOW] strtoip_c(string HANDLE); \r
  92 \r
  93 \r
  94 ///////////////////////////////////////////////////////////\r
  95 //          Compute running sum\r
  96 ///////////////////////////////////////////////////////////\r
  97 \r
  98 \r
  99 \r
 100     ullong UDAF [RUNNING, SUBAGGR moving_sum_lfta, SUPERAGGR super_moving_sum_udaf ] moving_sum_udaf fstring12 (uint, uint);\r
 101 \r
 102         uint EXTR moving_sum moving_sum_udaf moving_sum_extract (uint,uint);\r
 103         uint FUN  [COST LOW] moving_sum_extract(ullong);\r
 104 \r
 105         float EXTR moving_sum_exp moving_sum_udaf moving_sum_extract_exp (uint,uint, float);\r
 106         float FUN  [COST LOW]  moving_sum_extract_exp(ullong, float);\r
 107 \r
 108         ullong UDAF [RUNNING] super_moving_sum_udaf fstring12 (ullong);\r
 109         ullong UDAF moving_sum_lfta fstring8 (uint, uint);\r
 110 \r
 111 \r
 112 ///////////////////////////////////////////////////////////\r
 113 //               Compute the average of \r
 114 //              all positive numbers \r
 115 ///////////////////////////////////////////////////////////\r
 116 \r
 117         float UDAF POSAVG fstring16(float);\r
 118 \r
 119 \r
 120 ///////////////////////////////////////////////////////////\r
 121 //               Simple average example \r
 122 ///////////////////////////////////////////////////////////\r
 123 \r
 124         float EXTR extr_avg avg_udaf extr_avg_fcn (uint);\r
 125         float FUN extr_avg_fcn (string);\r
 126         string UDAF[SUBAGGR avg_udaf_lfta, SUPERAGGR avg_udaf_hfta] avg_udaf fstring12 (uint);\r
 127         string UDAF avg_udaf_hfta fstring12 (string);\r
 128         string UDAF avg_udaf_lfta fstring12 (uint);\r
 129 \r
 130 ///////////////////////////////////////////////////////////\r
 131 //               SAMPLING \r
 132 ///////////////////////////////////////////////////////////\r
 133 \r
 134         fstring100 STATE smart_sampling_state;\r
 135         int SFUN packet_count smart_sampling_state ();\r
 136         float SFUN gamma smart_sampling_state ();\r
 137         int SFUN do_clean_count smart_sampling_state ();\r
 138         int SFUN init_threshold smart_sampling_state ();\r
 139         int SFUN delay smart_sampling_state();\r
 140         int SFUN newly_closed smart_sampling_state();\r
 141 \r
 142 ///////////////////////////////////////////////////////////\r
 143 //               Manku Heavy Hitter \r
 144 ///////////////////////////////////////////////////////////\r
 145 \r
 146  \r
 147         fstring20 STATE manku_hh_state;\r
 148         BOOL SFUN local_count manku_hh_state (UINT);\r
 149         int SFUN current_bucket manku_hh_state ();\r
 150 \r
 151 ///////////////////////////////////////////////////////////\r
 152 //         Flips approximate quantile\r
 153 ///////////////////////////////////////////////////////////\r
 154 \r
 155         uint EXTR quantile_of quant_udaf_hfta0 extr_quant_hfta0_fcn (uint, float);\r
 156         uint  FUN [COST LOW] extr_quant_hfta0_fcn(string, float);\r
 157         uint EXTR median_of quant_udaf_hfta0 extr_med_hfta0_fcn (uint);\r
 158         uint  FUN [COST LOW] extr_med_hfta0_fcn(string);\r
 159         uint EXTR qspace_of quant_udaf_hfta0 extr_quant_hfta0_space (uint);\r
 160         uint  FUN [COST LOW] extr_quant_hfta0_space(string);\r
 161         string UDAF [SUBAGGR quant_udaf_lfta3, SUPERAGGR quant_udaf_hfta3] quant_udaf_hfta0 fstring8 (uint);\r
 162         string UDAF quant_udaf_hfta3 fstring16 (string);\r
 163         string UDAF quant_udaf_lfta3 fstring6600 (uint);\r
 164 \r
 165 ///////////////////////////////////////////////////////////\r
 166 //               FIRST and LAST aggregation funciton\r
 167 //      Should be replaced by builtins\r
 168 ///////////////////////////////////////////////////////////\r
 169 \r
 170         uint UDAF [RUNNING, SUBAGGR FIRST_lfta, SUPERAGGR FIRST_hfta] FIRST uint (uint);\r
 171         uint UDAF [RUNNING] FIRST_hfta uint (uint);\r
 172         uint UDAF [RUNNING] FIRST_lfta uint (uint);\r
 173 \r
 174         ullong UDAF [RUNNING, SUBAGGR FIRST_ULL_lfta, SUPERAGGR FIRST_ULL_hfta] FIRST ullong (ullong);\r
 175         ullong UDAF [RUNNING] FIRST_ULL_hfta ullong (ullong);\r
 176         ullong UDAF [RUNNING] FIRST_ULL_lfta ullong (ullong);\r
 177 \r
 178         IP UDAF [RUNNING, SUBAGGR FIRST_lfta, SUPERAGGR FIRST_hfta] FIRST IP (IP);\r
 179         IP UDAF [RUNNING] FIRST_hfta IP (IP);\r
 180         IP UDAF [RUNNING] FIRST_lfta IP (IP);\r
 181 \r
 182         string UDAF [RUNNING, SUBAGGR FIRST_STR_lfta, SUPERAGGR FIRST_STR_hfta] FIRST string (string);\r
 183         string UDAF [RUNNING] FIRST_STR_hfta string (string);\r
 184         string UDAF [RUNNING] FIRST_STR_lfta string (string);\r
 185 \r
 186         uint UDAF [RUNNING, SUBAGGR LAST_lfta, SUPERAGGR LAST_hfta] LAST uint (uint);\r
 187         uint UDAF [RUNNING] LAST_hfta uint (uint);\r
 188         uint UDAF [RUNNING] LAST_lfta uint (uint);\r
 189 \r
 190         ullong UDAF [RUNNING, SUBAGGR LAST_ULL_lfta, SUPERAGGR LAST_ULL_hfta] LAST ullong (ullong);\r
 191         ullong UDAF [RUNNING] LAST_ULL_hfta ullong (ullong);\r
 192         ullong UDAF [RUNNING] LAST_ULL_lfta ullong (ullong);\r
 193 \r
 194         IP UDAF [RUNNING, SUBAGGR LAST_lfta, SUPERAGGR LAST_hfta] LAST IP (IP);\r
 195         IP UDAF [RUNNING] LAST_hfta IP (IP);\r
 196         IP UDAF [RUNNING] LAST_lfta IP (IP);\r
 197 \r
 198         string UDAF [RUNNING, SUBAGGR LAST_STR_lfta, SUPERAGGR LAST_STR_hfta] LAST string (string);\r
 199         string UDAF [RUNNING] LAST_STR_hfta string (string);\r
 200         string UDAF [RUNNING] LAST_STR_lfta string (string);\r
 201 \r
 202 ///////////////////////////////////////////////////////////\r
 203 //               integer array aggregation funciton\r
 204 //      We are going to store 4 values in LFTA in fixed size buffer\r
 205 //  plus one byte for array length (17 bytes total)\r
 206 //  HFTA will combine partial aggregates\r
 207 ///////////////////////////////////////////////////////////\r
 208 \r
 209         string UDAF [RUNNING, SUBAGGR running_array_aggr_lfta, SUPERAGGR running_array_aggr_hfta] running_array_aggr string (uint);\r
 210         string UDAF [RUNNING] running_array_aggr_hfta string (string);\r
 211         string UDAF [RUNNING] running_array_aggr_lfta fstring17 (uint);\r
 212         \r