Ignore:
Timestamp:
May 29, 2012, 12:59:28 PM (7 years ago)
Author:
ksherdy
Message:

Updated Makefile.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/symbol_table/templates/main_template.cpp

    r2182 r2184  
    145145    ///////////////////////////////////////////////////////////////////////////
    146146    while (chars_avail >= SEGMENT_SIZE) {
    147         uint32_t blk;
    148         for(blk=0;blk<SEGMENT_BLOCKS;blk++) {
    149         s2p_do_block((BytePack *) &src_buffer[blk*BLOCK_SIZE], basis_bits[blk]);    // transpose
    150         markers_do_block(basis_bits[blk], markers[blk]);                            // gen symbol spans, mark starts & follows
    151         hash_strms_do_block(basis_bits[blk], hash[blk]);                            // gen hash bit streams
    152         identity_group_do_block(markers[blk], groups[blk]);                         // sort marker bit stream (identity)
     147                uint32_t blk;
     148                for(blk=0;blk<SEGMENT_BLOCKS;blk++) {
     149                        s2p_do_block((BytePack *) &src_buffer[blk*BLOCK_SIZE], basis_bits[blk]);    // transpose
     150                        markers_do_block(basis_bits[blk], markers[blk]);                            // gen symbol spans, mark starts & follows
     151                        hash_strms_do_block(basis_bits[blk], hash[blk]);                            // gen hash bit streams
     152                        identity_group_do_block(markers[blk], groups[blk]);                         // sort marker bit stream (identity)
    153153    }
    154154
    155155    for(int blk=0;blk<SEGMENT_BLOCKS;blk++) {   // write contiguous bit streams
    156         h0[blk] = hash[blk].h0;
    157         h1[blk] = hash[blk].h1;
    158         starts[blk] = groups[blk].starts;
    159         follows_0[blk] = groups[blk].follows_0;
     156                        h0[blk] = hash[blk].h0;
     157                        h1[blk] = hash[blk].h1;
     158                        starts[blk] = groups[blk].starts;
     159                        follows_0[blk] = groups[blk].follows_0;
    160160    }
    161161
     
    176176    uint32_t blk_offset;
    177177    for(int blk=0;blk<SEGMENT_BLOCKS;blk++) {
    178         blk_offset = blk * BLOCK_SIZE;
    179         gid_type gid;
    180 
    181         #ifdef INDEX_AT_STARTS
    182             ForwardScanner<BitBlock, scanword_t> scanner(&(groups[blk].starts));
    183         #else
    184             ForwardScanner<BitBlock, scanword_t> scanner(&(groups[blk].follows));
    185         #endif
    186 
    187         scanner.scan_to_next();
    188         while(!scanner.is_done()) {
    189                 gid = gids.at[scanner.get_pos() + blk_offset];
    190                 cout << string((char *)st.get_raw_data(gid), st.get_lgth(gid)) << ",";
    191                 scanner.scan_to_next();
    192         }
     178                        blk_offset = blk * BLOCK_SIZE;
     179                        gid_type gid;
     180
     181                        #ifdef INDEX_AT_STARTS
     182                                        ForwardScanner<BitBlock, scanword_t> scanner(&(groups[blk].starts));
     183                        #else
     184                                        ForwardScanner<BitBlock, scanword_t> scanner(&(groups[blk].follows));
     185                        #endif
     186
     187                        scanner.scan_to_next();
     188                        while(!scanner.is_done()) {
     189                                gid = gids.at[scanner.get_pos() + blk_offset];
     190                                cout << string((char *)st.get_raw_data(gid), st.get_lgth(gid)) << ",";
     191                                scanner.scan_to_next();
     192                        }
    193193    }
    194194    #endif
     
    203203    uint32_t blk = 0;
    204204    while (remaining >= BLOCK_SIZE) {
    205         s2p_do_block((BytePack *) &src_buffer[blk*BLOCK_SIZE], basis_bits[blk]);
    206         markers_do_block(basis_bits[blk], markers[blk]);
    207         hash_strms_do_block(basis_bits[blk], hash[blk]);
    208         identity_group_do_block(markers[blk], groups[blk]);
    209         blk++;
    210         remaining -= BLOCK_SIZE;
     205                        s2p_do_block((BytePack *) &src_buffer[blk*BLOCK_SIZE], basis_bits[blk]);
     206                        markers_do_block(basis_bits[blk], markers[blk]);
     207                        hash_strms_do_block(basis_bits[blk], hash[blk]);
     208                        identity_group_do_block(markers[blk], groups[blk]);
     209                        blk++;
     210                        remaining -= BLOCK_SIZE;
    211211    }
    212212
     
    215215    ///////////////////////////////////////////////////////////////////////////
    216216    if (remaining > 0 || @marker_strms_any_carry || @group_strms_any_carry /*|| hash_strms_any_carry*/) {
    217         BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
    218         s2p_do_final_block((BytePack *) &src_buffer[blk*BLOCK_SIZE], basis_bits[blk], EOF_mask);
    219         markers_do_final_block(basis_bits[blk], markers[blk], EOF_mask);
    220         hash_strms_do_final_block(basis_bits[blk], hash[blk], EOF_mask);
    221         identity_group_do_final_block(markers[blk], groups[blk], EOF_mask);
    222         blk++;
     217                        BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
     218                        s2p_do_final_block((BytePack *) &src_buffer[blk*BLOCK_SIZE], basis_bits[blk], EOF_mask);
     219                        markers_do_final_block(basis_bits[blk], markers[blk], EOF_mask);
     220                        hash_strms_do_final_block(basis_bits[blk], hash[blk], EOF_mask);
     221                        identity_group_do_final_block(markers[blk], groups[blk], EOF_mask);
     222                        blk++;
    223223    }
    224224
    225225    uint32_t segment_blocks = blk;
    226226    for(int blk=0;blk<segment_blocks;blk++) { // write contiguous hash bit streams
    227         h0[blk] = hash[blk].h0;
    228         h1[blk] = hash[blk].h1;
    229         starts[blk] = groups[blk].starts;
    230         follows_0[blk] = groups[blk].follows_0;
     227                        h0[blk] = hash[blk].h0;
     228                        h1[blk] = hash[blk].h1;
     229                        starts[blk] = groups[blk].starts;
     230                        follows_0[blk] = groups[blk].follows_0;
    231231    }
    232232
     
    239239    uint32_t blk_offset;
    240240    for(int blk=0;blk<segment_blocks;blk++) {
    241         blk_offset = blk * BLOCK_SIZE;
    242         gid_type gid;
    243 
    244         #ifdef INDEX_AT_STARTS
    245             ForwardScanner<BitBlock, scanword_t> scanner(&(groups[blk].starts));
    246         #else
    247             ForwardScanner<BitBlock, scanword_t> scanner(&(groups[blk].follows));
    248         #endif
    249 
    250         scanner.scan_to_next();
    251         while(!scanner.is_done()) {
    252                 gid = gids.at[scanner.get_pos() + blk_offset];
    253                 cout << string((char *)st.get_raw_data(gid), st.get_lgth(gid)) << ",";
     241                blk_offset = blk * BLOCK_SIZE;
     242                gid_type gid;
     243
     244                #ifdef INDEX_AT_STARTS
     245                          ForwardScanner<BitBlock, scanword_t> scanner(&(groups[blk].starts));
     246                #else
     247                          ForwardScanner<BitBlock, scanword_t> scanner(&(groups[blk].follows));
     248                #endif
     249
    254250                scanner.scan_to_next();
    255         }
     251                while(!scanner.is_done()) {
     252                        gid = gids.at[scanner.get_pos() + blk_offset];
     253                        cout << string((char *)st.get_raw_data(gid), st.get_lgth(gid)) << ",";
     254                        scanner.scan_to_next();
     255                }
    256256    }
    257257    #endif
    258258
    259259    #ifdef GID_TEST
    260         cout << st.get_max_gid() << endl;
     260                        cout << st.get_max_gid() << endl;
    261261    #endif
    262262
Note: See TracChangeset for help on using the changeset viewer.