Changeset 3834


Ignore:
Timestamp:
Apr 18, 2014, 2:35:35 AM (4 years ago)
Author:
ksherdy
Message:

Added launchers, test cases.

Location:
proto/s2k/trunk/framework
Files:
2 added
1 deleted
10 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/input/grammar/scatter/b2k.scatter

    r3806 r3834  
    172172    // e x p r e s s i o n s
    173173    //   
     174
     175//  KH: for constant integer expressions
     176//   
     177//      expr        #-> expr1 ((OR^|XOR^) expr)? _leftAssoc_ ;
     178//  expr1       #-> expr2 ((AND^) expr1)? _leftAssoc_ ;
     179//  expr2       #-> NOT^^? expr3;                                         
     180//  expr3       #-> expr4 ((MULTIPLY^ | DIVIDE^) expr3)? _leftAssoc_ ;
     181//  expr4       #-> expr5 ((PLUS^ | MINUS^) expr4)? _leftAssoc_ ;
     182     
    174183    expr                #-> LROUND expr RROUND
    175184                         | constant
     
    184193    funcCallArgList     ->      (expr (COMMA expr)*) ? ;
    185194    idisaFuncCallRest   ->      LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND; // KH: parameterized function call ?
    186     fieldWidth          ->      integerConstant ;                                             // KH: fieldWidthSpecifier ?
     195    fieldWidth          ->      integerConstant ;                                             // KH: fieldWidthSpecifier / expr ?
    187196    idisaFuncCallArgList    ->  (expr (COMMA expr)*) ? ;
    188197
  • proto/s2k/trunk/framework/input/grammar/scatter/s2k.scatter

    r3805 r3834  
    168168    // s t a t e m e n t s
    169169    //
    170     stmt                        #->     varDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt ;
     170    stmt                        #->     varDecl | funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | foreachStmt ;
    171171    blockStmt                   ->      LCURLY stmt* RCURLY ;
    172172    varDecl                     ->      type varName (ASSIGN^ expr) ? TERMINATOR ;
     
    183183  //elementName   #-> identifier ;
    184184
    185     foreach                     ->  FOREACH LROUND foreachIndexStreamList RROUND IN LROUND foreachMarkerStreamList RROUND blockStmt ;
    186     foreachIndexStreamList      ->  foreachIndexStream ; // foreachIndexStream ( COMMA foreachIndexStream ) * ;
    187     foreachIndexStream          ->  streamType foreachIndexStreamName ;
    188     foreachIndexStreamName      #-> identifier ;
    189     foreachMarkerStreamList     ->  foreachMarkerStreamName ; // expr ( COMMA expr )* ;
    190     foreachMarkerStreamName     #-> identifier ;
     185    foreachStmt                 ->  FOREACH LROUND indexStreamDeclList RROUND IN LROUND targetStreamDeclList RROUND blockStmt ;
     186    indexStreamDeclList         #-> streamDeclList ;
     187    targetStreamDeclList        #-> streamDeclList ;
     188        streamDeclList              ->  streamDecl ( COMMA streamDecl ) * ;
     189        streamDecl                  ->  streamType streamName ;
     190         
    191191
    192192  //annotationStmt    -> AMPERSAND annotationName LROUND annotationArgList RROUND blockStmt TERMINATOR ;
     
    212212    funcCallRest            ->  LROUND^ funcCallArgList RROUND ;
    213213    funcCallArgList         ->  (expr (COMMA expr)*) ? ;     
    214     idisaFuncCallRest   ->      LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND ;
     214    idisaFuncCallRest       ->  LANGLE^ fieldWidth RANGLE LROUND idisaFuncCallArgList RROUND ;
    215215    idisaFuncCallArgList    ->  (expr (COMMA expr)*) ? ;
    216     fieldWidth          ->      integerConstant ;
     216    fieldWidth              ->  integerConstant ;
    217217
    218218    //
     
    226226    primitiveType           #->     ( intType ) ;
    227227    intType                 ->      INT    { @type = {{PrimitiveType.INTEGER}};  } ;
     228   
    228229    streamType              ->      STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
    229230                                                                    @type = {{ StreamType.STREAM(%?) }} , @fieldWidth ;
    230231                                                                } ;
     232    streamName              #->     identifier ;                                                               
    231233                   
    232     fieldWidthSpecifier     #->      (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;   
    233     structType              ->       STRUCT structName ;       
    234     structName              #->      identifier ;               
    235 
    236     filterType              ->       FILTER filterName ;       
    237     filterName              #->      identifier ;
    238 }
     234    fieldWidthSpecifier     #->     (LANGLE integerConstant RANGLE ) | (epsilon {@value = 1;}) ;   
     235   
     236    // fieldWidthSpecifier  #->     (LANGLE expr RANGLE ) | (epsilon {@value = 1;}) ;
     237   
     238    structType              ->      STRUCT structName ;       
     239    structName              #->     identifier ;               
     240
     241    filterType              ->      FILTER filterName ;       
     242    filterName              #->     identifier ;
     243}
  • proto/s2k/trunk/framework/input/templates/cpplang/grep.template

    r3797 r3834  
    3030// runtime libraries
    3131#include <simd-lib/bitblock.hpp>
    32 #include <simd-lib/carrySet.hpp>
     32#include <simd-lib/runtime.hpp>
    3333#include <simd-lib/pabloSupport.hpp>
    3434#include <simd-lib/bitblock_iterator.hpp>
  • proto/s2k/trunk/framework/input/templates/cpplang/grep_header.template

    r3786 r3834  
    2020// runtime libraries
    2121#include <simd-lib/bitblock.hpp>
    22 #include <simd-lib/carrySet.hpp>
     22#include <simd-lib/runtime.hpp>
    2323#include <simd-lib/pabloSupport.hpp>
    2424#include <simd-lib/bitblock_iterator.hpp>
  • proto/s2k/trunk/framework/input/templates/cpplang/parabix2_header.template

    r3786 r3834  
    1919// runtime libraries
    2020#include <simd-lib/bitblock.hpp>
    21 #include <simd-lib/carrySet.hpp>
     21#include <simd-lib/runtime.hpp>
    2222#include <simd-lib/pabloSupport.hpp>
    2323
  • proto/s2k/trunk/framework/input/test/s2k/proto/grep/grep_flow.s2k

    r3807 r3834  
    8383}
    8484
     85//filter Demo(struct Output output) {
     86//      stream m = output.match_follows;
     87//      int c = 0;
     88//    foreach (stream s) in (stream m) {       
     89//      printf("%d", c);
     90//      c = c + 1;
     91//     
     92//    }   
     93//}
     94 
    8595
    8696graph Main() {
     
    95105    filter Match match;
    96106    filter MatchLines matchLines;
     107    filter Demo demo;
    97108
    98109    transpose(byte_data, basis_bits);
     
    100111    match(lex, output);
    101112    matchLines(lex, output);
     113//    demo(output);
    102114   
    103115}
  • proto/s2k/trunk/framework/input/test/s2k/proto/grep/grep_header_flow.s2k

    r3807 r3834  
    8585    output.line_ends = flow.ScanTo(output.line_starts, (output.lines & all_line_ends));
    8686}
     87
     88 
     89   
  • proto/s2k/trunk/framework/input/test/s2k/test.s2k

    r3767 r3834  
     1filter Test() {
    12
    2 
    3 struct Basis{
    4     stream bit_0;
    5     stream bit_1;
    6     stream bit_2;
    7     stream bit_3;
    8     stream bit_4;
    9     stream bit_5;
    10     stream bit_6;
    11     stream bit_7;
    12 };
    13 
    14 struct Lex{
    15     stream a;
    16     stream p;
    17     stream l;
    18     stream e;
    19     stream LF;
    20 };
    21 
    22 struct Matches{
    23     stream all_matched;
    24 };
    25 
    26 struct Lines{
    27     stream all_matched;
    28 };
    29 
    30 struct Output{
    31     stream lines;
    32 };
    33 
    34 filter ClassifyBytes(struct Basis_bits basis_bits, struct Lex lex) {
    35     stream temp1 = (basis_bits.bit_1 & (~ basis_bits.bit_0));
    36     stream temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
    37     stream temp3 = (temp1 & temp2);
    38     stream temp4 = (basis_bits.bit_4 | basis_bits.bit_5);
    39     stream temp5 = (basis_bits.bit_7 & (~ basis_bits.bit_6));
    40     stream temp6 = (temp5 & (~ temp4));
    41     lex.a = (temp3 & temp6);
    42     stream temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
    43     stream temp8 = (temp1 & temp7);
    44     stream temp9 = (basis_bits.bit_6 | basis_bits.bit_7);
    45     stream temp10 = (temp4 | temp9);
    46     lex.p = (temp8 & (~ temp10));
    47     stream temp11 = (basis_bits.bit_4 & basis_bits.bit_5);
    48     stream temp12 = (temp11 & (~ temp9));
    49     lex.l = (temp3 & temp12);
    50     stream temp13 = (basis_bits.bit_5 & (~ basis_bits.bit_4));
    51     stream temp14 = (temp13 & temp5);
    52     lex.e = (temp3 & temp14);
    53     stream temp15 = (basis_bits.bit_0 | basis_bits.bit_1);
    54     stream temp16 = (basis_bits.bit_2 | basis_bits.bit_3);
    55     stream temp17 = (temp15 | temp16);
    56     stream temp18 = (basis_bits.bit_4 & (~ basis_bits.bit_5));
    57     stream temp19 = (basis_bits.bit_6 & (~ basis_bits.bit_7));
    58     stream temp20 = (temp18 & temp19);
    59     lex.LF = (temp20 & (~ temp17));
    60 }
    61 
    62 filter Match(struct Lex lex, struct Matches matches) {
    63     stream m0 = lex.a;
    64     stream m1 = (pablo.Advance(m0) & lex.p);
    65     stream m2 = (pablo.Advance(m1) & lex.p);
    66     stream m3 = (pablo.Advance(m2) & lex.l);
    67     stream m4 = (pablo.Advance(m3) & lex.e);
    68     matches.all_matched = m4;
    69 }
    70 
    71 filter MatchLines1(struct Lex lex, struct Matches matches, struct Lines lines) {
    72     stream last_start = pablo.First();
    73     stream LF_or_match = (lex.LF | matches.all_matched);
    74     stream cursor = pablo.ScanToFirst(LF_or_match);
    75     while (pablo.inFile(cursor)) {
    76         if ((cursor & matches.all_matched)) {
    77             stream next_end = pablo.AdvanceThenScanTo(cursor, lex.LF);
    78             lines.all_matched |= (pablo.InclusiveSpan(last_start, next_end) | next_end);
    79             cursor = next_end;
    80         }
    81         if ((cursor & lex.LF)) {
    82             last_start = pablo.Advance(cursor);
    83         }
    84         cursor = pablo.AdvanceThenScanTo(cursor, LF_or_match);
     3    for (stream s) in (stream m) {
     4   
    855    }
    866}
    87 
    88 filter MatchLines2(struct Lex lex, struct Matches matches, struct Lines lines) {
    89     stream last_start = pablo.Mask(1,0);
    90     last_start = (pablo.Advance((~ last_start)) ^ (~ last_start));
    91     stream LF_or_match = (lex.LF | matches.all_matched);
    92     stream cursor = pablo.ScanToFirst(LF_or_match);
    93     while (pablo.inFile(cursor)) {
    94         if ((cursor & matches.all_matched)) {
    95             stream next_end = pablo.AdvanceThenScanTo(cursor, lex.LF);
    96             lines.all_matched |= (pablo.InclusiveSpan(last_start, next_end) | next_end);
    97             cursor = next_end;
    98         }
    99         if ((cursor & lex.LF)) {
    100             last_start = pablo.Advance(cursor);
    101         }
    102         cursor = pablo.AdvanceThenScanTo(cursor, LF_or_match);
    103     }
    104 }
    105 
    106 filter nameMatchLines(struct Data data, struct Output output) {
    107     output.lines = pablo.filter_bytes(data, (~ lines.all_matched));
    108 }
    109 
    110 filter CountLines(struct Lex lex, struct Lines lines) {
    111     return pablo.PopCount((pablo.MatchStar(lines, (~ lex.LF)) & lex.LF)) ;
    112 }
  • proto/s2k/trunk/framework/output/cpplang/grep/grep.hpp

    r3814 r3834  
    2020// runtime libraries
    2121#include <simd-lib/bitblock.hpp>
    22 #include <simd-lib/carrySet.hpp>
     22#include <simd-lib/runtime.hpp>
    2323#include <simd-lib/pabloSupport.hpp>
    2424#include <simd-lib/bitblock_iterator.hpp>
     
    161161        }
    162162       
    163         CarryDeclare(carry_set_0, 0, 0);
     163        DeclareRuntimeInfoSet(carry_set_0, 0, 0);
    164164};
    165165 
     
    198198        }
    199199       
    200         CarryDeclare(carry_set_0, 5, 0);
     200        DeclareRuntimeInfoSet(carry_set_0, 5, 0);
    201201};
    202202 
     
    243243                        while (bitblock::any(cursor))
    244244                        {
    245                                 CarryDeclare(carry_set_1, 3, 0);
     245                                DeclareRuntimeInfoSet(carry_set_1, 3, 0);
    246246                                if (bitblock::any(simd_and(cursor,all_line_starts)))
    247247                                {
     
    302302                        while (bitblock::any(simd_and(simd_and(cursor,EOF_mask),EOF_mask)))
    303303                        {
    304                                 CarryDeclare(carry_set_1, 3, 0);
     304                                DeclareRuntimeInfoSet(carry_set_1, 3, 0);
    305305                                if (bitblock::any(simd_and(cursor,all_line_starts)))
    306306                                {
     
    332332        }
    333333       
    334         CarryDeclare(carry_set_0, 7, 0);
     334        DeclareRuntimeInfoSet(carry_set_0, 7, 0);
    335335};
    336336 
  • proto/s2k/trunk/framework/output/cpplang/parabix2/parabix2.hpp

    r3799 r3834  
    1919// runtime libraries
    2020#include <simd-lib/bitblock.hpp>
    21 #include <simd-lib/carrySet.hpp>
     21#include <simd-lib/runtime.hpp>
    2222#include <simd-lib/pabloSupport.hpp>
    2323
     
    730730        }
    731731       
    732         CarryDeclare(carry_set_0, 10, 0);
     732        DeclareRuntimeInfoSet(carry_set_0, 10, 0);
    733733};
    734734 
     
    875875                        while (bitblock::any(CtCDPI_Cursor))
    876876                        {
    877                                 CarryDeclare(carry_set_1, 13, 0);
     877                                DeclareRuntimeInfoSet(carry_set_1, 13, 0);
    878878                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    879879                                BitBlock PI_Cursor;
     
    10921092                        while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
    10931093                        {
    1094                                 CarryDeclare(carry_set_1, 13, 0);
     1094                                DeclareRuntimeInfoSet(carry_set_1, 13, 0);
    10951095                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    10961096                                BitBlock PI_Cursor;
     
    11781178        }
    11791179       
    1180         CarryDeclare(carry_set_0, 17, 2);
     1180        DeclareRuntimeInfoSet(carry_set_0, 17, 2);
    11811181};
    11821182 
     
    12641264                                while (bitblock::any(AttNameStart))
    12651265                                {
    1266                                         CarryDeclare(carry_set_1, 7, 0);
     1266                                        DeclareRuntimeInfoSet(carry_set_1, 7, 0);
    12671267                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    12681268                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
     
    14221422                                while (bitblock::any(simd_and(AttNameStart,EOF_mask)))
    14231423                                {
    1424                                         CarryDeclare(carry_set_1, 7, 0);
     1424                                        DeclareRuntimeInfoSet(carry_set_1, 7, 0);
    14251425                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    14261426                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
     
    15071507        }
    15081508       
    1509         CarryDeclare(carry_set_0, 13, 0);
     1509        DeclareRuntimeInfoSet(carry_set_0, 13, 0);
    15101510};
    15111511 
     
    16121612        }
    16131613       
    1614         CarryDeclare(carry_set_0, 6, 0);
     1614        DeclareRuntimeInfoSet(carry_set_0, 6, 0);
    16151615};
    16161616 
     
    17231723        }
    17241724       
    1725         CarryDeclare(carry_set_0, 9, 0);
     1725        DeclareRuntimeInfoSet(carry_set_0, 9, 0);
    17261726};
    17271727 
     
    17591759        }
    17601760       
    1761         CarryDeclare(carry_set_0, 0, 0);
     1761        DeclareRuntimeInfoSet(carry_set_0, 0, 0);
    17621762};
    17631763 
Note: See TracChangeset for help on using the changeset viewer.