Bitlarni faylga yozish funksiyasini optimallashtirish

1. Men sizning funktsiyangizdan statik o'zgaruvchilarni olib tashlashdan boshlardim. Ular biroz sekinroq, chunki har bir funktsiya chaqiruvida ularning holatini (allaqachon ishga tushirilgan yoki yo'q) sinab ko'rish kerak. Faqat ularni funktsiya doirasidan tashqariga ko'chiring.

2. Nima uchun bunday qisqa buferdan foydalanasiz? Har bir imzosiz uzunlikni faylga yozishingiz kerakligiga ishonchingiz komilmi? Men unsigned char buffer[1024] kabi biror narsadan foydalanishni tavsiya qilaman.

3. Keyin boshqa "if" iboralaridan qanday qutulish haqida o'ylashingiz kerak.

write() qo'ng'iroq o'rniga quyidagilarni sinab ko'ring:

OutFile.rdbuf()->sputn((char *) & BitBuffer, sizeof(BitBuffer));

Faylni ochish, unga yozishdan ancha sekinroq bo'lishi mumkin. Dizayningizda siz ochiq qo'ng'iroqlarni minimallashtirasizmi?

Agar sizni to'g'ri tushunsam, siz olgan belgisiz uzun butun sonning length pastki bitini yozmoqchisiz. Kerakli bitlarni maskalash orqali kirish bitlari orqali aylanishni saqlashingiz mumkin:

unsigned long long mask = (1ull << length) - 1; // creates a mask of 'length' 1's
BitBuffer = Data & mask;

Izoh sifatida, nima uchun testingiz va yozishingiz birinchi versiyada loop ichida ekanligini tushunmayapman.

Avvalo, kodni tushunarli bo'lishi uchun yozishingiz kerak. Kod bo'laklaringizning ikkalasini ham oson tushuna olmayman. Mana, birinchisini qayta formatlash va qayta tiklashga urinish soddaroq bo'lishi va ba'zi izohlar qo'shish:

/**
 * @brief Write some bits to a file.
 *
 * The bits are written MSB-first to a temporary 64-bit integer, which is
 * then written to the file in host byte-order.
 *
 * @param Data The data to write to the file.  Only the least-significant
 *             Length bits are written.  Of the bits that are written, the
 *             most significant bit is written first.
 * @param Length The length of the data to write, in bits.  Must be <= 64.
 * @param OutFile The file to write to
 *
 * @note This function is not thread-safe
 * @note This function stores some state in a static variable.  You must
 *       ensure that the total data written is a multiple of 64 bits, or
 *       some data will be lost.  You can only switch from one OutFile to
 *       another on a 64-bit boundry.
 */
void WriteBitsToFile(unsigned long long Data,
                     unsigned Length,
                     std::ofstream & OutFile)
{
   static unsigned long long BitBuffer = 0;
   static unsigned BitCounter = 0; 

   // Loop through input bits, one bit at a time
   for (int i = (int)Length; i >= 0; --i)
   {
      // Get the input bit
      unsigned long long NextBit = ((Data >> i) & 1);

      // Add it to the temporary buffer
      BitBuffer = ((BitBuffer << 1) | NextBit);
      BitCounter++;

      // If the temporary buffer is full, write it out
      if (BitCounter == 64)
      {
         OutFile.write((char *) & BitBuffer, sizeof(BitBuffer));
         BitCounter = 0;
      }
   }
}

Endi men nima qilmoqchi ekanligingizni tushundim ...

Sizning ikkinchi versiyangiz ancha yaxshi ko'rinadi, chunki siz bitli tsikldan qochasiz. Buni optimallashtirish haqida so'raganingiz uchun, menimcha, sizda bu sekin ekanligini ko'rsatadigan profillash natijalari bormi? Va menimcha, siz bu orqali juda ko'p ma'lumotlarni joylashtiryapsizmi?

Mumkin bo'lgan optimallashtirishlardan biri bu juda katta buferga yozish (men kamida 4 kB taklif qilaman). Bu shuni anglatadiki, write() ga tez-tez qo'ng'iroq qilishingiz shart emas. write() ni chaqirish nisbatan sekin bo'lishi mumkin.

Buni kattaroq bufer bilan qilishning bir usuli. (Pseudo-C# tilida)

const int wordSz= sizeof(unsigned long long)*8;

void WriteBitsToFile(unsigned long long Data, unsigned Length, std::ofstream & OutFile) { 
   static unsigned long long BitBuffer[BUFSZ+1] ={0};  
   static unsigned bitsSoFar = 0;

   Data &= (1 << Length) - 1; 
   int index = bitsSoFar/wordSz;
   int offset = bitsSoFar - (index*wordSz);
   BitBuffer[index]|=Data<<offset;
   int remainder = offset+length-wordSz;
   if (remainder > 0)
   {
      index++;
      BitBuffer[index]=Data>>(length-remainder);
   }
   bitsSoFar+=length;
   if (bitsPacked > BUFSZ*wordSz)
   {
      OutFile.write((char*)BitBuffer, BUFSZ*sizeof(unsigned long long));
      bitsSoFar-=BUFSZ*wordSz;
      BitBuffer[0]=BitBuffer[BUFSZ];
   }
}