Ignore:
Timestamp:
May 5, 2012, 4:32:26 PM (7 years ago)
Author:
ksherdy
Message:

Refactored build process. Added log2 support.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/symbol_table/src/symbol_table.hpp

    r2068 r2069  
    121121
    122122        // Groups & groups
    123         IDISA_ALWAYS_INLINE
    124         void resolve(uint32_t blk_offset, uint8_t buffer [], Groups & groups,  BitBlock starts[],
     123        IDISA_ALWAYS_INLINE void resolve(uint32_t blk_offset, uint8_t buffer [], Groups & groups,  BitBlock starts[],
    125124                                 BitBlock * h0, BitBlock * h1, GIDS & gids) {
    126125
     
    128127                        // Byte Space Hash (Fixed Length)
    129128                        ///////////////////////////////////////////////////////////////////////////////
    130                         #define BYTE_HASH_FIXED(GROUP, LGTH) \
     129                        #define BYTE_HASH_FIXED(GROUP_STRATEGY, LGTH, CMP_STRATEGY, HASH_STRATEGY) \
    131130                                if(bitblock::any(groups.ends_##LGTH)) { \
    132                                         do_block<GIDS, GROUP##_hash_table <LGTH, ALLOCATOR> > \
     131                                        do_block<GIDS, GROUP_STRATEGY##_hash_table <LGTH, CMP_STRATEGY, HASH_STRATEGY, ALLOCATOR> > \
    133132                                                (blk_offset, \
    134133                                                 hash_table_##LGTH, \
     
    139138                                }
    140139
    141 //                              //BYTE_HASH_FIXED(id,1);
    142                                 BYTE_HASH_FIXED(div2,2);
    143 //                              //BYTE_HASH_FIXED(id,3);
    144                                 BYTE_HASH_FIXED(div2,4);
    145 //                              //BYTE_HASH_FIXED(id,5);
    146                                 BYTE_HASH_FIXED(div2,6);
    147 //                              //BYTE_HASH_FIXED(id,7);
    148 
    149                         #undef BYTE_HASH_FIXED
    150 
    151140                        /////////////////////////////////////////////////////////////////////////////
    152141                        // Byte Space Variable Lengths (groups contain variable lengths)
    153142                        ///////////////////////////////////////////////////////////////////////////////
    154                         #define BYTE_HASH_VARIABLE(GROUP, LGTH) \
     143                        #define BYTE_HASH_VARIABLE(GROUP_STRATEGY, LGTH, CMP_STRATEGY, HASH_STRATEGY) \
    155144                                if(bitblock::any(groups.ends_##LGTH)) { \
    156                                         do_block<GIDS, GROUP##_hash_table <LGTH, ALLOCATOR> > \
     145                                        do_block<GIDS, GROUP_STRATEGY##_hash_table <LGTH, CMP_STRATEGY, HASH_STRATEGY, ALLOCATOR> > \
    157146                                                (blk_offset, \
    158147                                                 hash_table_##LGTH, \
     
    164153                                }
    165154
    166                                 //BYTE_HASH_VARIABLE(log2,1);
    167                                 //BYTE_HASH_VARIABLE(log2,2);
    168                                 //BYTE_HASH_VARIABLE(log2,4);
    169 
    170                         #undef BYTE_HASH_VARIABLE
    171155
    172156                        ///////////////////////////////////////////////////////////////////////////////
    173157                        // Bit Space Hash (Fixed Length)
    174158                        ///////////////////////////////////////////////////////////////////////////////
    175                         #define BIT_HASH_FIXED(GROUP, LGTH) \
     159                        #define BIT_HASH_FIXED(GROUP_STRATEGY, LGTH, CMP_STRATEGY, HASH_STRATEGY) \
    176160                                if(bitblock::any(groups.ends_##LGTH)) { \
    177                                         do_block<GIDS, GROUP##_hash_table <LGTH, ALLOCATOR> > \
     161                                        do_block<GIDS, GROUP_STRATEGY##_hash_table <LGTH, CMP_STRATEGY, HASH_STRATEGY, ALLOCATOR> > \
    178162                                                (blk_offset, \
    179163                                                 hash_table_##LGTH, \
     
    184168                                }
    185169
    186                                 BIT_HASH_FIXED(div2,8);
    187 //                              //BIT_HASH_FIXED(9);
    188                                 BIT_HASH_FIXED(div2,10);
    189 //                              //BIT_HASH_FIXED(11);
    190                                 BIT_HASH_FIXED(div2,12);
    191 //                              //BIT_HASH_FIXED(13);
    192                                 BIT_HASH_FIXED(div2,14);
    193 //                              //BIT_HASH_FIXED(15);
    194                                 BIT_HASH_FIXED(div2,16);
    195 
     170                        /////////////////////////////////////////////////////////////////////////////
     171                        // Byte Space Variable Lengths (groups contain variable lengths)
     172                        ///////////////////////////////////////////////////////////////////////////////
     173                        #define BIT_HASH_VARIABLE(GROUP_STRATEGY, LGTH, CMP_STRATEGY, HASH_STRATEGY) \
     174                                if(bitblock::any(groups.ends_##LGTH)) { \
     175                                        do_block<GIDS, GROUP_STRATEGY##_hash_table <LGTH, CMP_STRATEGY, HASH_STRATEGY, ALLOCATOR> > \
     176                                                (blk_offset, \
     177                                                 hash_table_##LGTH, \
     178                                                 starts, \
     179                                                 &groups.ends_##LGTH, \
     180                                                 buffer, \
     181                                                 (uint8_t *)h0, (uint8_t *)h1, (BLOCK_SIZE / 8), /* h0, h1, hash block size (bits) */ \
     182                                                 gids, this->gid_factory, this->gid_data); \
     183                                }
     184
     185                        ///////////////////////////////////////////////////////////////////////////////
     186                        // WARNING: BYTE_HASH max 8 bytes under the shift XOR hash approach of hash.hpp
     187                        //     ---> (id,7),(div2,6),(log2,4)
     188                        ///////////////////////////////////////////////////////////////////////////////
     189                        #ifdef ID_STRATEGY
     190                            BYTE_HASH_FIXED(id,1,compare_strategy_t<1>,hash_strategy_t<1>);
     191                            BYTE_HASH_FIXED(id,2,compare_strategy_t<2>,hash_strategy_t<2>);
     192                            BYTE_HASH_FIXED(id,3,compare_strategy_t<3>,hash_strategy_t<3>);
     193                            BYTE_HASH_FIXED(id,4,compare_strategy_t<4>,hash_strategy_t<4>);
     194                            BYTE_HASH_FIXED(id,5,compare_strategy_t<5>,hash_strategy_t<5>);
     195                            BYTE_HASH_FIXED(id,6,compare_strategy_t<6>,hash_strategy_t<6>);
     196                            BYTE_HASH_FIXED(id,7,compare_strategy_t<7>,hash_strategy_t<7>);
     197                            BIT_HASH_FIXED(id,8,compare_strategy_t<8>,hash_strategy_t<8>);
     198                            BIT_HASH_FIXED(id,9,compare_strategy_t<9>,hash_strategy_t<9>);
     199                            BIT_HASH_FIXED(id,10,compare_strategy_t<10>,hash_strategy_t<10>);
     200                            BIT_HASH_FIXED(id,11,compare_strategy_t<11>,hash_strategy_t<11>);
     201                            BIT_HASH_FIXED(id,12,compare_strategy_t<12>,hash_strategy_t<12>);
     202                            BIT_HASH_FIXED(id,13,compare_strategy_t<13>,hash_strategy_t<13>);
     203                            BIT_HASH_FIXED(id,14,compare_strategy_t<14>,hash_strategy_t<14>);
     204                            BIT_HASH_FIXED(id,15,compare_strategy_t<15>,hash_strategy_t<15>);
     205                            BIT_HASH_FIXED(id,16,compare_strategy_t<16>,hash_strategy_t<16>);
     206                        #elif DIV2_STRATEGY
     207                            BYTE_HASH_FIXED(div2,2,compare_strategy_t<2>,hash_strategy_t<2>);
     208                            BYTE_HASH_FIXED(div2,4,compare_strategy_t<4>,hash_strategy_t<4>);
     209                            BYTE_HASH_FIXED(div2,6,compare_strategy_t<6>,hash_strategy_t<6>);
     210                            BIT_HASH_FIXED(div2,8,compare_strategy_t<8>,hash_strategy_t<8>);
     211                            BIT_HASH_FIXED(div2,10,compare_strategy_t<10>,hash_strategy_t<10>);
     212                            BIT_HASH_FIXED(div2,12,compare_strategy_t<12>,hash_strategy_t<12>);
     213                            BIT_HASH_FIXED(div2,14,compare_strategy_t<14>,hash_strategy_t<14>);
     214                            BIT_HASH_FIXED(div2,16,compare_strategy_t<16>,hash_strategy_t<16>);
     215                        #elif LOG2_STRATEGY
     216                            BYTE_HASH_VARIABLE(log2,1,compare_strategy_t<0>,log_hash_strategy_t<1>);
     217                            BYTE_HASH_VARIABLE(log2,2,compare_strategy_t<0>,log_hash_strategy_t<2>);
     218                            BYTE_HASH_VARIABLE(log2,4,compare_strategy_t<0>,log_hash_strategy_t<4>);
     219                            BIT_HASH_VARIABLE(log2,8,compare_strategy_t<0>,log_hash_strategy_t<8>);
     220                            BIT_HASH_VARIABLE(log2,16,compare_strategy_t<0>,log_hash_strategy_t<16>);
     221                        #endif
     222
     223                        #undef BYTE_HASH_FIXED
     224                        #undef BYTE_HASH_VARIABLE
    196225                        #undef BIT_HASH_FIXED
     226                        #undef BIT_HASH_VARIABLE
    197227
    198228                        if(bitblock::any(groups.ends_gte_17)) {
    199 
    200                             do_block<GIDS, id_hash_table<0, ALLOCATOR> >
     229                            do_block<GIDS, id_hash_table<0, compare_strategy_t<0>, hash_strategy_t<0>, ALLOCATOR> >
    201230                                                (blk_offset,
    202231                                                 hash_table_gte_17,
     
    219248        // Byte Space Hash
    220249        ///////////////////////////////////////////////////////////////////////////////
    221 //      div2_hash_table<2, ALLOCATOR> hash_table_1_2;
    222 
    223 //      id_hash_table<1, ALLOCATOR> hash_table_1;
    224 //      id_hash_table<2, ALLOCATOR> hash_table_2;
    225 //      id_hash_table<3, ALLOCATOR> hash_table_3;
    226 //      id_hash_table<4, ALLOCATOR> hash_table_4;
    227 //      id_hash_table<5, ALLOCATOR> hash_table_5;
    228 //      id_hash_table<6, ALLOCATOR> hash_table_6;
    229 //      id_hash_table<7, ALLOCATOR> hash_table_7;
    230 
    231         div2_hash_table<2, ALLOCATOR> hash_table_2;
    232         div2_hash_table<4, ALLOCATOR> hash_table_4;
    233         div2_hash_table<6, ALLOCATOR> hash_table_6;
    234 
    235 //      log2_hash_table<1, ALLOCATOR> hash_table_1;
    236 //      log2_hash_table<2, ALLOCATOR> hash_table_2;
    237 //      log2_hash_table<4, ALLOCATOR> hash_table_4;
    238 
    239         ///////////////////////////////////////////////////////////////////////////////
    240         // Bit Space Hash
    241         ///////////////////////////////////////////////////////////////////////////////
    242 //      id_hash_table<8, ALLOCATOR> hash_table_8;
    243 //      id_hash_table<9, ALLOCATOR> hash_table_9;
    244 //      id_hash_table<10, ALLOCATOR> hash_table_10;
    245 //      id_hash_table<11, ALLOCATOR> hash_table_11;
    246 //      id_hash_table<12, ALLOCATOR> hash_table_12;
    247 //      id_hash_table<13, ALLOCATOR> hash_table_13;
    248 //      id_hash_table<14, ALLOCATOR> hash_table_14;
    249 //      id_hash_table<15, ALLOCATOR> hash_table_15;
    250 //      id_hash_table<16, ALLOCATOR> hash_table_16;
    251 //      id_hash_table<0, ALLOCATOR> hash_table_gte_17;
    252 
    253         div2_hash_table<8, ALLOCATOR> hash_table_8;
    254         div2_hash_table<10, ALLOCATOR> hash_table_10;
    255         div2_hash_table<12, ALLOCATOR> hash_table_12;
    256         div2_hash_table<14, ALLOCATOR> hash_table_14;
    257         div2_hash_table<16, ALLOCATOR> hash_table_16;
    258         id_hash_table<0, ALLOCATOR> hash_table_gte_17;
     250        #ifdef ID_STRATEGY
     251            id_hash_table<1, compare_strategy_t<1>, hash_strategy_t<1>, ALLOCATOR> hash_table_1;
     252            id_hash_table<2, compare_strategy_t<2>, hash_strategy_t<2>, ALLOCATOR> hash_table_2;
     253            id_hash_table<3, compare_strategy_t<3>, hash_strategy_t<3>, ALLOCATOR> hash_table_3;
     254            id_hash_table<4, compare_strategy_t<4>, hash_strategy_t<4>, ALLOCATOR> hash_table_4;
     255            id_hash_table<5, compare_strategy_t<5>, hash_strategy_t<5>, ALLOCATOR> hash_table_5;
     256            id_hash_table<6, compare_strategy_t<6>, hash_strategy_t<6>, ALLOCATOR> hash_table_6;
     257            id_hash_table<7, compare_strategy_t<7>, hash_strategy_t<7>, ALLOCATOR> hash_table_7;
     258            id_hash_table<8, compare_strategy_t<8>, hash_strategy_t<8>, ALLOCATOR> hash_table_8;
     259            id_hash_table<9, compare_strategy_t<9>, hash_strategy_t<9>, ALLOCATOR> hash_table_9;
     260            id_hash_table<10, compare_strategy_t<10>, hash_strategy_t<10>, ALLOCATOR> hash_table_10;
     261            id_hash_table<11, compare_strategy_t<11>, hash_strategy_t<11>, ALLOCATOR> hash_table_11;
     262            id_hash_table<12, compare_strategy_t<12>, hash_strategy_t<12>, ALLOCATOR> hash_table_12;
     263            id_hash_table<13, compare_strategy_t<13>, hash_strategy_t<13>, ALLOCATOR> hash_table_13;
     264            id_hash_table<14, compare_strategy_t<14>, hash_strategy_t<14>, ALLOCATOR> hash_table_14;
     265            id_hash_table<15, compare_strategy_t<15>, hash_strategy_t<15>, ALLOCATOR> hash_table_15;
     266            id_hash_table<16, compare_strategy_t<16>, hash_strategy_t<16>, ALLOCATOR> hash_table_16;
     267        #elif DIV2_STRATEGY
     268            div2_hash_table<2, compare_strategy_t<2>, hash_strategy_t<2>, ALLOCATOR> hash_table_2;
     269            div2_hash_table<4, compare_strategy_t<4>, hash_strategy_t<4>, ALLOCATOR> hash_table_4;
     270            div2_hash_table<6, compare_strategy_t<6>, hash_strategy_t<6>, ALLOCATOR> hash_table_6;
     271            div2_hash_table<8, compare_strategy_t<8>, hash_strategy_t<8>, ALLOCATOR> hash_table_8;
     272            div2_hash_table<10, compare_strategy_t<10>, hash_strategy_t<10>, ALLOCATOR> hash_table_10;
     273            div2_hash_table<12, compare_strategy_t<12>, hash_strategy_t<12>, ALLOCATOR> hash_table_12;
     274            div2_hash_table<14, compare_strategy_t<14>, hash_strategy_t<14>, ALLOCATOR> hash_table_14;
     275            div2_hash_table<16, compare_strategy_t<16>, hash_strategy_t<16>, ALLOCATOR> hash_table_16;
     276        #elif LOG2_STRATEGY
     277            log2_hash_table<1, compare_strategy_t<0>, log_hash_strategy_t<1>, ALLOCATOR> hash_table_1;
     278            log2_hash_table<2, compare_strategy_t<0>, log_hash_strategy_t<2>, ALLOCATOR> hash_table_2;
     279            log2_hash_table<4, compare_strategy_t<0>, log_hash_strategy_t<4>, ALLOCATOR> hash_table_4;
     280            log2_hash_table<8, compare_strategy_t<0>, log_hash_strategy_t<8>, ALLOCATOR> hash_table_8;
     281            log2_hash_table<16, compare_strategy_t<0>, log_hash_strategy_t<16>, ALLOCATOR> hash_table_16;
     282        #else
     283            #error "Length group strategy not specified. #define {ID_STRATEGY,DIV2_STRATEGY,LOG2_STRATEGY}."
     284        #endif
     285
     286        id_hash_table<0, compare_strategy_t<0>, hash_strategy_t<0>, ALLOCATOR> hash_table_gte_17;
    259287};
    260288
Note: See TracChangeset for help on using the changeset viewer.