Changeset 16855 for trunk/Mars/mcore


Ignore:
Timestamp:
06/15/13 19:10:02 (11 years ago)
Author:
tbretz
Message:
Fixed a couple of issues including missing setting of badbit, broken returns and compilation with CINT, added some const qualifiers
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Mars/mcore/zfits.h

    r16844 r16855  
    1515
    1616
    17 #define FACT_RAW       0x0
    18 #define FACT_SMOOTHING 0x1
    19 #define FACT_HUFFMAN16 0x2
    20 
    21 #define FACT_COL_MAJOR 'C'
    22 #define FACT_ROW_MAJOR 'R'
    23 
    24 
    2517#ifndef __MARS__
    2618namespace std
    … …  
    3527    zfits(const string& fname, const string& tableName="",
    3628          bool force=false) : fits(fname, tableName, force),
    37         fBuffer(0),
    38         fTransposedBuffer(0),
    39         fCompressedBuffer(0),
    4029        fNumTiles(0),
    4130        fNumRowsPerTile(0),
    … …  
    5039    zfits(const string& fname, const string& fout, const string& tableName,
    5140          bool force=false) : fits(fname, fout, tableName, force),
    52               fBuffer(0),
    53               fTransposedBuffer(0),
    54               fCompressedBuffer(0),
    5541              fNumTiles(0),
    5642              fNumRowsPerTile(0),
    … …  
    8773
    8874private:
    89 
     75#ifndef __CINT__
    9076    //Structure helper for reading tiles headers
    91     typedef struct TileHeader
     77    struct TileHeader
    9278    {
    9379      char     id[4];
    … …  
    10288                                 size(s)
    10389      { };
    104     } __attribute__((__packed__)) TileHeader;
     90    } __attribute__((__packed__));
    10591
    10692    //Structure helper for reading blocks headers and compresion schemes
    107     typedef struct BlockHeader
     93    struct BlockHeader
    10894    {
    10995        uint64_t      size;
    … …  
    11399
    114100        BlockHeader(uint64_t      s=0,
    115                     char          o=FACT_ROW_MAJOR,
     101                    char          o='R'/*FACT_ROW_MAJOR*/,
    116102                    unsigned char n=1) : size(s),
    117103                                         ordering(o),
    118104                                         numProcs(n)
    119105        {}
    120     } __attribute__((__packed__)) BlockHeader;
    121 
     106    } __attribute__((__packed__));
     107#endif
    122108    // Do what it takes to initialize the compressed structured
    123109    void InitCompressionReading()
    … …  
    134120            if (it->comp != FACT)
    135121            {
     122                    clear(rdstate()|ios::badbit);
    136123#ifdef __EXCEPTIONS
    137                     throw runtime_error("ERROR: Only the FACT compression scheme is handled by this reader.");
     124                    throw runtime_error("Only the FACT compression scheme is handled by this reader.");
    138125#else
    139                     gLog << ___err___ << "ERROR: Only the FACT compression scheme is handled by this reader." << endl;
     126                    gLog << ___err___ << "ERROR - Only the FACT compression scheme is handled by this reader." << endl;
    140127                    return;
    141128#endif
    … …  
    144131        fColumnOrdering.resize(fTable.sortedCols.size());
    145132        for (auto it=fColumnOrdering.begin(); it != fColumnOrdering.end(); it++)
    146             (*it) = FACT_ROW_MAJOR;
     133            (*it) = 'R';//FACT_ROW_MAJOR;
     134
    147135        //Get compressed specific keywords
    148136        fNumTiles       = fTable.isCompressed ? GetInt("NAXIS2") : 0;
    … …  
    273261        const uint32_t requestedTile = rowNum/fNumRowsPerTile;
    274262        const uint32_t currentTile   = fCurrentRow/fNumRowsPerTile;
    275         const size_t   previousRow   = fCurrentRow;
    276263
    277264        fCurrentRow = rowNum;
    … …  
    285272            //skip to the beginning of the tile
    286273            seekg(fHeapOff+fCatalog[requestedTile][0].second - sizeof(TileHeader));
     274
    287275            TileHeader tHead;
    288276            read((char*)(&tHead), sizeof(TileHeader));
    … …  
    317305                switch (fColumnOrdering[i])
    318306                {
    319                     case FACT_ROW_MAJOR:
     307                case 'R': //FACT_ROW_MAJOR:
    320308                        // regular, "semi-transposed" copy
    321309                        for (char *dest=buffer; dest<buffer+thisRoundNumRows*fTable.bytes_per_row; dest+=fTable.bytes_per_row) // row-by-row
    … …  
    326314                    break;
    327315
    328                     case FACT_COL_MAJOR:
     316                case 'C'://FACT_COL_MAJOR:
    329317                        // transposed copy
    330318                        for (char *elem=buffer; elem<buffer+it->bytes; elem+=it->size) // element-by-element (arrays)
    … …  
    338326                    break;
    339327                    default:
     328                        clear(rdstate()|ios::badbit);
    340329    #ifdef __EXCEPTIONS
    341330                        throw runtime_error("Unkown column ordering scheme");
    342331    #else
    343332                        gLog << ___err___ << "ERROR - unkown column ordering scheme" << endl;
    344                         return;
     333                        return false;
    345334    #endif
    346335                    break;
    … …  
    417406            const int64_t compressedOffset = fTileOffsets[catalogCurrentRow][i];
    418407
    419             BlockHeader* head = reinterpret_cast<BlockHeader*>(&fCompressedBuffer[compressedOffset]);
     408            const BlockHeader* head = reinterpret_cast<BlockHeader*>(&fCompressedBuffer[compressedOffset]);
    420409
    421410            fColumnOrdering[i] = head->ordering;
    422411
    423             uint32_t numRows = (head->ordering==FACT_ROW_MAJOR) ? thisRoundNumRows : col.num;
    424             uint32_t numCols = (head->ordering==FACT_COL_MAJOR) ? thisRoundNumRows : col.num;
     412            const uint32_t numRows = (head->ordering=='R'/*FACT_ROW_MAJOR*/) ? thisRoundNumRows : col.num;
     413            const uint32_t numCols = (head->ordering=='C'/*FACT_COL_MAJOR*/) ? thisRoundNumRows : col.num;
    425414
    426415            const char *src = fCompressedBuffer.data()+compressedOffset+sizeof(BlockHeader)+sizeof(uint16_t)*head->numProcs;
    … …  
    432421                switch (head->processings[j])
    433422                {
    434                     case FACT_RAW:
     423                case 0x0://FACT_RAW:
    435424                            sizeWritten = UncompressUNCOMPRESSED(dest, src, numRows*numCols, col.size);
    436425                    break;
    437                     case FACT_SMOOTHING:
     426                case 0x1://FACT_SMOOTHING:
    438427                            sizeWritten = UnApplySMOOTHING(reinterpret_cast<int16_t*>(dest), numRows*numCols);
    439428                    break;
    440                     case FACT_HUFFMAN16:
     429                case 0x2://FACT_HUFFMAN16:
    441430                            sizeWritten = UncompressHUFFMAN16(dest, src, numRows);
    442431                    break;
    443432                    default:
     433                        clear(rdstate()|ios::badbit);
    444434#ifdef __EXCEPTIONS
    445435                    throw runtime_error("Unknown processing applied to data. Aborting");
    … …  
    448438                    return;
    449439#endif
    450                     break;
    451440                }
    452441                //increment destination counter only when processing done.
    … …  
    481470                break;
    482471            //padding or corrupt data
    483             if (tileHead.id[0] != 'T' || tileHead.id[1] != 'I' ||
    484                 tileHead.id[2] != 'L' || tileHead.id[3] != 'E')
     472            if (memcmp(tileHead.id, "TILE", 4))
    485473                break;
    486474
    487475            //a new tile begins here
    488             catalog.push_back(vector<pair<int64_t, int64_t> >(0));
     476            catalog.emplace_back(0);//push_back(vector<pair<int64_t, int64_t> >(0));
    489477            offsetInHeap += sizeof(TileHeader);
    490478
    … …  
    495483                if (fTable.sortedCols[i].num == 0)
    496484                {
    497                     catalog.back().push_back(make_pair(0,0));
     485                    catalog.back().emplace_back(0,0);
    498486                    continue;
    499487                }
    … …  
    503491                if (!good())
    504492                    break;
    505                 catalog.back().emplace_back(make_pair((int64_t)(columnHead.size),offsetInHeap));
     493                catalog.back().emplace_back(int64_t(columnHead.size),offsetInHeap);
    506494                offsetInHeap += columnHead.size;
    507495                seekg(fHeapOff+offsetInHeap);
    … …  
    522510            numRows        != fTable.num_rows)
    523511        {
     512                    clear(rdstate()|ios::badbit);
    524513#ifdef __EXCEPTIONS
    525                     throw runtime_error("Heap data does not agree with header. Aborting");
     514                    throw runtime_error("Heap data does not agree with header.");
    526515#else
    527516                    gLog << ___err___ << "ERROR - Heap data does not agree with header." << endl;
    … …  
    536525                    catalog[i][j].second != fCatalog[i][j].second)
    537526                {
     527                    clear(rdstate()|ios::badbit);
    538528#ifdef __EXCEPTIONS
    539                     throw runtime_error("Heap data does not agree with header. Aborting");
     529                    throw runtime_error("Heap data does not agree with header.");
    540530#else
    541531                    gLog << ___err___ << "ERROR - Heap data does not agree with header." << endl;
Note: See TracChangeset for help on using the changeset viewer.