source: proto/s2k/trunk/framework/output/cpplang/grep/grep_definitions.hpp @ 3761

Last change on this file since 3761 was 3761, checked in by ksherdy, 5 years ago

Added clear function def to b2k kernels to support segment-at-a-time grep.

File size: 11.8 KB
Line 
1// GENERATED CODE. DO NOT MODIFY.
2//
3// This template includes the minimal set of runtime support libraries required
4// to support compilation of s2k generated C++ code (bitblock.hpp, carryQ.hpp,
5// pabloSupport.hpp, bitblock_iterator.hpp)
6//
7// (c) 2012, 2013 Robert D. Cameron, Ken Herdy
8// All rights reserved.
9// Licensed to International Characters, Inc. under Academic Free License 3.0
10//
11//////////////////////////////////////////////////////////////////////////////////////////
12// @ global - Stream structure and stream function declarations.
13//
14//////////////////////////////////////////////////////////////////////////////////////////
15//
16#ifndef GREP_DEFINITIONS_HPP
17#define GREP_DEFINITIONS_HPP
18
19// runtime libraries
20#include <simd-lib/bitblock.hpp>
21#include <simd-lib/carrySet.hpp>
22#include <simd-lib/pabloSupport.hpp>
23#include <simd-lib/bitblock_iterator.hpp>
24
25//
26//#include <simd-lib/transpose.hpp>
27//#include <simd-lib/s2p.hpp>
28
29// namespace s2k
30// {
31struct Basis_bits
32{
33        BitBlock bit_0;
34        BitBlock bit_1;
35        BitBlock bit_2;
36        BitBlock bit_3;
37        BitBlock bit_4;
38        BitBlock bit_5;
39        BitBlock bit_6;
40        BitBlock bit_7;
41};
42 
43struct Lex
44{
45        BitBlock a;
46        BitBlock p;
47        BitBlock l;
48        BitBlock e;
49        BitBlock LF;
50};
51 
52struct Output
53{
54        BitBlock match_follows;
55        BitBlock lines;
56        BitBlock line_starts;
57        BitBlock line_ends;
58};
59 
60struct ClassifyBytes
61{
62        ClassifyBytes()
63        {
64        }
65       
66        IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex)
67        {
68                BitBlock temp1;
69                temp1 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
70                BitBlock temp2;
71                temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
72                BitBlock temp3;
73                temp3 = simd_and(temp1,temp2);
74                BitBlock temp4;
75                temp4 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
76                BitBlock temp5;
77                temp5 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
78                BitBlock temp6;
79                temp6 = simd_andc(temp5,temp4);
80                lex.a = simd_and(temp3,temp6);
81                BitBlock temp7;
82                temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
83                BitBlock temp8;
84                temp8 = simd_and(temp1,temp7);
85                BitBlock temp9;
86                temp9 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
87                BitBlock temp10;
88                temp10 = simd_or(temp4,temp9);
89                lex.p = simd_andc(temp8,temp10);
90                BitBlock temp11;
91                temp11 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
92                BitBlock temp12;
93                temp12 = simd_andc(temp11,temp9);
94                lex.l = simd_and(temp3,temp12);
95                BitBlock temp13;
96                temp13 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
97                BitBlock temp14;
98                temp14 = simd_and(temp13,temp5);
99                lex.e = simd_and(temp3,temp14);
100                BitBlock temp15;
101                temp15 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
102                BitBlock temp16;
103                temp16 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
104                BitBlock temp17;
105                temp17 = simd_or(temp15,temp16);
106                BitBlock temp18;
107                temp18 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
108                BitBlock temp19;
109                temp19 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
110                BitBlock temp20;
111                temp20 = simd_and(temp18,temp19);
112                lex.LF = simd_andc(temp20,temp17);
113        }
114       
115        void do_final_block(struct Basis_bits & basis_bits,struct Lex & lex,BitBlock & EOF_mask)
116        {
117                BitBlock temp1;
118                temp1 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
119                BitBlock temp2;
120                temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
121                BitBlock temp3;
122                temp3 = simd_and(temp1,temp2);
123                BitBlock temp4;
124                temp4 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
125                BitBlock temp5;
126                temp5 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
127                BitBlock temp6;
128                temp6 = simd_andc(temp5,temp4);
129                lex.a = simd_and(temp3,temp6);
130                BitBlock temp7;
131                temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
132                BitBlock temp8;
133                temp8 = simd_and(temp1,temp7);
134                BitBlock temp9;
135                temp9 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
136                BitBlock temp10;
137                temp10 = simd_or(temp4,temp9);
138                lex.p = simd_andc(temp8,temp10);
139                BitBlock temp11;
140                temp11 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
141                BitBlock temp12;
142                temp12 = simd_andc(temp11,temp9);
143                lex.l = simd_and(temp3,temp12);
144                BitBlock temp13;
145                temp13 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
146                BitBlock temp14;
147                temp14 = simd_and(temp13,temp5);
148                lex.e = simd_and(temp3,temp14);
149                BitBlock temp15;
150                temp15 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
151                BitBlock temp16;
152                temp16 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
153                BitBlock temp17;
154                temp17 = simd_or(temp15,temp16);
155                BitBlock temp18;
156                temp18 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
157                BitBlock temp19;
158                temp19 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
159                BitBlock temp20;
160                temp20 = simd_and(temp18,temp19);
161                lex.LF = simd_andc(temp20,temp17);
162        }
163       
164        void clear()
165        {
166               
167        }
168       
169        CarryDeclare(carry_set_0,0,0);
170};
171 
172struct Match
173{
174        Match()
175        {
176        }
177       
178        IDISA_INLINE void do_block(struct Lex & lex,struct Output & output)
179        {
180                BitBlock cursor;
181                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.a,carry_set_0.getCarry(0),cursor));
182                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.p),carry_set_0.getCarry(1),cursor));
183                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.p),carry_set_0.getCarry(2),cursor));
184                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.l),carry_set_0.getCarry(3),cursor));
185                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.e),carry_set_0.getCarry(4),cursor));
186                output.match_follows = cursor;
187                carry_set_0.carryAdjust(5);
188        }
189       
190        void do_final_block(struct Lex & lex,struct Output & output,BitBlock & EOF_mask)
191        {
192                BitBlock cursor;
193                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.a,carry_set_0.getCarry(0),cursor));
194                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.p),carry_set_0.getCarry(1),cursor));
195                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.p),carry_set_0.getCarry(2),cursor));
196                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.l),carry_set_0.getCarry(3),cursor));
197                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(simd_and(cursor,lex.e),carry_set_0.getCarry(4),cursor));
198                output.match_follows = cursor;
199        }
200       
201        void clear()
202        {
203               
204        }
205       
206        CarryDeclare(carry_set_0,5,0);
207};
208 
209struct MatchLines
210{
211        MatchLines()
212        {
213                carry_set_0.setCarry(carry_set_0.carryFlip(0),0);
214                carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
215        }
216       
217        IDISA_INLINE void do_block(struct Lex & lex,struct Output & output)
218        {
219                BitBlock all_line_starts;
220                BitBlock _temp0;
221                BitBlock _temp1;
222                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanToFirst(simd_not(lex.LF),carry_set_0.getCarry(0),_temp0));
223                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(lex.LF,carry_set_0.getCarry(1),_temp1));
224                all_line_starts = simd_or(_temp0,simd_andc(_temp1,lex.LF));
225                BitBlock all_line_ends;
226                all_line_ends = lex.LF;
227                BitBlock last_line_start;
228                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(all_line_starts,carry_set_0.getCarry(2),last_line_start));
229                BitBlock cursor;
230                cursor = last_line_start;
231                if (bitblock::any(simd_or(cursor,carry_set_0.carryRange(3,3))))
232                {
233                        if (bitblock::any(simd_and(cursor,all_line_starts)))
234                        {
235                                last_line_start = cursor;
236                        }
237                        if (bitblock::any(simd_or(simd_and(cursor,output.match_follows),carry_set_0.carryRange(3,2))))
238                        {
239                                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(cursor,simd_not(lex.LF),carry_set_0.getCarry(3),cursor));
240                                BitBlock _temp2;
241                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_InclusiveSpan(last_line_start,cursor,carry_set_0.getCarry(4),_temp2));
242                                output.lines = simd_or(output.lines,_temp2);
243                        }
244                        else
245                        {
246                                carry_set_0.carryDequeueEnqueue(3,2);
247                        }
248                        carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(cursor,simd_not(simd_or(all_line_starts,output.match_follows)),carry_set_0.getCarry(5),cursor));
249                        while (bitblock::any(cursor))
250                        {
251                                CarryDeclare(carry_set_1,3,0);
252                                if (bitblock::any(simd_and(cursor,all_line_starts)))
253                                {
254                                        last_line_start = cursor;
255                                }
256                                if (bitblock::any(simd_and(cursor,output.match_follows)))
257                                {
258                                        carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(cursor,simd_not(lex.LF),carry_set_1.getCarry(0),cursor));
259                                        BitBlock _temp2;
260                                        carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_InclusiveSpan(last_line_start,cursor,carry_set_1.getCarry(1),_temp2));
261                                        output.lines = simd_or(output.lines,_temp2);
262                                }
263                                carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(cursor,simd_not(simd_or(all_line_starts,output.match_follows)),carry_set_1.getCarry(2),cursor));
264                                LocalCarryCombine(carry_set_0,carry_set_1,3,3);
265                        }
266                }
267                else
268                {
269                        carry_set_0.carryDequeueEnqueue(3,3);
270                }
271                output.line_starts = simd_and(output.lines,all_line_starts);
272                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(output.line_starts,simd_not(simd_and(output.lines,all_line_ends)),carry_set_0.getCarry(6),output.line_ends));
273                carry_set_0.carryAdjust(7);
274        }
275       
276        void do_final_block(struct Lex & lex,struct Output & output,BitBlock & EOF_mask)
277        {
278                BitBlock all_line_starts;
279                BitBlock _temp0;
280                BitBlock _temp1;
281                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanToFirst(simd_or(simd_not(lex.LF),simd_not(EOF_mask)),carry_set_0.getCarry(0),_temp0));
282                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(lex.LF,carry_set_0.getCarry(1),_temp1));
283                all_line_starts = simd_or(_temp0,simd_andc(_temp1,lex.LF));
284                BitBlock all_line_ends;
285                all_line_ends = lex.LF;
286                BitBlock last_line_start;
287                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(simd_or(all_line_starts,simd_not(EOF_mask)),carry_set_0.getCarry(2),last_line_start));
288                BitBlock cursor;
289                cursor = last_line_start;
290                if (bitblock::any(simd_and(simd_or(simd_and(cursor,EOF_mask),carry_set_0.carryRange(3,3)),EOF_mask)))
291                {
292                        if (bitblock::any(simd_and(cursor,all_line_starts)))
293                        {
294                                last_line_start = cursor;
295                        }
296                        if (bitblock::any(simd_or(simd_and(cursor,output.match_follows),carry_set_0.carryRange(3,2))))
297                        {
298                                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(cursor,simd_andc(EOF_mask,lex.LF),carry_set_0.getCarry(3),cursor));
299                                BitBlock _temp2;
300                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_InclusiveSpan(last_line_start,cursor,carry_set_0.getCarry(4),_temp2));
301                                output.lines = simd_or(output.lines,_temp2);
302                        }
303                        else
304                        {
305                                carry_set_0.carryDequeueEnqueue(3,2);
306                        }
307                        carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(cursor,simd_andc(EOF_mask,simd_or(all_line_starts,output.match_follows)),carry_set_0.getCarry(5),cursor));
308                        while (bitblock::any(simd_and(simd_and(cursor,EOF_mask),EOF_mask)))
309                        {
310                                CarryDeclare(carry_set_1,3,0);
311                                if (bitblock::any(simd_and(cursor,all_line_starts)))
312                                {
313                                        last_line_start = cursor;
314                                }
315                                if (bitblock::any(simd_and(cursor,output.match_follows)))
316                                {
317                                        carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(cursor,simd_andc(EOF_mask,lex.LF),carry_set_1.getCarry(0),cursor));
318                                        BitBlock _temp2;
319                                        carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_InclusiveSpan(last_line_start,cursor,carry_set_1.getCarry(1),_temp2));
320                                        output.lines = simd_or(output.lines,_temp2);
321                                }
322                                carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(cursor,simd_andc(EOF_mask,simd_or(all_line_starts,output.match_follows)),carry_set_1.getCarry(2),cursor));
323                                LocalCarryCombine(carry_set_0,carry_set_1,3,3);
324                        }
325                }
326                else
327                {
328                        carry_set_0.carryDequeueEnqueue(3,3);
329                }
330                output.line_starts = simd_and(output.lines,all_line_starts);
331                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(output.line_starts,simd_andc(EOF_mask,simd_and(output.lines,all_line_ends)),carry_set_0.getCarry(6),output.line_ends));
332        }
333       
334        void clear()
335        {
336                carry_set_0.setCarry(carry_set_0.carryFlip(0),0);
337                carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
338        }
339       
340        CarryDeclare(carry_set_0,7,0);
341};
342 
343
344// }
345
346#endif // GREP_DEFINITIONS_HPP
Note: See TracBrowser for help on using the repository browser.