diff --git a/runtime/parsec/codelets/codelet_zgetrf.c b/runtime/parsec/codelets/codelet_zgetrf.c
index a7eaee7f0dd5141573e1df0c857953f72b218e68..d13b959f53f855376f339377f7e23c30459681d5 100644
--- a/runtime/parsec/codelets/codelet_zgetrf.c
+++ b/runtime/parsec/codelets/codelet_zgetrf.c
@@ -31,13 +31,19 @@ CORE_zgetrf_parsec( parsec_execution_stream_t *context,
     int *IPIV;
     cham_bool_t *check_info;
     int iinfo;
+    RUNTIME_sequence_t *sequence;
+    RUNTIME_request_t *request;
     int info;
 
     parsec_dtd_unpack_args(
-        this_task, &m, &n, &A, &lda, &IPIV, &check_info, &iinfo );
+        this_task, &m, &n, &A, &lda, &IPIV, &check_info, &iinfo, &sequence, &request );
 
     CORE_zgetrf( m, n, A, lda, IPIV, &info );
 
+    if ( (sequence->status == CHAMELEON_SUCCESS) && (info != 0) ) {
+        RUNTIME_sequence_flush( NULL, sequence, request, iinfo+info );
+    }
+
     (void)context;
     return PARSEC_HOOK_RETURN_DONE;
 }
@@ -52,12 +58,14 @@ void INSERT_TASK_zgetrf(const RUNTIME_option_t *options,
 
     parsec_dtd_taskpool_insert_task(
         PARSEC_dtd_taskpool, CORE_zgetrf_parsec, options->priority, "getrf",
-        sizeof(int),        &m,                          VALUE,
-        sizeof(int),        &n,                          VALUE,
-        PASSED_BY_REF,       RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
-        sizeof(int),        &lda,                        VALUE,
-        sizeof(int)*nb,      IPIV,                        SCRATCH,
-        sizeof(cham_bool_t), &check_info,                 VALUE,
-        sizeof(int),        &iinfo,                      VALUE,
+        sizeof(int),                 &m,                          VALUE,
+        sizeof(int),                 &n,                          VALUE,
+        PASSED_BY_REF,               RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
+        sizeof(int),                 &lda,                        VALUE,
+        sizeof(int)*nb,              IPIV,                        SCRATCH,
+        sizeof(cham_bool_t),         &check_info,                 VALUE,
+        sizeof(int),                 &iinfo,                      VALUE,
+        sizeof(RUNTIME_sequence_t*), &(options->sequence),        VALUE,
+        sizeof(RUNTIME_request_t*),  &(options->request),         VALUE,
         PARSEC_DTD_ARG_END );
 }
diff --git a/runtime/parsec/codelets/codelet_zgetrf_incpiv.c b/runtime/parsec/codelets/codelet_zgetrf_incpiv.c
index f8bae1c2b4b7118a6ada0c8accedecd4da4d2027..d326342e12c25b4a007f24bd6f34130a9f01f240 100644
--- a/runtime/parsec/codelets/codelet_zgetrf_incpiv.c
+++ b/runtime/parsec/codelets/codelet_zgetrf_incpiv.c
@@ -86,14 +86,19 @@ CORE_zgetrf_incpiv_parsec( parsec_execution_stream_t *context,
     int *IPIV;
     cham_bool_t *check_info;
     int iinfo;
-
+    RUNTIME_sequence_t *sequence;
+    RUNTIME_request_t *request;
     int info;
 
     parsec_dtd_unpack_args(
-        this_task, &m, &n, &ib, &A, &lda, &IPIV, &check_info, &iinfo );
+        this_task, &m, &n, &ib, &A, &lda, &IPIV, &check_info, &iinfo, &sequence, &request );
 
     CORE_zgetrf_incpiv( m, n, ib, A, lda, IPIV, &info );
 
+    if ( (sequence->status == CHAMELEON_SUCCESS) && (info != 0) ) {
+        RUNTIME_sequence_flush( NULL, sequence, request, iinfo+info );
+    }
+
     (void)context;
     return PARSEC_HOOK_RETURN_DONE;
 }
@@ -109,14 +114,16 @@ void INSERT_TASK_zgetrf_incpiv( const RUNTIME_option_t *options,
 
     parsec_dtd_taskpool_insert_task(
         PARSEC_dtd_taskpool, CORE_zgetrf_incpiv_parsec, options->priority, "getrf_inc",
-        sizeof(int),           &m,                                VALUE,
-        sizeof(int),           &n,                                VALUE,
-        sizeof(int),           &ib,                               VALUE,
-        PASSED_BY_REF,         RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
-        sizeof(int),           &lda,                              VALUE,
-        sizeof(int*),          &IPIV,                             VALUE,
-        sizeof(int),           &check_info,                       VALUE,
-        sizeof(int),           &iinfo,                            VALUE,
+        sizeof(int),                 &m,                                VALUE,
+        sizeof(int),                 &n,                                VALUE,
+        sizeof(int),                 &ib,                               VALUE,
+        PASSED_BY_REF,               RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
+        sizeof(int),                 &lda,                              VALUE,
+        sizeof(int*),                &IPIV,                             VALUE,
+        sizeof(int),                 &check_info,                       VALUE,
+        sizeof(int),                 &iinfo,                            VALUE,
+        sizeof(RUNTIME_sequence_t*), &(options->sequence),              VALUE,
+        sizeof(RUNTIME_request_t*),  &(options->request),               VALUE,
         PARSEC_DTD_ARG_END );
 
     (void)L;
diff --git a/runtime/parsec/codelets/codelet_zgetrf_nopiv.c b/runtime/parsec/codelets/codelet_zgetrf_nopiv.c
index 6d755bdadd0aafcf6c9e5584488521a5e827062e..6439294a04e1d77c22b613bafe39a626755b6f48 100644
--- a/runtime/parsec/codelets/codelet_zgetrf_nopiv.c
+++ b/runtime/parsec/codelets/codelet_zgetrf_nopiv.c
@@ -77,13 +77,19 @@ CORE_zgetrf_nopiv_parsec( parsec_execution_stream_t *context,
     CHAMELEON_Complex64_t *A;
     int lda;
     int iinfo;
+    RUNTIME_sequence_t *sequence;
+    RUNTIME_request_t *request;
     int info;
 
     parsec_dtd_unpack_args(
-        this_task, &m, &n, &ib, &A, &lda, &iinfo );
+        this_task, &m, &n, &ib, &A, &lda, &iinfo, &sequence, &request );
 
     CORE_zgetrf_nopiv( m, n, ib, A, lda, &info );
 
+    if ( (sequence->status == CHAMELEON_SUCCESS) && (info != 0) ) {
+        RUNTIME_sequence_flush( NULL, sequence, request, iinfo+info );
+    }
+
     (void)context;
     return PARSEC_HOOK_RETURN_DONE;
 }
@@ -97,12 +103,14 @@ void INSERT_TASK_zgetrf_nopiv(const RUNTIME_option_t *options,
 
     parsec_dtd_taskpool_insert_task(
         PARSEC_dtd_taskpool, CORE_zgetrf_nopiv_parsec, options->priority,  "getrf_nopiv",
-        sizeof(int),           &m,                          VALUE,
-        sizeof(int),           &n,                          VALUE,
-        sizeof(int),           &ib,                         VALUE,
-        PASSED_BY_REF,         RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
-        sizeof(int),           &lda,                        VALUE,
-        sizeof(int),           &iinfo,                      VALUE,
+        sizeof(int),                 &m,                          VALUE,
+        sizeof(int),                 &n,                          VALUE,
+        sizeof(int),                 &ib,                         VALUE,
+        PASSED_BY_REF,               RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
+        sizeof(int),                 &lda,                        VALUE,
+        sizeof(int),                 &iinfo,                      VALUE,
+        sizeof(RUNTIME_sequence_t*), &(options->sequence),        VALUE,
+        sizeof(RUNTIME_request_t*),  &(options->request),         VALUE,
         PARSEC_DTD_ARG_END );
 
     (void)nb;
diff --git a/runtime/parsec/codelets/codelet_zlag2c.c b/runtime/parsec/codelets/codelet_zlag2c.c
index d9f17eaa5d7c170410425fbb44ebe67ff2774ff5..1a12688297b73bc973ce8c9bba6eb5702da69e1b 100644
--- a/runtime/parsec/codelets/codelet_zlag2c.c
+++ b/runtime/parsec/codelets/codelet_zlag2c.c
@@ -35,7 +35,6 @@ CORE_zlag2c_parsec( parsec_execution_stream_t *context,
     int lda;
     CHAMELEON_Complex32_t *B;
     int ldb;
-    int info;
 
     parsec_dtd_unpack_args(
         this_task, &m, &n, &A, &lda, &B, &ldb );
diff --git a/runtime/parsec/codelets/codelet_zpotrf.c b/runtime/parsec/codelets/codelet_zpotrf.c
index 32928d1b0de9c0626b78af38e3a7e5322ba781f5..40caa4c84459c7d90de84719deb5d9c328af96a0 100644
--- a/runtime/parsec/codelets/codelet_zpotrf.c
+++ b/runtime/parsec/codelets/codelet_zpotrf.c
@@ -31,16 +31,19 @@ CORE_zpotrf_parsec( parsec_execution_stream_t *context,
 {
     cham_uplo_t uplo;
     int tempkm, ldak, iinfo, info;
+    RUNTIME_sequence_t *sequence;
+    RUNTIME_request_t *request;
     CHAMELEON_Complex64_t *A;
 
     parsec_dtd_unpack_args(
-        this_task, &uplo, &tempkm, &A, &ldak, &iinfo );
+        this_task, &uplo, &tempkm, &A, &ldak, &iinfo, &sequence, &request );
 
     CORE_zpotrf( uplo, tempkm, A, ldak, &info );
 
-    /* if ( (sequence->status == CHAMELEON_SUCCESS) && (info != 0) ) { */
-    /*     RUNTIME_sequence_flush( (CHAM_context_t*)quark, sequence, request, iinfo+info ); */
-    /* } */
+    if ( (sequence->status == CHAMELEON_SUCCESS) && (info != 0) ) {
+        RUNTIME_sequence_flush( NULL, sequence, request, iinfo+info );
+    }
+
     (void)context;
     (void)info;
     (void)iinfo;
@@ -56,11 +59,13 @@ void INSERT_TASK_zpotrf(const RUNTIME_option_t *options,
 
     parsec_dtd_taskpool_insert_task(
         PARSEC_dtd_taskpool, CORE_zpotrf_parsec, options->priority, "potrf",
-        sizeof(int),    &uplo,                             VALUE,
-        sizeof(int),           &n,                                VALUE,
-        PASSED_BY_REF,         RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
-        sizeof(int),           &lda,                              VALUE,
-        sizeof(int),           &iinfo,                            VALUE,
+        sizeof(int),                 &uplo,                             VALUE,
+        sizeof(int),                 &n,                                VALUE,
+        PASSED_BY_REF,               RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
+        sizeof(int),                 &lda,                              VALUE,
+        sizeof(int),                 &iinfo,                            VALUE,
+        sizeof(RUNTIME_sequence_t*), &(options->sequence),              VALUE,
+        sizeof(RUNTIME_request_t*),  &(options->request),               VALUE,
         PARSEC_DTD_ARG_END );
 
     (void)nb;
diff --git a/runtime/parsec/codelets/codelet_ztrtri.c b/runtime/parsec/codelets/codelet_ztrtri.c
index e4eb4b3e09d9f1cab5633d3e8d13ccc8dd1c3bc6..3a8e8eb9dea557e8083ea960a7d963dce7ef7099 100644
--- a/runtime/parsec/codelets/codelet_ztrtri.c
+++ b/runtime/parsec/codelets/codelet_ztrtri.c
@@ -30,13 +30,19 @@ CORE_ztrtri_parsec( parsec_execution_stream_t *context,
     CHAMELEON_Complex64_t *A;
     int LDA;
     int iinfo;
+    RUNTIME_sequence_t *sequence;
+    RUNTIME_request_t *request;
     int info;
 
     parsec_dtd_unpack_args(
-        this_task, &uplo, &diag, &N, &A, &LDA, &iinfo );
+        this_task, &uplo, &diag, &N, &A, &LDA, &iinfo, &sequence, &request );
 
     CORE_ztrtri( uplo, diag, N, A, LDA, &info );
 
+    if ( (sequence->status == CHAMELEON_SUCCESS) && (info != 0) ) {
+        RUNTIME_sequence_flush( NULL, sequence, request, iinfo+info );
+    }
+
     (void)context;
     return PARSEC_HOOK_RETURN_DONE;
 }
@@ -51,12 +57,14 @@ void INSERT_TASK_ztrtri( const RUNTIME_option_t *options,
 
     parsec_dtd_taskpool_insert_task(
         PARSEC_dtd_taskpool, CORE_ztrtri_parsec, options->priority, "trtri",
-        sizeof(int),         &uplo,                  VALUE,
-        sizeof(int),         &diag,                  VALUE,
-        sizeof(int),                &n,                     VALUE,
-        PASSED_BY_REF,              RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
-        sizeof(int),                &lda,                   VALUE,
-        sizeof(int),                &iinfo,                 VALUE,
+        sizeof(int),                 &uplo,                  VALUE,
+        sizeof(int),                 &diag,                  VALUE,
+        sizeof(int),                 &n,                     VALUE,
+        PASSED_BY_REF,               RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
+        sizeof(int),                 &lda,                   VALUE,
+        sizeof(int),                 &iinfo,                 VALUE,
+        sizeof(RUNTIME_sequence_t*), &(options->sequence),   VALUE,
+        sizeof(RUNTIME_request_t*),  &(options->request),    VALUE,
         PARSEC_DTD_ARG_END );
 
     (void)nb;
diff --git a/runtime/parsec/codelets/codelet_ztstrf.c b/runtime/parsec/codelets/codelet_ztstrf.c
index d5ab7a779ca2e192fc8ce42618049fd0d14f9052..cf63ad965ab3343535ebc8a435e303ae47451b0b 100644
--- a/runtime/parsec/codelets/codelet_ztstrf.c
+++ b/runtime/parsec/codelets/codelet_ztstrf.c
@@ -39,14 +39,19 @@ CORE_ztstrf_parsec( parsec_execution_stream_t *context,
     int ldwork;
     cham_bool_t *check_info;
     int iinfo;
-
+    RUNTIME_sequence_t *sequence;
+    RUNTIME_request_t *request;
     int info;
 
     parsec_dtd_unpack_args(
-        this_task, &m, &n, &ib, &nb, &U, &ldu, &A, &lda, &L, &ldl, &IPIV, &WORK, &ldwork, &check_info, &iinfo );
+        this_task, &m, &n, &ib, &nb, &U, &ldu, &A, &lda, &L, &ldl, &IPIV, &WORK, &ldwork, &check_info, &iinfo, &sequence, &request );
 
     CORE_ztstrf( m, n, ib, nb, U, ldu, A, lda, L, ldl, IPIV, WORK, ldwork, &info );
 
+    if ( (sequence->status == CHAMELEON_SUCCESS) && (info != 0) ) {
+        RUNTIME_sequence_flush( NULL, sequence, request, iinfo+info );
+    }
+
     (void)context;
     return PARSEC_HOOK_RETURN_DONE;
 }
@@ -63,21 +68,23 @@ void INSERT_TASK_ztstrf(const RUNTIME_option_t *options,
 
     parsec_dtd_taskpool_insert_task(
         PARSEC_dtd_taskpool, CORE_ztstrf_parsec, options->priority, "tstrf",
-        sizeof(int),           &m,                                VALUE,
-        sizeof(int),           &n,                                VALUE,
-        sizeof(int),           &ib,                               VALUE,
-        sizeof(int),           &nb,                               VALUE,
-        PASSED_BY_REF,         RTBLKADDR( U, CHAMELEON_Complex64_t, Um, Un ), chameleon_parsec_get_arena_index( U ) | INOUT,
-        sizeof(int),           &ldu,                              VALUE,
-        PASSED_BY_REF,         RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
-        sizeof(int),           &lda,                              VALUE,
-        PASSED_BY_REF,         RTBLKADDR( L, CHAMELEON_Complex64_t, Lm, Ln ), chameleon_parsec_get_arena_index( L ) | OUTPUT,
-        sizeof(int),           &ldl,                              VALUE,
-        sizeof(int*),          &IPIV,                             VALUE,
+        sizeof(int),                 &m,                                VALUE,
+        sizeof(int),                 &n,                                VALUE,
+        sizeof(int),                 &ib,                               VALUE,
+        sizeof(int),                 &nb,                               VALUE,
+        PASSED_BY_REF,               RTBLKADDR( U, CHAMELEON_Complex64_t, Um, Un ), chameleon_parsec_get_arena_index( U ) | INOUT,
+        sizeof(int),                 &ldu,                              VALUE,
+        PASSED_BY_REF,               RTBLKADDR( A, CHAMELEON_Complex64_t, Am, An ), chameleon_parsec_get_arena_index( A ) | INOUT | AFFINITY,
+        sizeof(int),                 &lda,                              VALUE,
+        PASSED_BY_REF,               RTBLKADDR( L, CHAMELEON_Complex64_t, Lm, Ln ), chameleon_parsec_get_arena_index( L ) | OUTPUT,
+        sizeof(int),                 &ldl,                              VALUE,
+        sizeof(int*),                &IPIV,                             VALUE,
         sizeof(CHAMELEON_Complex64_t)*ib*nb,    NULL,                 SCRATCH,
-        sizeof(int),           &nb,                               VALUE,
-        sizeof(int),           &check_info,                       VALUE,
-        sizeof(int),           &iinfo,                            VALUE,
+        sizeof(int),                 &nb,                               VALUE,
+        sizeof(int),                 &check_info,                       VALUE,
+        sizeof(int),                 &iinfo,                            VALUE,
+        sizeof(RUNTIME_sequence_t*), &(options->sequence),              VALUE,
+        sizeof(RUNTIME_request_t*),  &(options->request),               VALUE,
         PARSEC_DTD_ARG_END );
 
     (void)nb;