diff --git a/deps/mamba/Makefile.am b/deps/mamba/Makefile.am
index 1643b5c061e27a75aa6bfef2dad9fc681aa91410..13d6d8b870f7222386f98a85600d149afc182379 100644
--- a/deps/mamba/Makefile.am
+++ b/deps/mamba/Makefile.am
@@ -52,5 +52,8 @@ SUBDIRS = $(loop_SUBDIRS) common memory . examples
 
 dist_doc_DATA = README.md
 
+mambapkgconfigdir = $(libdir)/pkgconfig
+mambapkgconfig_DATA = mamba.pc
+
 check-examples:
 	$(MAKE) $(AM_MAKEFLAGS) -C examples check
diff --git a/deps/mamba/README.md b/deps/mamba/README.md
index 5d41b069632c7dde9f4213b8b400dd731cec66e7..2a8ca0968c23b53891b6aa258822852603d734fb 100644
--- a/deps/mamba/README.md
+++ b/deps/mamba/README.md
@@ -55,23 +55,24 @@ In order to modify the default behavior in order to make it fit better your usag
 The following variables can be set at compile time (or during the call to `configure` when provided to `CPPFLAGS`).
 In order to set their value, use the format `-D<name>=<value>`.
 
-  * `MMB_MAX_SPACES`: Maximum number of different mmbMemSpace available at once. Default: 5.
-  * `MMB_MAX_INTERFACES`: Maximum of number of interfaces per space. Default: 10.
-  * `MMB_MAX_ALLOCATIONS`: Not used. Default: 10.
-  * `MMB_CONFIG_DEFAULT_INTERFACE`: Default memory interface to use to allocate memory when none is requested. Default: `MMB_NATIVE`.
+  * `MMB_CONFIG_DEFAULT_PROVIDER`: Default memory provider to use to allocate memory when none is requested. Default: `MMB_NATIVE`.
   * `MMB_CONFIG_DEFAULT_STRATEGY`: Default memory allocation strategy to use when none is requested. Default: `MMB_NO_STRAT`.
   * `MMB_CONFIG_DEFAULT_GPU_CONTEXT`: Default execution context to use when allocating and copying memory to/from GPUs. Default: `MMB_GPU_CUDA`.
+  * `MMB_ENV_DEFAULT_PROVIDER_NAME`: Environment variable's name to look for when setting default provider. Default: `MMB_CONFIG_DEFAULT_PROVIDER`.
+  * `MMB_ENV_DEFAULT_STRATEGY_NAME`: Environment variable's name to look for when setting default strategy. Default: `MMB_CONFIG_DEFAULT_STRATEGY`.
+  * `MMB_ENV_DEFAULT_GPU_CONTEXT_NAME`: Environment variable's name to look for when setting default execution context for the GPU. Default: `MMB_CONFIG_DEFAULT_GPU_EXECUTION_CONTEXT`.
 
 ### Run-time
 
 The following variables can be set in the environment at run-time in order to modify some of the compile-time defined behaviors.
 These variable are read only once, during the library initialization.
 
-  * `MMB_CONFIG_DEFAULT_INTERFACE_TYPE`
+  * `MMB_CONFIG_DEFAULT_PROVIDER`
   * `MMB_CONFIG_DEFAULT_STRATEGY`
   * `MMB_CONFIG_DEFAULT_GPU_EXECUTION_CONTEXT`
 
 The variables defaults to the compile-time values.
+The name of these of these variable can be changed at compile time by setting `MMB_ENV_DEFAULT_PROVIDER_NAME`, `MMB_ENV_DEFAULT_STRATEGY_NAME` and `MMB_ENV_DEFAULT_GPU_CONTEXT_NAME` respectively.
 For simplicity, `MMB_CONFIG_DEFAULT_GPU_EXECUTION_CONTEXT` also accepts `NONE` as a valid choice.
 
 # API Usage
@@ -119,7 +120,7 @@ Usage: `(all args optional): ./matrix_multiply -v (for verbose mode) -t N (for t
 
 This demonstrates a tiled matrix multiply using multiple mamba arrays constructed on top of pre-initialised (with random or identity values) matrix buffers.
 This example also present how to allocate and use memory on different memory devices (DRAM, GPU, HBM, ...), and how to copy from one memory tier to an other.
-This example shows as well how to use different strategies and/or different memory interfaces.
+This example shows as well how to use different strategies and/or different memory providers.
 
 This example works the same as the [matrix_multiply.c example](#matrix_multiply), excepted that it requires extra steps to pass the data to the actual kernel (in addition to allocate the data on the GPU memory, the tiling information needs to be forwarded as well).
 The [CUDA file](./examples/matrix_multiply_cuda_ker.cu) only deals with this forwarding (the packing is done in [examples/matrix_multiply_cuda.c](./examples/matrix_multiply_cuda.c)).
diff --git a/deps/mamba/common/Makefile.am b/deps/mamba/common/Makefile.am
index 2b084988421e0f535cea7d690ac8b8ae900f6eab..f072218b23bd0f13cc6d194c07af7b8daa34577f 100644
--- a/deps/mamba/common/Makefile.am
+++ b/deps/mamba/common/Makefile.am
@@ -28,8 +28,8 @@
 #  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 #  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #  */
- 
-AM_CPPFLAGS = -I$(top_srcdir) -I.  -I$(top_srcdir)/memory 
+
+AM_CPPFLAGS = -I$(top_srcdir)/memory
 
 noinst_LTLIBRARIES = libmmb-common.la
 
@@ -44,7 +44,7 @@ libmmb_common_la_SOURCES = mamba.c \
 					mmb_error.c  				\
 					mmb_version.c
 
-include_HEADERS = mamba.h     \
+nobase_include_HEADERS = mamba.h     \
 					mmb_layout.h        \
 					mmb_dimensions.h    \
 					mmb_index.h         \
@@ -55,11 +55,10 @@ include_HEADERS = mamba.h     \
 					mmb_error.h 				\
 					uthash.h
 
+oldincludedir = @includedir@/common
 
 if WITH_LOOP_ANALYSIS
- EXTRA_FLAGS = $(LOOP_ANALYSIS_CFLAGS)
+  AM_CPPFLAGS += $(LOOP_ANALYSIS_CPPFLAGS)
 endif
 
-libmmb_common_la_CPPFLAGS =  $(AM_CPPFLAGS) $(EXTRA_FLAGS)
-
 libmmb_common_la_SHORTNAME = mmb-common
diff --git a/deps/mamba/common/mamba.c b/deps/mamba/common/mamba.c
index 2cead83c66b75374874a69eea8f254928adef3cd..7c89f81e6ef3150c9c7f68884c31a8b101ac4c53 100644
--- a/deps/mamba/common/mamba.c
+++ b/deps/mamba/common/mamba.c
@@ -35,8 +35,9 @@
 #include "mmb_tile.h"
 #include "mmb_tile_iterator.h"
 #include "mmb_logging.h"
-#include <mmb_memory.h>
-#include <mmb_allocation.h>
+#include "mmb_memory.h"
+/* Keep the full path to ease the research of the correpsonding header */
+#include "../memory/allocation.h"
 
 #ifdef HAVE_LOOP_ANALYSIS
 #include "mmb_loop.h"
@@ -88,6 +89,7 @@ mmbError mmb_init( mmbOptions *in_opts ) {
     return MMB_ERROR;
   }
 
+  (void) in_opts;
   mmbError stat = MMB_OK;
 
   stat = mmb_manager_create(&g_manager);
@@ -188,7 +190,7 @@ mmbError mmb_array_create(mmbDimensions *in_dims, mmbLayout *in_layout,
   }  
   mba->access = in_access;
   mmbMemInterface *interface;
-  stat = mmb_memspace_request_interface(in_space, MMB_DEFAULT_MEMINTERFACE,
+  stat = mmb_memspace_request_interface(in_space, MMB_DEFAULT_PROVIDER,
                                         MMB_DEFAULT_STRATEGY, &interface);
   if (MMB_OK != stat) {
     ERR("Unable to get interface for specified memory space.\n");
diff --git a/deps/mamba/common/mamba.h b/deps/mamba/common/mamba.h
index 59655b843a03503ed33dad2c4e101ea6e572d686..6a556a4db7d4b2d64e7524cd1591122e497751be 100644
--- a/deps/mamba/common/mamba.h
+++ b/deps/mamba/common/mamba.h
@@ -39,6 +39,7 @@
 #include "mmb_dimensions.h"
 #include "mmb_error.h"
 #include "mmb_tile.h"
+#include "mmb_memory.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/deps/mamba/common/mmb_dimensions.c b/deps/mamba/common/mmb_dimensions.c
index 336898250b1906dbd52d5e6b7476d1387f073dda..0b1cfa68c0c8e068895caf3a83ef3046097c2aca 100644
--- a/deps/mamba/common/mmb_dimensions.c
+++ b/deps/mamba/common/mmb_dimensions.c
@@ -39,6 +39,14 @@ mmbError mmb_dimensions_create(const size_t ndim, mmbDimensions **out_dims) {
   return mmbSet_size_t_create(ndim, out_dims);
 }
 
+mmbError mmb_dimensions_set(mmbDimensions *in_dims, size_t dim0, ...) {
+  va_list args;
+  va_start(args, dim0);
+  mmbError stat = mmbSet_size_t_set(in_dims, dim0, args);
+  va_end(args);
+  return stat;
+}
+
 mmbError mmb_dimensions_copy(mmbDimensions *dst, const mmbDimensions *src) {
   return mmbSet_size_t_copy(dst, src);
 }
diff --git a/deps/mamba/common/mmb_dimensions.h b/deps/mamba/common/mmb_dimensions.h
index 702f062674c5e0f603a118dc796223b4f928d0fe..3d77f71e8d6663a2accb6d2ff7ef5b29cc7d1808 100644
--- a/deps/mamba/common/mmb_dimensions.h
+++ b/deps/mamba/common/mmb_dimensions.h
@@ -25,6 +25,21 @@ extern const mmbDimensions mmb_dimensions_empty;
  */
 mmbError mmb_dimensions_create(const size_t ndim, mmbDimensions **out_dims);
 
+/**
+ * @brief      Populate a set with as many elements as size of \p in_dims.
+ *
+ * If less elements are given, the end of the set will be overwritten with
+ * unpredictable values. If too many elements are given, only the
+ * size(\p in_dims) first parameter values will be used.
+ *
+ * @param [in] in_dims    The set of dimensions to populate.
+ * @param [in] dim0       First value to add to the set.
+ * @param [in] ...        \p in_dims->size - 1 other elements of the set.
+ *
+ * @return     MMB_OK on success
+ */
+mmbError mmb_dimensions_set(mmbDimensions *in_dims, size_t dim0, ...);
+
 /**
  * @brief      Copy a set of dimensions from \p src to \p dst, both are
  *             expected to be allocated.
@@ -117,7 +132,7 @@ mmbError mmb_dimensions_prod(const mmbDimensions *in_dims, size_t *out_prod);
  *
  * @return     MMB_OK on success, the appropriate mmbError otherwise.
  */
-mmbError mmb_dimensions_set_buf_addr(mmbDimensions *in_dims, size_t *out_prod);
+mmbError mmb_dimensions_set_buf_addr(mmbDimensions *in_dims, size_t *buffer);
 
 /**
  * @brief      Compute the number of elements in mmbDimensions.
diff --git a/deps/mamba/common/mmb_error.c b/deps/mamba/common/mmb_error.c
index fd7d195e9eef59c6be4254c105b769239f4c9aac..de0e073e77dc353c3f1ed951a9d9b30d61bf85e6 100644
--- a/deps/mamba/common/mmb_error.c
+++ b/deps/mamba/common/mmb_error.c
@@ -40,8 +40,8 @@ const char * const mmb_error_table[MMB_ERROR__MAX] = {
   [MMB_NOT_FOUND]                 = "requested item not found",
   [MMB_INVALID_ARG]               = "invalid argument",
   [MMB_INVALID_LAYER]             = "operation impossible for the given layer",
+  [MMB_INVALID_PROVIDER]          = "provider unavailable",
   [MMB_INVALID_INTERFACE]         = "no valid interface available",
-  [MMB_INVALID_INTERFACE_TYPE]    = "nterface type unavailable",
   [MMB_INVALID_EXECUTION_CONTEXT] = "execution context unavailable",
   [MMB_INVALID_STRATEGY]          = "no valid strategy available",
   [MMB_INVALID_ALLOCATION]        = "allocation handle invalid or in inconsistent state",
diff --git a/deps/mamba/common/mmb_error.h b/deps/mamba/common/mmb_error.h
index 70e0ddde5a9404591765f75d94b928557d89ade4..a90d815f0404bbadf8635ba3512c9fae69a852e9 100644
--- a/deps/mamba/common/mmb_error.h
+++ b/deps/mamba/common/mmb_error.h
@@ -43,8 +43,8 @@ enum e_mmbError {
   MMB_NOT_FOUND,
   MMB_INVALID_ARG,
   MMB_INVALID_LAYER,
+  MMB_INVALID_PROVIDER,
   MMB_INVALID_INTERFACE,
-  MMB_INVALID_INTERFACE_TYPE,
   MMB_INVALID_EXECUTION_CONTEXT,
   MMB_INVALID_STRATEGY,
   MMB_INVALID_ALLOCATION,
diff --git a/deps/mamba/common/mmb_index.c b/deps/mamba/common/mmb_index.c
index 72a00370f6ee81fbeeb94073099ce9311c44b59a..62f05c62d2ce7f8810454c13ebf5f939713898e0 100644
--- a/deps/mamba/common/mmb_index.c
+++ b/deps/mamba/common/mmb_index.c
@@ -33,6 +33,8 @@
 #include "mmb_index.h"
 #include <stdarg.h>
 
+const mmbIndex mmb_index_empty = s_mmbSet_empty(size_t);
+
 mmbError mmb_index_create(const size_t ndim, mmbIndex **out_idx) {
   return mmbSet_size_t_create(ndim, out_idx);
 }
@@ -68,3 +70,19 @@ mmbError mmb_index_destroy(mmbIndex *in_idx) {
 int mmb_index_cmp(const mmbIndex *i1, const mmbIndex *i2) {
   return mmbSet_size_t_cmp(i1, i2);
 }
+
+mmbError mmb_index_prod(const mmbIndex *in_idx, size_t *out_prod) {
+  return mmbSet_size_t_prod(in_idx, out_prod);
+}
+
+mmbError mmb_index_set_buf_addr(mmbIndex *in_idx, size_t *buffer) {
+  return mmbSet_size_t_set_buf_addr(in_idx, buffer);
+}
+
+mmbError mmb_index_get_size(const mmbIndex *in_idx, size_t *size) {
+  return mmbSet_size_t_get_size(in_idx, size);
+}
+
+mmbError mmb_index_get_sizeof(const mmbIndex *in_idx, size_t *size) {
+  return mmbSet_size_t_get_sizeof(in_idx, size);
+}
diff --git a/deps/mamba/common/mmb_index.h b/deps/mamba/common/mmb_index.h
index 8ad511c1e7bd95710838e96b315bccc682319585..ae09574ea00836741c8d0bb1c25f1e9769c13360 100644
--- a/deps/mamba/common/mmb_index.h
+++ b/deps/mamba/common/mmb_index.h
@@ -42,6 +42,8 @@ extern "C" {
 
 typedef mmbSet_size_t mmbIndex;
 
+extern const mmbIndex mmb_index_empty;
+
 mmbError mmb_index_create(const size_t ndim, mmbIndex **out_idx);
 mmbError mmb_index_set(mmbIndex *in_idx, size_t id0, ...);
 mmbError mmb_index_copy(mmbIndex *dst, const mmbIndex *src);
@@ -50,6 +52,10 @@ mmbError mmb_index_fill(mmbIndex *dst, const size_t *src, const size_t nelt);
 mmbError mmb_index_resize(mmbIndex *in_idx, const size_t ndim);
 mmbError mmb_index_destroy(mmbIndex *in_idx);
 int mmb_index_cmp(const mmbIndex *i1, const mmbIndex *i2);
+mmbError mmb_index_prod(const mmbIndex *in_idx, size_t *out_prod);
+mmbError mmb_index_set_buf_addr(mmbIndex *in_idx, size_t *buffer);
+mmbError mmb_index_get_size(const mmbIndex *in_idx, size_t *size);
+mmbError mmb_index_get_sizeof(const mmbIndex *in_idx, size_t *size);
 
 #ifdef __cplusplus
 }
diff --git a/deps/mamba/common/mmb_layout.c b/deps/mamba/common/mmb_layout.c
index dd8f8992b0d25ce8397608015b3f4a8af5188616..a8c64e5301bfa43da3ea11be66b0d12dcf07cdd0 100644
--- a/deps/mamba/common/mmb_layout.c
+++ b/deps/mamba/common/mmb_layout.c
@@ -98,6 +98,8 @@ mmbError mmb_layout_create_block(size_t n_dims, size_t element_size_bytes,
                                  mmbDimensions *block_order, 
                                  mmbLayoutPadding *pad, 
                                  mmbLayout **out_layout) {
+  (void) n_dims; (void) element_size_bytes; (void) element_order;
+  (void) block_size; (void) block_order; (void) pad; (void) out_layout;
   return MMB_UNIMPLEMENTED;
 }
 
@@ -105,6 +107,7 @@ mmbError mmb_layout_create_irregular_1d(size_t element_size_bytes,
                                      size_t *offsets, 
                                      size_t *sizes, 
                                      mmbLayout **out_layout) {
+  (void) element_size_bytes; (void)offsets; (void) sizes; (void) out_layout;
   return MMB_UNIMPLEMENTED;
 }
 
diff --git a/deps/mamba/common/mmb_logging.h b/deps/mamba/common/mmb_logging.h
index 1cdcab8345b41e030ec7bd305bfac58e3dcfb9d2..bb7e2228d09084255d104e0aefc7045355ab0215 100644
--- a/deps/mamba/common/mmb_logging.h
+++ b/deps/mamba/common/mmb_logging.h
@@ -104,12 +104,12 @@ void mmb_location_aware_log(int level, const char *func, const char *file,
 
 /** Convenience macro to check states and goto label **/
 #define CHECK_STATUS(stat, message, label) \
-  {                                        \
+  do {                                     \
     if(stat != MMB_OK) {                   \
       ERR(message);                        \
       goto label;                          \
     }                                      \
-  }
+  } while (0)
 
 
 /** @} (group macros) */
diff --git a/deps/mamba/common/mmb_set.c b/deps/mamba/common/mmb_set.c
index 3ce774392f887b81a604d6a80dbcbae8bae9a8c5..fa82f0b6f0f6339ed5eb162fb03dc22c5f2fc257 100644
--- a/deps/mamba/common/mmb_set.c
+++ b/deps/mamba/common/mmb_set.c
@@ -73,7 +73,7 @@
 #define s_mmbSet_set_fct(T)                                                 \
   s_mmbSet_set(T)                                                           \
 {                                                                           \
-  in_set->d[0] = s1;                                                        \
+  in_set->d[0] = s0;                                                        \
   for(size_t i = 1; i < in_set->size; i++)                                  \
     in_set->d[i] = va_arg(vargs, T);                                        \
   return MMB_OK;                                                            \
diff --git a/deps/mamba/common/mmb_set.h b/deps/mamba/common/mmb_set.h
index e3631a1abe09add826b1ef013a08de5072260e4e..d895f0353921f480792002fb14a99dd235b7e790 100644
--- a/deps/mamba/common/mmb_set.h
+++ b/deps/mamba/common/mmb_set.h
@@ -69,7 +69,7 @@
   mmbError mmbSet_ ## T ## _create(const size_t ndim, mmbSet_name(T) **out_set)
 
 #define s_mmbSet_set(T)                                                     \
-  mmbError mmbSet_ ## T ## _set(mmbSet_name(T) *in_set, T s1, va_list vargs)
+  mmbError mmbSet_ ## T ## _set(mmbSet_name(T) *in_set, T s0, va_list vargs)
 
 #define s_mmbSet_copy(T)                                                    \
   mmbError mmbSet_ ## T ## _copy(mmbSet_name(T) *dst, const mmbSet_name(T) *src)
diff --git a/deps/mamba/common/mmb_tile.c b/deps/mamba/common/mmb_tile.c
index b634fed7bebb63ee2651597346ad49cebf62f585..f9ddcb900a378bae2c46dd8f79f3fe79c88967ec 100644
--- a/deps/mamba/common/mmb_tile.c
+++ b/deps/mamba/common/mmb_tile.c
@@ -484,7 +484,7 @@ mmbError mmb_tile_migrate(mmbArrayTile *in_tile, mmbMemSpace *in_space,
 
     Free old tile
   */ 
-
+  (void) in_tile; (void) in_space; (void) in_access; (void) in_layout;
   mmbError stat = MMB_UNIMPLEMENTED;
   return stat;
 }
@@ -636,7 +636,7 @@ mmbError mmb_tile_lower_byte_offset(mmbArrayTile *tile, size_t *n_bytes) {
   /* Ptr comparison between mmbAllocation and tile starting index */
   /* TODO: This should support ND */
   /* TODO: Support padding here? */
-  unsigned char* tile_lower_ptr;
+  unsigned char* tile_lower_ptr = NULL;
   switch(tile->layout->n_dims) {
     case 1:
       tile_lower_ptr = (unsigned char*)&(MMB_IDX_1D(tile, tile->lower[0], unsigned char));
@@ -646,6 +646,8 @@ mmbError mmb_tile_lower_byte_offset(mmbArrayTile *tile, size_t *n_bytes) {
     break;
     default:
       ERR("Unsupported dimensions for tile indexing\n");
+      stat = MMB_ERROR;
+      goto BAILOUT;
     break;
   }
   size_t n_elements = tile_lower_ptr - (unsigned char*)tile->allocation->ptr;
diff --git a/deps/mamba/common/mmb_tile.h b/deps/mamba/common/mmb_tile.h
index cab44062ff599c617b2918dd2b3f862016538463..8e746143733fd45f53e47a2c480ad21f0c21a443 100644
--- a/deps/mamba/common/mmb_tile.h
+++ b/deps/mamba/common/mmb_tile.h
@@ -33,12 +33,12 @@
 #define MMB_TILE_H
 
 
-#include "uthash.h"
+#include <uthash.h>
 
 #include "mmb_layout.h"
 #include "mmb_dimensions.h"
 #include "mmb_index.h"
-#include <mmb_memory.h>
+#include "mmb_memory.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/deps/mamba/common/mmb_tile_iterator.c b/deps/mamba/common/mmb_tile_iterator.c
index 8b1e902107b884ac6ecdaa246ec4003735b52909..750b1722b50fc64b1295a88472f1e577033d6141 100644
--- a/deps/mamba/common/mmb_tile_iterator.c
+++ b/deps/mamba/common/mmb_tile_iterator.c
@@ -37,14 +37,15 @@ mmbError mmb_tile_iterator_create(mmbArray *in_mba, mmbTileIterator** out_it){
   mmbError stat = MMB_OK;
   /* Check we have a tiling */
   if(!in_mba)
-    return MMB_ERROR;
+    return MMB_INVALID_ARG;
 
   if(!in_mba->tiling)
     return MMB_ERROR;
 
-  
+  if(!out_it)
+    return MMB_INVALID_ARG;
+
   /* Allocate new iterator */
-  *out_it = NULL;
   mmbTileIterator *it = (mmbTileIterator *)calloc(1, sizeof(mmbTileIterator));
   
   /* Initialise */
diff --git a/deps/mamba/configure.ac b/deps/mamba/configure.ac
index bce5e84af99c7bb52c6af945e3bc13d9c045f449..b966b8c8a1bf151b80df71014ad7872e84e3dd0e 100644
--- a/deps/mamba/configure.ac
+++ b/deps/mamba/configure.ac
@@ -29,13 +29,10 @@
 #  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #  */
 
-AC_INIT([mamba], [0.1.1], [emearesearchlab@hpe.com])
+AC_INIT([mamba], [0.1.2], [emearesearchlab@hpe.com])
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_AUX_DIR([build-aux])
 AC_PROG_CC
-AC_CHECK_DECL([ftruncate], [],
-              [AC_MSG_FAILURE([Shared memory needs the function ftruncate to work properly. Please consider modifying your compilation flags to enable it.])],
-              [[#include <unistd.h>]])
 AC_CHECK_TYPES(uint64_t)
 AM_PROG_AR
 AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects tar-ustar])
@@ -146,9 +143,11 @@ AC_ARG_WITH([loop_analysis],
             [AS_IF([test "x$with_loop_analysis" != "xno"],
                   [AC_DEFINE([HAVE_LOOP_ANALYSIS], [1],
                                     [Defined if you are using the loop analysis module])
-                   LOOP_ANALYSIS_CFLAGS='-I$(top_srcdir)/loop_analysis -I$(top_srcdir)/loop_analysis/loopanalyzer -I$(top_srcdir)/loop_analysis/loopanalyzer/pet/include -I$(top_srcdir)/loop_analysis/loopanalyzer/pet/isl/include -I$(top_builddir)/loop_analysis/loopanalyzer/pet/isl/include'
+                   LOOP_ANALYSIS_CPPFLAGS='-I$(top_srcdir)/loop_analysis -I$(top_srcdir)/loop_analysis/loopanalyzer -I$(top_srcdir)/loop_analysis/loopanalyzer/pet/include -I$(top_srcdir)/loop_analysis/loopanalyzer/pet/isl/include -I$(top_builddir)/loop_analysis/loopanalyzer/pet/isl/include'
                    LOOP_ANALYSIS_LIB='$(top_builddir)/loop_analysis/libmmb-loop.la'
-                   AC_SUBST(LOOP_ANALYSIS_CFLAGS)
+                   AC_SUBST(LOOP_ANALYSIS_CPPFLAGS_INSTALL,
+                            [-I${includedir}/loop_analysis])
+                   AC_SUBST(LOOP_ANALYSIS_CPPFLAGS)
                    AC_SUBST(LOOP_ANALYSIS_LIB)
                    AX_SUBDIRS_CONFIGURE([loop_analysis/loopanalyzer], [],[],[])
             ])],
@@ -206,10 +205,12 @@ AS_IF([test "x$enable_discovery" != "xno"],
                     [AC_MSG_WARN([Disabling auto-discovery of the topology.])],
                     [AC_MSG_ERROR([cannot activate discovery, but --enable-discovery given.])])
              ])
+       HWLOC_REQUIRES="hwloc>=2.0"
       ],
       [dnl Disable the topology discovery
        discovery_happy=no
       ])
+AC_SUBST([HWLOC_REQUIRES])
 
 AM_CONDITIONAL([ENABLE_DISCOVERY], [test "x$discovery_happy" != xno])
 AC_DEFINE_UNQUOTED([ENABLE_DISCOVERY],
@@ -223,6 +224,7 @@ AC_CONFIG_FILES([
     memory/Makefile
     examples/Makefile
     loop_analysis/Makefile
+    mamba.pc
 ])
 
 AC_OUTPUT
diff --git a/deps/mamba/examples/1d_array_copy.c b/deps/mamba/examples/1d_array_copy.c
index 7c6e396cd0650125748b7a879fc1c63e0d14a28b..6d75917a9c1e51cbe36443465e5b4b68a0d3d135 100644
--- a/deps/mamba/examples/1d_array_copy.c
+++ b/deps/mamba/examples/1d_array_copy.c
@@ -33,11 +33,11 @@
 #include <stdlib.h>
 #include <time.h>
 
-#include "mamba.h"
-#include "mmb_tile.h"
-#include "mmb_tile_iterator.h"
-#include "memory/mmb_memory.h"
-#include "mmb_logging.h"
+#include <mamba.h>
+#include <mmb_tile.h>
+#include <mmb_tile_iterator.h>
+#include <mmb_memory.h>
+#include <mmb_logging.h>
 
 mmbError mmb_array_cmp(mmbArray *mba0, mmbArray *mba1, bool *result);
 mmbError mmb_tile_cmp(mmbArrayTile *tile0, mmbArrayTile *tile1, bool *result);
diff --git a/deps/mamba/examples/1d_array_copy_wrapped.c b/deps/mamba/examples/1d_array_copy_wrapped.c
index dcec0935d1d9adc170c9a27caa450685b594965a..95df7d4c6e2256316611916336733c338771ddbc 100644
--- a/deps/mamba/examples/1d_array_copy_wrapped.c
+++ b/deps/mamba/examples/1d_array_copy_wrapped.c
@@ -32,10 +32,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "mamba.h"
-#include "mmb_tile_iterator.h"
-#include "memory/mmb_memory.h"
-#include "mmb_logging.h"
+#include <mamba.h>
+#include <mmb_tile_iterator.h>
+#include <mmb_memory.h>
+#include <mmb_logging.h>
 
 int check_buffer(float* buf, const size_t M){
   int success = 1;
diff --git a/deps/mamba/examples/Makefile.am b/deps/mamba/examples/Makefile.am
index 1fc24409db3975f7e0f0a183d2cb4c4942eb6c91..104564c0295284c358ec9a6c43070848b4cf89d5 100644
--- a/deps/mamba/examples/Makefile.am
+++ b/deps/mamba/examples/Makefile.am
@@ -31,7 +31,7 @@
 
 SUFFIXES = .cu .c
 
-AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/common -I$(top_srcdir)/memory
+AM_CPPFLAGS = -I$(top_srcdir)/common -I$(top_srcdir)/memory
 AM_CFLAGS   =
 AM_LDFLAGS  = -no-install
 
@@ -63,8 +63,7 @@ if CUDA
     nodist_EXTRA_matrix_multiply_cuda_SOURCES = dummy.cxx
 
     check_bin += tile_duplicate_cuda
-    tile_duplicate_cuda_SOURCES = tile_duplicate_cuda.c       \
-                                  tile_duplicate_cuda.h
+    tile_duplicate_cuda_SOURCES = tile_duplicate_cuda.c
     tile_duplicate_cuda_LDFLAGS = $(AM_LDFLAGS) $(CUDA_LDFLAGS)
     tile_duplicate_cuda_LDADD = tile_duplicate_cuda_ker.$(OBJEXT) \
                                  ../libmmb.la ${extra_libs} $(CUDA_LIBS)
@@ -75,7 +74,7 @@ endif
 
 if WITH_LOOP_ANALYSIS
 check_bin += loop_description
-loop_description_CPPFLAGS = $(AM_CPPFLAGS) $(LOOP_ANALYSIS_CFLAGS)
+loop_description_CPPFLAGS = $(AM_CPPFLAGS) $(LOOP_ANALYSIS_CPPFLAGS)
 loop_description_LDFLAGS = $(AM_LDFLAGS) 
 loop_description_LDADD = ../libmmb.la ${extra_libs}
 endif
diff --git a/deps/mamba/examples/loop_description.c b/deps/mamba/examples/loop_description.c
index 585718bb0bd67f3c3ae328b248b244e518092f2b..b6aee097e5e20ba1a2040c63f7d30be1670456f4 100644
--- a/deps/mamba/examples/loop_description.c
+++ b/deps/mamba/examples/loop_description.c
@@ -29,12 +29,12 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "stdio.h"
-#include "stdlib.h"
+#include <stdio.h>
+#include <stdlib.h>
 
-#include "mamba.h"
-#include "mmb_logging.h"
-#include "mmb_loop.h"
+#include <mamba.h>
+#include <mmb_logging.h>
+#include <mmb_loop.h>
 
 int main()
 {
diff --git a/deps/mamba/examples/matrix_multiply.c b/deps/mamba/examples/matrix_multiply.c
index f2309b7115d05b154e9bba3337f434a13f99f5ad..041987e5f2d08fa5b2a73001cf2bf827511905c0 100644
--- a/deps/mamba/examples/matrix_multiply.c
+++ b/deps/mamba/examples/matrix_multiply.c
@@ -36,11 +36,11 @@
 #include <string.h>
 #include <ctype.h>
 
-#include "mamba.h"
-#include "mmb_tile.h"
-#include "mmb_tile_iterator.h"
-#include "memory/mmb_memory.h"
-#include "mmb_logging.h"
+#include <mamba.h>
+#include <mmb_tile.h>
+#include <mmb_tile_iterator.h>
+#include <mmb_memory.h>
+#include <mmb_logging.h>
  
 void init_matrix_buffers(float* buf_a, float* buf_b, const size_t M, const size_t N, int b_is_identity);
 int  check_result(float* buf_a, float* buf_b, float* buf_c, const size_t M, const size_t N);
diff --git a/deps/mamba/examples/matrix_multiply_cuda.c b/deps/mamba/examples/matrix_multiply_cuda.c
index 208176e5f43d11f315ba00081e107c09eace8521..be8ae7c5b92dd5c0bccf449b8d00eadfe74a8485 100644
--- a/deps/mamba/examples/matrix_multiply_cuda.c
+++ b/deps/mamba/examples/matrix_multiply_cuda.c
@@ -39,7 +39,7 @@
 #include <mamba.h>
 #include <mmb_tile.h>
 #include <mmb_tile_iterator.h>
-#include <memory/mmb_memory.h>
+#include <mmb_memory.h>
 #include <mmb_logging.h>
 
 #include "matrix_multiply_cuda.h"
@@ -136,13 +136,13 @@ int main(int argc, char *const argv[])
   }
 #endif /* ENABLE_DISCOVERY */
 
-  mmbMemInterfaceType host_interface_type;
+  mmbProvider host_provider;
 #if HAVE_SICM
-  host_interface_type = MMB_SICM;
+  host_provider = MMB_SICM;
 #else
-  host_interface_type = MMB_DEFAULT_MEMINTERFACE;
+  host_provider = MMB_DEFAULT_PROVIDER;
 #endif /* HAVE_SICM */
-  err = mmb_memspace_request_interface(host, host_interface_type,
+  err = mmb_memspace_request_interface(host, host_provider,
                                        MMB_POOLED, &host_interface);
   if (MMB_OK != err) {
     ERR("CPU interface request failed. (%d)\n", err);
@@ -165,7 +165,7 @@ int main(int argc, char *const argv[])
   }
 #endif /* ENABLE_DISCOVERY */
 
-  err = mmb_memspace_request_interface(device, MMB_DEFAULT_MEMINTERFACE,
+  err = mmb_memspace_request_interface(device, MMB_DEFAULT_PROVIDER,
                                        MMB_POOLED, &device_interface);
   if (MMB_OK != err) {
     ERR("GPU interface request failed. (%d)\n", err);
diff --git a/deps/mamba/examples/matrix_multiply_cuda.h b/deps/mamba/examples/matrix_multiply_cuda.h
index 301d6baf5fbe1de2b6d327ea0d82feea6ddf4259..e678cfde250d4256687738a45644182b167a3a45 100644
--- a/deps/mamba/examples/matrix_multiply_cuda.h
+++ b/deps/mamba/examples/matrix_multiply_cuda.h
@@ -32,7 +32,6 @@
 #ifndef MAT_MUL_CUDA_H
 #define MAT_MUL_CUDA_H
 
-#include <mamba.h>
 #include <mmb_memory.h>
 
 #ifdef __cplusplus
diff --git a/deps/mamba/examples/report_mem_state.c b/deps/mamba/examples/report_mem_state.c
index b7652487e31432b83f92431c92cd727c72b9a6b0..26ea0052d1cbc5cfee0414794cec148afede417d 100644
--- a/deps/mamba/examples/report_mem_state.c
+++ b/deps/mamba/examples/report_mem_state.c
@@ -32,8 +32,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "mamba.h"
-#include "mmb_logging.h"
+#include <mamba.h>
+#include <mmb_logging.h>
 
 int main(void)
 {
diff --git a/deps/mamba/examples/tile_duplicate.c b/deps/mamba/examples/tile_duplicate.c
index 7810e683cd84b4fd2e48ea1497e1b5bfb80abdd6..3214a1d2177267704b656bdb44b63b5ec40ebf59 100644
--- a/deps/mamba/examples/tile_duplicate.c
+++ b/deps/mamba/examples/tile_duplicate.c
@@ -39,10 +39,9 @@
 #include <mamba.h>
 #include <mmb_tile.h>
 #include <mmb_tile_iterator.h>
-#include <memory/mmb_memory.h>
+#include <mmb_memory.h>
 #include <mmb_logging.h>
 
-
 mmbError init_matrix_buffer(mmbArray *mba_a);
 mmbError write_to_tile(mmbArrayTile *tile);
 mmbError check_result(mmbArray *mba);
@@ -175,7 +174,7 @@ BAILOUT:
   return stat;
 }
 
-mmbError write_to_tile(mmbArrayTile *tile) 
+mmbError write_to_tile(mmbArrayTile *tile)
 {
   // Pick up the tile  from the allocated metadata
   mmbArrayTile *dev_tile;
diff --git a/deps/mamba/examples/tile_duplicate_cuda.c b/deps/mamba/examples/tile_duplicate_cuda.c
index cee5cbb67fcf84d279364cbf9748e5ebe4006a73..622b363c9aa1e113b8a3379e49f1215f3c2dac7f 100644
--- a/deps/mamba/examples/tile_duplicate_cuda.c
+++ b/deps/mamba/examples/tile_duplicate_cuda.c
@@ -39,13 +39,14 @@
 #include <mamba.h>
 #include <mmb_tile.h>
 #include <mmb_tile_iterator.h>
-#include <memory/mmb_memory.h>
+#include <mmb_memory.h>
 #include <mmb_logging.h>
-#include "tile_duplicate_cuda.h"
 
-mmbError init_matrix_buffer(mmbArray *mba_a);
-mmbError write_to_tile(mmbArrayTile *tile);
-mmbError check_result(mmbArray *mba);
+static mmbError init_matrix_buffer(mmbArray *mba_a);
+static mmbError check_result(mmbArray *mba);
+
+/* Wrapper to cuda kernel */
+extern mmbError write_to_tile_cuda(mmbArrayTile *tile, bool verbose);
 
 int main(int argc, char *const argv[])
 {
@@ -153,7 +154,7 @@ BAILOUT:
 }
 
 
-mmbError init_matrix_buffer(mmbArray *mba_a)
+static mmbError init_matrix_buffer(mmbArray *mba_a)
 {
   // Tile array with single tile and initialise to 0
   mmbError stat = mmb_array_tile(mba_a, mba_a->dims);
@@ -181,20 +182,7 @@ BAILOUT:
   return stat;
 }
 
-mmbError write_to_tile(mmbArrayTile *tile) 
-{
-  // Pick up the tile  from the allocated metadata
-  mmbArrayTile *dev_tile;
-  mmb_tile_get_space_local_handle(tile, &dev_tile);
-  // Fill array tile with 1's
-  for (size_t i = dev_tile->lower[0]; i < dev_tile->upper[0] ;++i) {
-    MMB_IDX_1D(dev_tile, i, float) = 1.f;
-  }
-  return MMB_OK;
-}
-
-
-mmbError check_result(mmbArray *mba)
+static mmbError check_result(mmbArray *mba)
 {
   // Check array is full of 1's
   mmbError stat = mmb_array_tile(mba, mba->dims);
diff --git a/deps/mamba/examples/tile_duplicate_cuda.h b/deps/mamba/examples/tile_duplicate_cuda.h
deleted file mode 100644
index 3d00232a422896b1fb6534a8e9b4f929fc497ea2..0000000000000000000000000000000000000000
--- a/deps/mamba/examples/tile_duplicate_cuda.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2018-2020 Cray UK
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * 3. Neither the name of the copyright holder nor the names of its
- *    contributors may be used to endorse or promote products derived from
- *    this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
- * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef TILE_DUPLICATE_CUDA_H
-#define TILE_DUPLICATE_CUDA_H
-
-#include <mamba.h>
-#include <mmb_memory.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Wrapper to cuda kernel */
-extern mmbError write_to_tile_cuda(mmbArrayTile *tile, bool verbose);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* TILE_DUPLICATE_CUDA_H */
diff --git a/deps/mamba/examples/tile_duplicate_cuda_ker.cu b/deps/mamba/examples/tile_duplicate_cuda_ker.cu
index ab1525b8e842ee6b089ac51171ad4bbb3e65e30b..d2b64d71e524ec87f75056fc1aedf430c28f5e17 100644
--- a/deps/mamba/examples/tile_duplicate_cuda_ker.cu
+++ b/deps/mamba/examples/tile_duplicate_cuda_ker.cu
@@ -33,7 +33,6 @@
 #include <cstdio>
 #include <mamba.h>
 #include <mmb_logging.h>
-#include "tile_duplicate_cuda.h"
 
 __global__
 void write_to_tile_cuda_ker(mmbArrayTile *tile)
@@ -47,7 +46,7 @@ void write_to_tile_cuda_ker(mmbArrayTile *tile)
 }
 
 
-mmbError write_to_tile_cuda(mmbArrayTile *tile, bool verbose)
+extern "C" mmbError write_to_tile_cuda(mmbArrayTile *tile, bool verbose)
 {
   mmbError err = MMB_OK;
   /* Compute dimensions of the block grid and number of workers. */
diff --git a/deps/mamba/loop_analysis/Makefile.am b/deps/mamba/loop_analysis/Makefile.am
index 5591ba774757d3e3dc89603c3693ee0b7be4b310..3c874a718442b9578c3556a98dab954c27aa5b41 100644
--- a/deps/mamba/loop_analysis/Makefile.am
+++ b/deps/mamba/loop_analysis/Makefile.am
@@ -41,7 +41,7 @@ libmmb_loop_la_SOURCES +=  mmb_loop.c            \
 
 loop_SUBDIRS = loopanalyzer
 
-libmmb_loop_la_CFLAGS = -I$(top_srcdir)/common $(LOOP_ANALYSIS_CFLAGS)
+libmmb_loop_la_CPPFLAGS = -I$(top_srcdir)/common $(LOOP_ANALYSIS_CPPFLAGS)
 libmmb_loop_la_LIBADD = $(top_builddir)/loop_analysis/loopanalyzer/liblan.la
 endif
 
diff --git a/deps/mamba/loop_analysis/mmb_array_to_isl_id.h b/deps/mamba/loop_analysis/mmb_array_to_isl_id.h
index df81c44cc4ad8cc9671c499bbef9417755abd9af..83830c8c1569af95d23837eec397c6cb0e52063e 100644
--- a/deps/mamba/loop_analysis/mmb_array_to_isl_id.h
+++ b/deps/mamba/loop_analysis/mmb_array_to_isl_id.h
@@ -35,8 +35,8 @@
 #include <isl/id_type.h>
 #include <isl/maybe_id.h>
 
-#include "mmb_error.h"
-#include "mmb_logging.h"
+#include "../common/mmb_error.h"
+#include "../common/mmb_logging.h"
 
 typedef enum mmbDataRefType {
   MMB_DATA_REF_UNDEFINED,
@@ -89,4 +89,4 @@ uint32_t mmbDataRef_get_hash(mmbDataRef *ar);
 #undef ISL_TYPE
 
 
-#endif
\ No newline at end of file
+#endif
diff --git a/deps/mamba/loop_analysis/mmb_expr.h b/deps/mamba/loop_analysis/mmb_expr.h
index 774ff33d22aad2fb6001d7809a3db16e6875e5df..9b1fa453b348787fad48875e0bbade520a10c78d 100644
--- a/deps/mamba/loop_analysis/mmb_expr.h
+++ b/deps/mamba/loop_analysis/mmb_expr.h
@@ -37,7 +37,7 @@
 #include "isl/ctx.h"
 #include "isl/id.h"
 
-#include "mmb_error.h"
+#include "../common/mmb_error.h"
 
 typedef enum mmbExprType {
   MMB_EXPR_UNDEFINED = 0,
@@ -125,4 +125,4 @@ mmbError mmb_expr_is_decl(mmbExpr *in_expr, bool* out_result);
 const char* mmb_expr_access_type_to_string(mmbExprAccessType type);
 const char* mmb_expr_op_type_to_string(mmbOpType type);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/deps/mamba/loop_analysis/mmb_loop.h b/deps/mamba/loop_analysis/mmb_loop.h
index 1149b6b68f396af5cadce2a42ade1b5e5d5284e5..20ceb587cf924f8dd5d3f02ed229c28a7919bb90 100644
--- a/deps/mamba/loop_analysis/mmb_loop.h
+++ b/deps/mamba/loop_analysis/mmb_loop.h
@@ -33,8 +33,8 @@
 #ifndef MMB_LOOP_H
 #define MMB_LOOP_H
 
-#include "mmb_logging.h"
-#include "mmb_error.h"
+#include "../common/mmb_logging.h"
+#include "../common/mmb_error.h"
 #include "mmb_expr.h"
 #include "mmb_array_to_isl_id.h"
 
@@ -125,4 +125,4 @@ mmbError mmb_loop_add_access(mmbLoopId *in_loop, mmbDataRef *in_ref,
 mmbError mmb_stmt_destroy(mmbStmt *stmt);
 mmbError mmb_stmt_print(mmbStmt *stmt, int indent);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/deps/mamba/loop_analysis/mmb_to_pet_expr.h b/deps/mamba/loop_analysis/mmb_to_pet_expr.h
index e810cd432e171804430ee267c615462746de7f44..ebf69c2186b82168a9c808f40edb4fb6a7492730 100644
--- a/deps/mamba/loop_analysis/mmb_to_pet_expr.h
+++ b/deps/mamba/loop_analysis/mmb_to_pet_expr.h
@@ -29,11 +29,11 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "mmb_logging.h"
-#include "mmb_error.h"
+#include "../common/mmb_logging.h"
+#include "../common/mmb_error.h"
 #include "mmb_loop.h"
 
 #include "pet/expr.h"
 
 mmbError mmb_expr_to_pet_expr(mmbExpr *mmb_expr, pet_expr** pe_expr);
-mmbError mmb_expr_pet_type_size(mmbExpr *expr, int *type_size);
\ No newline at end of file
+mmbError mmb_expr_pet_type_size(mmbExpr *expr, int *type_size);
diff --git a/deps/mamba/loop_analysis/mmb_to_pet_tree.h b/deps/mamba/loop_analysis/mmb_to_pet_tree.h
index dab57f3bf582c2b4f044a28d049e522065cfe14b..4dffbb1c0369fbf1173deeaed0c440f477a0ddda 100644
--- a/deps/mamba/loop_analysis/mmb_to_pet_tree.h
+++ b/deps/mamba/loop_analysis/mmb_to_pet_tree.h
@@ -29,8 +29,8 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "mmb_logging.h"
-#include "mmb_error.h"
+#include "../common/mmb_logging.h"
+#include "../common/mmb_error.h"
 #include "mmb_loop.h"
 #include "mmb_to_pet_expr.h"
 #include "pet/tree.h"
@@ -40,4 +40,4 @@ mmbError extract_pet_tree_from_stmt(mmbStmt *stmt, pet_tree **tree);
 mmbError extract_pet_tree_from_loop(mmbLoop *loop, pet_tree **tree);
 mmbError extract_pet_tree_from_access_stmt(mmbAccess *access, 
                                             pet_tree **tree);
-mmbError extract_pet_tree_from_loop_stmt(mmbLoop *loop, pet_tree **tree);
\ No newline at end of file
+mmbError extract_pet_tree_from_loop_stmt(mmbLoop *loop, pet_tree **tree);
diff --git a/deps/mamba/mamba.pc.in b/deps/mamba/mamba.pc.in
new file mode 100644
index 0000000000000000000000000000000000000000..70538ecc7b51506bb57cd73ede459c21664232d3
--- /dev/null
+++ b/deps/mamba/mamba.pc.in
@@ -0,0 +1,13 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: mamba
+Description: Managed Abstracted Memory Array library
+URL: https://gitlab.com/cerl/mamba
+Version: @PACKAGE_VERSION@
+Requires.private: @HWLOC_REQUIRES@
+Cflags: -I${includedir} @LOOP_ANALYSIS_CPPFLAGS_INSTALL@
+Libs: -L${libdir} -lmmb
+Libs.private: @HWLOC_LDFLAGS@ @LIBHWLOC@
diff --git a/deps/mamba/memory/Makefile.am b/deps/mamba/memory/Makefile.am
index dc6cc5a3a220e426221a4a109b88665a0f0f0a41..586ee66bfbb4109d765fcbfb40bd259afc666e52 100644
--- a/deps/mamba/memory/Makefile.am
+++ b/deps/mamba/memory/Makefile.am
@@ -29,7 +29,7 @@
 #  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #  */
 
-AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/common @CUDA_CPPFLAGS@ @SICM_CPPFLAGS@ @HWLOC_CPPFLAGS@
+AM_CPPFLAGS = -I$(top_srcdir)/common @CUDA_CPPFLAGS@ @SICM_CPPFLAGS@ @HWLOC_CPPFLAGS@
 AM_CFLAGS = @CUDA_CFLAGS@ @HWLOC_CFLAGS@
 AM_LDFLAGS = @CUDA_LDFLAGS@ @SICM_LDFLAGS@ @HWLOC_LDFLAGS@
 
@@ -38,9 +38,9 @@ noinst_LTLIBRARIES = libmmb-mem.la
 libmmb_mem_la_LIBADD = @CUDA_LIBS@ @LIBSICM@
 
 interface_headers = interface.h         \
-                    interfaces/linux_native.h
+                    providers/linux_native.h
 
-interface_sources = interfaces/linux_native.c
+interface_sources = providers/linux_native.c
 
 strategy_headers = strategy.h           \
                    strategies/apply.h   \
@@ -56,8 +56,8 @@ strategy_sources = strategy.c           \
                    strategies/pooled.c
 
 if WITH_SICM
-    interface_sources += interfaces/sicm.c
-    interface_headers += interfaces/sicm.h
+    interface_sources += providers/sicm.c
+    interface_headers += providers/sicm.h
 endif
 
 if ENABLE_DISCOVERY
@@ -66,19 +66,22 @@ if ENABLE_DISCOVERY
     libmmb_mem_la_LIBADD += @LIBHWLOC@
 endif
 
-include_HEADERS = mmb_memory.h memory_config.h
+oldincludedir = @includedir@/memory
+
+nobase_include_HEADERS = mmb_memory.h
 
 noinst_headers = \
-        i_mmb_memory.h       \
-        mmb_allocation.h     \
+        i_memory.h           \
+        memory_config.h      \
+        allocation.h         \
         $(interface_headers) \
         $(strategy_headers)  \
         $(strategy_iheaders) \
         $(topology_headers)
 
 libmmb_mem_la_SOURCES = \
-        mmb_memory.c         \
-        mmb_allocation.c     \
+        memory.c             \
+        allocation.c         \
         $(interface_sources) \
         $(strategy_sources)  \
         $(topology_sources)  \
diff --git a/deps/mamba/memory/mmb_allocation.c b/deps/mamba/memory/allocation.c
similarity index 99%
rename from deps/mamba/memory/mmb_allocation.c
rename to deps/mamba/memory/allocation.c
index 8d071e944d56dc52ad870aa934f3cf17222bc8a7..b0f0e746e08a8386c30c64bad1654164532aac9c 100644
--- a/deps/mamba/memory/mmb_allocation.c
+++ b/deps/mamba/memory/allocation.c
@@ -36,10 +36,10 @@
 
 #include "mmb_error.h"
 #include "mmb_logging.h"
-
 #include "mmb_memory.h"
-#include "i_mmb_memory.h"
-#include "mmb_allocation.h"
+
+#include "i_memory.h"
+#include "allocation.h"
 
 #define N_ELT_FACTORY 1
 
diff --git a/deps/mamba/memory/mmb_allocation.h b/deps/mamba/memory/allocation.h
similarity index 98%
rename from deps/mamba/memory/mmb_allocation.h
rename to deps/mamba/memory/allocation.h
index 059173a682ae36b5a931353b66eb2043b311070f..c6d32184004ccdd31e50b0c2d5583bc048bfcf8b 100644
--- a/deps/mamba/memory/mmb_allocation.h
+++ b/deps/mamba/memory/allocation.h
@@ -34,7 +34,8 @@
 
 #include <stdlib.h>
 #include <stdbool.h>
-#include "mmb_error.h"
+
+#include "../common/mmb_error.h"
 #include "mmb_memory.h"
 
 /**
diff --git a/deps/mamba/memory/i_mmb_memory.h b/deps/mamba/memory/i_memory.h
similarity index 90%
rename from deps/mamba/memory/i_mmb_memory.h
rename to deps/mamba/memory/i_memory.h
index cee94216dbe37107188ed4fedaa54317271c7fad..32a6155c1673ce3fa58ffc519e822164a6f07119 100644
--- a/deps/mamba/memory/i_mmb_memory.h
+++ b/deps/mamba/memory/i_memory.h
@@ -34,12 +34,13 @@
 
 #include <stdlib.h>
 #include <stdbool.h>
+#include <string.h>
 
 #if ENABLE_DISCOVERY
 #include <hwloc.h>
 #endif /* ENABLE_DISCOVERY */
 
-#include "mmb_error.h"
+#include "../common/mmb_error.h"
 #include "mmb_memory.h"
 #include "memory_config.h"
 
@@ -56,7 +57,7 @@
  * @{ */
 
 struct mmbMemInterface {
-  mmbMemInterfaceType type;
+  mmbProvider   provider;
   mmbStrategy   strategy;
   struct mmbMemSpace *space;
   unsigned char data[];
@@ -89,18 +90,19 @@ mmbError mmb_meminterface_check_params(const mmbMemInterface *interface);
 struct mmbMemSpace {
   mmbMemLayer   layer;
   mmbExecutionContext ex_context;
-  mmbMemInterfaceType default_interface;
+  mmbProvider   default_provider;
   mmbStrategy   default_strategy;
   size_t        max_bytes;
-  size_t        n_interfaces;
-  struct mmbMemInterface *interfaces[MMB_MAX_INTERFACES];
+  size_t        num_interfaces;
+  size_t        max_interfaces;
+  struct mmbMemInterface **interfaces;
   bool          allocated;
   size_t        allocated_bytes;
 };
 
 mmbError mmb_memspace_create(const mmbMemLayer layer, const size_t max_mbytes,
                              const mmbExecutionContext ex_context,
-                             const mmbMemInterfaceType default_interface,
+                             const mmbProvider default_provider,
                              const mmbStrategy default_strat,
                              mmbMemSpace **out_space);
 mmbError mmb_memspace_destroy(mmbMemSpace *space);
@@ -118,8 +120,9 @@ mmbError mmb_memspace_destroy(mmbMemSpace *space);
  * @{ */
 
 struct mmbManager {
-  struct mmbMemSpace *spaces[MMB_MAX_SPACES];
   size_t num_spaces;
+  size_t max_spaces;
+  struct mmbMemSpace **spaces;
 #if ENABLE_DISCOVERY
   hwloc_topology_t topology;
 #endif /* ENABLE_DISCOVERY */
@@ -186,22 +189,22 @@ mmb_execution_context_get_symbol(const char * execution_context)
   return MMB_EXECUTION_CONTEXT__MAX;
 }
 inline static const char *
-mmb_memory_interface_type_get_string(const mmbMemInterfaceType interface)
+mmb_provider_get_string(const mmbProvider provider)
 {
-  switch (interface) {
+  switch (provider) {
     MMB_CASE_TO_STR(MMB_NATIVE);
     MMB_CASE_TO_STR(MMB_SICM);
     default: return "(invalid)";
   }
 }
-inline static mmbMemInterfaceType
-mmb_memory_interface_type_get_symbol(const char * interface)
+inline static mmbProvider
+mmb_provider_get_symbol(const char * provider)
 {
-  if (NULL != interface) {
-    MMB_CASE_FROM_STR(interface, MMB_NATIVE);
-    MMB_CASE_FROM_STR(interface, MMB_SICM);
+  if (NULL != provider) {
+    MMB_CASE_FROM_STR(provider, MMB_NATIVE);
+    MMB_CASE_FROM_STR(provider, MMB_SICM);
   }
-  return MMB_MEMINTERFACE_TYPE__MAX;
+  return MMB_PROVIDER__MAX;
 }
 inline static const char *
 mmb_strategy_get_string(const mmbStrategy strategy)
diff --git a/deps/mamba/memory/interface.h b/deps/mamba/memory/interface.h
index 44aec075ef2af9145e1e403ee109a8096def4ea8..997ed4b7482c389daee69cdbdc9a7157270f26dc 100644
--- a/deps/mamba/memory/interface.h
+++ b/deps/mamba/memory/interface.h
@@ -34,8 +34,9 @@
 
 #include <stdlib.h>
 #include <stdbool.h>
+
 #include "mmb_memory.h"
-#include "i_mmb_memory.h"
+#include "i_memory.h"
 
 /**
  * @name mmb_memory
@@ -48,13 +49,13 @@
 /**
  * @brief The dispatch table entry.
  *
- * Every memory interface needs to implement this set on function to provide a
+ * Every memory provider needs to implement this set on function to provide a
  * working memory interface.
  */
-struct mmb_dispatch_interface_entry {
+struct mmb_dispatch_provider_entry {
   const char *name; /**< printable name */
-  /** the function checking whether one \c mmbInterfaceType is suitable for
-   * this interface. */
+  /** the function checking whether one \c mmbProvider is suitable for
+   * this \c mmbLayer. */
   mmbError (*supports)(const mmbMemLayer layer, bool *is_supported);
   /** the function implementing mmb_meminterface_init for the backend */
   mmbError(*init)(mmbMemInterface *interface);
@@ -78,15 +79,15 @@ struct mmb_dispatch_interface_entry {
 /**
  * @brief Create a new mmbMemInterface handle and return a pointer to it.
  *
- * @param [in] type Enumerate value, different from
- *                  \c MMB_DEFAULT_MEMINTERFACE.
+ * @param [in] provider Enumerate value, different from
+ *                      \c MMB_DEFAULT_PROVIDER.
  * @param [in] strategy Enumarate value, different from
  *                      \c MMB_DEFAULT_STRATEGY.
  * @param [out] out_interface An handle to the allocated interface structure.
  *
  * @return \c MMB_OK on success, an error type otherwise.
  */
-mmbError mmb_meminterface_create(const mmbMemInterfaceType type,
+mmbError mmb_meminterface_create(const mmbProvider provider,
                                  const mmbStrategy strategy,
                                  mmbMemInterface **out_interface);
 
@@ -101,7 +102,7 @@ mmbError mmb_meminterface_create(const mmbMemInterfaceType type,
 mmbError mmb_meminterface_destroy(mmbMemInterface *interface);
 
 /**
- * @brief Initialize the strategies and memory interface used by this
+ * @brief Initialize the strategies and memory provider used by this
  *        mmbInterface.
  *
  * @param [in] interface An handle allocated with \p mmb_meminterface_create.
@@ -112,7 +113,7 @@ mmbError mmb_meminterface_init(mmbMemInterface *interface);
 
 /**
  * @brief Finalize the data specificaly used for the strategies and the memory
- *        interface of the \p interface mmbInterface.
+ *        provider of the \p interface mmbInterface.
  *
  * @param [in] interface An handle allocated with \p mmb_meminterface_create.
  *
diff --git a/deps/mamba/memory/mmb_memory.c b/deps/mamba/memory/memory.c
similarity index 75%
rename from deps/mamba/memory/mmb_memory.c
rename to deps/mamba/memory/memory.c
index d0a3ff150ab80a3b474983ea0b99f6b96caf926a..b650bc80778cfa7677436ebc4e978420406cf5c8 100644
--- a/deps/mamba/memory/mmb_memory.c
+++ b/deps/mamba/memory/memory.c
@@ -34,10 +34,10 @@
 #include <stdbool.h>
 #include <inttypes.h>
 
-#include "mmb_memory.h"
 #include "mmb_logging.h"
+#include "mmb_memory.h"
 
-#include "i_mmb_memory.h"
+#include "i_memory.h"
 #include "memory_config.h"
 
 #if ENABLE_DISCOVERY
@@ -45,7 +45,7 @@
 #endif /* ENABLE_DISCOVERY */
 
 #include "interface.h"
-#include "mmb_allocation.h"
+#include "allocation.h"
 
 #include "strategy.h"
 #include "strategies/basic.h"
@@ -73,8 +73,8 @@ mmb_strategies_table[MMB_STRATEGY__MAX] = {
 
 /* Possibly modifiable at configure/compile time and at runtime with
  * environment variables. */
-static mmbMemInterfaceType
-GLOBAL_DEFAULT_INTERFACE            = MMB_CONFIG_DEFAULT_INTERFACE;
+static mmbProvider
+GLOBAL_DEFAULT_PROVIDER             = MMB_CONFIG_DEFAULT_PROVIDER;
 static mmbStrategy
 GLOBAL_DEFAULT_STRATEGY             = MMB_CONFIG_DEFAULT_STRATEGY;
 static mmbExecutionContext
@@ -115,52 +115,53 @@ check_and_set_mmbstrategy(const mmbStrategy in_strat,
       break;
     case MMB_THREAD_SAFE:
     case MMB_LIMITED_GREEDY:
-      WARN("This strategy is not yet available.\n");
+      WARN("This strategy (%s) is not yet available.\n",
+           mmb_strategy_get_string(in_strat));
       status = MMB_UNIMPLEMENTED;
       break;
     default:
-      ERR("Invalid strategy requested.\n");
+      ERR("Invalid strategy requested (%d).\n", in_strat);
       status = MMB_INVALID_STRATEGY;
   }
   return status;
 }
 
 /**
- * @brief Translate the \p in_type to a value that can be used by the strategy
- *        building blocks.
+ * @brief Translate the \p in_provider to a value that can be used by the
+ *        strategy building blocks.
  *
- * @param [in] in_type Requested interface (can be \c MMB_DEFAULT_MEMINTERFACE).
- * @param [in] default_type The value to assign \p out_type if \p in_type
- *                          equals \c MMB_DEFAULT_MEMINTERFACE).
- * @param [out] out_type The proper interface value (cannot be
- *                       \c MMB_DEFAULT_MEMINTERFACE).
+ * @param [in] in_provider Requested provider (can be \c MMB_DEFAULT_PROVIDER).
+ * @param [in] default_provider The value to assign \p out_provider if
+ *                              \p in_provider equals \c MMB_DEFAULT_PROVIDER).
+ * @param [out] out_provider The proper provider value (cannot be
+ *                           \c MMB_DEFAULT_PROVIDER).
  *
  * @return \c MMB_OK on success, an error type otherwise.
  */
 static mmbError
-check_and_set_mmbmeminterfacetype(const mmbMemInterfaceType in_type,
-                                  const mmbMemInterfaceType default_type,
-                                  mmbMemInterfaceType *out_type)
+check_and_set_mmbprovider(const mmbProvider in_provider,
+                          const mmbProvider default_provider,
+                          mmbProvider *out_provider)
 {
   mmbError status = MMB_OK;
 
   /* Check parameters */
-  if (NULL == out_type) {
+  if (NULL == out_provider) {
     ERR("Out parameter cannot be NULL.\n");
     return MMB_INVALID_ARG;
   }
 
-  switch (in_type) {
-    case MMB_DEFAULT_MEMINTERFACE:
-      *out_type = default_type;
+  switch (in_provider) {
+    case MMB_DEFAULT_PROVIDER:
+      *out_provider = default_provider;
       break;
     case MMB_NATIVE:
     case MMB_SICM:
-      *out_type = in_type;
+      *out_provider = in_provider;
       break;
     default:
-      ERR("Invalid memory interface type requested.\n");
-      status = MMB_INVALID_INTERFACE_TYPE;
+      ERR("Invalid memory provider requested (%d).\n", in_provider);
+      status = MMB_INVALID_PROVIDER;
   }
   return status;
 }
@@ -170,7 +171,7 @@ check_and_set_mmbmeminterfacetype(const mmbMemInterfaceType in_type,
  *
  * @param [in] in_ex_con Requested strategy (can be
  *                       \c MMB_DEFAULT_EXECUTION_CONTEXT).
- * @param [in] default_ex_con The value to assign \p out_type if \p in_ex_con
+ * @param [in] default_ex_con The value to assign \p out_ex_con if \p in_ex_con
  *                            equals \c MMB_DEFAULT_EXECUTION_CONTEXT).
  * @param [out] out_ex_con The proper strategy value (cannot be
  *                         \c MMB_DEFAULT_EXCUTION_CONTEXT).
@@ -204,18 +205,19 @@ check_and_set_mmbexecutioncontext(const mmbExecutionContext in_ex_con,
       *out_ex_con = in_ex_con;
       break;
     case MMB_GPU_OPENCL:
-      WARN("This execution context is not yet available.\n");
+      WARN("This execution context \"%s\" is not yet available.\n",
+           mmb_execution_context_get_string(in_ex_con));
       status = MMB_UNIMPLEMENTED;
       break;
     default:
-      ERR("Invalid execution context requested.\n");
+      ERR("Invalid execution context requested (%d).\n", in_ex_con);
       status = MMB_INVALID_EXECUTION_CONTEXT;
   }
   return status;
 }
 
 mmbError mmb_allocation_create_wrapped(void* in_ptr, const size_t n_bytes,
-                                       mmbMemSpace *in_space,
+                                       mmbMemSpace *space,
                                        mmbAllocation **out_allocation)
 {
   mmbError stat = MMB_OK;
@@ -228,10 +230,10 @@ mmbError mmb_allocation_create_wrapped(void* in_ptr, const size_t n_bytes,
   mmbMemInterface *interface;
   /* TODO: deal with the "pointer-given" case */
   mmbStrategy strategy = MMB_NO_STRAT;
-  mmbMemInterfaceType type = GLOBAL_DEFAULT_INTERFACE;
-  stat = mmb_memspace_request_interface(in_space, type, strategy, &interface);
+  mmbProvider provider = GLOBAL_DEFAULT_PROVIDER;
+  stat = mmb_memspace_request_interface(space, provider, strategy, &interface);
   if (MMB_OK != stat) {
-    WARN("Impossible to find suitable interface.\n");
+    WARN("Unable to find suitable interface.\n");
     goto BAILOUT;
   }
 
@@ -261,7 +263,7 @@ mmbError mmb_allocation_destroy(mmbAllocation *in_allocation)
 
 mmbError mmb_memspace_create(const mmbMemLayer layer, const size_t max_bytes,
                              const mmbExecutionContext ex_context, 
-                             const mmbMemInterfaceType default_interface_type,
+                             const mmbProvider default_provider,
                              const mmbStrategy default_strat,
                              mmbMemSpace **out_space)
 {
@@ -273,7 +275,7 @@ mmbError mmb_memspace_create(const mmbMemLayer layer, const size_t max_bytes,
     return MMB_INVALID_ARG;
   }
   if (MMB_MEMLAYER__MAX <= layer) {
-    ERR("Invalid layer requested.\n");
+    ERR("Invalid layer requested (%d).\n", layer);
     stat = MMB_INVALID_LAYER;
     goto BAILOUT;
   }
@@ -282,8 +284,8 @@ mmbError mmb_memspace_create(const mmbMemLayer layer, const size_t max_bytes,
   if (MMB_OK != stat) {
     goto BAILOUT;
   }
-  mmbMemInterfaceType type = GLOBAL_DEFAULT_INTERFACE;
-  stat = check_and_set_mmbmeminterfacetype(default_interface_type, type, &type);
+  mmbProvider provider = GLOBAL_DEFAULT_PROVIDER;
+  stat = check_and_set_mmbprovider(default_provider, provider, &provider);
   if (MMB_OK != stat) {
     goto BAILOUT;
   }
@@ -294,17 +296,18 @@ mmbError mmb_memspace_create(const mmbMemLayer layer, const size_t max_bytes,
     goto BAILOUT;
   }
 
-  /* Check the requested interface can provide support
+  /* Check whether the requested provider can provide support
    * for the requested layer */
   /* TODO: This should also check support for requested execution context */
-  bool check_interface;
-  stat = mmb_interface_compatibility_check(type, layer, ex_con, &check_interface);
+  bool check_provider;
+  stat = mmb_provider_compatibility_check(provider, layer, ex_con, &check_provider);
   if (MMB_OK != stat) {
     goto BAILOUT;
-  } else if (false == check_interface) {
-    stat = MMB_INVALID_INTERFACE;
-    WARN("The requested interface (%s) cannot provide support for the requested "
-         "memory layer (%s).\n", mmb_memory_interface_type_get_string(type),
+  } else if (false == check_provider) {
+    stat = MMB_INVALID_PROVIDER;
+    WARN("The requested provider (%s) cannot provide support for the requested "
+         "memory layer (%s) with the required execution context (%s).\n",
+         mmb_provider_get_string(provider), mmb_layer_get_string(layer),
          mmb_execution_context_get_string(ex_con));
     goto BAILOUT;
   }
@@ -313,35 +316,44 @@ mmbError mmb_memspace_create(const mmbMemLayer layer, const size_t max_bytes,
    * e.g. to set default interface (at compile time) */
   mmbMemSpace *s = calloc (1, sizeof(mmbMemSpace));
   if (s == NULL) {
-    ERR("Failed to allocate memory space\n");
+    ERR("Failed to allocate memory space.\n");
+    stat = MMB_OUT_OF_MEMORY;
+    goto BAILOUT;
+  }
+  mmbMemInterface **interfaces = calloc(MMB_MAX_INTERFACES, sizeof *interfaces);
+  if (NULL == interfaces) {
+    ERR("Failed to allocate the array of interfaces.\n");
     stat = MMB_OUT_OF_MEMORY;
+    free(s);
     goto BAILOUT;
   }
+  s->interfaces = interfaces;
+  s->max_interfaces = MMB_MAX_INTERFACES;
   s->layer = layer;
   s->default_strategy = strategy;
-  s->default_interface = type;
+  s->default_provider = provider;
   s->max_bytes = max_bytes;
   s->ex_context = ex_con;
 
   /* Create default interface */
   mmbMemInterface *interface;
-  stat = mmb_meminterface_create(type, s->default_strategy, &interface);
+  stat = mmb_meminterface_create(provider, s->default_strategy, &interface);
   if (MMB_OK != stat) {
-    ERR("Failed to allocate memory interface\n");
+    ERR("Failed to allocate memory interface.\n");
     free(s);
     goto BAILOUT;
   }
   interface->space = s;
   stat = mmb_meminterface_init(interface);
   if (stat != MMB_OK) {
-    ERR("Failed to initialise memory interface\n");
+    ERR("Failed to initialise memory interface.\n");
     mmb_meminterface_destroy(interface);
     free(s);
     goto BAILOUT;
   }
 
-  /* TODO: Replace this with hashmap on interface type */
-  s->interfaces[s->n_interfaces++] = interface;
+  /* TODO: Replace this with hashmap on memory provider */
+  s->interfaces[s->num_interfaces++] = interface;
 
   *out_space = s;
 BAILOUT:
@@ -352,30 +364,29 @@ mmbError mmb_memspace_destroy(mmbMemSpace *space) {
   mmbError stat = MMB_OK;
   /* Check parameter */
   if (NULL == space) {
-    WARN("Invalid space.\n");
+    WARN("Invalid space (cannot be NULL).\n");
     return MMB_INVALID_ARG;
   }
-  if (space->n_interfaces > 0) {
-    for (unsigned i = 0; i < space->n_interfaces; i++) {
-      stat = mmb_meminterface_finalize(space->interfaces[i]);
-      if (MMB_OK != stat) {
-        WARN("Failed to finalize memory interface.\n");
-        goto BAILOUT;
-      }
-      stat = mmb_meminterface_destroy(space->interfaces[i]);
-      if (stat != MMB_OK) {
-        WARN("Failed to destroy memory interface\n");
-        goto BAILOUT;
-      }
+  for (unsigned i = 0; i < space->num_interfaces; i++) {
+    stat = mmb_meminterface_finalize(space->interfaces[i]);
+    if (MMB_OK != stat) {
+      WARN("Failed to finalize memory interface.\n");
+      goto BAILOUT;
+    }
+    stat = mmb_meminterface_destroy(space->interfaces[i]);
+    if (stat != MMB_OK) {
+      WARN("Failed to destroy memory interface.\n");
+      goto BAILOUT;
     }
   }
+  free(space->interfaces);
   free(space);
 BAILOUT:
   return stat;
 }
 
 mmbError mmb_memspace_request_interface(mmbMemSpace *space,
-                                        const mmbMemInterfaceType in_type,
+                                        const mmbProvider in_provider,
                                         const mmbStrategy in_strategy,
                                         mmbMemInterface **out_interface)
 {
@@ -384,7 +395,7 @@ mmbError mmb_memspace_request_interface(mmbMemSpace *space,
 
   /* check parameters */
   if (NULL == space) {
-    ERR("Invalid space.\n");
+    ERR("Invalid space (cannot be NULL).\n");
     return MMB_INVALID_ARG;
   }
   if (NULL == out_interface) {
@@ -396,34 +407,36 @@ mmbError mmb_memspace_request_interface(mmbMemSpace *space,
   if (MMB_OK != stat) {
     return stat;
   }
-  mmbMemInterfaceType type;
-  stat = check_and_set_mmbmeminterfacetype(in_type, space->default_interface, &type);
+  mmbProvider provider = space->default_provider;
+  stat = check_and_set_mmbprovider(in_provider, provider, &provider);
   if (MMB_OK != stat) {
     return stat;
   }
 
   /* Lookup to be replaced with a hashmap research */
-  for (size_t i = 0; i < space->n_interfaces; ++i) {
+  for (size_t i = 0; i < space->num_interfaces; ++i) {
     interface = space->interfaces[i];
-    if (strat == interface->strategy && in_type == interface->type) {
+    if (NULL != interface) {
+      if (strat == interface->strategy && in_provider == interface->provider) {
         goto end;
+      }
     }
   }
 
-  /* No suitable interface found. Try to create a new one */
-  if (MMB_MAX_INTERFACES <= space->n_interfaces + 1) {
-    /**
-     * For now, it stays as an error. Maybe it could be changed later for:
-     *      - a realloc of the array of interfaces
-     *      - finding another space with the same characteristics but an open
-     *        slot for an interface
-     *      - returning the error all the way to the user so the user chose the
-     *        new space he wants to use for it.
-     */
-    ERR("No slot available for any extra interface.\n");
-    return MMB_ERROR;
-  }
-  stat = mmb_meminterface_create(type, strat, &interface);
+  /* No suitable provider found. Try to create a new one */
+  if (space->num_interfaces == space->max_interfaces) {
+    size_t max_interfaces = space->max_interfaces + MMB_MAX_INTERFACES;
+    size_t realloc_size = sizeof(mmbMemInterface *[max_interfaces]);
+    mmbMemInterface **interfaces = realloc(space->interfaces, realloc_size);
+    if (NULL == interfaces) {
+      ERR("No slot available for any extra interface and "
+          "the reallocation failed.\n");
+      return MMB_OUT_OF_MEMORY;
+    }
+    space->max_interfaces = max_interfaces;
+    space->interfaces = interfaces;
+  }
+  stat = mmb_meminterface_create(provider, strat, &interface);
   if (MMB_OK != stat) {
     return stat;
   }
@@ -432,7 +445,7 @@ mmbError mmb_memspace_request_interface(mmbMemSpace *space,
   if (MMB_OK != stat) {
     return stat;
   }
-  space->interfaces[space->n_interfaces++] = interface;
+  space->interfaces[space->num_interfaces++] = interface;
 
 end:
   *out_interface = interface;
@@ -440,7 +453,7 @@ end:
   return stat;
 }
 
-mmbError mmb_meminterface_create(const mmbMemInterfaceType type,
+mmbError mmb_meminterface_create(const mmbProvider provider,
                                  const mmbStrategy strategy,
                                  mmbMemInterface **out_interface)
 {
@@ -453,20 +466,21 @@ mmbError mmb_meminterface_create(const mmbMemInterfaceType type,
   }
 
   size_t alloc_size_data;
-  stat = mmb_strat_get_data_size(type, strategy, &alloc_size_data);
+  stat = mmb_strat_get_data_size(provider, strategy, &alloc_size_data);
   if (MMB_OK != stat) {
     return stat;
   }
 
-  mmbMemInterface *tface = malloc(alloc_size_data + sizeof(mmbMemInterface));
-  if (tface == NULL) {
+  mmbMemInterface *interface;
+  interface = malloc(alloc_size_data + sizeof(mmbMemInterface));
+  if (interface == NULL) {
     ERR("Error, failed to allocate new memory space!\n");
     return MMB_OUT_OF_MEMORY;
   }
 
-  tface->type = type;
-  tface->strategy = strategy;
-  *out_interface = tface;
+  interface->provider = provider;
+  interface->strategy = strategy;
+  *out_interface = interface;
 
   return stat;
 }
@@ -511,10 +525,10 @@ mmbError mmb_meminterface_finalize(mmbMemInterface *interface)
 mmbError mmb_meminterface_check_params(const mmbMemInterface *interface)
 {
   if (NULL == interface) {
-    WARN("Invalid interface.\n");
+    WARN("Invalid interface (cannot be NULL).\n");
     return MMB_INVALID_ARG;
   } else if (NULL == interface->space) {
-    WARN("Invalid space handle in given interface.\n");
+    WARN("Invalid space handle in given interface (cannot be NULL).\n");
     return MMB_INVALID_ARG;
   }
   return MMB_OK;
@@ -579,7 +593,7 @@ mmbError mmb_free(mmbAllocation *allocation)
   /* Check parameters */
   stat = mmb_alloc_check_params(allocation);
   if (MMB_OK != stat) {
-    ERR("Failed mmb_alloc_check_params\n");
+    ERR("Failed mmb_alloc_check_params.\n");
     return stat;
   }
 
@@ -591,13 +605,13 @@ mmbError mmb_free(mmbAllocation *allocation)
   stat = mmb_strategies_table[allocation->interface->strategy]
           .free(allocation);
   if (MMB_OK != stat) {
-    ERR("Failed strategy free on allocation\n");
+    ERR("Failed strategy free on allocation.\n");
     return stat;
   }
 
   stat = mmb_alloc_free(allocation);
   if (MMB_OK != stat) {
-    ERR("Failed mmb_alloc_free on allocation\n");
+    ERR("Failed mmb_alloc_free on allocation.\n");
     return stat;
   }
   return stat;
@@ -691,8 +705,8 @@ mmbError mmb_allocation_get_execution_context(const mmbAllocation *alloc,
   return stat;
 }
 
-mmbError mmb_allocation_get_interface_type(const mmbAllocation *alloc,
-                                           mmbMemInterfaceType *interface)
+mmbError mmb_allocation_get_provider(const mmbAllocation *alloc,
+                                           mmbProvider *provider)
 {
   mmbError stat = MMB_OK;
   /* Check parameters */
@@ -700,7 +714,7 @@ mmbError mmb_allocation_get_interface_type(const mmbAllocation *alloc,
   if (MMB_OK != stat) {
     return stat;
   }
-  *interface = alloc->interface->type;
+  *provider = alloc->interface->provider;
   return stat;
 }
 
@@ -763,27 +777,25 @@ static mmbError mmb_manager_initialize(mmbManager *mngr)
 #endif /* ENABLE_DISCOVERY */
 
   /* Check the validity of compile defined GLOBAL_DEFAULT variables */
-  const char *global_default_interface_env = "MMB_CONFIG_DEFAULT_INTERFACE_TYPE";
-  const char *global_default_interface_str = getenv(global_default_interface_env);
-  if (NULL != global_default_interface_str) {
-    GLOBAL_DEFAULT_INTERFACE =
-      mmb_memory_interface_type_get_symbol(global_default_interface_str);
+  const char *global_default_provider_env = MMB_ENV_DEFAULT_PROVIDER_NAME;
+  const char *global_default_provider_str = getenv(global_default_provider_env);
+  if (NULL != global_default_provider_str) {
+    GLOBAL_DEFAULT_PROVIDER = mmb_provider_get_symbol(global_default_provider_str);
   } else {
-    global_default_interface_str =
-      mmb_memory_interface_type_get_string(GLOBAL_DEFAULT_INTERFACE);
+    global_default_provider_str = mmb_provider_get_string(GLOBAL_DEFAULT_PROVIDER);
   }
-  switch (GLOBAL_DEFAULT_INTERFACE) {
+  switch (GLOBAL_DEFAULT_PROVIDER) {
     case MMB_NATIVE:
     case MMB_SICM:
       break;
     default:
-      ERR("Default memory interface misconfigured (%s). Please rebuild the "
+      ERR("Default memory provider misconfigured (%s). Please rebuild the "
           "library with another value or set environment variable %s.\n",
-          global_default_interface_str, global_default_interface_env);
+          global_default_provider_str, global_default_provider_env);
       stat = MMB_ERROR;
       goto BAILOUT;
   }
-  const char *global_default_strategy_env = "MMB_CONFIG_DEFAULT_STRATEGY";
+  const char *global_default_strategy_env = MMB_ENV_DEFAULT_STRATEGY_NAME;
   const char *global_default_strategy_str = getenv(global_default_strategy_env);
   if (NULL != global_default_strategy_str) {
     GLOBAL_DEFAULT_STRATEGY = mmb_strategy_get_symbol(global_default_strategy_str);
@@ -796,7 +808,8 @@ static mmbError mmb_manager_initialize(mmbManager *mngr)
       break;
     case MMB_THREAD_SAFE:
     case MMB_LIMITED_GREEDY:
-      WARN("This strategy is not yet available.\n");
+      WARN("This strategy (%s) is not yet available.\n",
+           mmb_strategy_get_string(GLOBAL_DEFAULT_STRATEGY));
       /* FALLTHROUGH */
     default:
       ERR("Default strategy misconfigured (%s). Please rebuild the "
@@ -805,8 +818,7 @@ static mmbError mmb_manager_initialize(mmbManager *mngr)
       stat = MMB_ERROR;
       goto BAILOUT;
   }
-  const char *global_default_ex_con_env =
-    "MMB_CONFIG_DEFAULT_GPU_EXECUTION_CONTEXT";
+  const char *global_default_ex_con_env = MMB_ENV_DEFAULT_GPU_CONTEXT_NAME;
   const char *global_default_ex_con_str = getenv(global_default_ex_con_env);
   if (NULL != global_default_ex_con_str) {
     GLOBAL_DEFAULT_EXECUTION_CONTEXT[1] =
@@ -821,7 +833,8 @@ static mmbError mmb_manager_initialize(mmbManager *mngr)
     case MMB_NO_EXECUTION_CONTEXT:
       break;
     case MMB_GPU_OPENCL:
-      WARN("This execution context is not yet available.\n");
+      WARN("This execution (%s) context is not yet available.\n",
+           mmb_execution_context_get_string(GLOBAL_DEFAULT_EXECUTION_CONTEXT[1]));
       /* FALLTHROUGH */
     default:
       ERR("Invalid default execution context requested for GPUs (%s). Please "
@@ -848,7 +861,7 @@ mmbError mmb_manager_create(mmbManager **out_mngr)
 
   mmbManager *mngr = calloc(1, sizeof(mmbManager));
   if (NULL == mngr) {
-    ERR("Error, malloc of manager failed\n");
+    ERR("Error, malloc of manager failed.\n");
     stat = MMB_OUT_OF_MEMORY;
     goto BAILOUT;
   }
@@ -870,7 +883,7 @@ mmbError mmb_manager_destroy(mmbManager *mngr)
 
   /* Check parameters */
   if (NULL == mngr) {
-    WARN("Invalid manager handle.\n");
+    WARN("Invalid manager handle (cannot be NULL).\n");
     stat = MMB_INVALID_ARG;
     goto BAILOUT;
   }
@@ -880,11 +893,12 @@ mmbError mmb_manager_destroy(mmbManager *mngr)
     for (size_t i = 0; i < mngr->num_spaces ; i++) {
       stat =  mmb_memspace_destroy(mngr->spaces[i]);
       if (stat != MMB_OK) {
-        WARN("Unable to free memory space\n");
+        WARN("Unable to free memory space.\n");
         goto BAILOUT;
       }
     }
   }
+  free(mngr->spaces);
 
 #if ENABLE_DISCOVERY
   mmb_topology_finalize(mngr->topology);
@@ -905,7 +919,7 @@ mmbError mmb_manager_register_memory(mmbManager *mngr, const mmbMemLayer layer,
 
   /* Check parameters */
   if (NULL == mngr) {
-    ERR("Invalid manager provided.\n");
+    ERR("Invalid manager provided (cannot be NULL).\n");
     stat = MMB_INVALID_ARG;
     goto BAILOUT;
   }
@@ -919,32 +933,43 @@ mmbError mmb_manager_register_memory(mmbManager *mngr, const mmbMemLayer layer,
     case MMB_NVDIMM:
       break;
     default:
-      ERR("Only currently supported layers are MMB_DRAM, MMB_GDRAM, MMB_HBM "
-          "and MMB_NVDIMM.\n");
+      ERR("Only currently supported layers are %s, %s, %s and %s.\n",
+           mmb_layer_get_string(MMB_DRAM),
+           mmb_layer_get_string(MMB_GDRAM),
+           mmb_layer_get_string(MMB_HBM),
+           mmb_layer_get_string(MMB_NVDIMM));
       stat = MMB_UNIMPLEMENTED;
       goto BAILOUT;
   }
 
+  /* Extend the number of slots for the spaces if required */
+  if (mngr->num_spaces == mngr->max_spaces) {
+    size_t max_spaces = mngr->max_spaces + MMB_MAX_SPACES;
+    size_t realloc_size = sizeof(mmbMemSpace[max_spaces]);
+    mmbMemSpace **spaces = realloc(mngr->spaces, realloc_size);
+    if (NULL == spaces) {
+      /* Same as missing space for adding a new interface to a space. See
+       * function mmb_memspace_request_interface. */
+      ERR("Error, MAX_SPACES exceeded (%d) and unable to reallocate!\n",
+          mngr->max_spaces);
+      stat = MMB_OUT_OF_MEMORY;
+      goto BAILOUT;
+    }
+    mngr->spaces = spaces;
+    mngr->max_spaces = max_spaces;
+  }
+
   /* TODO: Translate between mmbLayer and mmbMemInterface */
   mmbMemSpace *space;
   stat = mmb_memspace_create(layer, max_bytes, ex_context,
-                             MMB_DEFAULT_MEMINTERFACE,
+                             MMB_DEFAULT_PROVIDER,
                              MMB_DEFAULT_STRATEGY,
                              &space);
   if (stat != MMB_OK) {
     WARN("Error, new memspace creation failed\n");
     goto BAILOUT;
   }
-  if (mngr->num_spaces+1 < MMB_MAX_SPACES) {
-    mngr->spaces[mngr->num_spaces++] = space;
-  } else {
-    /* Same as missing space for adding a new interface to a space. See
-     * function mmb_memspace_request_interface. */
-    ERR("Error, MAX_SPACES exceeded!\n");
-    mmb_memspace_destroy(space);
-    stat = MMB_ERROR;
-    goto BAILOUT;
-  }
+  mngr->spaces[mngr->num_spaces++] = space;
 
   /* Returns newly created handle */
   if (NULL != new_space) {
@@ -963,7 +988,7 @@ mmbError mmb_manager_request_space(mmbManager *mngr, const mmbMemLayer layer,
 
   /* Check parameters */
   if (NULL == mngr) {
-    ERR("Invalid manager handle.\n");
+    ERR("Invalid manager handle (cannot be NULL).\n");
     stat = MMB_ERROR;
     goto BAILOUT;
   }
@@ -973,7 +998,7 @@ mmbError mmb_manager_request_space(mmbManager *mngr, const mmbMemLayer layer,
     goto BAILOUT;
   }
   if (MMB_MEMLAYER__MAX <= layer) {
-    ERR("Invalid layer requested.\n");
+    ERR("Invalid layer requested (%d).\n", layer);
     stat = MMB_INVALID_LAYER;
     goto BAILOUT;
   }
@@ -1006,12 +1031,12 @@ mmbError mmb_manager_report_state(const mmbManager *mngr, FILE *out)
   mmbError stat = MMB_OK;
   /* Check parameters */
   if (NULL == mngr) {
-    ERR("Invalid manager handle parameter.\n");
+    ERR("Invalid manager handle parameter (cannot be NULL).\n");
     stat = MMB_INVALID_ARG;
     goto BAILOUT;
   }
   if (NULL == out) {
-    ERR("Invalid output stream.\n");
+    ERR("Invalid output stream (cannot be NULL).\n");
     stat = MMB_INVALID_ARG;
     goto BAILOUT;
   }
@@ -1029,8 +1054,7 @@ mmbError mmb_manager_report_state(const mmbManager *mngr, FILE *out)
     fprintf(out, "%*s%*s: %s,\n", INDENT, "", LABEL_LEN,
             "exe context", mmb_execution_context_get_string(sp->ex_context));
     fprintf(out, "%*s%*s: %s,\n", INDENT, "", LABEL_LEN,
-            "def. interface",
-            mmb_memory_interface_type_get_string(sp->default_interface));
+            "def. provider", mmb_provider_get_string(sp->default_provider));
     fprintf(out, "%*s%*s: %s,\n", INDENT, "", LABEL_LEN,
             "def. strategy", mmb_strategy_get_string(sp->default_strategy));
     fprintf(out, "%*s%*s: %zu,\n", INDENT, "", LABEL_LEN,
@@ -1039,8 +1063,8 @@ mmbError mmb_manager_report_state(const mmbManager *mngr, FILE *out)
             "allocated bytes", sp->allocated_bytes);
     fprintf(out, "%*s%*s: %zu,\n", INDENT, "", LABEL_LEN,
             "available bytes", sp->max_bytes - sp->allocated_bytes);
-    fprintf(out, "%*s%*s: %zu\n", INDENT, "", LABEL_LEN,
-            "#interfaces", sp->n_interfaces);
+    fprintf(out, "%*s%*s: %zu/%zu\n", INDENT, "", LABEL_LEN,
+            "#interfaces", sp->num_interfaces, sp->max_interfaces);
     fprintf(out, "%*s    }%c", 2, "", mngr->num_spaces - 1 > i ? ',' : '\n');
   }
   fprintf(out, "]\n");
diff --git a/deps/mamba/memory/memory_config.h b/deps/mamba/memory/memory_config.h
index 01b8901cd455a9a8e34785cef179f85f079a69a1..f46ce8dca6eb99d2347f260102f37175fd97910c 100644
--- a/deps/mamba/memory/memory_config.h
+++ b/deps/mamba/memory/memory_config.h
@@ -36,25 +36,39 @@
 #  define MMB_MAX_SPACES 5
 #endif /* MMB_MAX_SPACES */
 
-#ifndef MMB_MAX_ALLOCATIONS
-#  define MMB_MAX_ALLOCATIONS 10
-#endif /* MMB_MAX_ALLOCATIONS */
-
 #ifndef MMB_MAX_INTERFACES
 #  define MMB_MAX_INTERFACES 10
 #endif /* MMB_MAX_INTERFACES */
 
-/* Memory interface configuration */
-#ifndef MMB_CONFIG_DEFAULT_INTERFACE
-#  define MMB_CONFIG_DEFAULT_INTERFACE MMB_NATIVE
-#endif /* MMB_CONFIG_DEFAULT_INTERFACE */
+/*
+ * Memory provider configuration
+ */
+#ifndef MMB_ENV_DEFAULT_PROVIDER_NAME
+#  define MMB_ENV_DEFAULT_PROVIDER_NAME "MMB_CONFIG_DEFAULT_PROVIDER"
+#endif /* MMB_ENV_DEFAULT_PROVIDER_NAME */
+
+#ifndef MMB_CONFIG_DEFAULT_PROVIDER
+#  define MMB_CONFIG_DEFAULT_PROVIDER MMB_NATIVE
+#endif /* MMB_CONFIG_DEFAULT_PROVIDER */
+
+/*
+ * Strategy configuration
+ */
+#ifndef MMB_ENV_DEFAULT_STRATEGY_NAME
+#  define MMB_ENV_DEFAULT_STRATEGY_NAME "MMB_CONFIG_DEFAULT_STRATEGY"
+#endif /* MMB_ENV_DEFAULT_STRATEGY_NAME */
 
-/* Strategy configuration */
 #ifndef MMB_CONFIG_DEFAULT_STRATEGY
 #  define MMB_CONFIG_DEFAULT_STRATEGY MMB_NO_STRAT
 #endif /* MMB_CONFIG_DEFAULT_STRATEGY */
 
-/* GPU execution context configuration */
+/*
+ * GPU execution context configuration
+ */
+#ifndef MMB_ENV_DEFAULT_GPU_CONTEXT_NAME
+#  define MMB_ENV_DEFAULT_GPU_CONTEXT_NAME "MMB_CONFIG_DEFAULT_GPU_EXECUTION_CONTEXT"
+#endif /* MMB_ENV_DEFAULT_GPU_CONTEXT_NAME */
+
 #ifndef MMB_CONFIG_DEFAULT_GPU_CONTEXT
 #  if HAVE_CUDA
 #    define MMB_CONFIG_DEFAULT_GPU_CONTEXT MMB_GPU_CUDA
diff --git a/deps/mamba/memory/mmb_memory.h b/deps/mamba/memory/mmb_memory.h
index 8bfcb2bf4dccb25a346408f492fb50fd32af8bd5..d0254d5a8f6481c7845c6bfa155071c752a230ed 100644
--- a/deps/mamba/memory/mmb_memory.h
+++ b/deps/mamba/memory/mmb_memory.h
@@ -99,12 +99,12 @@ typedef enum mmbStrategy {
  * @name Public API
  * @{ */
 
-typedef enum mmbMemInterfaceType {
-  MMB_DEFAULT_MEMINTERFACE = -1,
+typedef enum mmbProvider {
+  MMB_DEFAULT_PROVIDER = -1,
   MMB_NATIVE,
   MMB_SICM,
-  MMB_MEMINTERFACE_TYPE__MAX
-} mmbMemInterfaceType;
+  MMB_PROVIDER__MAX
+} mmbProvider;
 
 typedef struct mmbMemInterface mmbMemInterface;
 
@@ -145,7 +145,7 @@ typedef enum mmbExecutionContext {
 typedef struct mmbMemSpace mmbMemSpace;
 
 mmbError mmb_memspace_request_interface(mmbMemSpace *space,
-                                        const mmbMemInterfaceType type,
+                                        const mmbProvider provider,
                                         const mmbStrategy strategy,
                                         mmbMemInterface **out_interface);
 
@@ -194,7 +194,7 @@ typedef struct mmbAllocation {
 } mmbAllocation;
 
 mmbError mmb_allocation_create_wrapped(void* in_ptr, const size_t n_bytes,
-                                       mmbMemSpace *in_space,
+                                       mmbMemSpace *space,
                                        mmbAllocation **out_allocation);
 mmbError mmb_allocation_destroy(mmbAllocation *in_allocation);
 
@@ -233,16 +233,16 @@ mmbError mmb_allocation_get_layer(const mmbAllocation *alloc, mmbMemLayer *layer
 mmbError mmb_allocation_get_execution_context(const mmbAllocation *alloc,
                                               mmbExecutionContext *ex_context);
 /**
- * @brief Returns the memory interface type used to allocate the memory for the
- *        given \c mmbAllocation.
+ * @brief Returns the memory provider used to allocate the memory for the given
+ *        \c mmbAllocation.
  *
  * @param [in]  alloc Handle to a valid mmbAllocation
- * @param [out] interface Pointer to a allocated mmbMemInterfaceType
+ * @param [out] provider Pointer to a allocated mmbProvider
  *
  * @return \c MMB_OK on success, an error type otherwise.
  */
-mmbError mmb_allocation_get_interface_type(const mmbAllocation *alloc,
-                                           mmbMemInterfaceType *interface);
+mmbError mmb_allocation_get_provider(const mmbAllocation *alloc,
+                                     mmbProvider *provider);
 /**
  * @brief Returns the strategy used to allocate the memory for the given
  *        \c mmbAllocation.
diff --git a/deps/mamba/memory/interfaces/linux_native.c b/deps/mamba/memory/providers/linux_native.c
similarity index 97%
rename from deps/mamba/memory/interfaces/linux_native.c
rename to deps/mamba/memory/providers/linux_native.c
index c68a24d8ce9d0733d1841cf628c5f5c602de2754..5ec7c250c155d1594b69606f92c96e4839efb0a6 100644
--- a/deps/mamba/memory/interfaces/linux_native.c
+++ b/deps/mamba/memory/providers/linux_native.c
@@ -35,9 +35,9 @@
 
 #include "mmb_error.h"
 #include "mmb_logging.h"
-#include "../mmb_memory.h"
+#include "mmb_memory.h"
 
-#include "../i_mmb_memory.h"
+#include "../i_memory.h"
 #include "../interface.h"
 #include "linux_native.h"
 
@@ -50,7 +50,7 @@
  * @{ */
 
 /**
- * @name Linux native memory interface.
+ * @name GNU/Linux native memory provider
  * @{ */
 
 mmbError mmb_init__linux(mmbMemInterface *interface)
@@ -89,7 +89,7 @@ mmbError mmb_supports__linux(const mmbMemLayer layer, bool *is_supported)
 }
 
 /**
- * @name Linux DRAM memory interface
+ * @name GNU/Linux native DRAM memory provider
  * @{ */
 
 mmbError mmb_allocate__linux_dram(const size_t n_bytes,
@@ -155,7 +155,7 @@ BAILOUT:
 /**  @} */
 
 /**
- * @name Linux CUDA memory interface
+ * @name GNU/Linux CUDA memory interface
  * @{ */
 
 #if HAVE_CUDA
diff --git a/deps/mamba/memory/interfaces/linux_native.h b/deps/mamba/memory/providers/linux_native.h
similarity index 92%
rename from deps/mamba/memory/interfaces/linux_native.h
rename to deps/mamba/memory/providers/linux_native.h
index 8cc187007679dee454aa0124ccec6c67acea1e29..e1a259f4046d8520916a1224b43ae75e6ff951fd 100644
--- a/deps/mamba/memory/interfaces/linux_native.h
+++ b/deps/mamba/memory/providers/linux_native.h
@@ -33,9 +33,11 @@
 #define MMB_LINUX_NATIVE_H
 
 #include <stdlib.h>
-#include "mmb_error.h"
+
+#include "../../common/mmb_error.h"
 #include "../mmb_memory.h"
-#include "../i_mmb_memory.h"
+
+#include "../i_memory.h"
 
 /**
  * @name mmb_memory
@@ -46,11 +48,11 @@
  * @{ */
 
 /**
- * @name Linux native memory interface.
+ * @name GNU/Linux native memory provider
  * @{ */
 
 /**
- * @brief Place holder. This interface doesn't really need initialization.
+ * @brief Place holder. This provider doesn't really need initialization.
  *
  * @param [in] interface Handle to the structure to initialize.
  *
@@ -59,7 +61,7 @@
 mmbError mmb_init__linux(mmbMemInterface *interface);
 
 /**
- * @brief Place holder. This interface doesn't really need initialization.
+ * @brief Place holder. This provider doesn't really need finalization.
  *
  * @param [in] interface Handle to the structure to finalize.
  *
@@ -69,7 +71,7 @@ mmbError mmb_finalize__linux(mmbMemInterface *interface);
 
 /**
  * @brief Check whether the requested layer is supported by the native
- *        interface.
+ *        linux provider.
  *
  * @param [in] layer Requested layer.
  * @param [out] is_supported Handle for returned value.
@@ -79,12 +81,12 @@ mmbError mmb_finalize__linux(mmbMemInterface *interface);
 mmbError mmb_supports__linux(const mmbMemLayer layer, bool *is_supported);
 
 /**
- * @name Native GNU/Linux DRAM memory interface
+ * @name GNU/Linux native DRAM memory provider
  * @{ */
 
 /**
  * @brief Data structure used to retain allocation NUMA node for \c MMB_NATIVE
- *        type of memory interfaces.
+ *        provider.
  */
 typedef struct mmbLinux {
   int numa_domain;
@@ -93,9 +95,9 @@ typedef struct mmbLinux {
 /**
  * @brief size of the \p mmbNative structure.
  *
- * This parameter is required to initialize the static table in mmb_memory.c.
- * This value is used to compute the required size for an struct
- * mmbMemInterface.
+ * This parameter is required to initialize the static table in memory.c.
+ * This value is used to compute the required size for an
+ * \c struct mmbMemInterface.
  */
 #define mmb_data_size__linux sizeof(struct mmbLinux)
 
@@ -144,7 +146,7 @@ mmbError mmb_copy__linux_dram(void *dst, mmbMemInterface *dst_inter,
 /**  @} */
 
 /**
- * @name Linux CUDA memory interface
+ * @name GNU/Linux CUDA memory provider
  * @{ */
 
 #if HAVE_CUDA
diff --git a/deps/mamba/memory/interfaces/sicm.c b/deps/mamba/memory/providers/sicm.c
similarity index 97%
rename from deps/mamba/memory/interfaces/sicm.c
rename to deps/mamba/memory/providers/sicm.c
index 01f8a9a6373cd6dbe2bd093b9e56ec4010469618..1f858d50d66ec3db704bdb71338c2c1b1c1050c5 100644
--- a/deps/mamba/memory/interfaces/sicm.c
+++ b/deps/mamba/memory/providers/sicm.c
@@ -36,9 +36,9 @@
 
 #include "mmb_error.h"
 #include "mmb_logging.h"
-#include "../mmb_memory.h"
+#include "mmb_memory.h"
 
-#include "../i_mmb_memory.h"
+#include "../i_memory.h"
 #include "../interface.h"
 #include "sicm.h"
 
@@ -51,13 +51,13 @@
  * @{ */
 
 /**
- * @name SICM memory interface
+ * @name SICM memory provider
  * @{ */
 
 /**
  * @brief Translate the enumerate value from mamba to a SICM device tag.
  *
- * @param [in] layer The interface memory layer requested.
+ * @param [in] layer The memory layer requested.
  * @param [out] out_tag The equivalent tag for SICM.
  *
  * @return \c MMB_OK on success, \c MMB_INVALID_LAYER if the requested layer
diff --git a/deps/mamba/memory/interfaces/sicm.h b/deps/mamba/memory/providers/sicm.h
similarity index 95%
rename from deps/mamba/memory/interfaces/sicm.h
rename to deps/mamba/memory/providers/sicm.h
index 4801abe87004c07b8fe4ebc726994ee8bda99cc4..a5b169903156c2ce592cf602369a632a0920d2c4 100644
--- a/deps/mamba/memory/interfaces/sicm.h
+++ b/deps/mamba/memory/providers/sicm.h
@@ -32,11 +32,13 @@
 #ifndef MMB_SICM_H
 #define MMB_SICM_H
 
-#include <stdlib.h>
+#include <stddef.h>
 #include <sicm_low.h>
-#include "mmb_error.h"
+
+#include "../../common/mmb_error.h"
 #include "../mmb_memory.h"
-#include "../i_mmb_memory.h"
+
+#include "../i_memory.h"
 
 /**
  * @name mmb_memory
@@ -47,7 +49,7 @@
  * @{ */
 
 /**
- * @name SICM memory interface
+ * @name SICM memory provider
  * @{ */
 
 /**
@@ -60,9 +62,9 @@ struct mmbSICM {
 /**
  * @brief size of the \p mmbSICM structure.
  *
- * This parameter is required to initialize the static table in mmb_memory.c.
- * This value is used to compute the required size for an struct
- * mmbMemInterface.
+ * This parameter is required to initialize the static table in memory.c.
+ * This value is used to compute the required size for an
+ * \c struct mmbMemInterface.
  */
 #define mmb_data_size__sicm sizeof(struct mmbSICM)
 
diff --git a/deps/mamba/memory/strategies/apply.c b/deps/mamba/memory/strategies/apply.c
index 505d20e2567917d5d6972b21de66d410f3023bf4..fe1a66f3bf17e6d3bda60ed78d2d11a2a523882a 100644
--- a/deps/mamba/memory/strategies/apply.c
+++ b/deps/mamba/memory/strategies/apply.c
@@ -34,8 +34,9 @@
 
 #include "mmb_logging.h"
 #include "mmb_error.h"
-#include "../mmb_memory.h"
-#include "../i_mmb_memory.h"
+#include "mmb_memory.h"
+
+#include "../i_memory.h"
 #include "i_strategy.h"
 #include "apply.h"
 
diff --git a/deps/mamba/memory/strategies/apply.h b/deps/mamba/memory/strategies/apply.h
index 9727975f4d7f6bbe46829cc45462ff2f0a94c3e4..155edc14077c489a047b797ddd4142b8c37e094c 100644
--- a/deps/mamba/memory/strategies/apply.h
+++ b/deps/mamba/memory/strategies/apply.h
@@ -32,11 +32,13 @@
 #ifndef MMB_APPLY_STRATEGY_H
 #define MMB_APPLY_STRATEGY_H
 
-#include <stdlib.h>
+#include <stddef.h>
 #include <stdarg.h>
-#include "mmb_error.h"
+
+#include "../../common/mmb_error.h"
 #include "../mmb_memory.h"
-#include "../i_mmb_memory.h"
+
+#include "../i_memory.h"
 
 /**
  * @name mmb_memory
diff --git a/deps/mamba/memory/strategies/basic.h b/deps/mamba/memory/strategies/basic.h
index fe30eb6e2c5852dacac4b94e20433822217a0546..3c94706c8232d7c7dd993487f012866c5972f211 100644
--- a/deps/mamba/memory/strategies/basic.h
+++ b/deps/mamba/memory/strategies/basic.h
@@ -32,10 +32,12 @@
 #ifndef MMB_STRATEGY_BASIC_H
 #define MMB_STRATEGY_BASIC_H
 
-#include <stdlib.h>
-#include "mmb_error.h"
+#include <stddef.h>
+
+#include "../../common/mmb_error.h"
 #include "../mmb_memory.h"
-#include "../i_mmb_memory.h"
+
+#include "../i_memory.h"
 
 /**
  * @name mmb_memory
diff --git a/deps/mamba/memory/strategies/i_basic.h b/deps/mamba/memory/strategies/i_basic.h
index b3c2e1e8654c3d7d918d98ba8816e55efeb82e6f..a94aacad0a7afbb15504370ffd976854e3b29b01 100644
--- a/deps/mamba/memory/strategies/i_basic.h
+++ b/deps/mamba/memory/strategies/i_basic.h
@@ -32,11 +32,13 @@
 #ifndef MMB_I_STRATEGY_BASIC_H
 #define MMB_I_STRATEGY_BASIC_H
 
-#include <stdlib.h>
+#include <stddef.h>
 #include <stdarg.h>
-#include "mmb_error.h"
+
+#include "../../common/mmb_error.h"
 #include "../mmb_memory.h"
-#include "../i_mmb_memory.h"
+
+#include "../i_memory.h"
 
 /**
  * @name mmb_memory
@@ -50,7 +52,7 @@
  * @name Basic Strategy
  *
  * This strategy is the final strategy that should be apply by any strategy
- * builder. This strategy *ALWAYS* calls the memory interface functions
+ * builder. This strategy *ALWAYS* calls the memory provider functions
  * referenced in the interface (or allocation) handle.
  *
  * @{ */
@@ -59,7 +61,7 @@
  * @name Private API
  *
  * Dummy set functions to be used by a strategy builder. These functions only
- * apply the call to the memory interface provided in the mmbMemInterface
+ * apply the call to the memory provider provided in the mmbMemInterface
  * handle (or the one embed in the mmbAllocation structure).
  *
  * @{ */
@@ -71,7 +73,7 @@
 #define mmb_strat_data_size__basic ((mmb_strat_data_size)0)
 
 /**
- * @brief Call the memory interface initialization of the parameters.
+ * @brief Call the memory provider initialization of the parameters.
  *
  * @param [in] interface Handle to the mmbMemInterface structure to initialize.
  * @param [in] data IGNORED. Should be \c NULL.
@@ -83,7 +85,7 @@ mmbError mmb_strat_init_va__basic(mmbMemInterface *interface, void *data,
                                   va_list args);
 
 /**
- * @brief Call the memory interface finalizarion of the parameters.
+ * @brief Call the memory provider finalization function.
  *
  * @param [in] interface Handle to the mmbMemInterface structure to finalize.
  * @param [in] data IGNORED. Should be \c NULL.
@@ -95,7 +97,7 @@ mmbError mmb_strat_finalize_va__basic(mmbMemInterface *interface, void *data,
                                       va_list args);
 
 /**
- * @brief Call the memory interface function to do the allocate operation.
+ * @brief Call the memory provider function to do the allocate operation.
  *
  * @param [in] n_bytes Size of the requested allocation.
  * @param [in] interface Handle to the mmbMemInterface structure used to
@@ -112,7 +114,7 @@ mmbError mmb_strat_allocate_va__basic(const size_t n_bytes,
                                       void **allocation, va_list args);
 
 /**
- * @brief Call the memory interface function to do the free operation.
+ * @brief Call the memory provider function to do the free operation.
  *
  * @param [in] allocation Allocation handle pointing to the data to be free'd
  *                        by the memory interface.
@@ -129,7 +131,7 @@ mmbError mmb_strat_free_va__basic(void *allocation, void *data,
                                   va_list args);
 
 /**
- * @brief Call the memory interface function to do the copy operation.
+ * @brief Call the memory provider function to do the copy operation.
  *
  * @param [out] dst Handle to the written data.
  * @param [in] dst_data IGNORED. Should be \c NULL.
diff --git a/deps/mamba/memory/strategies/i_pooled.h b/deps/mamba/memory/strategies/i_pooled.h
index 372aef3fc6267af5ab9cd67423e99395dceecda0..585be21766f0f41cfe4e48118ba11da2a1c5953d 100644
--- a/deps/mamba/memory/strategies/i_pooled.h
+++ b/deps/mamba/memory/strategies/i_pooled.h
@@ -32,11 +32,13 @@
 #ifndef MMB_I_STRATEGY_POOLED_H
 #define MMB_I_STRATEGY_POOLED_H
 
-#include <stdlib.h>
+#include <stddef.h>
 #include <stdarg.h>
-#include "mmb_error.h"
+
+#include "../../common/mmb_error.h"
 #include "../mmb_memory.h"
-#include "../i_mmb_memory.h"
+
+#include "../i_memory.h"
 
 /**
  * @name mmb_memory
diff --git a/deps/mamba/memory/strategies/i_strategy.h b/deps/mamba/memory/strategies/i_strategy.h
index 50737849f22a91082bcbbc154ce0bf959df9e740..6f286407ca285ff3a560f358b2815b528cb3a8eb 100644
--- a/deps/mamba/memory/strategies/i_strategy.h
+++ b/deps/mamba/memory/strategies/i_strategy.h
@@ -34,9 +34,11 @@
 
 #include <stdlib.h>
 #include <stdarg.h>
-#include "mmb_error.h"
+
+#include "../../common/mmb_error.h"
 #include "../mmb_memory.h"
-#include "../i_mmb_memory.h"
+
+#include "../i_memory.h"
 
 /**
  * @name mmb_memory
@@ -90,7 +92,7 @@ extern const struct mmb_dispatch_strategy_va_entry
 mmb_strategies_va_table[MMB_STRATEGY__MAX];
 
 extern const size_t
-mmb_interface_data_sizes[MMB_MEMINTERFACE_TYPE__MAX];
+mmb_provider_data_sizes[MMB_PROVIDER__MAX];
 
 /**  @} */
 
diff --git a/deps/mamba/memory/strategies/pooled.c b/deps/mamba/memory/strategies/pooled.c
index a45e60c19428fb8b396bc4c8a6092cb33ce1d103..896fb747d495428ce5dc8238a48a766b4dff25b3 100644
--- a/deps/mamba/memory/strategies/pooled.c
+++ b/deps/mamba/memory/strategies/pooled.c
@@ -32,11 +32,12 @@
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
+
 #include "mmb_error.h"
-#include "../mmb_memory.h"
-#include "../i_mmb_memory.h"
 #include "mmb_logging.h"
+#include "mmb_memory.h"
 
+#include "../i_memory.h"
 #include "apply.h"
 #include "i_strategy.h"
 #include "i_pooled.h"
@@ -60,8 +61,8 @@
 mmbError mmb_strat_init__pooled(mmbMemInterface *interface)
 {
   /* data is already allocated in interface: Compute offset to strat data */
-  const mmbMemInterfaceType type = interface->type;
-  unsigned char *data = interface->data + mmb_interface_data_sizes[type];
+  const mmbProvider provider = interface->provider;
+  unsigned char *data = interface->data + mmb_provider_data_sizes[provider];
   return mmb_strat_init__apply(interface,
       mmb_strategies_va_table[MMB_POOLED].init, data,
       mmb_strategies_va_table[MMB_NO_STRAT].init, NULL);
@@ -70,8 +71,8 @@ mmbError mmb_strat_init__pooled(mmbMemInterface *interface)
 mmbError mmb_strat_finalize__pooled(mmbMemInterface *interface)
 {
   /* data is already allocated in interface: Compute offset to strat data */
-  const mmbMemInterfaceType type = interface->type;
-  unsigned char *data = interface->data + mmb_interface_data_sizes[type];
+  const mmbProvider provider = interface->provider;
+  unsigned char *data = interface->data + mmb_provider_data_sizes[provider];
   return mmb_strat_finalize__apply(interface,
       mmb_strategies_va_table[MMB_POOLED].finalize, data,
       mmb_strategies_va_table[MMB_NO_STRAT].finalize, NULL);
@@ -82,8 +83,8 @@ mmbError mmb_strat_allocate__pooled(const size_t n_bytes,
                                     mmbAllocation *allocation)
 {
   /* data is already allocated in interface: Compute offset to strat data */
-  const mmbMemInterfaceType type = interface->type;
-  unsigned char *data = interface->data + mmb_interface_data_sizes[type];
+  const mmbProvider provider = interface->provider;
+  unsigned char *data = interface->data + mmb_provider_data_sizes[provider];
   return mmb_strat_allocate__apply(n_bytes, interface, allocation,
       mmb_strategies_va_table[MMB_POOLED].allocate, data,
       mmb_strategies_va_table[MMB_NO_STRAT].allocate, NULL);
@@ -92,9 +93,9 @@ mmbError mmb_strat_allocate__pooled(const size_t n_bytes,
 mmbError mmb_strat_free__pooled(mmbAllocation *allocation)
 {
   /* data is already allocated in interface: Compute offset to strat data */
-  const mmbMemInterfaceType type = allocation->interface->type;
+  const mmbProvider provider = allocation->interface->provider;
   unsigned char *data =
-    allocation->interface->data + mmb_interface_data_sizes[type];
+    allocation->interface->data + mmb_provider_data_sizes[provider];
   return mmb_strat_free__apply(allocation,
       mmb_strategies_va_table[MMB_POOLED].free, data,
       mmb_strategies_va_table[MMB_NO_STRAT].free, NULL);
@@ -103,8 +104,8 @@ mmbError mmb_strat_free__pooled(mmbAllocation *allocation)
 mmbError mmb_strat_copy__pooled(mmbAllocation *dest, const mmbAllocation *src)
 {
   /* data is already allocated in interface: Compute offset to strat data */
-  const mmbMemInterfaceType type = dest->interface->type;
-  unsigned char *data = dest->interface->data + mmb_interface_data_sizes[type];
+  const mmbProvider provider = dest->interface->provider;
+  unsigned char *data = dest->interface->data + mmb_provider_data_sizes[provider];
   return mmb_strat_copy__apply(dest, src,
       mmb_strategies_va_table[MMB_POOLED].copy, data,
       mmb_strategies_va_table[MMB_NO_STRAT].copy, NULL);
@@ -567,10 +568,10 @@ mmbError mmb_strat_copy_va__pooled(void                  *dst,
 /** thread_safe_pooled */
 mmbError mmb_strat_init__pooled_thread_safe(mmbMemInterface *interface)
 {
-  const mmbMemInterfaceType type = interface->type;
-  unsigned char *thread_data = interface->data + mmb_interface_data_sizes[type];
-  unsigned char *pooled_data =
-    thread_data + mmb_strategies_va_table[MMB_THREAD_SAFE].data_size;
+  const mmbProvider provider = interface->provider;
+  unsigned char *thread_data, *pooled_data;
+  thread_data = interface->data + mmb_provider_data_sizes[provider];
+  pooled_data = thread_data + mmb_strategies_va_table[MMB_THREAD_SAFE].data_size;
   return mmb_strat_init__apply(interface,
       mmb_strategies_va_table[MMB_THREAD_SAFE].init, thread_data,
       mmb_strategies_va_table[MMB_POOLED].init, pooled_data,
@@ -580,13 +581,11 @@ mmbError mmb_strat_init__pooled_thread_safe(mmbMemInterface *interface)
 /** thread_safe_pooled_thread_safe_memory */
 mmbError mmb_strat_init__pooled_full_thread_safe(mmbMemInterface *interface)
 {
-  const mmbMemInterfaceType type = interface->type;
-  unsigned char *pool_thread_data =
-    interface->data + mmb_interface_data_sizes[type];
-  unsigned char *pooled_data =
-    pool_thread_data + mmb_strategies_va_table[MMB_THREAD_SAFE].data_size;
-  unsigned char *mem_thread_data =
-    pooled_data + mmb_strategies_va_table[MMB_POOLED].data_size;
+  const mmbProvider provider = interface->provider;
+  unsigned char *pool_thread_data, *pooled_data, *mem_thread_data;
+  pool_thread_data = interface->data + mmb_provider_data_sizes[provider];
+  pooled_data = pool_thread_data + mmb_strategies_va_table[MMB_THREAD_SAFE].data_size;
+  mem_thread_data = pooled_data + mmb_strategies_va_table[MMB_POOLED].data_size;
   return mmb_strat_init__apply(interface,
       mmb_strategies_va_table[MMB_THREAD_SAFE].init, pool_thread_data,
       mmb_strategies_va_table[MMB_POOLED].init, pooled_data,
diff --git a/deps/mamba/memory/strategies/pooled.h b/deps/mamba/memory/strategies/pooled.h
index 9905c6d762fd1fdf2557ead64e07216d1174decf..bcf4ec36739375aeb45fb69fe71a975ddcda5c19 100644
--- a/deps/mamba/memory/strategies/pooled.h
+++ b/deps/mamba/memory/strategies/pooled.h
@@ -32,10 +32,12 @@
 #ifndef MMB_STRATEGY_POOLED_H
 #define MMB_STRATEGY_POOLED_H
 
-#include <stdlib.h>
-#include "mmb_error.h"
-#include "mmb_memory.h"
-#include "../i_mmb_memory.h"
+#include <stddef.h>
+
+#include "../../common/mmb_error.h"
+#include "../mmb_memory.h"
+
+#include "../i_memory.h"
 
 /**
  * @name mmb_memory
diff --git a/deps/mamba/memory/strategy.c b/deps/mamba/memory/strategy.c
index 6fe4cdac962fc18e597f3806888243e6349a4f8a..4289b783bd8676578bbf662ac3b6e48a959e5d13 100644
--- a/deps/mamba/memory/strategy.c
+++ b/deps/mamba/memory/strategy.c
@@ -4,12 +4,12 @@
 
 #include "mmb_memory.h"
 #include "mmb_logging.h"
-#include "i_mmb_memory.h"
 
+#include "i_memory.h"
 #include "interface.h"
-#include "interfaces/linux_native.h"
+#include "providers/linux_native.h"
 #if HAVE_SICM
-#include "interfaces/sicm.h"
+#include "providers/sicm.h"
 #endif /* HAVE_SICM */
 
 #include "strategies/apply.h"
@@ -26,14 +26,14 @@
  * @{ */
 
 /**
- * @brief Interface dispatch table.
+ * @brief Provider dispatch table.
  *
  * We use C99 named initializers, and rely on C static data being 0-initialized
  * so that the 'enabled' fields of the entries are 0 if we actually stored an
  * entry for the respective substrate.
  */
-static const struct mmb_dispatch_interface_entry
-mmb_interfaces_table[MMB_MEMINTERFACE_TYPE__MAX] = {
+static const struct mmb_dispatch_provider_entry
+mmb_providers_table[MMB_PROVIDER__MAX] = {
   [MMB_NATIVE] = {
     .name     = "LINUX_CPU",
     .supports = mmb_supports__linux,
@@ -76,12 +76,12 @@ mmb_interfaces_table[MMB_MEMINTERFACE_TYPE__MAX] = {
 };
 
 /**
- * @brief Size of interface specific data.
+ * @brief Size of provider specific data.
  *
  * This table is used to retrieve the addresses of the beginning of strategy
  * specific data in the interface structure.
  */
-const size_t mmb_interface_data_sizes[MMB_MEMINTERFACE_TYPE__MAX] = {
+const size_t mmb_provider_data_sizes[MMB_PROVIDER__MAX] = {
   [MMB_NATIVE]  = mmb_data_size__linux,
 #if HAVE_SICM
   [MMB_SICM]    = mmb_data_size__sicm,
@@ -116,7 +116,7 @@ mmb_strategies_va_table[MMB_STRATEGY__MAX] = {
     },
 };
 
-mmbError mmb_strat_get_data_size(const mmbMemInterfaceType type,
+mmbError mmb_strat_get_data_size(const mmbProvider provider,
                                  const mmbStrategy strategy,
                                  size_t *out_data_size)
 {
@@ -126,15 +126,15 @@ mmbError mmb_strat_get_data_size(const mmbMemInterfaceType type,
     ERR("Invalid pointer \"out_data_size\".\n");
     goto BAILOUT;
   }
-  switch (type) {
+  switch (provider) {
     case MMB_NATIVE:
 #if HAVE_SICM
     case MMB_SICM:
 #endif /* HAVE_SICM */
-      data_size += mmb_interface_data_sizes[type];
+      data_size += mmb_provider_data_sizes[provider];
       break;
     default:
-      ERR("Invalid interface data size requested.\n");
+      ERR("Invalid provider data size requested.\n");
       goto BAILOUT;
   }
   switch (strategy) {
@@ -152,24 +152,24 @@ BAILOUT:
   return stat;
 }
 
-mmbError mmb_interface_compatibility_check(const mmbMemInterfaceType type,
-                                           const mmbMemLayer layer,
-                                           const mmbExecutionContext ex_con,
-                                           bool *is_available)
+mmbError mmb_provider_compatibility_check(const mmbProvider provider,
+                                          const mmbMemLayer layer,
+                                          const mmbExecutionContext ex_con,
+                                          bool *is_available)
 {
   mmbError stat = MMB_OK;
   if (NULL == is_available) {
     return MMB_INVALID_ARG;
   } else if (MMB_MEMLAYER__MAX <= layer) {
     return MMB_INVALID_LAYER;
-  } else if (MMB_MEMINTERFACE_TYPE__MAX <= type) {
-    return MMB_INVALID_INTERFACE_TYPE;
+  } else if (MMB_PROVIDER__MAX <= provider) {
+    return MMB_INVALID_PROVIDER;
   } else if (MMB_EXECUTION_CONTEXT__MAX <= ex_con) {
     return MMB_INVALID_EXECUTION_CONTEXT;
   }
-  const bool avail = mmb_interfaces_table[type].ops[ex_con].enabled;
+  const bool avail = mmb_providers_table[provider].ops[ex_con].enabled;
   if (avail) {
-    stat = mmb_interfaces_table[type].supports(layer, is_available);
+    stat = mmb_providers_table[provider].supports(layer, is_available);
   } else {
     *is_available = avail;
   }
@@ -225,9 +225,9 @@ mmbError mmb_strat_copy__basic(mmbAllocation *dest, const mmbAllocation *src)
 /**
  * @name Private API
  *
- * Because of the need to access mmb_interfaces_table for the MMB_NO_STRAT
+ * Because of the need to access mmb_providers_table for the MMB_NO_STRAT
  * strategy functions, these functions are to be found in this file (the
- * interface dispatch table is static, so not exposed outside this file).
+ * provider dispatch table is static, so not exposed outside this file).
  *
  * @{ */
 
@@ -237,8 +237,8 @@ mmbError mmb_strat_init_va__basic(mmbMemInterface *interface,
 {
   (void) data;
   (void) args;
-  const mmbMemInterfaceType type = interface->type;
-  return mmb_interfaces_table[type].init(interface);
+  const mmbProvider provider = interface->provider;
+  return mmb_providers_table[provider].init(interface);
 }
 
 mmbError mmb_strat_finalize_va__basic(mmbMemInterface *interface,
@@ -247,8 +247,8 @@ mmbError mmb_strat_finalize_va__basic(mmbMemInterface *interface,
 {
   (void) data;
   (void) args;
-  const mmbMemInterfaceType type = interface->type;
-  return mmb_interfaces_table[type].finalize(interface);
+  const mmbProvider provider = interface->provider;
+  return mmb_providers_table[provider].finalize(interface);
 }
 
 mmbError mmb_strat_allocate_va__basic(const size_t n_bytes,
@@ -260,7 +260,7 @@ mmbError mmb_strat_allocate_va__basic(const size_t n_bytes,
   (void) data;
   (void) args;
   mmbError stat = MMB_OK;
-  const mmbMemInterfaceType type = interface->type;
+  const mmbProvider provider = interface->provider;
   const mmbExecutionContext ex_con = interface->space->ex_context;
 
   /* Check we arent over the limit */
@@ -271,8 +271,8 @@ mmbError mmb_strat_allocate_va__basic(const size_t n_bytes,
     goto BAILOUT;
   }
 
-  stat = mmb_interfaces_table[type].ops[ex_con].allocate(n_bytes, interface,
-                                                         allocation);
+  stat = mmb_providers_table[provider].ops[ex_con].allocate(n_bytes, interface,
+                                                            allocation);
   if (MMB_OK == stat) {
     interface->space->allocated_bytes += n_bytes;
   }
@@ -289,9 +289,9 @@ mmbError mmb_strat_free_va__basic(void *alloc,
   (void) data;
   (void) args;
   mmbError stat = MMB_OK;
-  const mmbMemInterfaceType type = interface->type;
+  const mmbProvider provider = interface->provider;
   const mmbExecutionContext ex_con = interface->space->ex_context;
-  stat = mmb_interfaces_table[type].ops[ex_con].free(alloc, interface, n_bytes);
+  stat = mmb_providers_table[provider].ops[ex_con].free(alloc, interface, n_bytes);
   if (MMB_OK == stat) {
     interface->space->allocated_bytes -= n_bytes;
   }
@@ -308,15 +308,15 @@ mmbError mmb_strat_copy_va__basic(void *dst, void *dst_data,
   (void) dst_data;
   (void) args;
   mmbError stat;
-  const mmbMemInterfaceType dst_type = dst_interface->type;
+  const mmbProvider dst_provider = dst_interface->provider;
   const mmbExecutionContext dst_ex_con = dst_interface->space->ex_context;
-  stat = mmb_interfaces_table[dst_type].ops[dst_ex_con]
+  stat = mmb_providers_table[dst_provider].ops[dst_ex_con]
             .copy(dst, dst_interface, src, src_interface, n_bytes);
-  if (MMB_INVALID_INTERFACE == stat || MMB_INVALID_LAYER == stat
+  if (MMB_INVALID_PROVIDER == stat || MMB_INVALID_LAYER == stat
       || MMB_INVALID_EXECUTION_CONTEXT == stat) {
-    const mmbMemInterfaceType src_type = src_interface->type;
+    const mmbProvider src_provider = src_interface->provider;
     const mmbExecutionContext src_ex_con = src_interface->space->ex_context;
-    stat = mmb_interfaces_table[src_type].ops[src_ex_con]
+    stat = mmb_providers_table[src_provider].ops[src_ex_con]
               .copy(dst, dst_interface, src, src_interface, n_bytes);
   }
   return stat;
diff --git a/deps/mamba/memory/strategy.h b/deps/mamba/memory/strategy.h
index 9a462130fd0dbb1a9edfc114eb3fb164c0822b6c..7f118c7337a7d81ede2bcd834146d8eca6fec404 100644
--- a/deps/mamba/memory/strategy.h
+++ b/deps/mamba/memory/strategy.h
@@ -34,9 +34,11 @@
 
 #include <stdlib.h>
 #include <stdbool.h>
-#include "mmb_error.h"
+
+#include "../common/mmb_error.h"
 #include "mmb_memory.h"
-#include "i_mmb_memory.h"
+
+#include "i_memory.h"
 
 /**
  * @name mmb_memory
@@ -81,36 +83,37 @@ struct mmb_dispatch_strategy_entry {
  * @brief Provides the size of the extra data required in the structure when
  *        allocating it.
  *
- * @param [in] type Offset in the interface array dispatch table. Cannot be
- *                  \c MMB_DEFAULT_INTERFACE
+ * @param [in] provider Offset in the provider array dispatch table. Cannot be
+ *                      \c MMB_DEFAULT_PROVIDER
  * @param [in] strategy Offset in the strategy array dispatch table. Cannot be
  *                      \c MMB_DEFAULT_STRATEGY
  * @param [out] out_data_size Strategy dependent data size.
  *
- * @return \c MMB_OK on success, \c MMB_INVALID_ARG if a wrong mmbMemInterface
+ * @return \c MMB_OK on success, \c MMB_INVALID_ARG if a wrong mmbProvider
  *         or a wrong mmbStrategy are as parameters.
  */
-mmbError mmb_strat_get_data_size(const mmbMemInterfaceType type,
+mmbError mmb_strat_get_data_size(const mmbProvider provider,
                                  const mmbStrategy strategy,
                                  size_t *out_data_size);
 
 /**
- * @brief Check on the availability of the requested interface for the
- *        requested memory layer.
+ * @brief Check on the availability of the requested provider for the
+ *        requested memory layer with the requested execution context.
  *
- * @param [in] type Interface type requested
+ * @param [in] provider Memory provider requested
  * @param [in] layer Memory layer
  * @param [in] ex_con Execution context to be tested
- * @param [out] is_available Whether the requested \p type interface provide
- *                           support for the given \p layer.
+ * @param [out] is_available Whether the requested memory \p provider supports
+ *                           the given \p layer.
  *
- * @return \c MMB_OK on success, \c MMB_INVALID_ARG if a wrong mmbMemInterface
- *         or wrong mmbMemLayer are given as parameters.
+ * @return \c MMB_OK on success, \c MMB_INVALID_ARG if a wrong mmbProvider,
+ *         wrong mmbMemLayer or wrong mmbExecutionContext are given as
+ *         parameters.
  */
-mmbError mmb_interface_compatibility_check(const mmbMemInterfaceType type,
-                                           const mmbMemLayer layer,
-                                           const mmbExecutionContext ex_con,
-                                           bool *is_available);
+mmbError mmb_provider_compatibility_check(const mmbProvider provider,
+                                          const mmbMemLayer layer,
+                                          const mmbExecutionContext ex_con,
+                                          bool *is_available);
 
 /**  @} */
 
diff --git a/deps/mamba/memory/topology.c b/deps/mamba/memory/topology.c
index c94b9ceb808d46fa55558bc1214229ebe2defe0f..33c3eff29edf1c747e37e849f9e83dc45f536ed9 100644
--- a/deps/mamba/memory/topology.c
+++ b/deps/mamba/memory/topology.c
@@ -38,7 +38,8 @@
 #include "mmb_error.h"
 #include "mmb_logging.h"
 #include "mmb_memory.h"
-#include "i_mmb_memory.h"
+
+#include "i_memory.h"
 #include "topology.h"
 
 static mmbError
@@ -150,7 +151,7 @@ mmb_topology_init(hwloc_topology_t *topology, uint64_t * restrict layers,
 
   /* Check parameters */
   if (NULL == topology) {
-    ERR("Invalid topology handle.\n");
+    ERR("Invalid topology handle (cannot be NULL).\n");
     stat = MMB_INVALID_ARG;
     goto BAILOUT;
   }
diff --git a/deps/mamba/memory/topology.h b/deps/mamba/memory/topology.h
index a95c38c211b961c87abd1ff032acf1b71a9fbff7..318dde470a6f588e6c7de984f235e2d89658e553 100644
--- a/deps/mamba/memory/topology.h
+++ b/deps/mamba/memory/topology.h
@@ -35,7 +35,7 @@
 #include <stdlib.h>
 #include <hwloc.h>
 
-#include "mmb_error.h"
+#include "../common/mmb_error.h"
 
 /**
  * @name mmb_topology