Ignore:
Timestamp:
Apr 14, 2012, 11:08:22 PM (7 years ago)
Author:
ksherdy
Message:

Code clean up.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/symbol_table/main_template.cpp

    r2010 r2029  
    22 * Created on: 18-December-2011
    33 * Author: Ken Herdy
     4 *
     5 * A simple test driver that perform an 'identity' translation of CSV (single) seperate symbol values
     6 * and prints results to standard output.
    47 *
    58 * Length sorted symbol table main.
     
    1922 * contiguously in memory, BitBlock struct members are copied into contiguous memory positions.
    2023 *
    21  * Design Issues
    22  *
    23  * (1) Max hash table size.
     24 * Design Considerations.
     25 *
     26 * (1) Hash table memory allocation.
    2427 * (2) Negative shift values.
    25  * (3) Template classes on Length L.
     28 * (3) Whether to specialized Hash/Symbol classes on symbol length...
    2629 *
    2730 */
     
    2932#include "transpose.hpp"
    3033#include "buffer.hpp"
    31 
    3234#include "../lib/bitblock.hpp"
    3335#include "../lib/allocator.hpp"
     
    134136    ///////////////////////////////////////////////////////////////////////////
    135137    while (chars_avail >= SEGMENT_SIZE) {
    136 
    137       uint32_t blk;
    138       for(blk=0;blk<SEGMENT_BLOCKS;blk++) {
    139         s2p_do_block((BytePack *) &raw_buffer[blk*BLOCK_SIZE], basis_bits[blk]);    // transpose
    140         markers_do_block(basis_bits[blk], markers[blk]);                            // gen symbol spans, mark starts & follows
    141         hash_strms_do_block(basis_bits[blk], hash[blk]);                            // gen hash bit streams
    142         identity_group_do_block(markers[blk], groups[blk]);                         // sort marker bit stream (identity)
     138                                uint32_t blk;
     139                                for(blk=0;blk<SEGMENT_BLOCKS;blk++) {
     140                                s2p_do_block((BytePack *) &raw_buffer[blk*BLOCK_SIZE], basis_bits[blk]);    // transpose
     141                                markers_do_block(basis_bits[blk], markers[blk]);                            // gen symbol spans, mark starts & follows
     142                                hash_strms_do_block(basis_bits[blk], hash[blk]);                            // gen hash bit streams
     143                                identity_group_do_block(markers[blk], groups[blk]);                         // sort marker bit stream (identity)
    143144      }
    144145
    145 //    for(int k=0;k<SEGMENT_BLOCKS;k++) {
    146 //        cout << "RAW " << string((((char*)&raw_buffer[0])+k*BLOCK_SIZE),BLOCK_SIZE) << endl;
    147 //    }
    148 
    149146      for(int blk=0;blk<SEGMENT_BLOCKS;blk++) { // write contiguous bit streams
    150         h0[blk] = hash[blk].h0;
    151         h1[blk] = hash[blk].h1;
    152         starts[blk] = groups[blk].starts;
    153         ends_gte_17[blk] = groups[blk].ends_gte_17;
     147                                h0[blk] = hash[blk].h0;
     148                                h1[blk] = hash[blk].h1;
     149                                starts[blk] = groups[blk].starts;
     150                                ends_gte_17[blk] = groups[blk].ends_gte_17;
    154151      }
    155152
     
    175172      uint32_t blk_offset;
    176173      for(int blk=0;blk<SEGMENT_BLOCKS;blk++) {
    177           blk_offset = blk * BLOCKSIZE;
    178           gid_type gid;
    179           ForwardScanner<BitBlock, scanword_t> fscanner(&(groups[blk].starts));
    180 
    181           fscanner.scan_to_next();
    182           while(!fscanner.is_done()) {
    183               gid = symbols.gids[fscanner.get_pos() + blk_offset];
    184   //        cout <<"Symbol[" << fscanner.get_pos() << "] = "
    185   //                << "(gid:" << gid << ",raw:"
    186   //                << string((char *)symbol_table.get_raw_data(gid), symbol_table.get_lgth(gid))<< ")" << endl;
    187               cout << string((char *)symbol_table.get_raw_data(gid), symbol_table.get_lgth(gid)) << ",";
    188 
    189               fscanner.scan_to_next();
    190 
    191           }
     174                                blk_offset = blk * BLOCKSIZE;
     175                                gid_type gid;
     176                                ForwardScanner<BitBlock, scanword_t> fscanner(&(groups[blk].starts));
     177
     178                                fscanner.scan_to_next();
     179                                while(!fscanner.is_done()) {
     180                                        gid = symbols.gids[fscanner.get_pos() + blk_offset];
     181                                        cout << string((char *)symbol_table.get_raw_data(gid), symbol_table.get_lgth(gid)) << ",";
     182                                        fscanner.scan_to_next();
     183                                }
    192184      }
    193185    }
     
    200192    uint32_t blk = 0;
    201193    while (remaining >= BLOCK_SIZE) {
    202         s2p_do_block((BytePack *) &raw_buffer[blk*BLOCK_SIZE], basis_bits[blk]);
    203         markers_do_block(basis_bits[blk], markers[blk]);
    204         hash_strms_do_block(basis_bits[blk], hash[blk]);
    205         identity_group_do_block(markers[blk], groups[blk]);
    206         blk++;
    207         remaining -= BLOCK_SIZE;
     194                        s2p_do_block((BytePack *) &raw_buffer[blk*BLOCK_SIZE], basis_bits[blk]);
     195                        markers_do_block(basis_bits[blk], markers[blk]);
     196                        hash_strms_do_block(basis_bits[blk], hash[blk]);
     197                        identity_group_do_block(markers[blk], groups[blk]);
     198                        blk++;
     199                        remaining -= BLOCK_SIZE;
    208200    }
    209201
     
    212204    ///////////////////////////////////////////////////////////////////////////
    213205    if (remaining > 0 || @marker_strms_any_carry /*|| hash_strms_any_carry*/) {
    214           BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
    215           s2p_do_final_block((BytePack *) &raw_buffer[blk*BLOCK_SIZE], basis_bits[blk], EOF_mask);
    216           markers_do_final_block(basis_bits[blk], markers[blk], EOF_mask);
    217           hash_strms_do_final_block(basis_bits[blk], hash[blk], EOF_mask);
    218           identity_group_do_final_block(markers[blk], groups[blk], EOF_mask);
    219           blk++;
    220     }
    221 
    222 //    for(int k=0;k<blk;k++) {
    223 //      cout << "RAW " << string((((char*)&raw_buffer[0])+k*BLOCK_SIZE),BLOCK_SIZE) << endl;
    224 //    }
     206                        BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-remaining));
     207                        s2p_do_final_block((BytePack *) &raw_buffer[blk*BLOCK_SIZE], basis_bits[blk], EOF_mask);
     208                        markers_do_final_block(basis_bits[blk], markers[blk], EOF_mask);
     209                        hash_strms_do_final_block(basis_bits[blk], hash[blk], EOF_mask);
     210                        identity_group_do_final_block(markers[blk], groups[blk], EOF_mask);
     211                        blk++;
     212    }
    225213
    226214    uint32_t segment_size = blk;
    227215    for(int blk=0;blk<segment_size;blk++) { // write contiguous hash bit streams
    228         h0[blk] = hash[blk].h0;
    229         h1[blk] = hash[blk].h1;
    230         starts[blk] = groups[blk].starts;
    231         ends_gte_17[blk] = groups[blk].ends_gte_17;
     216                        h0[blk] = hash[blk].h0;
     217                        h1[blk] = hash[blk].h1;
     218                        starts[blk] = groups[blk].starts;
     219                        ends_gte_17[blk] = groups[blk].ends_gte_17;
    232220    }
    233221
     
    238226    uint32_t blk_offset;
    239227    for(int blk=0;blk<segment_size;blk++) {
    240         blk_offset = blk * BLOCKSIZE;
    241         gid_type gid;
    242         ForwardScanner<BitBlock, scanword_t> fscanner(&(groups[blk].starts));
    243 
    244         fscanner.scan_to_next();
    245         while(!fscanner.is_done()) {
    246             gid = symbols.gids[fscanner.get_pos() + blk_offset];
    247 //          cout <<"Symbol[" << fscanner.get_pos() << "] = "
    248 //                  << "(gid:" << gid << ",raw:"
    249 //                  << string((char *)symbol_table.get_raw_data(gid), symbol_table.get_lgth(gid))<< ")" << endl;
    250             cout << string((char *)symbol_table.get_raw_data(gid), symbol_table.get_lgth(gid)) << ",";
    251 
    252             fscanner.scan_to_next();
    253         }
     228                        blk_offset = blk * BLOCKSIZE;
     229                        gid_type gid;
     230                        ForwardScanner<BitBlock, scanword_t> fscanner(&(groups[blk].starts));
     231
     232                        fscanner.scan_to_next();
     233                        while(!fscanner.is_done()) {
     234                                gid = symbols.gids[fscanner.get_pos() + blk_offset];
     235                                cout << string((char *)symbol_table.get_raw_data(gid), symbol_table.get_lgth(gid)) << ",";
     236                                fscanner.scan_to_next();
     237                        }
    254238
    255239    }
Note: See TracChangeset for help on using the changeset viewer.