Por qué valenok2003 está en contra de MT5 - página 24

Nuevo comentario
 
tara: La verdad es que no.
Cualquier for puede ser sustituido por el correspondiente while - y viceversa. Y es poco probable que ninguna de estas construcciones sea claramente más económica que la otra.
 
Mathemat:
Cualquier for puede ser sustituido por el correspondiente while - y viceversa. Y es poco probable que cualquiera de estas construcciones sea claramente más económica que la otra.
Cualquier for y while puede ser sustituido por goto con una ejecución de código más rápida.
 
Zhunko: Cualquier for y while puede ser sustituido por goto para acelerar la ejecución del código.
¿Un ejemplo, Vadim? No hagas asm, hagamos algo en C.
 
Mathemat:
¿Un ejemplo, Vadim? No me des asm, dame algo 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;
       }
Traté de deshacerme de los bucles innecesarios. Este código funciona un 20% más rápido que el memcpy estándar. Además, no tiene límite de tamaño de copia y es más seguro que memcpy.
 

Gracias. Por lo que tengo entendido, la principal construcción que debería funcionar más rápido es ésta:

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

Bueno, esto es la emulación mientras. Sí, es muy posible que sea más rápido que el bucle estándar. Pero probablemente sólo a costa de un tiempo de inicialización más lento de la propia construcción de control.

¿Y cuántas iteraciones hay en este "bucle"?

 

Un poco más rápido.

 

Hee:)

 
Roman.:
En principio, sí. El ensamblador tiene jmp. Entonces, ¿para qué se diseñó?
Assembler también tiene "nop", ¿y qué?
 
goto es muy versátil. Sustituye por , un tiempo y rompe. Es mucho mejor salir de un bucle goto anidado múltiple que añadir una condición de ruptura a cada bucle anidado.
 

goto es un gran sustituto cuando no hay excepciones, pero se necesita algo como un bloque finally.

Por supuesto, los ifs también son buenos, pero goto es probablemente aún más elegante.

Pero, en general, no tiene sentido comer espaguetis con un palillo si tienes un tenedor normal.

Y el programador que recogerá el código después de ti no te dará una palmadita en la cabeza.

1...171819202122232425
Nuevo comentario