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
9 ///////////////////////////////////////////////////////////
\r
10 // MIN/MAX functions
\r
11 ///////////////////////////////////////////////////////////
\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
19 IP FUN [LFTA_LEGAL, COST FREE] UMIN (IP,IP);
\r
20 IP FUN [LFTA_LEGAL, COST FREE] UMAX (IP,IP);
\r
22 ///////////////////////////////////////////////////////////
\r
23 // conditional functions
\r
24 ///////////////////////////////////////////////////////////
\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
31 ///////////////////////////////////////////////////////////
\r
32 // Function for regex matching
\r
33 ///////////////////////////////////////////////////////////
\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
42 ///////////////////////////////////////////////////////////
\r
43 // Truncating strings
\r
44 ///////////////////////////////////////////////////////////
\r
46 string FUN [LFTA_LEGAL,PARTIAL,COST FREE] str_truncate (string, uint);
\r
48 ///////////////////////////////////////////////////////////
\r
49 // Function for casting
\r
50 ///////////////////////////////////////////////////////////
\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
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
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
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
71 ullong FUN [LFTA_LEGAL,COST FREE]ULLONG(uint);
\r
72 ullong FUN [LFTA_LEGAL,COST FREE]ULLONG(int);
\r
74 ///////////////////////////////////////////////////////////
\r
75 // Numeric functions
\r
76 ///////////////////////////////////////////////////////////
\r
78 float FUN [LFTA_LEGAL, COST LOW] sqrt(float);
\r
81 ///////////////////////////////////////////////////////////
\r
82 // Convert an IPv4 address
\r
83 ///////////////////////////////////////////////////////////
\r
86 uint FUN [PARTIAL,COST HIGH] strtoi(string);
\r
87 IP FUN [PARTIAL,COST HIGH] strtoip(string);
\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
94 ///////////////////////////////////////////////////////////
\r
95 // Compute running sum
\r
96 ///////////////////////////////////////////////////////////
\r
100 ullong UDAF [RUNNING, SUBAGGR moving_sum_lfta, SUPERAGGR super_moving_sum_udaf ] moving_sum_udaf fstring12 (uint, uint);
\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
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
108 ullong UDAF [RUNNING] super_moving_sum_udaf fstring12 (ullong);
\r
109 ullong UDAF moving_sum_lfta fstring8 (uint, uint);
\r
112 ///////////////////////////////////////////////////////////
\r
113 // Compute the average of
\r
114 // all positive numbers
\r
115 ///////////////////////////////////////////////////////////
\r
117 float UDAF POSAVG fstring16(float);
\r
120 ///////////////////////////////////////////////////////////
\r
121 // Simple average example
\r
122 ///////////////////////////////////////////////////////////
\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
130 ///////////////////////////////////////////////////////////
\r
132 ///////////////////////////////////////////////////////////
\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
142 ///////////////////////////////////////////////////////////
\r
143 // Manku Heavy Hitter
\r
144 ///////////////////////////////////////////////////////////
\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
151 ///////////////////////////////////////////////////////////
\r
152 // Flips approximate quantile
\r
153 ///////////////////////////////////////////////////////////
\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
165 ///////////////////////////////////////////////////////////
\r
166 // FIRST and LAST aggregation funciton
\r
167 // Should be replaced by builtins
\r
168 ///////////////////////////////////////////////////////////
\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
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
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
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
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
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
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
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
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
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