root/INSTALL

Dear alpha tester,

to install, edit the Makefile and adjust the paths to includes
and libraries.

With the release of CUDA2.3 it is not longer necessary to patch and
compile open64 and you can skip a few paragraphs

quick install guide for cuda 2.2 open64 compiler

download ftp://download.nvidia.com/CUDAOpen64/nvopencc-2.2-src.tar.gz
mkdir ~/open64; cd ~/open64
extract the tarball here
patch -p1 < /path/to/nvopencc-2.2.patch (included)
cd src/targia3264_nvisa
make ROOT_DIR=~/open64/

when the build process stops with an error when trying to build 'bec' you find
inliner/inline
backend/be
gccfe/gfec

copy those to /usr/local/cuda/open64/lib after backing up the original files
and yes it works with bec from the original distribution

cuda 2.1 will probably not compile the program and the patch does not apply,
but all it does is add some includes and remove -Werror

tested with gcc-4.3

stxxl-1.2.1:

download from stxxl.sf.net and build. no need to install, just symlink
the stxxl source root dir to stxxl-svn in this directory
(stxxl from SVN is probably not really needed)

to build the software:

run the autoconfig: vi Makefile; vi obj/gcc (gcc 4.1 works)
cd obj; make

the number of blocks below should match the number of "Multiprocessors"
on your GPU which is the number of stream processors / 8

running a test (all on one line):
time ./c --condition rounds:rounds=256
         --implementation sharedmem --algorithm A51
         --roundfunc xor:condition=distinguished_point::bits=8:generator=increment
         --device cuda:threads=256:blocks=4:sleep=5000:operations=32768
         --logger verbose
         --work random:prefix=10,0
         --consume print:results=16
         generate --chainlength 65536 --chains 1024

(copy+paste)
time ./c --condition rounds:rounds=256 --implementation sharedmem --algorithm A51 --roundfunc xor:condition=distinguished_point::bits=8:generator=increment --device cuda:threads=256:blocks=4:sleep=5000:operations=32768 --logger verbose --work random:prefix=10,0 --consume print:results=16 generate --chainlength 65536 --chains 1024

this produces 1024 chains of 256 (--condition) column spans which are
divided by a distinguished point, where at least 8 bits of the chain value
are zero (--roundfunc condition:) and uses increment on a uint32_t
to generate values for the xor round function (starting at zero) (generator=increment)
two colons are used for nested option grouping (see --roundfunc)

the generator for the chain start values (--work random) uses srand()
and sets the first 10 bits to constant zero

the work consumer prints some of the values (--consume)

256 threads in 4 blocks get scheduled at once with 5ms sleep between
kernel calls and 32768 columns computed for those 4*256 chains per call.

device:operations should obviously divide --chainlength 65536
(that is until i implement error checking)

the call should generate a set of chains where about 50% of the chains
are complete (see output of --consume print)

--$switch help e.g. ./c --condition help gives some
info for most options

this is an alpha release. to find out more about the options,
look at the source.

e.g. --work maps to ./work_generator/*.hpp
--consume to ./work_consumer/*.hpp
...

and look for a static member function "optdesc()" that populates the
option parser if you are curious