Ignore:
Timestamp:
Nov 20, 2012, 5:29:13 PM (6 years ago)
Author:
linmengl
Message:

use store_unaligned to for speed

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/CSV/csv2xml/pablo_template.cpp

    r2611 r2663  
    4545#define LOOKAHEAD_BLOCKS 1
    4646#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
    47 #define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
     47#define SEGMENT_BLOCKS 15 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
    4848#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
    4949#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
     
    5555BitBlock Simd_const_even = simd<4>::constant<5>();
    5656
    57 BitBlock parse_quote_mask(BitBlock quote)
     57inline BitBlock parse_quote_mask(BitBlock quote)
    5858{
    5959    BitBlock p2, p4, p8, p16, p32, p64;
     
    9292#include "../lib/transpose.hpp"
    9393#include "../util/csv2xmlwriter.hpp"
     94#include "../util/bitsegment_iterator.hpp"
    9495
    9596static void do_process(FILE *infile, FILE *outfile);
     
    131132    printf("Process %s as input and %s as output\n", infilename, outfilename);
    132133
    133     FILE *infile = fopen(infilename, "r");
    134     FILE *outfile = fopen(outfilename, "w");
     134    FILE *infile = fopen(infilename, "rb");
     135    FILE *outfile = fopen(outfilename, "wb");
     136    setbuf(outfile, NULL); //shutdown default buffer system
     137    // printf("setvbuf = %d\n", setvbuf(outfile, NULL, _IOFBF, SEGMENT_SIZE * 16));
    135138
    136139    PERF_SEC_BIND(1);
     
    150153}
    151154
     155class IteratorPackage
     156{
     157public:
     158    BitSegment<SEGMENT_BLOCKS> delimSeg, eolSeg, andSeg, hideSeg;
     159
     160    IteratorPackage()
     161    {
     162        init();
     163    }
     164
     165    void init()
     166    {
     167        delimSeg.clear();
     168        eolSeg.clear();
     169        andSeg.clear();
     170        hideSeg.clear();
     171    }
     172
     173    void append(Marker &marker, Lex &lex)
     174    {
     175        delimSeg.append(marker.delim);
     176        eolSeg.append(marker.eol);
     177        andSeg.append(lex.AndSymbol);
     178        hideSeg.append(marker.hide);
     179    }
     180};
     181
    152182class BufferToXMLParser
    153183{
    154     BitBlockForwardIterator delimIter, eolIter, andIter, hideIter;
    155     BitBlockForwardIterator end;
     184    BitSegmentForwardIterator delimIter, eolIter, andIter, hideIter;
    156185    uint8_t *src_buffer;
    157186    Csv2XmlWriter *writer;
     187    IteratorPackage *package;
    158188
    159189public:
    160190
    161     BufferToXMLParser(Marker &marker, Lex &lex, uint8_t *buffer, Csv2XmlWriter *_writer)
    162     {
    163         delimIter = BitBlockForwardIterator(&marker.delim);
    164         eolIter = BitBlockForwardIterator(&marker.eol);
    165         andIter = BitBlockForwardIterator(&lex.AndSymbol);
    166         hideIter = BitBlockForwardIterator(&marker.hide);
    167 
     191    BufferToXMLParser(uint8_t *buffer, Csv2XmlWriter *_writer, IteratorPackage *_package, int n)
     192        : delimIter(_package->delimSeg.address(), n), eolIter(_package->eolSeg.address(), n),
     193            andIter(_package->andSeg.address(), n), hideIter(_package->hideSeg.address(), n)
     194    {
    168195        src_buffer = buffer;
    169196        writer = _writer;
     197        package = _package;
    170198    }
    171199
     
    174202        int pos = 0;
    175203
    176         while (eolIter != end)
     204        while (!eolIter.is_end())
    177205        {
    178206            parseRowWithoutLastColumn(pos, *eolIter);
     
    186214            pos = *eolIter + 1;
    187215
    188             eolIter ++;
     216            ++ eolIter;
    189217            writer->nextRow();
    190218        }
     
    206234    void parseRowWithoutLastColumn(int &pos, int endofline)
    207235    {
    208         BitBlockForwardIterator end;
    209         while ((delimIter != end) && (*delimIter < endofline))
     236        while ((!delimIter.is_end()) && (*delimIter < endofline))
    210237        {
    211238            int length = *delimIter - pos;
     
    213240            writer->nextCol();
    214241            pos = (*delimIter) + 1;
    215             delimIter++;
     242            ++delimIter;
    216243        }
    217244    }
     
    221248        char text[10] = "&amp;";
    222249
    223         if (startPos + length >= BLOCK_SIZE + 1)
    224         {
    225             printf("bufPrint memory leak!\n");
    226             exit(-1);
    227         }
    228 
    229250        while (length > 0)
    230251        {
    231             while ((andIter != end) && *andIter < startPos) andIter++;
    232 
    233             if (andIter != end && *andIter < startPos + length)
     252            while ((!andIter.is_end()) && *andIter < startPos) ++andIter;
     253
     254            if (!andIter.is_end() && *andIter < startPos + length)
    234255            {
    235256                bufPrintWithHideSymbol(startPos, *andIter - startPos);
    236                 writer->writeColumn(text);
     257                writer->writeColumn(text, 5);
    237258
    238259                length -= *andIter - startPos + 1;
     
    251272        while (length > 0)
    252273        {
    253             while (hideIter != end && *hideIter < startPos) hideIter++;
    254 
    255             if (hideIter != end && *hideIter < startPos + length)
     274            while (!hideIter.is_end() && *hideIter < startPos) ++hideIter;
     275
     276            if (!hideIter.is_end() && *hideIter < startPos + length)
    256277            {
    257278                bufPrintSimple(startPos, *hideIter - startPos);
     
    270291    {
    271292        uint8_t *p = src_buffer + startPos;
    272         uint8_t temp = p[length];
    273         p[length] = 0;
    274         writer->writeColumn((char *)p);
    275         p[length] = temp;
     293        writer->writeColumn((char *)p, length);
    276294    }
    277295};
     
    279297void do_process(FILE *infile, FILE *outfile) {
    280298
    281     @decl
     299    @decl;
    282300
    283301    BitBlock buf[9];//watch out buffer size, may cause memory leak!! shit!!
     302    BitBlock segBuf[9 * SEGMENT_BLOCKS];
    284303
    285304    uint8_t * src_buffer = (uint8_t *) buf;
     305    uint8_t * seg_buffer = (uint8_t *) segBuf;
    286306    size_t count;
    287307
    288     @stream_stmts
     308    @stream_stmts;
    289309
    290310    Csv2XmlWriter writer(outfile);
    291311    FlipSignal = ZERO;
    292     //if quoted string spanned more than 1 block, next block's FlipSignal should be 1
    293 
    294     while ((count = fread(src_buffer, sizeof(uint8_t), BLOCK_SIZE, infile)) > 0)
    295     {
     312
     313    bool infile_end = false;
     314    int segment_count;
     315    int segment_blocks;
     316    unsigned long long infile_count = 0;
     317    IteratorPackage package;
     318
     319    while (!infile_end)
     320    {
     321        segment_count = 0;
     322        segment_blocks = 0;
     323        package.init();
    296324        PERF_SEC_START(parser_timer);
    297325
    298         if (count < BLOCK_SIZE)
    299         {
    300             EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-count));
    301             s2p_do_final_block((BytePack *) src_buffer, basis_bits, EOF_mask);
    302             @final_block_stmts
    303         }
    304         else
    305         {
    306             s2p_do_block((BytePack *) src_buffer, basis_bits);
    307             @block_stmts
    308         }
    309 
    310         FlipSignal = ZERO;
    311         if (bitblock::any(simd_and(marker.quote_mask, HIGH_ONE)))
    312         {
    313             FlipSignal = ONE;
    314         }
    315 
    316         PERF_SEC_END(parser_timer, count);
    317 
    318         BufferToXMLParser bufParser(marker, lex, src_buffer, &writer);
    319         bufParser.parseEachRow(count);
    320     }
     326
     327        //if quoted string spanned more than 1 block, next block's FlipSignal should be 1
     328        while (segment_blocks < SEGMENT_BLOCKS && (count = fread(src_buffer, sizeof(uint8_t), BLOCK_SIZE, infile)) > 0)
     329        {
     330            memcpy(seg_buffer + segment_count, src_buffer, count);
     331            segment_blocks ++;
     332            segment_count += count;
     333            infile_count += count;
     334
     335            if (count < BLOCK_SIZE)
     336            {
     337                EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-count));
     338                s2p_do_final_block((BytePack *) src_buffer, basis_bits, EOF_mask);
     339                @final_block_stmts
     340            }
     341            else
     342            {
     343                s2p_do_block((BytePack *) src_buffer, basis_bits);
     344                @block_stmts
     345                FlipSignal = ZERO;
     346                if (bitblock::any(simd_and(marker.quote_mask, HIGH_ONE)))
     347                {
     348                    FlipSignal = ONE;
     349                }
     350            }
     351
     352            package.append(marker, lex);
     353        }
     354
     355        if (segment_count)
     356        {
     357            BufferToXMLParser bufParser(seg_buffer, &writer, &package, segment_blocks);
     358            bufParser.parseEachRow(segment_count);
     359            writer.flush();
     360
     361            PERF_SEC_END(parser_timer, segment_count);
     362        }
     363
     364        if (segment_blocks < SEGMENT_BLOCKS)
     365        {
     366            infile_end = true;
     367        }
     368    }
     369
     370
     371    printf("input: %lld\t", infile_count);
     372    printf("output: %lld\t", writer._outCount);
     373    printf("rate: %lf\n", (double) writer._outCount / (double) infile_count);
    321374}
Note: See TracChangeset for help on using the changeset viewer.