Changeset 3479 for proto/RE


Ignore:
Timestamp:
Sep 14, 2013, 11:17:13 AM (6 years ago)
Author:
linmengl
Message:

update Makefile

Location:
proto/RE
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • proto/RE/input/test/test1.re

    r3181 r3479  
    1 ^[ ]*#[ ]*include[ ]+("[^"]+"|<[^>]+>)
     1["']|&quot;|&apos;|&#0*3[49];|&#x0*2[27];
  • proto/RE/output/Makefile

    r3404 r3479  
    1111PABLO_SRC_CC=re_pablo.py
    1212
     13all: cc pablo
    1314
    14 all: cc pablo
     15all_gpu: cc pablo_c
    1516
    1617cc:
    1718        python $(CC_Compiler) $(CC_Input) > $(CC_Output)
    1819        sed -e '/@cc_code/{r $(CC_Output)' -e 'd}' $(PABLO_SRC_CC) > $(PABLO_SRC)
     20
    1921pablo:
    20         python $(PABLO_COMPILER) -W $(PABLO_SRC) -t $(PABLO_TEMPLATE) -o $(OUTFILE) $(PABLO_ADD_DEBUG)
     22        python $(PABLO_COMPILER) $(PABLO_SRC) -t $(PABLO_TEMPLATE) -o $(OUTFILE) $(PABLO_ADD_DEBUG)
    2123
    22 
     24pablo_c:
     25        python $(PABLO_COMPILER) $(PABLO_SRC) -t $(PABLO_TEMPLATE) -o $(OUTFILE) $(PABLO_ADD_DEBUG) -c
     26       
    2327clean: 
    2428        rm -f $(OUTFILE) $(CC_Output) $(PABLO_SRC)
  • proto/RE/output/ccinput

    r3403 r3479  
    1 lex.cc3 = [\x00-\x1F\x21-\xFF]
    2 lex.cc0 = [\x30-\x39\x41-\x5A\x61-\x7A]
    3 lex.cc5 = [\x3A]
    4 lex.cc4 = [\x2F]
    5 lex.cc7 = [\x40]
    6 lex.cc2 = [\x00-\x1F\x21-\x2E\x30-\xFF]
    7 lex.cc6 = [\x00-\x1F\x21-\x3F\x41-\xFF]
    8 lex.cc1 = [\x41-\x5A\x61-\x7A]
     1lex.cc4 = [\x74]
     2lex.cc2 = [\x75]
     3lex.cc6 = [\x61]
     4lex.cc9 = [\x30]
     5lex.cc5 = [\x3B]
     6lex.cc8 = [\x73]
     7lex.cc7 = [\x70]
     8lex.cc1 = [\x71]
     9lex.cc3 = [\x6F]
     10lex.cc10 = [\x23]
     11lex.cc16 = [\x22\x27]
     12lex.cc12 = [\x34\x39]
     13lex.cc0 = [\x26]
     14lex.cc15 = [\x32\x37]
     15lex.cc11 = [\x33]
     16lex.cc13 = [\x78]
     17lex.cc14 = [\x32]
    918lex.LF = [\x0A]
    1019
  • proto/RE/output/grep_template.cpp

    r3433 r3479  
    2727
    2828#ifdef BUFFER_PROFILING
    29     BOM_Table * parser_timer;
     29        BOM_Table * parser_timer;
    3030#elif PAPI
    3131                #define PAPI_EVENTS_COUNT 2
    3232                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
    33     CC * parser_timer;
     33        CC * parser_timer;
    3434#else
    35     void * parser_timer;
     35        void * parser_timer;
    3636#endif
    3737
    38 #define SEGMENT_BLOCKS 31
     38#define SEGMENT_BLOCKS 15
    3939#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
    4040
    41 #define BUFFER_SEGMENTS 32
     41#define BUFFER_SEGMENTS 15
    4242#define BUFFER_SIZE (BUFFER_SEGMENTS * SEGMENT_SIZE)
    4343@global
     
    5858                switch (opt_code) {
    5959                case 'c':
    60                     count_only_option = 1;
    61                     break;
     60                        count_only_option = 1;
     61                        break;
    6262                case 'v':
    63                     print_version_option = 1;
    64                     break;
     63                        print_version_option = 1;
     64                        break;
    6565                case '?':
    66                     break;
     66                        break;
    6767                default:
    68                     printf ("Invalid option: %c\n", opt_code);
    69                     printf("Usage: %s [-c] [-v] <filename> [<outputfile>]\n", argv[0]);
    70                     exit(-1);
     68                        printf ("Invalid option: %c\n", opt_code);
     69                        printf("Usage: %s [-c] [-v] <filename> [<outputfile>]\n", argv[0]);
     70                                        exit(-1);
    7171                }
    7272        }
     
    108108        }
    109109
    110         PERF_SEC_BIND(1);
     110        PERF_SEC_BIND(1);
    111111
    112112        PERF_SEC_INIT(parser_timer);
     
    118118        PERF_SEC_DESTROY(parser_timer);
    119119
    120         fclose(infile);
    121         fclose(outfile);
     120        fclose(infile);
     121        fclose(outfile);
    122122
    123123        return(0);
     
    159159       
    160160        while (chars_avail >= SEGMENT_SIZE) {
    161                         LF_scanner.init();
    162                         match_scanner.init();
     161                LF_scanner.init();
     162                match_scanner.init();
    163163
    164164                PERF_SEC_START(parser_timer);
     
    173173                        if (count_only_option) {
    174174                          if (bitblock::any(output.matches)) {
    175                             if (bitblock::any(simd_and(match_vector, output.matches))) {
    176                               match_count += bitblock::popcount(match_vector);
    177                               match_vector = output.matches;
    178                             }
    179                             else {
    180                               match_vector = simd_or(match_vector, output.matches);
    181                             }
     175                                if (bitblock::any(simd_and(match_vector, output.matches))) {
     176                                  match_count += bitblock::popcount(match_vector);
     177                                  match_vector = output.matches;
     178                                }
     179                                else {
     180                                  match_vector = simd_or(match_vector, output.matches);
     181                                }
    182182                          }
    183183                        }
    184184
    185185                }
    186 
    187186 
    188         demo.clear();
    189 
    190      
    191         int copy_back_pos = LF_scanner.get_final_pos() + 1;
    192         int copy_back_size = SEGMENT_SIZE - copy_back_pos;
    193 
    194         match_scanner.clear_from(copy_back_pos);
    195 
    196 
    197             if (!count_only_option) {
     187                demo.clear();
     188                 
     189                int copy_back_pos = LF_scanner.get_final_pos() + 1;
     190                int copy_back_size = SEGMENT_SIZE - copy_back_pos;
     191
     192                match_scanner.clear_from(copy_back_pos);
     193
     194
     195                if (!count_only_option) {
     196                        line_start = 0;
     197
     198                        while (match_scanner.has_next()) {
     199                                match_pos = match_scanner.scan_to_next();       
     200                                line_end = LF_scanner.scan_to_next();
     201                                while (line_end < match_pos) {
     202                                        line_start = line_end+1;
     203                                        line_no++; 
     204                                        line_end = LF_scanner.scan_to_next();
     205                                }
     206                                fwrite(&src_buffer[line_start], 1, line_end - line_start + 1, outfile);
     207                                line_start = line_end+1;
     208                                line_no++; 
     209                        }
     210                        while (LF_scanner.has_next()) {
     211                                line_end = LF_scanner.scan_to_next();
     212                                line_no++;
     213                        }       
     214                }
     215
     216                memmove(&src_buffer[0], &src_buffer[copy_back_pos], copy_back_size);
     217
     218                PERF_SEC_END(parser_timer, chars_avail);
     219
     220                chars_read = fread(&src_buffer[copy_back_size], 1, copy_back_pos, infile);
     221                chars_avail = chars_read + copy_back_size;
     222                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
     223                buffer_pos += chars_avail;
     224                buffer_base = buffer_pos;
     225        }
     226
     227
     228//////////////////////////////////////////////////////////////////////////////////////////
     229// Final Partial Segment
     230//////////////////////////////////////////////////////////////////////////////////////////
     231        PERF_SEC_START(parser_timer);
     232
     233        block_pos = 0;
     234        int remaining = chars_avail;
     235
     236
     237        LF_scanner.init();
     238        match_scanner.init();
     239
     240        /* Full Blocks */
     241        blk = 0;
     242        while (remaining >= BLOCK_SIZE) {
     243                block_base = block_pos;
     244                s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
     245                @block_stmts
     246                LF_scanner.load_block(lex.LF, blk);
     247                match_scanner.load_block(output.matches, blk);
     248                        if (count_only_option) {
     249                          if (bitblock::any(output.matches)) {
     250                                if (bitblock::any(simd_and(match_vector, output.matches))) {
     251                                  match_count += bitblock::popcount(match_vector);
     252                                  match_vector = output.matches;
     253                                }
     254                                else {
     255                                  match_vector = simd_or(match_vector, output.matches);
     256                                }
     257                          }
     258                        }
     259                block_pos += BLOCK_SIZE;
     260                remaining -= BLOCK_SIZE;
     261                blk++;
     262        }
     263        block_base = block_pos;
     264
     265//    Partial Block or Any Carry
     266//
     267        EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
     268                                s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
     269        @final_block_stmts
     270
     271        if (count_only_option) {
     272                match_count += bitblock::popcount(match_vector);
     273                if (bitblock::any(output.matches)) {
     274                        match_count += bitblock::popcount(output.matches);
     275                }
     276                fprintf(outfile, "Matching Lines:%d\n",match_count);
     277        }
     278        else {
     279                LF_scanner.load_block(lex.LF, blk);
     280                match_scanner.load_block(output.matches, blk);
     281                blk++;
     282
     283                for (int i = blk; i < SEGMENT_BLOCKS; i++){
     284                        LF_scanner.load_block(simd<1>::constant<0>(), i);
     285                        match_scanner.load_block(simd<1>::constant<0>(), i);
     286                }
    198287                line_start = 0;
    199288
     
    214303                        line_no++;     
    215304                }       
    216             }
    217 
    218 
    219           memmove(&src_buffer[0], &src_buffer[copy_back_pos], copy_back_size);
    220 
    221           PERF_SEC_END(parser_timer, chars_avail);
    222 
    223           chars_read = fread(&src_buffer[copy_back_size], 1, copy_back_pos, infile);
    224           chars_avail = chars_read + copy_back_size;
    225           if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
    226           buffer_pos += chars_avail;
    227           buffer_base = buffer_pos;
    228         }
    229 
    230 
    231 //////////////////////////////////////////////////////////////////////////////////////////
    232 // Final Partial Segment
    233 //////////////////////////////////////////////////////////////////////////////////////////
    234         PERF_SEC_START(parser_timer);
    235 
    236         block_pos = 0;
    237         int remaining = chars_avail;
    238 
    239 
    240         LF_scanner.init();
    241         match_scanner.init();
    242 
    243         /* Full Blocks */
    244         blk = 0;
    245         while (remaining >= BLOCK_SIZE) {
    246                 block_base = block_pos;
    247                 s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
    248                 @block_stmts
    249                 LF_scanner.load_block(lex.LF, blk);
    250                 match_scanner.load_block(output.matches, blk);
    251                         if (count_only_option) {
    252                           if (bitblock::any(output.matches)) {
    253                             if (bitblock::any(simd_and(match_vector, output.matches))) {
    254                               match_count += bitblock::popcount(match_vector);
    255                               match_vector = output.matches;
    256                             }
    257                             else {
    258                               match_vector = simd_or(match_vector, output.matches);
    259                             }
    260                           }
    261                         }
    262                 block_pos += BLOCK_SIZE;
    263                 remaining -= BLOCK_SIZE;
    264                 blk++;
    265         }
    266         block_base = block_pos;
    267 
    268 //    Partial Block or Any Carry
    269 //
    270         EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
    271                                 s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
    272         @final_block_stmts
    273 
    274         if (count_only_option) {
    275                 match_count += bitblock::popcount(match_vector);
    276                 if (bitblock::any(output.matches)) {
    277                         match_count += bitblock::popcount(output.matches);
    278                 }
    279                 fprintf(outfile, "Matching Lines:%d\n",match_count);
    280         }
    281         else {
    282                 LF_scanner.load_block(lex.LF, blk);
    283                 match_scanner.load_block(output.matches, blk);
    284                 blk++;
    285 
    286                 for (int i = blk; i < SEGMENT_BLOCKS; i++){
    287                     LF_scanner.load_block(simd<1>::constant<0>(), i);
    288                     match_scanner.load_block(simd<1>::constant<0>(), i);
    289                 }
    290                 line_start = 0;
    291 
    292                 while (match_scanner.has_next()) {
    293                         match_pos = match_scanner.scan_to_next();       
    294                         line_end = LF_scanner.scan_to_next();
    295                         while (line_end < match_pos) {
    296                                 line_start = line_end+1;
    297                                 line_no++; 
    298                                 line_end = LF_scanner.scan_to_next();
    299                         }
    300                         fwrite(&src_buffer[line_start], 1, line_end - line_start + 1, outfile);
    301                         line_start = line_end+1;
    302                         line_no++; 
    303                 }
    304                 while (LF_scanner.has_next()) {
    305                         line_end = LF_scanner.scan_to_next();
    306                         line_no++;     
    307                 }       
    308305        }
    309306
  • proto/RE/output/re_debug.py

    r3403 r3479  
    4141        cc6 = (0)
    4242        cc7 = (0)
     43        cc8 = (0)
     44        cc9 = (0)
     45        cc10 = (0)
     46        cc11 = (0)
     47        cc12 = (0)
     48        cc13 = (0)
     49        cc14 = (0)
     50        cc15 = (0)
     51        cc16 = (0)
    4352        LF = (0) 
    4453
     
    6069        m7=0
    6170        m8=0
    62         m9=0
    63         m10=0
    64         m11=0
    65         m12=0
    66         m13=0
    6771        m0=~0
    6872        m1 = m0
    69         m0 = bitutil.Advance((m0 & lex.cc1))
    70         m0 = bitutil.MatchStar(m0, lex.cc0)
    71         m0 = bitutil.Advance((m0 & lex.cc5))
    72         m0 = bitutil.Advance((m0 & lex.cc4))
    73         m0 = bitutil.Advance((m0 & lex.cc4))
     73        m2 = m0
     74        m3 = m0
    7475        m4 = m0
    75         m4 = bitutil.Advance((m4 & lex.cc2))
    76         m0 = m4
    77         m0 = bitutil.MatchStar(m0, lex.cc2)
    78         m6 = m0
    79         m6 = bitutil.Advance((m6 & lex.cc4))
    80         m6 = bitutil.MatchStar(m6, lex.cc3)
    81         m0 = (m0 | m6)
    82         m10 = m1
    83         m10 = bitutil.Advance((m10 & lex.cc6))
    84         m1 = m10
    85         m1 = bitutil.MatchStar(m1, lex.cc6)
    86         m1 = bitutil.Advance((m1 & lex.cc7))
    87         m12 = m1
    88         m12 = bitutil.Advance((m12 & lex.cc6))
    89         m1 = m12
    90         m1 = bitutil.MatchStar(m1, lex.cc6)
    91         m0 = (m0 | m1)
     76        m0 = bitutil.Advance((m0 & lex.cc16))
     77        m1 = bitutil.Advance((m1 & lex.cc0))
     78        m1 = bitutil.Advance((m1 & lex.cc1))
     79        m1 = bitutil.Advance((m1 & lex.cc2))
     80        m1 = bitutil.Advance((m1 & lex.cc3))
     81        m1 = bitutil.Advance((m1 & lex.cc4))
     82        m1 = bitutil.Advance((m1 & lex.cc5))
     83        m2 = bitutil.Advance((m2 & lex.cc0))
     84        m2 = bitutil.Advance((m2 & lex.cc6))
     85        m2 = bitutil.Advance((m2 & lex.cc7))
     86        m2 = bitutil.Advance((m2 & lex.cc3))
     87        m2 = bitutil.Advance((m2 & lex.cc8))
     88        m2 = bitutil.Advance((m2 & lex.cc5))
     89        m3 = bitutil.Advance((m3 & lex.cc0))
     90        m3 = bitutil.Advance((m3 & lex.cc10))
     91        m3 = bitutil.MatchStar(m3, lex.cc9)
     92        m3 = bitutil.Advance((m3 & lex.cc11))
     93        m3 = bitutil.Advance((m3 & lex.cc12))
     94        m3 = bitutil.Advance((m3 & lex.cc5))
     95        m4 = bitutil.Advance((m4 & lex.cc0))
     96        m4 = bitutil.Advance((m4 & lex.cc10))
     97        m4 = bitutil.Advance((m4 & lex.cc13))
     98        m4 = bitutil.MatchStar(m4, lex.cc9)
     99        m4 = bitutil.Advance((m4 & lex.cc14))
     100        m4 = bitutil.Advance((m4 & lex.cc15))
     101        m4 = bitutil.Advance((m4 & lex.cc5))
     102        m0 = ((((m0 | m1) | m2) | m3) | m4)
    92103        bitutil.print_aligned_streams([('       Input Data', u8data),
    93104        ('      lex.cc0', bitutil.bitstream2string(lex.cc0, lgth+1)),
     
    99110        ('      lex.cc6', bitutil.bitstream2string(lex.cc6, lgth+1)),
    100111        ('      lex.cc7', bitutil.bitstream2string(lex.cc7, lgth+1)),
     112        ('      lex.cc8', bitutil.bitstream2string(lex.cc8, lgth+1)),
     113        ('      lex.cc9', bitutil.bitstream2string(lex.cc9, lgth+1)),
     114        ('      lex.cc10', bitutil.bitstream2string(lex.cc10, lgth+1)),
     115        ('      lex.cc11', bitutil.bitstream2string(lex.cc11, lgth+1)),
     116        ('      lex.cc12', bitutil.bitstream2string(lex.cc12, lgth+1)),
     117        ('      lex.cc13', bitutil.bitstream2string(lex.cc13, lgth+1)),
     118        ('      lex.cc14', bitutil.bitstream2string(lex.cc14, lgth+1)),
     119        ('      lex.cc15', bitutil.bitstream2string(lex.cc15, lgth+1)),
     120        ('      lex.cc16', bitutil.bitstream2string(lex.cc16, lgth+1)),
    101121        ('      m0', bitutil.bitstream2string(m0, lgth+1)),
    102122        ('      m1', bitutil.bitstream2string(m1, lgth+1)),
     
    107127        ('      m6', bitutil.bitstream2string(m6, lgth+1)),
    108128        ('      m7', bitutil.bitstream2string(m7, lgth+1)),
    109         ('      m8', bitutil.bitstream2string(m8, lgth+1)),
    110         ('      m9', bitutil.bitstream2string(m9, lgth+1)),
    111         ('      m10', bitutil.bitstream2string(m10, lgth+1)),
    112         ('      m11', bitutil.bitstream2string(m11, lgth+1)),
    113         ('      m12', bitutil.bitstream2string(m12, lgth+1)),
    114         ('      m13', bitutil.bitstream2string(m13, lgth+1))])
     129        ('      m8', bitutil.bitstream2string(m8, lgth+1))])
    115130        return
    116131
  • proto/RE/output/re_pablo.py

    r3403 r3479  
    3939        cc6 = (0)
    4040        cc7 = (0)
     41        cc8 = (0)
     42        cc9 = (0)
     43        cc10 = (0)
     44        cc11 = (0)
     45        cc12 = (0)
     46        cc13 = (0)
     47        cc14 = (0)
     48        cc15 = (0)
     49        cc16 = (0)
    4150        LF = (0) 
    4251
     
    5766        m7=0
    5867        m8=0
    59         m9=0
    60         m10=0
    61         m11=0
    62         m12=0
    63         m13=0
    6468        m0=~0
    6569        m1 = m0
    66         m0 = pablo.Advance((m0 & lex.cc1))
    67         m0 = pablo.MatchStar(m0, lex.cc0)
    68         m0 = pablo.Advance((m0 & lex.cc5))
    69         m0 = pablo.Advance((m0 & lex.cc4))
    70         m0 = pablo.Advance((m0 & lex.cc4))
     70        m2 = m0
     71        m3 = m0
    7172        m4 = m0
    72         m4 = pablo.Advance((m4 & lex.cc2))
    73         m0 = m4
    74         m0 = pablo.MatchStar(m0, lex.cc2)
    75         m6 = m0
    76         m6 = pablo.Advance((m6 & lex.cc4))
    77         m6 = pablo.MatchStar(m6, lex.cc3)
    78         m0 = (m0 | m6)
    79         m10 = m1
    80         m10 = pablo.Advance((m10 & lex.cc6))
    81         m1 = m10
    82         m1 = pablo.MatchStar(m1, lex.cc6)
    83         m1 = pablo.Advance((m1 & lex.cc7))
    84         m12 = m1
    85         m12 = pablo.Advance((m12 & lex.cc6))
    86         m1 = m12
    87         m1 = pablo.MatchStar(m1, lex.cc6)
    88         m0 = (m0 | m1)
     73        m0 = pablo.Advance((m0 & lex.cc16))
     74        m1 = pablo.Advance((m1 & lex.cc0))
     75        m1 = pablo.Advance((m1 & lex.cc1))
     76        m1 = pablo.Advance((m1 & lex.cc2))
     77        m1 = pablo.Advance((m1 & lex.cc3))
     78        m1 = pablo.Advance((m1 & lex.cc4))
     79        m1 = pablo.Advance((m1 & lex.cc5))
     80        m2 = pablo.Advance((m2 & lex.cc0))
     81        m2 = pablo.Advance((m2 & lex.cc6))
     82        m2 = pablo.Advance((m2 & lex.cc7))
     83        m2 = pablo.Advance((m2 & lex.cc3))
     84        m2 = pablo.Advance((m2 & lex.cc8))
     85        m2 = pablo.Advance((m2 & lex.cc5))
     86        m3 = pablo.Advance((m3 & lex.cc0))
     87        m3 = pablo.Advance((m3 & lex.cc10))
     88        m3 = pablo.MatchStar(m3, lex.cc9)
     89        m3 = pablo.Advance((m3 & lex.cc11))
     90        m3 = pablo.Advance((m3 & lex.cc12))
     91        m3 = pablo.Advance((m3 & lex.cc5))
     92        m4 = pablo.Advance((m4 & lex.cc0))
     93        m4 = pablo.Advance((m4 & lex.cc10))
     94        m4 = pablo.Advance((m4 & lex.cc13))
     95        m4 = pablo.MatchStar(m4, lex.cc9)
     96        m4 = pablo.Advance((m4 & lex.cc14))
     97        m4 = pablo.Advance((m4 & lex.cc15))
     98        m4 = pablo.Advance((m4 & lex.cc5))
     99        m0 = ((((m0 | m1) | m2) | m3) | m4)
    89100        output.matches = 0
    90101        all_matches = m0
  • proto/RE/output/src/Makefile

    r3333 r3479  
    2424        $(CC) -o $(OUTFILE) $(SRCFILE) $(INCLUDES) $(AFLAGS)
    2525
     26avx2:   $(SRCFILE)
     27        $(CC) -DUSE_S2P_AVX -DBLOCK_SIZE=256 -o $(OUTFILE) $(SRCFILE) $(INCLUDES) -march=core-avx2 -m64 -mavx2 -fabi-version=6
     28
    2629avx:    $(SRCFILE)
    2730        $(CC) -o $(OUTFILE) $(SRCFILE) $(INCLUDES) -march=nocona -m64 -mavx
  • proto/RE/performance/perf.py

    r3470 r3479  
    3030        if not os.path.exists(outputpath):
    3131                os.makedirs(outputpath)
    32         if not os.path.exists(outputpath+'/'+execution.stat):           
    33                 one=execute_one(execution,1)
    34                 results_file = open(outputpath+'/'+execution.stat,'w')
    35                 results_file.write(str(one))
    36                 results_file.close()
    37         else:
    38                 results_file = open(outputpath+'/'+execution.stat,'r')
    39                 one=int(results_file.read())
    40                 results_file.close()
     32        # if not os.path.exists(outputpath+'/'+execution.stat):         
     33        #       one=execute_one(execution,1)
     34        #       results_file = open(outputpath+'/'+execution.stat,'w')
     35        #       results_file.write(str(one))
     36        #       results_file.close()
     37        # else:
     38        #       results_file = open(outputpath+'/'+execution.stat,'r')
     39        #       one=int(results_file.read())
     40        #       results_file.close()
     41
     42        one=execute_one(execution,1)
     43        results_file = open(outputpath+'/'+execution.stat,'w')
     44        results_file.write(str(one))
     45        results_file.close()   
     46       
    4147        return one,one,one,one
    4248
     
    7379                cmd = ['perf stat -x, -o perfoutput -r '+str(count)+' -e '+ execution.stat+ ' '+re_home+'output/src/re -c '+ execution.file.file + redirectoutput]
    7480                p = Popen(cmd,shell=True)
     81                p.wait()
     82        if execution.program=='bitstreams_avx2':
     83                re_home = '../'
     84                re_input_file = open(re_home+'input/test/test1.re', 'w')
     85                re_input_file.write(execution.expression.expression+'\n')
     86                re_input_file.close()
     87                call('make -C '+re_home + redirectoutput,shell=True)
     88                call('make -C '+re_home+'output/' + redirectoutput,shell=True)
     89                call('make avx2 -C '+re_home+'output/src/' + redirectoutput,shell=True)
     90                shutil.copyfile(re_home+'output/re_pablo_cc.py', outputpath+'/re_pablo_cc.py')
     91                cmd = ['perf stat -x, -o perfoutput -r '+str(count)+' -e '+ execution.stat+ ' '+re_home+'output/src/re -c '+ execution.file.file + redirectoutput]
     92                p = Popen(cmd,shell=True)
     93                p.wait()       
     94        if execution.program=='gpu':
     95                re_home = '../'
     96                re_input_file = open(re_home+'input/test/test1.re', 'w')
     97                re_input_file.write(execution.expression.expression+'\n')
     98                re_input_file.close()
     99                call('make -C '+re_home + redirectoutput,shell=True)
     100                call('make all_gpu -C '+re_home+'output/' + redirectoutput,shell=True)
     101                shutil.copyfile(re_home+'output/re_pablo_cc.py', outputpath+'/re_pablo_cc.py')
     102                shutil.copyfile(re_home+'output/src/re.cpp', outputpath+'/re.cpp')
     103                shutil.copyfile(re_home+'performance/GPU_fixer.py', outputpath+'/GPU_fixer.py')
     104                shutil.copyfile(re_home+'performance/Regxp.cl', outputpath+'/Regxp.cl')
     105                p = Popen(['python '+outputpath+'/GPU_fixer.py '+outputpath+'/re.cpp'] ,shell=True)
    75106                p.wait()
    76107        if execution.program=='grep':
     
    193224expressions.append(Expression('(^|[^A-Z0-9:])([A-F0-9]{1,4}:){7}[A-F0-9]{1,4}($|[^A-Z0-9:])', 'IPv6', ('reb',)))
    194225
    195 programs = ['bitstreams', 'agrep', 'nrgrep112', 'grep', 'pcregrep']
     226# programs = ['bitstreams', 'agrep', 'nrgrep112', 'grep', 'pcregrep']
    196227#programs = ['bitstreams','grep']
    197 #programs = ['bitstreams']
     228programs = ['gpu', 'bitstreams_avx2']
    198229
    199230#stats = ['cycles:u', 'instructions:u', 'cache-misses:u', 'L1-dcache-load-misses:u', 'L1-dcache-store-misses:u', 'L1-dcache-prefetch-misses:u', 'L1-icache-load-misses:u']
Note: See TracChangeset for help on using the changeset viewer.