Warum valenok2003 gegen MT5 ist - Seite 24

Neuer Kommentar
 
tara: Nicht wirklich.
Jedes for kann durch ein entsprechendes while ersetzt werden - und umgekehrt. Und es ist unwahrscheinlich, dass eine dieser Konstruktionen eindeutig wirtschaftlicher ist als die andere.
 
Mathemat:
Jedes for kann durch ein entsprechendes while ersetzt werden - und umgekehrt. Und es ist unwahrscheinlich, dass eines der beiden Konstrukte eindeutig wirtschaftlicher ist als das andere.
Jedes for und while kann durch goto ersetzt werden, wodurch der Code schneller ausgeführt wird.
 
Zhunko: Jedes for und while kann durch goto ersetzt werden, um die Codeausführung zu beschleunigen.
Ein Beispiel, Vadim? Machen Sie nicht asm, machen wir etwas in C.
 
Mathemat:
Ein Beispiel, Vadim? Geben Sie mir nicht asm, geben Sie mir etwas in 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;
       }
Ich habe versucht, unnötige Schleifen zu beseitigen. Dieser Code arbeitet 20 % schneller als das standardmäßige memcpy. Außerdem gibt es keine Begrenzung der Kopiergröße und es ist sicherer als memcpy.
 

Ich danke Ihnen. Soweit ich weiß, ist dies die Hauptkonstruktion, die schneller funktionieren sollte:

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

Nun, das ist derweil die Emulation. Ja, es ist durchaus möglich, dass sie schneller ist als die Standardschleife. Aber wahrscheinlich nur auf Kosten einer langsameren Initialisierungszeit des Kontrollkonstrukts selbst.

Und wie viele Iterationen gibt es in dieser "Schleife"?

 

Ein bisschen schneller.

 

Hee:)

 
Roman.:
Im Prinzip ja. Assembler hat jmp. Wofür wurde sie also entwickelt?
Assembler hat auch "nop", was soll's?
 
goto ist sehr vielseitig. Es ersetzt für eine Weile und Pause. Es ist viel besser, aus einer mehrfach verschachtelten goto-Schleife auszusteigen, als eine Abbruchbedingung zu jeder verschachtelten Schleife hinzuzufügen.
 

goto ist ein großartiger Ersatz, wenn es keine Ausnahmen gibt, aber Sie brauchen so etwas wie einen finally-Block.

Natürlich sind ifs auch gut, aber goto ist wahrscheinlich noch eleganter.

Aber im Allgemeinen hat es keinen Sinn, Spaghetti mit einem Zahnstocher zu essen, wenn man eine normale Gabel hat.

Und der Programmierer, der den Code nach Ihnen aufnimmt, wird Ihnen nicht auf den Kopf klopfen.

1...171819202122232425
Neuer Kommentar