diff --git a/compute/zgelqf.c b/compute/zgelqf.c
index 0b2ee5b69e80ef6d1ea054ef976637cf4b224a42..4d6633b0a78492bd399ca094282a10fff36cda20 100644
--- a/compute/zgelqf.c
+++ b/compute/zgelqf.c
@@ -278,8 +278,8 @@ int CHAMELEON_zgelqf_Tile_Async( CHAM_desc_t *A, CHAM_desc_t *T,
      */
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int m = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
+        int m = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, m, A->n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zgelqf_param.c b/compute/zgelqf_param.c
index 6d8c125a518b5593d9e415909afe8675633e41cc..74261782657b25920be184b511ca55865614b48d 100644
--- a/compute/zgelqf_param.c
+++ b/compute/zgelqf_param.c
@@ -282,8 +282,8 @@ int CHAMELEON_zgelqf_param_Tile_Async( const libhqr_tree_t *qrtree, CHAM_desc_t
      */
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int m = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
+        int m = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, m, A->n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zgelqs.c b/compute/zgelqs.c
index 703650460f4881ee64633fe939179c3359ce628a..483d3ef27bf2aaf1863100393a0b26957b4a0ce3 100644
--- a/compute/zgelqs.c
+++ b/compute/zgelqs.c
@@ -318,8 +318,8 @@ int CHAMELEON_zgelqs_Tile_Async( CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B,
 
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int m = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
+        int m = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, m, A->n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zgelqs_param.c b/compute/zgelqs_param.c
index eedb2dacd145743702424b164760495ba2803ce5..26839a939576ecdf18843ec3b707bb8dbfef3b23 100644
--- a/compute/zgelqs_param.c
+++ b/compute/zgelqs_param.c
@@ -330,8 +330,8 @@ int CHAMELEON_zgelqs_param_Tile_Async( const libhqr_tree_t *qrtree, CHAM_desc_t
 
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int m = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
+        int m = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, m, A->n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zgels.c b/compute/zgels.c
index b132610a81546f8c9d3882e4afbab171096673d7..c18c4c0466aee6379bb65cdb461f5b77a936bb0b 100644
--- a/compute/zgels.c
+++ b/compute/zgels.c
@@ -364,8 +364,8 @@ int CHAMELEON_zgels_Tile_Async( cham_trans_t trans, CHAM_desc_t *A,
     if (A->m >= A->n) {
 #if defined(CHAMELEON_COPY_DIAG)
         {
-            int n = chameleon_min(A->m, A->n);
-            chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+            int n = chameleon_min( A->m, A->n );
+            chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
             Dptr = &D;
         }
 #endif
@@ -432,8 +432,8 @@ int CHAMELEON_zgels_Tile_Async( cham_trans_t trans, CHAM_desc_t *A,
     else {
 #if defined(CHAMELEON_COPY_DIAG)
         {
-            int m = chameleon_min(A->m, A->n);
-            chameleon_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
+            int m = chameleon_min( A->m, A->n );
+            chameleon_zdesc_copy_and_restrict( A, &D, m, A->n );
             Dptr = &D;
         }
 #endif
diff --git a/compute/zgels_param.c b/compute/zgels_param.c
index 01999735fd6cbc7f5c9fe7c72f6d46c40634c168..26d777cc628c103081bbeec45426f897a0fd1af6 100644
--- a/compute/zgels_param.c
+++ b/compute/zgels_param.c
@@ -377,8 +377,8 @@ int CHAMELEON_zgels_param_Tile_Async( const libhqr_tree_t *qrtree, cham_trans_t
     if (A->m >= A->n) {
 #if defined(CHAMELEON_COPY_DIAG)
         {
-            int n = chameleon_min(A->m, A->n);
-            chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+            int n = chameleon_min( A->m, A->n );
+            chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
             Dptr = &D;
         }
 #endif
@@ -431,8 +431,8 @@ int CHAMELEON_zgels_param_Tile_Async( const libhqr_tree_t *qrtree, cham_trans_t
     else {
 #if defined(CHAMELEON_COPY_DIAG)
         {
-            int m = chameleon_min(A->m, A->n);
-            chameleon_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
+            int m = chameleon_min( A->m, A->n );
+            chameleon_zdesc_copy_and_restrict( A, &D, m, A->n );
             Dptr = &D;
         }
 #endif
diff --git a/compute/zgeqrf.c b/compute/zgeqrf.c
index 98675a46764601d76a38b731866ec83d32380c4e..f9557eb9972d14b4d4d4cebf9d2852ac090ce64f 100644
--- a/compute/zgeqrf.c
+++ b/compute/zgeqrf.c
@@ -277,8 +277,8 @@ int CHAMELEON_zgeqrf_Tile_Async( CHAM_desc_t *A, CHAM_desc_t *T,
      */
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int n = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+        int n = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zgeqrf_param.c b/compute/zgeqrf_param.c
index c406b9207f2072b983e6a7b3948f4392297f77cb..75e25f895823d0addb078258fa1e312cafc2ed08 100644
--- a/compute/zgeqrf_param.c
+++ b/compute/zgeqrf_param.c
@@ -302,8 +302,8 @@ int CHAMELEON_zgeqrf_param_Tile_Async( const libhqr_tree_t *qrtree, CHAM_desc_t
 
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int n = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+        int n = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zgeqrs.c b/compute/zgeqrs.c
index a6b41d0b1e257355c73121871d61b16a6023493f..0857f9e08c8339b74d1348409161a169445f0cdf 100644
--- a/compute/zgeqrs.c
+++ b/compute/zgeqrs.c
@@ -307,8 +307,8 @@ int CHAMELEON_zgeqrs_Tile_Async( CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B,
      */
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int n = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+        int n = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zgeqrs_param.c b/compute/zgeqrs_param.c
index 84aa1af688d62c989aa28ce83b84326f10a0c46c..eb914016d4b26ec62ef2f5db87c0cb1094d8a707 100644
--- a/compute/zgeqrs_param.c
+++ b/compute/zgeqrs_param.c
@@ -311,8 +311,8 @@ int CHAMELEON_zgeqrs_param_Tile_Async( const libhqr_tree_t *qrtree,
      */
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int n = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+        int n = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zgesv_incpiv.c b/compute/zgesv_incpiv.c
index 89cc15107a81ba8487352119261fe559f1bf2dd1..3842b95c8529ae6d3938fe0cb2d9d8d7a18b9c1d 100644
--- a/compute/zgesv_incpiv.c
+++ b/compute/zgesv_incpiv.c
@@ -311,8 +311,8 @@ int CHAMELEON_zgesv_incpiv_Tile_Async( CHAM_desc_t *A, CHAM_desc_t *L, int *IPIV
 
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int n = chameleon_min(A->mt, A->nt) * A->nb;
-        chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+        int n = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zgetrf_incpiv.c b/compute/zgetrf_incpiv.c
index f1f2e795a3bca4e6d8fe4d2626f179f97cb94828..6cc7614fdab2fa86f54bbde68d0fdcbd91adfee4 100644
--- a/compute/zgetrf_incpiv.c
+++ b/compute/zgetrf_incpiv.c
@@ -283,8 +283,8 @@ int CHAMELEON_zgetrf_incpiv_Tile_Async( CHAM_desc_t *A, CHAM_desc_t *L, int *IPI
 
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int n = chameleon_min(A->mt, A->nt) * A->nb;
-        chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+        int n = chameleon_min( A->m, A->n ) * A->nb;
+        chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/ztpgqrt.c b/compute/ztpgqrt.c
index 98db159afb8e089b7b696401d48bb1e1974edbe1..d826d81114c62e7bf19580ea820c0301d0582bad 100644
--- a/compute/ztpgqrt.c
+++ b/compute/ztpgqrt.c
@@ -404,7 +404,7 @@ int CHAMELEON_ztpgqrt_Tile_Async( int L,
 
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        chameleon_zdesc_alloc(D, V1->mb, V1->nb, V1->m, KT*V1->nb, 0, 0, V1->m, KT*V1->nb, );
+        chameleon_zdesc_copy_and_restrict( V1, &D, V1->m, KT*V1->nb );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zunglq.c b/compute/zunglq.c
index 3d3ce3062eff4f92e911ab4850526eda11ebb5ec..085fcd29b5e94b2a0bf07b6a1f8b15216c25ab9e 100644
--- a/compute/zunglq.c
+++ b/compute/zunglq.c
@@ -300,8 +300,8 @@ int CHAMELEON_zunglq_Tile_Async( CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *Q,
 
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int m = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
+        int m = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, m, A->n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zunglq_param.c b/compute/zunglq_param.c
index aec224f967b56e19904e253dd6871d8fadffbd07..4a7a908cb91ad485a559b8e685d7a0cdf8a5d620 100644
--- a/compute/zunglq_param.c
+++ b/compute/zunglq_param.c
@@ -303,8 +303,8 @@ int CHAMELEON_zunglq_param_Tile_Async( const libhqr_tree_t *qrtree, CHAM_desc_t
      */
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int m = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
+        int m = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, m, A->n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zungqr.c b/compute/zungqr.c
index 69f8be30e599d076837fe3a4bd8f413487e59722..0f4558e7abb7662e6b11204d0169b761eae84140 100644
--- a/compute/zungqr.c
+++ b/compute/zungqr.c
@@ -297,8 +297,8 @@ int CHAMELEON_zungqr_Tile_Async( CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *Q,
      */
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int n = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+        int n = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zungqr_param.c b/compute/zungqr_param.c
index 36bacc08921fda83e45bf14b8a41194cae68f6f2..8c0eb0a68a10de717fd3aabdabcf59d3c9c9d26a 100644
--- a/compute/zungqr_param.c
+++ b/compute/zungqr_param.c
@@ -310,8 +310,8 @@ int CHAMELEON_zungqr_param_Tile_Async( const libhqr_tree_t *qrtree, CHAM_desc_t
 
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int n = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+        int n = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zunmlq.c b/compute/zunmlq.c
index 07c635a67d1923f9b09039fd741de925c5fe1546..de73e20a3eb6460463243a27e57d775867537b9f 100644
--- a/compute/zunmlq.c
+++ b/compute/zunmlq.c
@@ -359,8 +359,8 @@ int CHAMELEON_zunmlq_Tile_Async( cham_side_t side, cham_trans_t trans,
      */
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int m = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
+        int m = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, m, A->n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zunmlq_param.c b/compute/zunmlq_param.c
index df0fba8bad95e072825f0677f80bcde122fef881..0c85cc62d4591cc15a0314aec185fd39cc1376d6 100644
--- a/compute/zunmlq_param.c
+++ b/compute/zunmlq_param.c
@@ -365,8 +365,8 @@ int CHAMELEON_zunmlq_param_Tile_Async( const libhqr_tree_t *qrtree, cham_side_t
 
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int m = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, m, A->n, 0, 0, m, A->n, );
+        int m = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, m, A->n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zunmqr.c b/compute/zunmqr.c
index 09387b79bf49214c25b85a3a5413225f43baba8b..979823987ea26fe8870301b4422c866d3bde5ab2 100644
--- a/compute/zunmqr.c
+++ b/compute/zunmqr.c
@@ -362,8 +362,8 @@ int CHAMELEON_zunmqr_Tile_Async( cham_side_t side, cham_trans_t trans,
 
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int n = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+        int n = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
         Dptr = &D;
     }
 #endif
diff --git a/compute/zunmqr_param.c b/compute/zunmqr_param.c
index e7b31e742f1775d7837b373bad935f81d9f63bff..810c2ea2f0c855704d4a2dc9903ef7141bedb349 100644
--- a/compute/zunmqr_param.c
+++ b/compute/zunmqr_param.c
@@ -372,8 +372,8 @@ int CHAMELEON_zunmqr_param_Tile_Async( const libhqr_tree_t *qrtree,
 
 #if defined(CHAMELEON_COPY_DIAG)
     {
-        int n = chameleon_min(A->m, A->n);
-        chameleon_zdesc_alloc(D, A->mb, A->nb, A->m, n, 0, 0, A->m, n, );
+        int n = chameleon_min( A->m, A->n );
+        chameleon_zdesc_copy_and_restrict( A, &D, A->m, n );
         Dptr = &D;
     }
 #endif
diff --git a/control/compute_z.h b/control/compute_z.h
index 196fde2047bf7ac40676bd383f63c8f9010405e3..ad911e8f6a3f9a0d701b42cc23f9508f3ad94279 100644
--- a/control/compute_z.h
+++ b/control/compute_z.h
@@ -154,6 +154,29 @@ chameleon_zdesc_alloc_diag( CHAM_desc_t *descA, int nb, int m, int n, int p, int
         }                                                               \
     }
 
+/**
+ * @brief Create a copy of a descriptor restricted to a smaller size.
+ * @param[in]  descIn  The input descriptor from which the structure should be copied.
+ * @param[out] descOut The output descriptor that is a copy of the input one with allocation on the fly.
+ * @param[in]  m       The number of rows of the output descriptor.
+ * @param[in]  n       The number of columns of the output descriptor.
+ * @return CHAMELEON_SUCCESS on success, the associated error on failure.
+ */
+static inline int
+chameleon_zdesc_copy_and_restrict( CHAM_desc_t *descIn,
+                                   CHAM_desc_t *descOut,
+                                   int m, int n )
+{
+    int rc;
+    rc = chameleon_desc_init( descOut, CHAMELEON_MAT_ALLOC_TILE,
+                              ChamComplexDouble, descIn->mb, descIn->nb, descIn->mb * descIn->nb,
+                              m, n, 0, 0, m, n, descIn->p, descIn->q,
+                              descIn->get_blkaddr,
+                              descIn->get_blkldd,
+                              descIn->get_rankof );
+    return rc;
+}
+
 /**
  * @brief Internal function to convert the lapack format to tile format in
  * LAPACK interface calls