Skopiuj pojedyncze elementy szybciej niż cała struktura?

Question

Mam małą strukturę i odkryłem, że kopiowanie poszczególnych elementów jest znacznie szybsze niż kopiowanie struktury za jednym razem. Czy istnieje ku temu dobry powód?

Mój program:

// Some random structure 
private struct PackStats 
{ 
    public int nGoodPacks, nBadPacks, nTotalPacks; 
} 

// ... 
PackStats stats1 = new PackStats(); 
PackStats stats2 = new PackStats(); 

// Set some random statistics 
stats1.nGoodPacks = 55; 
stats1.nBadPacks = 3; 
stats1.nTotalPacks = (stats1.nGoodPacks + stats1.nBadPacks); 

// Now assign stats2 from stats1 

// This single line consumes ~190ns... 
stats2 = stats1; 

// ...but these three lines consume ~100ns (in total) 
stats2.nGoodPacks = stats1.nGoodPacks; 
stats2.nBadPacks = stats1.nBadPacks; 
stats2.nTotalPacks = stats1.nTotalPacks; 

Do pomiaru czasu w zakresie nanosekund, robię przypisania miliony razy:

uint uStart = GetTickCount(); 
for (int nLoop=0; nLoop<10000000; nLoop++) 
{ 
    // Do something... 
} 
uint uElapsed = (GetTickCount() - uStart); 

Wyniki były mniej więcej zgodne zarówno z włączoną optymalizacją i niepełnosprawnych .. Kopiowanie poszczególnych członków tej małej struktury było około dwa razy szybsze. Czy ten sam wynik miałby zastosowanie w C/C++?

Answer 1

Twoje czasy wydają się być na kompilację debugowania. Zrobiłem ten sam test z tego kodu:

private void DoIt() 
    { 
     const int numReps = 1000000000; 
     PackStats stats1 = new PackStats(); 
     PackStats stats2 = new PackStats(); 

     stats1.a = 55; 
     stats1.b = 3; 
     stats1.c = stats1.a + stats1.b; 

     for (var i = 0; i < 2; ++i) 
     { 
      var sw1 = Stopwatch.StartNew(); 
      for (var j = 0; j < numReps; ++j) 
      { 
       stats2 = stats1; 
      } 
      sw1.Stop(); 
      Console.WriteLine("Copy struct = {0:N0} ms", sw1.ElapsedMilliseconds); 

      sw1.Restart(); 
      for (var j = 0; j < numReps; ++j) 
      { 
       stats2.a = stats1.a; 
       stats2.b = stats1.b; 
       stats2.c = stats1.c; 
      } 
      sw1.Stop(); 
      Console.WriteLine("Copy fields = {0:N0} ms", sw1.ElapsedMilliseconds); 
     } 
    } 

Moje czasy są przedstawione poniżej:

   struct  fields 
Debug/Debug  2,245  1,908 
Debug/No  2,238  1,919 
Release/Debug 287   294 
Release/No  281   275 

to z Visual Studio 2015. Program został skompilowany jako dowolny CPU, i działać na 64- maszyna bitowa.

Debugowanie/debugowanie oznacza uruchomienie kompilacji debugowania z dołączonym debuggerem (tj. Naciśnięcie klawisza F5 w celu uruchomienia programu). Debugowanie/Nie oznacza wykonanie kompilacji debugowania bez debugowania (np. Ctrl + F5). A Release, oczywiście, oznacza kompilację wydania.

To, co mi to mówi, to to, że w trybie zwolnienia nie ma praktycznie żadnej różnicy między kopiowaniem struktury na raz lub kopiowaniem poszczególnych pól. W najgorszym przypadku pokazanym tutaj jest to 6 milisekund ponad miliard iteracji.

Odpowiedź na pytanie: "Skopiuj poszczególnych członków szybciej niż całą strukturę?" wygląda na "W trybie debugowania, tak".