Почему valenok2003 против МТ5 - страница 24

Новый комментарий
 
tara: Не совсем.
Любой for можно заменить на сооветствующий while - и наоборот. И вряд ли какая-то из этих конструкций будет явно экономнее другой.
 
Mathemat:
Любой for можно заменить на сооветствующий while - и наоборот. И вряд ли какая-то из этих конструкций будет явно экономнее другой.
 Любой for и while можно заменить на goto с ускорением исполнения кода.
 
Zhunko:  Любой for и while можно заменить на goto с ускорением исполнения кода.
Пример, Вадим? Только не надо asm, давай что-нибудь на Си.
 
Mathemat:
Пример, Вадим? Только не надо asm, давай что-нибудь на Си.
      // 1.1.1. Метод копирования данных по указателю до 128 Гб.
      template<class type1, class type2> // Любые типы.
      static void Copy(      type1*  pt1Dest,        // Указатель на приёмник данных.
                       const DWORD64 dw64SizeDest,   // Размер приёмника данных в байтах.
                             type2*  pt2Source,      // Указатель на источник данных.
                       const DWORD64 dw64SizeSource, // Размер источника данных в байтах, начиная от указателя pt2Source.
                             DWORD64 dw64Count)      // Количество копируемых данных в байтах.
       {
        PBYTE pbtDest = PBYTE(pt1Dest);     // Инициализируем локальный указатель на приёмник.
        PBYTE pbtSource = PBYTE(pt2Source); // Инициализируем локальный указатель на источник.
        // Корректируем количество копируемых байт под размер источника.
        dw64Count = COUNT_DIRECT(_T("Utils::Memory::Simple::Copy"), dw64SizeSource, 0, dw64Count);
        dw64Count = Min(dw64Count, dw64SizeDest);
        // Для количества данных более или равно 2147483647 байт цикл необходим.
        if (dw64Count >= sizeof(BYTES_0X7FFFFFFF))
         {
          DWORD64 i = 0;
          DWORD64 dw64Iterations = Utils::Math::Arithmetic::DivideFloor(dw64Count, sizeof(BYTES_0X7FFFFFFF)); // Количество итераций. Округляем в меньшую сторону.
          START: if (!SimpleCopy<BYTES_0X7FFFFFFF>(pbtDest, pbtSource, dw64Count)) return;
          i++;
          if (i < dw64Iterations) goto START;
         }
        if (!SimpleCopy<BYTES_0X40000000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X20000000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X10000000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X8000000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X4000000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X2000000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X1000000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X800000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X400000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X200000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X100000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X80000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X40000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X20000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X10000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X8000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X4000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X2000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X1000>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X800>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X400>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X200>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X100>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X80>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X40>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X20>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X10>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X8>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X4>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X2>(pbtDest, pbtSource, dw64Count)) return;
        if (!SimpleCopy<BYTES_0X1>(pbtDest, pbtSource, dw64Count)) return;
       }
Постарался избавиться от лишних циклов. Этот код работает на 20% быстрее, чем стандартный memcpy. Ещё в нём отсутствует ограничение на объём копирования и он безопаснее, чем memcpy.
 

Спасибо. Насколько понял, главная конструкция, которая должна работать быстрее, - вот эта:

START: if (!SimpleCopy<BYTES_0X7FFFFFFF>(pbtDest, pbtSource, dw64Count)) return;
i++;
if (i < dw64Iterations) goto START;

Ну это и есть эмуляция while. Да, вполне допускаю, что она быстрее стандартного цикла. Но, наверно, только за счет меньшего времени на инициализацию самой управляющей конструкции.

А сколько итераций в этом "цикле"?

 

Немного быстрее.

 

 

Гы:)

 

 
Roman.:
В принципе - да. В ассемблере есть же jmp. Значит он для чего то же создавался?
В ассемблере есть и "nop", и что с того?
 
goto очень универсальная штука. Заменяет for , while и break. Из  многовложенного цикла по goto намного лучше выходить, чем прописывать в каждой вложке условия для выхода по break.
 

goto отличная замена там, где нет исключений, но нужно что-то типа блока finally.

Оно конечно и if-ами решается хорошо, но goto наверное даже изящней.

Но в целом смысл скажем есть спагетти зубочисткой если есть нормальная вилка.

Да и программист который после вас в коде будет ковыряться по головке не погладит.

1...171819202122232425
Новый комментарий
Причина обращения: