Библиотеки: TickCompressor - со сжатием 1 тика до 2-3 байт в срднем - страница 2

fxsaber #:

Супер-круто!

Можно по аналогии попробовать.

Предполагаю, что Ваш побитовый вариант медленнее, потому что идет принудительный переход ushort->uint. А при делении и остатке перехода нет.

Как и из первых тестов использование & дало замедление 2% по самым быстрым вариантам

Вот сравнение по 3 запуска

/% версия  & версия 
Ticks: 4039748
Compressed size: 18729685
Decompressed ticks: 4039748
Decompress performance: 1830 MB/s
Decompress performance: 32.0 Ticks (millions)/sec.
Decompress performance criterion: 414.0
Correct = true

Ticks: 4039748
Compressed size: 18729685
Decompressed ticks: 4039748
Decompress performance: 1827 MB/s
Decompress performance: 31.9 Ticks (millions)/sec.
Decompress performance criterion: 413.2
Correct = true

Ticks: 4039748
Compressed size: 18729685
Decompressed ticks: 4039748
Decompress performance: 1849 MB/s
Decompress performance: 32.3 Ticks (millions)/sec.
Decompress performance criterion: 418.2
Correct = true
Ticks: 4039748
Compressed size: 18729685
Decompressed ticks: 4039748
Decompress performance: 1783 MB/s
Decompress performance: 31.2 Ticks (millions)/sec.
Decompress performance criterion: 403.2
Correct = true

Ticks: 4039748
Compressed size: 18729685
Decompressed ticks: 4039748
Decompress performance: 1764 MB/s
Decompress performance: 30.8 Ticks (millions)/sec.
Decompress performance criterion: 399.0
Correct = true

Ticks: 4039748
Compressed size: 18729685
Decompressed ticks: 4039748
Decompress performance: 1808 MB/s
Decompress performance: 31.6 Ticks (millions)/sec.
Decompress performance criterion: 408.9
Correct = true

Тестировал этот вариант и тот что в коде

         case 2:{
            while (r < blockSize){
                  f=ArrToUshort(m,r); // 2 байта с номером сжатия. 
                  switch(f&3){
                     case 0:{fl=Arr4ToUchar(m,r); break;}
                     case 1:{fl=ArrToUchar (m,r); break;}
                     case 2:{fl=ArrToUshort(m,r); break;}
                     case 3:{fl=ArrToUint  (m,r); break;}
                  }
                  switch(f & 12){
                     case 0:{this.tp+=Arr4ToUchar(m,r); break;}
                     case 4:{this.tp+=ArrToUchar (m,r); break;}
                     case 8:{this.tp+=ArrToUshort(m,r); break;}
                     case 12:{this.tp+=ArrToLong  (m,r); break;}
                  }
                  if(isVol(fl)){
                     switch(f & 48){
                        case 0:{v=Arr4ToUchar(m,r); break;}
                        case 16:{v=ArrToUchar (m,r); break;}
                        case 32:{v=ArrToUshort(m,r); break;}
                        case 48:{v=ArrToLong  (m,r); break;}
                     }
                  }
                  if(isBid(fl)){
                     switch(f & 192){
                        case 0:{this.bp+=Arr4ToChar(m,r); break;}
                        case 64:{this.bp+=ArrToChar (m,r); break;}
                        case 128:{this.bp+=ArrToShort(m,r); break;}
                        case 192:{this.bp+=ArrToLong (m,r); break;}
                     }
                  }
                  if(isAsk(fl)){
                     switch(f & 768){
                        case 0:{this.ap+=Arr4ToChar(m,r); break;}
                        case 256:{this.ap+=ArrToChar (m,r); break;}
                        case 512:{this.ap+=ArrToShort(m,r); break;}
                        case 768:{this.ap+=ArrToLong (m,r); break;}
                     }
                  }
                  if(isLast(fl)){
                     switch(f & 3072){
                        case 0:{this.lp+=Arr4ToChar(m,r); break;}
                        case 1024:{this.lp+=ArrToChar (m,r); break;}
                        case 2048:{this.lp+=ArrToShort(m,r); break;}
                        case 3072:{this.lp+=ArrToLong (m,r); break;}
                     }
                  }
                  SetAllTick(T[tick++],v,fl);
               }
               break;
         }
fxsaber #:
AskBid-вариант используется в 99% случаев. Наверное, имеется смысл сделать Light-вариант библиотеки, где выкинуть все проверки других вариантов, включая TickItems.

TickItems проверяется 1 раз на блок данных в 10000 тиков. Ускорение ничтожное может быть. Не стоит трат времени.

fxsaber #:

Такие конструкции должны быстрее работать через switch.


Проверял. Два if()else if()else быстрее или так же. Потому и заменил swith на if

fxsaber #:
На самом деле можно избавиться от вычитания из 255. И обойтись одним switch на 27 значений.
математика быстро считается. Большие сомнения в ускорении в этом месте
fxsaber #:

Такие конструкции должны быстрее работать через switch.


dt имеет смысл сделать uchar, сейчас long.

Если заменить, то требуется 3 преобразования в int тут 

dt=f%3
u=(f/3)%3;
dt=(f/9)%3;

вместо 1 сейчас.

Думаю работу с компрессором закончил. Надо на другие вещи переключаться.

Еще предложение.

//               if(dt<229){this.tp+=dt; db=ArrToUchar(m,r); this.bp+=db%16-8; this.ap+=(db/16)-8;  }//2 байта всего на самые часто встречающиеся тики
               if(dt<229)
               {
                 struct BidAsk_Add
                 {
                   long Bid_Add;
                   long Ask_Add;
                   
                   void Add( long &Bid, long &Ask ) const
                   {
                     Bid += this.Bid_Add;
                     Ask += this.Ask_Add;
                     
                     return;
                   }
                 } static const Adds[] = {{-8, -8}, {-7, -8}, {-6, -8}, {-5, -8}, {-4, -8}, {-3, -8}, {-2, -8}, {-1, -8}, 
                                          { 0, -8}, { 1, -8}, { 2, -8}, { 3, -8}, { 4, -8}, { 5, -8}, { 6, -8}, { 7, -8}, 
                                          {-8, -7}, {-7, -7}, {-6, -7}, {-5, -7}, {-4, -7}, {-3, -7}, {-2, -7}, {-1, -7}, 
                                          { 0, -7}, { 1, -7}, { 2, -7}, { 3, -7}, { 4, -7}, { 5, -7}, { 6, -7}, { 7, -7}, 
                                          {-8, -6}, {-7, -6}, {-6, -6}, {-5, -6}, {-4, -6}, {-3, -6}, {-2, -6}, {-1, -6}, 
                                          { 0, -6}, { 1, -6}, { 2, -6}, { 3, -6}, { 4, -6}, { 5, -6}, { 6, -6}, { 7, -6}, 
                                          {-8, -5}, {-7, -5}, {-6, -5}, {-5, -5}, {-4, -5}, {-3, -5}, {-2, -5}, {-1, -5}, 
                                          { 0, -5}, { 1, -5}, { 2, -5}, { 3, -5}, { 4, -5}, { 5, -5}, { 6, -5}, { 7, -5}, 
                                          {-8, -4}, {-7, -4}, {-6, -4}, {-5, -4}, {-4, -4}, {-3, -4}, {-2, -4}, {-1, -4}, 
                                          { 0, -4}, { 1, -4}, { 2, -4}, { 3, -4}, { 4, -4}, { 5, -4}, { 6, -4}, { 7, -4}, 
                                          {-8, -3}, {-7, -3}, {-6, -3}, {-5, -3}, {-4, -3}, {-3, -3}, {-2, -3}, {-1, -3}, 
                                          { 0, -3}, { 1, -3}, { 2, -3}, { 3, -3}, { 4, -3}, { 5, -3}, { 6, -3}, { 7, -3}, 
                                          {-8, -2}, {-7, -2}, {-6, -2}, {-5, -2}, {-4, -2}, {-3, -2}, {-2, -2}, {-1, -2}, 
                                          { 0, -2}, { 1, -2}, { 2, -2}, { 3, -2}, { 4, -2}, { 5, -2}, { 6, -2}, { 7, -2}, 
                                          {-8, -1}, {-7, -1}, {-6, -1}, {-5, -1}, {-4, -1}, {-3, -1}, {-2, -1}, {-1, -1}, 
                                          { 0, -1}, { 1, -1}, { 2, -1}, { 3, -1}, { 4, -1}, { 5, -1}, { 6, -1}, { 7, -1}, 
                                          {-8,  0}, {-7,  0}, {-6,  0}, {-5,  0}, {-4,  0}, {-3,  0}, {-2,  0}, {-1,  0}, 
                                          { 0,  0}, { 1,  0}, { 2,  0}, { 3,  0}, { 4,  0}, { 5,  0}, { 6,  0}, { 7,  0}, 
                                          {-8,  1}, {-7,  1}, {-6,  1}, {-5,  1}, {-4,  1}, {-3,  1}, {-2,  1}, {-1,  1}, 
                                          { 0,  1}, { 1,  1}, { 2,  1}, { 3,  1}, { 4,  1}, { 5,  1}, { 6,  1}, { 7,  1}, 
                                          {-8,  2}, {-7,  2}, {-6,  2}, {-5,  2}, {-4,  2}, {-3,  2}, {-2,  2}, {-1,  2}, 
                                          { 0,  2}, { 1,  2}, { 2,  2}, { 3,  2}, { 4,  2}, { 5,  2}, { 6,  2}, { 7,  2}, 
                                          {-8,  3}, {-7,  3}, {-6,  3}, {-5,  3}, {-4,  3}, {-3,  3}, {-2,  3}, {-1,  3}, 
                                          { 0,  3}, { 1,  3}, { 2,  3}, { 3,  3}, { 4,  3}, { 5,  3}, { 6,  3}, { 7,  3}, 
                                          {-8,  4}, {-7,  4}, {-6,  4}, {-5,  4}, {-4,  4}, {-3,  4}, {-2,  4}, {-1,  4}, 
                                          { 0,  4}, { 1,  4}, { 2,  4}, { 3,  4}, { 4,  4}, { 5,  4}, { 6,  4}, { 7,  4}, 
                                          {-8,  5}, {-7,  5}, {-6,  5}, {-5,  5}, {-4,  5}, {-3,  5}, {-2,  5}, {-1,  5}, 
                                          { 0,  5}, { 1,  5}, { 2,  5}, { 3,  5}, { 4,  5}, { 5,  5}, { 6,  5}, { 7,  5}, 
                                          {-8,  6}, {-7,  6}, {-6,  6}, {-5,  6}, {-4,  6}, {-3,  6}, {-2,  6}, {-1,  6}, 
                                          { 0,  6}, { 1,  6}, { 2,  6}, { 3,  6}, { 4,  6}, { 5,  6}, { 6,  6}, { 7,  6}, 
                                          {-8,  7}, {-7,  7}, {-6,  7}, {-5,  7}, {-4,  7}, {-3,  7}, {-2,  7}, {-1,  7}, 
                                          { 0,  7}, { 1,  7}, { 2,  7}, { 3,  7}, { 4,  7}, { 5,  7}, { 6,  7}, { 7,  7}};
                 
                 this.tp+=dt; Adds[ArrToUchar(m,r)].Add(this.bp, this.ap);
               }                      
fxsaber #:

Еще предложение.

Поиск ячейки в массиве - долго. А там всего 6 математических операций, которые очень быстро работают...

У меня было еще 5 вариантов с чтением по 2 и 4 бита, все медленнее до 10%, но размер файла был до 30% меньше (85мб место 116). 

Думаю, что замедление именно из за поиска в массиве и чтения.

Например тут 

               fl=Arr2ToUchar (m,r);//flag 2 бита => 1 байт за 4 тика заполняется
               dt=ArrToUchar(m,r); 
               if(dt<229){this.tp+=dt; if((fl&1)>0){this.bp+=Arr4ToChar (m,r);}if(fl>1){this.ap+=Arr4ToChar (m,r);}}//1,5 или 2 байта всего на самые часто встречающиеся тики
файл был 101мб, но медленнее того, что сейчас на 6%.

Целый день на эксперименты потратил. Думаю - достаточно.
Вроде, не хватает данных о количестве тиков в блоке. Сейчас непонятно, сколько выделять под MqlTick[] при разжатии.
fxsaber #:

Такие конструкции должны быстрее работать через switch.

Проверил еще раз. Все таки switch медленнее. По 4 запуска

 if  switch
Ticks: 4039748
Compressed size: 16316996
Decompressed ticks: 4039748
Decompress performance: 3573 MB/s
Decompress performance: 62.4 Ticks (millions)/sec.
Decompress performance criterion: 927.5
Correct = true
Ticks: 4039748
Compressed size: 16316996
Decompressed ticks: 4039748
Decompress performance: 3745 MB/s
Decompress performance: 65.5 Ticks (millions)/sec.
Decompress performance criterion: 972.3
Correct = true
Ticks: 4039748
Compressed size: 16316996
Decompressed ticks: 4039748
Decompress performance: 3740 MB/s
Decompress performance: 65.4 Ticks (millions)/sec.
Decompress performance criterion: 970.9
Correct = true
Ticks: 4039748
Compressed size: 16316996
Decompressed ticks: 4039748
Decompress performance: 3746 MB/s
Decompress performance: 65.5 Ticks (millions)/sec.
Decompress performance criterion: 972.5
Correct = true
Ticks: 4039748
Compressed size: 16316996
Decompressed ticks: 4039748
Decompress performance: 3500 MB/s
Decompress performance: 61.2 Ticks (millions)/sec.
Decompress performance criterion: 908.6
Correct = true
Ticks: 4039748
Compressed size: 16316996
Decompressed ticks: 4039748
Decompress performance: 3531 MB/s
Decompress performance: 61.7 Ticks (millions)/sec.
Decompress performance criterion: 916.6
Correct = true
Ticks: 4039748
Compressed size: 16316996
Decompressed ticks: 4039748
Decompress performance: 3713 MB/s
Decompress performance: 64.9 Ticks (millions)/sec.
Decompress performance criterion: 963.9
Correct = true
Ticks: 4039748
Compressed size: 16316996
Decompressed ticks: 4039748
Decompress performance: 3657 MB/s
Decompress performance: 63.9 Ticks (millions)/sec.
Decompress performance criterion: 949.3
Correct = true
fxsaber #:
Вроде, не хватает данных о количестве тиков в блоке. Сейчас непонятно, сколько выделять под MqlTick[] при разжатии.

Каждый блок по 10000 тиков сжимается до любого размера, потом этот же блок разжимается ровно до 10000 тиков. Между блоками при записи в файл записывается метка с размером блока.

Используется один и тот же MqlTick Ticks[10000];

Размер тоже влияет на скорость. 100 и 1000000 медленнее. Остановился в выборе на 10000. 

Aleksei Kuznetsov #:

Каждый блок по 10000 тиков сжимается до любого размера, потом этот же блок разжимается ровно до 10000 тиков. Между блоками при записи в файл записывается метка с размером блока.

Увидел это.
int ticks_per_block=200000;


Получается, что нужно выделять количество блоков * 10000. А количество блоков сразу в массиве можно посчитать по смещениям.