=========================
Pointer und Optimierungen
=========================



C-Beispiel mit Pointer
======================
:import: day04/blub.c


Assembler Code
==============
Wir übersetzen den C-Code zunächst wie üblich in Assembler:

  *--[SHELL(path=day04)]------------------------------------------------*
  |                                                                     |
  |  gcc-4.8 -S -fno-asynchronous-unwind-tables blub.c                  |
  |                                                                     |
  *---------------------------------------------------------------------*

Damit erhalten wir

:import: day04/blub.s


Optimierter Assembler Code
==========================
Jetzt übersetzen wir mit voller Optimierung (`-O3`)

  *--[SHELL(path=day04)]------------------------------------------------*
  |                                                                     |
  |  gcc-4.8 -S -O3 -fno-asynchronous-unwind-tables blub.c              |
  |                                                                     |
  *---------------------------------------------------------------------*

Damit ist der Assembler Code plötzlich sehr übersichtlich.

:import: day04/blub.s


Benchmark Trouble
=================
Ein Compiler darf eine Menge tricksen solange er garantieren kann, dass stets
das gleiche Endergebnis rauskommt.  Bei Benchmarks ist das aber problematisch,
denn ein Rechenergebnis interessiert uns ja nicht.  Sondern nur wie lange eine
Berechnung dauert.  Weil eine einzelne Rechnung unterhalb der Messgenauigkeit
liegt und weil Ausreisser das Ergebnis verfälschen können wiederholt man eine
Rechnung $x$ mal und mittelt die Zeiten.

Benchmark für Speicherzugriff
-----------------------------
Wir wollen testen wie teuer ein Speicherzugriff ist.  Wir schreiben also das

:import: day04/bench_assign.c

Zunächst übersetzen wir ohne Optimierung (wir schalten diese sogar explizit aus
mit `-O0`)

  *--[SHELL(path=day04)]------------------------------------------------*
  |                                                                     |
  |  gcc-4.8 -S -O0 -fno-asynchronous-unwind-tables bench_assign.c      |
  |                                                                     |
  *---------------------------------------------------------------------*

Und erhalten

:import: day04/bench_assign.s

Dann schalten wir die Optimierung an:

  *--[SHELL(path=day04)]------------------------------------------------*
  |                                                                     |
  |  gcc-4.8 -S -O3 -fno-asynchronous-unwind-tables bench_assign.c      |
  |                                                                     |
  *---------------------------------------------------------------------*

Jetzt erhalten wir
ä
:import: day04/bench_assign.s


Benchmark für Pointerzugriff
----------------------------
Wir wollen testen wie teuer ein indirekter Variabel-Zugriff über einen Pointer
ist:

:import: day04/bench_pointer.c

Zunächst übersetzen wir ohne Optimierung (wir schalten diese sogar explizit aus
mit `-O0`)

  *--[SHELL(path=day04)]------------------------------------------------*
  |                                                                     |
  |  gcc-4.8 -S -O0 -fno-asynchronous-unwind-tables bench_pointer.c     |
  |                                                                     |
  *---------------------------------------------------------------------*

Und erhalten

:import: day04/bench_pointer.s

Dann schalten wir die Optimierung an:

  *--[SHELL(path=day04)]------------------------------------------------*
  |                                                                     |
  |  gcc-4.8 -S -O3 -fno-asynchronous-unwind-tables bench_pointer.c     |
  |                                                                     |
  *---------------------------------------------------------------------*

Jetzt erhalten wir

:import: day04/bench_pointer.s

der Compiler hat erkannt, wie man direkt zugreifen kann und hat die Indirektion
komplett weg optimiert.  Das ist toll in der Praxis!  Aber es ist blöd, wenn
man dafür einen Benchmark machen möchte.

:navigate: __up__    -> doc:index
           __next__  -> doc:day04/page02