=================
UlmBLAS (Level 1)
=================

Wir wollen unsere eigen BLAS Implementierung erstellen.  Das erste Ziel ist
hierbei:

 - Erst einmal implementieren wir nur die 10 Level 1 Routinen und davon nur
   die *double* Varianten.
 - Unsere Implementierung muss die Netlib Test Suite bestehen.  Wir benötigen
   also ein zur BLAS Referenz-Implementierung kompatibles Interface.  Damit
   kann man dann automatisch auch BLAS Benchmarks benutzen.


Schritt:  RefBLAS, Test Suite, Verzeichnisse
============================================
Wir beginnen mit der Organisation.  Folgende Unterverzeichnisse wird es geben:

 - *level1*: Hier entsteht unsere eigene Implementierung.  Jede BLAS Funktion
   bekommt eine eigene Datei (`dasum.c`, `daxpy.c`, ...).  Am Anfang ist das
   natürlich leer.
 - *refblas*: Hier legen wir alle BLAS Funktionen der Referenz Implementierung
   von Netlib ab.  *Ein Makefile das all diese Source Files übersetzt und eine
   statische Bibliothek erzeugt müsst ihr schreiben.*
 - *test*: Hier kommt die Test Suite rein.  Diese besteht aus einer Anzahl von
   Fortran Source Files.  Für uns ist zunächst nur `dblat1.f` relevant.  Ein
   Makefile zum Testen der Level 1 Funktionen ist bereits enthalten.  Schaut
   euch diese Makefile genau an.  Dinge wie `wildcard` und `patsubst` sind
   sehr nützlich!

*Aufgabe:*

 - Den tarball __step1.tgz__ speichern und entpacken:
     - Mit `tar tfvz step1.tgz` könnt ihr zunächst nur das Inhaltverzeichnis
       des tarball anschauen und
     - mit `tar xfvz` entpacken.
 - Ein makefile für *refblas* schreiben:
     - Am Ende soll `../librefblas.a` erzeugt werden (also `librefblas.a` im
       Eltern-Verzeichnis `..`).
     - Erst soll aus allen Fortran Files der Form `*.f` ein Object File
       erzeugt werden.
     - Die Object File werden dann mit dem `ar` Befehl in eine statische
       Bibliothek archiviert.  Schaut euch an welche Optionen ihr benötigt.
     - Mit `make` in *refblas* die Bibliothek erzeugen.
 - Testen, ob die Test Suite durchläuft: In *test* erst mit `make` die Test
   Suite erzeugen, dann mit `make check_ref` die Referenz Implementierung
   testen.


Schritt:  Stubs für UlmBLAS
===========================
Ein Lösungsvorschlag könnt ist in __step2.tgz__ enthalten.  Wenn alles geklappt
hat, dann habt ihr in *refblas* ein Makefile der Art

:import: day06/step2/refblas/Makefile

Und ihr könnt folgendes machen:

  *--[SHELL(path=day06/step2)]----------------------------------------------*
  |                                                                         |
  |  cd refblas                                                             |
  |  make                                                                   |
  |  cd ../test                                                             |
  |  make                                                                   |
  |  make check_ref                                                         |
  |                                                                         |
  *-------------------------------------------------------------------------*

Dass die Referenz Implementierung Warnungen liefert ist nicht unsere Schuld.

*Aufgabe:*

  - Für jede BLAS Level 1 Funktion oder Routine soll jetzt ein C-Funktionsrumpf
    erzeugt werden.
  - Das sieht zum Beispiel für *ddot* so aus

:import: day06/step2/level1/ddot.c

  - Und für *daxpy* sieht es so aus

:import: day06/step2/level1/daxpy.c

  - Schaut euch dazu das zugehörig Fortran Source File an
  - Überlegt euch, ob ein Pointer *const* sein kann oder nicht
  - Schreibt ein Makefile, das alle C-Files in *level1* in Object Files
    übersetzt und eine statische Bibliothek *libulmblas.a* im obersten
    Verzeichnis erzeugt.
  - Im Ordner *test* sollte jetzt auch ein Target `check_ulm` hinzugefügt
    werden, das unsere BLAS Implementierung testet.


Schritt:  Erste UlmBLAS Implementierung und Tests
=================================================
Ein Lösungsvorschlag für die vorige Aufagbe ist in __step3.tgz__ enthalten.

Jetzt wird es Zeit mit der *UlmBLAS* Implementierung zu beginnen.  Für *ddot*
könnte die so aussehen:

:import: day06/step3/level1/ddot.c

Diese besteht auf den ersten Test (alle anderen test gehen natürlich noch
schief):

  *--[SHELL(path=day06/step3)]----------------------------------------------*
  |                                                                         |
  |  cd level1                                                              |
  |  make                                                                   |
  |  cd ../refblas                                                          |
  |  make                                                                   |
  |  cd ../test                                                             |
  |  make                                                                   |
  |  make check_ulm                                                         |
  |                                                                         |
  *-------------------------------------------------------------------------*


:links: step1.tgz -> http://apfel.mathematik.uni-ulm.de/~lehn/sghpc/download/step1.tgz
        step2.tgz -> http://apfel.mathematik.uni-ulm.de/~lehn/sghpc/download/step2.tgz
        step3.tgz -> http://apfel.mathematik.uni-ulm.de/~lehn/sghpc/download/step3.tgz

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