d2q9: rename "timers" (name conflict with libc)

d2q9: fix stupid bugs

d2q9: consistent naming for 2D and 3D case

d3q19: implement optimized bulk collision/stream

d3q19: remove libc, add stubs

Do not link against newlib anymore.
Add required stubs used by the startup code.
Add own (very slow!) implementations of memcpy() and memset().

This frees about 2k in SRAM bank 0.

d3q19: initial upload (no Zou/He)

Will not compile with Zou/He boundaries due
to linker error. The code does not fit in Bank 0,
even with -Os.

host: split write_image into GIF and MP4 (fails!)

split write_image() into convert_to_gif() (using ImageMagick 'convert')
and convert_to_mp4() (using FFMPEG) functions.

NOTE:
since the Parallella Ubuntu ships with libav instead of ffmpeg,
and the ffmpeg/avconv binaries don't support type globs, converting
to MP4 does not work - and fails without error message.

host: split write_image for density/velocity, -lm

split write_image() into write_density() and
write_velocity().
velocity calculations needs square root, so include
<math.h> and link against libm.

d2q9: implement Zou/He boundaries on all sides

only the top wall can be imprinted with a velocity,
for the other sides the velocities are zero.

d2q9: fix processing of non-wrapping borders

d2q9: rename NUM_CORES to CORES

make naming consistent with CORES_{X,Y} and BLOCKS_{X,Y}

d2q9: rename BLOCK_{X,Y} to BLOCKS_{X,Y}

makes naming consistent with CORES_{X,Y}

d2q9: replace attribute 'unused' with 'used'

While the attribute 'unused' only removes a warning, the
attribute 'used' actually prevents the linker from removing
the object. The objects in question are dummy objects to
prevent the linker from even trying to put anything else there.

Change the Makefile to remove the sections in question (banks 1/2/3)
from the SREC file, since they contain uninitialized data anyway.

d2q9: remove row, col, core from header

rename folder

The main code and the underlying data structures are too different
to bother building a 2D and a 3D simulation from the same code base.

simple full bounce-back borders

remove useless delay(), since ping-pong works now

Makefile: don't print $(EOBJS) in help screen

shared: don't pack shm_t, but align it instead

Accesses to the poll flag or the iteration counter do not
result in four byte-accesses anymore. Sigh.

all: new polling architecture

Replaces states[][] with pollflag+iteration.
The host communicates to the target when it is done reading shared
memory. No need for delay() on the target anymore. Only core 0
writes the iteration counter, reducing traffic to shared memory.
Writing populations is still slow. But no data loss anymore.

target: fail build on too small sizes

at least 1x1 cores and 3x3 blocks, please.

host: fix write_populations().

timers: save timer values to timers.dat

it is reasonably impossible to calculate the standard inside epiphany,
since there is no 128 bit datatype (as needed for storing the squares).
the required sqrtf will already overflow the internal code memory, adding
bignum stuff won't help. even float ceils.

so put the burden of statistics on the host.

all: begin of time measurement infrastructure

measure time differences, write them to shm, print them on the host

host: cleanup

Makefile: run everything internally with float

- treat floating point constants as single precision
  (this removes all dependencies for double)
- use internal.ldf linker script
  (puts libc functions in local memory)

speedup is immense. running code from external memory
is extremely slow, especially when all cores fight for it.

inner borders

- implement inner borders, still wrap-around the outer borders
- shm_t uses CORES_X, CORES_Y instead of linearized numbers
- change index order to be [y][x] everywhere
- maximum size now 104x104 (using 26x26 blocks in a 4x4 grid)
- compile-time bombs for anything larger
- finally supports non-square block and grid sizes

allow blocks of up to 24 KB (three banks)

add compile-time error for oversized grids

lb: D2Q9 working, single bank, single core

limited to 10x10 (double precision) or 15x15 (single precision)

initial commit