Pourquoi valenok2003 est contre MT5 - page 24

Nouveau commentaire
 
tara: Pas vraiment.
Tout for peut être remplacé par un while correspondant - et vice versa. Et il est peu probable que l'une de ces constructions soit clairement plus économique que l'autre.
 
Mathemat:
Tout for peut être remplacé par un while correspondant - et vice versa. Et il est peu probable que l'une de ces constructions soit clairement plus économique que l'autre.
Tous les for et while peuvent être remplacés par des goto avec une exécution plus rapide du code.
 
Zhunko: Tout for et while peut être remplacé par goto pour accélérer l'exécution du code.
Un exemple, Vadim? Ne fais pas d'asm, fais quelque chose en C.
 
Mathemat:
Un exemple, Vadim? Ne me donnez pas d'asm, donnez moi quelque chose en C.
      // 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;
       }
J'ai essayé de me débarrasser des boucles inutiles. Ce code est 20% plus rapide que le memcpy standard. Il n'a pas non plus de limite de taille de copie et est plus sûr que memcpy.
 

Merci. D'après ce que je comprends, la principale construction qui devrait fonctionner plus rapidement est celle-ci :

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

Eh bien, c'est l'émulation en cours. Oui, il est tout à fait possible qu'elle soit plus rapide que la boucle standard. Mais probablement seulement au prix d'un temps d'initialisation plus lent de la construction de contrôle elle-même.

Et combien d'itérations y a-t-il dans cette "boucle" ?

 

Un peu plus vite.

 

Hee :)

 
Roman.:
En principe, oui. L'assembleur a jmp. Alors, pour quoi était-il conçu ?
L'assembleur a aussi "nop", et alors ?
 
Le goto est très polyvalent. Il remplace pour, pendant et pour la pause. Il est bien plus efficace de sortir d'une boucle goto imbriquée que d'ajouter une condition d'interruption à chaque boucle imbriquée.
 

goto est un excellent substitut lorsqu'il n'y a pas d'exception, mais vous avez besoin de quelque chose comme un bloc finally.

Bien sûr, les ifs sont aussi bons, mais goto est probablement encore plus élégant.

Mais de manière générale, il est inutile de manger des spaghettis avec un cure-dent si vous avez une fourchette normale.

Et le programmeur qui reprendra le code après vous ne vous tapera pas sur la tête.

1...171819202122232425
Nouveau commentaire