C++におけるビット毎アクセスの実現

23562 ワード
C++ 大端小端 ビットアクセス 技術
私が起業したプロジェクトでは、ネットワーク帯域幅を節約するために、ネットワークでデータを伝送するにはコンパクトなアクセスが必要で、国防、科学研究、宇宙飛行、軍需産業など多くの分野でも同様の需要があります.
コンパクトなアクセスを実現し、1バイトずつアクセスするのではなく、ビットごとにアクセスします.例えば、1バイトでは、8つのbool情報を格納することができ、くだらないことは言わないで、直接コードを共有することができます(注釈:中のコードアルゴリズムは最適化に値します).
／／以下、関数定義
   
   
   
   
    
    
    
    
    
  1.  
    2. 
    
    
    
    
  2.  
    3. 
    
    
    
    
  3. /***********************************************************************/ 
    4. 
    
    
    
    
  4. /*       ： buffer                                            */ 
    5. 
    
    
    
    
  5. /*     pBuffer[in]：  buffer                                       */ 
    6. 
    
    
    
    
  6. /*     nStart[in]：                                              */ 
    7. 
    
    
    
    
  7. /*     nEnd[out]：                                             */ 
    8. 
    
    
    
    
  8. /*     retByte[out]：                                         */ 
    9. 
    
    
    
    
  9. /*     ：void                                                           */ 
    10. 
    
    
    
    
  10. /***********************************************************************/ 
    11. 
    
    
    
    
  11. void ReadOneBit( byte* pBuffer, int nStart, /* out */int& nEnd, /* out */ byte& retByte );  
    12. 
    
    
    
    
  12.  
    13. 
    
    
    
    
  13. /***********************************************************************/ 
    14. 
    
    
    
    
  14. /*       ：   buffer                                  */ 
    15. 
    
    
    
    
  15. /*     pBuffer[in]：  buffer                                       */ 
    16. 
    
    
    
    
  16. /*     nStart[in]：                                              */ 
    17. 
    
    
    
    
  17. /*     btLength[in]：                                            */ 
    18. 
    
    
    
    
  18. /*     nEnd[out]：                                             */ 
    19. 
    
    
    
    
  19. /*     retData[out]：       ，                        */ 
    20. 
    
    
    
    
  20. /*     ：void                                                           */ 
    21. 
    
    
    
    
  21. /***********************************************************************/ 
    22. 
    
    
    
    
  22. template<typename T>  
    23. 
    
    
    
    
  23. void  ReadDataFromBuffer( byte* pBuffer, int nStart, byte btLength, /* out */int& nEnd, /* out */ T& retData );  
    24. 
    
    
    
    
  24.  
    25. 
    
    
    
    
  25. /***********************************************************************/ 
    26. 
    
    
    
    
  26. /*       ：   buffer                                    */ 
    27. 
    
    
    
    
  27. /*     pBuffer[in]：  buffer                                       */ 
    28. 
    
    
    
    
  28. /*     nStart[in]：                                              */ 
    29. 
    
    
    
    
  29. /*     nCount[in]：                                             */ 
    30. 
    
    
    
    
  30. /*     nEnd[out]：                                             */ 
    31. 
    
    
    
    
  31. /*     pRetData[out]：                                      */ 
    32. 
    
    
    
    
  32. /*     ：void                                                           */ 
    33. 
    
    
    
    
  33. /***********************************************************************/ 
    34. 
    
    
    
    
  34. void ReadStringFromBuffer( byte* pBuffer, int nStart, int nCount, /* out */int& nEnd, /* out */char* pRetData );  
    35. 
    
    
    
    
  35.  
    36. 
    
    
    
    
  36.  
    37. 
    
    
    
    
  37.  
    38. 
    
    
    
    
  38. /***********************************************************************/ 
    39. 
    
    
    
    
  39. /*       ： buffer                                            */ 
    40. 
    
    
    
    
  40. /*     pBuffer[in]：  buffer                                       */ 
    41. 
    
    
    
    
  41. /*     btData[in]：                                            */ 
    42. 
    
    
    
    
  42. /*     nStart[in]：                                              */ 
    43. 
    
    
    
    
  43. /*     nEnd[out]：                                             */ 
    44. 
    
    
    
    
  44. /*     ：void                                                           */ 
    45. 
    
    
    
    
  45. /***********************************************************************/ 
    46. 
    
    
    
    
  46. void WriteOneBit( byte* pBuffer, byte btData, int nStart,  /* out */int& nEnd );  
    47. 
    
    
    
    
  47.  
    48. 
    
    
    
    
  48. /***********************************************************************/ 
    49. 
    
    
    
    
  49. /*       ：   buffer                                   */ 
    50. 
    
    
    
    
  50. /*     pBuffer[in]：  buffer                                       */ 
    51. 
    
    
    
    
  51. /*     tData[in]：       ，                           */ 
    52. 
    
    
    
    
  52. /*     nStart[in]：                                              */ 
    53. 
    
    
    
    
  53. /*     btLength[in]：                                            */ 
    54. 
    
    
    
    
  54. /*     nEnd[out]：                                             */ 
    55. 
    
    
    
    
  55. /*     ：void                                                           */ 
    56. 
    
    
    
    
  56. /***********************************************************************/ 
    57. 
    
    
    
    
  57. template<typename T>  
    58. 
    
    
    
    
  58. void  WriteDataToBuffer( byte* pBuffer, T tData, int nStart, byte btLength, /* out */int& nEnd );  
    59. 
    
    
    
    
  59.  
    60. 
    
    
    
    
  60. /***********************************************************************/ 
    61. 
    
    
    
    
  61. /*       ：   buffer                                    */ 
    62. 
    
    
    
    
  62. /*     pBuffer[in]：  buffer                                       */ 
    63. 
    
    
    
    
  63. /*     pchar[in]：                                           */ 
    64. 
    
    
    
    
  64. /*     nStart[in]：                                              */ 
    65. 
    
    
    
    
  65. /*     nCount[in]：                                             */ 
    66. 
    
    
    
    
  66. /*     nEnd[out]：                                             */ 
    67. 
    
    
    
    
  67. /*     ：void                                                           */ 
    68. 
    
    
    
    
  68. /***********************************************************************/ 
    69. 
    
    
    
    
  69. void WtriteStringToBuffer( byte* pBuffer, char* pchar, int nStart,  int nCount, /* out */int& nEnd  );  
    70.

//以下は関数実装
   
   
   
   
    
    
    
    
    
  1.  
    2. 
    
    
    
    
  2.  
    3. 
    
    
    
    
  3. void ReadOneBit( byte* pBuffer, int nStart, /* out */int& nEnd, /* out */ byte& retByte )  
    4. 
    
    
    
    
  4. {  
    5. 
    
    
    
    
  5.     byte btData = pBuffer[nStart/8];  
    6. 
    
    
    
    
  6.     btData = btData <
    7. 
    
    
    
    
  7.     retByte = btData >> 7;  
    8. 
    
    
    
    
  8.     nEnd = nStart+1;  
    9. 
    
    
    
    
  9. }  
    10. 
    
    
    
    
  10.  
    11. 
    
    
    
    
  11. template<typename T>  
    12. 
    
    
    
    
  12. void  ReadDataFromBuffer( byte* pBuffer, int nStart, byte btLength, /* out */int& nEnd, /* out */ T& retData )  
    13. 
    
    
    
    
  13. {  
    14. 
    
    
    
    
  14.     //      
    15. 
    
    
    
    
  15.     retData = 0;  
    16. 
    
    
    
    
  16.     if ( btLength > sizeof(T)*8 )  
    17. 
    
    
    
    
  17.         return ;  
    18. 
    
    
    
    
  18.       
    19. 
    
    
    
    
  19.     byte btData;  
    20. 
    
    
    
    
  20.     T tData;  
    21. 
    
    
    
    
  21.     while ( btLength-- )  
    22. 
    
    
    
    
  22.     {  
    23. 
    
    
    
    
  23.         ReadOneBit(pBuffer, nStart, nStart, btData);  
    24. 
    
    
    
    
  24.         tData = btData <
    25. 
    
    
    
    
  25.         retData |= tData;  
    26. 
    
    
    
    
  26.     }  
    27. 
    
    
    
    
  27.       
    28. 
    
    
    
    
  28.     nEnd = nStart;  
    29. 
    
    
    
    
  29. }  
    30. 
    
    
    
    
  30.  
    31. 
    
    
    
    
  31. void ReadStringFromBuffer( byte* pBuffer, int nStart, int nCount, /* out */int& nEnd, /* out */char* pRetData )  
    32. 
    
    
    
    
  32. {  
    33. 
    
    
    
    
  33.     for ( int nIndex=0; nIndex
    34. 
    
    
    
    
  34.     {  
    35. 
    
    
    
    
  35.         ReadDataFromBuffer(pBuffer, nStart, 8, nStart, pRetData[nIndex]);  
    36. 
    
    
    
    
  36.     }  
    37. 
    
    
    
    
  37.     nEnd = nStart;  
    38. 
    
    
    
    
  38. }  
    39. 
    
    
    
    
  39.  
    40. 
    
    
    
    
  40.  
    41. 
    
    
    
    
  41. void WriteOneBit( byte* pBuffer, byte btData, int nStart,  /* out */int& nEnd )  
    42. 
    
    
    
    
  42. {  
    43. 
    
    
    
    
  43.     int nSet = nStart / 8;  
    44. 
    
    
    
    
  44.     byte c = pBuffer[nSet];  
    45. 
    
    
    
    
  45.     switch ( btData )  
    46. 
    
    
    
    
  46.     {  
    47. 
    
    
    
    
  47.     case 1:  
    48. 
    
    
    
    
  48.         c |= ( 1 <
    49. 
    
    
    
    
  49.         break;  
    50. 
    
    
    
    
  50.     case 0:  
    51. 
    
    
    
    
  51.         c &= ( ~(1 <
    52. 
    
    
    
    
  52.         break;  
    53. 
    
    
    
    
  53.     default:  
    54. 
    
    
    
    
  54.         return;  
    55. 
    
    
    
    
  55.     }  
    56. 
    
    
    
    
  56.     pBuffer [nSet] = c;  
    57. 
    
    
    
    
  57.     nEnd = nStart +1;  
    58. 
    
    
    
    
  58. }  
    59. 
    
    
    
    
  59.  
    60. 
    
    
    
    
  60.  
    61. 
    
    
    
    
  61.  
    62. 
    
    
    
    
  62. template<typename T>  
    63. 
    
    
    
    
  63. void  WriteDataToBuffer( byte* pBuffer, T tData, int nStart, byte btLength, /* out */int& nEnd )  
    64. 
    
    
    
    
  64. {  
    65. 
    
    
    
    
  65. /* //       
    66. 
    
    
    
    
  66.     byte btDataLength = sizeof(T);  
    67. 
    
    
    
    
  67.     if ( btLength > sizeof(T)*8 )  
    68. 
    
    
    
    
  68.         return;  
    69. 
    
    
    
    
  69.       
    70. 
    
    
    
    
  70.     int nDataStart = 0; //         0，      
    71. 
    
    
    
    
  71.     while ( btLength-- )  
    72. 
    
    
    
    
  72.     {  
    73. 
    
    
    
    
  73.         byte bitData;  
    74. 
    
    
    
    
  74.         ReadOneBit((byte*)&tData, nDataStart, nDataStart, bitData);  
    75. 
    
    
    
    
  75.         WriteOneBit(pBuffer, bitData, nStart, nStart);  
    76. 
    
    
    
    
  76.     }  
    77. 
    
    
    
    
  77.       
    78. 
    
    
    
    
  78.     nEnd = nStart;  
    79. 
    
    
    
    
  79. */ 
    80. 
    
    
    
    
  80.  
    81. 
    
    
    
    
  81.     //     ： buffer   ，        
    82. 
    
    
    
    
  82.  
    83. 
    
    
    
    
  83.     //            
    84. 
    
    
    
    
  84.     byte btDataLength = sizeof(T);  
    85. 
    
    
    
    
  85.  
    86. 
    
    
    
    
  86.     //          
    87. 
    
    
    
    
  87.     if ( btLength > sizeof(T)*8 )  
    88. 
    
    
    
    
  88.         return;  
    89. 
    
    
    
    
  89.  
    90. 
    
    
    
    
  90.     //       byte*  
    91. 
    
    
    
    
  91.     byte* ptData = (byte*)&tData;   
    92. 
    
    
    
    
  92.  
    93. 
    
    
    
    
  93.     //      
    94. 
    
    
    
    
  94.     int nSet = btLength / 8;  
    95. 
    
    
    
    
  95.     int nRin = btLength % 8;  
    96. 
    
    
    
    
  96.       
    97. 
    
    
    
    
  97.     //            
    98. 
    
    
    
    
  98.     byte bitData;  
    99. 
    
    
    
    
  99.     byte byteData;  
    100. 
    
    
    
    
  100.     int nTempEnd;  
    101. 
    
    
    
    
  101.  
    102. 
    
    
    
    
  102.     //  rin    
    103. 
    
    
    
    
  103.     byteData = ptData[nSet];  
    104. 
    
    
    
    
  104.     while ( nRin-- )  
    105. 
    
    
    
    
  105.     {  
    106. 
    
    
    
    
  106.         ReadOneBit(&byteData, 7-nRin, nTempEnd, bitData);  
    107. 
    
    
    
    
  107.         WriteOneBit(pBuffer, bitData, nStart, nStart);  
    108. 
    
    
    
    
  108.     }  
    109. 
    
    
    
    
  109.  
    110. 
    
    
    
    
  110.     //  Set    
    111. 
    
    
    
    
  111.     while ( nSet )  
    112. 
    
    
    
    
  112.     {  
    113. 
    
    
    
    
  113.         byteData = ptData[--nSet];  
    114. 
    
    
    
    
  114.         //   byte  
    115. 
    
    
    
    
  115.         int i=0;  
    116. 
    
    
    
    
  116.         while ( i!=8 )  
    117. 
    
    
    
    
  117.         {  
    118. 
    
    
    
    
  118.             ReadOneBit(&byteData, i++, nTempEnd, bitData);  
    119. 
    
    
    
    
  119.             WriteOneBit(pBuffer, bitData, nStart, nStart);  
    120. 
    
    
    
    
  120.         }  
    121. 
    
    
    
    
  121.     }  
    122. 
    
    
    
    
  122.     nEnd = nStart;  
    123. 
    
    
    
    
  123.  
    124. 
    
    
    
    
  124. }  
    125. 
    
    
    
    
  125.  
    126. 
    
    
    
    
  126.  
    127. 
    
    
    
    
  127. void WtriteStringToBuffer( byte* pBuffer, char* pchar, int nStart,  int nCount, /* out */int& nEnd  )  
    128. 
    
    
    
    
  128. {  
    129. 
    
    
    
    
  129.     for ( int nIndex=0; nIndex
    130. 
    
    
    
    
  130.     {  
    131. 
    
    
    
    
  131.         WriteDataToBuffer(pBuffer, pchar[nIndex], nStart, 8, nStart);  
    132. 
    
    
    
    
  132.     }  
    133. 
    
    
    
    
  133.     nEnd = nStart;  
    134. 
    
    
    
    
  134. } 
    135.

kubernetesでRedisClusterを構築してみた
Pythonデータ構造の単一チェーンテーブル