diff --git a/control/descriptor.h b/control/descriptor.h
index e0ebcc936077256f42902dd8a49dcf05ca3c54ab..2981f9685da6ebc709d790a88aa9c95fa784845a 100644
--- a/control/descriptor.h
+++ b/control/descriptor.h
@@ -196,6 +196,32 @@ inline static int morse_desc_islocal( const MORSE_desc_t *A, int m, int n )
#endif /* defined(CHAMELEON_USE_MPI) */
}
+/*******************************************************************************
+ * Declare data accesses of codelets using these macros, for instance:
+ * MORSE_BEGIN_ACCESS_DECLARATION
+ * MORSE_ACCESS_R(A, Am, An)
+ * MORSE_ACCESS_R(B, Bm, Bn)
+ * MORSE_ACCESS_RW(C, Cm, Cn)
+ * MORSE_END_ACCESS_DECLARATION
+ */
+#define MORSE_BEGIN_ACCESS_DECLARATION { \
+ unsigned __morse_need_submit = 0;
+
+#define MORSE_ACCESS_R(A, Am, An) \
+ if (morse_desc_islocal(A, Am, An)) __morse_need_submit = 1;
+
+#define MORSE_ACCESS_W(A, Am, An) \
+ if (morse_desc_islocal(A, Am, An)) __morse_need_submit = 1;
+
+#define MORSE_ACCESS_RW(A, Am, An) \
+ if (morse_desc_islocal(A, Am, An)) __morse_need_submit = 1;
+
+#define MORSE_RANK_CHANGED __morse_need_submit = 1;
+
+#define MORSE_END_ACCESS_DECLARATION \
+ if (!__morse_need_submit) return; \
+}
+
#ifdef __cplusplus
}
#endif
diff --git a/runtime/parsec/codelets/codelet_ztpqrt.c b/runtime/parsec/codelets/codelet_ztpqrt.c
index a0b3f6e06cda9f115f55c9daf904216f131e2b9d..6b8a3fe2d2292570b0ca560672ff3e90ab94c055 100644
--- a/runtime/parsec/codelets/codelet_ztpqrt.c
+++ b/runtime/parsec/codelets/codelet_ztpqrt.c
@@ -78,7 +78,7 @@ void MORSE_TASK_ztpqrt( const MORSE_option_t *options,
sizeof(int), &lda, VALUE,
PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INOUT | REGION_FULL,
sizeof(int), &ldb, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INOUT | REGION_FULL,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
sizeof(int), &ldt, VALUE,
sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
0);
diff --git a/runtime/starpu/codelets/codelet_zasum.c b/runtime/starpu/codelets/codelet_zasum.c
index 7c17a35d1c8eac5f9144c4a31f7acd7544ef418d..2323b95e6d2a4e72ee6a0b13842c7d31e678132a 100644
--- a/runtime/starpu/codelets/codelet_zasum.c
+++ b/runtime/starpu/codelets/codelet_zasum.c
@@ -35,6 +35,12 @@ void MORSE_TASK_dzasum(const MORSE_option_t *options,
{
struct starpu_codelet *codelet = &cl_zasum;
void (*callback)(void*) = options->profiling ? cl_zasum_callback : NULL;
+
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
starpu_insert_task(
starpu_mpi_codelet(codelet),
STARPU_VALUE, &storev, sizeof(MORSE_enum),
diff --git a/runtime/starpu/codelets/codelet_zaxpy.c b/runtime/starpu/codelets/codelet_zaxpy.c
index 557eaa1086febacb8b2e7f7befc87945542c8629..56b03bfe80a83d0cf9856e72d261112cb510fff5 100644
--- a/runtime/starpu/codelets/codelet_zaxpy.c
+++ b/runtime/starpu/codelets/codelet_zaxpy.c
@@ -33,23 +33,25 @@ void MORSE_TASK_zaxpy(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zaxpy;
void (*callback)(void*) = options->profiling ? cl_zaxpy_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) ){
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &M, sizeof(int),
- STARPU_VALUE, alpha, sizeof(MORSE_Complex64_t),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &incA, sizeof(int),
- STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &incB, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &M, sizeof(int),
+ STARPU_VALUE, alpha, sizeof(MORSE_Complex64_t),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &incA, sizeof(int),
+ STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &incB, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zaxpy",
+ STARPU_NAME, "zaxpy",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zbuild.c b/runtime/starpu/codelets/codelet_zbuild.c
index d2e654064a626977bb7bada6ec775e972601c2e4..6271384564537e164713f4c5d1fc45a03117509b 100644
--- a/runtime/starpu/codelets/codelet_zbuild.c
+++ b/runtime/starpu/codelets/codelet_zbuild.c
@@ -43,30 +43,30 @@ void MORSE_TASK_zbuild( const MORSE_option_t *options,
void (*callback)(void*) = options->profiling ? cl_zbuild_callback : NULL;
int row_min, row_max, col_min, col_max;
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_W(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- row_min = Am*A->mb ;
- row_max = Am == A->mt-1 ? A->m-1 : row_min+A->mb-1 ;
- col_min = An*A->nb ;
- col_max = An == A->nt-1 ? A->n-1 : col_min+A->nb-1 ;
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &row_min, sizeof(int),
- STARPU_VALUE, &row_max, sizeof(int),
- STARPU_VALUE, &col_min, sizeof(int),
- STARPU_VALUE, &col_max, sizeof(int),
- STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &user_data, sizeof(void*),
- STARPU_VALUE, &user_build_callback, sizeof(void*),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ row_min = Am*A->mb ;
+ row_max = Am == A->mt-1 ? A->m-1 : row_min+A->mb-1 ;
+ col_min = An*A->nb ;
+ col_max = An == A->nt-1 ? A->n-1 : col_min+A->nb-1 ;
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &row_min, sizeof(int),
+ STARPU_VALUE, &row_max, sizeof(int),
+ STARPU_VALUE, &col_min, sizeof(int),
+ STARPU_VALUE, &col_max, sizeof(int),
+ STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &user_data, sizeof(void*),
+ STARPU_VALUE, &user_build_callback, sizeof(void*),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zbuild",
+ STARPU_NAME, "zbuild",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zgeadd.c b/runtime/starpu/codelets/codelet_zgeadd.c
index 1a57e312356b644a2ba23ff55d2c67495d7d05ac..edfd5461b71160c28c5361926ff63dd8d15e8d1c 100644
--- a/runtime/starpu/codelets/codelet_zgeadd.c
+++ b/runtime/starpu/codelets/codelet_zgeadd.c
@@ -91,27 +91,28 @@ void MORSE_TASK_zgeadd(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zgeadd;
void (*callback)(void*) = options->profiling ? cl_zgeadd_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
- STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
+ STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zgeadd",
+ STARPU_NAME, "zgeadd",
#endif
- 0);
- }
+ 0);
(void)nb;
}
diff --git a/runtime/starpu/codelets/codelet_zgelqt.c b/runtime/starpu/codelets/codelet_zgelqt.c
index 2b4c0daf8121b4acce12ccbf675a5723bc9cf0ed..af571f2ae79f096aa8efc680c16957b334fa8c48 100644
--- a/runtime/starpu/codelets/codelet_zgelqt.c
+++ b/runtime/starpu/codelets/codelet_zgelqt.c
@@ -104,29 +104,30 @@ void MORSE_TASK_zgelqt(const MORSE_option_t *options,
void (*callback)(void*) = options->profiling ? cl_zgelqt_callback : NULL;
MORSE_starpu_ws_t *h_work = (MORSE_starpu_ws_t*)(options->ws_host);
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( T, Tm, Tn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- /* max( nb * (ib+1), ib * (ib+nb) ) */
- STARPU_SCRATCH, options->ws_worker,
- /* /\* ib*n + 3*ib*ib + max(m,n) *\/ */
- STARPU_VALUE, &h_work, sizeof(MORSE_starpu_ws_t *),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_ACCESS_W(T, Tm, Tn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ /* max( nb * (ib+1), ib * (ib+nb) ) */
+ STARPU_SCRATCH, options->ws_worker,
+ /* /\* ib*n + 3*ib*ib + max(m,n) *\/ */
+ STARPU_VALUE, &h_work, sizeof(MORSE_starpu_ws_t *),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zgelqt",
+ STARPU_NAME, "zgelqt",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zgemm.c b/runtime/starpu/codelets/codelet_zgemm.c
index d9ba98ff68d151edc28c8dfa5ef023200fd2e508..ed5ff9d571be4c9ccf6f657e286c1338f5c41fa0 100644
--- a/runtime/starpu/codelets/codelet_zgemm.c
+++ b/runtime/starpu/codelets/codelet_zgemm.c
@@ -70,37 +70,38 @@ void MORSE_TASK_zgemm(const MORSE_option_t *options,
rank_changed = 1;
}
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) ||
- morse_desc_islocal( C, Cm, Cn ) ||
- rank_changed
- )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &transA, sizeof(MORSE_enum),
- STARPU_VALUE, &transB, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_R, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
- STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
- STARPU_VALUE, &ldc, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_R(B, Bm, Bn);
+ MORSE_ACCESS_RW(C, Cm, Cn);
+ if (rank_changed)
+ MORSE_RANK_CHANGED;
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &transA, sizeof(MORSE_enum),
+ STARPU_VALUE, &transB, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_R, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
+ STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
+ STARPU_VALUE, &ldc, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_USE_MPI)
- STARPU_EXECUTE_ON_NODE, execution_rank,
+ STARPU_EXECUTE_ON_NODE, execution_rank,
#endif
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zgemm",
+ STARPU_NAME, "zgemm",
#endif
- 0);
- }
+ 0);
}
#if !defined(CHAMELEON_SIMULATION)
diff --git a/runtime/starpu/codelets/codelet_zgeqrt.c b/runtime/starpu/codelets/codelet_zgeqrt.c
index d738fc0b5a741f683a5d4f5499212cf459a4f172..50769b3be7323b6342f68889c1138d6d4950d1b2 100644
--- a/runtime/starpu/codelets/codelet_zgeqrt.c
+++ b/runtime/starpu/codelets/codelet_zgeqrt.c
@@ -105,29 +105,30 @@ void MORSE_TASK_zgeqrt(const MORSE_option_t *options,
void (*callback)(void*) = options->profiling ? cl_zgeqrt_callback : NULL;
MORSE_starpu_ws_t *h_work = (MORSE_starpu_ws_t*)(options->ws_host);
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( T, Tm, Tn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- /* max( nb * (ib+1), ib * (ib+nb) ) */
- STARPU_SCRATCH, options->ws_worker,
- /* ib * (m+3*ib) + max(m,n) */
- STARPU_VALUE, &h_work, sizeof(MORSE_starpu_ws_t *),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_ACCESS_W(T, Tm, Tn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ /* max( nb * (ib+1), ib * (ib+nb) ) */
+ STARPU_SCRATCH, options->ws_worker,
+ /* ib * (m+3*ib) + max(m,n) */
+ STARPU_VALUE, &h_work, sizeof(MORSE_starpu_ws_t *),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zgeqrt",
+ STARPU_NAME, "zgeqrt",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zgessm.c b/runtime/starpu/codelets/codelet_zgessm.c
index cabe11ce96babfc59ed50a7e5ea8fbb002394752..547111784edd1c1e30720fbb22e6f4f44d5485dd 100644
--- a/runtime/starpu/codelets/codelet_zgessm.c
+++ b/runtime/starpu/codelets/codelet_zgessm.c
@@ -90,30 +90,31 @@ void MORSE_TASK_zgessm(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zgessm;
void (*callback)(void*) = options->profiling ? cl_zgessm_callback : NULL;
- if ( morse_desc_islocal( L, Lm, Ln ) ||
- morse_desc_islocal( D, Dm, Dn ) ||
- morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_VALUE, &IPIV, sizeof(int*),
- STARPU_R, RTBLKADDR(L, MORSE_Complex64_t, Lm, Ln),
- STARPU_VALUE, &ldl, sizeof(int),
- STARPU_R, RTBLKADDR(D, MORSE_Complex64_t, Dm, Dn),
- STARPU_VALUE, &ldd, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(L, Lm, Ln);
+ MORSE_ACCESS_R(D, Dm, Dn);
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_VALUE, &IPIV, sizeof(int*),
+ STARPU_R, RTBLKADDR(L, MORSE_Complex64_t, Lm, Ln),
+ STARPU_VALUE, &ldl, sizeof(int),
+ STARPU_R, RTBLKADDR(D, MORSE_Complex64_t, Dm, Dn),
+ STARPU_VALUE, &ldd, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zgessm",
+ STARPU_NAME, "zgessm",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zgessq.c b/runtime/starpu/codelets/codelet_zgessq.c
index cd229712b59f21dc3fd901dd73faeefff0a00514..094c7ba09e7da55c4774cd6d6ce6f68805e6cd16 100644
--- a/runtime/starpu/codelets/codelet_zgessq.c
+++ b/runtime/starpu/codelets/codelet_zgessq.c
@@ -35,23 +35,24 @@ void MORSE_TASK_zgessq( const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zgessq;
void (*callback)(void*) = options->profiling ? cl_zgessq_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( SCALESUMSQ, SCALESUMSQm, SCALESUMSQn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_RW, RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(SCALESUMSQ, SCALESUMSQm, SCALESUMSQn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_RW, RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zgessq",
+ STARPU_NAME, "zgessq",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zgetrf.c b/runtime/starpu/codelets/codelet_zgetrf.c
index 54544d0690f06c26e37bca0d76db946ba546da42..e9b5327bfc6ef02a5dbec929ed096cac06ae2dc7 100644
--- a/runtime/starpu/codelets/codelet_zgetrf.c
+++ b/runtime/starpu/codelets/codelet_zgetrf.c
@@ -40,24 +40,25 @@ void MORSE_TASK_zgetrf(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zgetrf;
void (*callback)(void*) = options->profiling ? cl_zgetrf_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &IPIV, sizeof(int*),
- STARPU_VALUE, &check_info, sizeof(MORSE_bool),
- STARPU_VALUE, &iinfo, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &IPIV, sizeof(int*),
+ STARPU_VALUE, &check_info, sizeof(MORSE_bool),
+ STARPU_VALUE, &iinfo, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zgetrf",
+ STARPU_NAME, "zgetrf",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zgetrf_incpiv.c b/runtime/starpu/codelets/codelet_zgetrf_incpiv.c
index c76be02aaf3026a9a45bea2173a8d47024e8e86d..ad3475cb764564a20fac78f3afd4b6e063bfe58f 100644
--- a/runtime/starpu/codelets/codelet_zgetrf_incpiv.c
+++ b/runtime/starpu/codelets/codelet_zgetrf_incpiv.c
@@ -100,30 +100,31 @@ void MORSE_TASK_zgetrf_incpiv(const MORSE_option_t *options,
MORSE_starpu_ws_t *h_work = (MORSE_starpu_ws_t*)(options->ws_host);
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( L, Lm, Ln ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_W, RTBLKADDR(L, MORSE_Complex64_t, Lm, Ln),
- STARPU_VALUE, &ldl, sizeof(int),
- STARPU_VALUE, &IPIV, sizeof(int*),
- STARPU_VALUE, &check_info, sizeof(MORSE_bool),
- STARPU_VALUE, &iinfo, sizeof(int),
- STARPU_SCRATCH, options->ws_worker,
- STARPU_VALUE, &h_work, sizeof(MORSE_starpu_ws_t *),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_ACCESS_W(L, Lm, Ln);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_W, RTBLKADDR(L, MORSE_Complex64_t, Lm, Ln),
+ STARPU_VALUE, &ldl, sizeof(int),
+ STARPU_VALUE, &IPIV, sizeof(int*),
+ STARPU_VALUE, &check_info, sizeof(MORSE_bool),
+ STARPU_VALUE, &iinfo, sizeof(int),
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_VALUE, &h_work, sizeof(MORSE_starpu_ws_t *),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zgetrf_incpiv",
+ STARPU_NAME, "zgetrf_incpiv",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zgetrf_nopiv.c b/runtime/starpu/codelets/codelet_zgetrf_nopiv.c
index 3fa0f5c3920b6caf99c5fed29befadfa5168a92f..ab9d87acebd7cfafb43e597c38b3f220e5ac2133 100644
--- a/runtime/starpu/codelets/codelet_zgetrf_nopiv.c
+++ b/runtime/starpu/codelets/codelet_zgetrf_nopiv.c
@@ -85,23 +85,24 @@ void MORSE_TASK_zgetrf_nopiv(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zgetrf_nopiv;
void (*callback)(void*) = options->profiling ? cl_zgetrf_nopiv_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &iinfo, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &iinfo, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zgetrf_nopiv",
+ STARPU_NAME, "zgetrf_nopiv",
#endif
- 0);
- }
+ 0);
}
/*
diff --git a/runtime/starpu/codelets/codelet_zhe2ge.c b/runtime/starpu/codelets/codelet_zhe2ge.c
index f107252cc70a863a5774da37f9ea6aa2000a6327..6551a8fbb0fe55b06a341c55f0e8aa17345bb59a 100644
--- a/runtime/starpu/codelets/codelet_zhe2ge.c
+++ b/runtime/starpu/codelets/codelet_zhe2ge.c
@@ -39,25 +39,26 @@ void MORSE_TASK_zhe2ge(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zhe2ge;
void (*callback)(void*) = options->profiling ? cl_zhe2ge_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_W, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_W(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_W, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zhe2ge",
+ STARPU_NAME, "zhe2ge",
#endif
- 0);
- }
+ 0);
}
#if !defined(CHAMELEON_SIMULATION)
diff --git a/runtime/starpu/codelets/codelet_zhemm.c b/runtime/starpu/codelets/codelet_zhemm.c
index 4489e84ad443df55c9a5762657fc7fc9d8ec341d..df45234630fbd77f77f7e976eea77cba868c305b 100644
--- a/runtime/starpu/codelets/codelet_zhemm.c
+++ b/runtime/starpu/codelets/codelet_zhemm.c
@@ -48,31 +48,32 @@ void MORSE_TASK_zhemm(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zhemm;
void (*callback)(void*) = options->profiling ? cl_zhemm_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) ||
- morse_desc_islocal( C, Cm, Cn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_R, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
- STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
- STARPU_VALUE, &ldc, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_R(B, Bm, Bn);
+ MORSE_ACCESS_RW(C, Cm, Cn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_R, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
+ STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
+ STARPU_VALUE, &ldc, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zhemm",
+ STARPU_NAME, "zhemm",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zher2k.c b/runtime/starpu/codelets/codelet_zher2k.c
index 78a4d6f137c9a037a9555b1b88571da4301de11a..9b6b7194db42d17a7fb5eb755efc76ec7c79c09b 100644
--- a/runtime/starpu/codelets/codelet_zher2k.c
+++ b/runtime/starpu/codelets/codelet_zher2k.c
@@ -48,31 +48,32 @@ void MORSE_TASK_zher2k(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zher2k;
void (*callback)(void*) = options->profiling ? cl_zher2k_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) ||
- morse_desc_islocal( C, Cm, Cn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_R, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_VALUE, &beta, sizeof(double),
- STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
- STARPU_VALUE, &ldc, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_R(B, Bm, Bn);
+ MORSE_ACCESS_RW(C, Cm, Cn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_R, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_VALUE, &beta, sizeof(double),
+ STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
+ STARPU_VALUE, &ldc, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zher2k",
+ STARPU_NAME, "zher2k",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zherfb.c b/runtime/starpu/codelets/codelet_zherfb.c
index 210fb3278ab53ffdee9805b1a7061696669e9a46..b5ceec04b8ded9bf733c534645ae7a5303294b5b 100644
--- a/runtime/starpu/codelets/codelet_zherfb.c
+++ b/runtime/starpu/codelets/codelet_zherfb.c
@@ -40,32 +40,33 @@ void MORSE_TASK_zherfb(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zherfb;
void (*callback)(void*) = options->profiling ? cl_zherfb_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( T, Tm, Tn ) ||
- morse_desc_islocal( C, Cm, Cn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_VALUE, &nb, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
- STARPU_VALUE, &ldc, sizeof(int),
- STARPU_SCRATCH, options->ws_worker,
- STARPU_VALUE, &nb, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_R(T, Tm, Tn);
+ MORSE_ACCESS_RW(C, Cm, Cn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_VALUE, &nb, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
+ STARPU_VALUE, &ldc, sizeof(int),
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_VALUE, &nb, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zherfb",
+ STARPU_NAME, "zherfb",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zherk.c b/runtime/starpu/codelets/codelet_zherk.c
index 8e0d48f6f41c0751db73210ab67756c29217df1c..e5ef780218f5cf95f13f6956b971350d38268b8f 100644
--- a/runtime/starpu/codelets/codelet_zherk.c
+++ b/runtime/starpu/codelets/codelet_zherk.c
@@ -47,28 +47,29 @@ void MORSE_TASK_zherk(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zherk;
void (*callback)(void*) = options->profiling ? cl_zherk_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( C, Cm, Cn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(double),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &beta, sizeof(double),
- STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
- STARPU_VALUE, &ldc, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(C, Cm, Cn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(double),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &beta, sizeof(double),
+ STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
+ STARPU_VALUE, &ldc, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zherk",
+ STARPU_NAME, "zherk",
#endif
- 0);
- }
+ 0);
}
#if !defined(CHAMELEON_SIMULATION)
diff --git a/runtime/starpu/codelets/codelet_zhessq.c b/runtime/starpu/codelets/codelet_zhessq.c
index 11666dbce7ab3dcd260b47f1097b24e00cc0326d..8f9ddf984bfb5533e6c93e6c9eabd636cd7cddd5 100644
--- a/runtime/starpu/codelets/codelet_zhessq.c
+++ b/runtime/starpu/codelets/codelet_zhessq.c
@@ -35,23 +35,24 @@ void MORSE_TASK_zhessq( const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zhessq;
void (*callback)(void*) = options->profiling ? cl_zgessq_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( SCALESUMSQ, SCALESUMSQm, SCALESUMSQn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_RW, RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(SCALESUMSQ, SCALESUMSQm, SCALESUMSQn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_RW, RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zhessq",
+ STARPU_NAME, "zhessq",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zlacpy.c b/runtime/starpu/codelets/codelet_zlacpy.c
index ee86f5d18efef05a17b147c0f4689bed0b212fe8..99274e18383f14a36c6e117528eeabbf483aaf49 100644
--- a/runtime/starpu/codelets/codelet_zlacpy.c
+++ b/runtime/starpu/codelets/codelet_zlacpy.c
@@ -47,27 +47,28 @@ void MORSE_TASK_zlacpyx(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zlacpy;
void (*callback)(void*) = options->profiling ? cl_zlacpy_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &displA, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &displB, sizeof(int),
- STARPU_W, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_W(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &displA, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &displB, sizeof(int),
+ STARPU_W, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zlacpy",
+ STARPU_NAME, "zlacpy",
#endif
- 0);
- }
+ 0);
}
void MORSE_TASK_zlacpy(const MORSE_option_t *options,
diff --git a/runtime/starpu/codelets/codelet_zlag2c.c b/runtime/starpu/codelets/codelet_zlag2c.c
index 7390acaae69b5e5d3e95d5ea8995e98a95a63bfc..f09c80846b3ba17e2decea7b2aed145c1c858c66 100644
--- a/runtime/starpu/codelets/codelet_zlag2c.c
+++ b/runtime/starpu/codelets/codelet_zlag2c.c
@@ -44,24 +44,25 @@ void MORSE_TASK_zlag2c(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zlag2c;
void (*callback)(void*) = options->profiling ? cl_zlag2c_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_W, RTBLKADDR(B, MORSE_Complex32_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_W(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_W, RTBLKADDR(B, MORSE_Complex32_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zlag2c",
+ STARPU_NAME, "zlag2c",
#endif
- 0);
- }
+ 0);
}
#if !defined(CHAMELEON_SIMULATION)
diff --git a/runtime/starpu/codelets/codelet_zlange.c b/runtime/starpu/codelets/codelet_zlange.c
index 9a1b1ebcf01d0a7fcf1a500ff4d3086179f3d3b9..9571eec74fdafabafd27866d5de9a040857fdad8 100644
--- a/runtime/starpu/codelets/codelet_zlange.c
+++ b/runtime/starpu/codelets/codelet_zlange.c
@@ -39,25 +39,26 @@ void MORSE_TASK_zlange(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zlange;
void (*callback)(void*) = options->profiling ? cl_zlange_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &norm, sizeof(MORSE_enum),
- STARPU_VALUE, &M, sizeof(int),
- STARPU_VALUE, &N, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &LDA, sizeof(int),
- STARPU_SCRATCH, options->ws_worker,
- STARPU_W, RTBLKADDR(B, double, Bm, Bn),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_W(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &norm, sizeof(MORSE_enum),
+ STARPU_VALUE, &M, sizeof(int),
+ STARPU_VALUE, &N, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &LDA, sizeof(int),
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_W, RTBLKADDR(B, double, Bm, Bn),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zlange",
+ STARPU_NAME, "zlange",
#endif
- 0);
- }
+ 0);
}
#if !defined(CHAMELEON_SIMULATION)
diff --git a/runtime/starpu/codelets/codelet_zlanhe.c b/runtime/starpu/codelets/codelet_zlanhe.c
index 24a87f7525e82f2427c9b854b2661a3ef1bcbf55..37725f178d09623af6933cc63217a0ddb8d8ea14 100644
--- a/runtime/starpu/codelets/codelet_zlanhe.c
+++ b/runtime/starpu/codelets/codelet_zlanhe.c
@@ -37,25 +37,26 @@ void MORSE_TASK_zlanhe(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zlanhe;
void (*callback)(void*) = options->profiling ? cl_zlange_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &norm, sizeof(MORSE_enum),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &N, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &LDA, sizeof(int),
- STARPU_SCRATCH, options->ws_worker,
- STARPU_W, RTBLKADDR(B, double, Bm, Bn),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_W(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &norm, sizeof(MORSE_enum),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &N, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &LDA, sizeof(int),
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_W, RTBLKADDR(B, double, Bm, Bn),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zlanhe",
+ STARPU_NAME, "zlanhe",
#endif
- 0);
- }
+ 0);
(void)NB;
}
diff --git a/runtime/starpu/codelets/codelet_zlansy.c b/runtime/starpu/codelets/codelet_zlansy.c
index 0e3fe5933c241be87004ae3582cd6dcd22954ae1..dd01215c23e4da1334215d5e54124b1f51bda397 100644
--- a/runtime/starpu/codelets/codelet_zlansy.c
+++ b/runtime/starpu/codelets/codelet_zlansy.c
@@ -39,25 +39,26 @@ void MORSE_TASK_zlansy(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zlansy;
void (*callback)(void*) = options->profiling ? cl_zlange_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &norm, sizeof(MORSE_enum),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &N, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &LDA, sizeof(int),
- STARPU_SCRATCH, options->ws_worker,
- STARPU_W, RTBLKADDR(B, double, Bm, Bn),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_W(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &norm, sizeof(MORSE_enum),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &N, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &LDA, sizeof(int),
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_W, RTBLKADDR(B, double, Bm, Bn),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zlansy",
+ STARPU_NAME, "zlansy",
#endif
- 0);
- }
+ 0);
}
#if !defined(CHAMELEON_SIMULATION)
diff --git a/runtime/starpu/codelets/codelet_zlantr.c b/runtime/starpu/codelets/codelet_zlantr.c
index c6815973f6c4c92330f76ad5a6334cd9f834fe80..e950fd7e2606f3a19462cf89bffcd83066d38170 100644
--- a/runtime/starpu/codelets/codelet_zlantr.c
+++ b/runtime/starpu/codelets/codelet_zlantr.c
@@ -36,27 +36,28 @@ void MORSE_TASK_zlantr(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zlantr;
void (*callback)(void*) = options->profiling ? cl_zlange_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &norm, sizeof(MORSE_enum),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &diag, sizeof(MORSE_enum),
- STARPU_VALUE, &M, sizeof(int),
- STARPU_VALUE, &N, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &LDA, sizeof(int),
- STARPU_SCRATCH, options->ws_worker,
- STARPU_W, RTBLKADDR(B, double, Bm, Bn),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_W(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &norm, sizeof(MORSE_enum),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &diag, sizeof(MORSE_enum),
+ STARPU_VALUE, &M, sizeof(int),
+ STARPU_VALUE, &N, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &LDA, sizeof(int),
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_W, RTBLKADDR(B, double, Bm, Bn),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zlantr",
+ STARPU_NAME, "zlantr",
#endif
- 0);
- }
+ 0);
(void)NB;
}
diff --git a/runtime/starpu/codelets/codelet_zlascal.c b/runtime/starpu/codelets/codelet_zlascal.c
index 445ee1c318e4d55e804b9d7dfa8b92c0cb351898..614962ed4e5420d504e64a2f0ba4b10df3fa0e24 100644
--- a/runtime/starpu/codelets/codelet_zlascal.c
+++ b/runtime/starpu/codelets/codelet_zlascal.c
@@ -71,23 +71,24 @@ void MORSE_TASK_zlascal(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zlascal;
void (*callback)(void*) = options->profiling ? cl_zlascal_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ))
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zlascal",
+ STARPU_NAME, "zlascal",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zlaset.c b/runtime/starpu/codelets/codelet_zlaset.c
index 639acdb5658de9538d9ae71eb4784dc29b2c2bf4..fcba9efaa1de298206aefb5afa87afb065ab8eab 100644
--- a/runtime/starpu/codelets/codelet_zlaset.c
+++ b/runtime/starpu/codelets/codelet_zlaset.c
@@ -77,24 +77,25 @@ void MORSE_TASK_zlaset(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zlaset;
void (*callback)(void*) = options->profiling ? cl_zlaset_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &M, sizeof(int),
- STARPU_VALUE, &N, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
- STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &LDA, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_W(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &M, sizeof(int),
+ STARPU_VALUE, &N, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
+ STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &LDA, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zlaset",
+ STARPU_NAME, "zlaset",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zlaset2.c b/runtime/starpu/codelets/codelet_zlaset2.c
index ac9e8fda8f83acd4d7a75bb0843a3e7dbc1efd35..0d5efc1de99e772b81572793b1ec21a0aa6d2e9d 100644
--- a/runtime/starpu/codelets/codelet_zlaset2.c
+++ b/runtime/starpu/codelets/codelet_zlaset2.c
@@ -74,23 +74,24 @@ void MORSE_TASK_zlaset2(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zlaset2;
void (*callback)(void*) = options->profiling ? cl_zlaset2_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &M, sizeof(int),
- STARPU_VALUE, &N, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &LDA, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_W(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &M, sizeof(int),
+ STARPU_VALUE, &N, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &LDA, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zlaset2",
+ STARPU_NAME, "zlaset2",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zlatro.c b/runtime/starpu/codelets/codelet_zlatro.c
index 29345b4424a13aa2de6b9eec195d52a7430665ac..9faa75eb64cafc605c736e0f79e17f3a15aabf1f 100644
--- a/runtime/starpu/codelets/codelet_zlatro.c
+++ b/runtime/starpu/codelets/codelet_zlatro.c
@@ -47,26 +47,27 @@ void MORSE_TASK_zlatro(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zlatro;
void (*callback)(void*) = NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_W, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_W(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_W, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zlatro",
+ STARPU_NAME, "zlatro",
#endif
- 0);
- }
+ 0);
(void)mb;
}
diff --git a/runtime/starpu/codelets/codelet_zlauum.c b/runtime/starpu/codelets/codelet_zlauum.c
index 1f5876bd25a9e7fafcb46e305e2593f5229ddb4c..f578695ff8599d3a0804d44f38d75ecf7125771a 100644
--- a/runtime/starpu/codelets/codelet_zlauum.c
+++ b/runtime/starpu/codelets/codelet_zlauum.c
@@ -46,21 +46,22 @@ void MORSE_TASK_zlauum(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zlauum;
void (*callback)(void*) = options->profiling ? cl_zlauum_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zlauum",
+ STARPU_NAME, "zlauum",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zplghe.c b/runtime/starpu/codelets/codelet_zplghe.c
index de57291a5c48f4abe986d07b6026a2f3b0ff8b19..79ff9238fa36e4fe5ddfaf0c8f2ea8ac9d6a38b8 100644
--- a/runtime/starpu/codelets/codelet_zplghe.c
+++ b/runtime/starpu/codelets/codelet_zplghe.c
@@ -41,26 +41,27 @@ void MORSE_TASK_zplghe( const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zplghe;
void (*callback)(void*) = options->profiling ? cl_zplghe_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &bump, sizeof(double),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &bigM, sizeof(int),
- STARPU_VALUE, &m0, sizeof(int),
- STARPU_VALUE, &n0, sizeof(int),
- STARPU_VALUE, &seed, sizeof(unsigned long long int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_W(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &bump, sizeof(double),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &bigM, sizeof(int),
+ STARPU_VALUE, &m0, sizeof(int),
+ STARPU_VALUE, &n0, sizeof(int),
+ STARPU_VALUE, &seed, sizeof(unsigned long long int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zplghe",
+ STARPU_NAME, "zplghe",
#endif
- 0);
- }
+ 0);
}
/* cl_zplghe_cpu_func - Generate a tile for random hermitian (positive definite if bump is large enough) matrix. */
diff --git a/runtime/starpu/codelets/codelet_zplgsy.c b/runtime/starpu/codelets/codelet_zplgsy.c
index 965ff11d884e566a096d6495bd3c6ebc59682d6b..cbe5f9ee2970b7f924aa46303b167640e3db69bb 100644
--- a/runtime/starpu/codelets/codelet_zplgsy.c
+++ b/runtime/starpu/codelets/codelet_zplgsy.c
@@ -42,26 +42,27 @@ void MORSE_TASK_zplgsy( const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zplgsy;
void (*callback)(void*) = options->profiling ? cl_zplgsy_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &bump, sizeof(MORSE_Complex64_t),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &bigM, sizeof(int),
- STARPU_VALUE, &m0, sizeof(int),
- STARPU_VALUE, &n0, sizeof(int),
- STARPU_VALUE, &seed, sizeof(unsigned long long int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_W(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &bump, sizeof(MORSE_Complex64_t),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &bigM, sizeof(int),
+ STARPU_VALUE, &m0, sizeof(int),
+ STARPU_VALUE, &n0, sizeof(int),
+ STARPU_VALUE, &seed, sizeof(unsigned long long int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zplgsy",
+ STARPU_NAME, "zplgsy",
#endif
- 0);
- }
+ 0);
}
/* cl_zplgsy_cpu_func - Generate a tile for random symmetric (positive definite if 'bump' is large enough) matrix. */
diff --git a/runtime/starpu/codelets/codelet_zplrnt.c b/runtime/starpu/codelets/codelet_zplrnt.c
index 12bd1dfbdfa2c8952d5bef5d64cf630f79b106ec..b8c96b26348d48af715214639e7657d03e22f25b 100644
--- a/runtime/starpu/codelets/codelet_zplrnt.c
+++ b/runtime/starpu/codelets/codelet_zplrnt.c
@@ -41,25 +41,27 @@ void MORSE_TASK_zplrnt( const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zplrnt;
void (*callback)(void*) = options->profiling ? cl_zplrnt_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &bigM, sizeof(int),
- STARPU_VALUE, &m0, sizeof(int),
- STARPU_VALUE, &n0, sizeof(int),
- STARPU_VALUE, &seed, sizeof(unsigned long long int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_W(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &bigM, sizeof(int),
+ STARPU_VALUE, &m0, sizeof(int),
+ STARPU_VALUE, &n0, sizeof(int),
+ STARPU_VALUE, &seed, sizeof(unsigned long long int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zplrnt",
+ STARPU_NAME, "zplrnt",
#endif
- 0);
- }
+ 0);
}
/* cl_zplrnt_cpu_func - Generate a tile for random matrix. */
diff --git a/runtime/starpu/codelets/codelet_zplssq.c b/runtime/starpu/codelets/codelet_zplssq.c
index 0c85274d127025756eba7f0dbb917ec760ee53bf..75538476ebfe37346cb37be9276222076acbb106 100644
--- a/runtime/starpu/codelets/codelet_zplssq.c
+++ b/runtime/starpu/codelets/codelet_zplssq.c
@@ -66,20 +66,21 @@ void MORSE_TASK_zplssq( const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zplssq;
void (*callback)(void*) = options->profiling ? cl_zplssq_callback : NULL;
- if ( morse_desc_islocal( SCALESUMSQ, SCALESUMSQm, SCALESUMSQn ) ||
- morse_desc_islocal( SCLSSQ, SCLSSQm, SCLSSQn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_R, RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn),
- STARPU_RW, RTBLKADDR(SCLSSQ, double, SCLSSQm, SCLSSQn),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(SCALESUMSQ, SCALESUMSQm, SCALESUMSQn);
+ MORSE_ACCESS_RW(SCLSSQ, SCLSSQm, SCLSSQn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_R, RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn),
+ STARPU_RW, RTBLKADDR(SCLSSQ, double, SCLSSQm, SCLSSQn),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zplssq",
+ STARPU_NAME, "zplssq",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zpotrf.c b/runtime/starpu/codelets/codelet_zpotrf.c
index 2f5e6cfc984e4021f6c2506aa5b0c386baf98362..857cf3356edda7507b788e90ce56682cdd1f4608 100644
--- a/runtime/starpu/codelets/codelet_zpotrf.c
+++ b/runtime/starpu/codelets/codelet_zpotrf.c
@@ -47,23 +47,24 @@ void MORSE_TASK_zpotrf(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zpotrf;
void (*callback)(void*) = options->profiling ? cl_zpotrf_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &iinfo, sizeof(int),
- /* STARPU_SCRATCH, options->ws_worker, */
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &iinfo, sizeof(int),
+ /* STARPU_SCRATCH, options->ws_worker, */
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zpotrf",
+ STARPU_NAME, "zpotrf",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zssssm.c b/runtime/starpu/codelets/codelet_zssssm.c
index 20dfcd9da62fa92a5faa445b4704d768cbd64449..a1fae08bb05f5eb552ea5a2492b543009b294a71 100644
--- a/runtime/starpu/codelets/codelet_zssssm.c
+++ b/runtime/starpu/codelets/codelet_zssssm.c
@@ -115,35 +115,36 @@ void MORSE_TASK_zssssm(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zssssm;
void (*callback)(void*) = options->profiling ? cl_zssssm_callback : NULL;
- if ( morse_desc_islocal( A1, A1m, A1n ) ||
- morse_desc_islocal( A2, A2m, A2n ) ||
- morse_desc_islocal( L1, L1m, L1n ) ||
- morse_desc_islocal( L2, L2m, L2n ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m1, sizeof(int),
- STARPU_VALUE, &n1, sizeof(int),
- STARPU_VALUE, &m2, sizeof(int),
- STARPU_VALUE, &n2, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
- STARPU_VALUE, &lda1, sizeof(int),
- STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
- STARPU_VALUE, &lda2, sizeof(int),
- STARPU_R, RTBLKADDR(L1, MORSE_Complex64_t, L1m, L1n),
- STARPU_VALUE, &ldl1, sizeof(int),
- STARPU_R, RTBLKADDR(L2, MORSE_Complex64_t, L2m, L2n),
- STARPU_VALUE, &ldl2, sizeof(int),
- STARPU_VALUE, &IPIV, sizeof(int*),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A1, A1m, A1n);
+ MORSE_ACCESS_RW(A2, A2m, A2n);
+ MORSE_ACCESS_R(L1, L1m, L1n);
+ MORSE_ACCESS_R(L2, L2m, L2n);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m1, sizeof(int),
+ STARPU_VALUE, &n1, sizeof(int),
+ STARPU_VALUE, &m2, sizeof(int),
+ STARPU_VALUE, &n2, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
+ STARPU_VALUE, &lda1, sizeof(int),
+ STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
+ STARPU_VALUE, &lda2, sizeof(int),
+ STARPU_R, RTBLKADDR(L1, MORSE_Complex64_t, L1m, L1n),
+ STARPU_VALUE, &ldl1, sizeof(int),
+ STARPU_R, RTBLKADDR(L2, MORSE_Complex64_t, L2m, L2n),
+ STARPU_VALUE, &ldl2, sizeof(int),
+ STARPU_VALUE, &IPIV, sizeof(int*),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zssssm",
+ STARPU_NAME, "zssssm",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zsymm.c b/runtime/starpu/codelets/codelet_zsymm.c
index 78ad94c01ba60bd5c65981017bb4185e7ecd577d..71e6b86700dde96065d72c0a0c3e43edac347f2c 100644
--- a/runtime/starpu/codelets/codelet_zsymm.c
+++ b/runtime/starpu/codelets/codelet_zsymm.c
@@ -48,31 +48,32 @@ void MORSE_TASK_zsymm(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zsymm;
void (*callback)(void*) = options->profiling ? cl_zsymm_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) ||
- morse_desc_islocal( C, Cm, Cn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_R, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
- STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
- STARPU_VALUE, &ldc, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_R(B, Bm, Bn);
+ MORSE_ACCESS_RW(C, Cm, Cn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_R, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
+ STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
+ STARPU_VALUE, &ldc, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zsymm",
+ STARPU_NAME, "zsymm",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zsyr2k.c b/runtime/starpu/codelets/codelet_zsyr2k.c
index d2a59d995c18b9d854ceb989f0d0e713f2879cf0..cafe3887e071c926e91f296b79d97210eaf71c15 100644
--- a/runtime/starpu/codelets/codelet_zsyr2k.c
+++ b/runtime/starpu/codelets/codelet_zsyr2k.c
@@ -48,31 +48,32 @@ void MORSE_TASK_zsyr2k(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zsyr2k;
void (*callback)(void*) = options->profiling ? cl_zsyr2k_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) ||
- morse_desc_islocal( C, Cm, Cn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_R, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
- STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
- STARPU_VALUE, &ldc, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_R(B, Bm, Bn);
+ MORSE_ACCESS_RW(C, Cm, Cn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_R, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
+ STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
+ STARPU_VALUE, &ldc, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zsyr2k",
+ STARPU_NAME, "zsyr2k",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zsyrk.c b/runtime/starpu/codelets/codelet_zsyrk.c
index c38981ef4a49b300d3bc16a6f00dd3f20d56f6ad..b368779f50cc7af2dcb8644be56720746a4deb37 100644
--- a/runtime/starpu/codelets/codelet_zsyrk.c
+++ b/runtime/starpu/codelets/codelet_zsyrk.c
@@ -47,28 +47,29 @@ void MORSE_TASK_zsyrk(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zsyrk;
void (*callback)(void*) = options->profiling ? cl_zsyrk_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( C, Cm, Cn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
- STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
- STARPU_VALUE, &ldc, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(C, Cm, Cn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
+ STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
+ STARPU_VALUE, &ldc, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zsyrk",
+ STARPU_NAME, "zsyrk",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zsyssq.c b/runtime/starpu/codelets/codelet_zsyssq.c
index 7335678bddfc08d70a921a71fa00218aa8233253..882650f2865138f4d3e804631de879e1add16b04 100644
--- a/runtime/starpu/codelets/codelet_zsyssq.c
+++ b/runtime/starpu/codelets/codelet_zsyssq.c
@@ -34,23 +34,25 @@ void MORSE_TASK_zsyssq( const MORSE_option_t *options,
{
struct starpu_codelet *codelet = &cl_zsyssq;
void (*callback)(void*) = options->profiling ? cl_zgessq_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( SCALESUMSQ, SCALESUMSQm, SCALESUMSQn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_RW, RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(SCALESUMSQ, SCALESUMSQm, SCALESUMSQn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_RW, RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zsyssq",
+ STARPU_NAME, "zsyssq",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zsytrf_nopiv.c b/runtime/starpu/codelets/codelet_zsytrf_nopiv.c
index a1592b9aa3d44d6f968debea2e54c6d960e93cb5..002591071b3b5a7509b9e4941732a264bfc1aaed 100644
--- a/runtime/starpu/codelets/codelet_zsytrf_nopiv.c
+++ b/runtime/starpu/codelets/codelet_zsytrf_nopiv.c
@@ -41,23 +41,24 @@ void MORSE_TASK_zsytrf_nopiv(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zsytrf_nopiv;
void (*callback)(void*) = options->profiling ? cl_zsytrf_nopiv_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &iinfo, sizeof(int),
- /* STARPU_SCRATCH, options->ws_worker, */
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &iinfo, sizeof(int),
+ /* STARPU_SCRATCH, options->ws_worker, */
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zsytrf_nopiv",
+ STARPU_NAME, "zsytrf_nopiv",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_ztile_zero.c b/runtime/starpu/codelets/codelet_ztile_zero.c
index 553729e36cf47cea9916bd6153d30ea29f90f559..b07702888352d4402837a23c8f63a15fc74eeeaf 100644
--- a/runtime/starpu/codelets/codelet_ztile_zero.c
+++ b/runtime/starpu/codelets/codelet_ztile_zero.c
@@ -38,23 +38,24 @@ void MORSE_TASK_ztile_zero(const const MORSE_option_t *options,
codelet = &cl_ztile_zero;
void (*callback)(void*) = options->profiling ? cl_zlacpy_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &X1, sizeof(int),
- STARPU_VALUE, &X2, sizeof(int),
- STARPU_VALUE, &Y1, sizeof(int),
- STARPU_VALUE, &Y2, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback, NULL,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_W(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &X1, sizeof(int),
+ STARPU_VALUE, &X2, sizeof(int),
+ STARPU_VALUE, &Y1, sizeof(int),
+ STARPU_VALUE, &Y2, sizeof(int),
+ STARPU_W, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback, NULL,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztile_zero",
+ STARPU_NAME, "ztile_zero",
#endif
- 0);
- }
+ 0);
}
/*****************************************************************************
diff --git a/runtime/starpu/codelets/codelet_ztpmqrt.c b/runtime/starpu/codelets/codelet_ztpmqrt.c
index e1743543e701b43c6a81372c97aae60db1b6154e..5428c9eea8badfdc586898350e80af94497a2f6a 100644
--- a/runtime/starpu/codelets/codelet_ztpmqrt.c
+++ b/runtime/starpu/codelets/codelet_ztpmqrt.c
@@ -36,37 +36,38 @@ void MORSE_TASK_ztpmqrt( const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_ztpmqrt;
void (*callback)(void*) = options->profiling ? cl_ztpmqrt_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) ||
- morse_desc_islocal( V, Vm, Vn ) ||
- morse_desc_islocal( T, Tm, Tn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &M, sizeof(int),
- STARPU_VALUE, &N, sizeof(int),
- STARPU_VALUE, &K, sizeof(int),
- STARPU_VALUE, &L, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
- STARPU_VALUE, &ldv, sizeof(int),
- STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- /* Other options */
- STARPU_SCRATCH, options->ws_worker,
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(V, Vm, Vn);
+ MORSE_ACCESS_R(T, Tm, Tn);
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_ACCESS_RW(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &M, sizeof(int),
+ STARPU_VALUE, &N, sizeof(int),
+ STARPU_VALUE, &K, sizeof(int),
+ STARPU_VALUE, &L, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
+ STARPU_VALUE, &ldv, sizeof(int),
+ STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ /* Other options */
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztpmqrt",
+ STARPU_NAME, "ztpmqrt",
#endif
- 0);
- }
+ 0);
(void)ib; (void)nb;
}
diff --git a/runtime/starpu/codelets/codelet_ztpqrt.c b/runtime/starpu/codelets/codelet_ztpqrt.c
index bda639581a0dd6a1474be055ba4b038efa04137a..893a3ec9735607828e41d8c9186a1c5134b916c9 100644
--- a/runtime/starpu/codelets/codelet_ztpqrt.c
+++ b/runtime/starpu/codelets/codelet_ztpqrt.c
@@ -34,31 +34,32 @@ void MORSE_TASK_ztpqrt( const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_ztpqrt;
void (*callback)(void*) = options->profiling ? cl_ztpqrt_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) ||
- morse_desc_islocal( T, Tm, Tn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &M, sizeof(int),
- STARPU_VALUE, &N, sizeof(int),
- STARPU_VALUE, &L, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_RW, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- /* Other options */
- STARPU_SCRATCH, options->ws_worker,
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_ACCESS_RW(B, Bm, Bn);
+ MORSE_ACCESS_W(T, Tm, Tn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &M, sizeof(int),
+ STARPU_VALUE, &N, sizeof(int),
+ STARPU_VALUE, &L, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ /* Other options */
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztpqrt",
+ STARPU_NAME, "ztpqrt",
#endif
- 0);
- }
+ 0);
(void)ib; (void)nb;
}
diff --git a/runtime/starpu/codelets/codelet_ztradd.c b/runtime/starpu/codelets/codelet_ztradd.c
index 9147e25affaa5222547338aec3fc03f8ae3ca6b8..ffce0ea3f581a58470f5b01a16f682d898bb7ee7 100644
--- a/runtime/starpu/codelets/codelet_ztradd.c
+++ b/runtime/starpu/codelets/codelet_ztradd.c
@@ -95,28 +95,29 @@ void MORSE_TASK_ztradd(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_ztradd;
void (*callback)(void*) = options->profiling ? cl_zgeadd_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
- STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &beta, sizeof(MORSE_Complex64_t),
+ STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztradd",
+ STARPU_NAME, "ztradd",
#endif
- 0);
- }
+ 0);
(void)nb;
}
diff --git a/runtime/starpu/codelets/codelet_ztrasm.c b/runtime/starpu/codelets/codelet_ztrasm.c
index 859e2688837be2d4ccb1cd8ea89675f71fdf20e2..03e30ff6c330c3b07ee93f1981af345b610d46f0 100644
--- a/runtime/starpu/codelets/codelet_ztrasm.c
+++ b/runtime/starpu/codelets/codelet_ztrasm.c
@@ -34,6 +34,12 @@ void MORSE_TASK_ztrasm(const MORSE_option_t *options,
{
struct starpu_codelet *codelet = &cl_ztrasm;
void (*callback)(void*) = options->profiling ? cl_ztrasm_callback : NULL;
+
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
starpu_insert_task(
starpu_mpi_codelet(codelet),
STARPU_VALUE, &storev, sizeof(MORSE_enum),
diff --git a/runtime/starpu/codelets/codelet_ztrmm.c b/runtime/starpu/codelets/codelet_ztrmm.c
index 0072d1f24f34fac62ccf1fa6cf03876e3fa520e2..ca54848703d4778361831948aaebfff235795779 100644
--- a/runtime/starpu/codelets/codelet_ztrmm.c
+++ b/runtime/starpu/codelets/codelet_ztrmm.c
@@ -47,29 +47,30 @@ void MORSE_TASK_ztrmm(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_ztrmm;
void (*callback)(void*) = options->profiling ? cl_ztrmm_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &transA, sizeof(MORSE_enum),
- STARPU_VALUE, &diag, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(B, Bm, Bn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &transA, sizeof(MORSE_enum),
+ STARPU_VALUE, &diag, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztrmm",
+ STARPU_NAME, "ztrmm",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_ztrsm.c b/runtime/starpu/codelets/codelet_ztrsm.c
index dbed609debc3c2688ac937a5f6cb5b3f49f9f027..061c264121b27baf69d7906300551697302f4fba 100644
--- a/runtime/starpu/codelets/codelet_ztrsm.c
+++ b/runtime/starpu/codelets/codelet_ztrsm.c
@@ -64,34 +64,35 @@ void MORSE_TASK_ztrsm(const MORSE_option_t *options,
rank_changed=1;
}
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( B, Bm, Bn ) ||
- rank_changed
- )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &transA, sizeof(MORSE_enum),
- STARPU_VALUE, &diag, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
- STARPU_VALUE, &ldb, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(B, Bm, Bn);
+ if (rank_changed)
+ MORSE_RANK_CHANGED;
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &transA, sizeof(MORSE_enum),
+ STARPU_VALUE, &diag, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &alpha, sizeof(MORSE_Complex64_t),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_RW, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),
+ STARPU_VALUE, &ldb, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_USE_MPI)
- STARPU_EXECUTE_ON_NODE, execution_rank,
+ STARPU_EXECUTE_ON_NODE, execution_rank,
#endif
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztrsm",
+ STARPU_NAME, "ztrsm",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_ztrssq.c b/runtime/starpu/codelets/codelet_ztrssq.c
index ce875156976c82406e31e86814e9b36fd6caa736..578b318cee6174de50647efb18a59963e14dc40b 100644
--- a/runtime/starpu/codelets/codelet_ztrssq.c
+++ b/runtime/starpu/codelets/codelet_ztrssq.c
@@ -35,25 +35,27 @@ void MORSE_TASK_ztrssq( const MORSE_option_t *options,
{
struct starpu_codelet *codelet = &cl_ztrssq;
void (*callback)(void*) = options->profiling ? cl_ztrasm_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( SCALESUMSQ, SCALESUMSQm, SCALESUMSQn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &diag, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_RW, RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_RW(SCALESUMSQ, SCALESUMSQm, SCALESUMSQn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &diag, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_RW, RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztrssq",
+ STARPU_NAME, "ztrssq",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_ztrtri.c b/runtime/starpu/codelets/codelet_ztrtri.c
index 4d4b8a23c03f9aa73551bb4407a98c838409bdbd..1f619cd097dbd1a75dbdc1f6f6b9d606ef3020be 100644
--- a/runtime/starpu/codelets/codelet_ztrtri.c
+++ b/runtime/starpu/codelets/codelet_ztrtri.c
@@ -48,23 +48,24 @@ void MORSE_TASK_ztrtri(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_ztrtri;
void (*callback)(void*) = options->profiling ? cl_ztrtri_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &uplo, sizeof(MORSE_enum),
- STARPU_VALUE, &diag, sizeof(MORSE_enum),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_VALUE, &iinfo, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &uplo, sizeof(MORSE_enum),
+ STARPU_VALUE, &diag, sizeof(MORSE_enum),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_VALUE, &iinfo, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztrtri",
+ STARPU_NAME, "ztrtri",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_ztslqt.c b/runtime/starpu/codelets/codelet_ztslqt.c
index 04c75182b0010da72689f834c8c783d20a1db5b9..3780308276014e3c7596a79b65d1e32e01df2466 100644
--- a/runtime/starpu/codelets/codelet_ztslqt.c
+++ b/runtime/starpu/codelets/codelet_ztslqt.c
@@ -119,32 +119,33 @@ void MORSE_TASK_ztslqt(const MORSE_option_t *options,
void (*callback)(void*) = options->profiling ? cl_ztslqt_callback : NULL;
MORSE_starpu_ws_t *h_work = (MORSE_starpu_ws_t*)(options->ws_host);
- if ( morse_desc_islocal( A1, A1m, A1n ) ||
- morse_desc_islocal( A2, A2m, A2n ) ||
- morse_desc_islocal( T, Tm, Tn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
- STARPU_VALUE, &lda1, sizeof(int),
- STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
- STARPU_VALUE, &lda2, sizeof(int),
- STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- /* max( nb * (ib+1), ib * (ib+nb) ) */
- STARPU_SCRATCH, options->ws_worker,
- /* /\* 2 * ib * (nb+ib) + nb *\/ */
- STARPU_VALUE, &h_work, sizeof(MORSE_starpu_ws_t *),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A1, A1m, A1n);
+ MORSE_ACCESS_RW(A2, A2m, A2n);
+ MORSE_ACCESS_W(T, Tm, Tn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
+ STARPU_VALUE, &lda1, sizeof(int),
+ STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
+ STARPU_VALUE, &lda2, sizeof(int),
+ STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ /* max( nb * (ib+1), ib * (ib+nb) ) */
+ STARPU_SCRATCH, options->ws_worker,
+ /* /\* 2 * ib * (nb+ib) + nb *\/ */
+ STARPU_VALUE, &h_work, sizeof(MORSE_starpu_ws_t *),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztslqt",
+ STARPU_NAME, "ztslqt",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_ztsmlq.c b/runtime/starpu/codelets/codelet_ztsmlq.c
index 62fa28f927f7f03ac47ebbeba1a6fd1d8c925b35..3901295404dcd256073c9e34fa72bcbd2d4dfce0 100644
--- a/runtime/starpu/codelets/codelet_ztsmlq.c
+++ b/runtime/starpu/codelets/codelet_ztsmlq.c
@@ -145,39 +145,40 @@ void MORSE_TASK_ztsmlq(const MORSE_option_t *options,
void (*callback)(void*) = options->profiling ? cl_ztsmlq_callback : NULL;
int ldwork = side == MorseLeft ? ib : nb;
- if ( morse_desc_islocal( A1, A1m, A1n ) ||
- morse_desc_islocal( A2, A2m, A2n ) ||
- morse_desc_islocal( V, Vm, Vn ) ||
- morse_desc_islocal( T, Tm, Tn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &m1, sizeof(int),
- STARPU_VALUE, &n1, sizeof(int),
- STARPU_VALUE, &m2, sizeof(int),
- STARPU_VALUE, &n2, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
- STARPU_VALUE, &lda1, sizeof(int),
- STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
- STARPU_VALUE, &lda2, sizeof(int),
- STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
- STARPU_VALUE, &ldv, sizeof(int),
- STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- /* max( ib*nb, 2*ib*nb ) */
- STARPU_SCRATCH, options->ws_worker,
- STARPU_VALUE, &ldwork, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A1, A1m, A1n);
+ MORSE_ACCESS_RW(A2, A2m, A2n);
+ MORSE_ACCESS_R(V, Vm, Vn);
+ MORSE_ACCESS_R(T, Tm, Tn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &m1, sizeof(int),
+ STARPU_VALUE, &n1, sizeof(int),
+ STARPU_VALUE, &m2, sizeof(int),
+ STARPU_VALUE, &n2, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
+ STARPU_VALUE, &lda1, sizeof(int),
+ STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
+ STARPU_VALUE, &lda2, sizeof(int),
+ STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
+ STARPU_VALUE, &ldv, sizeof(int),
+ STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ /* max( ib*nb, 2*ib*nb ) */
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_VALUE, &ldwork, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztsmlq",
+ STARPU_NAME, "ztsmlq",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_ztsmlq_hetra1.c b/runtime/starpu/codelets/codelet_ztsmlq_hetra1.c
index 0c1d3625584653584bd772962b5ca86ca1ac24b6..6a2a43768ba0209eaf265b685f7a329b0a81b76b 100644
--- a/runtime/starpu/codelets/codelet_ztsmlq_hetra1.c
+++ b/runtime/starpu/codelets/codelet_ztsmlq_hetra1.c
@@ -46,39 +46,40 @@ void MORSE_TASK_ztsmlq_hetra1(const MORSE_option_t *options,
int ldwork = side == MorseLeft ? ib : nb;
- /* T follows distribution of V */
- if ( morse_desc_islocal( A1, A1m, A1n ) ||
- morse_desc_islocal( A2, A2m, A2n ) ||
- morse_desc_islocal( V, Vm, Vn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &m1, sizeof(int),
- STARPU_VALUE, &n1, sizeof(int),
- STARPU_VALUE, &m2, sizeof(int),
- STARPU_VALUE, &n2, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_VALUE, &nb, sizeof(int),
- STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
- STARPU_VALUE, &lda1, sizeof(int),
- STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
- STARPU_VALUE, &lda2, sizeof(int),
- STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
- STARPU_VALUE, &ldv, sizeof(int),
- STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- STARPU_SCRATCH, options->ws_worker,
- STARPU_VALUE, &ldwork, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A1, A1m, A1n);
+ MORSE_ACCESS_RW(A2, A2m, A2n);
+ MORSE_ACCESS_R(V, Vm, Vn);
+ MORSE_ACCESS_R(T, Tm, Tn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &m1, sizeof(int),
+ STARPU_VALUE, &n1, sizeof(int),
+ STARPU_VALUE, &m2, sizeof(int),
+ STARPU_VALUE, &n2, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_VALUE, &nb, sizeof(int),
+ STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
+ STARPU_VALUE, &lda1, sizeof(int),
+ STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
+ STARPU_VALUE, &lda2, sizeof(int),
+ STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
+ STARPU_VALUE, &ldv, sizeof(int),
+ STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_VALUE, &ldwork, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztsmlq_hetra1",
+ STARPU_NAME, "ztsmlq_hetra1",
#endif
- 0);
- }
+ 0);
}
#if !defined(CHAMELEON_SIMULATION)
diff --git a/runtime/starpu/codelets/codelet_ztsmqr.c b/runtime/starpu/codelets/codelet_ztsmqr.c
index 7183c7f6f42c97a0ff19fdc165f4a6352c5ccf53..3f26f7c5803992b3c8af206676ef4acb6a7c15d6 100644
--- a/runtime/starpu/codelets/codelet_ztsmqr.c
+++ b/runtime/starpu/codelets/codelet_ztsmqr.c
@@ -170,43 +170,45 @@ void MORSE_TASK_ztsmqr(const MORSE_option_t *options,
rank_changed = 1;
}
- if ( morse_desc_islocal( A1, A1m, A1n ) ||
- morse_desc_islocal( A2, A2m, A2n ) ||
- morse_desc_islocal( V, Vm, Vn ) ||
- morse_desc_islocal( T, Tm, Tn ) ||
- rank_changed )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &m1, sizeof(int),
- STARPU_VALUE, &n1, sizeof(int),
- STARPU_VALUE, &m2, sizeof(int),
- STARPU_VALUE, &n2, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
- STARPU_VALUE, &lda1, sizeof(int),
- STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
- STARPU_VALUE, &lda2, sizeof(int),
- STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
- STARPU_VALUE, &ldv, sizeof(int),
- STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- /* max( ib*nb, 2*ib*nb ) */
- STARPU_SCRATCH, options->ws_worker,
- STARPU_VALUE, &ldwork, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A1, A1m, A1n);
+ MORSE_ACCESS_RW(A2, A2m, A2n);
+ MORSE_ACCESS_R(V, Vm, Vn);
+ MORSE_ACCESS_R(T, Tm, Tn);
+ if (rank_changed)
+ MORSE_RANK_CHANGED;
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &m1, sizeof(int),
+ STARPU_VALUE, &n1, sizeof(int),
+ STARPU_VALUE, &m2, sizeof(int),
+ STARPU_VALUE, &n2, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
+ STARPU_VALUE, &lda1, sizeof(int),
+ STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
+ STARPU_VALUE, &lda2, sizeof(int),
+ STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
+ STARPU_VALUE, &ldv, sizeof(int),
+ STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ /* max( ib*nb, 2*ib*nb ) */
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_VALUE, &ldwork, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztsmqr",
+ STARPU_NAME, "ztsmqr",
#endif
#if defined(CHAMELEON_USE_MPI)
- STARPU_EXECUTE_ON_NODE, execution_rank,
+ STARPU_EXECUTE_ON_NODE, execution_rank,
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_ztsmqr_hetra1.c b/runtime/starpu/codelets/codelet_ztsmqr_hetra1.c
index 16edc18b40e71dfa1468fd05569d3ea94ab01c71..792d9e0592832bb075a1916408fa983d9b82bef8 100644
--- a/runtime/starpu/codelets/codelet_ztsmqr_hetra1.c
+++ b/runtime/starpu/codelets/codelet_ztsmqr_hetra1.c
@@ -46,38 +46,39 @@ void MORSE_TASK_ztsmqr_hetra1(const MORSE_option_t *options,
int ldwork = side == MorseLeft ? ib : nb;
- /* T follows distribution of V */
- if ( morse_desc_islocal( A1, A1m, A1n ) ||
- morse_desc_islocal( A2, A2m, A2n ) ||
- morse_desc_islocal( V, Vm, Vn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &m1, sizeof(int),
- STARPU_VALUE, &n1, sizeof(int),
- STARPU_VALUE, &m2, sizeof(int),
- STARPU_VALUE, &n2, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
- STARPU_VALUE, &lda1, sizeof(int),
- STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
- STARPU_VALUE, &lda2, sizeof(int),
- STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
- STARPU_VALUE, &ldv, sizeof(int),
- STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- STARPU_SCRATCH, options->ws_worker,
- STARPU_VALUE, &ldwork, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A1, A1m, A1n);
+ MORSE_ACCESS_RW(A2, A2m, A2n);
+ MORSE_ACCESS_R(V, Vm, Vn);
+ MORSE_ACCESS_R(T, Tm, Tn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &m1, sizeof(int),
+ STARPU_VALUE, &n1, sizeof(int),
+ STARPU_VALUE, &m2, sizeof(int),
+ STARPU_VALUE, &n2, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
+ STARPU_VALUE, &lda1, sizeof(int),
+ STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
+ STARPU_VALUE, &lda2, sizeof(int),
+ STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
+ STARPU_VALUE, &ldv, sizeof(int),
+ STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_VALUE, &ldwork, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztsmqr_hetra1",
+ STARPU_NAME, "ztsmqr_hetra1",
#endif
- 0);
- }
+ 0);
}
#if !defined(CHAMELEON_SIMULATION)
diff --git a/runtime/starpu/codelets/codelet_ztsqrt.c b/runtime/starpu/codelets/codelet_ztsqrt.c
index 7081a754a0aa53d583b6ecf97ce9f03840b46125..c16ca67736570afa9d99490686ef7d7c823b9949 100644
--- a/runtime/starpu/codelets/codelet_ztsqrt.c
+++ b/runtime/starpu/codelets/codelet_ztsqrt.c
@@ -108,33 +108,34 @@ void MORSE_TASK_ztsqrt(const MORSE_option_t *options,
void (*callback)(void*) = options->profiling ? cl_ztsqrt_callback : NULL;
MORSE_starpu_ws_t *h_work = (MORSE_starpu_ws_t*)(options->ws_host);
- if ( morse_desc_islocal( A1, A1m, A1n ) ||
- morse_desc_islocal( A2, A2m, A2n ) ||
- morse_desc_islocal( T, Tm, Tn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
- STARPU_VALUE, &lda1, sizeof(int),
- STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
- STARPU_VALUE, &lda2, sizeof(int),
- STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn ),
- STARPU_VALUE, &ldt, sizeof(int),
- /* max( nb * (ib+1), ib * (ib+nb) ) */
- STARPU_SCRATCH, options->ws_worker,
- /* 2 * ib * (nb+ib) + nb */
- STARPU_VALUE, &h_work, sizeof(MORSE_starpu_ws_t *),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A1, A1m, A1n);
+ MORSE_ACCESS_RW(A2, A2m, A2n);
+ MORSE_ACCESS_W(T, Tm, Tn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
+ STARPU_VALUE, &lda1, sizeof(int),
+ STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
+ STARPU_VALUE, &lda2, sizeof(int),
+ STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn ),
+ STARPU_VALUE, &ldt, sizeof(int),
+ /* max( nb * (ib+1), ib * (ib+nb) ) */
+ STARPU_SCRATCH, options->ws_worker,
+ /* 2 * ib * (nb+ib) + nb */
+ STARPU_VALUE, &h_work, sizeof(MORSE_starpu_ws_t *),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztsqrt",
+ STARPU_NAME, "ztsqrt",
#endif
- STARPU_EXECUTE_ON_NODE, A2->get_rankof(A2, A2m, A2n),
- 0);
- }
+ STARPU_EXECUTE_ON_NODE, A2->get_rankof(A2, A2m, A2n),
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_ztstrf.c b/runtime/starpu/codelets/codelet_ztstrf.c
index 0628740d9bc0f0cc6fb797b80eb45addcc3e7599..eae5108ee9c28ba1335d524f6b6a5dd9a65c060f 100644
--- a/runtime/starpu/codelets/codelet_ztstrf.c
+++ b/runtime/starpu/codelets/codelet_ztstrf.c
@@ -113,35 +113,36 @@ void MORSE_TASK_ztstrf(const MORSE_option_t *options,
void (*callback)(void*) = options->profiling ? cl_ztstrf_callback : NULL;
MORSE_starpu_ws_t *d_work = (MORSE_starpu_ws_t*)(options->ws_host);
- if ( morse_desc_islocal( U, Um, Un ) ||
- morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( L, Lm, Ln ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_VALUE, &nb, sizeof(int),
- STARPU_RW, RTBLKADDR(U, MORSE_Complex64_t, Um, Un),
- STARPU_VALUE, &ldu, sizeof(int),
- STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_W, RTBLKADDR(L, MORSE_Complex64_t, Lm, Ln),
- STARPU_VALUE, &ldl, sizeof(int),
- STARPU_VALUE, &IPIV, sizeof(int*),
- STARPU_SCRATCH, options->ws_worker,
- STARPU_VALUE, &d_work, sizeof(MORSE_starpu_ws_t *),
- STARPU_VALUE, &nb, sizeof(int),
- STARPU_VALUE, &check_info, sizeof(MORSE_bool),
- STARPU_VALUE, &iinfo, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(U, Um, Un);
+ MORSE_ACCESS_RW(A, Am, An);
+ MORSE_ACCESS_W(L, Lm, Ln);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_VALUE, &nb, sizeof(int),
+ STARPU_RW, RTBLKADDR(U, MORSE_Complex64_t, Um, Un),
+ STARPU_VALUE, &ldu, sizeof(int),
+ STARPU_RW, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_W, RTBLKADDR(L, MORSE_Complex64_t, Lm, Ln),
+ STARPU_VALUE, &ldl, sizeof(int),
+ STARPU_VALUE, &IPIV, sizeof(int*),
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_VALUE, &d_work, sizeof(MORSE_starpu_ws_t *),
+ STARPU_VALUE, &nb, sizeof(int),
+ STARPU_VALUE, &check_info, sizeof(MORSE_bool),
+ STARPU_VALUE, &iinfo, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "ztstrf",
+ STARPU_NAME, "ztstrf",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zttlqt.c b/runtime/starpu/codelets/codelet_zttlqt.c
index 269cec7a973661dff42dbec34f6d0dc3c13ed39a..f89913e6922496aa20d3ce275461b3805dc97c78 100644
--- a/runtime/starpu/codelets/codelet_zttlqt.c
+++ b/runtime/starpu/codelets/codelet_zttlqt.c
@@ -117,30 +117,31 @@ void MORSE_TASK_zttlqt(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zttlqt;
void (*callback)(void*) = options->profiling ? cl_zttlqt_callback : NULL;
- if ( morse_desc_islocal( A1, A1m, A1n ) ||
- morse_desc_islocal( A2, A2m, A2n ) ||
- morse_desc_islocal( T, Tm, Tn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
- STARPU_VALUE, &lda1, sizeof(int),
- STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
- STARPU_VALUE, &lda2, sizeof(int),
- STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- /* nb * (ib+1) */
- STARPU_SCRATCH, options->ws_worker,
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A1, A1m, A1n);
+ MORSE_ACCESS_RW(A2, A2m, A2n);
+ MORSE_ACCESS_W(T, Tm, Tn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
+ STARPU_VALUE, &lda1, sizeof(int),
+ STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
+ STARPU_VALUE, &lda2, sizeof(int),
+ STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ /* nb * (ib+1) */
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zttlqt",
+ STARPU_NAME, "zttlqt",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zttmlq.c b/runtime/starpu/codelets/codelet_zttmlq.c
index ca03af3c7e836b6a241288974a683b19e93d0573..2a75969c1e45651602f21fa00aaf707510f393f0 100644
--- a/runtime/starpu/codelets/codelet_zttmlq.c
+++ b/runtime/starpu/codelets/codelet_zttmlq.c
@@ -138,39 +138,40 @@ void MORSE_TASK_zttmlq(const MORSE_option_t *options,
void (*callback)(void*) = options->profiling ? cl_zttmlq_callback : NULL;
int ldwork = side == MorseLeft ? ib : nb;
- if ( morse_desc_islocal( A1, A1m, A1n ) ||
- morse_desc_islocal( A2, A2m, A2n ) ||
- morse_desc_islocal( V, Vm, Vn ) ||
- morse_desc_islocal( T, Tm, Tn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &m1, sizeof(int),
- STARPU_VALUE, &n1, sizeof(int),
- STARPU_VALUE, &m2, sizeof(int),
- STARPU_VALUE, &n2, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
- STARPU_VALUE, &lda1, sizeof(int),
- STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
- STARPU_VALUE, &lda2, sizeof(int),
- STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
- STARPU_VALUE, &ldv, sizeof(int),
- STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- /* nb * ib */
- STARPU_SCRATCH, options->ws_worker,
- STARPU_VALUE, &ldwork, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A1, A1m, A1n);
+ MORSE_ACCESS_RW(A2, A2m, A2n);
+ MORSE_ACCESS_R(V, Vm, Vn);
+ MORSE_ACCESS_R(T, Tm, Tn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &m1, sizeof(int),
+ STARPU_VALUE, &n1, sizeof(int),
+ STARPU_VALUE, &m2, sizeof(int),
+ STARPU_VALUE, &n2, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
+ STARPU_VALUE, &lda1, sizeof(int),
+ STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
+ STARPU_VALUE, &lda2, sizeof(int),
+ STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
+ STARPU_VALUE, &ldv, sizeof(int),
+ STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ /* nb * ib */
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_VALUE, &ldwork, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zttmlq",
+ STARPU_NAME, "zttmlq",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zttmqr.c b/runtime/starpu/codelets/codelet_zttmqr.c
index e31b558607eec2c9588e636221fc2bb890e70fac..f16d3f0b07408cdb4b75bd22e850d872571cbe22 100644
--- a/runtime/starpu/codelets/codelet_zttmqr.c
+++ b/runtime/starpu/codelets/codelet_zttmqr.c
@@ -163,43 +163,45 @@ void MORSE_TASK_zttmqr(const MORSE_option_t *options,
rank_changed = 1;
}
- if ( morse_desc_islocal( A1, A1m, A1n ) ||
- morse_desc_islocal( A2, A2m, A2n ) ||
- morse_desc_islocal( V, Vm, Vn ) ||
- morse_desc_islocal( T, Tm, Tn ) ||
- rank_changed )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &m1, sizeof(int),
- STARPU_VALUE, &n1, sizeof(int),
- STARPU_VALUE, &m2, sizeof(int),
- STARPU_VALUE, &n2, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
- STARPU_VALUE, &lda1, sizeof(int),
- STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
- STARPU_VALUE, &lda2, sizeof(int),
- STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
- STARPU_VALUE, &ldv, sizeof(int),
- STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- /* nb * ib */
- STARPU_SCRATCH, options->ws_worker,
- STARPU_VALUE, &ldwork, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A1, A1m, A1n);
+ MORSE_ACCESS_RW(A2, A2m, A2n);
+ MORSE_ACCESS_R(V, Vm, Vn);
+ MORSE_ACCESS_R(T, Tm, Tn);
+ if (rank_changed)
+ MORSE_RANK_CHANGED;
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &m1, sizeof(int),
+ STARPU_VALUE, &n1, sizeof(int),
+ STARPU_VALUE, &m2, sizeof(int),
+ STARPU_VALUE, &n2, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
+ STARPU_VALUE, &lda1, sizeof(int),
+ STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
+ STARPU_VALUE, &lda2, sizeof(int),
+ STARPU_R, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn),
+ STARPU_VALUE, &ldv, sizeof(int),
+ STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ /* nb * ib */
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_VALUE, &ldwork, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_USE_MPI)
- STARPU_EXECUTE_ON_NODE, execution_rank,
+ STARPU_EXECUTE_ON_NODE, execution_rank,
#endif
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zttmqr",
+ STARPU_NAME, "zttmqr",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zttqrt.c b/runtime/starpu/codelets/codelet_zttqrt.c
index b368a3202a70036be6afb7db92e29f8ae9a91f25..02bc8245873c567e641f76b5e7b0bac82e613628 100644
--- a/runtime/starpu/codelets/codelet_zttqrt.c
+++ b/runtime/starpu/codelets/codelet_zttqrt.c
@@ -117,30 +117,31 @@ void MORSE_TASK_zttqrt(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zttqrt;
void (*callback)(void*) = options->profiling ? cl_zttqrt_callback : NULL;
- if ( morse_desc_islocal( A1, A1m, A1n ) ||
- morse_desc_islocal( A2, A2m, A2n ) ||
- morse_desc_islocal( T, Tm, Tn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
- STARPU_VALUE, &lda1, sizeof(int),
- STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
- STARPU_VALUE, &lda2, sizeof(int),
- STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- /* nb * (ib+1) */
- STARPU_SCRATCH, options->ws_worker,
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_RW(A1, A1m, A1n);
+ MORSE_ACCESS_RW(A2, A2m, A2n);
+ MORSE_ACCESS_W(T, Tm, Tn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_RW, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n),
+ STARPU_VALUE, &lda1, sizeof(int),
+ STARPU_RW, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n),
+ STARPU_VALUE, &lda2, sizeof(int),
+ STARPU_W, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ /* nb * (ib+1) */
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zttqrt",
+ STARPU_NAME, "zttqrt",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zunmlq.c b/runtime/starpu/codelets/codelet_zunmlq.c
index 956d92643e51e0d09601ce45be9ec514c10beaf9..6525661f635f020ec7c234e456eeca32ecbd177c 100644
--- a/runtime/starpu/codelets/codelet_zunmlq.c
+++ b/runtime/starpu/codelets/codelet_zunmlq.c
@@ -127,34 +127,35 @@ void MORSE_TASK_zunmlq(const MORSE_option_t *options,
struct starpu_codelet *codelet = &cl_zunmlq;
void (*callback)(void*) = options->profiling ? cl_zunmlq_callback : NULL;
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( T, Tm, Tn ) ||
- morse_desc_islocal( C, Cm, Cn ) )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
- STARPU_VALUE, &ldc, sizeof(int),
- /* ib * nb */
- STARPU_SCRATCH, options->ws_worker,
- STARPU_VALUE, &nb, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_R(T, Tm, Tn);
+ MORSE_ACCESS_RW(C, Cm, Cn);
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
+ STARPU_VALUE, &ldc, sizeof(int),
+ /* ib * nb */
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_VALUE, &nb, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zunmlq",
+ STARPU_NAME, "zunmlq",
#endif
- 0);
- }
+ 0);
}
diff --git a/runtime/starpu/codelets/codelet_zunmqr.c b/runtime/starpu/codelets/codelet_zunmqr.c
index fcbf06a7ec3ae8dda9addac2d6cc6ad916c140cb..3c981f4bbb0a2349580ed9d6443b914389e388cd 100644
--- a/runtime/starpu/codelets/codelet_zunmqr.c
+++ b/runtime/starpu/codelets/codelet_zunmqr.c
@@ -148,38 +148,40 @@ void MORSE_TASK_zunmqr(const MORSE_option_t *options,
rank_changed = 1;
}
- if ( morse_desc_islocal( A, Am, An ) ||
- morse_desc_islocal( T, Tm, Tn ) ||
- morse_desc_islocal( C, Cm, Cn ) ||
- rank_changed )
- {
- starpu_insert_task(
- starpu_mpi_codelet(codelet),
- STARPU_VALUE, &side, sizeof(MORSE_enum),
- STARPU_VALUE, &trans, sizeof(MORSE_enum),
- STARPU_VALUE, &m, sizeof(int),
- STARPU_VALUE, &n, sizeof(int),
- STARPU_VALUE, &k, sizeof(int),
- STARPU_VALUE, &ib, sizeof(int),
- STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
- STARPU_VALUE, &lda, sizeof(int),
- STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
- STARPU_VALUE, &ldt, sizeof(int),
- STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
- STARPU_VALUE, &ldc, sizeof(int),
- /* ib * nb */
- STARPU_SCRATCH, options->ws_worker,
- STARPU_VALUE, &nb, sizeof(int),
- STARPU_PRIORITY, options->priority,
- STARPU_CALLBACK, callback,
+ MORSE_BEGIN_ACCESS_DECLARATION;
+ MORSE_ACCESS_R(A, Am, An);
+ MORSE_ACCESS_R(T, Tm, Tn);
+ MORSE_ACCESS_RW(C, Cm, Cn);
+ if (rank_changed)
+ MORSE_RANK_CHANGED;
+ MORSE_END_ACCESS_DECLARATION;
+
+ starpu_insert_task(
+ starpu_mpi_codelet(codelet),
+ STARPU_VALUE, &side, sizeof(MORSE_enum),
+ STARPU_VALUE, &trans, sizeof(MORSE_enum),
+ STARPU_VALUE, &m, sizeof(int),
+ STARPU_VALUE, &n, sizeof(int),
+ STARPU_VALUE, &k, sizeof(int),
+ STARPU_VALUE, &ib, sizeof(int),
+ STARPU_R, RTBLKADDR(A, MORSE_Complex64_t, Am, An),
+ STARPU_VALUE, &lda, sizeof(int),
+ STARPU_R, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn),
+ STARPU_VALUE, &ldt, sizeof(int),
+ STARPU_RW, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),
+ STARPU_VALUE, &ldc, sizeof(int),
+ /* ib * nb */
+ STARPU_SCRATCH, options->ws_worker,
+ STARPU_VALUE, &nb, sizeof(int),
+ STARPU_PRIORITY, options->priority,
+ STARPU_CALLBACK, callback,
#if defined(CHAMELEON_USE_MPI)
- STARPU_EXECUTE_ON_NODE, execution_rank,
+ STARPU_EXECUTE_ON_NODE, execution_rank,
#endif
#if defined(CHAMELEON_CODELETS_HAVE_NAME)
- STARPU_NAME, "zunmqr",
+ STARPU_NAME, "zunmqr",
#endif
- 0);
- }
+ 0);
}