ForumBölümler

Neden valenok2003 vs MT5 - sayfa 24

Yeni yorum
tara : Tam olarak değil.
Herhangi bir for, karşılık gelen while - ile değiştirilebilir ve bunun tersi de geçerlidir. Ve bu tasarımlardan herhangi birinin diğerinden açıkça daha ekonomik olması pek olası değildir.
Mathemat :
Herhangi bir for, karşılık gelen while - ile değiştirilebilir ve bunun tersi de geçerlidir. Ve bu tasarımlardan herhangi birinin diğerinden açıkça daha ekonomik olması pek olası değildir.
Herhangi bir for ve while , daha hızlı kod yürütme ile goto ile değiştirilebilir.
Zhunko : Herhangi bir for ve while, kod yürütmeyi hızlandırmak için goto ile değiştirilebilir.
Örnek, Vadim ? Sadece asm'ye gerek yok, hadi C'de bir şeyler yapalım.
Mathemat :
Örnek, Vadim ? Sadece asm'ye gerek yok, hadi C'de bir şeyler yapalım. 
       // 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 ;
       }
Fazla döngülerden kurtulmaya çalıştım. Bu kod, standart memcpy'den %20 daha hızlıdır. Ayrıca kopya boyutu sınırı yoktur ve memcpy'den daha güvenlidir.

Teşekkür ederim. Anladığım kadarıyla, daha hızlı çalışması gereken ana yapı şudur: 

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

Eh, bu süre öykünmesidir. Evet, standart döngüden daha hızlı olduğunu tamamen kabul ediyorum. Ancak, muhtemelen, yalnızca kontrol yapısının kendisini başlatmak için daha az zaman nedeniyle.

Ve bu "döngüde" kaç yineleme var?

Biraz daha hızlı.

eee :)

Roman. :
Sanırım, evet. Montajcıda jmp var. Peki ne için yaratıldı?
Assembler'ın da "hayır"ı var, ne olmuş yani?
goto çok yönlüdür. , while ve break yerine geçer. Çok yuvalı bir döngüden goto ile çıkmak, her yuvada koparak çıkmak için koşullar belirlemekten çok daha iyidir.

goto, istisnaların olmadığı, ancak nihayet bloğu gibi bir şeye ihtiyaç duyulan yerlerde harika bir yedek.

Tabii ki, ifs ile iyi bir şekilde çözülebilir, ancak goto muhtemelen daha da zariftir.

Ancak genel olarak, normal bir çatal varsa, kürdan ile spagetti yemek mantıklıdır.

Ve kodda sizden sonra kafayı seçecek olan programcı vuruş yapmayacaktır.

1...171819202122232425
Yeni yorum