GitLab

Move towards a common list of args and a common log/timing
infrastructure for benchmarks.

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

Useful and currently missing.

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.

Disable CI runs for refs that are work in progress.

Simple gitlab-ci config with a single step, running the full list of
configure, make, make install and make check.

No tags, no split build and test for now, as artifacts are a bit tricky
to get right.

This config should grow in the future to ensure that we run all the test
on all the platforms we want.

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

We were unlocking the dma before the request type get set to a
proper value, resulting in requests sometimes overlapping when
multiple threads were used in benchmarks.

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.

When a user doesn't need a tile to be pushed back into the scratchpad,
it is better to just `release` that tile instead. This is particularly
useful for read-only data for applications that are bandwidth limited.

Also add documentation to two forgotten functions in the header file.

Note that several comments are still missing, specifically for the
area's acquire()/release()/available() routines, the function of which
is not clear to me.

Add mutex to make request creation and destruction thread-safe. As for
scratch_seq, we need to deal both with requests and tiles during these
functions, so we lock the entire section.

Add mutex to make request creation and destruction thread-safe. As we
need to deal both we requests and tiles during these functions, we lock
the entire section.

Add mutex to make request creation and destruction thread-safe. Same as
dma_linux_seq, the changes are quite simple, as we only need to protect
modifications to the requests array.

Add a mutex to make request creation and destruction thread-safe. As the
code here is quite simple, we only need to protect modifications to the
request array.

scratch_request_seq contains one extra tiling that is unnecessary.
Remove it.

The request type contains two much stuff, remove extra pointers to win
some space.

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.

Replace custom code with generic vectors for the scratch implementation.
In the process, fix a bug in the management of tiles, as they were being
freed on pull completion, which is wrong.

Use the newly introduced vector type to manage requests inside dmas.
This cleans up the API a bit, and remove dubious ops from the dma
internals.

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).

Add working implementation of copy and move to dma_linux_par, and
corresponding unit test.

Fix a few typos in the dma_linux_seq code, that for some reason didn't
raise any flags so far. Also add a small validation to the unit test.

Add a dma that spawns a fixed amount of theads for each request created.
The number of threads is configured at dma creation time.

This patch refactors dma request types to remove generic function
pointers from the library. This include modifying the linux_seq
implementation to:
- move the copy/move implementation to the dma ops
- remove one layer of indirection, as the request type no longer need
_data and _ops substructures.

Enforcing dma requests to have a fully qualified generic type, with
function pointers, will cause issues for future kinds of dma
implementation, that might require a different way of handling requests
altogether.

This work is driven by our current work on a parallel dma implementation.

Missing instructions in autogen.sh and missing jemalloc file to allow a
clean repo to compile.

Things have changed. Reflect the new code.

This patch adds the basics for a dma interface, including
type-dependent requests structures, and an API based on explicit
copy/move calls.

The APIs is flexible enough to deal with sync/async calls. The internal
design is inspired by aml_area, with the goal that create/init stay type
specific, but the core interactions are generic.