diff --git a/attributes/maestro-schema.c b/attributes/maestro-schema.c
index 70f18d12e75190689f9d3eae1931d2c24695a900..fc745012f1cc028539d49ec7f2a5692116f7b6aa 100644
--- a/attributes/maestro-schema.c
+++ b/attributes/maestro-schema.c
@@ -2759,50 +2759,6 @@ mstro_attribute_pool_find_dist_layout(Mstro__Pool__Attributes *attributes, mmbLa
   return status;
 }
 
-/* FIXME push to mamba?!*/
-/** If a CDO has is_distributed flag set at the mstro_pm_cdo_registry_entry but
-  * the cdo handle does not has a distribution defined,
-  *
-  * we cook up a default distributed for it, which consists of one piece holding
-  * all the cdo data */
-mstro_status
-mstro_attribute_create_default_dist_layout(mmbLayout *src_layout, mmbLayout **default_layout){
-  mstro_status status = MSTRO_OK;
-
-
-  /*FIXME only support irregular 1D layouts */
-  if ((src_layout->type != MMB_IRREGULAR) || (src_layout->n_dims != 1)) {
-    ERR("FIXME only support now 1D irregular layouts \n");
-    return MSTRO_UNIMPL;
-  }
-
-  size_t *offsets, *sizes;
-  offsets = (size_t *) malloc(sizeof(size_t) * 1);
-  sizes = (size_t *) malloc(sizeof(size_t) * 1);
-
-  if ((!offsets) || (!sizes) ) {
-    ERR("Can not allocate memory for default layout offsets and sizes \n");
-    return MSTRO_NOMEM;
-  }
-
-  offsets[0] = 0; // data starts from the begining
-  /* find the whole cdo size -- FIXME push to mamba */
-  sizes[0] = 0; // cdo size
-  for (size_t i = 0; i < src_layout->irregular.n_blocks.d[0]; i++) {
-    sizes[0] += src_layout->irregular.lengths[i]; // cdo size
-  }
-
-
-  mmbError stat = MMB_OK;
-  stat = mmb_layout_create_dist_irregular_1d(src_layout->element.size_bytes,
-                                       0, /*index = 0*/
-                                       1, /* nblocks = 1*/
-                                       offsets,
-                                       sizes,
-                                       default_layout);
-
-  return (stat == MMB_OK) ? MSTRO_OK : MSTRO_FAIL;
-}
 
 mstro_status
 mstro_attribute_pool_aval_to_mmbLayout(Mstro__Pool__Mmblayout *aval_layout, mmbLayout **dist_layout){
diff --git a/maestro/pool_client.c b/maestro/pool_client.c
index e55c191337f3e6c8003240c79304b0772a0ed1af..96caacd15f5b993a32d28155f79e239b381fcd0c 100644
--- a/maestro/pool_client.c
+++ b/maestro/pool_client.c
@@ -378,6 +378,7 @@ mstro_pc__calculate_data_size_and_offsets(
   if(is_distributed) {
     mmbLayout *src_layout = NULL;
     mmbLayout *dst_layout = NULL;
+    mmbError stat = MMB_OK;
     /* read source and dst layouts */
     status = mstro_attribute_pool_find_dist_layout(src_cdo->attributes_msg, &src_layout);
     status = mstro_attribute_pool_find_dist_layout(dst_attributes, &dst_layout); 
@@ -385,13 +386,13 @@ mstro_pc__calculate_data_size_and_offsets(
 
     if(src_layout == NULL){
       /* cook a default layout for src from dst */
-      status = mstro_attribute_create_default_dist_layout(dst_layout, &src_layout);
+      stat = mmb_layout_dist_create_default_layout(dst_layout, &src_layout);
     }
     else if(dst_layout == NULL) {
       /* cook a default layout for dst from src */
-      status = mstro_attribute_create_default_dist_layout(src_layout, &dst_layout);
+      stat = mmb_layout_dist_create_default_layout(src_layout, &dst_layout);
     }
-    assert(status == MSTRO_OK);
+    assert(stat == MMB_OK);
     /* find the mapping between src and dst layouts */
     mmbLayoutIntersection *out_li = NULL;
     mmbError mmb_s;
@@ -410,7 +411,7 @@ mstro_pc__calculate_data_size_and_offsets(
         /*read the length, number of segments, and src and dst offsets from the intersection object*/
         *dst_offset = out_li->overlap[index].dst_offset * src_layout->element.size_bytes; /* offset in bytes */
         *src_offset = out_li->overlap[index].src_offset * src_layout->element.size_bytes; /* offset in bytes */
-        /* data_lenth is equal to the length of intersection * size of element in bytes */
+        /* data_length is equal to the length of intersection * size of element in bytes */
         DEBUG("Intersection length %zu and size of element is %zu \n", out_li->overlap[index].length, src_layout->element.size_bytes);
         *data_length = out_li->overlap[index].length * src_layout->element.size_bytes ; /* data size in bytes */
       }
diff --git a/maestro/pool_manager_registry.c b/maestro/pool_manager_registry.c
index 828c450cd9790c0dd2b129b91fe7d89b71e89767..4839feab05497cdf75ff4e19a5259dba531acec3 100644
--- a/maestro/pool_manager_registry.c
+++ b/maestro/pool_manager_registry.c
@@ -654,6 +654,7 @@ mstro_pm__dist_cdo_find_best_provider(
   mstro_status status;
   bool default_layout = false;
   mmbLayout *src_layout = NULL;
+  mmbError stat;
 
   /* FIXME: this is just greedy */
   /* FIXME: this also does not return the actual local-id */
@@ -685,8 +686,8 @@ mstro_pm__dist_cdo_find_best_provider(
 
           if(!h->dist_layout) {
             WARN("CDO with local-id %zu is flagged as distributed but has no distribution layout ... will create a default one \n", h->local_id);
-            status = mstro_attribute_create_default_dist_layout(e->req_dist_layout, &src_layout);
-            assert(status == MSTRO_OK);
+            stat = mmb_layout_dist_create_default_layout(e->req_dist_layout, &src_layout);
+            assert(stat == MMB_OK);
             default_layout = true;
           }
           else {
@@ -696,9 +697,9 @@ mstro_pm__dist_cdo_find_best_provider(
 
           /** try to match the distribution */
           mmbLayoutEquivalence diff;
-          mmbError mmb_s;
-          mmb_s = mmb_layout_cmp(src_layout, e->req_dist_layout, &diff);
-          assert(MMB_OK == mmb_s);
+          
+          stat = mmb_layout_cmp(src_layout, e->req_dist_layout, &diff);
+          assert(MMB_OK == stat);
           assert(diff != MMB_LAYOUT_EQUAL); /* would have been caught above by mstro_pm__find_cdo_with_layout */
           if (diff == MMB_LAYOUT_DIFF_FIELDS){
             DEBUG("Found entry with local-id %zu for % " PRIappid " but with different layout \n",
@@ -706,8 +707,8 @@ mstro_pm__dist_cdo_find_best_provider(
 
             /* FIXME make a hash table of the two layouts, so that we do not compute this intersection many times */
             mmbLayoutIntersection *out_li = NULL;
-            mmb_s = mmb_layout_compute_intersection(src_layout, e->req_dist_layout, &out_li);
-            assert(MMB_OK == mmb_s);
+            stat = mmb_layout_compute_intersection(src_layout, e->req_dist_layout, &out_li);
+            assert(MMB_OK == stat);
             DEBUG("checking layouts intersection \n");
             if (out_li) {
               mstro_pm__mmbLayoutIntersecton_to_candidates(out_li, e->req_dist_layout->index, src_layout, app_to_attributes_table, candidates);
@@ -883,6 +884,7 @@ mstro_pm__find_cdo_with_layout(
                             uint64_t *local_id) {
 
   mstro_status status = MSTRO_OK;
+  mmbError stat;
   mmbLayout *src_layout = NULL;
   bool default_layout = false;
   struct per_app_cdo_entries *entry, *tmp;
@@ -895,8 +897,8 @@ mstro_pm__find_cdo_with_layout(
 
         if (!h->dist_layout) {
           WARN("CDO with local-id %zu is flagged as distributed but has no distribution layout ... will create a default one \n", h->local_id);
-          status = mstro_attribute_create_default_dist_layout(s_layout, &src_layout);
-          assert(status == MSTRO_OK);
+          stat = mmb_layout_dist_create_default_layout(s_layout, &src_layout);
+          assert(stat == MMB_OK);
           default_layout = true;
         }
         else {
@@ -1145,6 +1147,7 @@ mstro_pm__handle_demands(struct mstro_pm_demand_queue_entry *q)
   struct mstro_pm_demand_queue_entry *unhandled=NULL;
   size_t len=0;
   struct mstro_pm_demand_queue_entry *e;
+  mmbError stat;
   mmbLayout *default_layout = NULL;
   mmbLayout *src_layout;
   LL_COUNT(q,e,len);
@@ -1177,8 +1180,8 @@ mstro_pm__handle_demands(struct mstro_pm_demand_queue_entry *q)
               WARN("Required CDO is flagged as distributed but has no distribution layout ... will create a default one \n");
               /* look for a cdo distribution as a source dist */
               status = mstro_pm__find_dist_layout(regentry->app_to_attributes, &src_layout);
-              status = mstro_attribute_create_default_dist_layout(src_layout, &default_layout);
-              assert(status == MSTRO_OK);
+              stat = mmb_layout_dist_create_default_layout(src_layout, &default_layout);
+              assert(stat == MMB_OK);
               e->req_dist_layout = default_layout;
             }
 
diff --git a/transport/transport.c b/transport/transport.c
index 9458253c4eef4a09cce6fdcb9c9e8dc3405fccdc..53e39db4b17d75bef93bea2b06991b290944bcda 100644
--- a/transport/transport.c
+++ b/transport/transport.c
@@ -438,22 +438,19 @@ mstro_transport_execute(
       int64_t cdo_size = 0;
       mmbLayout *dst_layout = NULL;
       mmbLayout *src_layout = NULL;
+      mmbError stat;
       s = mstro_attribute_pool_find_dist_layout(cdo->attributes_msg, &dst_layout);
       assert(s == MSTRO_OK);
     
       if(dst_layout == NULL) {
       /* cook a default layout for dst from src */
       s = mstro_attribute_pool_find_dist_layout(ticket->attributes, &src_layout);
-      s = mstro_attribute_create_default_dist_layout(src_layout, &dst_layout);
       assert(s == MSTRO_OK);
+      stat = mmb_layout_dist_create_default_layout(src_layout, &dst_layout);
+      assert(stat == MMB_OK);
       }
-
-      /* FIXME assuming irregular 1D mmb_layout only */
-      assert(dst_layout->type == MMB_IRREGULAR);
-      assert(dst_layout->n_dims == 1);
-      /* FIXME push down size calculation to mamba ...
-       * cdo size = length of my piece in the distribution * size of element */
-      cdo_size =  dst_layout->irregular.lengths[dst_layout->index] * dst_layout->element.size_bytes;
+      stat = mmb_layout_dist_find_piece_size(dst_layout, &cdo_size);
+      assert(stat == MMB_OK);
       DEBUG("Size of my piece as calculated from my distribution layout is %"PRId64" \n", cdo_size);
 
       /* free up allocated layout objects*/