Ignore:
Timestamp:
Nov 18, 2013, 6:21:18 AM (6 years ago)
Author:
cameron
Message:

simd-lib updates

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icXML/icXML-devel/src/simd-lib/carryQ.hpp

    r2720 r3567  
    1212=============================================================================*/
    1313
     14#include <string.h>
    1415#include <stdint.h>
    1516#include <iostream>
     
    4344}
    4445
    45 
    46 #include <string.h>
    47 
     46template <uint16_t CarryCount, uint16_t AdvanceNCount> class CarryArray;
     47
     48#define LocalCarryCombine(carrySet, localCarry, carryNo, carryCount)\
     49        carrySet.CarryCombine(localCarry.cq, carryNo, carryCount); 
     50
     51#define CarryDeclare(name, carry1_count, carryN_count)\
     52CarryArray<carry1_count, carryN_count> name;
    4853
    4954// Array of BitBlock implementation.
     
    5358public:
    5459
    55     #define Carry0 simd<BLOCK_SIZE>::constant<0>()
    56     #define Carry1 simd<BLOCK_SIZE>::constant<1>()
    57  
    58         BitBlock cq[CarryCount + AdvanceNCount];
     60#ifndef CARRY64
     61    #define carry_value_0 simd<BLOCK_SIZE>::constant<0>()
     62    #define carry_value_1 simd<BLOCK_SIZE>::constant<1>()
     63#endif
     64#ifdef CARRY64
     65    #define carry_value_0 0
     66    #define carry_value_1 1
     67#endif
     68
     69        carry_t cq[CarryCount + AdvanceNCount];
    5970        //BitBlock pending64[AdvanceNCount];
    6071        CarryArray()
    6172        {
    62             memset (cq, 0, sizeof(BitBlock) * (CarryCount + AdvanceNCount));
     73            memset (cq, 0, sizeof(carry_t) * (CarryCount + AdvanceNCount));
    6374            //memset(pending64, 0, sizeof(BitBlock) * AdvanceNCount);
    6475        }
    6576        ~CarryArray() {}
    6677
    67         IDISA_ALWAYS_INLINE BitBlock BitBlock_advance_ci_co(BitBlock strm, BitBlock carryin, uint16_t carryno)
     78        IDISA_ALWAYS_INLINE BitBlock BitBlock_advance_ci_co(BitBlock strm, carry_t carryin, uint16_t carryno)
    6879        {
    6980                BitBlock rslt;
     
    7283        }
    7384
    74         IDISA_ALWAYS_INLINE BitBlock BitBlock_add_ci_co(BitBlock strm1, BitBlock strm2, BitBlock carryin, const uint16_t carryno)
     85        IDISA_ALWAYS_INLINE BitBlock BitBlock_add_ci_co(BitBlock strm1, BitBlock strm2, carry_t carryin, const uint16_t carryno)
    7586        {
    7687                BitBlock sum;
     
    7990        }
    8091
    81         IDISA_ALWAYS_INLINE BitBlock BitBlock_sub_ci_co(BitBlock strm1, BitBlock strm2, BitBlock carryin, uint16_t carryno)
     92        IDISA_ALWAYS_INLINE BitBlock BitBlock_sub_ci_co(BitBlock strm1, BitBlock strm2, carry_t carryin, uint16_t carryno)
    8293        {
    8394                BitBlock diff;
     
    8697        }
    8798
    88         IDISA_ALWAYS_INLINE BitBlock BitBlock_scantofirst(BitBlock charclass, BitBlock carryin, uint16_t carryno)
     99        IDISA_ALWAYS_INLINE BitBlock BitBlock_scantofirst(BitBlock charclass, carry_t carryin, uint16_t carryno)
    89100        {
    90101                BitBlock marker;
     
    95106        }
    96107
    97         IDISA_ALWAYS_INLINE BitBlock BitBlock_scanthru_ci_co(BitBlock markers0, BitBlock charclass, BitBlock carryin, uint16_t carryno)
     108        IDISA_ALWAYS_INLINE BitBlock BitBlock_scanthru_ci_co(BitBlock markers0, BitBlock charclass, carry_t carryin, uint16_t carryno)
    98109        {
    99110                BitBlock markers1;
     
    102113        }
    103114
    104         IDISA_ALWAYS_INLINE BitBlock BitBlock_advance_then_scanthru(BitBlock markers0, BitBlock charclass, BitBlock carryin, uint16_t carryno)
     115        IDISA_ALWAYS_INLINE BitBlock BitBlock_advance_then_scanthru(BitBlock markers0, BitBlock charclass, carry_t carryin, uint16_t carryno)
    105116        {
    106117                BitBlock markers1;
     
    110121        }
    111122
    112         IDISA_ALWAYS_INLINE BitBlock BitBlock_span_upto(BitBlock starts, BitBlock follows, BitBlock carryin, uint16_t carryno)
     123        IDISA_ALWAYS_INLINE BitBlock BitBlock_span_upto(BitBlock starts, BitBlock follows, carry_t carryin, uint16_t carryno)
    113124        {
    114125                BitBlock span;
     
    117128        }
    118129
    119         IDISA_ALWAYS_INLINE BitBlock BitBlock_inclusive_span(BitBlock starts, BitBlock ends, BitBlock carryin, uint16_t carryno)
     130        IDISA_ALWAYS_INLINE BitBlock BitBlock_inclusive_span(BitBlock starts, BitBlock ends, carry_t carryin, uint16_t carryno)
    120131        {
    121132                BitBlock span;
     
    124135        }
    125136
    126         IDISA_ALWAYS_INLINE BitBlock BitBlock_exclusive_span(BitBlock starts, BitBlock ends, BitBlock carryin, uint16_t carryno)
     137        IDISA_ALWAYS_INLINE BitBlock BitBlock_exclusive_span(BitBlock starts, BitBlock ends, carry_t carryin, uint16_t carryno)
    127138        {
    128139                BitBlock span;
     
    131142        }
    132143
    133 
     144/*
    134145        IDISA_ALWAYS_INLINE BitBlock BitBlock_advance32_ci_co(BitBlock strm, uint32_t pending_in, uint32_t & pending_out)
    135146        {
     
    137148                return simd_or(simd<BLOCK_SIZE>::slli<32>(strm), mvmd<BLOCK_SIZE>::fill((uint64_t)pending_in));
    138149        }
    139 
    140         template <int n> IDISA_ALWAYS_INLINE BitBlock BitBlock_advance_n_(BitBlock strm, BitBlock pending_in, uint16_t pendingno)
     150*/
     151
     152/*
     153        template <int n> IDISA_ALWAYS_INLINE BitBlock BitBlock_advance_n_(BitBlock strm, carry_t pending_in, uint16_t pendingno)
    141154        {
    142155                BitBlock half_block_shifted = esimd<BLOCK_SIZE/2>::mergel(strm, pending_in);
     
    147160                return result;
    148161        }
     162*/
    149163
    150164        IDISA_ALWAYS_INLINE bool CarryTest(uint16_t carryno, uint16_t carry_count)
    151 
    152 
    153         {
    154                   BitBlock c1 = cq[carryno];
     165        {
     166                  carry_t c1 = cq[carryno];
    155167                  int ubound = carryno + carry_count;
    156168                  for (int i = carryno + 1; i < ubound ; i++) {
     
    160172        }
    161173
     174        IDISA_ALWAYS_INLINE carry_t CarryRange(uint16_t carryno, uint16_t carry_count)
     175        {
     176                  carry_t c1 = cq[carryno];
     177                  int ubound = carryno + carry_count;
     178                  for (int i = carryno + 1; i < ubound ; i++) {
     179                        c1 = carry_or(c1, cq[i]);
     180                  }
     181                  return c1;
     182        }
     183
    162184        IDISA_ALWAYS_INLINE void CarryDequeueEnqueue(uint16_t carryno, uint16_t carry_count)
    163185        {
     
    165187        }
    166188
     189        // Deprecated (renamed)
    167190        IDISA_ALWAYS_INLINE void CarryQ_Adjust(uint16_t carry_count)
    168191        {
     
    170193        }
    171194
    172         IDISA_ALWAYS_INLINE void CarryCombine(BitBlock local_cq[], uint16_t carryno, uint16_t carry_count)
     195        IDISA_ALWAYS_INLINE void CarryAdjust(uint16_t carry_count)
     196        {
     197                return;
     198        }
     199
     200        IDISA_ALWAYS_INLINE void CarryCombine(carry_t local_cq[], uint16_t carryno, uint16_t carry_count)
    173201        {
    174202                  for (int i = 0; i < carry_count; i++) {
     
    180208        {
    181209                  cq[carryno] = carry_or(cq[carryno], cq[carry2]);
    182                   cq[carry2] = Carry0;
    183         }
    184 
    185         IDISA_ALWAYS_INLINE BitBlock get_carry_in(uint16_t carryno) const
    186         {
    187                 return carry2bitblock(cq[carryno]);
    188         }
    189 
    190 //      IDISA_ALWAYS_INLINE BitBlock get_pending64(uint16_t advance_n_blkno) const
    191 //      {
    192 //              return pending64[advance_n_blkno];
    193 //      }
    194 
    195         IDISA_ALWAYS_INLINE BitBlock get_pending64(uint16_t advance_n_blkno) const
     210                  cq[carry2] = carry_value_0;
     211        }
     212
     213        IDISA_ALWAYS_INLINE carry_t get_carry_in(uint16_t carryno) const
     214        {
     215                return cq[carryno];
     216        }
     217
     218        // Deprecated (renamed)
     219        IDISA_ALWAYS_INLINE carry_t GetCarry(uint16_t carryno) const
     220        {
     221                return cq[carryno];
     222        }
     223
     224        IDISA_ALWAYS_INLINE void SetCarry(carry_t carryVal, uint16_t carryno)
     225        {
     226                cq[carryno] = carryVal;
     227        }
     228
     229
     230        // Deprecated in PabloJ, retained for legacy compiler.
     231        IDISA_ALWAYS_INLINE carry_t get_pending64(uint16_t advance_n_blkno) const
     232        {
     233                return cq[CarryCount + advance_n_blkno];
     234        }
     235
     236        IDISA_ALWAYS_INLINE carry_t Pending64(uint16_t advance_n_blkno) const
    196237        {
    197238                return cq[CarryCount + advance_n_blkno];
     
    200241//private:
    201242        // helpers
    202         IDISA_ALWAYS_INLINE BitBlock carry_flip(BitBlock carry) const
    203         {
    204                 return simd_xor(carry, Carry1);
    205         }
    206 
    207         IDISA_ALWAYS_INLINE bool test_carry(BitBlock carry) const
     243#ifndef  CARRY64
     244        // Deprecated (renamed)
     245        IDISA_ALWAYS_INLINE carry_t carry_flip(carry_t carry) const
     246        {
     247                return simd_xor(carry, carry_value_1);
     248        }
     249
     250        IDISA_ALWAYS_INLINE BitBlock CarryFlip(carry_t carry) const
     251        {
     252                return simd_xor(carry, carry_value_1);
     253        }
     254
     255        IDISA_ALWAYS_INLINE bool test_carry(carry_t carry) const
    208256        {
    209257                return bitblock::any(carry);
    210258        }
    211259
    212         IDISA_ALWAYS_INLINE BitBlock carry_or(BitBlock carry1, BitBlock carry2) const
     260        IDISA_ALWAYS_INLINE carry_t carry_or(carry_t carry1, carry_t carry2) const
    213261        {
    214262                return simd_or(carry1, carry2);
    215263        }
    216        
    217 #undef Carry0
    218 #undef Carry1
     264#endif
     265#ifdef  CARRY64
     266        // Deprecated (renamed)
     267        IDISA_ALWAYS_INLINE carry_t carry_flip(carry_t carry) const
     268        {
     269                return carry ^ 1;
     270        }
     271
     272        IDISA_ALWAYS_INLINE BitBlock CarryFlip(carry_t carry) const
     273        {
     274                return carry ^ 1;
     275        }
     276
     277        IDISA_ALWAYS_INLINE bool test_carry(carry_t carry) const
     278        {
     279                return carry != 0;
     280        }
     281
     282        IDISA_ALWAYS_INLINE carry_t carry_or(carry_t carry1, carry_t carry2) const
     283        {
     284                return carry1 | carry2;
     285        }
     286#endif
    219287
    220288};
Note: See TracChangeset for help on using the changeset viewer.