GitLab

If necessary, dma implementations copy the source and destination
layouts to avoid issues where the user would like to lose track of the
layout once the dma request has been launched.

Fixes #51.

Same as the others.

Add a configure option for building docs, and create a CI job that will
always run to validate it. Note that make install-data doesn't need
source builds, so the environment can be quite small.

This patch also fixes the uncovered issues, and make doc build fail on
warnings.

Some operators will need an extra argument (like transforms).

Change the DMA generic API to allow for a custom function pointer to
perform a specific request. Requires us to change a bit the underlying
management structures.

Now that only one type of request is allowed (layouts), remove va_args
for the DMA API, making it significantly cleaner.

Fix #49.

Remove support for direct pointers in a DMA request, with the goal to
remove va_args in the entire DMA API soon. As scratchs still work with
pointers, also modify scratchs to convert tiles in layouts.

This reverts commit 04315e6e.

Not needed since vector doesn't contain the actual inner type.

Various fixes related to dma API, missing validation on arguments,
pthread management and so on.

Since vector resize can cause pointers into the vector to become
invalid, this patch introduces a level of indirection for DMAs and
Scratchs, using uuid on the user-side of a request to index into the
request vector.

Refactor the DMA API to work on layouts internally. The resulting code
ends up simpler for most cases, as long as we add a generic copy
function.

One things missing:
- a good API to expose the collection of copy functions we have.

One question not solved:
- should the DMA ask for a copy function on each operation ?

Use the newly added INNER_MALLOC for all the relevant creators.

Removes static allocations of all objects from the library.
While this will make our code less compact in theory,
this part of the API is too confusing for new users.

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

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

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

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

Nicolas Denoyelle authored Mar 12, 2019 and Swann Perarnau committed Mar 13, 2019

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

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.

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.

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.

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.

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.

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.