From a2bde4b97ee1b69ada8a46a25ce78fe7ef7b87a5 Mon Sep 17 00:00:00 2001
From: Samuel Thibault <samuel.thibault@ens-lyon.org>
Date: Fri, 17 Mar 2017 12:01:39 +0100
Subject: [PATCH] use macros in all codelets
---
runtime/starpu/codelets/codelet_zasum.c | 6 ++
runtime/starpu/codelets/codelet_zaxpy.c | 32 +++++----
runtime/starpu/codelets/codelet_zbuild.c | 42 ++++++------
runtime/starpu/codelets/codelet_zgeadd.c | 39 +++++------
runtime/starpu/codelets/codelet_zgelqt.c | 43 ++++++------
runtime/starpu/codelets/codelet_zgeqrt.c | 43 ++++++------
runtime/starpu/codelets/codelet_zgessm.c | 45 ++++++------
runtime/starpu/codelets/codelet_zgessq.c | 31 +++++----
runtime/starpu/codelets/codelet_zgetrf.c | 33 ++++-----
.../starpu/codelets/codelet_zgetrf_incpiv.c | 45 ++++++------
.../starpu/codelets/codelet_zgetrf_nopiv.c | 31 +++++----
runtime/starpu/codelets/codelet_zhe2ge.c | 35 +++++-----
runtime/starpu/codelets/codelet_zhemm.c | 47 ++++++-------
runtime/starpu/codelets/codelet_zher2k.c | 47 ++++++-------
runtime/starpu/codelets/codelet_zherfb.c | 49 ++++++-------
runtime/starpu/codelets/codelet_zherk.c | 41 +++++------
runtime/starpu/codelets/codelet_zhessq.c | 31 +++++----
runtime/starpu/codelets/codelet_zlacpy.c | 39 +++++------
runtime/starpu/codelets/codelet_zlag2c.c | 33 ++++-----
runtime/starpu/codelets/codelet_zlange.c | 35 +++++-----
runtime/starpu/codelets/codelet_zlanhe.c | 35 +++++-----
runtime/starpu/codelets/codelet_zlansy.c | 35 +++++-----
runtime/starpu/codelets/codelet_zlantr.c | 39 +++++------
runtime/starpu/codelets/codelet_zlascal.c | 31 +++++----
runtime/starpu/codelets/codelet_zlaset.c | 33 ++++-----
runtime/starpu/codelets/codelet_zlaset2.c | 31 +++++----
runtime/starpu/codelets/codelet_zlatro.c | 37 +++++-----
runtime/starpu/codelets/codelet_zlauum.c | 27 ++++----
runtime/starpu/codelets/codelet_zplghe.c | 37 +++++-----
runtime/starpu/codelets/codelet_zplgsy.c | 37 +++++-----
runtime/starpu/codelets/codelet_zplrnt.c | 36 +++++-----
runtime/starpu/codelets/codelet_zplssq.c | 25 +++----
runtime/starpu/codelets/codelet_zpotrf.c | 31 +++++----
runtime/starpu/codelets/codelet_zssssm.c | 55 +++++++--------
runtime/starpu/codelets/codelet_zsymm.c | 47 ++++++-------
runtime/starpu/codelets/codelet_zsyr2k.c | 47 ++++++-------
runtime/starpu/codelets/codelet_zsyrk.c | 41 +++++------
runtime/starpu/codelets/codelet_zsyssq.c | 32 +++++----
.../starpu/codelets/codelet_zsytrf_nopiv.c | 31 +++++----
runtime/starpu/codelets/codelet_ztile_zero.c | 31 +++++----
runtime/starpu/codelets/codelet_ztpmqrt.c | 59 ++++++++--------
runtime/starpu/codelets/codelet_ztpqrt.c | 47 ++++++-------
runtime/starpu/codelets/codelet_ztradd.c | 41 +++++------
runtime/starpu/codelets/codelet_ztrasm.c | 6 ++
runtime/starpu/codelets/codelet_ztrmm.c | 43 ++++++------
runtime/starpu/codelets/codelet_ztrsm.c | 49 ++++++-------
runtime/starpu/codelets/codelet_ztrssq.c | 36 +++++-----
runtime/starpu/codelets/codelet_ztrtri.c | 31 +++++----
runtime/starpu/codelets/codelet_ztslqt.c | 49 ++++++-------
runtime/starpu/codelets/codelet_ztsmlq.c | 63 ++++++++---------
.../starpu/codelets/codelet_ztsmlq_hetra1.c | 63 ++++++++---------
runtime/starpu/codelets/codelet_ztsmqr.c | 68 ++++++++++---------
.../starpu/codelets/codelet_ztsmqr_hetra1.c | 61 +++++++++--------
runtime/starpu/codelets/codelet_ztsqrt.c | 51 +++++++-------
runtime/starpu/codelets/codelet_ztstrf.c | 55 +++++++--------
runtime/starpu/codelets/codelet_zttlqt.c | 45 ++++++------
runtime/starpu/codelets/codelet_zttmlq.c | 63 ++++++++---------
runtime/starpu/codelets/codelet_zttmqr.c | 68 ++++++++++---------
runtime/starpu/codelets/codelet_zttqrt.c | 45 ++++++------
runtime/starpu/codelets/codelet_zunmlq.c | 53 ++++++++-------
runtime/starpu/codelets/codelet_zunmqr.c | 58 ++++++++--------
61 files changed, 1298 insertions(+), 1221 deletions(-)
diff --git a/runtime/starpu/codelets/codelet_zasum.c b/runtime/starpu/codelets/codelet_zasum.c
index 7c17a35d1..2323b95e6 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 557eaa108..56b03bfe8 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 d2e654064..45cf4467f 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_AAAESS_RW(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 1a57e3123..edfd5461b 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 2b4c0daf8..af571f2ae 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_zgeqrt.c b/runtime/starpu/codelets/codelet_zgeqrt.c
index d738fc0b5..50769b3be 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 cabe11ce9..547111784 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 cd229712b..094c7ba09 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 54544d069..e9b5327bf 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 c76be02aa..ad3475cb7 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 3fa0f5c39..ab9d87ace 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 f107252cc..6551a8fbb 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 4489e84ad..df4523463 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 78a4d6f13..9b6b7194d 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 210fb3278..b5ceec04b 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 8e0d48f6f..e5ef78021 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 11666dbce..8f9ddf984 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 ee86f5d18..99274e183 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 7390acaae..f09c80846 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 9a1b1ebcf..9571eec74 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 24a87f752..37725f178 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 0e3fe5933..dd01215c2 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 c6815973f..e950fd7e2 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 445ee1c31..614962ed4 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 639acdb56..fcba9efaa 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 ac9e8fda8..0d5efc1de 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 29345b442..9faa75eb6 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 1f5876bd2..f578695ff 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 de57291a5..79ff9238f 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 965ff11d8..cbe5f9ee2 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 12bd1dfbd..b8c96b263 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 0c85274d1..75538476e 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 2f5e6cfc9..857cf3356 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 20dfcd9da..a1fae08bb 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 78ad94c01..71e6b8670 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 d2a59d995..cafe3887e 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 c38981ef4..b368779f5 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 7335678bd..2bdeb1e9d 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_R(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 a1592b9aa..002591071 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 553729e36..09e5bdc83 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_RW(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_RW, 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 e1743543e..088d69fb9 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(A, Am, An);
+ MORSE_ACCESS_R(B, Bm, Bn);
+ MORSE_ACCESS_RW(V, Vm, Vn);
+ MORSE_ACCESS_RW(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, &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 bda639581..353072f24 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_ATTESS_RW(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_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,
#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 9147e25af..ffce0ea3f 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 859e26888..03e30ff6c 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 0072d1f24..ca5484870 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 dbed609de..061c26412 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 ce8751569..578b318ce 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 4d4b8a23c..1f619cd09 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 04c75182b..378030827 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 62fa28f92..390129540 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 0c1d36255..6a2a43768 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 7183c7f6f..3f26f7c58 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 16edc18b4..792d9e059 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 7081a754a..c16ca6773 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 0628740d9..eae5108ee 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 269cec7a9..f89913e69 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 ca03af3c7..2a75969c1 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 e31b55860..f16d3f0b0 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 b368a3202..02bc82458 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 956d92643..6525661f6 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 fcbf06a7e..3c981f4bb 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);
}
--
GitLab