From df0ff7fdad1388e4fde6949cbd7bc947b54371c2 Mon Sep 17 00:00:00 2001
From: George Bosilca <bosilca@icl.utk.edu>
Date: Sun, 28 Jan 2024 04:25:10 +0000
Subject: [PATCH 1/9] Fix coverity reported issues

Don't generate the args code if there are no successors
compute the key using 64 bits arithmetic
ensure vpid is within expected range

Signed-off-by: George Bosilca <bosilca@icl.utk.edu>
---
 parsec/interfaces/ptg/ptg-compiler/jdf2c.c  | 48 +++++++++++++--------
 parsec/parsec.c                             |  2 +
 parsec/utils/argv.c                         | 10 ++---
 parsec/utils/output.c                       | 23 +++-------
 tests/class/future.c                        |  4 +-
 tests/class/future_datacopy.c               | 25 ++++++-----
 tests/dsl/dtd/dtd_test_simple_gemm.c        |  2 +-
 tests/dsl/ptg/user-defined-functions/main.c | 12 ++++++
 tests/runtime/cuda/stage_main.c             |  1 -
 9 files changed, 71 insertions(+), 56 deletions(-)

diff --git a/parsec/interfaces/ptg/ptg-compiler/jdf2c.c b/parsec/interfaces/ptg/ptg-compiler/jdf2c.c
index 850afedce..c0a944fda 100644
--- a/parsec/interfaces/ptg/ptg-compiler/jdf2c.c
+++ b/parsec/interfaces/ptg/ptg-compiler/jdf2c.c
@@ -3152,6 +3152,12 @@ static void jdf_generate_startup_tasks(const jdf_t *jdf, const jdf_function_entr
 
     coutput("%s  if( NULL != ((parsec_data_collection_t*)"TASKPOOL_GLOBAL_PREFIX"_g_%s)->vpid_of ) {\n"
             "%s    vpid = ((parsec_data_collection_t*)"TASKPOOL_GLOBAL_PREFIX"_g_%s)->vpid_of((parsec_data_collection_t*)"TASKPOOL_GLOBAL_PREFIX"_g_%s, %s);\n"
+            "%s    if( vpid >= context->nb_vp ) {\n"
+            "%s       char tmp[128];\n"
+            "%s       parsec_output(parsec_debug_output, \"VPID %%d for task %%s is too large (> %%d the number of VP in the context)\",\n"
+            "%s                     vpid, parsec_task_snprintf(tmp, 128, (parsec_task_t *)this_task), context->nb_vp);\n"
+            "%s       vpid = vpid %% context->nb_vp;\n"
+            "%s    }\n"
             "%s    assert(context->nb_vp >= vpid);\n"
             "%s  } else {\n"
             "%s    vpid = (vpid + 1) %% context->nb_vp;  /* spread the initial joy */\n"
@@ -3167,6 +3173,12 @@ static void jdf_generate_startup_tasks(const jdf_t *jdf, const jdf_function_entr
             indent(nesting),
             indent(nesting),
             indent(nesting),
+            indent(nesting),
+            indent(nesting),
+            indent(nesting),
+            indent(nesting),
+            indent(nesting),
+            indent(nesting),
             indent(nesting), parsec_get_name(jdf, f, "task_t"),
             indent(nesting));
 
@@ -4817,7 +4829,7 @@ static void jdf_generate_new_function( const jdf_t* jdf )
     if( jdf_uses_dynamic_termdet(jdf) ) {
         coutput("  __parsec_tp->initial_number_tasks = 0;\n");
     }
-    
+
     string_arena_init(sa1);
     string_arena_init(sa2);
     coutput("/* Prevent warnings related to not used hidden global variables */\n"
@@ -4855,7 +4867,7 @@ static void jdf_generate_hashfunction_for(const jdf_t *jdf, const jdf_function_e
             string_arena_init(sa_range_multiplier);
             for(vl = f->locals; vl != NULL; vl = vl->next) {
                 if( local_is_parameter(f, vl) != NULL ) {
-                    coutput("  __parsec_id += (assignment->%s.value - __parsec_tp->%s_%s_min)%s;\n", vl->name, f->fname, vl->name, 
+                    coutput("  __parsec_id += ((uint64_t)assignment->%s.value - __parsec_tp->%s_%s_min)%s;\n", vl->name, f->fname, vl->name, 
                             string_arena_get_string(sa_range_multiplier));
                     string_arena_add_string(sa_range_multiplier, " * __parsec_tp->%s_%s_range", f->fname, vl->name);
                 }
@@ -7189,21 +7201,8 @@ static void jdf_generate_code_release_deps(const jdf_t *jdf, const jdf_function_
             "{\n"
             "  PARSEC_PINS(es, RELEASE_DEPS_BEGIN, (parsec_task_t *)this_task);"
             "  const __parsec_%s_internal_taskpool_t *__parsec_tp = (const __parsec_%s_internal_taskpool_t *)this_task->taskpool;\n"
-            "  parsec_release_dep_fct_arg_t arg;\n"
-            "  int __vp_id;\n"
             "  int consume_local_repo = 0;\n"
-            "  arg.action_mask = action_mask;\n"
-            "  arg.output_entry = NULL;\n"
-            "  arg.output_repo = NULL;\n"
-            "#if defined(DISTRIBUTED)\n"
-            "  arg.remote_deps = deps;\n"
-            "#endif  /* defined(DISTRIBUTED) */\n"
             "  assert(NULL != es);\n"
-            "  if( action_mask & PARSEC_ACTION_RELEASE_LOCAL_DEPS )"
-            "    arg.ready_lists = alloca(sizeof(parsec_task_t *) * es->virtual_process->parsec_context->nb_vp);\n"
-            "  else\n"
-            "    arg.ready_lists = NULL;\n"
-            "  for( __vp_id = 0; __vp_id < es->virtual_process->parsec_context->nb_vp; arg.ready_lists[__vp_id++] = NULL );\n"
             "  (void)__parsec_tp; (void)deps;\n",
             name, parsec_get_name(jdf, f, "task_t"),
             jdf_basename, jdf_basename);
@@ -7214,9 +7213,22 @@ static void jdf_generate_code_release_deps(const jdf_t *jdf, const jdf_function_
 
     if( !(f->flags & JDF_FUNCTION_FLAG_NO_SUCCESSORS) ) {
 
-        coutput("  arg.output_repo = %s_repo;\n", f->fname);
-        coutput("  arg.output_entry = this_task->repo_entry;\n");
-        coutput("  arg.output_usage = 0;\n");
+        coutput("  parsec_release_dep_fct_arg_t arg;\n"
+                "  arg.action_mask = action_mask;\n"
+                "  arg.output_entry = NULL;\n"
+                "  arg.output_repo = NULL;\n"
+                "#if defined(DISTRIBUTED)\n"
+                "  arg.remote_deps = deps;\n"
+                "#endif  /* defined(DISTRIBUTED) */\n"
+                "  arg.ready_lists = NULL;\n"
+                "  if( action_mask & PARSEC_ACTION_RELEASE_LOCAL_DEPS ) {\n"
+                "    arg.ready_lists = alloca(sizeof(parsec_task_t *) * es->virtual_process->parsec_context->nb_vp);\n"
+                "    for( int __vp_id = 0; __vp_id < es->virtual_process->parsec_context->nb_vp; arg.ready_lists[__vp_id++] = NULL );\n"
+                "  }\n"
+                "  arg.output_repo = %s_repo;\n"
+                "  arg.output_entry = this_task->repo_entry;\n"
+                "  arg.output_usage = 0;\n",
+                f->fname);
 
         coutput("  if( action_mask & (PARSEC_ACTION_RELEASE_LOCAL_DEPS | PARSEC_ACTION_GET_REPO_ENTRY) ) {\n"
                 "    arg.output_entry = data_repo_lookup_entry_and_create( es, arg.output_repo, %s((const parsec_taskpool_t*)__parsec_tp, (const parsec_assignment_t*)&this_task->locals));\n"
diff --git a/parsec/parsec.c b/parsec/parsec.c
index 78998ae13..c0337b241 100644
--- a/parsec/parsec.c
+++ b/parsec/parsec.c
@@ -765,6 +765,7 @@ parsec_context_t* parsec_init( int nb_cores, int* pargc, char** pargv[] )
     (void)parsec_remote_dep_init(context);
 
     PARSEC_PINS_INIT(context);
+#if defined(PARSEC_PROF_TRACE)
     if(profiling_enabled && (0 == parsec_pins_nb_modules_enabled())) {
         if(parsec_debug_rank == 0)
             parsec_warning("*** PaRSEC Profiling warning: creating profile file as requested,\n"
@@ -772,6 +773,7 @@ parsec_context_t* parsec_init( int nb_cores, int* pargc, char** pargv[] )
                            "*** Activate the MCA PINS Module task_profiler to get the previous behavior\n"
                            "***   ( --mca mca_pins task_profiler )\n");
     }
+#endif  /* defined(PARSEC_PROF_TRACE) */
 
 #if defined(PARSEC_PROF_GRAPHER)
     if(parsec_dot_file) {
diff --git a/parsec/utils/argv.c b/parsec/utils/argv.c
index f3cb8401a..c24db0e95 100644
--- a/parsec/utils/argv.c
+++ b/parsec/utils/argv.c
@@ -333,11 +333,9 @@ char *parsec_argv_join(char **argv, int delimiter)
  */
 char *parsec_argv_join_range(char **argv, size_t start, size_t end, int delimiter)
 {
+    char *pp, *str;
     char **p;
-    char *pp;
-    char *str;
-    size_t str_len = 0;
-    size_t i;
+    size_t i, str_len = 0;
 
     /* Bozo case */
 
@@ -351,9 +349,11 @@ char *parsec_argv_join_range(char **argv, size_t start, size_t end, int delimite
     for (p = &argv[start], i=start; *p && i < end; ++p, ++i) {
         str_len += strlen(*p) + 1;
     }
+    if (0 == str_len) {
+        return strdup("");
+    }
 
     /* Allocate the string. */
-
     if (NULL == (str = (char*) malloc(str_len)))
         return NULL;
 
diff --git a/parsec/utils/output.c b/parsec/utils/output.c
index 44d8d2044..67a27a715 100644
--- a/parsec/utils/output.c
+++ b/parsec/utils/output.c
@@ -568,6 +568,8 @@ static int do_open(int output_id, parsec_output_stream_t * lds)
             parsec_atomic_unlock(&mutex);
             return PARSEC_ERR_OUT_OF_RESOURCE;
         }
+        info[i].ldi_used = true;
+        parsec_atomic_unlock(&mutex);
     }
 
     /* Otherwise, we're reopening, so we need to free all previous
@@ -575,6 +577,7 @@ static int do_open(int output_id, parsec_output_stream_t * lds)
 
     else {
         free_descriptor(output_id);
+        info[output_id].ldi_used = true;
         i = output_id;
     }
 
@@ -587,10 +590,6 @@ static int do_open(int output_id, parsec_output_stream_t * lds)
 
     /* Got a stream -- now initialize it and open relevant outputs */
 
-    info[i].ldi_used = true;
-    if (-1 == output_id) {
-        parsec_atomic_unlock(&mutex);
-    }
     info[i].ldi_enabled = lds->lds_is_debugging ?
 #if defined(PARSEC_DEBUG)
     true : true;
@@ -702,17 +701,10 @@ static int open_file(int i)
         if (NULL == filename) {
             return PARSEC_ERR_OUT_OF_RESOURCE;
         }
-        strncpy(filename, output_dir, MAXPATHLEN);
-        strcat(filename, "/");
-        if (NULL != output_prefix) {
-            strcat(filename, output_prefix);
-        }
-        if (info[i].ldi_file_suffix != NULL) {
-            strcat(filename, info[i].ldi_file_suffix);
-        } else {
-            info[i].ldi_file_suffix = NULL;
-            strcat(filename, "output.txt");
-        }
+        snprintf(filename, MAXPATHLEN, "%s/%s%s",
+                 output_dir,
+                 (NULL != output_prefix) ? output_prefix : "",
+                 (NULL != info[i].ldi_file_suffix) ? info[i].ldi_file_suffix : "output.txt");
         flags = O_CREAT | O_RDWR;
         if (!info[i].ldi_file_want_append) {
             flags |= O_TRUNC;
@@ -737,7 +729,6 @@ static int open_file(int i)
            return PARSEC_ERROR;
         }
 #endif
-
     }
 
     /* Return successfully even if the session dir did not exist yet;
diff --git a/tests/class/future.c b/tests/class/future.c
index 2a33839e0..07d76d6ff 100644
--- a/tests/class/future.c
+++ b/tests/class/future.c
@@ -78,8 +78,8 @@ static void usage(const char *name, const char *msg)
             "Usage: \n"
             "   %s [-c cores|-n ncopy|-h]\n"
             " where\n"
-            "   -c cores:   cores (integer >0) defines the number of cores to test, even number (default %d) \n"
-            "   -n ncopy:   ncopy (integer >0) defines the number of copies of test (default %u)\n",
+            "   -c cores:   cores (integer > 0) defines the number of cores to test, even number (default %d) \n"
+            "   -n ncopy:   ncopy (integer > 0) defines the number of copies of test (default %u)\n",
             name,
             cores,
             ncopy);
diff --git a/tests/class/future_datacopy.c b/tests/class/future_datacopy.c
index 7e941ed48..f82fd945b 100644
--- a/tests/class/future_datacopy.c
+++ b/tests/class/future_datacopy.c
@@ -162,35 +162,34 @@ int main(int argc, char* argv[])
                 break;
         }
     }
-    
+
     printf("running with %d cores and %d copies\n", cores, ncopy);
     threads = calloc(sizeof(pthread_t), cores);
 
     fut_array = malloc(ncopy*sizeof(parsec_datacopy_future_t*));
     data = malloc(cores*ncopy*sizeof(int));
     int *ids = malloc(cores*sizeof(int));
-    
 
     data_check_out = malloc(ncopy*sizeof(int**));
     for(i=0; i< ncopy; i++){
         data_check_out[i] = malloc(cores*sizeof(int*));
         data[i] = i;
-        data_in = malloc(cores*sizeof(int*));
+        data_in = malloc(cores*sizeof(int));
         *data_in = data[i];
         fut_array[i] = PARSEC_OBJ_NEW(parsec_datacopy_future_t);
-        parsec_future_init( fut_array[i], 
-                            cb_fulfill, 
+        parsec_future_init( fut_array[i],
+                            cb_fulfill,
                             data_in,
                             cb_match,
                             data_in,
-                            cb_cleanup); 
+                            cb_cleanup);
     }
 
     for(i=0; i< cores; i++){
         ids[i] = i;
         pthread_create(&threads[i], NULL, do_test_no_nested, &ids[i]);
     }
- 
+
     for(i=0; i< cores; i++){
         flag += pthread_join(threads[i], &retval);
     }
@@ -199,7 +198,7 @@ int main(int argc, char* argv[])
     for(i=0; i< ncopy; i++){
         for(j=1; j< cores; j++){
             if( data_check_out[i][j-1] != data_check_out[i][j] ){
-                flag = 1; 
+                flag = 1;
                 break;
             }
         }
@@ -212,22 +211,22 @@ int main(int argc, char* argv[])
 
     for(i=0; i< ncopy; i++){
         data[i] = i;
-        data_in = malloc(cores*sizeof(int*));
+        data_in = malloc(cores*sizeof(int));
         *data_in = data[i];
         fut_array[i] = PARSEC_OBJ_NEW(parsec_datacopy_future_t);
-        parsec_future_init( fut_array[i], 
-                            cb_fulfill, 
+        parsec_future_init( fut_array[i],
+                            cb_fulfill,
                             data_in,
                             cb_match,
                             data_in,
-                            cb_cleanup); 
+                            cb_cleanup);
     }
 
     for(i=0; i< cores; i++){
         ids[i] = i;
         pthread_create(&threads[i], NULL, do_test_nested, &ids[i]);
     }
- 
+
     for(i=0; i< cores; i++){
         flag += pthread_join(threads[i], &retval);
     }
diff --git a/tests/dsl/dtd/dtd_test_simple_gemm.c b/tests/dsl/dtd/dtd_test_simple_gemm.c
index 222dd8418..e592cb0ef 100644
--- a/tests/dsl/dtd/dtd_test_simple_gemm.c
+++ b/tests/dsl/dtd/dtd_test_simple_gemm.c
@@ -384,10 +384,10 @@ static void *create_cublas_handle(void *obj, void *p)
 
 static void destroy_one_on_device(void *_h, void *_n)
 {
+    (void)_h;
 #if defined(PARSEC_HAVE_DEV_CUDA_SUPPORT)
     cudaFree(_h);
 #endif
-    (void)_h;
     (void)_n;
 }
 
diff --git a/tests/dsl/ptg/user-defined-functions/main.c b/tests/dsl/ptg/user-defined-functions/main.c
index 9eea1c948..c78594f80 100644
--- a/tests/dsl/ptg/user-defined-functions/main.c
+++ b/tests/dsl/ptg/user-defined-functions/main.c
@@ -60,12 +60,24 @@ int main(int argc, char *argv[])
         switch(c) {
         case 'P':
             P = atoi(optarg);
+            if( P <= 0 ) {
+                fprintf(stderr, "The process grid P must be >= 0 (provided %d)\n", P);
+                exit(-1);
+            }
             break;
         case 'm':
             MB = atoi(optarg);
+            if( MB <= 0 ) {
+                fprintf(stderr, "MB must be >= 0 (provided %d)\n", MB);
+                exit(-1);
+            }
             break;
         case 'n':
             NB = atoi(optarg);
+            if( NB <= 0 ) {
+                fprintf(stderr, "NB must be >= 0 (provided %d)\n", NB);
+                exit(-1);
+            }
             break;
         case 'M':
             M = atoi(optarg);
diff --git a/tests/runtime/cuda/stage_main.c b/tests/runtime/cuda/stage_main.c
index b34c7e495..9056f80d7 100644
--- a/tests/runtime/cuda/stage_main.c
+++ b/tests/runtime/cuda/stage_main.c
@@ -14,7 +14,6 @@ int main(int argc, char *argv[])
 {
     parsec_context_t *parsec = NULL;
     parsec_taskpool_t *tp;
-    int i;
     int size = 1;
     int rank = 0;
     int M;

From fc062b8b852ae4ea20f338410ab51b7647955e39 Mon Sep 17 00:00:00 2001
From: George Bosilca <bosilca@icl.utk.edu>
Date: Fri, 2 Feb 2024 04:12:39 +0000
Subject: [PATCH 2/9] Initialize the ht_item.

This is only used by the DTD interface, but it needs to be completely
initialized in all cases.

Signed-off-by: George Bosilca <bosilca@icl.utk.edu>
---
 parsec/data_dist/matrix/matrixtypes.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/parsec/data_dist/matrix/matrixtypes.c b/parsec/data_dist/matrix/matrixtypes.c
index 27a9775be..f7bb59278 100644
--- a/parsec/data_dist/matrix/matrixtypes.c
+++ b/parsec/data_dist/matrix/matrixtypes.c
@@ -257,7 +257,9 @@ int parsec_add2arena(parsec_arena_datatype_t *adt, parsec_datatype_t oldtype,
     if( PARSEC_SUCCESS != rc ) {
         return rc;
     }
-
+    adt->ht_item.next_item = NULL;  /* keep Coverity happy */
+    adt->ht_item.hash64    = 0;  /* keep Coverity happy */
+    adt->ht_item.key       = 0;  /* keep Coverity happy */
     return PARSEC_SUCCESS;
 }
 

From 538dea3195332d5e6adc43b623c359bf322438c2 Mon Sep 17 00:00:00 2001
From: George Bosilca <bosilca@icl.utk.edu>
Date: Fri, 2 Feb 2024 04:13:27 +0000
Subject: [PATCH 3/9] terminate string

Signed-off-by: George Bosilca <bosilca@icl.utk.edu>
---
 parsec/interfaces/ptg/ptg-compiler/jdf_unparse.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/parsec/interfaces/ptg/ptg-compiler/jdf_unparse.c b/parsec/interfaces/ptg/ptg-compiler/jdf_unparse.c
index 44ba471ef..3ef647630 100644
--- a/parsec/interfaces/ptg/ptg-compiler/jdf_unparse.c
+++ b/parsec/interfaces/ptg/ptg-compiler/jdf_unparse.c
@@ -234,7 +234,7 @@ static int jdf_call_unparse(const jdf_call_t *call, FILE *out)
 static int jdf_datatransfer_type_unparse(jdf_datatransfer_type_t dt, FILE *out)
 {
     int err = 0;
-    char start[1] = "[";
+    char start[2] = "[";
 
     if( (JDF_STRING == dt.type->op) || (JDF_VAR == dt.type->op) ) {
         if( strcmp(dt.type->jdf_var, "DEFAULT") ) {

From d4797c53686f0df447244b24e0db66a914854e46 Mon Sep 17 00:00:00 2001
From: Aurelien Bouteiller <bouteill@icl.utk.edu>
Date: Wed, 7 Feb 2024 13:10:03 -0500
Subject: [PATCH 4/9] Do not overwrite the ht_index in the adt during
 redistribute_dtd

Signed-off-by: Aurelien Bouteiller <bouteill@icl.utk.edu>
---
 parsec/data_dist/matrix/matrixtypes.c                   | 3 ---
 parsec/data_dist/matrix/redistribute/redistribute_dtd.c | 2 ++
 parsec/interfaces/dtd/insert_function.c                 | 2 ++
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/parsec/data_dist/matrix/matrixtypes.c b/parsec/data_dist/matrix/matrixtypes.c
index f7bb59278..52a299583 100644
--- a/parsec/data_dist/matrix/matrixtypes.c
+++ b/parsec/data_dist/matrix/matrixtypes.c
@@ -257,9 +257,6 @@ int parsec_add2arena(parsec_arena_datatype_t *adt, parsec_datatype_t oldtype,
     if( PARSEC_SUCCESS != rc ) {
         return rc;
     }
-    adt->ht_item.next_item = NULL;  /* keep Coverity happy */
-    adt->ht_item.hash64    = 0;  /* keep Coverity happy */
-    adt->ht_item.key       = 0;  /* keep Coverity happy */
     return PARSEC_SUCCESS;
 }
 
diff --git a/parsec/data_dist/matrix/redistribute/redistribute_dtd.c b/parsec/data_dist/matrix/redistribute/redistribute_dtd.c
index 16ad30c4a..3a2e3db60 100644
--- a/parsec/data_dist/matrix/redistribute/redistribute_dtd.c
+++ b/parsec/data_dist/matrix/redistribute/redistribute_dtd.c
@@ -424,10 +424,12 @@ parsec_redistribute_New_dtd(parsec_context_t *parsec,
 
     /* Cleaning data arrays we allocated for communication */
     adt = parsec_dtd_get_arena_datatype(parsec, SOURCE);
+    assert(NULL != adt);
     parsec_type_free(&adt->opaque_dtt);
     PARSEC_OBJ_RELEASE(adt->arena);
     parsec_dtd_destroy_arena_datatype(parsec, SOURCE);
     adt = parsec_dtd_get_arena_datatype(parsec, TARGET);
+    assert(NULL != adt);
     parsec_type_free(&adt->opaque_dtt);
     PARSEC_OBJ_RELEASE(adt->arena);
     parsec_dtd_destroy_arena_datatype(parsec, TARGET);
diff --git a/parsec/interfaces/dtd/insert_function.c b/parsec/interfaces/dtd/insert_function.c
index eeea29fff..69014cacc 100644
--- a/parsec/interfaces/dtd/insert_function.c
+++ b/parsec/interfaces/dtd/insert_function.c
@@ -3495,6 +3495,8 @@ parsec_arena_datatype_t *parsec_dtd_create_arena_datatype(parsec_context_t *ctx,
     if(NULL == new_adt)
         return NULL;
     new_adt->ht_item.key = my_id;
+    new_adt->ht_item.next_item = NULL;  /* keep Coverity happy */
+    new_adt->ht_item.hash64    = 0;  /* keep Coverity happy */
     parsec_hash_table_nolock_insert(&ctx->dtd_arena_datatypes_hash_table, &new_adt->ht_item);
     *id = my_id;
     return new_adt;

From b33263f2f5991bbdc3b84f13d00931db7c8a6782 Mon Sep 17 00:00:00 2001
From: Aurelien Bouteiller <bouteill@icl.utk.edu>
Date: Mon, 15 Apr 2024 14:58:05 -0400
Subject: [PATCH 5/9] Move the initialization of adt fields to adt_construct

---
 parsec/data_dist/matrix/matrixtypes.c   | 5 ++++-
 parsec/interfaces/dtd/insert_function.c | 6 +++---
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/parsec/data_dist/matrix/matrixtypes.c b/parsec/data_dist/matrix/matrixtypes.c
index 52a299583..0e93d37d7 100644
--- a/parsec/data_dist/matrix/matrixtypes.c
+++ b/parsec/data_dist/matrix/matrixtypes.c
@@ -27,7 +27,10 @@ int parsec_arena_datatype_construct(parsec_arena_datatype_t *adt,
     adt->arena = PARSEC_OBJ_NEW(parsec_arena_t);
     parsec_arena_construct(adt->arena, elem_size,
                            alignment);
-    adt->opaque_dtt = opaque_dtt;
+    adt->ht_item.next_item  = NULL; /* keep Coverity happy */
+    adt->ht_item.hash64     = 0;    /* keep Coverity happy */
+    adt->ht_item.key        = 0;    /* keep Coverity happy */
+    adt->opaque_dtt         = opaque_dtt;
     return PARSEC_SUCCESS;
 }
 
diff --git a/parsec/interfaces/dtd/insert_function.c b/parsec/interfaces/dtd/insert_function.c
index 68e82bb3f..fc609500f 100644
--- a/parsec/interfaces/dtd/insert_function.c
+++ b/parsec/interfaces/dtd/insert_function.c
@@ -3463,12 +3463,12 @@ parsec_arena_datatype_t *parsec_dtd_create_arena_datatype(parsec_context_t *ctx,
     if(NULL != new_adt)
         return NULL;
 #endif
-    new_adt = calloc(sizeof(parsec_arena_datatype_t), 1);
+    new_adt = calloc(1, sizeof(parsec_arena_datatype_t));
     if(NULL == new_adt)
         return NULL;
+    /* all other fields are zeroed at that point, no need to initialize, will
+     * complete initialization during parsec_add2arena */
     new_adt->ht_item.key = my_id;
-    new_adt->ht_item.next_item = NULL;  /* keep Coverity happy */
-    new_adt->ht_item.hash64    = 0;  /* keep Coverity happy */
     parsec_hash_table_nolock_insert(&ctx->dtd_arena_datatypes_hash_table, &new_adt->ht_item);
     *id = my_id;
     return new_adt;

From 43123453a9e42f3fdf27987b8334625d5838faf2 Mon Sep 17 00:00:00 2001
From: Aurelien Bouteiller <bouteill@icl.utk.edu>
Date: Mon, 22 Apr 2024 17:49:06 -0400
Subject: [PATCH 6/9] api: change arena datatype constructors and destructors
 to be symetrical and avoid memory leakage in certain cases

---
 .../build_with_parsec/dtd_test_allreduce.c    |  14 +-
 contrib/renaming/README                       |  65 ---------
 contrib/renaming/README.md                    | 135 ++++++++++++++++++
 contrib/renaming/rename.sed                   |   9 +-
 parsec/data.c                                 |  38 +++++
 parsec/data.h                                 |  13 ++
 parsec/data_dist/matrix/apply_wrapper.c       |  24 ++--
 parsec/data_dist/matrix/deprecated/matrix.h   |  56 ++++++--
 parsec/data_dist/matrix/matrix.h              |  56 +++++---
 parsec/data_dist/matrix/matrixtypes.c         |  54 +++----
 .../matrix/redistribute/redistribute_dtd.c    |  34 ++---
 .../redistribute/redistribute_wrapper.c       |  34 ++---
 parsec/interfaces/dtd/insert_function.c       |  42 +++---
 parsec/interfaces/dtd/insert_function.h       |  53 ++++---
 parsec/interfaces/ptg/ptg-compiler/jdf2c.c    |  17 ++-
 parsec/parsec_internal.h                      |   6 +-
 tests/api/taskpool_wait/main.c                |  11 +-
 tests/dsl/dtd/dtd_test_allreduce.c            |  12 +-
 tests/dsl/dtd/dtd_test_broadcast.c            |  12 +-
 tests/dsl/dtd/dtd_test_cuda_task_insert.c     |  41 +++---
 tests/dsl/dtd/dtd_test_data_flush.c           |  25 ++--
 .../dsl/dtd/dtd_test_explicit_task_creation.c |  11 +-
 tests/dsl/dtd/dtd_test_hierarchy.c            |  12 +-
 .../dsl/dtd/dtd_test_insert_task_interface.c  |  12 +-
 tests/dsl/dtd/dtd_test_interleave_actions.c   |  22 ++-
 tests/dsl/dtd/dtd_test_new_tile.c             |  11 +-
 tests/dsl/dtd/dtd_test_pingpong.c             |  20 +--
 tests/dsl/dtd/dtd_test_reduce.c               |  12 +-
 tests/dsl/dtd/dtd_test_simple_gemm.c          |   9 +-
 tests/dsl/dtd/dtd_test_task_placement.c       |  12 +-
 tests/dsl/dtd/dtd_test_template_counter.c     |  12 +-
 tests/dsl/dtd/dtd_test_untie.c                |  12 +-
 tests/dsl/dtd/dtd_test_war.c                  |   9 +-
 tests/dsl/ptg/recursive.jdf                   |   7 +-
 tests/dsl/ptg/startup.jdf                     |   1 -
 tests/runtime/multichain.jdf                  |   5 +-
 36 files changed, 523 insertions(+), 395 deletions(-)
 delete mode 100644 contrib/renaming/README
 create mode 100644 contrib/renaming/README.md

diff --git a/contrib/build_with_parsec/dtd_test_allreduce.c b/contrib/build_with_parsec/dtd_test_allreduce.c
index 1e671c395..904b4ea85 100644
--- a/contrib/build_with_parsec/dtd_test_allreduce.c
+++ b/contrib/build_with_parsec/dtd_test_allreduce.c
@@ -148,13 +148,13 @@ int main(int argc, char **argv)
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new(  );
 #if PARSEC_VERSION_MAJOR < 4
     parsec_add2arena_rect(&parsec_dtd_arenas_datatypes[TILE_FULL],
+                          parsec_datatype_int32_t, nb, 1, nb);
 #else
-    parsec_arena_datatype_t *adt;
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena_rect( adt,
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype);
+    parsec_matrix_adt_construct_rect(adt,
+                                     parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 #endif
-                                 parsec_datatype_int32_t,
-                                 nb, 1, nb);
 
     parsec_matrix_block_cyclic_t *m = (parsec_matrix_block_cyclic_t*)malloc(sizeof(parsec_matrix_block_cyclic_t));
     parsec_matrix_block_cyclic_init(m, PARSEC_MATRIX_COMPLEX_DOUBLE, PARSEC_MATRIX_TILE,
@@ -235,9 +235,7 @@ int main(int argc, char **argv)
 #if PARSEC_VERSION_MAJOR < 4
     PARSEC_OBJ_RELEASE(parsec_dtd_arenas_datatypes[0].arena);
 #else
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
 #endif
     parsec_dtd_data_collection_fini( A );
     parsec_tiled_matrix_destroy_data(dcA);
diff --git a/contrib/renaming/README b/contrib/renaming/README
deleted file mode 100644
index 9c26b0396..000000000
--- a/contrib/renaming/README
+++ /dev/null
@@ -1,65 +0,0 @@
-With the 4.0 release, PaRSEC has undergone a major renaming in an effort to properly namespace symbols provided by PaRSEC.
-This will likely affect existing codes that will have to adapt to using the new symbols.
-To help with this effort, the sed script `contrib/renaming/rename.sed` is provided that can be used to apply the changes to existing source code files.
-To apply the changes, users can execute the following command:
-
-```
-find . -name "*.c" -or -name "*.h" -or -name "*.cc" -or -name "*.jdf" -or -name "*.h.in" | xargs sed -i -f $PARSEC_SOURCE_DIR/contrib/renaming/rename.sed
-```
-
-Depending on your source code, your may have to adapt the above line to apply to all relevant files.
-
-The full list of replacements can be found below:
-
-```
-# data types
-enum matrix_type -> parsec_matrix_type_t
-matrix_RealDouble -> PARSEC_MATRIX_DOUBLE
-matrix_RealFloat -> PARSEC_MATRIX_FLOAT
-matrix_Integer -> PARSEC_MATRIX_INTEGER
-matrix_Byte -> PARSEC_MATRIX_BYTE
-matrix_ComplexFloat -> PARSEC_MATRIX_COMPLEX_FLOAT
-matrix_ComplexDouble -> PARSEC_MATRIX_COMPLEX_DOUBLE
-
-# storage
-enum matrix_storage -> parsec_matrix_storage_t
-matrix_Lapack -> PARSEC_MATRIX_LAPACK
-matrix_Tile -> PARSEC_MATRIX_TILE
-
-# matrix shapes
-enum matrix_uplo -> parsec_matrix_uplo_t
-matrix_UpperLower -> PARSEC_MATRIX_FULL
-matrix_Upper -> PARSEC_MATRIX_UPPER
-matrix_Lower -> PARSEC_MATRIX_LOWER
-
-# vector shapes
-enum vector_distrib -> parsec_vector_two_dim_cyclic_distrib_t
-matrix_VectorRow -> PARSEC_VECTOR_DISTRIB_ROW
-matrix_VectorCol -> PARSEC_VECTOR_DISTRIB_COL
-matrix_VectorDiag -> PARSEC_VECTOR_DISTRIB_DIAG
-
-# matrix implementations
-parsec_tiled_matrix_dc* -> parsec_tiled_matrix*
-sym_two_dim_block_cyclic* -> parsec_matrix_sym_block_cyclic*
-two_dim_block_cyclic* -> parsec_matrix_block_cyclic*
-two_dim_tabular_* -> parsec_matrix_tabular_*
-two_dim_td_table_clone_table_structure -> parsec_matrix_tabular_clone_table_structure
-
-# symbols in matrix.h
-tiled_matrix_submatrix -> parsec_tiled_matrix_submatrix
-parsec_matrix_create_data -> parsec_tiled_matrix_create_data
-parsec_matrix_add2arena -> parsec_add2arena
-parsec_matrix_del2arena -> parsec_del2arena
-parsec_matrix_data_* -> parsec_tiled_matrix_data_*
-
-
-# vector
-vector_two_dim_cyclic_* -> parsec_vector_two_dim_cyclic*
-
-# 2D grid
-grid_2Dcyclic_* -> parsec_grid_2Dcyclic_*
-
-# matrix ops
-tiled_matrix_unary_op_t -> parsec_tiled_matrix_unary_op_t
-tiled_matrix_binary_op_t -> parsec_tiled_matrix_binary_op_t
-```
diff --git a/contrib/renaming/README.md b/contrib/renaming/README.md
new file mode 100644
index 000000000..fdfa28aae
--- /dev/null
+++ b/contrib/renaming/README.md
@@ -0,0 +1,135 @@
+Changes that can be automated when updating from PaRSEC API v3.x to PaRSEC API v4.x
+===================================================================================
+
+With the 4.0 release, PaRSEC has undergone a major renaming in an effort to properly namespace symbols provided by PaRSEC.
+This will likely affect existing codes that will have to adapt to using the new symbols.
+To help with this effort, the sed script `contrib/renaming/rename.sed` is provided that can be used to apply the changes to existing source code files.
+To apply the changes, users can execute the following command:
+
+```sh
+find . -name "*.c" -or -name "*.h" -or -name "*.cc" -or -name "*.jdf" -or -name "*.h.in" | xargs sed -i -f $PARSEC_SOURCE_DIR/contrib/renaming/rename.sed
+```
+
+Depending on your source code, your may have to adapt the above line to apply to all relevant files.
+
+The full list of replacements can be found below:
+
+```sh
+# data types
+enum matrix_type -> parsec_matrix_type_t
+matrix_RealDouble -> PARSEC_MATRIX_DOUBLE
+matrix_RealFloat -> PARSEC_MATRIX_FLOAT
+matrix_Integer -> PARSEC_MATRIX_INTEGER
+matrix_Byte -> PARSEC_MATRIX_BYTE
+matrix_ComplexFloat -> PARSEC_MATRIX_COMPLEX_FLOAT
+matrix_ComplexDouble -> PARSEC_MATRIX_COMPLEX_DOUBLE
+
+# storage
+enum matrix_storage -> parsec_matrix_storage_t
+matrix_Lapack -> PARSEC_MATRIX_LAPACK
+matrix_Tile -> PARSEC_MATRIX_TILE
+
+# matrix shapes
+enum matrix_uplo -> parsec_matrix_uplo_t
+matrix_UpperLower -> PARSEC_MATRIX_FULL
+matrix_Upper -> PARSEC_MATRIX_UPPER
+matrix_Lower -> PARSEC_MATRIX_LOWER
+
+# vector shapes
+enum vector_distrib -> parsec_vector_two_dim_cyclic_distrib_t
+matrix_VectorRow -> PARSEC_VECTOR_DISTRIB_ROW
+matrix_VectorCol -> PARSEC_VECTOR_DISTRIB_COL
+matrix_VectorDiag -> PARSEC_VECTOR_DISTRIB_DIAG
+
+# matrix implementations
+parsec_tiled_matrix_dc* -> parsec_tiled_matrix*
+sym_two_dim_block_cyclic* -> parsec_matrix_sym_block_cyclic*
+two_dim_block_cyclic* -> parsec_matrix_block_cyclic*
+two_dim_tabular_* -> parsec_matrix_tabular_*
+two_dim_td_table_clone_table_structure -> parsec_matrix_tabular_clone_table_structure
+
+# symbols in matrix.h
+tiled_matrix_submatrix -> parsec_tiled_matrix_submatrix
+parsec_matrix_create_data -> parsec_tiled_matrix_create_data
+parsec_matrix_add2arena -> parsec_matrix_adt_construct
+parsec_add2arena -> parsec_matrix_adt_construct
+parsec_matrix_del2arena -> parsec_matrix_arena_datatype_destruct_free_type
+parsec_del2arena -> parsec_matrix_arena_datatype_destruct_free_type
+parsec_matrix_data_* -> parsec_tiled_matrix_data_*
+
+# vector
+vector_two_dim_cyclic_* -> parsec_vector_two_dim_cyclic*
+
+# 2D grid
+grid_2Dcyclic_* -> parsec_grid_2Dcyclic_*
+
+# matrix ops
+tiled_matrix_unary_op_t -> parsec_tiled_matrix_unary_op_t
+tiled_matrix_binary_op_t -> parsec_tiled_matrix_binary_op_t
+
+# arena_datatype contructors/destructors
+parsec_dtd_destroy_arena_datatype -> parsec_dtd_free_arena_datatype
+```
+
+Changes that are not automated when updating between PaRSEC API v3.x and v4.x
+=============================================================================
+
+DTD initialization of arena datatypes has changed to avoid memory leakage.
+--------------------------------------------------------------------------
+
+We show below some typical conversions. More can be found by examining the commit that modified this line.
+
+This snippet extracted from `contrib/build_with_parsec/dtd_text_allreduce.c` shows both the v3.x and v4.x canonical snippet:
+```c
+    // v3.x to v4.0 release: DTD arena_datatype allocation and initialization
+#if PARSEC_VERSION_MAJOR < 4
+    parsec_add2arena_rect(&parsec_dtd_arenas_datatypes[TILE_FULL],
+        parsec_datatype_int32_t, nb, 1, nb);
+#else
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype);
+    parsec_matrix_adt_construct_rect(adt,
+        parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
+#endif
+```
+
+If you had updated to pre-release v4.x, you may have to do the following change:
+```diff
+     // v4.x pre-release to v4.0 release: DTD arena_datatype allocation and initialization
+-    parsec_arena_datatype_t *adt;
+-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
+-    parsec_add2arena_rect( adt,
+-       parsec_datatype_int32_t, nb, 1, nb);
++    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype);
++    parsec_matrix_adt_construct_rect(adt,
++       parsec_datatype_int32_t, nb, 1, nb);
++    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
+```
+
+The cleanup of DTD allocated arena datatypes can be significantly simplified:
+```diff
+     // v3.x to v4.0: DTD arena_datatype cleanup
+-    adt = parsec_dtd_get_arena_datatype(parsec, TILE_FULL);
+-    assert(NULL != adt);
+-    parsec_type_free(&adt->opaque_dtt);
+-    PARSEC_OBJ_RELEASE(adt->arena);
+-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
++    adt = parsec_dtd_detach_arena_datatype(parsec, TILE_FULL);
++    assert(NULL != adt);
++    parsec_type_free(&adt->opaque_dtt);
++    PARSEC_OBJ_RELEASE(adt);
+```
+
+This snippet repeated itself often enough that we have a shorthand for detaching the adt,
+clearing the type, and releasing the adt all in one go:
+```diff
+     // equivalent to the new code above
++    parsec_dtd_free_arena_datatype(parsec, DATA);
+```
+PTG use of del2arena
+--------------------
+
+In some PTG wrappers, v3.x canonical approach would have a `parsec_del2arena(adt)`
+call followed by `PARSEC_OBJ_RELEASE(adt->arena)`.
+
+in v4.x the `parsec_arena_datatype_t` destructor recursively destructs the internal members of the `adt`. Hence the `PARSEC_OBJ_RELEASE(adt->arena)` is not necessary anymore. (legacy code that still call the explicit release remain correct, the adt destructor will care not to cause a double free).
diff --git a/contrib/renaming/rename.sed b/contrib/renaming/rename.sed
index f0b507b6c..440397186 100644
--- a/contrib/renaming/rename.sed
+++ b/contrib/renaming/rename.sed
@@ -33,8 +33,10 @@ s/two_dim_td_table_clone_table_structure/parsec_matrix_tabular_clone_table_struc
 # symbols in matrix.h
 s/tiled_matrix_submatrix/parsec_tiled_matrix_submatrix/g
 s/parsec_matrix_create_data/parsec_tiled_matrix_create_data/g
-s/parsec_matrix_add2arena/parsec_add2arena/g
-s/parsec_matrix_del2arena/parsec_del2arena/g
+s/parsec_matrix_add2arena/parsec_matrix_adt_construct/g
+s/parsec_add2arena/parsec_matrix_adt_construct/g
+s/parsec_matrix_del2arena/parsec_matrix_arena_datatype_destruct_free_type/g
+s/parsec_del2arena/parsec_matrix_arena_datatype_destruct_free_type/g
 s/parsec_matrix_data_/parsec_tiled_matrix_data_/g
 
 # vector
@@ -47,3 +49,6 @@ s/grid_2Dcyclic_/parsec_grid_2Dcyclic_/g
 # matrix ops
 s/tiled_matrix_unary_op_t/parsec_tiled_matrix_unary_op_t/g
 s/tiled_matrix_binary_op_t/parsec_tiled_matrix_binary_op_t/g
+
+# DTD arena datatypes
+s/parsec_dtd_destroy_arena_datatype/parsec_dtd_free_arena_datatype/g
diff --git a/parsec/data.c b/parsec/data.c
index a08c9d5d6..48013b68f 100644
--- a/parsec/data.c
+++ b/parsec/data.c
@@ -560,3 +560,41 @@ parsec_data_destroy( parsec_data_t *data )
 #endif
     PARSEC_OBJ_RELEASE(data);
 }
+
+
+/**
+ * Arena-datatype management.
+ */
+
+/* adt constructor is split in two stages: when the adt is constructed
+ * with OBJ_CONSTRUCT (or allocated with OBJ_NEW), we initialize the
+ * adt object. The user code must then call the parameterized constructor
+ * (below) that attaches the datatype and creates the associated arena.
+ *
+ * When the adt object is destructed (or released), the implicit destructor
+ * releases all resources created by both split constructor stages.
+ *
+ * Freeing the type is not part of the implicit destructor.
+ */
+int parsec_arena_datatype_construct(parsec_arena_datatype_t *adt,
+                                    size_t elem_size,
+                                    size_t alignment,
+                                    parsec_datatype_t opaque_dtt) {
+    adt->arena = PARSEC_OBJ_NEW(parsec_arena_t);
+    parsec_arena_construct(adt->arena, elem_size,
+                           alignment);
+    adt->ht_item.next_item  = NULL; /* keep Coverity happy */
+    adt->ht_item.hash64     = 0;    /* keep Coverity happy */
+    adt->ht_item.key        = 0;    /* keep Coverity happy */
+    adt->opaque_dtt         = opaque_dtt;
+    return PARSEC_SUCCESS;
+}
+
+static void parsec_arena_datatype_destruct(parsec_object_t *obj) {
+    parsec_arena_datatype_t *adt = (parsec_arena_datatype_t *)obj;
+    if(NULL != adt->arena) PARSEC_OBJ_RELEASE(adt->arena);
+}
+
+PARSEC_OBJ_CLASS_INSTANCE(parsec_arena_datatype_t, parsec_object_t,
+                          NULL,
+                          parsec_arena_datatype_destruct);
diff --git a/parsec/data.h b/parsec/data.h
index f21c2918b..0331ab908 100644
--- a/parsec/data.h
+++ b/parsec/data.h
@@ -144,6 +144,19 @@ parsec_data_create_with_type( parsec_data_collection_t *desc,
 PARSEC_DECLSPEC void
 parsec_data_destroy( parsec_data_t *holder );
 
+/**
+ * Construct an arena datatype. Because the parameters cannot be known
+ * when OBJ_NEW is called, the construct must be called explicitely
+ * by the user.
+ */
+PARSEC_DECLSPEC int
+parsec_arena_datatype_construct( parsec_arena_datatype_t *adt,
+                                 size_t elem_size,
+                                 size_t alignment,
+                                 parsec_datatype_t opaque_dtt);
+
+PARSEC_OBJ_CLASS_DECLARATION(parsec_arena_datatype_t);
+
 END_C_DECLS
 
 /** @} */
diff --git a/parsec/data_dist/matrix/apply_wrapper.c b/parsec/data_dist/matrix/apply_wrapper.c
index f336017d3..d6b8ef100 100644
--- a/parsec/data_dist/matrix/apply_wrapper.c
+++ b/parsec/data_dist/matrix/apply_wrapper.c
@@ -69,27 +69,25 @@ parsec_apply_New( parsec_matrix_uplo_t uplo,
 
     switch( A->mtype ) {
     case PARSEC_MATRIX_COMPLEX_DOUBLE    :
-        parsec_add2arena( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
-                          parsec_datatype_double_complex_t,
-                          PARSEC_MATRIX_FULL, 1, A->mb, A->mb, A->mb, PARSEC_ARENA_ALIGNMENT_SSE, -1);
+        parsec_matrix_adt_construct_tile( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
+                          parsec_datatype_double_complex_t, A->mb);
         break;
     case PARSEC_MATRIX_COMPLEX_FLOAT     :
-        parsec_add2arena( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
-                          parsec_datatype_complex_t,
-                          PARSEC_MATRIX_FULL, 1, A->mb, A->mb, A->mb, PARSEC_ARENA_ALIGNMENT_SSE, -1);
+        parsec_matrix_adt_construct_tile( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
+                          parsec_datatype_complex_t, A->mb);
         break;
     case PARSEC_MATRIX_DOUBLE       :
-        parsec_add2arena( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX], parsec_datatype_double_t,
-                          PARSEC_MATRIX_FULL, 1, A->mb, A->mb, A->mb, PARSEC_ARENA_ALIGNMENT_SSE, -1);
+        parsec_matrix_adt_construct_tile( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
+                          parsec_datatype_double_t, A->mb);
         break;
     case PARSEC_MATRIX_FLOAT        :
-        parsec_add2arena( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX], parsec_datatype_float_t,
-                          PARSEC_MATRIX_FULL, 1, A->mb, A->mb, A->mb, PARSEC_ARENA_ALIGNMENT_SSE, -1);
+        parsec_matrix_adt_construct_tile( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
+                          parsec_datatype_float_t, A->mb);
         break;
     case PARSEC_MATRIX_INTEGER          :
     default:
-        parsec_add2arena( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX], parsec_datatype_int_t,
-                          PARSEC_MATRIX_FULL, 1, A->mb, A->mb, A->mb, PARSEC_ARENA_ALIGNMENT_SSE, -1);
+        parsec_matrix_adt_construct_tile( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
+                          parsec_datatype_int_t, A->mb);
     }
     return (parsec_taskpool_t*)parsec_app;
 }
@@ -116,7 +114,7 @@ parsec_apply_Destruct( parsec_taskpool_t *tp )
         free( omap->_g_op_args );
     }
 
-    parsec_del2arena( &omap->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX] );
+    parsec_matrix_arena_datatype_destruct_free_type( &omap->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX] );
 
     parsec_taskpool_free(tp);
 }
diff --git a/parsec/data_dist/matrix/deprecated/matrix.h b/parsec/data_dist/matrix/deprecated/matrix.h
index 9c20b8a06..d8101f07d 100644
--- a/parsec/data_dist/matrix/deprecated/matrix.h
+++ b/parsec/data_dist/matrix/deprecated/matrix.h
@@ -139,28 +139,25 @@ int parsec_matrix_add2arena( parsec_arena_datatype_t *adt, parsec_datatype_t old
                              parsec_matrix_uplo_t uplo, int diag,
                              unsigned int m, unsigned int n, unsigned int ld,
                              size_t alignment, int resized )
-    __parsec_attribute_deprecated__("Use parsec_add2arena");
-
+    __parsec_attribute_deprecated__("Use parsec_matrix_arena_datatype_construct_alloc_type");
 static inline
 int parsec_matrix_add2arena( parsec_arena_datatype_t *adt, parsec_datatype_t oldtype,
                              parsec_matrix_uplo_t uplo, int diag,
                              unsigned int m, unsigned int n, unsigned int ld,
-                             size_t alignment, int resized )
-{
-    return parsec_add2arena(adt, oldtype, uplo, diag, m, n, ld, alignment, resized);
+                             size_t alignment, int resized ) {
+    PARSEC_OBJ_CONSTRUCT(adt, parsec_arena_datatype_t);
+    return parsec_matrix_arena_datatype_construct_alloc_type(adt, oldtype, uplo, diag, m, n, ld, alignment, resized);
 }
 
 static inline
 int parsec_matrix_del2arena( parsec_arena_datatype_t *adt )
-    __parsec_attribute_deprecated__("Use parsec_del2arena");
-
+    __parsec_attribute_deprecated__("Use parsec_matrix_adt_destruct_free_type(adt)");
 static inline
-int parsec_matrix_del2arena( parsec_arena_datatype_t *adt )
-{
-    return parsec_del2arena(adt);
+int parsec_matrix_del2arena( parsec_arena_datatype_t *adt ) {
+    return parsec_matrix_arena_datatype_destruct_free_type(adt);
 }
 
-/* deprecated */
+/* deprecated macros */
 #define parsec_matrix_add2arena_tile( _adt_ , _oldtype_, _m_ ) \
     parsec_matrix_add2arena( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_m_), (_m_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
 
@@ -172,3 +169,40 @@ int parsec_matrix_del2arena( parsec_arena_datatype_t *adt )
 
 #define parsec_matrix_add2arena_rect( _adt_ , _oldtype_, _m_, _n_, _ld_ ) \
     parsec_matrix_add2arena( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_n_), (_ld_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
+
+/* shorthand version parsec_add2arena also deprecated */
+static inline
+int parsec_add2arena( parsec_arena_datatype_t *adt, parsec_datatype_t oldtype,
+                      parsec_matrix_uplo_t uplo, int diag,
+                      unsigned int m, unsigned int n, unsigned int ld,
+                      size_t alignment, int resized )
+    __parsec_attribute_deprecated__("Use parsec_matrix_arena_datatype_construct_alloc_type");
+static inline
+int parsec_add2arena( parsec_arena_datatype_t *adt, parsec_datatype_t oldtype,
+                      parsec_matrix_uplo_t uplo, int diag,
+                      unsigned int m, unsigned int n, unsigned int ld,
+                      size_t alignment, int resized ) {
+    PARSEC_OBJ_CONSTRUCT(adt, parsec_arena_datatype_t);
+    return parsec_matrix_arena_datatype_construct_alloc_type(adt, oldtype, uplo, diag, m, n, ld, alignment, resized);
+}
+
+static inline
+int parsec_del2arena( parsec_arena_datatype_t *adt )
+    __parsec_attribute_deprecated__("Use parsec_matrix_adt_destruct_free_type(adt)");
+static inline
+int parsec_del2arena( parsec_arena_datatype_t *adt) {
+    return parsec_matrix_arena_datatype_destruct_free_type(adt);
+}
+
+/* deprecated macros */
+#define parsec_add2arena_tile( _adt_ , _oldtype_, _m_ ) \
+    parsec_add2arena( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_m_), (_m_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
+
+#define parsec_add2arena_upper( _adt_ , _oldtype_, diag, _n_ ) \
+    parsec_add2arena( (_adt_), (_oldtype_), PARSEC_MATRIX_UPPER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
+
+#define parsec_add2arena_lower( _adt_ , _oldtype_, diag, _n_ ) \
+    parsec_add2arena( (_adt_), (_oldtype_), PARSEC_MATRIX_LOWER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
+
+#define parsec_add2arena_rect( _adt_ , _oldtype_, _m_, _n_, _ld_ ) \
+    parsec_add2arena( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_n_), (_ld_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
diff --git a/parsec/data_dist/matrix/matrix.h b/parsec/data_dist/matrix/matrix.h
index 24fe57463..1440b834c 100644
--- a/parsec/data_dist/matrix/matrix.h
+++ b/parsec/data_dist/matrix/matrix.h
@@ -324,24 +324,46 @@ int parsec_matrix_define_datatype(parsec_datatype_t *newtype, parsec_datatype_t
  * is created using the datatype extent. The alignment indicates the restrictions related
  * to the alignment of the allocated data by the arena.
  */
-int parsec_add2arena( parsec_arena_datatype_t *adt, parsec_datatype_t oldtype,
-                             parsec_matrix_uplo_t uplo, int diag,
-                             unsigned int m, unsigned int n, unsigned int ld,
-                             size_t alignment, int resized );
+int parsec_matrix_arena_datatype_construct_alloc_type(parsec_arena_datatype_t *adt,
+                                                     parsec_datatype_t oldtype,
+                                                     parsec_matrix_uplo_t uplo, int diag,
+                                                     unsigned int m, unsigned int n, unsigned int ld,
+                                                     size_t alignment, int resized);
+int parsec_matrix_arena_datatype_destruct_free_type(parsec_arena_datatype_t *adt);
+
+#define parsec_matrix_adt_construct_tile( _adt_ , _oldtype_, _m_ ) \
+    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_m_), (_m_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
+#define parsec_matrix_adt_new_tile( _adt_ , _oldtype_, _m_ ) \
+    ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
+     parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_m_), (_m_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
+     (_adt_))
+
+#define parsec_matrix_adt_construct_upper( _adt_ , _oldtype_, diag, _n_ ) \
+    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_UPPER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
+#define parsec_matrix_adt_new_upper( _adt_ , _oldtype_, diag, _n_ ) \
+    ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
+     parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_UPPER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
+     (_adt_))
+
+#define parsec_matrix_adt_construct_lower( _adt_ , _oldtype_, diag, _n_ ) \
+    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_LOWER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
+#define parsec_matrix_adt_new_lower( _adt_ , _oldtype_, diag, _n_ ) \
+    ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
+     parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_LOWER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
+     (_adt_))
+
+#define parsec_matrix_adt_construct_rect( _adt_ , _oldtype_, _m_, _n_, _ld_ ) \
+    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_n_), (_ld_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
+#define parsec_matrix_adt_new_rect( _adt_ , _oldtype_, _m_, _n_, _ld_ ) \
+    ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
+     parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_n_), (_ld_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
+     (_adt_))
+
+#define parsec_matrix_adt_free(_adt_) do {\
+    parsec_matrix_arena_datatype_destruct_free_type(_adt_); \
+    free(_adt_); \
+} while(0)
 
-int parsec_del2arena( parsec_arena_datatype_t *adt );
-
-#define parsec_add2arena_tile( _adt_ , _oldtype_, _m_ ) \
-    parsec_add2arena( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_m_), (_m_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
-
-#define parsec_add2arena_upper( _adt_ , _oldtype_, diag, _n_ ) \
-    parsec_add2arena( (_adt_), (_oldtype_), PARSEC_MATRIX_UPPER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
-
-#define parsec_add2arena_lower( _adt_ , _oldtype_, diag, _n_ ) \
-    parsec_add2arena( (_adt_), (_oldtype_), PARSEC_MATRIX_LOWER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
-
-#define parsec_add2arena_rect( _adt_ , _oldtype_, _m_, _n_, _ld_ ) \
-    parsec_add2arena( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_n_), (_ld_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
 
 /* include deprecated symbols */
 #include "parsec/data_dist/matrix/deprecated/matrix.h"
diff --git a/parsec/data_dist/matrix/matrixtypes.c b/parsec/data_dist/matrix/matrixtypes.c
index 0e93d37d7..b61ab5149 100644
--- a/parsec/data_dist/matrix/matrixtypes.c
+++ b/parsec/data_dist/matrix/matrixtypes.c
@@ -15,25 +15,6 @@
 #include <mpi.h>
 #endif
 
-/**
- * Arena-datatype management.
- */
-
-int parsec_arena_datatype_construct(parsec_arena_datatype_t *adt,
-                                   size_t elem_size,
-                                   size_t alignment,
-                                   parsec_datatype_t opaque_dtt)
-{
-    adt->arena = PARSEC_OBJ_NEW(parsec_arena_t);
-    parsec_arena_construct(adt->arena, elem_size,
-                           alignment);
-    adt->ht_item.next_item  = NULL; /* keep Coverity happy */
-    adt->ht_item.hash64     = 0;    /* keep Coverity happy */
-    adt->ht_item.key        = 0;    /* keep Coverity happy */
-    adt->opaque_dtt         = opaque_dtt;
-    return PARSEC_SUCCESS;
-}
-
 int parsec_matrix_define_contiguous( parsec_datatype_t oldtype,
                                      unsigned int nb_elem,
                                      int resized,
@@ -241,29 +222,30 @@ int parsec_matrix_define_datatype(parsec_datatype_t *newtype, parsec_datatype_t
     return PARSEC_SUCCESS;
 }
 
-int parsec_add2arena(parsec_arena_datatype_t *adt, parsec_datatype_t oldtype,
-                     parsec_matrix_uplo_t uplo, int diag,
-                     unsigned int m, unsigned int n, unsigned int ld,
-                     size_t alignment, int resized )
-{
+/**
+ * Arena-datatype management.
+ */
+int parsec_matrix_arena_datatype_construct_alloc_type(parsec_arena_datatype_t *adt,
+                                                      parsec_datatype_t oldtype,
+                                                      parsec_matrix_uplo_t uplo, int diag,
+                                                      unsigned int m, unsigned int n, unsigned int ld,
+                                                      size_t alignment, int resized) {
     ptrdiff_t extent = 0;
     int rc;
+    parsec_datatype_t newtype;
 
-    rc = parsec_matrix_define_datatype(&adt->opaque_dtt, oldtype, uplo, diag,
+    rc = parsec_matrix_define_datatype(&newtype, oldtype, uplo, diag,
                                        m, n, ld, resized, &extent);
-    if( PARSEC_SUCCESS != rc ) {
-        return rc;
-    }
+    if( PARSEC_SUCCESS != rc ) return rc;
+
+    parsec_arena_datatype_construct(adt, extent, alignment, newtype);
+    if( PARSEC_SUCCESS != rc ) return rc;
 
-    adt->arena = PARSEC_OBJ_NEW(parsec_arena_t);
-    rc = parsec_arena_construct(adt->arena, extent, alignment);
-    if( PARSEC_SUCCESS != rc ) {
-        return rc;
-    }
     return PARSEC_SUCCESS;
 }
 
-int parsec_del2arena( parsec_arena_datatype_t *adt )
-{
-    return parsec_type_free( &adt->opaque_dtt );
+int parsec_matrix_arena_datatype_destruct_free_type(parsec_arena_datatype_t *adt) {
+    parsec_type_free( &adt->opaque_dtt );
+    PARSEC_OBJ_DESTRUCT(adt);
+    return PARSEC_SUCCESS;
 }
diff --git a/parsec/data_dist/matrix/redistribute/redistribute_dtd.c b/parsec/data_dist/matrix/redistribute/redistribute_dtd.c
index 3a2e3db60..3f8900bc5 100644
--- a/parsec/data_dist/matrix/redistribute/redistribute_dtd.c
+++ b/parsec/data_dist/matrix/redistribute/redistribute_dtd.c
@@ -373,17 +373,15 @@ parsec_redistribute_New_dtd(parsec_context_t *parsec,
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
     /* Allocating data arrays to be used by comm engine */
-    adt = parsec_dtd_create_arena_datatype(parsec, &TARGET);
-    parsec_add2arena(adt,
-                     MY_TYPE, PARSEC_MATRIX_FULL,
-                     1, dcT->mb, dcT->nb, dcT->mb,
-                     PARSEC_ARENA_ALIGNMENT_SSE, -1);
-
-    adt = parsec_dtd_create_arena_datatype(parsec, &SOURCE);
-    parsec_add2arena(adt,
-                     MY_TYPE, PARSEC_MATRIX_FULL,
-                     1, dcY->mb, dcY->nb, dcY->mb,
-                     PARSEC_ARENA_ALIGNMENT_SSE, -1);
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+                     MY_TYPE, dcT->mb, dcT->nb, dcT->mb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TARGET);
+
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+                     MY_TYPE, dcY->mb, dcY->nb, dcY->mb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &SOURCE);
 
     /* Registering the handle with parsec context */
     parsec_context_add_taskpool(parsec, dtd_tp);
@@ -423,16 +421,10 @@ parsec_redistribute_New_dtd(parsec_context_t *parsec,
     parsec_taskpool_free( dtd_tp );
 
     /* Cleaning data arrays we allocated for communication */
-    adt = parsec_dtd_get_arena_datatype(parsec, SOURCE);
-    assert(NULL != adt);
-    parsec_type_free(&adt->opaque_dtt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, SOURCE);
-    adt = parsec_dtd_get_arena_datatype(parsec, TARGET);
-    assert(NULL != adt);
-    parsec_type_free(&adt->opaque_dtt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TARGET);
+    rc = parsec_dtd_free_arena_datatype(parsec, SOURCE);
+    assert(PARSEC_SUCCESS == rc);
+    rc = parsec_dtd_free_arena_datatype(parsec, TARGET);
+    assert(PARSEC_SUCCESS == rc);
 
     parsec_dtd_data_collection_fini( (parsec_data_collection_t *)dcY );
     parsec_dtd_data_collection_fini( (parsec_data_collection_t *)dcT );
diff --git a/parsec/data_dist/matrix/redistribute/redistribute_wrapper.c b/parsec/data_dist/matrix/redistribute/redistribute_wrapper.c
index 1eb1246de..28adc9dc2 100644
--- a/parsec/data_dist/matrix/redistribute/redistribute_wrapper.c
+++ b/parsec/data_dist/matrix/redistribute/redistribute_wrapper.c
@@ -97,10 +97,8 @@ parsec_redistribute_New(parsec_tiled_matrix_t *dcY,
         int n_T_END = (size_col+disj_T-1) / dcT->nb;
         taskpool->_g_NT = (n_T_END-n_T_START)/taskpool->_g_num_col;
 
-        parsec_add2arena(&taskpool->arenas_datatypes[PARSEC_redistribute_reshuffle_DEFAULT_ADT_IDX],
-                         MY_TYPE, PARSEC_MATRIX_FULL,
-                         1, dcY->mb, dcY->nb, dcY->mb,
-                         PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+        parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_reshuffle_DEFAULT_ADT_IDX],
+                         MY_TYPE, dcY->mb, dcY->nb, dcY->mb);
         /* General version */
     } else {
         parsec_redistribute_taskpool_t* taskpool = NULL;
@@ -118,23 +116,17 @@ parsec_redistribute_New(parsec_tiled_matrix_t *dcY,
         int n_T_END = (size_col+disj_T-1) / (dcT->nb-2*R);
         taskpool->_g_NT = (n_T_END-n_T_START)/taskpool->_g_num_col;
 
-        parsec_add2arena(&taskpool->arenas_datatypes[PARSEC_redistribute_DEFAULT_ADT_IDX],
-                         MY_TYPE, PARSEC_MATRIX_FULL,
-                         1, 1, 1, 1,
-                         PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+        parsec_matrix_adt_construct_tile(&taskpool->arenas_datatypes[PARSEC_redistribute_DEFAULT_ADT_IDX],
+                         MY_TYPE, 1);
 
         int Y_LDA = dcY->storage == PARSEC_MATRIX_LAPACK ? dcY->llm : dcY->mb;
         int T_LDA = dcT->storage == PARSEC_MATRIX_LAPACK ? dcT->llm : dcT->mb;
 
-        parsec_add2arena(&taskpool->arenas_datatypes[PARSEC_redistribute_TARGET_ADT_IDX],
-                         MY_TYPE, PARSEC_MATRIX_FULL,
-                         1, dcT->mb, dcT->nb, T_LDA,
-                         PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+        parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_TARGET_ADT_IDX],
+                         MY_TYPE, dcT->mb, dcT->nb, T_LDA);
 
-        parsec_add2arena(&taskpool->arenas_datatypes[PARSEC_redistribute_INNER_ADT_IDX],
-                         MY_TYPE, PARSEC_MATRIX_FULL,
-                         1, dcY->mb-2*R, dcY->nb-2*R, Y_LDA,
-                         PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+        parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_INNER_ADT_IDX],
+                         MY_TYPE, dcY->mb-2*R, dcY->nb-2*R, Y_LDA);
     }
 
     return redistribute_taskpool;
@@ -156,12 +148,12 @@ __parsec_redistribute_destructor(parsec_redistribute_taskpool_t *redistribute_ta
         && (redistribute_taskpool->_g_disj_T % redistribute_taskpool->_g_descT->nb == 0) )
     {
         parsec_redistribute_reshuffle_taskpool_t *redistribute_reshuffle_taskpool = (parsec_redistribute_reshuffle_taskpool_t *)redistribute_taskpool;
-        parsec_del2arena(&redistribute_reshuffle_taskpool->arenas_datatypes[PARSEC_redistribute_reshuffle_DEFAULT_ADT_IDX]);
+        parsec_matrix_arena_datatype_destruct_free_type(&redistribute_reshuffle_taskpool->arenas_datatypes[PARSEC_redistribute_reshuffle_DEFAULT_ADT_IDX]);
     } else {
-        parsec_del2arena(&redistribute_taskpool->arenas_datatypes[PARSEC_redistribute_DEFAULT_ADT_IDX]);
-        parsec_del2arena(&redistribute_taskpool->arenas_datatypes[PARSEC_redistribute_TARGET_ADT_IDX]);
-        // parsec_del2arena(&redistribute_taskpool->arenas_datatypes[PARSEC_redistribute_SOURCE_ADT_IDX]);
-        parsec_del2arena(&redistribute_taskpool->arenas_datatypes[PARSEC_redistribute_INNER_ADT_IDX]);
+        parsec_matrix_arena_datatype_destruct_free_type(&redistribute_taskpool->arenas_datatypes[PARSEC_redistribute_DEFAULT_ADT_IDX]);
+        parsec_matrix_arena_datatype_destruct_free_type(&redistribute_taskpool->arenas_datatypes[PARSEC_redistribute_TARGET_ADT_IDX]);
+        // parsec_matrix_arena_datatype_destruct_free_type(&redistribute_taskpool->arenas_datatypes[PARSEC_redistribute_SOURCE_ADT_IDX]);
+        parsec_matrix_arena_datatype_destruct_free_type(&redistribute_taskpool->arenas_datatypes[PARSEC_redistribute_INNER_ADT_IDX]);
     }
 }
 
diff --git a/parsec/interfaces/dtd/insert_function.c b/parsec/interfaces/dtd/insert_function.c
index fc609500f..6bd7cab49 100644
--- a/parsec/interfaces/dtd/insert_function.c
+++ b/parsec/interfaces/dtd/insert_function.c
@@ -3451,43 +3451,37 @@ parsec_dtd_get_taskpool(parsec_task_t *this_task)
     return this_task->taskpool;
 }
 
-parsec_arena_datatype_t *parsec_dtd_create_arena_datatype(parsec_context_t *ctx, int *id)
-{
-    parsec_arena_datatype_t *new_adt;
+int parsec_dtd_attach_arena_datatype(parsec_context_t *ctx, parsec_arena_datatype_t *adt, int *id) {
     int my_id = parsec_atomic_fetch_inc_int32(&ctx->dtd_arena_datatypes_next_id);
     if( (my_id & PARSEC_GET_REGION_INFO) != my_id) {
-        return NULL;
+        return PARSEC_ERR_OUT_OF_RESOURCE;
     }
 #if defined(PARSEC_DEBUG_PARANOID)
-    new_adt = parsec_hash_table_nolock_find(&ctx->dtd_arena_datatypes_hash_table, my_id);
-    if(NULL != new_adt)
-        return NULL;
+    assert(NULL == parsec_hash_table_nolock_find(&ctx->dtd_arena_datatypes_hash_table, my_id));
 #endif
-    new_adt = calloc(1, sizeof(parsec_arena_datatype_t));
-    if(NULL == new_adt)
-        return NULL;
-    /* all other fields are zeroed at that point, no need to initialize, will
-     * complete initialization during parsec_add2arena */
-    new_adt->ht_item.key = my_id;
-    parsec_hash_table_nolock_insert(&ctx->dtd_arena_datatypes_hash_table, &new_adt->ht_item);
-    *id = my_id;
-    return new_adt;
+    adt->ht_item.key = *id = my_id;
+    parsec_hash_table_nolock_insert(&ctx->dtd_arena_datatypes_hash_table, &adt->ht_item);
+    return PARSEC_SUCCESS;
 }
 
-parsec_arena_datatype_t *parsec_dtd_get_arena_datatype(parsec_context_t *ctx, int id)
-{
+parsec_arena_datatype_t *parsec_dtd_detach_arena_datatype(parsec_context_t *ctx, int id) {
+    return parsec_hash_table_nolock_remove(&ctx->dtd_arena_datatypes_hash_table, id);
+}
+
+parsec_arena_datatype_t *parsec_dtd_get_arena_datatype(parsec_context_t *ctx, int id) {
     return parsec_hash_table_nolock_find(&ctx->dtd_arena_datatypes_hash_table, id);
 }
 
-int parsec_dtd_destroy_arena_datatype(parsec_context_t *ctx, int id)
-{
-    parsec_arena_datatype_t *adt = parsec_hash_table_nolock_remove(&ctx->dtd_arena_datatypes_hash_table, id);
-    if(NULL == adt)
-        return PARSEC_ERR_VALUE_OUT_OF_BOUNDS;
-    free(adt);
+int parsec_dtd_free_arena_datatype(parsec_context_t *ctx, int id) {
+    parsec_arena_datatype_t *adt = parsec_dtd_detach_arena_datatype(ctx, id);
+    if(NULL == adt) return PARSEC_ERR_VALUE_OUT_OF_BOUNDS;
+
+    if(PARSEC_DATATYPE_NULL != adt->opaque_dtt) parsec_type_free(&adt->opaque_dtt);
+    PARSEC_OBJ_RELEASE(adt);
     return PARSEC_SUCCESS;
 }
 
+
 /**
  * Return pointer on the device pointer associated with the i-th flow
  * of `this_task`.
diff --git a/parsec/interfaces/dtd/insert_function.h b/parsec/interfaces/dtd/insert_function.h
index ca1884a92..aa7e2d06c 100644
--- a/parsec/interfaces/dtd/insert_function.h
+++ b/parsec/interfaces/dtd/insert_function.h
@@ -82,27 +82,42 @@ typedef struct {
 typedef struct parsec_dtd_task_class_s  parsec_dtd_task_class_t;
 
 /**
- * @brief Create a new Arena Datatype for DTD
+ * @brief Attach an Arena Datatype for DTD
  * @details Create a new unique Arena Datatype identifier,
- *    @id, and a new Arena Datatype; Associates the new Arena
+ *    @id, and a sets it in the pre-allocated Datatype; Associates the new Arena
  *    Datatype with the context @p ctx and the unique id @p id.
  *    This function is thread-safe per context, but not
  *    thread-safe if called in parallel on the same context.
  *
  * @param ctx the context in which the arena datatype exists.
+ * @param adt the Arena Datatype to attach, the adt must already be constructed
  * @param id Ignored as input. As output: the unique ID assigned
- *    to this new Arena Datatype.
- * @return the new Arena Datatype, or NULL if there was an error
- *    (e.g. no more memory or too many arena datatypes created
- *    within this context.) id is untouched if NULL is returned.
+ *    to this Arena Datatype.
+ * @return PARSEC_SUCCESS, or PARSEC_ERR_OUT_OF_RESOUCE if the adt was
+ * not attached (e.g. no more memory or too many arena datatypes created
+ *    within this context.) id and adt are untouched if an error is returned.
  */
-parsec_arena_datatype_t *parsec_dtd_create_arena_datatype(parsec_context_t *ctx, int *id);
+int parsec_dtd_attach_arena_datatype(parsec_context_t *ctx, parsec_arena_datatype_t *adt, int *id);
+
+/**
+ * @brief detach the Arena Datatype from its association to the
+ *    unique identifier
+ * @details This function is only valid if @p id is the unique
+ *    identifier associated to an Arena Datatype in @p ctx. This
+ *    function detaches the Arena Datatype from its association with the
+ *    identifier. The Arena Datatype is not freed.
+ * @param ctx the context in which the Arena Datatype exists
+ * @param id the unique identifier of the Arena Datatype to release
+ * @return The detached Arena Datatype in case of success, or NULL if
+ * there was an error.
+ */
+parsec_arena_datatype_t *parsec_dtd_detach_arena_datatype(parsec_context_t *ctx, int id);
 
 /**
  * @brief returns the Arena Datatype associated with this identifier
  *    in this context
  * @details This function is thread-safe as long as the Arena Datatype
- *    associated with this @p id in this @p ctx is not removed in parallel.
+ *    associated with this @p id in this @p ctx is not detached in parallel.
  * @param ctx the context in which the Arena Datatype exists
  * @param id the unique identifier of the Arena Datatype
  * @return the existing Arena Datatype, or NULL if there was an
@@ -111,18 +126,20 @@ parsec_arena_datatype_t *parsec_dtd_create_arena_datatype(parsec_context_t *ctx,
 parsec_arena_datatype_t *parsec_dtd_get_arena_datatype(parsec_context_t *ctx, int id);
 
 /**
- * @brief release the Arena Datatype and its association to the
- *    unique identifier
- * @details This function is only valid if @p id is the unique
- *    identifier associated to an Arena Datatype in @p ctx. This
- *    function releases the Arena Datatype and its association with the
- *    identifier.
+ * @brief detach and free the Arena Datatype associated with this identified,
+ * and the free the type assigned to the Arena Datatype
+ * @details This is a convenience function that detach and free the Arena
+ *   Datatype, and free its internal members (i.e., the arena, the opaque_dtt).
+ *   In some circumstances (e.g., persistent datatypes) calling this function
+ *   is not appropriate as it also free the datatype. In this case users should
+ *   call parsec_dtd_detach_arena_datatype and parsec_arena_datatype_destruct
+ *   themselves instead.
  * @param ctx the context in which the Arena Datatype exists
- * @param id the unique identifier of the Arena Datatype to release
- * @return PARSEC_SUCCESS in case of success, or an error code
- *    otherwise.
+ * @param id the unique identifier of the Arena Datatype
+ * @return PARSEC_SUCCESS or PARSEC_ERR_VALUE_OUT_OF_BOUNDS if the id is
+ *   invalid.
  */
-int parsec_dtd_destroy_arena_datatype(parsec_context_t *ctx, int id);
+int parsec_dtd_free_arena_datatype(parsec_context_t *ctx, int id);
 
 /**
  * Users can use this two variables to control the sliding window of task insertion.
diff --git a/parsec/interfaces/ptg/ptg-compiler/jdf2c.c b/parsec/interfaces/ptg/ptg-compiler/jdf2c.c
index eab822b31..bb7e41b53 100644
--- a/parsec/interfaces/ptg/ptg-compiler/jdf2c.c
+++ b/parsec/interfaces/ptg/ptg-compiler/jdf2c.c
@@ -4562,12 +4562,7 @@ static void jdf_generate_destructor( const jdf_t *jdf )
             "  }\n"
             "  free(__parsec_tp->super.super.task_classes_array); __parsec_tp->super.super.task_classes_array = NULL;\n"
             "  __parsec_tp->super.super.nb_task_classes = 0;\n"
-            "\n"
-            "  for(i = 0; i < (uint32_t)__parsec_tp->super.arenas_datatypes_size; i++) {\n"
-            "    if( NULL != __parsec_tp->super.arenas_datatypes[i].arena ) {\n"
-            "      PARSEC_OBJ_RELEASE(__parsec_tp->super.arenas_datatypes[i].arena);\n"
-            "    }\n"
-            "  }\n");
+            "\n");
 
     coutput("  /* Destroy the data repositories for this object */\n");
     for( f = jdf->functions; NULL != f; f = f->next ) {
@@ -4758,7 +4753,15 @@ static void jdf_generate_constructor( const jdf_t* jdf )
         } else {
             coutput("  __parsec_tp->super.arenas_datatypes_size = %d;\n", datatype_index);
         }
-        coutput("  memset(&__parsec_tp->super.arenas_datatypes[0], 0, __parsec_tp->super.arenas_datatypes_size*sizeof(parsec_arena_datatype_t));\n");
+        /* we CONSTRUCT the adts, but we don't DESTRUCT them (in the
+         * generated destructor) because the adt CONSTRUCT is done in two
+         * stages, one in the generated code runs the generic constructor, then
+         * the user code calls the parameterized constructor (that attaches the
+         * datatype). Thus, for symmetry the user code is also responsible for calling
+         * the destructor. */
+        coutput("  for(i = 0; i < (uint32_t)__parsec_tp->super.arenas_datatypes_size; i++) {\n"
+                "    PARSEC_OBJ_CONSTRUCT(&__parsec_tp->super.arenas_datatypes[i], parsec_arena_datatype_t);\n"
+                "  }\n");
     }
 
     coutput("  /* If profiling is enabled, the keys for profiling */\n"
diff --git a/parsec/parsec_internal.h b/parsec/parsec_internal.h
index 970587260..fb450bb3b 100644
--- a/parsec/parsec_internal.h
+++ b/parsec/parsec_internal.h
@@ -39,16 +39,12 @@ BEGIN_C_DECLS
  * Arena-datatype management.
  */
 struct parsec_arena_datatype_s {
+    parsec_object_t           super;
     parsec_arena_t           *arena;       /**< allocator for this datatype */
     parsec_datatype_t         opaque_dtt;  /**< datatype */
     parsec_hash_table_item_t  ht_item;     /**< sometimes, arena datatype are stored in hash tables */
 };
 
-int parsec_arena_datatype_construct(parsec_arena_datatype_t *adt,
-                                   size_t elem_size,
-                                   size_t alignment,
-                                   parsec_datatype_t opaque_dtt);
-
 /* NULL terminated local hostname of the current PaRSEC process */
 PARSEC_DECLSPEC extern const char* parsec_hostname;
 
diff --git a/tests/api/taskpool_wait/main.c b/tests/api/taskpool_wait/main.c
index f715ffa7c..f3a87da06 100644
--- a/tests/api/taskpool_wait/main.c
+++ b/tests/api/taskpool_wait/main.c
@@ -37,8 +37,9 @@ int main(int argc, char *argv[]) {
     parsec_data_collection_set_key(&A.super.super, "A");
     parsec_dtd_data_collection_init(&A.super.super);
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena(adt, parsec_datatype_int32_t, PARSEC_MATRIX_FULL, 0, nb, 1, nb, PARSEC_ARENA_ALIGNMENT_SSE, -1);
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt, parsec_datatype_int32_t, 0, nb, 1);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     printf("Single PTG taskpool, waited with parsec_context_wait\n");
     ptg_tp1 = (parsec_taskpool_t*)parsec_ptg_tp_new(&A, deltamin, deltamax);
@@ -95,12 +96,10 @@ int main(int argc, char *argv[]) {
 
     printf("All tests done, cleaning up data\n");
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
     parsec_dtd_data_collection_fini(&A.super.super);
 
     parsec_fini(&parsec);
     MPI_Finalize();
     return err;
-}
\ No newline at end of file
+}
diff --git a/tests/dsl/dtd/dtd_test_allreduce.c b/tests/dsl/dtd/dtd_test_allreduce.c
index b163846ef..f1e7a17e6 100644
--- a/tests/dsl/dtd/dtd_test_allreduce.c
+++ b/tests/dsl/dtd/dtd_test_allreduce.c
@@ -136,10 +136,10 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new(  );
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena_rect( adt,
-                                  parsec_datatype_int32_t,
-                                  nb, 1, nb );
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     parsec_matrix_block_cyclic_t *m = (parsec_matrix_block_cyclic_t*)malloc(sizeof(parsec_matrix_block_cyclic_t));
     parsec_matrix_block_cyclic_init(m, PARSEC_MATRIX_COMPLEX_DOUBLE, PARSEC_MATRIX_TILE,
@@ -226,9 +226,7 @@ int main(int argc, char **argv)
     PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
     parsec_taskpool_free( dtd_tp );
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
     parsec_dtd_data_collection_fini( A );
     parsec_tiled_matrix_destroy_data(dcA);
     parsec_data_collection_destroy(&dcA->super);
diff --git a/tests/dsl/dtd/dtd_test_broadcast.c b/tests/dsl/dtd/dtd_test_broadcast.c
index fab9e4bbf..4c8bc5b24 100644
--- a/tests/dsl/dtd/dtd_test_broadcast.c
+++ b/tests/dsl/dtd/dtd_test_broadcast.c
@@ -80,10 +80,10 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena_rect( adt,
-                                  parsec_datatype_int32_t,
-                                  nb, 1, nb);
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect( adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     /* Correctness checking */
     dcA = create_and_distribute_data(rank, world, nb, nt);
@@ -149,9 +149,7 @@ int main(int argc, char **argv)
     PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
     parsec_taskpool_free( dtd_tp );
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
     parsec_dtd_data_collection_fini( A );
     free_data(dcA);
 
diff --git a/tests/dsl/dtd/dtd_test_cuda_task_insert.c b/tests/dsl/dtd/dtd_test_cuda_task_insert.c
index 9b689db73..6521f303e 100644
--- a/tests/dsl/dtd/dtd_test_cuda_task_insert.c
+++ b/tests/dsl/dtd/dtd_test_cuda_task_insert.c
@@ -168,9 +168,10 @@ int test_cuda_memset(int world, int myrank, parsec_context_t *parsec_context, in
     // Create new DTD taskpool
     parsec_taskpool_t *tp = parsec_dtd_taskpool_new();
 
-    parsec_arena_datatype_t *adt = parsec_dtd_create_arena_datatype(parsec_context, &TILE_FULL);
-    // unless `parsec_dtd_taskpool_new()` is called first.
-    parsec_add2arena_rect(adt, parsec_datatype_int32_t, nb, 1, nb);
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
     parsec_tiled_matrix_t *dcA;
     dcA = create_and_distribute_data(myrank, world, nb, nt*mt);
@@ -271,9 +272,7 @@ int test_cuda_memset(int world, int myrank, parsec_context_t *parsec_context, in
                mode_to_string(mode), data_ptr, data_ptr[0], data_ptr[nb - 1]);
 
     // Cleanup data and parsec data structures
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec_context, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec_context, TILE_FULL);
     parsec_dtd_data_collection_fini(A);
     free_data(dcA);
 
@@ -331,8 +330,10 @@ int test_cuda_memset_and_read(int world, int myrank, parsec_context_t *parsec_co
     // Create new DTD taskpool
     parsec_taskpool_t *tp = parsec_dtd_taskpool_new();
 
-    parsec_arena_datatype_t *adt = parsec_dtd_create_arena_datatype(parsec_context, &TILE_FULL);
-    parsec_add2arena_rect(adt, parsec_datatype_int32_t, nb, 1, nb);
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
     parsec_tiled_matrix_t *dcA;
     dcA = create_and_distribute_data(myrank, world, nb, nt*mt);
@@ -413,9 +414,7 @@ int test_cuda_memset_and_read(int world, int myrank, parsec_context_t *parsec_co
            data_ptr, data_ptr[0], data_ptr[1]);
 
     // Cleanup data and parsec data structures
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec_context, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec_context, TILE_FULL);
     parsec_dtd_data_collection_fini(A);
     free_data(dcA);
 
@@ -494,8 +493,10 @@ int test_cuda_memset_write_read(int world, int myrank, parsec_context_t *parsec_
     // Create new DTD taskpool
     parsec_taskpool_t *tp = parsec_dtd_taskpool_new();
 
-    parsec_arena_datatype_t *adt = parsec_dtd_create_arena_datatype(parsec_context, &TILE_FULL);
-    parsec_add2arena_rect(adt, parsec_datatype_int32_t, nb, 1, nb);
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
     parsec_tiled_matrix_t *dcA;
     dcA = create_and_distribute_data(myrank, nb, mt, nt);
@@ -605,9 +606,7 @@ int test_cuda_memset_write_read(int world, int myrank, parsec_context_t *parsec_
     parsec_dtd_task_class_release(tp, cudaread_tc);
 
     // Cleanup data and parsec data structures
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec_context, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec_context, TILE_FULL);
     parsec_dtd_data_collection_fini(A);
     free_data(dcA);
 
@@ -703,8 +702,10 @@ int test_cuda_multiple_devices(int world, int myrank, parsec_context_t *parsec_c
 
     parsec_task_class_t *cudaread_tc, *cudacpy_tc;
 
-    parsec_arena_datatype_t *adt = parsec_dtd_create_arena_datatype(parsec_context, &TILE_FULL);
-    parsec_add2arena_rect(adt, parsec_datatype_int32_t, nb, 1, nb);
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
     parsec_tiled_matrix_t *dcA;
     dcA = create_and_distribute_data(myrank, world, nb, 3*nt*mt);
@@ -836,9 +837,7 @@ int test_cuda_multiple_devices(int world, int myrank, parsec_context_t *parsec_c
     parsec_dtd_task_class_release(tp, cudacpy_tc);
 
     // Cleanup data and parsec data structures
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec_context, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec_context, TILE_FULL);
     parsec_dtd_data_collection_fini(A);
     free_data(dcA);
 
diff --git a/tests/dsl/dtd/dtd_test_data_flush.c b/tests/dsl/dtd/dtd_test_data_flush.c
index 5f3e02c32..f9b04db0e 100644
--- a/tests/dsl/dtd/dtd_test_data_flush.c
+++ b/tests/dsl/dtd/dtd_test_data_flush.c
@@ -214,10 +214,10 @@ int main(int argc, char ** argv)
 
         dtd_tp = parsec_dtd_taskpool_new();
 
-        adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-        parsec_add2arena_rect( adt,
-                                      parsec_datatype_int32_t,
-                                      nb, 1, nb );
+        adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+        parsec_matrix_adt_construct_rect(adt,
+                parsec_datatype_int32_t, nb, 1, nb);
+        parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
         parsec_data_copy_t *gdata;
         parsec_data_t *data;
@@ -340,9 +340,7 @@ int main(int argc, char ** argv)
         parsec_dtd_data_collection_fini(A);
         free_data(dcA);
 
-        parsec_del2arena(adt);
-        PARSEC_OBJ_RELEASE(adt->arena);
-        parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+        parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
     } else if (world == 3) {
         /* We send data from rank 0 to 2 and flush it back
          * rank 1 does nothing.
@@ -359,10 +357,11 @@ int main(int argc, char ** argv)
 
         dtd_tp = parsec_dtd_taskpool_new();
 
-        adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-        parsec_add2arena_rect( adt,
-                                      parsec_datatype_int32_t,
-                                      nb, 1, nb);
+        adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+        parsec_matrix_adt_construct_rect(adt,
+                parsec_datatype_int32_t, nb, 1, nb);
+        parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
+
         parsec_data_copy_t *gdata;
         parsec_data_t *data;
         int *real_data, key;
@@ -414,9 +413,7 @@ int main(int argc, char ** argv)
         parsec_dtd_data_collection_fini(A);
         free_data(dcA);
 
-        parsec_del2arena(adt);
-        PARSEC_OBJ_RELEASE(adt->arena);
-        parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+        parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
     }
 
     parsec_fini(&parsec);
diff --git a/tests/dsl/dtd/dtd_test_explicit_task_creation.c b/tests/dsl/dtd/dtd_test_explicit_task_creation.c
index 2e9d467f3..906de44e2 100644
--- a/tests/dsl/dtd/dtd_test_explicit_task_creation.c
+++ b/tests/dsl/dtd/dtd_test_explicit_task_creation.c
@@ -87,7 +87,11 @@ int main(int argc, char ** argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new(  );
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
+
     parsec_arena_datatype_construct( adt,
                                      nb*sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
                                      MPI_INT );
@@ -148,9 +152,8 @@ int main(int argc, char ** argv)
     PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
 
     parsec_taskpool_free( dtd_tp );
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
 
     parsec_dtd_data_collection_fini( A );
     free_data(dcA);
diff --git a/tests/dsl/dtd/dtd_test_hierarchy.c b/tests/dsl/dtd/dtd_test_hierarchy.c
index fb05a44f0..56e391be8 100644
--- a/tests/dsl/dtd/dtd_test_hierarchy.c
+++ b/tests/dsl/dtd/dtd_test_hierarchy.c
@@ -131,10 +131,10 @@ int main(int argc, char ** argv)
     dcA = create_and_distribute_empty_data(rank, world, nb, nt);
     parsec_data_collection_set_key((parsec_data_collection_t *)dcA, "A");
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena_rect( adt,
-                                  parsec_datatype_int32_t,
-                                  nb, 1, nb );
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     parsec_data_collection_t *A = (parsec_data_collection_t *)dcA;
     parsec_dtd_data_collection_init(A);
@@ -164,9 +164,7 @@ int main(int argc, char ** argv)
     rc = parsec_context_wait(parsec);
     PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
     parsec_dtd_data_collection_fini( A );
     free_data(dcA);
 
diff --git a/tests/dsl/dtd/dtd_test_insert_task_interface.c b/tests/dsl/dtd/dtd_test_insert_task_interface.c
index cd50b63d5..9f10a3248 100644
--- a/tests/dsl/dtd/dtd_test_insert_task_interface.c
+++ b/tests/dsl/dtd/dtd_test_insert_task_interface.c
@@ -91,10 +91,10 @@ int main(int argc, char ** argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new(  );
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena_rect( adt,
-                                  parsec_datatype_int32_t,
-                                  nb, 1, nb);
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     dcA = create_and_distribute_data(rank, world, nb, nt);
     parsec_data_collection_set_key((parsec_data_collection_t *)dcA, "A");
@@ -151,9 +151,7 @@ int main(int argc, char ** argv)
 
     parsec_taskpool_free( dtd_tp );
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
     parsec_dtd_data_collection_fini( A );
     free_data(dcA);
 
diff --git a/tests/dsl/dtd/dtd_test_interleave_actions.c b/tests/dsl/dtd/dtd_test_interleave_actions.c
index 25428a5cd..5263f60ad 100644
--- a/tests/dsl/dtd/dtd_test_interleave_actions.c
+++ b/tests/dsl/dtd/dtd_test_interleave_actions.c
@@ -25,11 +25,11 @@ int recv_data_kernel(
    (void)es;
    int *data_in;
    int rank;
-   
+
    parsec_dtd_unpack_args(this_task, &data_in, &rank);
 
    printf("[recv_data_kernel] rank = %d, data_in = %d\n", rank, *data_in);
-    
+
    return PARSEC_HOOK_RETURN_DONE;
 }
 
@@ -141,10 +141,10 @@ int main(int argc, char **argv) {
 
    parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-   adt = parsec_dtd_create_arena_datatype(parsec_context, &TILE_FULL);
-   parsec_add2arena_rect( adt,
-         parsec_datatype_int32_t,
-         nb, 1, nb);
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
    if( 0 == rank ) {
       parsec_data_copy_t *parsec_data_copy;
@@ -156,7 +156,7 @@ int main(int argc, char **argv) {
       parsec_data = A->data_of_key(A, key);
       parsec_data_copy = parsec_data_get_copy(parsec_data, 0);
       data_ptr = (int*)parsec_data_copy_get_ptr(parsec_data_copy);
-      *data_ptr = 1; 
+      *data_ptr = 1;
       parsec_output( 0, "Initial data, node: %d A At key[%d]: %d\n", rank, key, *data_ptr );
    }
 
@@ -168,8 +168,8 @@ int main(int argc, char **argv) {
       // The following sleep statememt ensure that rank `0` has enough
       // time to send data to other processes before adding the taskpool.
       sleep(1);
-   }   
-      
+   }
+
    // Registering the dtd_handle with PARSEC context
    ret = parsec_context_add_taskpool( parsec_context, dtd_tp );
    PARSEC_CHECK_ERROR(ret, "parsec_context_add_taskpool");
@@ -214,9 +214,7 @@ int main(int argc, char **argv) {
    PARSEC_CHECK_ERROR(ret, "parsec_context_wait");
 
     // Cleanup data and parsec data structures
-   parsec_del2arena(adt);
-   PARSEC_OBJ_RELEASE(adt->arena);
-   parsec_dtd_destroy_arena_datatype(parsec_context, TILE_FULL);
+   parsec_dtd_free_arena_datatype(parsec_context, TILE_FULL);
    parsec_dtd_data_collection_fini( A );
    free_data(dcA);
 
diff --git a/tests/dsl/dtd/dtd_test_new_tile.c b/tests/dsl/dtd/dtd_test_new_tile.c
index 36f6b99da..881ba4682 100644
--- a/tests/dsl/dtd/dtd_test_new_tile.c
+++ b/tests/dsl/dtd/dtd_test_new_tile.c
@@ -321,9 +321,10 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena( adt, parsec_datatype_int32_t,PARSEC_MATRIX_FULL, 0,
-                      nb, 1, nb, PARSEC_ARENA_ALIGNMENT_SSE, -1);
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     /* Registering the dtd_handle with PARSEC context */
     rc = parsec_context_add_taskpool( parsec, dtd_tp );
@@ -506,9 +507,7 @@ int main(int argc, char **argv)
     parsec_dtd_task_class_release(dtd_tp, second_tc);
     parsec_dtd_task_class_release(dtd_tp, third_tc);
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
 
     parsec_taskpool_free( dtd_tp );
     parsec_fini(&parsec);
diff --git a/tests/dsl/dtd/dtd_test_pingpong.c b/tests/dsl/dtd/dtd_test_pingpong.c
index 04ec9c4af..cbee5d8bf 100644
--- a/tests/dsl/dtd/dtd_test_pingpong.c
+++ b/tests/dsl/dtd/dtd_test_pingpong.c
@@ -112,10 +112,11 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena_rect( adt,
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect( adt,
                                   parsec_datatype_int32_t,
                                   nb, 1, nb );
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     /* Correctness checking */
     dcA = create_and_distribute_data(rank, world, nb, nt);
@@ -173,8 +174,7 @@ int main(int argc, char **argv)
         assert( *real_data == 1);
     }
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
 
     parsec_dtd_data_collection_fini( A );
     free_data(dcA);
@@ -211,9 +211,11 @@ int main(int argc, char **argv)
         nb = sizes[i];
         nt = 2;
 
-        parsec_add2arena_rect( adt,
-                                      parsec_datatype_int32_t,
-                                      nb, 1, nb);
+        adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+        parsec_matrix_adt_construct_rect( adt,
+                                  parsec_datatype_int32_t,
+                                  nb, 1, nb );
+        parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
         dcA = create_and_distribute_data(rank, world, nb, nt);
         parsec_data_collection_set_key((parsec_data_collection_t *)dcA, "A");
@@ -240,15 +242,13 @@ int main(int argc, char **argv)
         PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
         SYNC_TIME_PRINT(rank, ("\tSize of message : %zu bytes\tTime for each pingpong : %12.5f\n", sizes[i]*sizeof(int), sync_time_elapsed/repeat_pingpong));
 
-        parsec_del2arena(adt);
-        PARSEC_OBJ_RELEASE(adt->arena);
+        parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
         parsec_dtd_data_collection_fini( A );
         free_data(dcA);
 
         parsec_taskpool_free(dtd_tp);
     }
 
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
     parsec_fini(&parsec);
 
 #ifdef PARSEC_HAVE_MPI
diff --git a/tests/dsl/dtd/dtd_test_reduce.c b/tests/dsl/dtd/dtd_test_reduce.c
index 8911f7885..ce1be7bf4 100644
--- a/tests/dsl/dtd/dtd_test_reduce.c
+++ b/tests/dsl/dtd/dtd_test_reduce.c
@@ -83,10 +83,10 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new(  );
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena_rect( adt,
-                                  parsec_datatype_int32_t,
-                                  nb, 1, nb );
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     /* Correctness checking */
     dcA = create_and_distribute_data(rank, world, nb, nt);
@@ -139,9 +139,7 @@ int main(int argc, char **argv)
 
     parsec_taskpool_free( dtd_tp );
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
     parsec_dtd_data_collection_fini( A );
     free_data(dcA);
 
diff --git a/tests/dsl/dtd/dtd_test_simple_gemm.c b/tests/dsl/dtd/dtd_test_simple_gemm.c
index abcf623a9..c8ceb9911 100644
--- a/tests/dsl/dtd/dtd_test_simple_gemm.c
+++ b/tests/dsl/dtd/dtd_test_simple_gemm.c
@@ -635,8 +635,9 @@ int main(int argc, char **argv)
     }
 
     // Create datatypes
-    parsec_arena_datatype_t *adt = parsec_dtd_create_arena_datatype(parsec_context, &TILE_FULL);
-    parsec_add2arena_rect(adt, parsec_datatype_double_t, mb, nb, mb);
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt, parsec_datatype_double_t, mb, nb, mb);
+    parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
     // Create and initialize the data
     parsec_matrix_block_cyclic_t *dcA = create_initialize_matrix(parsec_context, rank, 1789, "A", mb, kb, M, K,
@@ -677,9 +678,7 @@ int main(int argc, char **argv)
         parsec_info_unregister(&parsec_per_device_infos, Cu1, NULL);
     }
 
-    parsec_type_free(&adt->opaque_dtt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec_context, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec_context, TILE_FULL);
 
     destroy_matrix(dcA);
     destroy_matrix(dcB);
diff --git a/tests/dsl/dtd/dtd_test_task_placement.c b/tests/dsl/dtd/dtd_test_task_placement.c
index 647f212eb..854f5b244 100644
--- a/tests/dsl/dtd/dtd_test_task_placement.c
+++ b/tests/dsl/dtd/dtd_test_task_placement.c
@@ -107,10 +107,10 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena_rect( adt,
-                                  parsec_datatype_int32_t,
-                                  nb, 1, nb);
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     /* Correctness checking */
     dcA = create_and_distribute_data(rank, world, nb, nt);
@@ -180,9 +180,7 @@ int main(int argc, char **argv)
 
     parsec_taskpool_free( dtd_tp );
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
     parsec_dtd_data_collection_fini( A );
     free_data(dcA);
 
diff --git a/tests/dsl/dtd/dtd_test_template_counter.c b/tests/dsl/dtd/dtd_test_template_counter.c
index 648a76eb2..74f1d91dd 100644
--- a/tests/dsl/dtd/dtd_test_template_counter.c
+++ b/tests/dsl/dtd/dtd_test_template_counter.c
@@ -79,10 +79,10 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena_rect( adt,
-                                  parsec_datatype_int32_t,
-                                  nb, 1, nb);
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     /* Correctness checking */
     dcA = create_and_distribute_data(rank, world, nb, nt);
@@ -130,9 +130,7 @@ int main(int argc, char **argv)
 
     parsec_context_wait(parsec);
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
     parsec_dtd_data_collection_fini( A );
     free_data(dcA);
 
diff --git a/tests/dsl/dtd/dtd_test_untie.c b/tests/dsl/dtd/dtd_test_untie.c
index 38c89025f..4c1bab9fc 100644
--- a/tests/dsl/dtd/dtd_test_untie.c
+++ b/tests/dsl/dtd/dtd_test_untie.c
@@ -136,10 +136,10 @@ int main(int argc, char ** argv)
     dcA = create_and_distribute_data(rank, world, nb, nt);
     parsec_data_collection_set_key((parsec_data_collection_t *)dcA, "A");
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena_rect( adt,
-                                  parsec_datatype_int32_t,
-                                  nb, 1, nb);
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect(adt,
+            parsec_datatype_int32_t, nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     parsec_data_collection_t *A = (parsec_data_collection_t *)dcA;
     parsec_dtd_data_collection_init(A);
@@ -190,9 +190,7 @@ int main(int argc, char ** argv)
     rc = parsec_context_wait(parsec);
     PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
     parsec_dtd_data_collection_fini( A );
     free_data(dcA);
 
diff --git a/tests/dsl/dtd/dtd_test_war.c b/tests/dsl/dtd/dtd_test_war.c
index ab367d606..8f141f953 100644
--- a/tests/dsl/dtd/dtd_test_war.c
+++ b/tests/dsl/dtd/dtd_test_war.c
@@ -90,10 +90,11 @@ int main(int argc, char ** argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
-    parsec_add2arena_rect( adt,
+    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_construct_rect( adt,
                                   parsec_datatype_int32_t,
                                   nb, 1, nb);
+    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     dcA = create_and_distribute_data(rank, world, nb, nt);
     memset(((parsec_matrix_block_cyclic_t *)dcA)->mat,
@@ -149,9 +150,7 @@ int main(int argc, char ** argv)
     parsec_dtd_data_collection_fini( A );
     free_data(dcA);
 
-    parsec_del2arena(adt);
-    PARSEC_OBJ_RELEASE(adt->arena);
-    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
+    parsec_dtd_free_arena_datatype(parsec, TILE_FULL);
 
     parsec_fini(&parsec);
 
diff --git a/tests/dsl/ptg/recursive.jdf b/tests/dsl/ptg/recursive.jdf
index e8c14fcb5..733b19718 100644
--- a/tests/dsl/ptg/recursive.jdf
+++ b/tests/dsl/ptg/recursive.jdf
@@ -146,7 +146,8 @@ int main( int argc, char** argv )
                                      parsec_datadist_getsizeoftype(TYPE));
 
     parsec_translate_matrix_type(TYPE, &dt);
-    parsec_add2arena_rect(&adt, dt,
+
+    parsec_matrix_adt_construct_rect(&adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
     /* Start the PaRSEC engine */
@@ -157,7 +158,6 @@ int main( int argc, char** argv )
     tp = parsec_recursive_new( (parsec_matrix_block_cyclic_t*)&descA, level, ni );
     assert( NULL != tp );
     tp->arenas_datatypes[PARSEC_recursive_DEFAULT_ADT_IDX] = adt;
-    PARSEC_OBJ_RETAIN(adt.arena);
 
     tp->_g_pri = 0;
     rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
@@ -167,8 +167,7 @@ int main( int argc, char** argv )
     PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
 
     free(descA.mat);
-    PARSEC_OBJ_RELEASE(adt.arena);
-    parsec_del2arena( & adt );
+    parsec_matrix_arena_datatype_destruct_free_type(&adt);
 
     parsec_fini( &parsec);
 
diff --git a/tests/dsl/ptg/startup.jdf b/tests/dsl/ptg/startup.jdf
index 2bc514b16..e99dd042a 100644
--- a/tests/dsl/ptg/startup.jdf
+++ b/tests/dsl/ptg/startup.jdf
@@ -203,7 +203,6 @@ int main( int argc, char** argv )
     }
 
     free(descA.mat);
-    PARSEC_OBJ_RELEASE(adt.arena);
     parsec_del2arena( & adt );
 
     parsec_fini( &parsec);
diff --git a/tests/runtime/multichain.jdf b/tests/runtime/multichain.jdf
index 0dc5dadf1..7b0e7d44c 100644
--- a/tests/runtime/multichain.jdf
+++ b/tests/runtime/multichain.jdf
@@ -223,6 +223,7 @@ int main(int argc, char* argv[])
         parsec_translate_matrix_type(TYPE, &baseType);
         parsec_type_create_contiguous(descA.super.mb * descA.super.nb,
                                       baseType, &newtype);
+        PARSEC_OBJ_CONSTRUCT(&adt, parsec_arena_datatype_t);
         parsec_arena_datatype_construct( &adt,
                                          descA.super.mb * descA.super.nb * parsec_datadist_getsizeoftype(TYPE),
                                          PARSEC_ARENA_ALIGNMENT_SSE, newtype);
@@ -233,7 +234,6 @@ int main(int argc, char* argv[])
             tp = parsec_multichain_new( &descA, &descB, ni, nj );
             assert( NULL != tp );
             tp->arenas_datatypes[PARSEC_multichain_DEFAULT_ADT_IDX] = adt;
-            PARSEC_OBJ_RETAIN(adt.arena);
 
             rc = parsec_context_start(parsec);
             PARSEC_CHECK_ERROR(rc, "parsec_context_start");
@@ -268,7 +268,6 @@ int main(int argc, char* argv[])
             assert( NULL != tp );
 
             tp->arenas_datatypes[PARSEC_multichain_DEFAULT_ADT_IDX] = adt;
-            PARSEC_OBJ_RETAIN(adt.arena);
             TIMER_START(time_elapsed);
             rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
             PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
@@ -291,8 +290,8 @@ int main(int argc, char* argv[])
         }
         free(descA.mat);
         free(descB.mat);
-        PARSEC_OBJ_RELEASE(adt.arena);
         parsec_type_free(&newtype);
+        PARSEC_OBJ_DESTRUCT(&adt);
     }  /* go to the next communicator */
 
     parsec_fini( &parsec);

From 5a5aa5fcd73b9b339b13aa1424bd489c54dd4e0b Mon Sep 17 00:00:00 2001
From: Aurelien Bouteiller <bouteill@icl.utk.edu>
Date: Tue, 23 Apr 2024 15:20:34 -0400
Subject: [PATCH 7/9] api: use the renaming script to convert deprecated
 add2arena to the new adt construct form

---
 parsec/data_dist/matrix/matrix.h              | 15 +++++++---
 .../sym_two_dim_rectangle_cyclic_band.c       |  2 +-
 .../sym_two_dim_rectangle_cyclic_band.h       |  2 +-
 tests/api/touch.jdf                           |  2 +-
 tests/apps/all2all/a2a.jdf                    |  2 +-
 tests/apps/haar_tree/main.c                   | 10 +++----
 tests/apps/pingpong/bandwidth.jdf             | 14 ++++-----
 tests/apps/stencil/stencil_1D.jdf             | 16 ++++------
 tests/collections/kcyclic.jdf                 |  2 +-
 .../redistribute/redistribute_check.jdf       | 16 ++++------
 .../redistribute/redistribute_check2.jdf      |  8 ++---
 .../redistribute_no_optimization.jdf          | 16 ++++------
 tests/collections/reshape/common.h            | 29 +++++++------------
 .../collections/two_dim_band/two_dim_band.jdf |  8 ++---
 tests/dsl/ptg/complex_deps.jdf                |  4 +--
 tests/dsl/ptg/local-indices/local_indices.jdf |  4 +--
 tests/dsl/ptg/startup.jdf                     |  4 +--
 tests/dsl/ptg/user-defined-functions/utt.jdf  |  4 +--
 tests/profiling/async.jdf                     |  4 +--
 tests/runtime/cuda/get_best_device_check.jdf  |  8 ++---
 tests/runtime/cuda/nvlink_wrapper.c           | 14 ++++-----
 tests/runtime/cuda/stress_wrapper.c           |  8 ++---
 22 files changed, 81 insertions(+), 111 deletions(-)

diff --git a/parsec/data_dist/matrix/matrix.h b/parsec/data_dist/matrix/matrix.h
index 1440b834c..1f6794d50 100644
--- a/parsec/data_dist/matrix/matrix.h
+++ b/parsec/data_dist/matrix/matrix.h
@@ -331,6 +331,13 @@ int parsec_matrix_arena_datatype_construct_alloc_type(parsec_arena_datatype_t *a
                                                      size_t alignment, int resized);
 int parsec_matrix_arena_datatype_destruct_free_type(parsec_arena_datatype_t *adt);
 
+#define parsec_matrix_adt_construct( _adt_ , _oldtype_, _uplo_, _diag_, _m_, _n_, _ld_, _align_, _resize_ ) \
+    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), (_uplo_), (_diag_), (_m_), (_n_), (_ld_), (_align_), (_resize_) )
+#define parsec_matrix_adt_new( _adt_ , _oldtype_, _uplo_, _diag_, _m_, _n_, _ld_, _align_, _resize_ ) \
+    ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
+    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), (_uplo_), (_diag_), (_m_), (_n_), (_ld_), (_align_), (_resize_) ) \
+     (_adt_))
+
 #define parsec_matrix_adt_construct_tile( _adt_ , _oldtype_, _m_ ) \
     parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_m_), (_m_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
 #define parsec_matrix_adt_new_tile( _adt_ , _oldtype_, _m_ ) \
@@ -338,16 +345,16 @@ int parsec_matrix_arena_datatype_destruct_free_type(parsec_arena_datatype_t *adt
      parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_m_), (_m_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
      (_adt_))
 
-#define parsec_matrix_adt_construct_upper( _adt_ , _oldtype_, diag, _n_ ) \
+#define parsec_matrix_adt_construct_upper( _adt_ , _oldtype_, _diag_, _n_ ) \
     parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_UPPER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
-#define parsec_matrix_adt_new_upper( _adt_ , _oldtype_, diag, _n_ ) \
+#define parsec_matrix_adt_new_upper( _adt_ , _oldtype_, _diag_, _n_ ) \
     ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
      parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_UPPER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
      (_adt_))
 
-#define parsec_matrix_adt_construct_lower( _adt_ , _oldtype_, diag, _n_ ) \
+#define parsec_matrix_adt_construct_lower( _adt_ , _oldtype_, _diag_, _n_ ) \
     parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_LOWER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
-#define parsec_matrix_adt_new_lower( _adt_ , _oldtype_, diag, _n_ ) \
+#define parsec_matrix_adt_new_lower( _adt_ , _oldtype_, _diag_, _n_ ) \
     ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
      parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_LOWER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
      (_adt_))
diff --git a/parsec/data_dist/matrix/sym_two_dim_rectangle_cyclic_band.c b/parsec/data_dist/matrix/sym_two_dim_rectangle_cyclic_band.c
index 3905ba175..5b761c454 100644
--- a/parsec/data_dist/matrix/sym_two_dim_rectangle_cyclic_band.c
+++ b/parsec/data_dist/matrix/sym_two_dim_rectangle_cyclic_band.c
@@ -106,7 +106,7 @@ static parsec_data_t* sym_twoDBC_band_data_of_key(parsec_data_collection_t *desc
 }
 
 /*
- * sysm_two_dim_block_cyclic_band_t structure init
+ * parsec_matrix_block_cyclic_band_t structure init
  * It inherits from off-band, so should be called after initialization of off_band
  */
 void parsec_matrix_sym_block_cyclic_band_init( parsec_matrix_sym_block_cyclic_band_t *desc,
diff --git a/parsec/data_dist/matrix/sym_two_dim_rectangle_cyclic_band.h b/parsec/data_dist/matrix/sym_two_dim_rectangle_cyclic_band.h
index 1c7de6d63..522713009 100644
--- a/parsec/data_dist/matrix/sym_two_dim_rectangle_cyclic_band.h
+++ b/parsec/data_dist/matrix/sym_two_dim_rectangle_cyclic_band.h
@@ -27,7 +27,7 @@ typedef struct parsec_matrix_sym_block_cyclic_band_s {
 } parsec_matrix_sym_block_cyclic_band_t;
 
 /*
- * sym_two_dim_block_cyclic_band_t structure init
+ * parsec_matrix_sym_block_cyclic_band_t structure init
  * It inherits from off-band, so should be called after initialization of off_band
  */
 void parsec_matrix_sym_block_cyclic_band_init( parsec_matrix_sym_block_cyclic_band_t *desc,
diff --git a/tests/api/touch.jdf b/tests/api/touch.jdf
index 0e6b406b4..7af1357e4 100644
--- a/tests/api/touch.jdf
+++ b/tests/api/touch.jdf
@@ -68,7 +68,7 @@ parsec_taskpool_t* touch_initialize(int block, int n)
     assert( NULL != tp );
 
     parsec_translate_matrix_type(TYPE, &dt);
-    parsec_add2arena_rect( &tp->arenas_datatypes[PARSEC_touch_DEFAULT_ADT_IDX],
+    parsec_matrix_adt_construct_rect( &tp->arenas_datatypes[PARSEC_touch_DEFAULT_ADT_IDX],
                                   dt, descA.super.mb, descA.super.nb, descA.super.mb );
 
     return &tp->super;
diff --git a/tests/apps/all2all/a2a.jdf b/tests/apps/all2all/a2a.jdf
index c2ad11c8d..e92ceaa57 100644
--- a/tests/apps/all2all/a2a.jdf
+++ b/tests/apps/all2all/a2a.jdf
@@ -126,7 +126,7 @@ parsec_taskpool_t *a2a_new(parsec_tiled_matrix_t *A, parsec_tiled_matrix_t *B, i
 
     tp = parsec_a2a_new(A, B, repeat, worldsize);
 
-    parsec_add2arena_rect( &tp->arenas_datatypes[PARSEC_a2a_DEFAULT_ADT_IDX],
+    parsec_matrix_adt_construct_rect( &tp->arenas_datatypes[PARSEC_a2a_DEFAULT_ADT_IDX],
                                   parsec_datatype_int32_t,
                                   size, 1, size);
 
diff --git a/tests/apps/haar_tree/main.c b/tests/apps/haar_tree/main.c
index 897987b59..381b2c426 100644
--- a/tests/apps/haar_tree/main.c
+++ b/tests/apps/haar_tree/main.c
@@ -216,10 +216,8 @@ int main(int argc, char *argv[])
                               0, 0, world, world,
                               1, world, 1, 1, 0, 0);
 
-    parsec_add2arena( &adt, parsec_datatype_float_t,
-                             PARSEC_MATRIX_FULL, 0,
-                             2, 1, 2,
-                             PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+    parsec_matrix_adt_construct_rect( &adt,
+             parsec_datatype_float_t, 2, 1, 2);
 
 #if defined(HAVE_MPI)
     MPI_Barrier(MPI_COMM_WORLD);
@@ -234,7 +232,7 @@ int main(int argc, char *argv[])
     PARSEC_CHECK_ERROR(rc, "parsec_context_start");
     rc = parsec_context_wait(parsec);
     PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
-        
+
     project->arenas_datatypes[PARSEC_project_DEFAULT_ADT_IDX].arena = NULL;
     parsec_taskpool_free(&project->super);
     ret = 0;
@@ -293,7 +291,7 @@ int main(int argc, char *argv[])
         }
     }
 #endif  /* defined(HAVE_MPI) */
-    parsec_del2arena( & adt );
+    parsec_matrix_arena_datatype_destruct_free_type( & adt );
 
     walker->arenas_datatypes[PARSEC_walk_DEFAULT_ADT_IDX].arena = NULL;
     parsec_taskpool_free(&walker->super);
diff --git a/tests/apps/pingpong/bandwidth.jdf b/tests/apps/pingpong/bandwidth.jdf
index 8805c928d..c0dc4c177 100644
--- a/tests/apps/pingpong/bandwidth.jdf
+++ b/tests/apps/pingpong/bandwidth.jdf
@@ -98,10 +98,8 @@ parsec_bandwidth_New(parsec_tiled_matrix_t *dcA,
   taskpool = parsec_bandwidth_new(dcA, Disk, loops, frags, ws); 
   bandwidth_taskpool = (parsec_taskpool_t*)taskpool;
 
-  parsec_add2arena( &taskpool->arenas_datatypes[PARSEC_bandwidth_DEFAULT_ADT_IDX],
-                           parsec_datatype_double_t, PARSEC_MATRIX_FULL,
-                           1, 1, size, 1,
-                           PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+  parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_bandwidth_DEFAULT_ADT_IDX],
+                           parsec_datatype_double_t, 1, size, 1);
 
   return bandwidth_taskpool;
 }
@@ -112,7 +110,7 @@ parsec_bandwidth_New(parsec_tiled_matrix_t *dcA,
 void parsec_bandwidth_Destruct(parsec_taskpool_t *taskpool)
 {
   parsec_bandwidth_taskpool_t *bandwidth_taskpool = (parsec_bandwidth_taskpool_t *)taskpool;
-  parsec_del2arena(&bandwidth_taskpool->arenas_datatypes[PARSEC_bandwidth_DEFAULT_ADT_IDX]);
+  parsec_matrix_arena_datatype_destruct_free_type(&bandwidth_taskpool->arenas_datatypes[PARSEC_bandwidth_DEFAULT_ADT_IDX]);
   parsec_taskpool_free(taskpool);
 }
 
@@ -248,10 +246,8 @@ int main(int argc, char *argv[])
 
         bandwidth_taskpool = (parsec_taskpool_t*)taskpool;
 
-        parsec_add2arena( &taskpool->arenas_datatypes[PARSEC_bandwidth_DEFAULT_ADT_IDX],
-                                 parsec_datatype_double_t, PARSEC_MATRIX_FULL,
-                                 1, 1, size, 1,
-                                 PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+        parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_bandwidth_DEFAULT_ADT_IDX],
+                                 parsec_datatype_double_t, 1, size, 1);
 
         /* Time start */
 #if defined(PARSEC_HAVE_MPI)
diff --git a/tests/apps/stencil/stencil_1D.jdf b/tests/apps/stencil/stencil_1D.jdf
index cffe28807..9c94685b0 100644
--- a/tests/apps/stencil/stencil_1D.jdf
+++ b/tests/apps/stencil/stencil_1D.jdf
@@ -135,15 +135,11 @@ parsec_stencil_1D_New(parsec_tiled_matrix_t *dcA, int iter, int R)
   taskpool = parsec_stencil_1D_new(dcA, iter, R);
   stencil_1D_taskpool = (parsec_taskpool_t*)taskpool;
 
-  parsec_add2arena( &taskpool->arenas_datatypes[PARSEC_stencil_1D_FULL_ADT_IDX],
-                           MY_TYPE, PARSEC_MATRIX_FULL,
-                           1, dcA->mb, dcA->nb, dcA->mb,
-                           PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+  parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_stencil_1D_FULL_ADT_IDX],
+                           MY_TYPE, dcA->mb, dcA->nb, dcA->mb);
 
-  parsec_add2arena( &taskpool->arenas_datatypes[PARSEC_stencil_1D_LR_ADT_IDX],
-                           MY_TYPE, PARSEC_MATRIX_FULL,
-                           1, dcA->mb, R, dcA->mb,
-                           PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+  parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_stencil_1D_LR_ADT_IDX],
+                           MY_TYPE, dcA->mb, R, dcA->mb);
 
   return stencil_1D_taskpool;
 }
@@ -154,8 +150,8 @@ parsec_stencil_1D_New(parsec_tiled_matrix_t *dcA, int iter, int R)
 void parsec_stencil_1D_Destruct(parsec_taskpool_t *taskpool)
 {
   parsec_stencil_1D_taskpool_t *stencil_1D_taskpool = (parsec_stencil_1D_taskpool_t *)taskpool;
-  parsec_del2arena(&stencil_1D_taskpool->arenas_datatypes[PARSEC_stencil_1D_FULL_ADT_IDX]);
-  parsec_del2arena(&stencil_1D_taskpool->arenas_datatypes[PARSEC_stencil_1D_LR_ADT_IDX]);
+  parsec_matrix_arena_datatype_destruct_free_type(&stencil_1D_taskpool->arenas_datatypes[PARSEC_stencil_1D_FULL_ADT_IDX]);
+  parsec_matrix_arena_datatype_destruct_free_type(&stencil_1D_taskpool->arenas_datatypes[PARSEC_stencil_1D_LR_ADT_IDX]);
   parsec_taskpool_free(taskpool);
 }
 
diff --git a/tests/collections/kcyclic.jdf b/tests/collections/kcyclic.jdf
index bdb3359bf..439406b88 100644
--- a/tests/collections/kcyclic.jdf
+++ b/tests/collections/kcyclic.jdf
@@ -215,7 +215,7 @@ parsec_taskpool_t* kcyclic_taskpool(parsec_matrix_block_cyclic_t* A,
     assert( NULL != tp );
 
     parsec_translate_matrix_type(TYPE, &dt);
-    parsec_add2arena_rect( &tp->arenas_datatypes[PARSEC_kcyclic_DEFAULT_ADT_IDX],
+    parsec_matrix_adt_construct_rect( &tp->arenas_datatypes[PARSEC_kcyclic_DEFAULT_ADT_IDX],
                                   dt, A->super.mb, A->super.nb, A->super.mb);
 
     return &tp->super;
diff --git a/tests/collections/redistribute/redistribute_check.jdf b/tests/collections/redistribute/redistribute_check.jdf
index 320415f81..e749c7f28 100644
--- a/tests/collections/redistribute/redistribute_check.jdf
+++ b/tests/collections/redistribute/redistribute_check.jdf
@@ -194,15 +194,11 @@ parsec_redistribute_check_New(parsec_tiled_matrix_t *Y,
     taskpool = parsec_redistribute_check_new(Y, T, size_row, size_col, disi_Y, disj_Y, disi_T, disj_T, R);
     redistribute_check_taskpool = (parsec_taskpool_t*)taskpool;
 
-    parsec_add2arena(&taskpool->arenas_datatypes[PARSEC_redistribute_check_ORIGIN_ADT_IDX],
-                            MY_TYPE, PARSEC_MATRIX_FULL,
-                            1, Y->mb, Y->nb, Y->mb,
-                            PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+    parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_check_ORIGIN_ADT_IDX],
+                            MY_TYPE, Y->mb, Y->nb, Y->mb);
 
-    parsec_add2arena(&taskpool->arenas_datatypes[PARSEC_redistribute_check_TARGET_ADT_IDX],
-                            MY_TYPE, PARSEC_MATRIX_FULL,
-                            1, T->mb, T->nb, T->mb,
-                            PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+    parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_check_TARGET_ADT_IDX],
+                            MY_TYPE, T->mb, T->nb, T->mb);
 
     return redistribute_check_taskpool;
 }
@@ -210,8 +206,8 @@ parsec_redistribute_check_New(parsec_tiled_matrix_t *Y,
 static void
 __parsec_taskpool_redistribute_check_destructor(parsec_redistribute_check_taskpool_t *redistribute_check_taskpool)
 {
-    parsec_del2arena(&redistribute_check_taskpool->arenas_datatypes[PARSEC_redistribute_check_ORIGIN_ADT_IDX]);
-    parsec_del2arena(&redistribute_check_taskpool->arenas_datatypes[PARSEC_redistribute_check_TARGET_ADT_IDX]);
+    parsec_matrix_arena_datatype_destruct_free_type(&redistribute_check_taskpool->arenas_datatypes[PARSEC_redistribute_check_ORIGIN_ADT_IDX]);
+    parsec_matrix_arena_datatype_destruct_free_type(&redistribute_check_taskpool->arenas_datatypes[PARSEC_redistribute_check_TARGET_ADT_IDX]);
 }
 
 PARSEC_OBJ_CLASS_INSTANCE(parsec_redistribute_check_taskpool_t, parsec_taskpool_t,
diff --git a/tests/collections/redistribute/redistribute_check2.jdf b/tests/collections/redistribute/redistribute_check2.jdf
index fcb4c0b52..a68ddb6f2 100644
--- a/tests/collections/redistribute/redistribute_check2.jdf
+++ b/tests/collections/redistribute/redistribute_check2.jdf
@@ -105,10 +105,8 @@ parsec_redistribute_check2_New(parsec_tiled_matrix_t *dcY,
     int n_END = (disj_Y+size_col-1)/dcY->nb;
     taskpool->_g_NT = (n_END-n_START)/taskpool->_g_num_col;
 
-    parsec_add2arena(&taskpool->arenas_datatypes[PARSEC_redistribute_check2_DEFAULT_ADT_IDX],
-                            MY_TYPE, PARSEC_MATRIX_FULL,
-                            1, dcY->mb, dcY->nb, dcY->mb,
-                            PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+    parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_check2_DEFAULT_ADT_IDX],
+                            MY_TYPE, dcY->mb, dcY->nb, dcY->mb);
 
     return redistribute_check2_taskpool;
 }
@@ -116,7 +114,7 @@ parsec_redistribute_check2_New(parsec_tiled_matrix_t *dcY,
 static void
 __parsec_taskpool_redistribute_check2_destructor(parsec_redistribute_check2_taskpool_t *redistribute_check2_taskpool)
 {
-    parsec_del2arena(&redistribute_check2_taskpool->arenas_datatypes[PARSEC_redistribute_check2_DEFAULT_ADT_IDX]);
+    parsec_matrix_arena_datatype_destruct_free_type(&redistribute_check2_taskpool->arenas_datatypes[PARSEC_redistribute_check2_DEFAULT_ADT_IDX]);
 }
 
 PARSEC_OBJ_CLASS_INSTANCE(parsec_redistribute_check2_taskpool_t, parsec_taskpool_t,
diff --git a/tests/collections/redistribute/redistribute_no_optimization.jdf b/tests/collections/redistribute/redistribute_no_optimization.jdf
index 4277520ac..c8eb96aef 100644
--- a/tests/collections/redistribute/redistribute_no_optimization.jdf
+++ b/tests/collections/redistribute/redistribute_no_optimization.jdf
@@ -428,15 +428,11 @@ parsec_redistribute_no_optimization_New(parsec_tiled_matrix_t *dcY,
     int n_T_END = (size_col+disj_T-1) / dcT->nb;
     taskpool->_g_NT = (n_T_END-n_T_START)/taskpool->_g_num_col;
 
-    parsec_add2arena(&taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_TARGET_ADT_IDX],
-                                MY_TYPE, PARSEC_MATRIX_FULL,
-                                1, dcT->mb, dcT->nb, dcT->mb,
-                                PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+    parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_TARGET_ADT_IDX],
+                                MY_TYPE, dcT->mb, dcT->nb, dcT->mb);
 
-    parsec_add2arena(&taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_SOURCE_ADT_IDX],
-		    MY_TYPE, PARSEC_MATRIX_FULL,
-		    1, dcY->mb, dcY->nb, dcY->mb,
-		    PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+    parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_SOURCE_ADT_IDX],
+                                MY_TYPE, dcY->mb, dcY->nb, dcY->mb);
 
     return redistribute_no_optimization_taskpool;
 }
@@ -447,8 +443,8 @@ parsec_redistribute_no_optimization_New(parsec_tiled_matrix_t *dcY,
 static void
 __parsec_taskpool_redistribute_no_optimization_destructor(parsec_redistribute_no_optimization_taskpool_t *redistribute_no_optimization_taskpool)
 {
-    parsec_del2arena(&redistribute_no_optimization_taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_TARGET_ADT_IDX]);
-    parsec_del2arena(&redistribute_no_optimization_taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_SOURCE_ADT_IDX]);
+    parsec_matrix_arena_datatype_destruct_free_type(&redistribute_no_optimization_taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_TARGET_ADT_IDX]);
+    parsec_matrix_arena_datatype_destruct_free_type(&redistribute_no_optimization_taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_SOURCE_ADT_IDX]);
 }
 
 PARSEC_OBJ_CLASS_INSTANCE(parsec_redistribute_no_optimization_taskpool_t, parsec_taskpool_t,
diff --git a/tests/collections/reshape/common.h b/tests/collections/reshape/common.h
index 45045bc21..2b0498afa 100644
--- a/tests/collections/reshape/common.h
+++ b/tests/collections/reshape/common.h
@@ -131,27 +131,18 @@ int reshape_print(parsec_execution_stream_t *es,
     parsec_arena_datatype_t adt_default;                                  \
     parsec_arena_datatype_t adt_lower;                                    \
     parsec_arena_datatype_t adt_upper;                                    \
-    parsec_add2arena( &adt_default,                                \
-                            parsec_datatype_int_t,                        \
-                            PARSEC_MATRIX_FULL,                     \
-                            1, MB, NB, MB,                                \
-                            PARSEC_ARENA_ALIGNMENT_SSE, -1 );             \
-                                                                          \
-    parsec_add2arena( &adt_lower,                                  \
-                             parsec_datatype_int_t,                       \
-                             PARSEC_MATRIX_LOWER, 1, MB, NB, MB,          \
-                             PARSEC_ARENA_ALIGNMENT_SSE, -1 );            \
-                                                                          \
-    parsec_add2arena( &adt_upper,                                  \
-                             parsec_datatype_int_t,                       \
-                             PARSEC_MATRIX_UPPER, 1, MB, NB, MB,          \
-                             PARSEC_ARENA_ALIGNMENT_SSE, -1 );            \
+    parsec_matrix_adt_construct_rect( &adt_default,                       \
+                            parsec_datatype_int_t, MB, NB, MB );          \
+    parsec_matrix_adt_construct_lower( &adt_lower,                        \
+                            parsec_datatype_int_t, 1, MB );               \
+    parsec_matrix_adt_construct_upper( &adt_upper,                        \
+                            parsec_datatype_int_t, 1, MB );               \
     (void)adt_default; (void)adt_lower; (void)adt_upper;
 
-#define DO_FINI_DATATYPES()                                              \
-    parsec_del2arena(&adt_default);                               \
-    parsec_del2arena(&adt_lower);                                 \
-    parsec_del2arena(&adt_upper);
+#define DO_FINI_DATATYPES()                                               \
+    parsec_matrix_arena_datatype_destruct_free_type(&adt_default);        \
+    parsec_matrix_arena_datatype_destruct_free_type(&adt_lower);          \
+    parsec_matrix_arena_datatype_destruct_free_type(&adt_upper);
 
 
 #define DO_RUN(ctp) do {                                                 \
diff --git a/tests/collections/two_dim_band/two_dim_band.jdf b/tests/collections/two_dim_band/two_dim_band.jdf
index b39facb5a..c9d30a29d 100644
--- a/tests/collections/two_dim_band/two_dim_band.jdf
+++ b/tests/collections/two_dim_band/two_dim_band.jdf
@@ -203,10 +203,8 @@ parsec_two_dim_band_New(parsec_tiled_matrix_t *Y, int uplo)
     taskpool = parsec_two_dim_band_new(Y, uplo);
     two_dim_band_taskpool = (parsec_taskpool_t*)taskpool;
 
-    parsec_add2arena( &taskpool->arenas_datatypes[PARSEC_two_dim_band_DEFAULT_ADT_IDX],
-                             parsec_datatype_double_t, PARSEC_MATRIX_FULL,
-                             1, Y->mb, Y->nb, Y->mb,
-                             PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+    parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_two_dim_band_DEFAULT_ADT_IDX],
+                             parsec_datatype_double_t, Y->mb, Y->nb, Y->mb);
     return two_dim_band_taskpool;
 }
 
@@ -216,7 +214,7 @@ parsec_two_dim_band_New(parsec_tiled_matrix_t *Y, int uplo)
 void parsec_two_dim_band_Destruct(parsec_taskpool_t *taskpool)
 {
     parsec_two_dim_band_taskpool_t *two_dim_band_taskpool = (parsec_two_dim_band_taskpool_t *)taskpool;
-    parsec_del2arena(&two_dim_band_taskpool->arenas_datatypes[PARSEC_two_dim_band_DEFAULT_ADT_IDX]);
+    parsec_matrix_arena_datatype_destruct_free_type(&two_dim_band_taskpool->arenas_datatypes[PARSEC_two_dim_band_DEFAULT_ADT_IDX]);
     parsec_taskpool_free(taskpool);
 }
 
diff --git a/tests/dsl/ptg/complex_deps.jdf b/tests/dsl/ptg/complex_deps.jdf
index 894c5d137..d47f2ac2e 100644
--- a/tests/dsl/ptg/complex_deps.jdf
+++ b/tests/dsl/ptg/complex_deps.jdf
@@ -167,7 +167,7 @@ int main( int argc, char** argv )
                                      descA.super.bsiz *
                                      parsec_datadist_getsizeoftype(TYPE) );
     parsec_translate_matrix_type(TYPE, &otype);
-    parsec_add2arena_rect(&adt, otype,
+    parsec_matrix_adt_construct_rect(&adt, otype,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
 
@@ -213,7 +213,7 @@ int main( int argc, char** argv )
     TIMER_STOP(time_elapsed);
     printf("DAG execution in %ld micro-sec\n", time_elapsed);
 
-    parsec_del2arena( & adt );
+    parsec_matrix_arena_datatype_destruct_free_type( & adt );
 
     free(descA.mat);
 
diff --git a/tests/dsl/ptg/local-indices/local_indices.jdf b/tests/dsl/ptg/local-indices/local_indices.jdf
index afddc9780..d7f360112 100644
--- a/tests/dsl/ptg/local-indices/local_indices.jdf
+++ b/tests/dsl/ptg/local-indices/local_indices.jdf
@@ -169,7 +169,7 @@ int main( int argc, char** argv )
     parsec_data_collection_set_key(&descA.super.super, "A");
 
     parsec_translate_matrix_type(PARSEC_MATRIX_DOUBLE, &dt);
-    parsec_add2arena_rect(&adt, dt,
+    parsec_matrix_adt_construct_rect(&adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
     /* Start the PaRSEC engine */
     rc = parsec_context_start(parsec);
@@ -219,7 +219,7 @@ int main( int argc, char** argv )
     parsec_taskpool_free(&tp->super);
 
     free(descA.mat);
-    parsec_del2arena( & adt );
+    parsec_matrix_arena_datatype_destruct_free_type( & adt );
 
     parsec_fini( &parsec);
 
diff --git a/tests/dsl/ptg/startup.jdf b/tests/dsl/ptg/startup.jdf
index e99dd042a..0f7651210 100644
--- a/tests/dsl/ptg/startup.jdf
+++ b/tests/dsl/ptg/startup.jdf
@@ -145,7 +145,7 @@ int main( int argc, char** argv )
                                      parsec_datadist_getsizeoftype(TYPE) );
 
     parsec_translate_matrix_type(TYPE, &dt);
-    parsec_add2arena_rect(&adt, dt,
+    parsec_matrix_adt_construct_rect(&adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
     srandom((int)getpid());  /* Start the random generator */
@@ -203,7 +203,7 @@ int main( int argc, char** argv )
     }
 
     free(descA.mat);
-    parsec_del2arena( & adt );
+    parsec_matrix_arena_datatype_destruct_free_type( & adt );
 
     parsec_fini( &parsec);
 
diff --git a/tests/dsl/ptg/user-defined-functions/utt.jdf b/tests/dsl/ptg/user-defined-functions/utt.jdf
index 63ebe9c8b..43313ed0a 100644
--- a/tests/dsl/ptg/user-defined-functions/utt.jdf
+++ b/tests/dsl/ptg/user-defined-functions/utt.jdf
@@ -143,7 +143,7 @@ int main( int argc, char** argv )
     parsec_data_collection_set_key(&descA.super.super, "A");
 
     parsec_translate_matrix_type(PARSEC_MATRIX_DOUBLE, &dt);
-    parsec_add2arena( &adt, dt, PARSEC_MATRIX_FULL, 0, descA.super.mb, descA.super.nb, descA.super.mb, PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+    parsec_matrix_adt_construct_rect( &adt, dt, descA.super.mb, descA.super.nb, descA.super.mb);
 
     /* Start the PaRSEC engine */
     rc = parsec_context_start(parsec);
@@ -173,7 +173,7 @@ int main( int argc, char** argv )
     }
 
     free(descA.mat);
-    parsec_del2arena( & adt );
+    parsec_matrix_arena_datatype_destruct_free_type( & adt );
 
     parsec_fini( &parsec);
 
diff --git a/tests/profiling/async.jdf b/tests/profiling/async.jdf
index 487c2ea21..ccf1f98ef 100644
--- a/tests/profiling/async.jdf
+++ b/tests/profiling/async.jdf
@@ -230,7 +230,7 @@ int main( int argc, char** argv )
     parsec_data_collection_set_key(&descA.super.super, "A");
 
     parsec_translate_matrix_type(PARSEC_MATRIX_DOUBLE, &dt);
-    parsec_add2arena_rect(&adt, dt,
+    parsec_matrix_adt_construct_rect(&adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
     /* Start the PaRSEC engine */
@@ -247,7 +247,7 @@ int main( int argc, char** argv )
     PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
 
     free(descA.mat);
-    parsec_del2arena( & adt );
+    parsec_matrix_arena_datatype_destruct_free_type( & adt );
 
     parsec_taskpool_free( (parsec_taskpool_t*)tp );
 
diff --git a/tests/runtime/cuda/get_best_device_check.jdf b/tests/runtime/cuda/get_best_device_check.jdf
index 65025d8e1..26676d2a2 100644
--- a/tests/runtime/cuda/get_best_device_check.jdf
+++ b/tests/runtime/cuda/get_best_device_check.jdf
@@ -169,10 +169,8 @@ parsec_get_best_device_check_New(parsec_tiled_matrix_t *dcA, int *info)
     taskpool->_g_cuda_device_index = dev_index;
 #endif
 
-    parsec_add2arena( &taskpool->arenas_datatypes[PARSEC_get_best_device_check_DEFAULT_ADT_IDX],
-            parsec_datatype_double_t, PARSEC_MATRIX_FULL,
-            1, dcA->mb, dcA->nb, dcA->mb,
-            PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+    parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_get_best_device_check_DEFAULT_ADT_IDX],
+            parsec_datatype_double_t, dcA->mb, dcA->nb, dcA->mb);
 
     return get_best_device_check_taskpool;
 }
@@ -183,7 +181,7 @@ parsec_get_best_device_check_New(parsec_tiled_matrix_t *dcA, int *info)
 static void
 __parsec_taskpool_get_best_device_check_destructor(parsec_get_best_device_check_taskpool_t *get_best_device_check_taskpool)
 {
-    parsec_del2arena(&get_best_device_check_taskpool->arenas_datatypes[PARSEC_get_best_device_check_DEFAULT_ADT_IDX]);
+    parsec_matrix_arena_datatype_destruct_free_type(&get_best_device_check_taskpool->arenas_datatypes[PARSEC_get_best_device_check_DEFAULT_ADT_IDX]);
 #if defined(PARSEC_HAVE_DEV_CUDA_SUPPORT)
     if( NULL != get_best_device_check_taskpool->_g_cuda_device_index )
         free(get_best_device_check_taskpool->_g_cuda_device_index);
diff --git a/tests/runtime/cuda/nvlink_wrapper.c b/tests/runtime/cuda/nvlink_wrapper.c
index 14c873bad..5dbdb8d6e 100644
--- a/tests/runtime/cuda/nvlink_wrapper.c
+++ b/tests/runtime/cuda/nvlink_wrapper.c
@@ -64,7 +64,7 @@ __parsec_nvlink_destructor( parsec_nvlink_taskpool_t* nvlink_taskpool)
     int g, dev;
     parsec_matrix_block_cyclic_t *userM;
     parsec_matrix_block_cyclic_t *dcA;
-    parsec_del2arena( & nvlink_taskpool->arenas_datatypes[PARSEC_nvlink_DEFAULT_ADT_IDX] );
+    parsec_matrix_arena_datatype_destruct_free_type( & nvlink_taskpool->arenas_datatypes[PARSEC_nvlink_DEFAULT_ADT_IDX] );
     parsec_data_free(nvlink_taskpool->_g_descA->mat);
     parsec_info_unregister(&parsec_per_stream_infos, nvlink_taskpool->_g_CuHI, NULL);
     dcA = nvlink_taskpool->_g_descA;
@@ -156,7 +156,7 @@ parsec_taskpool_t* testing_nvlink_New( parsec_context_t *ctx, int depth, int mb
 
     /* GEMM1 tasks will create one data copy per GPU, and work on those.
      * see nvlink.jdf:MAKE_C tasks */
-    
+
     /* userM is a user-managed matrix: the user creates the data copies
      * only on the GPU they want the GEMM2 to run. To simplify the code,
      * we use parsec_matrix_block_cyclic that requires to also have a CPU data
@@ -208,14 +208,12 @@ parsec_taskpool_t* testing_nvlink_New( parsec_context_t *ctx, int depth, int mb
             g++;
         }
     }
-    
+
     testing_handle = parsec_nvlink_new(dcA, userM, ctx->nb_nodes, CuHI, nb, dev_index);
 
-    parsec_add2arena( &testing_handle->arenas_datatypes[PARSEC_nvlink_DEFAULT_ADT_IDX],
-                             parsec_datatype_double_complex_t,
-                             PARSEC_MATRIX_FULL, 1, mb, mb, mb,
-                             PARSEC_ARENA_ALIGNMENT_SSE, -1 );
-    
+    parsec_matrix_adt_construct_tile( &testing_handle->arenas_datatypes[PARSEC_nvlink_DEFAULT_ADT_IDX],
+                             parsec_datatype_double_complex_t, mb );
+
     return &testing_handle->super;
 }
 
diff --git a/tests/runtime/cuda/stress_wrapper.c b/tests/runtime/cuda/stress_wrapper.c
index 457610377..d291f5c3c 100644
--- a/tests/runtime/cuda/stress_wrapper.c
+++ b/tests/runtime/cuda/stress_wrapper.c
@@ -10,7 +10,7 @@ static void __parsec_stress_destructor( parsec_taskpool_t *tp )
 {
     parsec_stress_taskpool_t *stress_taskpool = (parsec_stress_taskpool_t *)tp;
     parsec_matrix_block_cyclic_t *dcA;
-    parsec_del2arena( & stress_taskpool->arenas_datatypes[PARSEC_stress_DEFAULT_ADT_IDX] );
+    parsec_matrix_arena_datatype_destruct_free_type( & stress_taskpool->arenas_datatypes[PARSEC_stress_DEFAULT_ADT_IDX] );
     parsec_data_free(stress_taskpool->_g_descA->mat);
     dcA = stress_taskpool->_g_descA;
     parsec_tiled_matrix_destroy( (parsec_tiled_matrix_t*)stress_taskpool->_g_descA );
@@ -72,10 +72,8 @@ parsec_taskpool_t* testing_stress_New( parsec_context_t *ctx, int depth, int mb
 
     testing_handle = parsec_stress_new(dcA, ctx->nb_nodes, nb, dev_index);
 
-    parsec_add2arena( &testing_handle->arenas_datatypes[PARSEC_stress_DEFAULT_ADT_IDX],
-                             parsec_datatype_double_complex_t,
-                             PARSEC_MATRIX_FULL, 1, mb, mb, mb,
-                             PARSEC_ARENA_ALIGNMENT_SSE, -1 );
+    parsec_matrix_adt_construct_tile( &testing_handle->arenas_datatypes[PARSEC_stress_DEFAULT_ADT_IDX],
+                             parsec_datatype_double_complex_t, mb );
     return &testing_handle->super;
 }
 

From 45d6c62a04d4295db58f1bfcbfe4f468b46fbd99 Mon Sep 17 00:00:00 2001
From: Aurelien Bouteiller <bouteill@icl.utk.edu>
Date: Tue, 23 Apr 2024 17:38:24 -0400
Subject: [PATCH 8/9] bugfix: handle the case where the adt is persistent

---
 parsec/data.c                                 | 21 +++++++++++++++----
 parsec/data_dist/matrix/matrix.h              |  7 ++++---
 parsec/interfaces/ptg/ptg-compiler/jdf2c.c    |  5 ++++-
 tests/apps/haar_tree/main.c                   | 13 +++++-------
 tests/collections/reshape/common.h            |  3 +++
 .../reshape/testing_avoidable_reshape.c       |  1 -
 ...ting_remote_multiple_outs_same_pred_flow.c |  3 ---
 tests/collections/reshape/testing_reshape.c   | 12 -----------
 tests/dsl/ptg/complex_deps.jdf                | 11 +++++-----
 tests/dsl/ptg/local-indices/local_indices.jdf |  8 +++----
 tests/dsl/ptg/recursive.jdf                   |  8 +++----
 tests/dsl/ptg/startup.jdf                     | 14 ++++++-------
 tests/dsl/ptg/user-defined-functions/utt.jdf  |  8 +++----
 tests/profiling/async.jdf                     |  8 +++----
 14 files changed, 60 insertions(+), 62 deletions(-)

diff --git a/parsec/data.c b/parsec/data.c
index 48013b68f..d5892cd6e 100644
--- a/parsec/data.c
+++ b/parsec/data.c
@@ -568,7 +568,8 @@ parsec_data_destroy( parsec_data_t *data )
 
 /* adt constructor is split in two stages: when the adt is constructed
  * with OBJ_CONSTRUCT (or allocated with OBJ_NEW), we initialize the
- * adt object. The user code must then call the parameterized constructor
+ * adt object with static zero values.
+ * The user code must then call the parameterized constructor
  * (below) that attaches the datatype and creates the associated arena.
  *
  * When the adt object is destructed (or released), the implicit destructor
@@ -583,11 +584,23 @@ int parsec_arena_datatype_construct(parsec_arena_datatype_t *adt,
     adt->arena = PARSEC_OBJ_NEW(parsec_arena_t);
     parsec_arena_construct(adt->arena, elem_size,
                            alignment);
+    adt->opaque_dtt         = opaque_dtt;
+    return PARSEC_SUCCESS;
+}
+
+/* This constructor must only initialize fields with static values.
+ * When the user is using a persistent adt, the PTG generator will
+ * construct_zero the static arenas, and the user will overwrite them
+ * without calling destruct, which is valid only if this function does
+ * not allocate memory.
+ */
+static void parsec_arena_datatype_construct_zero(parsec_object_t *obj) {
+    parsec_arena_datatype_t *adt = (parsec_arena_datatype_t *)obj;
+    adt->arena              = NULL;
     adt->ht_item.next_item  = NULL; /* keep Coverity happy */
     adt->ht_item.hash64     = 0;    /* keep Coverity happy */
     adt->ht_item.key        = 0;    /* keep Coverity happy */
-    adt->opaque_dtt         = opaque_dtt;
-    return PARSEC_SUCCESS;
+    adt->opaque_dtt         = NULL;
 }
 
 static void parsec_arena_datatype_destruct(parsec_object_t *obj) {
@@ -596,5 +609,5 @@ static void parsec_arena_datatype_destruct(parsec_object_t *obj) {
 }
 
 PARSEC_OBJ_CLASS_INSTANCE(parsec_arena_datatype_t, parsec_object_t,
-                          NULL,
+                          parsec_arena_datatype_construct_zero,
                           parsec_arena_datatype_destruct);
diff --git a/parsec/data_dist/matrix/matrix.h b/parsec/data_dist/matrix/matrix.h
index 1f6794d50..bc796b797 100644
--- a/parsec/data_dist/matrix/matrix.h
+++ b/parsec/data_dist/matrix/matrix.h
@@ -366,9 +366,10 @@ int parsec_matrix_arena_datatype_destruct_free_type(parsec_arena_datatype_t *adt
      parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_n_), (_ld_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
      (_adt_))
 
-#define parsec_matrix_adt_free(_adt_) do {\
-    parsec_matrix_arena_datatype_destruct_free_type(_adt_); \
-    free(_adt_); \
+#define parsec_matrix_adt_free(_padt_) do {\
+    parsec_matrix_arena_datatype_destruct_free_type(*(_padt_)); \
+    free(*(_padt_)); \
+    (*_padt_) = NULL; \
 } while(0)
 
 
diff --git a/parsec/interfaces/ptg/ptg-compiler/jdf2c.c b/parsec/interfaces/ptg/ptg-compiler/jdf2c.c
index bb7e41b53..f017b0447 100644
--- a/parsec/interfaces/ptg/ptg-compiler/jdf2c.c
+++ b/parsec/interfaces/ptg/ptg-compiler/jdf2c.c
@@ -4758,7 +4758,10 @@ static void jdf_generate_constructor( const jdf_t* jdf )
          * stages, one in the generated code runs the generic constructor, then
          * the user code calls the parameterized constructor (that attaches the
          * datatype). Thus, for symmetry the user code is also responsible for calling
-         * the destructor. */
+         * the destructor.
+         * The statically constructed arena_datatype_t can be overwritten by
+         * the user without leaking memory.
+         */
         coutput("  for(i = 0; i < (uint32_t)__parsec_tp->super.arenas_datatypes_size; i++) {\n"
                 "    PARSEC_OBJ_CONSTRUCT(&__parsec_tp->super.arenas_datatypes[i], parsec_arena_datatype_t);\n"
                 "  }\n");
diff --git a/tests/apps/haar_tree/main.c b/tests/apps/haar_tree/main.c
index 381b2c426..bf37f39bf 100644
--- a/tests/apps/haar_tree/main.c
+++ b/tests/apps/haar_tree/main.c
@@ -143,7 +143,7 @@ int main(int argc, char *argv[])
     parsec_matrix_block_cyclic_t fakeDesc;
     parsec_project_taskpool_t *project;
     parsec_walk_taskpool_t *walker;
-    parsec_arena_datatype_t adt;
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
     int do_checks = 0, be_verbose = 0;
     int pargc = 0, i;
     char **pargv;
@@ -216,7 +216,7 @@ int main(int argc, char *argv[])
                               0, 0, world, world,
                               1, world, 1, 1, 0, 0);
 
-    parsec_matrix_adt_construct_rect( &adt,
+    parsec_matrix_adt_construct_rect( adt,
              parsec_datatype_float_t, 2, 1, 2);
 
 #if defined(HAVE_MPI)
@@ -224,8 +224,7 @@ int main(int argc, char *argv[])
 #endif
 
     project = parsec_project_new(treeA, world, (parsec_data_collection_t*)&fakeDesc, 1e-3, be_verbose, 1.0);
-    project->arenas_datatypes[PARSEC_project_DEFAULT_ADT_IDX] = adt;
-    PARSEC_OBJ_RETAIN(adt.arena);
+    project->arenas_datatypes[PARSEC_project_DEFAULT_ADT_IDX] = *adt;
     rc = parsec_context_add_taskpool(parsec, &project->super);
     PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
     rc = parsec_context_start(parsec);
@@ -233,7 +232,6 @@ int main(int argc, char *argv[])
     rc = parsec_context_wait(parsec);
     PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
 
-    project->arenas_datatypes[PARSEC_project_DEFAULT_ADT_IDX].arena = NULL;
     parsec_taskpool_free(&project->super);
     ret = 0;
 
@@ -247,7 +245,7 @@ int main(int argc, char *argv[])
                                 rs, print_node_fn, print_link_fn,
                                 be_verbose);
     }
-    walker->arenas_datatypes[PARSEC_walk_DEFAULT_ADT_IDX] = adt;
+    walker->arenas_datatypes[PARSEC_walk_DEFAULT_ADT_IDX] = *adt;
     rc = parsec_context_add_taskpool(parsec, &walker->super);
     PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
     rc = parsec_context_start(parsec);
@@ -291,9 +289,8 @@ int main(int argc, char *argv[])
         }
     }
 #endif  /* defined(HAVE_MPI) */
-    parsec_matrix_arena_datatype_destruct_free_type( & adt );
+    parsec_matrix_adt_free( &adt );
 
-    walker->arenas_datatypes[PARSEC_walk_DEFAULT_ADT_IDX].arena = NULL;
     parsec_taskpool_free(&walker->super);
 
     tree_dist_free(treeA);
diff --git a/tests/collections/reshape/common.h b/tests/collections/reshape/common.h
index 2b0498afa..ec8972169 100644
--- a/tests/collections/reshape/common.h
+++ b/tests/collections/reshape/common.h
@@ -131,6 +131,9 @@ int reshape_print(parsec_execution_stream_t *es,
     parsec_arena_datatype_t adt_default;                                  \
     parsec_arena_datatype_t adt_lower;                                    \
     parsec_arena_datatype_t adt_upper;                                    \
+    PARSEC_OBJ_CONSTRUCT(&adt_default, parsec_arena_datatype_t);          \
+    PARSEC_OBJ_CONSTRUCT(&adt_lower, parsec_arena_datatype_t);            \
+    PARSEC_OBJ_CONSTRUCT(&adt_upper, parsec_arena_datatype_t);            \
     parsec_matrix_adt_construct_rect( &adt_default,                       \
                             parsec_datatype_int_t, MB, NB, MB );          \
     parsec_matrix_adt_construct_lower( &adt_lower,                        \
diff --git a/tests/collections/reshape/testing_avoidable_reshape.c b/tests/collections/reshape/testing_avoidable_reshape.c
index 365eaa7f9..39ca3f221 100644
--- a/tests/collections/reshape/testing_avoidable_reshape.c
+++ b/tests/collections/reshape/testing_avoidable_reshape.c
@@ -92,7 +92,6 @@ int main(int argc, char *argv[])
       parsec_datatype_t tmp = adt_default.opaque_dtt;
       ctp->arenas_datatypes[PARSEC_avoidable_reshape_DEFAULT_ADT_IDX].opaque_dtt = dcA.super.super.default_dtt;
 #endif
-      PARSEC_OBJ_RETAIN(adt_default.arena);
 
       DO_RUN(ctp);
       DO_CHECK(avoidable_reshape, dcA, dcA_check);
diff --git a/tests/collections/reshape/testing_remote_multiple_outs_same_pred_flow.c b/tests/collections/reshape/testing_remote_multiple_outs_same_pred_flow.c
index 5366cb91b..baed1066e 100644
--- a/tests/collections/reshape/testing_remote_multiple_outs_same_pred_flow.c
+++ b/tests/collections/reshape/testing_remote_multiple_outs_same_pred_flow.c
@@ -116,9 +116,6 @@ int main(int argc, char *argv[])
       ctp->arenas_datatypes[PARSEC_remote_multiple_outs_same_pred_flow_DEFAULT_ADT_IDX]    = adt_default;
       ctp->arenas_datatypes[PARSEC_remote_multiple_outs_same_pred_flow_LOWER_TILE_ADT_IDX] = adt_lower;
       ctp->arenas_datatypes[PARSEC_remote_multiple_outs_same_pred_flow_UPPER_TILE_ADT_IDX] = adt_upper;
-      PARSEC_OBJ_RETAIN(adt_default.arena);
-      PARSEC_OBJ_RETAIN(adt_lower.arena);
-      PARSEC_OBJ_RETAIN(adt_upper.arena);
 
       DO_RUN(ctp);
       DO_CHECK(remote_multiple_outs_same_pred_flow, dcA, dcA_check);
diff --git a/tests/collections/reshape/testing_reshape.c b/tests/collections/reshape/testing_reshape.c
index 9f2433507..b5c9d48ca 100644
--- a/tests/collections/reshape/testing_reshape.c
+++ b/tests/collections/reshape/testing_reshape.c
@@ -92,8 +92,6 @@ int main(int argc, char *argv[])
 
       ctp->arenas_datatypes[PARSEC_local_no_reshape_DEFAULT_ADT_IDX]    = adt_default;
       ctp->arenas_datatypes[PARSEC_local_no_reshape_LOWER_TILE_ADT_IDX] = adt_lower;
-      PARSEC_OBJ_RETAIN(adt_default.arena);
-      PARSEC_OBJ_RETAIN(adt_lower.arena);
 
       DO_RUN(ctp);
       DO_CHECK(local_no_reshape, dcA, dcA_check);
@@ -124,8 +122,6 @@ int main(int argc, char *argv[])
 
       ctp->arenas_datatypes[PARSEC_local_read_reshape_DEFAULT_ADT_IDX]    = adt_default;
       ctp->arenas_datatypes[PARSEC_local_read_reshape_LOWER_TILE_ADT_IDX] = adt_lower;
-      PARSEC_OBJ_RETAIN(adt_default.arena);
-      PARSEC_OBJ_RETAIN(adt_lower.arena);
 
       DO_RUN(ctp);
       DO_CHECK(local_read_reshape, dcA, dcA_check);
@@ -157,8 +153,6 @@ int main(int argc, char *argv[])
 
       ctp->arenas_datatypes[PARSEC_local_output_reshape_DEFAULT_ADT_IDX]    = adt_default;
       ctp->arenas_datatypes[PARSEC_local_output_reshape_LOWER_TILE_ADT_IDX] = adt_lower;
-      PARSEC_OBJ_RETAIN(adt_default.arena);
-      PARSEC_OBJ_RETAIN(adt_lower.arena);
 
       DO_RUN(ctp);
       DO_CHECK(local_output_reshape, dcA, dcA_check);
@@ -190,8 +184,6 @@ int main(int argc, char *argv[])
 
       ctp->arenas_datatypes[PARSEC_local_input_reshape_DEFAULT_ADT_IDX]    = adt_default;
       ctp->arenas_datatypes[PARSEC_local_input_reshape_LOWER_TILE_ADT_IDX] = adt_lower;
-      PARSEC_OBJ_RETAIN(adt_default.arena);
-      PARSEC_OBJ_RETAIN(adt_lower.arena);
 
       DO_RUN(ctp);
       DO_CHECK(local_input_reshape, dcA, dcA_check);
@@ -222,8 +214,6 @@ int main(int argc, char *argv[])
 
       ctp->arenas_datatypes[PARSEC_remote_read_reshape_DEFAULT_ADT_IDX]    = adt_default;
       ctp->arenas_datatypes[PARSEC_remote_read_reshape_LOWER_TILE_ADT_IDX] = adt_lower;
-      PARSEC_OBJ_RETAIN(adt_default.arena);
-      PARSEC_OBJ_RETAIN(adt_lower.arena);
 
       DO_RUN(ctp);
       DO_CHECK(remote_read_reshape, dcA, dcA_check);
@@ -252,8 +242,6 @@ int main(int argc, char *argv[])
 
       ctp->arenas_datatypes[PARSEC_remote_no_re_reshape_DEFAULT_ADT_IDX]    = adt_default;
       ctp->arenas_datatypes[PARSEC_remote_no_re_reshape_LOWER_TILE_ADT_IDX] = adt_lower;
-      PARSEC_OBJ_RETAIN(adt_default.arena);
-      PARSEC_OBJ_RETAIN(adt_lower.arena);
 
       DO_RUN(ctp);
       DO_CHECK(remote_no_re_reshape, dcA, dcA_check);
diff --git a/tests/dsl/ptg/complex_deps.jdf b/tests/dsl/ptg/complex_deps.jdf
index d47f2ac2e..df31fe438 100644
--- a/tests/dsl/ptg/complex_deps.jdf
+++ b/tests/dsl/ptg/complex_deps.jdf
@@ -111,7 +111,7 @@ int main( int argc, char** argv )
 {
     parsec_complex_deps_taskpool_t* tp;
     parsec_matrix_block_cyclic_t descA;
-    parsec_arena_datatype_t adt;
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
     parsec_datatype_t otype;
     parsec_context_t *parsec;
     int ni = NN, nk = NN, verbose = 0, i = 1, rc;
@@ -167,15 +167,14 @@ int main( int argc, char** argv )
                                      descA.super.bsiz *
                                      parsec_datadist_getsizeoftype(TYPE) );
     parsec_translate_matrix_type(TYPE, &otype);
-    parsec_matrix_adt_construct_rect(&adt, otype,
+    parsec_matrix_adt_construct_rect(adt, otype,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
 
     /* Heat up the engine: small tasks */
     tp = parsec_complex_deps_new( &descA, ni, nk );
     assert( NULL != tp );
-    tp->arenas_datatypes[PARSEC_complex_deps_DEFAULT_ADT_IDX] = adt;
-    PARSEC_OBJ_RETAIN(adt.arena);
+    tp->arenas_datatypes[PARSEC_complex_deps_DEFAULT_ADT_IDX] = *adt;
 
     rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
     PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
@@ -191,7 +190,7 @@ int main( int argc, char** argv )
     tp = parsec_complex_deps_new( &descA, ni, nk );
     assert( NULL != tp );
     TIMER_START(time_elapsed);
-    tp->arenas_datatypes[PARSEC_complex_deps_DEFAULT_ADT_IDX] = adt;
+    tp->arenas_datatypes[PARSEC_complex_deps_DEFAULT_ADT_IDX] = *adt;
     rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
     PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
     TIMER_STOP(time_elapsed);
@@ -213,7 +212,7 @@ int main( int argc, char** argv )
     TIMER_STOP(time_elapsed);
     printf("DAG execution in %ld micro-sec\n", time_elapsed);
 
-    parsec_matrix_arena_datatype_destruct_free_type( & adt );
+    parsec_matrix_adt_free( & adt );
 
     free(descA.mat);
 
diff --git a/tests/dsl/ptg/local-indices/local_indices.jdf b/tests/dsl/ptg/local-indices/local_indices.jdf
index d7f360112..4df0b7f28 100644
--- a/tests/dsl/ptg/local-indices/local_indices.jdf
+++ b/tests/dsl/ptg/local-indices/local_indices.jdf
@@ -120,7 +120,7 @@ int main( int argc, char** argv )
 {
     parsec_local_indices_taskpool_t* tp;
     parsec_matrix_block_cyclic_t descA;
-    parsec_arena_datatype_t adt;
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
     parsec_datatype_t dt;
     parsec_context_t *parsec;
     int ws = 1, mr = 0;
@@ -169,7 +169,7 @@ int main( int argc, char** argv )
     parsec_data_collection_set_key(&descA.super.super, "A");
 
     parsec_translate_matrix_type(PARSEC_MATRIX_DOUBLE, &dt);
-    parsec_matrix_adt_construct_rect(&adt, dt,
+    parsec_matrix_adt_construct_rect(adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
     /* Start the PaRSEC engine */
     rc = parsec_context_start(parsec);
@@ -179,7 +179,7 @@ int main( int argc, char** argv )
     memset(local_nb, 0, 4*sizeof(int));
     tp = parsec_local_indices_new( &descA, (int32_t*)local_nb );
     assert( NULL != tp );
-    tp->arenas_datatypes[PARSEC_local_indices_DEFAULT_ADT_IDX] = adt;
+    tp->arenas_datatypes[PARSEC_local_indices_DEFAULT_ADT_IDX] = *adt;
     rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
     PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
     rc = parsec_context_wait(parsec);
@@ -219,7 +219,7 @@ int main( int argc, char** argv )
     parsec_taskpool_free(&tp->super);
 
     free(descA.mat);
-    parsec_matrix_arena_datatype_destruct_free_type( & adt );
+    parsec_matrix_adt_free( &adt );
 
     parsec_fini( &parsec);
 
diff --git a/tests/dsl/ptg/recursive.jdf b/tests/dsl/ptg/recursive.jdf
index 733b19718..e7f4e443f 100644
--- a/tests/dsl/ptg/recursive.jdf
+++ b/tests/dsl/ptg/recursive.jdf
@@ -96,7 +96,7 @@ int main( int argc, char** argv )
 {
     parsec_recursive_taskpool_t* tp;
     parsec_matrix_block_cyclic_t descA;
-    parsec_arena_datatype_t adt;
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
     parsec_datatype_t dt;
     parsec_context_t *parsec;
     int ni = NN, level = 3, i = 1, rc;
@@ -147,7 +147,7 @@ int main( int argc, char** argv )
 
     parsec_translate_matrix_type(TYPE, &dt);
 
-    parsec_matrix_adt_construct_rect(&adt, dt,
+    parsec_matrix_adt_construct_rect(adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
     /* Start the PaRSEC engine */
@@ -157,7 +157,7 @@ int main( int argc, char** argv )
     /* Heat up the engine: small tasks no priority */
     tp = parsec_recursive_new( (parsec_matrix_block_cyclic_t*)&descA, level, ni );
     assert( NULL != tp );
-    tp->arenas_datatypes[PARSEC_recursive_DEFAULT_ADT_IDX] = adt;
+    tp->arenas_datatypes[PARSEC_recursive_DEFAULT_ADT_IDX] = *adt;
 
     tp->_g_pri = 0;
     rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
@@ -167,7 +167,7 @@ int main( int argc, char** argv )
     PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
 
     free(descA.mat);
-    parsec_matrix_arena_datatype_destruct_free_type(&adt);
+    parsec_matrix_adt_free(&adt);
 
     parsec_fini( &parsec);
 
diff --git a/tests/dsl/ptg/startup.jdf b/tests/dsl/ptg/startup.jdf
index 0f7651210..ef42d5d36 100644
--- a/tests/dsl/ptg/startup.jdf
+++ b/tests/dsl/ptg/startup.jdf
@@ -90,7 +90,7 @@ int main( int argc, char** argv )
 {
     parsec_startup_taskpool_t* tp;
     parsec_matrix_block_cyclic_t descA;
-    parsec_arena_datatype_t adt;
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
     parsec_datatype_t dt;
     parsec_context_t *parsec;
     int ni = NN, nj = NN, nk = NN, verbose = 0, i = 1, rc;
@@ -145,7 +145,7 @@ int main( int argc, char** argv )
                                      parsec_datadist_getsizeoftype(TYPE) );
 
     parsec_translate_matrix_type(TYPE, &dt);
-    parsec_matrix_adt_construct_rect(&adt, dt,
+    parsec_matrix_adt_construct_rect(adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
     srandom((int)getpid());  /* Start the random generator */
@@ -157,10 +157,9 @@ int main( int argc, char** argv )
     /* Heat up the engine: small tasks no priority */
     tp = parsec_startup_new( &descA, ni, nj, nk );
     assert( NULL != tp );
-    tp->arenas_datatypes[PARSEC_startup_DEFAULT_ADT_IDX] = adt;
-    PARSEC_OBJ_RETAIN(adt.arena);
-
+    tp->arenas_datatypes[PARSEC_startup_DEFAULT_ADT_IDX] = *adt;
     tp->_g_pri = 0;
+
     rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
     PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
     rc = parsec_context_wait(parsec);
@@ -177,8 +176,7 @@ int main( int argc, char** argv )
         assert( NULL != tp );
 
         TIMER_START(time_elapsed);
-        tp->arenas_datatypes[PARSEC_startup_DEFAULT_ADT_IDX] = adt;
-        PARSEC_OBJ_RETAIN(adt.arena);
+        tp->arenas_datatypes[PARSEC_startup_DEFAULT_ADT_IDX] = *adt;
         tp->_g_pri = priorities[i].prio;
 
         rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
@@ -203,7 +201,7 @@ int main( int argc, char** argv )
     }
 
     free(descA.mat);
-    parsec_matrix_arena_datatype_destruct_free_type( & adt );
+    parsec_matrix_adt_free(&adt);
 
     parsec_fini( &parsec);
 
diff --git a/tests/dsl/ptg/user-defined-functions/utt.jdf b/tests/dsl/ptg/user-defined-functions/utt.jdf
index 43313ed0a..a8576d92d 100644
--- a/tests/dsl/ptg/user-defined-functions/utt.jdf
+++ b/tests/dsl/ptg/user-defined-functions/utt.jdf
@@ -101,7 +101,7 @@ int main( int argc, char** argv )
 {
     parsec_utt_taskpool_t* tp;
     parsec_matrix_block_cyclic_t descA;
-    parsec_arena_datatype_t adt;
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
     parsec_datatype_t dt;
     parsec_context_t *parsec;
     int ws = 1, mr = 0;
@@ -143,7 +143,7 @@ int main( int argc, char** argv )
     parsec_data_collection_set_key(&descA.super.super, "A");
 
     parsec_translate_matrix_type(PARSEC_MATRIX_DOUBLE, &dt);
-    parsec_matrix_adt_construct_rect( &adt, dt, descA.super.mb, descA.super.nb, descA.super.mb);
+    parsec_matrix_adt_construct_rect( adt, dt, descA.super.mb, descA.super.nb, descA.super.mb);
 
     /* Start the PaRSEC engine */
     rc = parsec_context_start(parsec);
@@ -152,7 +152,7 @@ int main( int argc, char** argv )
     nb_tasks = 0;
     tp = parsec_utt_new( &descA, &nb_tasks, nt, 1 );
     assert( NULL != tp );
-    tp->arenas_datatypes[PARSEC_utt_DEFAULT_ADT_IDX] = adt;
+    tp->arenas_datatypes[PARSEC_utt_DEFAULT_ADT_IDX] = *adt;
     rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
     PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
     rc = parsec_context_wait(parsec);
@@ -173,7 +173,7 @@ int main( int argc, char** argv )
     }
 
     free(descA.mat);
-    parsec_matrix_arena_datatype_destruct_free_type( & adt );
+    parsec_matrix_adt_free( & adt );
 
     parsec_fini( &parsec);
 
diff --git a/tests/profiling/async.jdf b/tests/profiling/async.jdf
index ccf1f98ef..f755f6a2b 100644
--- a/tests/profiling/async.jdf
+++ b/tests/profiling/async.jdf
@@ -153,7 +153,7 @@ int main( int argc, char** argv )
 {
     parsec_async_taskpool_t* tp;
     parsec_matrix_block_cyclic_t descA;
-    parsec_arena_datatype_t adt;
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
     parsec_datatype_t dt;
     parsec_context_t *parsec;
     int ws, mr, rc;
@@ -230,7 +230,7 @@ int main( int argc, char** argv )
     parsec_data_collection_set_key(&descA.super.super, "A");
 
     parsec_translate_matrix_type(PARSEC_MATRIX_DOUBLE, &dt);
-    parsec_matrix_adt_construct_rect(&adt, dt,
+    parsec_matrix_adt_construct_rect(adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
     /* Start the PaRSEC engine */
@@ -239,7 +239,7 @@ int main( int argc, char** argv )
 
     tp = parsec_async_new( &descA, verbose, taskqueue, NB );
     assert( NULL != tp );
-    tp->arenas_datatypes[PARSEC_async_DEFAULT_ADT_IDX] = adt;
+    tp->arenas_datatypes[PARSEC_async_DEFAULT_ADT_IDX] = *adt;
     rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
     PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
 
@@ -247,7 +247,7 @@ int main( int argc, char** argv )
     PARSEC_CHECK_ERROR(rc, "parsec_context_wait");
 
     free(descA.mat);
-    parsec_matrix_arena_datatype_destruct_free_type( & adt );
+    parsec_matrix_adt_free( & adt );
 
     parsec_taskpool_free( (parsec_taskpool_t*)tp );
 

From 12fdcd404a0c1e021e32d81b1aab1d89d0af56dd Mon Sep 17 00:00:00 2001
From: Aurelien Bouteiller <bouteill@icl.utk.edu>
Date: Wed, 22 May 2024 11:58:38 -0400
Subject: [PATCH 9/9] add2arena: rename the replacements to add2arena for
 consistency with contructor/destructor naming conventions

---
 .../build_with_parsec/dtd_test_allreduce.c    |  4 +-
 contrib/renaming/README.md                    | 13 +--
 contrib/renaming/rename.sed                   |  5 +-
 examples/Ex02_Chain.jdf                       |  8 +-
 examples/Ex03_ChainMPI.jdf                    |  6 +-
 examples/Ex04_ChainData.jdf                   |  6 +-
 examples/Ex05_Broadcast.jdf                   |  6 +-
 examples/Ex06_RAW.jdf                         |  6 +-
 examples/Ex07_RAW_CTL.jdf                     | 10 +-
 parsec/data.c                                 | 28 ++++--
 parsec/data.h                                 | 23 +++--
 parsec/data_dist/matrix/apply_wrapper.c       | 10 +-
 parsec/data_dist/matrix/deprecated/matrix.h   |  8 +-
 parsec/data_dist/matrix/matrix.h              | 97 ++++++++-----------
 parsec/data_dist/matrix/matrixtypes.c         | 87 +++++++++++++++--
 .../matrix/redistribute/redistribute_dtd.c    |  8 +-
 .../redistribute/redistribute_wrapper.c       |  8 +-
 tests/api/taskpool_wait/main.c                |  3 +-
 tests/api/touch.jdf                           |  2 +-
 tests/apps/all2all/a2a.jdf                    |  4 +-
 .../BT_reduction_wrapper.c                    |  2 +-
 tests/apps/haar_tree/main.c                   |  2 +-
 tests/apps/merge_sort/merge_sort_wrapper.c    |  2 +-
 tests/apps/pingpong/bandwidth.jdf             |  4 +-
 tests/apps/pingpong/rtt_wrapper.c             |  2 +-
 tests/apps/stencil/stencil_1D.jdf             |  4 +-
 tests/collections/kcyclic.jdf                 |  2 +-
 .../redistribute/redistribute_check.jdf       |  4 +-
 .../redistribute/redistribute_check2.jdf      |  2 +-
 .../redistribute_no_optimization.jdf          |  4 +-
 tests/collections/reduce.c                    |  2 +-
 tests/collections/reshape/common.h            | 32 +++---
 .../collections/two_dim_band/two_dim_band.jdf |  2 +-
 tests/dsl/dtd/dtd_test_allreduce.c            |  3 +-
 tests/dsl/dtd/dtd_test_broadcast.c            |  3 +-
 tests/dsl/dtd/dtd_test_cuda_task_insert.c     | 12 +--
 tests/dsl/dtd/dtd_test_data_flush.c           |  6 +-
 .../dsl/dtd/dtd_test_explicit_task_creation.c |  5 +-
 tests/dsl/dtd/dtd_test_hierarchy.c            |  3 +-
 .../dsl/dtd/dtd_test_insert_task_interface.c  |  3 +-
 tests/dsl/dtd/dtd_test_interleave_actions.c   |  3 +-
 tests/dsl/dtd/dtd_test_new_tile.c             |  3 +-
 tests/dsl/dtd/dtd_test_pingpong.c             |  6 +-
 tests/dsl/dtd/dtd_test_reduce.c               |  3 +-
 tests/dsl/dtd/dtd_test_simple_gemm.c          |  4 +-
 tests/dsl/dtd/dtd_test_task_placement.c       |  3 +-
 tests/dsl/dtd/dtd_test_template_counter.c     |  3 +-
 tests/dsl/dtd/dtd_test_untie.c                |  3 +-
 tests/dsl/dtd/dtd_test_war.c                  |  3 +-
 tests/dsl/ptg/branching/branching_wrapper.c   |  2 +-
 tests/dsl/ptg/choice/choice_wrapper.c         |  2 +-
 tests/dsl/ptg/complex_deps.jdf                |  2 +-
 tests/dsl/ptg/controlgather/ctlgat_wrapper.c  |  2 +-
 tests/dsl/ptg/local-indices/local_indices.jdf |  2 +-
 .../check_multisize_bcast_wrapper.c           |  2 +-
 tests/dsl/ptg/ptgpp/forward_READ_NULL.jdf     |  2 +-
 tests/dsl/ptg/ptgpp/forward_RW_NULL.jdf       |  2 +-
 tests/dsl/ptg/ptgpp/too_many_in_deps.jdf      |  2 +-
 tests/dsl/ptg/ptgpp/too_many_local_vars.jdf   |  2 +-
 tests/dsl/ptg/ptgpp/too_many_out_deps.jdf     |  2 +-
 tests/dsl/ptg/ptgpp/too_many_read_flows.jdf   |  2 +-
 tests/dsl/ptg/ptgpp/too_many_write_flows.jdf  |  2 +-
 tests/dsl/ptg/ptgpp/write_check.jdf           |  2 +-
 tests/dsl/ptg/recursive.jdf                   |  2 +-
 tests/dsl/ptg/startup.jdf                     |  2 +-
 tests/dsl/ptg/strange.jdf                     |  2 +-
 tests/dsl/ptg/user-defined-functions/utt.jdf  |  2 +-
 tests/profiling/async.jdf                     |  2 +-
 tests/runtime/cuda/get_best_device_check.jdf  |  2 +-
 tests/runtime/cuda/nvlink_wrapper.c           |  2 +-
 tests/runtime/cuda/stress_wrapper.c           |  2 +-
 tests/runtime/dtt_bug_replicator_ex.c         |  6 +-
 tests/runtime/multichain.jdf                  |  2 +-
 tests/runtime/scheduling/ep_wrapper.c         |  2 +-
 74 files changed, 288 insertions(+), 238 deletions(-)

diff --git a/contrib/build_with_parsec/dtd_test_allreduce.c b/contrib/build_with_parsec/dtd_test_allreduce.c
index 904b4ea85..5d5e1efe5 100644
--- a/contrib/build_with_parsec/dtd_test_allreduce.c
+++ b/contrib/build_with_parsec/dtd_test_allreduce.c
@@ -150,9 +150,7 @@ int main(int argc, char **argv)
     parsec_add2arena_rect(&parsec_dtd_arenas_datatypes[TILE_FULL],
                           parsec_datatype_int32_t, nb, 1, nb);
 #else
-    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype);
-    parsec_matrix_adt_construct_rect(adt,
-                                     parsec_datatype_int32_t, nb, 1, nb);
+    parsec_arena_datatype_t *adt = parsec_matrix_adt_new_rect(parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 #endif
 
diff --git a/contrib/renaming/README.md b/contrib/renaming/README.md
index fdfa28aae..be9b4c0b0 100644
--- a/contrib/renaming/README.md
+++ b/contrib/renaming/README.md
@@ -51,8 +51,8 @@ two_dim_td_table_clone_table_structure -> parsec_matrix_tabular_clone_table_stru
 # symbols in matrix.h
 tiled_matrix_submatrix -> parsec_tiled_matrix_submatrix
 parsec_matrix_create_data -> parsec_tiled_matrix_create_data
-parsec_matrix_add2arena -> parsec_matrix_adt_construct
-parsec_add2arena -> parsec_matrix_adt_construct
+parsec_matrix_add2arena -> parsec_matrix_adt_define
+parsec_add2arena -> parsec_matrix_adt_define
 parsec_matrix_del2arena -> parsec_matrix_arena_datatype_destruct_free_type
 parsec_del2arena -> parsec_matrix_arena_datatype_destruct_free_type
 parsec_matrix_data_* -> parsec_tiled_matrix_data_*
@@ -86,8 +86,7 @@ This snippet extracted from `contrib/build_with_parsec/dtd_text_allreduce.c` sho
     parsec_add2arena_rect(&parsec_dtd_arenas_datatypes[TILE_FULL],
         parsec_datatype_int32_t, nb, 1, nb);
 #else
-    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype);
-    parsec_matrix_adt_construct_rect(adt,
+    parsec_arena_datatype_t *adt = parsec_matrix_adt_new_rect(
         parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 #endif
@@ -100,8 +99,7 @@ If you had updated to pre-release v4.x, you may have to do the following change:
 -    adt = parsec_dtd_create_arena_datatype(parsec, &TILE_FULL);
 -    parsec_add2arena_rect( adt,
 -       parsec_datatype_int32_t, nb, 1, nb);
-+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype);
-+    parsec_matrix_adt_construct_rect(adt,
++    parsec_arena_datatype_t *adt = parsec_matrix_adt_new_rect(
 +       parsec_datatype_int32_t, nb, 1, nb);
 +    parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 ```
@@ -116,8 +114,7 @@ The cleanup of DTD allocated arena datatypes can be significantly simplified:
 -    parsec_dtd_destroy_arena_datatype(parsec, TILE_FULL);
 +    adt = parsec_dtd_detach_arena_datatype(parsec, TILE_FULL);
 +    assert(NULL != adt);
-+    parsec_type_free(&adt->opaque_dtt);
-+    PARSEC_OBJ_RELEASE(adt);
++    parsec_matrix_adt_free(&adt);
 ```
 
 This snippet repeated itself often enough that we have a shorthand for detaching the adt,
diff --git a/contrib/renaming/rename.sed b/contrib/renaming/rename.sed
index 440397186..993a2d889 100644
--- a/contrib/renaming/rename.sed
+++ b/contrib/renaming/rename.sed
@@ -33,8 +33,9 @@ s/two_dim_td_table_clone_table_structure/parsec_matrix_tabular_clone_table_struc
 # symbols in matrix.h
 s/tiled_matrix_submatrix/parsec_tiled_matrix_submatrix/g
 s/parsec_matrix_create_data/parsec_tiled_matrix_create_data/g
-s/parsec_matrix_add2arena/parsec_matrix_adt_construct/g
-s/parsec_add2arena/parsec_matrix_adt_construct/g
+s/parsec_matrix_add2arena/parsec_matrix_adt_define/g
+s/parsec_add2arena/parsec_matrix_adt_define/g
+s/parsec_matrix_adt_define_tile/parsec_matrix_adt_define_square/g
 s/parsec_matrix_del2arena/parsec_matrix_arena_datatype_destruct_free_type/g
 s/parsec_del2arena/parsec_matrix_arena_datatype_destruct_free_type/g
 s/parsec_matrix_data_/parsec_tiled_matrix_data_/g
diff --git a/examples/Ex02_Chain.jdf b/examples/Ex02_Chain.jdf
index 4544a19b8..133b2fa0a 100644
--- a/examples/Ex02_Chain.jdf
+++ b/examples/Ex02_Chain.jdf
@@ -5,7 +5,7 @@ extern "C" %{
  * circulate from one task to another
  *    private variables
  *    guarded calls, RW
- *    parsec_arena_datatype_construct()
+ *    parsec_arena_datatype_set_type()
  *
  * @version 4.0
  * @email parsec-users@icl.utk.edu
@@ -113,9 +113,9 @@ int main(int argc, char *argv[])
      * datatype of the DEFAULT type, so it can allocate the required memory
      * space.
      */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_Ex02_Chain_DEFAULT_ADT_IDX],
-                                     sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
-                                     parsec_datatype_int_t );
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_Ex02_Chain_DEFAULT_ADT_IDX],
+                                    sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
+                                    parsec_datatype_int_t );
 
     rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
     PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
diff --git a/examples/Ex03_ChainMPI.jdf b/examples/Ex03_ChainMPI.jdf
index d54eae388..d0f0a0e30 100644
--- a/examples/Ex03_ChainMPI.jdf
+++ b/examples/Ex03_ChainMPI.jdf
@@ -139,9 +139,9 @@ int main(int argc, char *argv[])
      * The arena is now also used to describe the layout to the communication
      * engine (MPI)
      */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_Ex03_ChainMPI_DEFAULT_ADT_IDX],
-                                     sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
-                                     parsec_datatype_int_t );
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_Ex03_ChainMPI_DEFAULT_ADT_IDX],
+                                    sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
+                                    parsec_datatype_int_t );
 
     rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
     PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
diff --git a/examples/Ex04_ChainData.jdf b/examples/Ex04_ChainData.jdf
index 2d5d40729..5329891e2 100644
--- a/examples/Ex04_ChainData.jdf
+++ b/examples/Ex04_ChainData.jdf
@@ -134,9 +134,9 @@ int main(int argc, char *argv[])
     mydata.vpid_of = vpid_of;
     mydata.data_key = data_key;
 
-    parsec_arena_datatype_construct( &adt,
-                                     sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
-                                     parsec_datatype_int_t );
+    parsec_arena_datatype_set_type( &adt,
+                                    sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
+                                    parsec_datatype_int_t );
 
     ddata_mycounter = parsec_data_create( &ddata_mycounter, /* The parsec_data_t taskpool value   */
                                          &mydata,          /* The descriptor associated to it */
diff --git a/examples/Ex05_Broadcast.jdf b/examples/Ex05_Broadcast.jdf
index bbd3e5251..15996a6dd 100644
--- a/examples/Ex05_Broadcast.jdf
+++ b/examples/Ex05_Broadcast.jdf
@@ -133,9 +133,9 @@ int main(int argc, char *argv[])
     mydata.data_key = data_key;
     mydata.data_of = data_of;
 
-    parsec_arena_datatype_construct( &adt,
-                                     sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
-                                     parsec_datatype_int_t );
+    parsec_arena_datatype_set_type( &adt,
+                                    sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
+                                    parsec_datatype_int_t );
 
     ddata_mycounter = parsec_data_create(
         &ddata_mycounter, &mydata, 0,
diff --git a/examples/Ex06_RAW.jdf b/examples/Ex06_RAW.jdf
index b0c0d0bc9..26a199619 100644
--- a/examples/Ex06_RAW.jdf
+++ b/examples/Ex06_RAW.jdf
@@ -149,9 +149,9 @@ int main(int argc, char *argv[])
     mydata.data_key = data_key;
     mydata.data_of = data_of;
 
-    parsec_arena_datatype_construct( &adt,
-                                     sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
-                                     parsec_datatype_int_t );
+    parsec_arena_datatype_set_type( &adt,
+                                    sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
+                                    parsec_datatype_int_t );
 
     mycounter = 300 + rank;
     ddata_mycounter = parsec_data_create(
diff --git a/examples/Ex07_RAW_CTL.jdf b/examples/Ex07_RAW_CTL.jdf
index e0308b233..503c07e74 100644
--- a/examples/Ex07_RAW_CTL.jdf
+++ b/examples/Ex07_RAW_CTL.jdf
@@ -156,9 +156,9 @@ int main(int argc, char *argv[])
     mydata.data_key = data_key;
     mydata.data_of = data_of;
 
-    parsec_arena_datatype_construct( &adt,
-                                     sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
-                                     parsec_datatype_int_t );
+    parsec_arena_datatype_set_type( &adt,
+                                    sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
+                                    parsec_datatype_int_t );
 
     mycounter = 300 + rank;
     ddata_mycounter = parsec_data_create(
@@ -168,8 +168,8 @@ int main(int argc, char *argv[])
 
     tp = parsec_Ex07_RAW_CTL_new(&mydata, world, rank);
 
-    tp->arenas_datatypes[PARSEC_Ex07_RAW_CTL_DEFAULT_ADT_IDX] = adt; 
-    
+    tp->arenas_datatypes[PARSEC_Ex07_RAW_CTL_DEFAULT_ADT_IDX] = adt;
+
     rc = parsec_context_add_taskpool( parsec, (parsec_taskpool_t*)tp );
     PARSEC_CHECK_ERROR(rc, "parsec_context_add_taskpool");
     rc = parsec_context_start(parsec);
diff --git a/parsec/data.c b/parsec/data.c
index d5892cd6e..012ea0c8b 100644
--- a/parsec/data.c
+++ b/parsec/data.c
@@ -570,31 +570,31 @@ parsec_data_destroy( parsec_data_t *data )
  * with OBJ_CONSTRUCT (or allocated with OBJ_NEW), we initialize the
  * adt object with static zero values.
  * The user code must then call the parameterized constructor
- * (below) that attaches the datatype and creates the associated arena.
+ * (init, below) that attaches the datatype and creates the associated arena.
  *
  * When the adt object is destructed (or released), the implicit destructor
  * releases all resources created by both split constructor stages.
  *
  * Freeing the type is not part of the implicit destructor.
  */
-int parsec_arena_datatype_construct(parsec_arena_datatype_t *adt,
-                                    size_t elem_size,
-                                    size_t alignment,
-                                    parsec_datatype_t opaque_dtt) {
+int parsec_arena_datatype_set_type(parsec_arena_datatype_t *adt,
+                                   size_t elem_size,
+                                   size_t alignment,
+                                   parsec_datatype_t opaque_dtt) {
     adt->arena = PARSEC_OBJ_NEW(parsec_arena_t);
     parsec_arena_construct(adt->arena, elem_size,
                            alignment);
-    adt->opaque_dtt         = opaque_dtt;
+    adt->opaque_dtt = opaque_dtt;
     return PARSEC_SUCCESS;
 }
 
 /* This constructor must only initialize fields with static values.
  * When the user is using a persistent adt, the PTG generator will
- * construct_zero the static arenas, and the user will overwrite them
+ * construct the static arenas, and the user will overwrite them
  * without calling destruct, which is valid only if this function does
  * not allocate memory.
  */
-static void parsec_arena_datatype_construct_zero(parsec_object_t *obj) {
+static void parsec_arena_datatype_construct(parsec_object_t *obj) {
     parsec_arena_datatype_t *adt = (parsec_arena_datatype_t *)obj;
     adt->arena              = NULL;
     adt->ht_item.next_item  = NULL; /* keep Coverity happy */
@@ -609,5 +609,15 @@ static void parsec_arena_datatype_destruct(parsec_object_t *obj) {
 }
 
 PARSEC_OBJ_CLASS_INSTANCE(parsec_arena_datatype_t, parsec_object_t,
-                          parsec_arena_datatype_construct_zero,
+                          parsec_arena_datatype_construct,
                           parsec_arena_datatype_destruct);
+
+parsec_arena_datatype_t *parsec_arena_datatype_new(void)
+{
+    return PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+}
+
+void parsec_arena_datatype_release(parsec_arena_datatype_t **adt) {
+    PARSEC_OBJ_RELEASE(*adt);
+}
+
diff --git a/parsec/data.h b/parsec/data.h
index 0331ab908..fcd8a34f4 100644
--- a/parsec/data.h
+++ b/parsec/data.h
@@ -145,15 +145,24 @@ PARSEC_DECLSPEC void
 parsec_data_destroy( parsec_data_t *holder );
 
 /**
- * Construct an arena datatype. Because the parameters cannot be known
- * when OBJ_NEW is called, the construct must be called explicitely
- * by the user.
+ * Set the type of an arena datatype. Because the parameters cannot
+ * be known when OBJ_NEW/CONSTRUCT is called, the set_type must be
+ * called explicitely by the user.
+ * The opaque_dtt is not freed by the arena datatype destructor.
+ * The destructor will take care of cleanup for other internal members
+ * and work whether set_type was called or not.
  */
 PARSEC_DECLSPEC int
-parsec_arena_datatype_construct( parsec_arena_datatype_t *adt,
-                                 size_t elem_size,
-                                 size_t alignment,
-                                 parsec_datatype_t opaque_dtt);
+parsec_arena_datatype_set_type( parsec_arena_datatype_t *adt,
+                                size_t elem_size,
+                                size_t alignment,
+                                parsec_datatype_t opaque_dtt );
+
+PARSEC_DECLSPEC parsec_arena_datatype_t*
+parsec_arena_datatype_new(void);
+
+PARSEC_DECLSPEC void
+parsec_arena_datatype_release(parsec_arena_datatype_t **adt);
 
 PARSEC_OBJ_CLASS_DECLARATION(parsec_arena_datatype_t);
 
diff --git a/parsec/data_dist/matrix/apply_wrapper.c b/parsec/data_dist/matrix/apply_wrapper.c
index d6b8ef100..7389cb48e 100644
--- a/parsec/data_dist/matrix/apply_wrapper.c
+++ b/parsec/data_dist/matrix/apply_wrapper.c
@@ -69,24 +69,24 @@ parsec_apply_New( parsec_matrix_uplo_t uplo,
 
     switch( A->mtype ) {
     case PARSEC_MATRIX_COMPLEX_DOUBLE    :
-        parsec_matrix_adt_construct_tile( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
+        parsec_matrix_adt_define_square( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
                           parsec_datatype_double_complex_t, A->mb);
         break;
     case PARSEC_MATRIX_COMPLEX_FLOAT     :
-        parsec_matrix_adt_construct_tile( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
+        parsec_matrix_adt_define_square( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
                           parsec_datatype_complex_t, A->mb);
         break;
     case PARSEC_MATRIX_DOUBLE       :
-        parsec_matrix_adt_construct_tile( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
+        parsec_matrix_adt_define_square( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
                           parsec_datatype_double_t, A->mb);
         break;
     case PARSEC_MATRIX_FLOAT        :
-        parsec_matrix_adt_construct_tile( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
+        parsec_matrix_adt_define_square( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
                           parsec_datatype_float_t, A->mb);
         break;
     case PARSEC_MATRIX_INTEGER          :
     default:
-        parsec_matrix_adt_construct_tile( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
+        parsec_matrix_adt_define_square( &parsec_app->arenas_datatypes[PARSEC_apply_DEFAULT_ADT_IDX],
                           parsec_datatype_int_t, A->mb);
     }
     return (parsec_taskpool_t*)parsec_app;
diff --git a/parsec/data_dist/matrix/deprecated/matrix.h b/parsec/data_dist/matrix/deprecated/matrix.h
index d8101f07d..c51866933 100644
--- a/parsec/data_dist/matrix/deprecated/matrix.h
+++ b/parsec/data_dist/matrix/deprecated/matrix.h
@@ -139,14 +139,14 @@ int parsec_matrix_add2arena( parsec_arena_datatype_t *adt, parsec_datatype_t old
                              parsec_matrix_uplo_t uplo, int diag,
                              unsigned int m, unsigned int n, unsigned int ld,
                              size_t alignment, int resized )
-    __parsec_attribute_deprecated__("Use parsec_matrix_arena_datatype_construct_alloc_type");
+    __parsec_attribute_deprecated__("Use parsec_matrix_arena_datatype_define_type");
 static inline
 int parsec_matrix_add2arena( parsec_arena_datatype_t *adt, parsec_datatype_t oldtype,
                              parsec_matrix_uplo_t uplo, int diag,
                              unsigned int m, unsigned int n, unsigned int ld,
                              size_t alignment, int resized ) {
     PARSEC_OBJ_CONSTRUCT(adt, parsec_arena_datatype_t);
-    return parsec_matrix_arena_datatype_construct_alloc_type(adt, oldtype, uplo, diag, m, n, ld, alignment, resized);
+    return parsec_matrix_arena_datatype_define_type(adt, oldtype, uplo, diag, m, n, ld, alignment, resized);
 }
 
 static inline
@@ -176,14 +176,14 @@ int parsec_add2arena( parsec_arena_datatype_t *adt, parsec_datatype_t oldtype,
                       parsec_matrix_uplo_t uplo, int diag,
                       unsigned int m, unsigned int n, unsigned int ld,
                       size_t alignment, int resized )
-    __parsec_attribute_deprecated__("Use parsec_matrix_arena_datatype_construct_alloc_type");
+    __parsec_attribute_deprecated__("Use parsec_matrix_arena_datatype_define_type");
 static inline
 int parsec_add2arena( parsec_arena_datatype_t *adt, parsec_datatype_t oldtype,
                       parsec_matrix_uplo_t uplo, int diag,
                       unsigned int m, unsigned int n, unsigned int ld,
                       size_t alignment, int resized ) {
     PARSEC_OBJ_CONSTRUCT(adt, parsec_arena_datatype_t);
-    return parsec_matrix_arena_datatype_construct_alloc_type(adt, oldtype, uplo, diag, m, n, ld, alignment, resized);
+    return parsec_matrix_arena_datatype_define_type(adt, oldtype, uplo, diag, m, n, ld, alignment, resized);
 }
 
 static inline
diff --git a/parsec/data_dist/matrix/matrix.h b/parsec/data_dist/matrix/matrix.h
index bc796b797..437d47fc8 100644
--- a/parsec/data_dist/matrix/matrix.h
+++ b/parsec/data_dist/matrix/matrix.h
@@ -23,10 +23,10 @@ struct parsec_execution_stream_s;
 struct parsec_taskpool_s;
 
 typedef enum parsec_matrix_type_e {
-    PARSEC_MATRIX_BYTE          = 0, /**< unsigned char  */
-    PARSEC_MATRIX_INTEGER       = 1, /**< signed int     */
-    PARSEC_MATRIX_FLOAT     = 2, /**< float          */
-    PARSEC_MATRIX_DOUBLE    = 3, /**< double         */
+    PARSEC_MATRIX_BYTE           = 0, /**< unsigned char  */
+    PARSEC_MATRIX_INTEGER        = 1, /**< signed int     */
+    PARSEC_MATRIX_FLOAT          = 2, /**< float          */
+    PARSEC_MATRIX_DOUBLE         = 3, /**< double         */
     PARSEC_MATRIX_COMPLEX_FLOAT  = 4, /**< complex float  */
     PARSEC_MATRIX_COMPLEX_DOUBLE = 5  /**< complex double */
 } parsec_matrix_type_t;
@@ -53,10 +53,10 @@ static inline int parsec_datadist_getsizeoftype(parsec_matrix_type_t type)
 {
     int size = -1;
     switch( type ) {
-    case PARSEC_MATRIX_BYTE          : parsec_type_size(parsec_datatype_int8_t, &size); break;
-    case PARSEC_MATRIX_INTEGER       : parsec_type_size(parsec_datatype_int32_t, &size); break;
-    case PARSEC_MATRIX_FLOAT     : parsec_type_size(parsec_datatype_float_t, &size); break;
-    case PARSEC_MATRIX_DOUBLE    : parsec_type_size(parsec_datatype_double_t, &size); break;
+    case PARSEC_MATRIX_BYTE           : parsec_type_size(parsec_datatype_int8_t, &size); break;
+    case PARSEC_MATRIX_INTEGER        : parsec_type_size(parsec_datatype_int32_t, &size); break;
+    case PARSEC_MATRIX_FLOAT          : parsec_type_size(parsec_datatype_float_t, &size); break;
+    case PARSEC_MATRIX_DOUBLE         : parsec_type_size(parsec_datatype_double_t, &size); break;
     case PARSEC_MATRIX_COMPLEX_FLOAT  : parsec_type_size(parsec_datatype_complex_t, &size); break;
     case PARSEC_MATRIX_COMPLEX_DOUBLE : parsec_type_size(parsec_datatype_double_complex_t, &size); break;
     /* If you want to add more types, note that size=extent is true only for predefined datatypes.
@@ -324,54 +324,43 @@ int parsec_matrix_define_datatype(parsec_datatype_t *newtype, parsec_datatype_t
  * is created using the datatype extent. The alignment indicates the restrictions related
  * to the alignment of the allocated data by the arena.
  */
-int parsec_matrix_arena_datatype_construct_alloc_type(parsec_arena_datatype_t *adt,
-                                                     parsec_datatype_t oldtype,
-                                                     parsec_matrix_uplo_t uplo, int diag,
-                                                     unsigned int m, unsigned int n, unsigned int ld,
-                                                     size_t alignment, int resized);
+int parsec_matrix_arena_datatype_define_type(parsec_arena_datatype_t *adt,
+                                             parsec_datatype_t oldtype,
+                                             parsec_matrix_uplo_t uplo, int diag,
+                                             unsigned int m, unsigned int n, unsigned int ld,
+                                             size_t alignment, int resized);
 int parsec_matrix_arena_datatype_destruct_free_type(parsec_arena_datatype_t *adt);
 
-#define parsec_matrix_adt_construct( _adt_ , _oldtype_, _uplo_, _diag_, _m_, _n_, _ld_, _align_, _resize_ ) \
-    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), (_uplo_), (_diag_), (_m_), (_n_), (_ld_), (_align_), (_resize_) )
-#define parsec_matrix_adt_new( _adt_ , _oldtype_, _uplo_, _diag_, _m_, _n_, _ld_, _align_, _resize_ ) \
-    ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
-    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), (_uplo_), (_diag_), (_m_), (_n_), (_ld_), (_align_), (_resize_) ) \
-     (_adt_))
-
-#define parsec_matrix_adt_construct_tile( _adt_ , _oldtype_, _m_ ) \
-    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_m_), (_m_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
-#define parsec_matrix_adt_new_tile( _adt_ , _oldtype_, _m_ ) \
-    ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
-     parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_m_), (_m_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
-     (_adt_))
-
-#define parsec_matrix_adt_construct_upper( _adt_ , _oldtype_, _diag_, _n_ ) \
-    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_UPPER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
-#define parsec_matrix_adt_new_upper( _adt_ , _oldtype_, _diag_, _n_ ) \
-    ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
-     parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_UPPER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
-     (_adt_))
-
-#define parsec_matrix_adt_construct_lower( _adt_ , _oldtype_, _diag_, _n_ ) \
-    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_LOWER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
-#define parsec_matrix_adt_new_lower( _adt_ , _oldtype_, _diag_, _n_ ) \
-    ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
-     parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_LOWER, (_diag_), (_n_), (_n_), (_n_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
-     (_adt_))
-
-#define parsec_matrix_adt_construct_rect( _adt_ , _oldtype_, _m_, _n_, _ld_ ) \
-    parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_n_), (_ld_), PARSEC_ARENA_ALIGNMENT_SSE, -1 )
-#define parsec_matrix_adt_new_rect( _adt_ , _oldtype_, _m_, _n_, _ld_ ) \
-    ((_adt_) = PARSEC_OBJ_NEW(parsec_arena_datatype_t), \
-     parsec_matrix_arena_datatype_construct_alloc_type( (_adt_), (_oldtype_), PARSEC_MATRIX_FULL, 0, (_m_), (_n_), (_ld_), PARSEC_ARENA_ALIGNMENT_SSE, -1 ), \
-     (_adt_))
-
-#define parsec_matrix_adt_free(_padt_) do {\
-    parsec_matrix_arena_datatype_destruct_free_type(*(_padt_)); \
-    free(*(_padt_)); \
-    (*_padt_) = NULL; \
-} while(0)
-
+/* these defines simplify the script for conversion of deprecated add2arena/del2arena */
+#define parsec_matrix_adt_define_type( _adt_, _oldtype_, _uplo_, _diag_, _m_, _n_, _ld_, _align_, _resize_ ) \
+    parsec_matrix_arena_datatype_define_type( (_adt_), (_oldtype_), (_uplo_), (_diag_), (_m_), (_n_), (_ld_), (_align_), (_resize_) )
+#define parsec_matrix_adt_destruct_free_type( _adt_ ) \
+    parsec_matrix_arena_datatype_destruct_free_type( (_adt_) )
+
+/* shorthands of the above for the common types */
+int parsec_matrix_adt_define_rect(parsec_arena_datatype_t *adt,
+                                  parsec_datatype_t oldtype,
+                                  unsigned int m, unsigned int n, unsigned int ld);
+parsec_arena_datatype_t *parsec_matrix_adt_new_rect(parsec_datatype_t oldtype,
+                                  unsigned int m, unsigned int n, unsigned int ld);
+
+int parsec_matrix_adt_define_upper(parsec_arena_datatype_t *adt,
+                                   parsec_datatype_t oldtype,
+                                   int diag, unsigned int m);
+parsec_arena_datatype_t *parsec_matrix_adt_new_upper(parsec_datatype_t oldtype,
+                                   int diag, unsigned int m);
+int parsec_matrix_adt_define_lower(parsec_arena_datatype_t *adt,
+                                   parsec_datatype_t oldtype,
+                                   int diag, unsigned int m);
+parsec_arena_datatype_t *parsec_matrix_adt_new_lower(parsec_datatype_t oldtype,
+                                   int diag, unsigned int m);
+int parsec_matrix_adt_define_square(parsec_arena_datatype_t *adt,
+                                    parsec_datatype_t oldtype,
+                                    unsigned int m);
+parsec_arena_datatype_t *parsec_matrix_adt_new_square(parsec_datatype_t oldtype,
+                                    unsigned int m);
+
+int parsec_matrix_adt_free(parsec_arena_datatype_t **padt);
 
 /* include deprecated symbols */
 #include "parsec/data_dist/matrix/deprecated/matrix.h"
diff --git a/parsec/data_dist/matrix/matrixtypes.c b/parsec/data_dist/matrix/matrixtypes.c
index b61ab5149..ff9a1466d 100644
--- a/parsec/data_dist/matrix/matrixtypes.c
+++ b/parsec/data_dist/matrix/matrixtypes.c
@@ -225,11 +225,13 @@ int parsec_matrix_define_datatype(parsec_datatype_t *newtype, parsec_datatype_t
 /**
  * Arena-datatype management.
  */
-int parsec_matrix_arena_datatype_construct_alloc_type(parsec_arena_datatype_t *adt,
-                                                      parsec_datatype_t oldtype,
-                                                      parsec_matrix_uplo_t uplo, int diag,
-                                                      unsigned int m, unsigned int n, unsigned int ld,
-                                                      size_t alignment, int resized) {
+/* high level interfaces */
+int parsec_matrix_arena_datatype_define_type(parsec_arena_datatype_t *adt,
+                                             parsec_datatype_t oldtype,
+                                             parsec_matrix_uplo_t uplo, int diag,
+                                             unsigned int m, unsigned int n, unsigned int ld,
+                                             size_t alignment, int resized)
+{
     ptrdiff_t extent = 0;
     int rc;
     parsec_datatype_t newtype;
@@ -238,14 +240,85 @@ int parsec_matrix_arena_datatype_construct_alloc_type(parsec_arena_datatype_t *a
                                        m, n, ld, resized, &extent);
     if( PARSEC_SUCCESS != rc ) return rc;
 
-    parsec_arena_datatype_construct(adt, extent, alignment, newtype);
+    parsec_arena_datatype_set_type(adt, extent, alignment, newtype);
     if( PARSEC_SUCCESS != rc ) return rc;
 
     return PARSEC_SUCCESS;
 }
 
-int parsec_matrix_arena_datatype_destruct_free_type(parsec_arena_datatype_t *adt) {
+int parsec_matrix_arena_datatype_destruct_free_type(parsec_arena_datatype_t *adt)
+{
     parsec_type_free( &adt->opaque_dtt );
     PARSEC_OBJ_DESTRUCT(adt);
     return PARSEC_SUCCESS;
 }
+
+/* shorthands of the above for the common types */
+int parsec_matrix_adt_define_rect(parsec_arena_datatype_t *adt,
+                                parsec_datatype_t oldtype,
+                                unsigned int m, unsigned int n, unsigned int ld)
+{
+    return parsec_matrix_arena_datatype_define_type(adt, oldtype, PARSEC_MATRIX_FULL, 0, m, n, ld, PARSEC_ARENA_ALIGNMENT_SSE, -1);
+}
+
+int parsec_matrix_adt_define_upper(parsec_arena_datatype_t *adt,
+                                 parsec_datatype_t oldtype,
+                                 int diag, unsigned int m)
+{
+    return parsec_matrix_arena_datatype_define_type(adt, oldtype, PARSEC_MATRIX_UPPER, diag, m, m, m, PARSEC_ARENA_ALIGNMENT_SSE, -1);
+}
+
+int parsec_matrix_adt_define_lower(parsec_arena_datatype_t *adt,
+                                 parsec_datatype_t oldtype,
+                                 int diag, unsigned int m)
+{
+    return parsec_matrix_arena_datatype_define_type(adt, oldtype, PARSEC_MATRIX_LOWER, diag, m, m, m, PARSEC_ARENA_ALIGNMENT_SSE, -1);
+}
+
+int parsec_matrix_adt_define_square(parsec_arena_datatype_t *adt,
+                                  parsec_datatype_t oldtype,
+                                  unsigned int m)
+{
+    return parsec_matrix_arena_datatype_define_type(adt, oldtype, PARSEC_MATRIX_FULL, 0, m, m, m, PARSEC_ARENA_ALIGNMENT_SSE, -1);
+}
+
+parsec_arena_datatype_t *parsec_matrix_adt_new_rect(parsec_datatype_t oldtype,
+                                unsigned int m, unsigned int n, unsigned int ld)
+{
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_define_rect(adt, oldtype, m, n, ld);
+    return adt;
+}
+
+parsec_arena_datatype_t *parsec_matrix_adt_new_upper(parsec_datatype_t oldtype,
+                                 int diag, unsigned int m)
+{
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_define_upper(adt, oldtype, diag, m);
+    return adt;
+}
+
+parsec_arena_datatype_t *parsec_matrix_adt_new_lower(parsec_datatype_t oldtype,
+                                 int diag, unsigned int m)
+{
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_define_lower(adt, oldtype, diag, m);
+    return adt;
+}
+
+parsec_arena_datatype_t *parsec_matrix_adt_new_square(parsec_datatype_t oldtype,
+                                  unsigned int m)
+{
+    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
+    parsec_matrix_adt_define_square(adt, oldtype, m);
+    return adt;
+}
+
+int parsec_matrix_adt_free(parsec_arena_datatype_t **padt)
+{
+    parsec_matrix_arena_datatype_destruct_free_type(*padt);
+    free(*padt); /* OBJ_DESTRUCT done above */
+    *padt = NULL;
+    return PARSEC_SUCCESS;
+}
+
diff --git a/parsec/data_dist/matrix/redistribute/redistribute_dtd.c b/parsec/data_dist/matrix/redistribute/redistribute_dtd.c
index 3f8900bc5..4dfd0b38d 100644
--- a/parsec/data_dist/matrix/redistribute/redistribute_dtd.c
+++ b/parsec/data_dist/matrix/redistribute/redistribute_dtd.c
@@ -373,14 +373,10 @@ parsec_redistribute_New_dtd(parsec_context_t *parsec,
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
     /* Allocating data arrays to be used by comm engine */
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
-                     MY_TYPE, dcT->mb, dcT->nb, dcT->mb);
+    adt = parsec_matrix_adt_new_rect(MY_TYPE, dcT->mb, dcT->nb, dcT->mb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TARGET);
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
-                     MY_TYPE, dcY->mb, dcY->nb, dcY->mb);
+    adt = parsec_matrix_adt_new_rect(MY_TYPE, dcY->mb, dcY->nb, dcY->mb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &SOURCE);
 
     /* Registering the handle with parsec context */
diff --git a/parsec/data_dist/matrix/redistribute/redistribute_wrapper.c b/parsec/data_dist/matrix/redistribute/redistribute_wrapper.c
index 28adc9dc2..218ba8946 100644
--- a/parsec/data_dist/matrix/redistribute/redistribute_wrapper.c
+++ b/parsec/data_dist/matrix/redistribute/redistribute_wrapper.c
@@ -97,7 +97,7 @@ parsec_redistribute_New(parsec_tiled_matrix_t *dcY,
         int n_T_END = (size_col+disj_T-1) / dcT->nb;
         taskpool->_g_NT = (n_T_END-n_T_START)/taskpool->_g_num_col;
 
-        parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_reshuffle_DEFAULT_ADT_IDX],
+        parsec_matrix_adt_define_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_reshuffle_DEFAULT_ADT_IDX],
                          MY_TYPE, dcY->mb, dcY->nb, dcY->mb);
         /* General version */
     } else {
@@ -116,16 +116,16 @@ parsec_redistribute_New(parsec_tiled_matrix_t *dcY,
         int n_T_END = (size_col+disj_T-1) / (dcT->nb-2*R);
         taskpool->_g_NT = (n_T_END-n_T_START)/taskpool->_g_num_col;
 
-        parsec_matrix_adt_construct_tile(&taskpool->arenas_datatypes[PARSEC_redistribute_DEFAULT_ADT_IDX],
+        parsec_matrix_adt_define_square(&taskpool->arenas_datatypes[PARSEC_redistribute_DEFAULT_ADT_IDX],
                          MY_TYPE, 1);
 
         int Y_LDA = dcY->storage == PARSEC_MATRIX_LAPACK ? dcY->llm : dcY->mb;
         int T_LDA = dcT->storage == PARSEC_MATRIX_LAPACK ? dcT->llm : dcT->mb;
 
-        parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_TARGET_ADT_IDX],
+        parsec_matrix_adt_define_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_TARGET_ADT_IDX],
                          MY_TYPE, dcT->mb, dcT->nb, T_LDA);
 
-        parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_INNER_ADT_IDX],
+        parsec_matrix_adt_define_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_INNER_ADT_IDX],
                          MY_TYPE, dcY->mb-2*R, dcY->nb-2*R, Y_LDA);
     }
 
diff --git a/tests/api/taskpool_wait/main.c b/tests/api/taskpool_wait/main.c
index f3a87da06..424bd42ee 100644
--- a/tests/api/taskpool_wait/main.c
+++ b/tests/api/taskpool_wait/main.c
@@ -37,8 +37,7 @@ int main(int argc, char *argv[]) {
     parsec_data_collection_set_key(&A.super.super, "A");
     parsec_dtd_data_collection_init(&A.super.super);
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt, parsec_datatype_int32_t, 0, nb, 1);
+    adt = parsec_matrix_adt_new_rect(parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
     printf("Single PTG taskpool, waited with parsec_context_wait\n");
diff --git a/tests/api/touch.jdf b/tests/api/touch.jdf
index 7af1357e4..b862a2c66 100644
--- a/tests/api/touch.jdf
+++ b/tests/api/touch.jdf
@@ -68,7 +68,7 @@ parsec_taskpool_t* touch_initialize(int block, int n)
     assert( NULL != tp );
 
     parsec_translate_matrix_type(TYPE, &dt);
-    parsec_matrix_adt_construct_rect( &tp->arenas_datatypes[PARSEC_touch_DEFAULT_ADT_IDX],
+    parsec_matrix_adt_define_rect( &tp->arenas_datatypes[PARSEC_touch_DEFAULT_ADT_IDX],
                                   dt, descA.super.mb, descA.super.nb, descA.super.mb );
 
     return &tp->super;
diff --git a/tests/apps/all2all/a2a.jdf b/tests/apps/all2all/a2a.jdf
index e92ceaa57..45dbd509b 100644
--- a/tests/apps/all2all/a2a.jdf
+++ b/tests/apps/all2all/a2a.jdf
@@ -126,12 +126,10 @@ parsec_taskpool_t *a2a_new(parsec_tiled_matrix_t *A, parsec_tiled_matrix_t *B, i
 
     tp = parsec_a2a_new(A, B, repeat, worldsize);
 
-    parsec_matrix_adt_construct_rect( &tp->arenas_datatypes[PARSEC_a2a_DEFAULT_ADT_IDX],
+    parsec_matrix_adt_define_rect( &tp->arenas_datatypes[PARSEC_a2a_DEFAULT_ADT_IDX],
                                   parsec_datatype_int32_t,
                                   size, 1, size);
 
-
-
     return (parsec_taskpool_t*)tp;
 }
 
diff --git a/tests/apps/generalized_reduction/BT_reduction_wrapper.c b/tests/apps/generalized_reduction/BT_reduction_wrapper.c
index 36190823d..31ed36b98 100644
--- a/tests/apps/generalized_reduction/BT_reduction_wrapper.c
+++ b/tests/apps/generalized_reduction/BT_reduction_wrapper.c
@@ -45,7 +45,7 @@ parsec_taskpool_t *BT_reduction_new(parsec_tiled_matrix_t *A, int nb, int nt)
     parsec_type_create_contiguous(nb, parsec_datatype_int32_t, &block);
     parsec_type_extent(block, &lb, &extent);
 
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_BT_reduction_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_BT_reduction_DEFAULT_ADT_IDX],
                                      extent, PARSEC_ARENA_ALIGNMENT_SSE,
                                      block);
 
diff --git a/tests/apps/haar_tree/main.c b/tests/apps/haar_tree/main.c
index bf37f39bf..7028ef22a 100644
--- a/tests/apps/haar_tree/main.c
+++ b/tests/apps/haar_tree/main.c
@@ -216,7 +216,7 @@ int main(int argc, char *argv[])
                               0, 0, world, world,
                               1, world, 1, 1, 0, 0);
 
-    parsec_matrix_adt_construct_rect( adt,
+    parsec_matrix_adt_define_rect( adt,
              parsec_datatype_float_t, 2, 1, 2);
 
 #if defined(HAVE_MPI)
diff --git a/tests/apps/merge_sort/merge_sort_wrapper.c b/tests/apps/merge_sort/merge_sort_wrapper.c
index 360ed0033..69f67b6a7 100644
--- a/tests/apps/merge_sort/merge_sort_wrapper.c
+++ b/tests/apps/merge_sort/merge_sort_wrapper.c
@@ -33,7 +33,7 @@ parsec_taskpool_t* merge_sort_new(parsec_tiled_matrix_t *A, int nb, int nt)
     /* As the datatype is parsec_datatype_int32_t all communications to/from
      * this arena should use the count property or they will exchange a
      * single integer. */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_merge_sort_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_merge_sort_DEFAULT_ADT_IDX],
                                      nb*sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
                                      parsec_datatype_int32_t);
 
diff --git a/tests/apps/pingpong/bandwidth.jdf b/tests/apps/pingpong/bandwidth.jdf
index c0dc4c177..595ff2b49 100644
--- a/tests/apps/pingpong/bandwidth.jdf
+++ b/tests/apps/pingpong/bandwidth.jdf
@@ -98,7 +98,7 @@ parsec_bandwidth_New(parsec_tiled_matrix_t *dcA,
   taskpool = parsec_bandwidth_new(dcA, Disk, loops, frags, ws); 
   bandwidth_taskpool = (parsec_taskpool_t*)taskpool;
 
-  parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_bandwidth_DEFAULT_ADT_IDX],
+  parsec_matrix_adt_define_rect( &taskpool->arenas_datatypes[PARSEC_bandwidth_DEFAULT_ADT_IDX],
                            parsec_datatype_double_t, 1, size, 1);
 
   return bandwidth_taskpool;
@@ -246,7 +246,7 @@ int main(int argc, char *argv[])
 
         bandwidth_taskpool = (parsec_taskpool_t*)taskpool;
 
-        parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_bandwidth_DEFAULT_ADT_IDX],
+        parsec_matrix_adt_define_rect( &taskpool->arenas_datatypes[PARSEC_bandwidth_DEFAULT_ADT_IDX],
                                  parsec_datatype_double_t, 1, size, 1);
 
         /* Time start */
diff --git a/tests/apps/pingpong/rtt_wrapper.c b/tests/apps/pingpong/rtt_wrapper.c
index ae2223ac6..2878c07ba 100644
--- a/tests/apps/pingpong/rtt_wrapper.c
+++ b/tests/apps/pingpong/rtt_wrapper.c
@@ -57,7 +57,7 @@ parsec_taskpool_t *rtt_new(parsec_data_collection_t *A, int size, int nb)
     parsec_type_create_contiguous(size, parsec_datatype_uint8_t, &block);
     parsec_type_extent(block, &lb, &extent);
 
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_rtt_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_rtt_DEFAULT_ADT_IDX],
                                      extent, PARSEC_ARENA_ALIGNMENT_SSE,
                                      block );
     return (parsec_taskpool_t*)tp;
diff --git a/tests/apps/stencil/stencil_1D.jdf b/tests/apps/stencil/stencil_1D.jdf
index 9c94685b0..af1106c7a 100644
--- a/tests/apps/stencil/stencil_1D.jdf
+++ b/tests/apps/stencil/stencil_1D.jdf
@@ -135,10 +135,10 @@ parsec_stencil_1D_New(parsec_tiled_matrix_t *dcA, int iter, int R)
   taskpool = parsec_stencil_1D_new(dcA, iter, R);
   stencil_1D_taskpool = (parsec_taskpool_t*)taskpool;
 
-  parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_stencil_1D_FULL_ADT_IDX],
+  parsec_matrix_adt_define_rect( &taskpool->arenas_datatypes[PARSEC_stencil_1D_FULL_ADT_IDX],
                            MY_TYPE, dcA->mb, dcA->nb, dcA->mb);
 
-  parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_stencil_1D_LR_ADT_IDX],
+  parsec_matrix_adt_define_rect( &taskpool->arenas_datatypes[PARSEC_stencil_1D_LR_ADT_IDX],
                            MY_TYPE, dcA->mb, R, dcA->mb);
 
   return stencil_1D_taskpool;
diff --git a/tests/collections/kcyclic.jdf b/tests/collections/kcyclic.jdf
index 439406b88..9a90019e6 100644
--- a/tests/collections/kcyclic.jdf
+++ b/tests/collections/kcyclic.jdf
@@ -215,7 +215,7 @@ parsec_taskpool_t* kcyclic_taskpool(parsec_matrix_block_cyclic_t* A,
     assert( NULL != tp );
 
     parsec_translate_matrix_type(TYPE, &dt);
-    parsec_matrix_adt_construct_rect( &tp->arenas_datatypes[PARSEC_kcyclic_DEFAULT_ADT_IDX],
+    parsec_matrix_adt_define_rect( &tp->arenas_datatypes[PARSEC_kcyclic_DEFAULT_ADT_IDX],
                                   dt, A->super.mb, A->super.nb, A->super.mb);
 
     return &tp->super;
diff --git a/tests/collections/redistribute/redistribute_check.jdf b/tests/collections/redistribute/redistribute_check.jdf
index e749c7f28..24fb5ba5a 100644
--- a/tests/collections/redistribute/redistribute_check.jdf
+++ b/tests/collections/redistribute/redistribute_check.jdf
@@ -194,10 +194,10 @@ parsec_redistribute_check_New(parsec_tiled_matrix_t *Y,
     taskpool = parsec_redistribute_check_new(Y, T, size_row, size_col, disi_Y, disj_Y, disi_T, disj_T, R);
     redistribute_check_taskpool = (parsec_taskpool_t*)taskpool;
 
-    parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_check_ORIGIN_ADT_IDX],
+    parsec_matrix_adt_define_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_check_ORIGIN_ADT_IDX],
                             MY_TYPE, Y->mb, Y->nb, Y->mb);
 
-    parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_check_TARGET_ADT_IDX],
+    parsec_matrix_adt_define_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_check_TARGET_ADT_IDX],
                             MY_TYPE, T->mb, T->nb, T->mb);
 
     return redistribute_check_taskpool;
diff --git a/tests/collections/redistribute/redistribute_check2.jdf b/tests/collections/redistribute/redistribute_check2.jdf
index a68ddb6f2..b6934a0c7 100644
--- a/tests/collections/redistribute/redistribute_check2.jdf
+++ b/tests/collections/redistribute/redistribute_check2.jdf
@@ -105,7 +105,7 @@ parsec_redistribute_check2_New(parsec_tiled_matrix_t *dcY,
     int n_END = (disj_Y+size_col-1)/dcY->nb;
     taskpool->_g_NT = (n_END-n_START)/taskpool->_g_num_col;
 
-    parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_check2_DEFAULT_ADT_IDX],
+    parsec_matrix_adt_define_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_check2_DEFAULT_ADT_IDX],
                             MY_TYPE, dcY->mb, dcY->nb, dcY->mb);
 
     return redistribute_check2_taskpool;
diff --git a/tests/collections/redistribute/redistribute_no_optimization.jdf b/tests/collections/redistribute/redistribute_no_optimization.jdf
index c8eb96aef..67eb8e455 100644
--- a/tests/collections/redistribute/redistribute_no_optimization.jdf
+++ b/tests/collections/redistribute/redistribute_no_optimization.jdf
@@ -428,10 +428,10 @@ parsec_redistribute_no_optimization_New(parsec_tiled_matrix_t *dcY,
     int n_T_END = (size_col+disj_T-1) / dcT->nb;
     taskpool->_g_NT = (n_T_END-n_T_START)/taskpool->_g_num_col;
 
-    parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_TARGET_ADT_IDX],
+    parsec_matrix_adt_define_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_TARGET_ADT_IDX],
                                 MY_TYPE, dcT->mb, dcT->nb, dcT->mb);
 
-    parsec_matrix_adt_construct_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_SOURCE_ADT_IDX],
+    parsec_matrix_adt_define_rect(&taskpool->arenas_datatypes[PARSEC_redistribute_no_optimization_SOURCE_ADT_IDX],
                                 MY_TYPE, dcY->mb, dcY->nb, dcY->mb);
 
     return redistribute_no_optimization_taskpool;
diff --git a/tests/collections/reduce.c b/tests/collections/reduce.c
index 61b5c29fc..df8f4aae3 100644
--- a/tests/collections/reduce.c
+++ b/tests/collections/reduce.c
@@ -76,7 +76,7 @@ int main( int argc, char* argv[] )
                                                NULL);
     /* Prepare the arena for the reduction */
     parsec_type_create_contiguous(nb, parsec_datatype_float_t, &newtype);
-    parsec_arena_datatype_construct(&((parsec_reduce_taskpool_t*)tp)->arenas_datatypes[PARSEC_reduce_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type(&((parsec_reduce_taskpool_t*)tp)->arenas_datatypes[PARSEC_reduce_DEFAULT_ADT_IDX],
                                     nb*sizeof(float),
                                     PARSEC_ARENA_ALIGNMENT_SSE,
                                     newtype);
diff --git a/tests/collections/reshape/common.h b/tests/collections/reshape/common.h
index ec8972169..65d7689bd 100644
--- a/tests/collections/reshape/common.h
+++ b/tests/collections/reshape/common.h
@@ -127,24 +127,24 @@ int reshape_print(parsec_execution_stream_t *es,
     (void)name;
 
 
-#define DO_INI_DATATYPES()                                                \
-    parsec_arena_datatype_t adt_default;                                  \
-    parsec_arena_datatype_t adt_lower;                                    \
-    parsec_arena_datatype_t adt_upper;                                    \
-    PARSEC_OBJ_CONSTRUCT(&adt_default, parsec_arena_datatype_t);          \
-    PARSEC_OBJ_CONSTRUCT(&adt_lower, parsec_arena_datatype_t);            \
-    PARSEC_OBJ_CONSTRUCT(&adt_upper, parsec_arena_datatype_t);            \
-    parsec_matrix_adt_construct_rect( &adt_default,                       \
-                            parsec_datatype_int_t, MB, NB, MB );          \
-    parsec_matrix_adt_construct_lower( &adt_lower,                        \
-                            parsec_datatype_int_t, 1, MB );               \
-    parsec_matrix_adt_construct_upper( &adt_upper,                        \
-                            parsec_datatype_int_t, 1, MB );               \
+#define DO_INI_DATATYPES()                                               \
+    parsec_arena_datatype_t adt_default;                                 \
+    parsec_arena_datatype_t adt_lower;                                   \
+    parsec_arena_datatype_t adt_upper;                                   \
+    PARSEC_OBJ_CONSTRUCT(&adt_default, parsec_arena_datatype_t);         \
+    PARSEC_OBJ_CONSTRUCT(&adt_lower, parsec_arena_datatype_t);           \
+    PARSEC_OBJ_CONSTRUCT(&adt_upper, parsec_arena_datatype_t);           \
+    parsec_matrix_adt_define_rect( &adt_default,                         \
+                            parsec_datatype_int_t, MB, NB, MB );         \
+    parsec_matrix_adt_define_lower( &adt_lower,                          \
+                            parsec_datatype_int_t, 1, MB );              \
+    parsec_matrix_adt_define_upper( &adt_upper,                          \
+                            parsec_datatype_int_t, 1, MB );              \
     (void)adt_default; (void)adt_lower; (void)adt_upper;
 
-#define DO_FINI_DATATYPES()                                               \
-    parsec_matrix_arena_datatype_destruct_free_type(&adt_default);        \
-    parsec_matrix_arena_datatype_destruct_free_type(&adt_lower);          \
+#define DO_FINI_DATATYPES()                                              \
+    parsec_matrix_arena_datatype_destruct_free_type(&adt_default);       \
+    parsec_matrix_arena_datatype_destruct_free_type(&adt_lower);         \
     parsec_matrix_arena_datatype_destruct_free_type(&adt_upper);
 
 
diff --git a/tests/collections/two_dim_band/two_dim_band.jdf b/tests/collections/two_dim_band/two_dim_band.jdf
index c9d30a29d..b160d6cd5 100644
--- a/tests/collections/two_dim_band/two_dim_band.jdf
+++ b/tests/collections/two_dim_band/two_dim_band.jdf
@@ -203,7 +203,7 @@ parsec_two_dim_band_New(parsec_tiled_matrix_t *Y, int uplo)
     taskpool = parsec_two_dim_band_new(Y, uplo);
     two_dim_band_taskpool = (parsec_taskpool_t*)taskpool;
 
-    parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_two_dim_band_DEFAULT_ADT_IDX],
+    parsec_matrix_adt_define_rect( &taskpool->arenas_datatypes[PARSEC_two_dim_band_DEFAULT_ADT_IDX],
                              parsec_datatype_double_t, Y->mb, Y->nb, Y->mb);
     return two_dim_band_taskpool;
 }
diff --git a/tests/dsl/dtd/dtd_test_allreduce.c b/tests/dsl/dtd/dtd_test_allreduce.c
index f1e7a17e6..b7aede7d9 100644
--- a/tests/dsl/dtd/dtd_test_allreduce.c
+++ b/tests/dsl/dtd/dtd_test_allreduce.c
@@ -136,8 +136,7 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new(  );
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_broadcast.c b/tests/dsl/dtd/dtd_test_broadcast.c
index 4c8bc5b24..c1f0b7462 100644
--- a/tests/dsl/dtd/dtd_test_broadcast.c
+++ b/tests/dsl/dtd/dtd_test_broadcast.c
@@ -80,8 +80,7 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect( adt,
+    adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_cuda_task_insert.c b/tests/dsl/dtd/dtd_test_cuda_task_insert.c
index 6521f303e..22dfb6a94 100644
--- a/tests/dsl/dtd/dtd_test_cuda_task_insert.c
+++ b/tests/dsl/dtd/dtd_test_cuda_task_insert.c
@@ -168,8 +168,7 @@ int test_cuda_memset(int world, int myrank, parsec_context_t *parsec_context, in
     // Create new DTD taskpool
     parsec_taskpool_t *tp = parsec_dtd_taskpool_new();
 
-    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    parsec_arena_datatype_t *adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
@@ -330,8 +329,7 @@ int test_cuda_memset_and_read(int world, int myrank, parsec_context_t *parsec_co
     // Create new DTD taskpool
     parsec_taskpool_t *tp = parsec_dtd_taskpool_new();
 
-    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    parsec_arena_datatype_t *adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
@@ -493,8 +491,7 @@ int test_cuda_memset_write_read(int world, int myrank, parsec_context_t *parsec_
     // Create new DTD taskpool
     parsec_taskpool_t *tp = parsec_dtd_taskpool_new();
 
-    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    parsec_arena_datatype_t *adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
@@ -702,8 +699,7 @@ int test_cuda_multiple_devices(int world, int myrank, parsec_context_t *parsec_c
 
     parsec_task_class_t *cudaread_tc, *cudacpy_tc;
 
-    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    parsec_arena_datatype_t *adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_data_flush.c b/tests/dsl/dtd/dtd_test_data_flush.c
index f9b04db0e..b0da5ef55 100644
--- a/tests/dsl/dtd/dtd_test_data_flush.c
+++ b/tests/dsl/dtd/dtd_test_data_flush.c
@@ -214,8 +214,7 @@ int main(int argc, char ** argv)
 
         dtd_tp = parsec_dtd_taskpool_new();
 
-        adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-        parsec_matrix_adt_construct_rect(adt,
+        adt = parsec_matrix_adt_new_rect(
                 parsec_datatype_int32_t, nb, 1, nb);
         parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
@@ -357,8 +356,7 @@ int main(int argc, char ** argv)
 
         dtd_tp = parsec_dtd_taskpool_new();
 
-        adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-        parsec_matrix_adt_construct_rect(adt,
+        adt = parsec_matrix_adt_new_rect(
                 parsec_datatype_int32_t, nb, 1, nb);
         parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_explicit_task_creation.c b/tests/dsl/dtd/dtd_test_explicit_task_creation.c
index 906de44e2..44ecbcf35 100644
--- a/tests/dsl/dtd/dtd_test_explicit_task_creation.c
+++ b/tests/dsl/dtd/dtd_test_explicit_task_creation.c
@@ -87,12 +87,11 @@ int main(int argc, char ** argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new(  );
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
-    parsec_arena_datatype_construct( adt,
+    parsec_arena_datatype_set_type( adt,
                                      nb*sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
                                      MPI_INT );
 
diff --git a/tests/dsl/dtd/dtd_test_hierarchy.c b/tests/dsl/dtd/dtd_test_hierarchy.c
index 56e391be8..8d0268d61 100644
--- a/tests/dsl/dtd/dtd_test_hierarchy.c
+++ b/tests/dsl/dtd/dtd_test_hierarchy.c
@@ -131,8 +131,7 @@ int main(int argc, char ** argv)
     dcA = create_and_distribute_empty_data(rank, world, nb, nt);
     parsec_data_collection_set_key((parsec_data_collection_t *)dcA, "A");
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_insert_task_interface.c b/tests/dsl/dtd/dtd_test_insert_task_interface.c
index 9f10a3248..a760328ba 100644
--- a/tests/dsl/dtd/dtd_test_insert_task_interface.c
+++ b/tests/dsl/dtd/dtd_test_insert_task_interface.c
@@ -91,8 +91,7 @@ int main(int argc, char ** argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new(  );
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_interleave_actions.c b/tests/dsl/dtd/dtd_test_interleave_actions.c
index 5263f60ad..e56c2a69d 100644
--- a/tests/dsl/dtd/dtd_test_interleave_actions.c
+++ b/tests/dsl/dtd/dtd_test_interleave_actions.c
@@ -141,8 +141,7 @@ int main(int argc, char **argv) {
 
    parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_new_tile.c b/tests/dsl/dtd/dtd_test_new_tile.c
index 881ba4682..b486b2f3b 100644
--- a/tests/dsl/dtd/dtd_test_new_tile.c
+++ b/tests/dsl/dtd/dtd_test_new_tile.c
@@ -321,8 +321,7 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_pingpong.c b/tests/dsl/dtd/dtd_test_pingpong.c
index cbee5d8bf..bdb3e988e 100644
--- a/tests/dsl/dtd/dtd_test_pingpong.c
+++ b/tests/dsl/dtd/dtd_test_pingpong.c
@@ -112,8 +112,7 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect( adt,
+    adt = parsec_matrix_adt_new_rect(
                                   parsec_datatype_int32_t,
                                   nb, 1, nb );
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
@@ -211,8 +210,7 @@ int main(int argc, char **argv)
         nb = sizes[i];
         nt = 2;
 
-        adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-        parsec_matrix_adt_construct_rect( adt,
+        adt = parsec_matrix_adt_new_rect(
                                   parsec_datatype_int32_t,
                                   nb, 1, nb );
         parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
diff --git a/tests/dsl/dtd/dtd_test_reduce.c b/tests/dsl/dtd/dtd_test_reduce.c
index ce1be7bf4..582edc57c 100644
--- a/tests/dsl/dtd/dtd_test_reduce.c
+++ b/tests/dsl/dtd/dtd_test_reduce.c
@@ -83,8 +83,7 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new(  );
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_simple_gemm.c b/tests/dsl/dtd/dtd_test_simple_gemm.c
index c8ceb9911..f53c353c6 100644
--- a/tests/dsl/dtd/dtd_test_simple_gemm.c
+++ b/tests/dsl/dtd/dtd_test_simple_gemm.c
@@ -635,8 +635,8 @@ int main(int argc, char **argv)
     }
 
     // Create datatypes
-    parsec_arena_datatype_t *adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt, parsec_datatype_double_t, mb, nb, mb);
+    parsec_arena_datatype_t *adt = parsec_matrix_adt_new_rect(parsec_datatype_double_t, mb, nb, mb);
+
     parsec_dtd_attach_arena_datatype(parsec_context, adt, &TILE_FULL);
 
     // Create and initialize the data
diff --git a/tests/dsl/dtd/dtd_test_task_placement.c b/tests/dsl/dtd/dtd_test_task_placement.c
index 854f5b244..de0c5f891 100644
--- a/tests/dsl/dtd/dtd_test_task_placement.c
+++ b/tests/dsl/dtd/dtd_test_task_placement.c
@@ -107,8 +107,7 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_template_counter.c b/tests/dsl/dtd/dtd_test_template_counter.c
index 74f1d91dd..f553de733 100644
--- a/tests/dsl/dtd/dtd_test_template_counter.c
+++ b/tests/dsl/dtd/dtd_test_template_counter.c
@@ -79,8 +79,7 @@ int main(int argc, char **argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_untie.c b/tests/dsl/dtd/dtd_test_untie.c
index 4c1bab9fc..472cc2ce4 100644
--- a/tests/dsl/dtd/dtd_test_untie.c
+++ b/tests/dsl/dtd/dtd_test_untie.c
@@ -136,8 +136,7 @@ int main(int argc, char ** argv)
     dcA = create_and_distribute_data(rank, world, nb, nt);
     parsec_data_collection_set_key((parsec_data_collection_t *)dcA, "A");
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect(adt,
+    adt = parsec_matrix_adt_new_rect(
             parsec_datatype_int32_t, nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
 
diff --git a/tests/dsl/dtd/dtd_test_war.c b/tests/dsl/dtd/dtd_test_war.c
index 8f141f953..b0128bbc8 100644
--- a/tests/dsl/dtd/dtd_test_war.c
+++ b/tests/dsl/dtd/dtd_test_war.c
@@ -90,8 +90,7 @@ int main(int argc, char ** argv)
 
     parsec_taskpool_t *dtd_tp = parsec_dtd_taskpool_new();
 
-    adt = PARSEC_OBJ_NEW(parsec_arena_datatype_t);
-    parsec_matrix_adt_construct_rect( adt,
+    adt = parsec_matrix_adt_new_rect(
                                   parsec_datatype_int32_t,
                                   nb, 1, nb);
     parsec_dtd_attach_arena_datatype(parsec, adt, &TILE_FULL);
diff --git a/tests/dsl/ptg/branching/branching_wrapper.c b/tests/dsl/ptg/branching/branching_wrapper.c
index 33ff11c73..618ad9811 100644
--- a/tests/dsl/ptg/branching/branching_wrapper.c
+++ b/tests/dsl/ptg/branching/branching_wrapper.c
@@ -48,7 +48,7 @@ parsec_taskpool_t *branching_new(parsec_data_collection_t *A, int size, int nb)
     parsec_type_create_contiguous(size, parsec_datatype_int_t, &block);
     parsec_type_extent(block, &lb, &extent);
 
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_branching_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_branching_DEFAULT_ADT_IDX],
                                      extent, PARSEC_ARENA_ALIGNMENT_SSE,
                                      block );
 
diff --git a/tests/dsl/ptg/choice/choice_wrapper.c b/tests/dsl/ptg/choice/choice_wrapper.c
index 994648bf0..a2a7c0847 100644
--- a/tests/dsl/ptg/choice/choice_wrapper.c
+++ b/tests/dsl/ptg/choice/choice_wrapper.c
@@ -48,7 +48,7 @@ parsec_taskpool_t *choice_new(parsec_data_collection_t *A, int size, int *decisi
     tp = parsec_choice_new(A, nb, world, decision);
 
     parsec_type_create_contiguous(size, parsec_datatype_uint8_t, &newType);
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_choice_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_choice_DEFAULT_ADT_IDX],
                                      size * sizeof(char), size * sizeof(char), newType );
 
 
diff --git a/tests/dsl/ptg/complex_deps.jdf b/tests/dsl/ptg/complex_deps.jdf
index df31fe438..93838303a 100644
--- a/tests/dsl/ptg/complex_deps.jdf
+++ b/tests/dsl/ptg/complex_deps.jdf
@@ -167,7 +167,7 @@ int main( int argc, char** argv )
                                      descA.super.bsiz *
                                      parsec_datadist_getsizeoftype(TYPE) );
     parsec_translate_matrix_type(TYPE, &otype);
-    parsec_matrix_adt_construct_rect(adt, otype,
+    parsec_matrix_adt_define_rect(adt, otype,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
 
diff --git a/tests/dsl/ptg/controlgather/ctlgat_wrapper.c b/tests/dsl/ptg/controlgather/ctlgat_wrapper.c
index 660f2395f..1efe889bc 100644
--- a/tests/dsl/ptg/controlgather/ctlgat_wrapper.c
+++ b/tests/dsl/ptg/controlgather/ctlgat_wrapper.c
@@ -55,7 +55,7 @@ parsec_taskpool_t *ctlgat_new(parsec_data_collection_t *A, int size, int nb)
     tp = parsec_ctlgat_new(A, nb, worldsize);
 
     parsec_type_create_contiguous(size, parsec_datatype_uint8_t, &block);
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_ctlgat_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_ctlgat_DEFAULT_ADT_IDX],
                                      size * sizeof(uint8_t), PARSEC_ARENA_ALIGNMENT_SSE,
                                      block );
 
diff --git a/tests/dsl/ptg/local-indices/local_indices.jdf b/tests/dsl/ptg/local-indices/local_indices.jdf
index 4df0b7f28..2863a988e 100644
--- a/tests/dsl/ptg/local-indices/local_indices.jdf
+++ b/tests/dsl/ptg/local-indices/local_indices.jdf
@@ -169,7 +169,7 @@ int main( int argc, char** argv )
     parsec_data_collection_set_key(&descA.super.super, "A");
 
     parsec_translate_matrix_type(PARSEC_MATRIX_DOUBLE, &dt);
-    parsec_matrix_adt_construct_rect(adt, dt,
+    parsec_matrix_adt_define_rect(adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
     /* Start the PaRSEC engine */
     rc = parsec_context_start(parsec);
diff --git a/tests/dsl/ptg/multisize_bcast/check_multisize_bcast_wrapper.c b/tests/dsl/ptg/multisize_bcast/check_multisize_bcast_wrapper.c
index e5f1732f5..590b3154a 100644
--- a/tests/dsl/ptg/multisize_bcast/check_multisize_bcast_wrapper.c
+++ b/tests/dsl/ptg/multisize_bcast/check_multisize_bcast_wrapper.c
@@ -32,7 +32,7 @@ parsec_taskpool_t* check_multisize_bcast_new(parsec_matrix_block_cyclic_t *A, in
     /* As the datatype is parsec_datatype_int32_t all communications to/from
      * this arena should use the count property or they will exchange a
      * single integer. */
-    parsec_arena_datatype_construct(&tp->arenas_datatypes[PARSEC_check_multisize_bcast_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type(&tp->arenas_datatypes[PARSEC_check_multisize_bcast_DEFAULT_ADT_IDX],
                            nb*sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
                            parsec_datatype_int32_t);
 
diff --git a/tests/dsl/ptg/ptgpp/forward_READ_NULL.jdf b/tests/dsl/ptg/ptgpp/forward_READ_NULL.jdf
index 9267c27ea..787da3841 100644
--- a/tests/dsl/ptg/ptgpp/forward_READ_NULL.jdf
+++ b/tests/dsl/ptg/ptgpp/forward_READ_NULL.jdf
@@ -109,7 +109,7 @@ int main(int argc, char *argv[])
      * The arena is now also used to describe the layout to the communication
      * engine (MPI)
      */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_forward_READ_NULL_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_forward_READ_NULL_DEFAULT_ADT_IDX],
                                      sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
                                      parsec_datatype_int_t );
     
diff --git a/tests/dsl/ptg/ptgpp/forward_RW_NULL.jdf b/tests/dsl/ptg/ptgpp/forward_RW_NULL.jdf
index 11eed9a2d..6e5f6abf2 100644
--- a/tests/dsl/ptg/ptgpp/forward_RW_NULL.jdf
+++ b/tests/dsl/ptg/ptgpp/forward_RW_NULL.jdf
@@ -109,7 +109,7 @@ int main(int argc, char *argv[])
      * The arena is now also used to describe the layout to the communication
      * engine (MPI)
      */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_forward_RW_NULL_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_forward_RW_NULL_DEFAULT_ADT_IDX],
                                      sizeof(int), PARSEC_ARENA_ALIGNMENT_SSE,
                                      parsec_datatype_int_t );
 
diff --git a/tests/dsl/ptg/ptgpp/too_many_in_deps.jdf b/tests/dsl/ptg/ptgpp/too_many_in_deps.jdf
index 82c2b3b69..bc5b68cab 100644
--- a/tests/dsl/ptg/ptgpp/too_many_in_deps.jdf
+++ b/tests/dsl/ptg/ptgpp/too_many_in_deps.jdf
@@ -94,7 +94,7 @@ int main(int argc, char* argv[])
 
     /* This test generates no communications between processes, so the datatype
      * associated with the arena are insignificant. */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_too_many_in_deps_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_too_many_in_deps_DEFAULT_ADT_IDX],
                                      descA.super.mb * descA.super.nb * parsec_datadist_getsizeoftype(TYPE),
                                      PARSEC_ARENA_ALIGNMENT_SSE,
                                      PARSEC_DATATYPE_NULL);  /* change for distributed cases */
diff --git a/tests/dsl/ptg/ptgpp/too_many_local_vars.jdf b/tests/dsl/ptg/ptgpp/too_many_local_vars.jdf
index 6b1fa717d..16388dce6 100644
--- a/tests/dsl/ptg/ptgpp/too_many_local_vars.jdf
+++ b/tests/dsl/ptg/ptgpp/too_many_local_vars.jdf
@@ -87,7 +87,7 @@ int main(int argc, char* argv[])
 
     /* This test generates no communications between processes, so the datatype
      * associated with the arena are insignificant. */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_too_many_local_vars_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_too_many_local_vars_DEFAULT_ADT_IDX],
                                      descA.super.mb * descA.super.nb * parsec_datadist_getsizeoftype(TYPE),
                                      PARSEC_ARENA_ALIGNMENT_SSE,
                                      PARSEC_DATATYPE_NULL);  /* change for distributed cases */
diff --git a/tests/dsl/ptg/ptgpp/too_many_out_deps.jdf b/tests/dsl/ptg/ptgpp/too_many_out_deps.jdf
index cd42dbbb6..e8cd24de4 100644
--- a/tests/dsl/ptg/ptgpp/too_many_out_deps.jdf
+++ b/tests/dsl/ptg/ptgpp/too_many_out_deps.jdf
@@ -89,7 +89,7 @@ int main(int argc, char* argv[])
 
     /* This test generates no communications between processes, so the datatype
      * associated with the arena are insignificant. */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_too_many_out_deps_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_too_many_out_deps_DEFAULT_ADT_IDX],
                                      descA.super.mb * descA.super.nb * parsec_datadist_getsizeoftype(TYPE),
                                      PARSEC_ARENA_ALIGNMENT_SSE,
                                      PARSEC_DATATYPE_NULL);  /* change for distributed cases */
diff --git a/tests/dsl/ptg/ptgpp/too_many_read_flows.jdf b/tests/dsl/ptg/ptgpp/too_many_read_flows.jdf
index 855ffbd1e..7a65f8d8a 100644
--- a/tests/dsl/ptg/ptgpp/too_many_read_flows.jdf
+++ b/tests/dsl/ptg/ptgpp/too_many_read_flows.jdf
@@ -91,7 +91,7 @@ int main(int argc, char* argv[])
 
     /* This test generates no communications between processes, so the datatype
      * associated with the arena are insignificant. */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_too_many_read_flows_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_too_many_read_flows_DEFAULT_ADT_IDX],
                                      descA.super.mb * descA.super.nb * parsec_datadist_getsizeoftype(TYPE),
                                      PARSEC_ARENA_ALIGNMENT_SSE,
                                      PARSEC_DATATYPE_NULL);  /* change for distributed cases */
diff --git a/tests/dsl/ptg/ptgpp/too_many_write_flows.jdf b/tests/dsl/ptg/ptgpp/too_many_write_flows.jdf
index a2b24fdb5..697e7e543 100644
--- a/tests/dsl/ptg/ptgpp/too_many_write_flows.jdf
+++ b/tests/dsl/ptg/ptgpp/too_many_write_flows.jdf
@@ -95,7 +95,7 @@ int main(int argc, char* argv[])
 
     /* This test generates no communications between processes, so the datatype
      * associated with the arena are insignificant. */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_too_many_write_flows_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_too_many_write_flows_DEFAULT_ADT_IDX],
                                      descA.super.mb * descA.super.nb * parsec_datadist_getsizeoftype(TYPE),
                                      PARSEC_ARENA_ALIGNMENT_SSE,
                                      PARSEC_DATATYPE_NULL);  /* change for distributed cases */
diff --git a/tests/dsl/ptg/ptgpp/write_check.jdf b/tests/dsl/ptg/ptgpp/write_check.jdf
index 06f002ec7..01e2bc65b 100644
--- a/tests/dsl/ptg/ptgpp/write_check.jdf
+++ b/tests/dsl/ptg/ptgpp/write_check.jdf
@@ -133,7 +133,7 @@ int main(int argc, char* argv[])
 
     /* This test generates no communications between processes, so the datatype
      * associated with the arena are insignificant. */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_write_check_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_write_check_DEFAULT_ADT_IDX],
                                      descA.super.mb * descA.super.nb * parsec_datadist_getsizeoftype(TYPE),
                                      PARSEC_ARENA_ALIGNMENT_SSE,
                                      PARSEC_DATATYPE_NULL);  /* change for distributed cases */
diff --git a/tests/dsl/ptg/recursive.jdf b/tests/dsl/ptg/recursive.jdf
index e7f4e443f..5e0ada630 100644
--- a/tests/dsl/ptg/recursive.jdf
+++ b/tests/dsl/ptg/recursive.jdf
@@ -147,7 +147,7 @@ int main( int argc, char** argv )
 
     parsec_translate_matrix_type(TYPE, &dt);
 
-    parsec_matrix_adt_construct_rect(adt, dt,
+    parsec_matrix_adt_define_rect(adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
     /* Start the PaRSEC engine */
diff --git a/tests/dsl/ptg/startup.jdf b/tests/dsl/ptg/startup.jdf
index ef42d5d36..9f46212a4 100644
--- a/tests/dsl/ptg/startup.jdf
+++ b/tests/dsl/ptg/startup.jdf
@@ -145,7 +145,7 @@ int main( int argc, char** argv )
                                      parsec_datadist_getsizeoftype(TYPE) );
 
     parsec_translate_matrix_type(TYPE, &dt);
-    parsec_matrix_adt_construct_rect(adt, dt,
+    parsec_matrix_adt_define_rect(adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
     srandom((int)getpid());  /* Start the random generator */
diff --git a/tests/dsl/ptg/strange.jdf b/tests/dsl/ptg/strange.jdf
index 8649ac70b..4c4896308 100644
--- a/tests/dsl/ptg/strange.jdf
+++ b/tests/dsl/ptg/strange.jdf
@@ -173,7 +173,7 @@ int main(int argc, char* argv[] )
     ((parsec_strange_taskpool_t*)tp)->_g_neworder = neworder;
 
     /* Datatype not needed for a single node test */
-    parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_strange_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_strange_DEFAULT_ADT_IDX],
                                      descA.super.mb * descA.super.nb * parsec_datadist_getsizeoftype(TYPE),
                                      PARSEC_ARENA_ALIGNMENT_SSE,
                                      PARSEC_DATATYPE_NULL);  /* change for distributed cases */
diff --git a/tests/dsl/ptg/user-defined-functions/utt.jdf b/tests/dsl/ptg/user-defined-functions/utt.jdf
index a8576d92d..2b5997034 100644
--- a/tests/dsl/ptg/user-defined-functions/utt.jdf
+++ b/tests/dsl/ptg/user-defined-functions/utt.jdf
@@ -143,7 +143,7 @@ int main( int argc, char** argv )
     parsec_data_collection_set_key(&descA.super.super, "A");
 
     parsec_translate_matrix_type(PARSEC_MATRIX_DOUBLE, &dt);
-    parsec_matrix_adt_construct_rect( adt, dt, descA.super.mb, descA.super.nb, descA.super.mb);
+    parsec_matrix_adt_define_rect( adt, dt, descA.super.mb, descA.super.nb, descA.super.mb);
 
     /* Start the PaRSEC engine */
     rc = parsec_context_start(parsec);
diff --git a/tests/profiling/async.jdf b/tests/profiling/async.jdf
index f755f6a2b..c044b7721 100644
--- a/tests/profiling/async.jdf
+++ b/tests/profiling/async.jdf
@@ -230,7 +230,7 @@ int main( int argc, char** argv )
     parsec_data_collection_set_key(&descA.super.super, "A");
 
     parsec_translate_matrix_type(PARSEC_MATRIX_DOUBLE, &dt);
-    parsec_matrix_adt_construct_rect(adt, dt,
+    parsec_matrix_adt_define_rect(adt, dt,
                                  descA.super.mb, descA.super.nb, descA.super.mb);
 
     /* Start the PaRSEC engine */
diff --git a/tests/runtime/cuda/get_best_device_check.jdf b/tests/runtime/cuda/get_best_device_check.jdf
index 26676d2a2..d1b0a4e7d 100644
--- a/tests/runtime/cuda/get_best_device_check.jdf
+++ b/tests/runtime/cuda/get_best_device_check.jdf
@@ -169,7 +169,7 @@ parsec_get_best_device_check_New(parsec_tiled_matrix_t *dcA, int *info)
     taskpool->_g_cuda_device_index = dev_index;
 #endif
 
-    parsec_matrix_adt_construct_rect( &taskpool->arenas_datatypes[PARSEC_get_best_device_check_DEFAULT_ADT_IDX],
+    parsec_matrix_adt_define_rect( &taskpool->arenas_datatypes[PARSEC_get_best_device_check_DEFAULT_ADT_IDX],
             parsec_datatype_double_t, dcA->mb, dcA->nb, dcA->mb);
 
     return get_best_device_check_taskpool;
diff --git a/tests/runtime/cuda/nvlink_wrapper.c b/tests/runtime/cuda/nvlink_wrapper.c
index 5dbdb8d6e..d6faeee89 100644
--- a/tests/runtime/cuda/nvlink_wrapper.c
+++ b/tests/runtime/cuda/nvlink_wrapper.c
@@ -211,7 +211,7 @@ parsec_taskpool_t* testing_nvlink_New( parsec_context_t *ctx, int depth, int mb
 
     testing_handle = parsec_nvlink_new(dcA, userM, ctx->nb_nodes, CuHI, nb, dev_index);
 
-    parsec_matrix_adt_construct_tile( &testing_handle->arenas_datatypes[PARSEC_nvlink_DEFAULT_ADT_IDX],
+    parsec_matrix_adt_define_square( &testing_handle->arenas_datatypes[PARSEC_nvlink_DEFAULT_ADT_IDX],
                              parsec_datatype_double_complex_t, mb );
 
     return &testing_handle->super;
diff --git a/tests/runtime/cuda/stress_wrapper.c b/tests/runtime/cuda/stress_wrapper.c
index d291f5c3c..65cc4f216 100644
--- a/tests/runtime/cuda/stress_wrapper.c
+++ b/tests/runtime/cuda/stress_wrapper.c
@@ -72,7 +72,7 @@ parsec_taskpool_t* testing_stress_New( parsec_context_t *ctx, int depth, int mb
 
     testing_handle = parsec_stress_new(dcA, ctx->nb_nodes, nb, dev_index);
 
-    parsec_matrix_adt_construct_tile( &testing_handle->arenas_datatypes[PARSEC_stress_DEFAULT_ADT_IDX],
+    parsec_matrix_adt_define_square( &testing_handle->arenas_datatypes[PARSEC_stress_DEFAULT_ADT_IDX],
                              parsec_datatype_double_complex_t, mb );
     return &testing_handle->super;
 }
diff --git a/tests/runtime/dtt_bug_replicator_ex.c b/tests/runtime/dtt_bug_replicator_ex.c
index 975c775b9..299aebbad 100644
--- a/tests/runtime/dtt_bug_replicator_ex.c
+++ b/tests/runtime/dtt_bug_replicator_ex.c
@@ -64,18 +64,18 @@ int main( int argc, char** argv )
         dump_double_array("Original ", (double*)dcA.mat, 0, 0, NB, NB, NB);
     }
     parsec_type_create_contiguous(NB*NB, parsec_datatype_double_t, &tile_dtt);
-    parsec_arena_datatype_construct( &dtt_tp->arenas_datatypes[PARSEC_dtt_bug_replicator_DTT1_ADT_IDX],
+    parsec_arena_datatype_set_type( &dtt_tp->arenas_datatypes[PARSEC_dtt_bug_replicator_DTT1_ADT_IDX],
                                      NB*NB*sizeof(double),
                                      PARSEC_ARENA_ALIGNMENT_SSE, tile_dtt );
 
-    parsec_arena_datatype_construct( &dtt_tp->arenas_datatypes[PARSEC_dtt_bug_replicator_DEFAULT_ADT_IDX],
+    parsec_arena_datatype_set_type( &dtt_tp->arenas_datatypes[PARSEC_dtt_bug_replicator_DEFAULT_ADT_IDX],
                                      NB*NB*sizeof(double),
                                      PARSEC_ARENA_ALIGNMENT_SSE, tile_dtt );
 
     parsec_type_create_vector(NB, 1, NB, parsec_datatype_double_t, &vdtt1);
     parsec_type_create_resized(vdtt1, 0, sizeof(parsec_datatype_double_t), &vdtt2);
     parsec_type_create_contiguous(NB, vdtt2, &vdtt);
-    parsec_arena_datatype_construct( &dtt_tp->arenas_datatypes[PARSEC_dtt_bug_replicator_DTT2_ADT_IDX],
+    parsec_arena_datatype_set_type( &dtt_tp->arenas_datatypes[PARSEC_dtt_bug_replicator_DTT2_ADT_IDX],
                                      NB*NB*sizeof(double),
                                      PARSEC_ARENA_ALIGNMENT_SSE, vdtt );
 
diff --git a/tests/runtime/multichain.jdf b/tests/runtime/multichain.jdf
index 7b0e7d44c..08d78862b 100644
--- a/tests/runtime/multichain.jdf
+++ b/tests/runtime/multichain.jdf
@@ -224,7 +224,7 @@ int main(int argc, char* argv[])
         parsec_type_create_contiguous(descA.super.mb * descA.super.nb,
                                       baseType, &newtype);
         PARSEC_OBJ_CONSTRUCT(&adt, parsec_arena_datatype_t);
-        parsec_arena_datatype_construct( &adt,
+        parsec_arena_datatype_set_type( &adt,
                                          descA.super.mb * descA.super.nb * parsec_datadist_getsizeoftype(TYPE),
                                          PARSEC_ARENA_ALIGNMENT_SSE, newtype);
 
diff --git a/tests/runtime/scheduling/ep_wrapper.c b/tests/runtime/scheduling/ep_wrapper.c
index 77a3e472b..e65eadc40 100644
--- a/tests/runtime/scheduling/ep_wrapper.c
+++ b/tests/runtime/scheduling/ep_wrapper.c
@@ -41,7 +41,7 @@ parsec_taskpool_t *ep_new(parsec_data_collection_t *A, int nt, int level)
         MPI_Type_extent(MPI_BYTE, &extent);
 #endif  /* defined(PARSEC_HAVE_MPI_20) */
         /* The datatype is irrelevant as the example does not do communications between nodes */
-        parsec_arena_datatype_construct( &tp->arenas_datatypes[PARSEC_ep_DEFAULT_ADT_IDX],
+        parsec_arena_datatype_set_type( &tp->arenas_datatypes[PARSEC_ep_DEFAULT_ADT_IDX],
                                          extent, PARSEC_ARENA_ALIGNMENT_SSE,
                                          MPI_BYTE );
     }