,                                                                             ,
,                                                                             ,
                             ==========================
                             FTBLAS library README file
                             ==========================

authors:

,                                                                             ,
,   Julien Langou, UC Denver                                                  ,
,   Remi Delmas                                                               ,
,                                                                             ,

FTBLAS library:

,                                                                             ,
,   This is the alpha version of the alpha version of the library, you should ,
,   understand by using the library what is meant by alpha^2.                 ,
,                                                                             ,
,   The library is entirely based on FT-MPI and we thank the FT-MPI team (in  ,
,   particular George Bosilca) for their help during the development of the   ,
,   library.                                                                  ,
,                                                                             ,
,   This library is a proof of concept.  This is the base for our current and ,
,   future work.  It is a good test suite for exercising the capabilities     ,
,   promised by FT-MPI.  It is meant to be the first comprehensive            ,
,   fault-tolerant library built around FT-MPI.                               ,
,                                                                             ,

quick user's guide:

,                                                                             ,
,   Set up the Makefile                                                       ,
,   Type make                                                                 ,
,   Start your FT-MPI console (if possible with nine hosts)                   ,
,   Type in a shell:  ftmpirun -np 9 -o main_ftmpi                            ,
,                                                                             ,
,   -> that should run a series 1000-by-1000 matrix vector product on 4       ,
,      processors (2-by-2 grid) with algorithmic block size of 32. Each       ,
,      matrix-matrix product is checked after completion. We really need 9    ,
,      processes, the 5 border processes are checkpoint processes.            ,
,                                                                             ,
,  -> to enable failure                                                       ,
,     (a) either add the compilation flag: -DWANT_ERROR                       ,
,         this is going to be a little be crazy because all our FT routine    ,
,         will crash (with an exit(0)) once each time they are called         ,
,         the current setup is:                                               ,
,         * ftdgemv        -> proc 5 exit somewhere in the middle             ,
,         * ftdgemmm_summa -> proc 6 exit somewhere in the middle             ,
,         * ftdlacpy       -> proc 8 exit somewhere in the middle             ,
,         * ftdnrm2.c      -> proc 5 exit somewhere in the middle             ,
,         * ftdnrm2mat.c   -> proc 7 exit somewhere in the middle             ,
,                                                                             ,
,     (b) or log on a host and kill one process                               ,
,     [ do not forget to cross your fingers ]                                 ,
,                                                                             ,
,  -> the code should run forever and survive all failures                    ,
,                                                                             ,
,  -> possibility of changing the # of processes, matrix size, block size,    ,
,     and grid shape with inline arguments:                                   ,
,         ftmpirun -np 9 -o main_ftmpi -p 2 -q 2 -mnk 1000 \                  ,
,                -nb_n 500 -nb_m 500 -nb_k 500 -nb_alg 25                     ,
,                                                                             ,
,  -> There is a little too much print !!!                                    ,
,     Just take the lines with:  grep x | grep C | grep "/" | grep "me 0"     ,
,     should be enough (we want 0.0000)                                       ,
,                                                                             ,

what the code does:

,  The main is in the file demo_dnrm2.c. We use the SUMMA algorithm, as       ,
,  opposed to PUMMA, the FT-PUMMA code is also availables.                    ,
,                                                                             ,
,        /* main test                                                      */ ,
,                                                                             ,
,        create random x, y, A, B, C, v                                       ,
,        create temp vector y, v                                              ,
,        while( 1 )                                                           ,
,            nrmx   <- || x ||_2       (1)    ( ftdnrm2    )                  ,
,            C      <- A * B           (2)    ( ftdgemm    )                  ,
,            Cx     <- C * xrow        (3)    ( ftdgemv    )                  ,
,            y      <- B * xrow        (4)    ( ftdgemv    )                  ,
,            v      <- y               (5)    ( ftdlacpy   )                  ,
,            Cx     <- A * v - Cx      (6)    ( ftdgemv    )                  ,
,            nrmres <- || Cx ||_2      (7)    ( ftdnrm2    )                  ,
,            nrmc   <- || C ||_fro     (8)    ( ftdnrm2mat )                  ,
,            check that normres/normx/normc <= 1e-10                          ,
,        endwhile                                                             ,
,        free temp vector y, v                                                ,
,        free random x, y, A, B, C, v                                         ,
,                                                                             ,
,        /* do not ask me why we are freeing space after our infinite loop */ ,
,        /* this is because we are good programmers !!                     */ ,
,                                                                             ,

known bugs:

,                                                                             ,
,                                                                             ,
,   1- After a violent crash, it is a good idea to type at least twice 'ps'   ,
,      in the FT-MPI console.                                                 ,
,                                                                             ,
,   2- Sometimes when you kill where you should not, the code does not like   ,
,      it.                                                                    ,
,                                                                             ,
,   3- And we even have problems when we kill the application at some         ,
,      specific places.                                                       ,
,                                                                             ,

please report bugs and patches to julien.langou@ucdenver.edu

