Kiedy, jeśli w ogóle, rozwijanie pętli jest nadal przydatne?

To nie robi żadnej różnicy, ponieważ robisz tę samą liczbę porównań. Oto lepszy przykład. Zamiast:

for (int i=0; i<200; i++) {
  doStuff();
}

Napisz:

for (int i=0; i<50; i++) {
  doStuff();
  doStuff();
  doStuff();
  doStuff();
}

Nawet wtedy to prawie na pewno nie będzie miało znaczenia, ale teraz robisz 50 porównań zamiast 200 (wyobraź sobie, że porównanie jest bardziej złożone).

ręczne rozwijanie pętli w ogóle jest w dużej mierze artefaktem historii. To kolejna z rosnącej listy rzeczy, które dobry kompilator zrobi dla ciebie, gdy ma znaczenie. Na przykład większość ludzi nie zadaje sobie trudu pisania x <<= 1 lub x += x zamiast x *= 2. Po prostu napisz x *= 2, A kompilator zoptymalizuje go dla Ciebie do tego, co najlepsze.

W zasadzie coraz mniej jest potrzeby zastanawiania się nad kompilatorem.

Niezależnie od przewidywania gałęzi na nowoczesnym sprzęcie, większość kompilatorów i tak rozwija pętle.

Warto byłoby dowiedzieć się, jak wiele optymalizacji robi dla ciebie twój kompilator.

Znalazłem prezentację Felixa von Leitnera bardzo pouczającą w tym temacie. Polecam przeczytać. Podsumowanie: nowoczesne Kompilatory są bardzo sprytne, więc optymalizacje ręczne prawie nigdy nie są skuteczne.

O ile to Rozumiem, nowoczesne Kompilatory już rozwijają pętle tam, gdzie jest to właściwe - przykładem jest gcc, jeśli przejdzie optymalizacja flagi to instrukcja mówi, że będzie:

Rozwiń pętle, których liczba iteracji można określić na czas kompilacji lub po wejściu do pętla.

Tak więc, w praktyce jest prawdopodobne, że Twój kompilator wykona za Ciebie trywialne przypadki. Dlatego do ciebie należy upewnienie się, że jak najwięcej Twoich pętli jest łatwych dla kompilator do określenia, ile iteracji będzie potrzebnych.

Rozwijanie pętli, niezależnie od tego, czy jest to rozwijanie ręczne, czy rozwijanie kompilatora, często może być nieproduktywne, szczególnie w przypadku nowszych procesorów x86 (Core 2, Core i7). Podsumowując: porównuj swój kod z rozwijaniem pętli i bez niego na dowolnych procesorach, na których planujesz wdrożyć ten kod.

Próba bez wiedzy to nie jest sposób, aby to zrobić.
Czy ten rodzaj zajmuje wysoki procent całkowitego czasu?

Wszystkie rozwijane pętle zmniejszają narzut pętli zwiększania / zmniejszania, porównywania dla warunku zatrzymania i skoków. Jeśli to, co robisz w pętli, zajmuje więcej cykli instrukcji niż sama pętla napowietrzna, nie zobaczysz większej poprawy w procentach.

Oto przykład, jak uzyskać maksymalną wydajność.

Rozwijanie pętli może być pomocne w konkretnych przypadkach. Jedynym zyskiem nie jest pominięcie niektórych testów!

Może na przykład umożliwić skalarną wymianę, wydajne wstawianie prefetchingu oprogramowania... Zdziwiłbyś się, jak bardzo może to być przydatne (możesz łatwo uzyskać 10% przyspieszenie na większości pętli, nawet z-O3), agresywnie rozwijając.

Jak już wcześniej zostało powiedziane, zależy to w dużej mierze od pętli, a kompilator i eksperyment są niezbędne. Trudno ustalić regułę (lub heurystyka kompilatora dla rozwinięcia byłaby idealna)

Rozwijanie pętli zależy całkowicie od rozmiaru problemu. Jest to całkowicie zależne od algorytmu jest w stanie zmniejszyć rozmiar do mniejszych grup pracy. To, co zrobiłeś powyżej, nie wygląda tak. Nie jestem pewien, czy symulację monte carlo można w ogóle rozwinąć.

I dobrym scenariuszem dla rozwijania pętli byłoby obracanie obrazu. Ponieważ można obracać oddzielne grupy pracy. Aby to zadziałało, musisz zmniejszyć liczbę iteracji.

Rozwijanie pętli jest nadal przydatne, jeśli w pętli i z nią jest wiele zmiennych lokalnych. Aby ponownie użyć tych rejestrów więcej zamiast zapisywać jeden dla indeksu pętli.

W twoim przykładzie używasz małej ilości zmiennych lokalnych, nie nadużywając rejestrów.

Porównanie (do końca pętli) jest również główną wadą, jeśli porównanie jest ciężkie( np. Instrukcja Nie-test), zwłaszcza jeśli zależy to od funkcji zewnętrznej.

Rozwijanie pętli pomaga zwiększyć procesor świadomość przewidywania gałęzi również, ale te i tak się zdarzają.