GitLab

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.

Kamil Iskra authored Mar 28, 2018 and Swann Perarnau committed Mar 29, 2018

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.

Using variable arguments on the tile id for retrieving tiling info makes
the API difficult to use when more than one tile must be used at the
same time.

We change the API to use a tileid, with the assumption that any valuable
tiling will be able to define a workable uuid scheme.

A few missing declarations in aml.h, to make it easier to deal with the
library.

As we cannot find out in advance the binding an area uses, it is not
possible to use a correctly allocated pointer to aml_area_binding.

Fixes a segfault we observed outside of current unit-tests.

Allows memory movement logic to ask a target area how memory should be
bound to it.

Note that it would be safer in the long term to have areas take a
binding at creation time, and translate to nodemasks internally.

Still the same schema, although it looks a bit messier on linux because
of all the options needed.

Same schema as for arena, we create init functions for each type of
area, to make sure that users know what they are working with.

The functions are easy here, as posix is more an allocator than anything
proper.

Add arena_jemalloc initialization, working the same way than tiling and
binding initializations.

We made the choice of not building generic arena allocation functions,
as the benefit of that isn't exactly obvious right now.

Also, we want users to understand the kind of arenas and areas they are
manipulating.

create -> register
purge -> deregister

create is a name we are using elsewhere for dynamic allocation.
And those names match better what we are doing.

Implement 1d tiling and simple binding support. The idea is to allow
an application to explain the AML how data should be organized, and to
be able to reuse this info when dealing with memory movement.

The current interfaces are not great, but they work.

Use a gitignore trick to ignore all files that don't have an extension.
That will cover all binary files generated by make on Linux.

The jemalloc subpackage install rule is too big, and includes stuff that
we don't need to add to the target system. This patch makes sure we only
install the valuable stuff.

We also correct the pkg-config data to match the new installs.