One more silent error. ax_pthreads will fail on -Werror, so we still
need to fix that.

Still fails, some issues in configure.ac/Makefile.am

Note that this still fails on make check, some problem with
CPPFLAGS/LDFLAGS

Last bit of API lacking consistency.

Implement #31 for vector.
Improve error management.
Checkpatch vector.

Implement #31 for tiling.
Improve error management.
Checkpatch tiling.

Implement #31 for scratch.
Improve error management.
Checkpatch scratch.

Implement #31 for dma.
Improve error management.
Checkpatch dma

Convert area/area_linux to new error handler.
Implement #31 for area.
Checkpatch area

Note that area_linux is still using a dynamic data structure no matter
what: a bitmask to the set of authorized nodes. The conversion to
aml_bitmap wouldn't help as there's no default value available for all
nodes on that type (similar to numa_all_nodes_ptr).

The source repo has been reorganized, but the repoquality checks were
not updated. Also make sure that style checks happen early, to fail the
CI quickly.

Same as the rest.

We're starting to agree on one main header for all the generic APIs of
building blocks, struct definitions included, and one header per
specific implementation.

Improve the spelling while we're at it.

Since we removed `move` from the dma API, bindings are now useless.

Poorly supported feature that doesn't play well with the rest of the
library and limits what we can do in the future.

Use m4 to define autoconf-level version variables, following the naming
scheme of semver.org

To make use of these variables in the headers and sources, a
generated-header is added in aml/utils/version.h

Also add a simple test for that part of the lib.

The overall strategy for now is to split the implementations into
distinct headers, but keep the generic APIs inside the main aml.h

Related to #27

The overall strategy for now is to split the implementations into
distinct headers, but keep the generic APIs inside the main aml.h

Related to #27

While the current bitmask management is heavily inspired by libnuma, it is not
as easy to use has the libnuma API. This patch is an attempt to refactor
to code towards something cleaner.

- create one directory per building block in src and include
- keep one directory for tests, \
  otherwise automake make them "test suites"
- move to AC_OPENMP, which is from autoconf 2.62 (2008)

Force libtool to static link the PIC version of our jemalloc import into
libaml, making libaml standalone. This requires us to test some
additional libraries in our own configure (pthread, and dlopen).

This also solves the long-standing issue of `make check` only working after
`make install`, while removing our custom jemalloc from the installed
libraries.

Fixes #26.

Mbind is giving us trouble again, will need to spend time looking at it
carefully.

Instead of asking the user to provide the offsets into a tiling, add a
function providing a tileid. This tileid corresponds to the in-memory
order of tiles, making the tilestart functions a lot simpler.

We still need to split the tileid for tilestart because scratchpads
create requests based on tileids.

Also add a unit test for tiling_2d, to make sure we're not doing
anything crazy.

This patch provides aligned allocations for all areas. Simple tests
included.

Note that I haven't tested if it conflicts with arena-wide alignements.

We are starting to work on benchmarks to evaluate the usefulness of this
library. Instead of integrating them into the testing infrastructure, it
makes more sense for them to have their own directory and a different
way of handling them.

This patch:
 - creates a benchmark directory for actual codes that we want to use as
   benchmarks of our library.
 - moves functional tests into it.
 - add proper OpenMP detection for these codes

Mempolicy seems to be inconsistant depending on the distro. Need a more
complete investigation.

The mbind test could end trying to MBIND to too many numanodes at the
same time. Use only one numa node instead.

Fix small issues with type convertion across several tests,
as a change of architecture might trigger bad behavior in
variadic functions.

This is a second type of use for the scratchpad: a single master
thread is responsible for launching all data movements, but the tiles
are worked on in parallel. We support this model by using a sequential
scratch on top of a parallel dma.

Add openmp version of the previous functional test. We also rename them,
to mark the fact that those two tests are designed to use a *single-thread*
to run the kernel across an entire tile.

This patch reintroduce the first functional test, a stream add
implementation using pthreads for parallelism. We make use of our
scratch_par implementation to implement a pipelined version of the
application, where each worker thread is using its own batch of tiles,
and migrating data asynchronously.

Add a scratchpad that creates one pthread per request, to call
synchronous dma operations.

The intent is to end up with a cross product of programming language
support between dma and scratch:
- scratch_par + dma_seq gives users parallel scratch requests
- scratch_seq + dma_par gives users sequential access to parallel moves

The two other options don't make as much sense though.

Add a generic vector type to the library, with some special features:
- the elements are embedded in the vector, and not pointers
- each element must include an int field that is used as a "key"
- the element has a "null" value for its key, used to indicate that this
element of the vector is null.
- add/remove functions provide access to a new element/free it from the
vector, but don't "destroy" it.
- resize on add is exponential.

This patch includes implementation and unit test.

Move the scratchpad tiles into an internal concern:
- the scratchpad does the allocation
- the scratchpad tracks available tiles internally
- the user can ask for the scratch baseptr.

This is necessary to abstract move-based scratchs, and to remove from the
user responsibility of maintaining tiling and baseptr tracking.

We still fail-hard when tiles are not available, and the design is not
thread safe. But we are getting there.

This is the initial implementation and validation of a scratchpad: a
logic unit that handles tracking data across a "main" area and a
"scratch" area.

The API and internals will probably change again soon, as there's no
clear way to implement a move based scratchpad on this one.

Note that this implementation doesn't do any tracking, not really, and
that's the next step.

Replace the unused "max" argument for file-based mappings with an offset
argument (until now the offset was hardcoded to 0).