diff --git a/runtime/parsec/CMakeLists.txt b/runtime/parsec/CMakeLists.txt
index 37624f0a700c57056a31346ecba4502fa1162357..a19890afe2b1c55a0eccfdb36c0a25d4dcde1e64 100644
--- a/runtime/parsec/CMakeLists.txt
+++ b/runtime/parsec/CMakeLists.txt
@@ -27,6 +27,7 @@
#
###
+cmake_minimum_required(VERSION 2.8)
# check if magma_dgetrf_incpiv_gpu is accessible in libmagma and activate it in chameleon
if ( CBLAS_FOUND AND LAPACKE_FOUND AND LAPACK_FOUND AND CUDA_FOUND AND CUDA_CUBLAS_LIBRARIES AND MAGMA_FOUND )
@@ -73,10 +74,10 @@ precisions_rules_py(RUNTIME_COMMON_GENERATED "${ZSRC}"
TARGETDIR "control")
set(RUNTIME_COMMON
- control/runtime_control.c
+ control/runtime_async.c
control/runtime_context.c
+ control/runtime_control.c
control/runtime_descriptor.c
- control/runtime_async.c
control/runtime_options.c
control/runtime_profiling.c
codelets/codelet_dataflush.c
@@ -109,6 +110,7 @@ set(ZSRC
# LAPACK
##################
codelets/codelet_zgeadd.c
+ codelets/codelet_zlascal.c
codelets/codelet_zgelqt.c
codelets/codelet_zgeqrt.c
codelets/codelet_zgessm.c
@@ -116,6 +118,8 @@ set(ZSRC
codelets/codelet_zgetrf.c
codelets/codelet_zgetrf_incpiv.c
codelets/codelet_zgetrf_nopiv.c
+ codelets/codelet_zhe2ge.c
+ codelets/codelet_zherfb.c
codelets/codelet_zhessq.c
codelets/codelet_zlacpy.c
codelets/codelet_zlange.c
@@ -124,6 +128,7 @@ set(ZSRC
codelets/codelet_zlantr.c
codelets/codelet_zlaset2.c
codelets/codelet_zlaset.c
+ codelets/codelet_zlatro.c
codelets/codelet_zlauum.c
codelets/codelet_zplghe.c
codelets/codelet_zplgsy.c
@@ -140,6 +145,8 @@ set(ZSRC
codelets/codelet_ztslqt.c
codelets/codelet_ztsmlq.c
codelets/codelet_ztsmqr.c
+ codelets/codelet_ztsmlq_hetra1.c
+ codelets/codelet_ztsmqr_hetra1.c
codelets/codelet_ztsqrt.c
codelets/codelet_ztstrf.c
codelets/codelet_zttlqt.c
@@ -153,7 +160,6 @@ set(ZSRC
##################
codelets/codelet_zbuild.c
)
-list(REMOVE_DUPLICATES ZSRC)
precisions_rules_py(RUNTIME_SRCS_GENERATED "${ZSRC}"
PRECISIONS "${CHAMELEON_PRECISION}"
@@ -171,9 +177,9 @@ set_property(TARGET chameleon_parsec PROPERTY LINKER_LANGUAGE Fortran)
set_property(TARGET chameleon_parsec PROPERTY INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib")
target_link_libraries(chameleon_parsec coreblas ${PARSEC_LIBRARIES_DEP})
-if(CHAMELEON_USE_CUDA OR CHAMELEON_USE_MAGMA)
+if(CHAMELEON_USE_CUDA)
target_link_libraries(chameleon_parsec cudablas)
-endif(CHAMELEON_USE_CUDA OR CHAMELEON_USE_MAGMA)
+endif(CHAMELEON_USE_CUDA)
add_dependencies(chameleon_parsec
chameleon_include
@@ -182,6 +188,10 @@ add_dependencies(chameleon_parsec
runtime_parsec_include
)
+if (CHAMELEON_USE_CUDA AND NOT CHAMELEON_SIMULATION)
+ add_dependencies(chameleon_starpu cudablas_include)
+endif()
+
# installation
# ------------
install(TARGETS chameleon_parsec
diff --git a/runtime/parsec/codelets/codelet_zasum.c b/runtime/parsec/codelets/codelet_zasum.c
index e796649eed06a588dad61f72f0d6294b8920b59c..401bede893f37596e69b2d4ef8e6941fbe7ad256 100644
--- a/runtime/parsec/codelets/codelet_zasum.c
+++ b/runtime/parsec/codelets/codelet_zasum.c
@@ -23,7 +23,8 @@
#include "runtime/parsec/include/morse_parsec.h"
static int
-CORE_dzasum_parsec(dague_execution_unit_t *context, dague_execution_context_t *this_task)
+CORE_dzasum_parsec(dague_execution_unit_t *context,
+ dague_execution_context_t *this_task)
{
MORSE_enum *storev;
MORSE_enum *uplo;
@@ -33,15 +34,15 @@ CORE_dzasum_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *lda;
double *work;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &storev,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &work
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &storev,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &work );
CORE_dzasum(*storev, *uplo, *M, *N, A, *lda, work);
@@ -55,13 +56,14 @@ void MORSE_TASK_dzasum(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_dzasum_parsec, "zasum",
- sizeof(MORSE_enum), &storev, VALUE,
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &M, VALUE,
- sizeof(int), &N, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), INOUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_dzasum_parsec, "zasum",
+ sizeof(MORSE_enum), &storev, VALUE,
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &M, VALUE,
+ sizeof(int), &N, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), INOUT | REGION_FULL,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zaxpy.c b/runtime/parsec/codelets/codelet_zaxpy.c
index 96f8048582998039f07a0aac60f88701bfcb8f88..ef3e8983ffc8a8af5b0016c517cda621e9849c95 100644
--- a/runtime/parsec/codelets/codelet_zaxpy.c
+++ b/runtime/parsec/codelets/codelet_zaxpy.c
@@ -32,15 +32,14 @@ CORE_zaxpy_parsec(dague_execution_unit_t *context, dague_execution_context_t *th
MORSE_Complex64_t *B;
int *incB;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &incA,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &incB
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &incA,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &incB );
CORE_zaxpy(*M, *alpha, A, *incA, B, *incB);
@@ -54,12 +53,13 @@ void MORSE_TASK_zaxpy(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zaxpy_parsec, "axpy",
- sizeof(int), &M, VALUE,
- sizeof(MORSE_Complex64_t), alpha, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &incA, VALUE,
- PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INOUT | REGION_FULL,
- sizeof(int), &incB, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zaxpy_parsec, "axpy",
+ sizeof(int), &M, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &incA, VALUE,
+ PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INOUT | REGION_FULL,
+ sizeof(int), &incB, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zbuild.c b/runtime/parsec/codelets/codelet_zbuild.c
index d058dcafcddefdf1fd8672a4ee125f29233bb06d..0adbbe29c0f30bbdc80c923f3c08ef404bc82ded 100644
--- a/runtime/parsec/codelets/codelet_zbuild.c
+++ b/runtime/parsec/codelets/codelet_zbuild.c
@@ -24,28 +24,28 @@
**/
#include "runtime/parsec/include/morse_parsec.h"
-static int
-CORE_zbuild_parsec(dague_execution_unit_t *context, dague_execution_context_t *this_task)
+static inline int
+CORE_zbuild_parsec(dague_execution_unit_t *context,
+ dague_execution_context_t *this_task)
{
MORSE_Complex64_t *A;
- int *lda;
- void *user_data;
- void (*user_build_callback)(int row_min, int row_max, int col_min, int col_max, void *buffer, int ld, void *user_data) ;
- int row_min, row_max, col_min, col_max;
-
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &row_min,
- UNPACK_VALUE, &row_max,
- UNPACK_VALUE, &col_min,
- UNPACK_VALUE, &col_max,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_VALUE, &user_data,
- UNPACK_VALUE, &user_build_callback
- );
+ int lda;
+ void *user_data;
+ void (*user_build_callback)(int row_min, int row_max, int col_min, int col_max, void *buffer, int ld, void *user_data) ;
+ int row_min, row_max, col_min, col_max;
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &row_min,
+ UNPACK_VALUE, &row_max,
+ UNPACK_VALUE, &col_min,
+ UNPACK_VALUE, &col_max,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_VALUE, &user_data,
+ UNPACK_VALUE, &user_build_callback );
- user_build_callback(row_min, row_max, col_min, col_max, A, ld, user_data);
+ user_build_callback(row_min, row_max, col_min, col_max, A, lda, user_data);
return 0;
}
@@ -61,14 +61,15 @@ void MORSE_TASK_zbuild( const MORSE_option_t *options,
col_min = An*A->nb ;
col_max = An == A->nt-1 ? A->n-1 : col_min+A->nb-1 ;
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zbuild_parsec, "zbuild",
- sizeof(int), &row_min, VALUE,
- sizeof(int), &row_max, VALUE,
- sizeof(int), &col_min, VALUE,
- sizeof(int), &col_max, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- sizeof(void*), &user_data, VALUE,
- sizeof(void*), &user_build_callback, VALUE
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zbuild_parsec, "zbuild",
+ sizeof(int), &row_min, VALUE,
+ sizeof(int), &row_max, VALUE,
+ sizeof(int), &col_min, VALUE,
+ sizeof(int), &col_max, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ sizeof(void*), &user_data, VALUE,
+ sizeof(void*), &user_build_callback, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zgeadd.c b/runtime/parsec/codelets/codelet_zgeadd.c
index 440898f4fc7da0d84f750ca7748a84e86f2aa6ee..3f3fcbad85de9d5fcc37d85ce7b5d8662f7a1350 100644
--- a/runtime/parsec/codelets/codelet_zgeadd.c
+++ b/runtime/parsec/codelets/codelet_zgeadd.c
@@ -40,17 +40,17 @@ CORE_zgeadd_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *B;
int *LDB;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA,
- UNPACK_VALUE, &beta,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &LDB
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_VALUE, &beta,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &LDB );
CORE_zgeadd(*trans, *M, *N, *alpha, A, *LDA, *beta, B, *LDB);
@@ -118,7 +118,7 @@ void MORSE_TASK_zgeadd(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(
+ dague_insert_task(
DAGUE_dtd_handle, CORE_zgeadd_parsec, "geadd",
sizeof(MORSE_enum), &trans, VALUE,
sizeof(int), &m, VALUE,
diff --git a/runtime/parsec/codelets/codelet_zgelqt.c b/runtime/parsec/codelets/codelet_zgelqt.c
index 6c71adc8569b703a6ab784a59bd95ec08f9ac5a3..eebd02cc0b6c1fd0173ab5e86a5644b575ab8c36 100644
--- a/runtime/parsec/codelets/codelet_zgelqt.c
+++ b/runtime/parsec/codelets/codelet_zgelqt.c
@@ -96,18 +96,17 @@ CORE_zgelqt_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *TAU;
MORSE_Complex64_t *WORK;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_SCRATCH, &TAU,
- UNPACK_SCRATCH, &WORK
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &TAU,
+ UNPACK_SCRATCH, &WORK );
CORE_zgelqt(*m, *n, *ib, A, *lda, T, *ldt, TAU, WORK);
@@ -121,15 +120,16 @@ void MORSE_TASK_zgelqt(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zgelqt_parsec, "gelqt",
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zgelqt_parsec, "gelqt",
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zgemm.c b/runtime/parsec/codelets/codelet_zgemm.c
index ba0f15f3df07fa8c88515cc9e71ba22e6aaf672b..5d100cf5d1753f14c92cca2ac9b2a3de594bbbdb 100644
--- a/runtime/parsec/codelets/codelet_zgemm.c
+++ b/runtime/parsec/codelets/codelet_zgemm.c
@@ -28,7 +28,8 @@
*
**/
static int
-CORE_zgemm_parsec(dague_execution_unit_t *context, dague_execution_context_t *this_task)
+CORE_zgemm_parsec(dague_execution_unit_t *context,
+ dague_execution_context_t *this_task)
{
MORSE_enum *transA;
MORSE_enum *transB;
@@ -44,21 +45,21 @@ CORE_zgemm_parsec(dague_execution_unit_t *context, dague_execution_context_t *th
MORSE_Complex64_t *C;
int *ldc;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &transA,
- UNPACK_VALUE, &transB,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &ldb,
- UNPACK_VALUE, &beta,
- UNPACK_DATA, &C,
- UNPACK_VALUE, &ldc
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &transA,
+ UNPACK_VALUE, &transB,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &ldb,
+ UNPACK_VALUE, &beta,
+ UNPACK_DATA, &C,
+ UNPACK_VALUE, &ldc );
CORE_zgemm(*transA, *transB, *m, *n, *k,
*alpha, A, *lda,
@@ -77,19 +78,20 @@ void MORSE_TASK_zgemm(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zgemm_parsec, "Gemm",
- sizeof(MORSE_enum), &transA, VALUE,
- sizeof(MORSE_enum), &transB, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(MORSE_Complex64_t), &alpha, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INPUT | REGION_FULL,
- sizeof(int), &ldb, VALUE,
- sizeof(MORSE_Complex64_t), &beta, VALUE,
- PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
- sizeof(int), &ldc, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zgemm_parsec, "Gemm",
+ sizeof(MORSE_enum), &transA, VALUE,
+ sizeof(MORSE_enum), &transB, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INPUT | REGION_FULL,
+ sizeof(int), &ldb, VALUE,
+ sizeof(MORSE_Complex64_t), &beta, VALUE,
+ PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
+ sizeof(int), &ldc, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zgeqrt.c b/runtime/parsec/codelets/codelet_zgeqrt.c
index 7a5a6724a4d65962fc2cb1afde57dd7ff2c8920d..f9d9b55882fbbef50efb7cb49e0ef3756835be16 100644
--- a/runtime/parsec/codelets/codelet_zgeqrt.c
+++ b/runtime/parsec/codelets/codelet_zgeqrt.c
@@ -97,18 +97,17 @@ CORE_zgeqrt_parsec (dague_execution_unit_t *context, dague_execution_context_t *
MORSE_Complex64_t *TAU;
MORSE_Complex64_t *WORK;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_SCRATCH, &TAU,
- UNPACK_SCRATCH, &WORK
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &TAU,
+ UNPACK_SCRATCH, &WORK );
CORE_zgeqrt(*m, *n, *ib, A, *lda, T, *ldt, TAU, WORK);
@@ -122,15 +121,16 @@ void MORSE_TASK_zgeqrt(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zgeqrt_parsec, "geqrt",
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zgeqrt_parsec, "geqrt",
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zgessm.c b/runtime/parsec/codelets/codelet_zgessm.c
index d5a5368b7fe849da1b15a727ede0ca818e5d9011..d06acae872c5f9b5daad13dc0c01842fc16e9bd7 100644
--- a/runtime/parsec/codelets/codelet_zgessm.c
+++ b/runtime/parsec/codelets/codelet_zgessm.c
@@ -82,20 +82,19 @@ CORE_zgessm_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *A;
int *lda;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &ib,
- UNPACK_SCRATCH, &IPIV,
- UNPACK_DATA, &L,
- UNPACK_VALUE, &ldl,
- UNPACK_DATA, &D,
- UNPACK_VALUE, &ldd,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &ib,
+ UNPACK_SCRATCH, &IPIV,
+ UNPACK_DATA, &L,
+ UNPACK_VALUE, &ldl,
+ UNPACK_DATA, &D,
+ UNPACK_VALUE, &ldd,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda );
CORE_zgessm(*m, *n, *k, *ib, IPIV, D, *ldd, A, *lda);
@@ -111,17 +110,18 @@ void MORSE_TASK_zgessm(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zgessm_parsec, "gessm",
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(int), &ib, VALUE,
- sizeof(int)*nb, IPIV, SCRATCH,
- PASSED_BY_REF, RTBLKADDR( L, MORSE_Complex64_t, Lm, Ln ), INPUT | REGION_FULL,
- sizeof(int), &ldl, VALUE,
- PASSED_BY_REF, RTBLKADDR( D, MORSE_Complex64_t, Dm, Dn ), INPUT | REGION_FULL,
- sizeof(int), &ldd, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zgessm_parsec, "gessm",
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &ib, VALUE,
+ sizeof(int)*nb, IPIV, SCRATCH,
+ PASSED_BY_REF, RTBLKADDR( L, MORSE_Complex64_t, Lm, Ln ), INPUT | REGION_FULL,
+ sizeof(int), &ldl, VALUE,
+ PASSED_BY_REF, RTBLKADDR( D, MORSE_Complex64_t, Dm, Dn ), INPUT | REGION_FULL,
+ sizeof(int), &ldd, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zgessq.c b/runtime/parsec/codelets/codelet_zgessq.c
index 0f3c41e8b9f3c1100eea646e7125354fd135d03e..7f5784c0fac7829286f516c99c12234591a81979 100644
--- a/runtime/parsec/codelets/codelet_zgessq.c
+++ b/runtime/parsec/codelets/codelet_zgessq.c
@@ -31,13 +31,13 @@ CORE_zgessq_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *lda;
double *SCALESUMSQ;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &SCALESUMSQ
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &SCALESUMSQ );
CORE_zgessq( *m, *n, A, *lda, SCALESUMSQ, SCALESUMSQ+1);
@@ -51,11 +51,12 @@ void MORSE_TASK_zgessq( const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zgessq_parsec, "gessq",
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn ), INOUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zgessq_parsec, "gessq",
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn ), INOUT | REGION_FULL,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zgetrf.c b/runtime/parsec/codelets/codelet_zgetrf.c
index 47bcdee98aa12fedf5ba8239f57b53cf045f1fa1..c5a5d20289f6fa84fbd61f5bb3bbfae2b14b7f9d 100644
--- a/runtime/parsec/codelets/codelet_zgetrf.c
+++ b/runtime/parsec/codelets/codelet_zgetrf.c
@@ -34,16 +34,15 @@ CORE_zgetrf_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *iinfo;
int info;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_SCRATCH, &IPIV,
- UNPACK_VALUE, &check_info,
- UNPACK_VALUE, &iinfo
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_SCRATCH, &IPIV,
+ UNPACK_VALUE, &check_info,
+ UNPACK_VALUE, &iinfo );
CORE_zgetrf( *m, *n, A, *lda, IPIV, &info );
@@ -58,13 +57,14 @@ void MORSE_TASK_zgetrf(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zgetrf_parsec, "getrf",
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- sizeof(int)*nb, IPIV, SCRATCH,
- sizeof(MORSE_bool), &check_info, VALUE,
- sizeof(int), &iinfo, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zgetrf_parsec, "getrf",
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ sizeof(int)*nb, IPIV, SCRATCH,
+ sizeof(MORSE_bool), &check_info, VALUE,
+ sizeof(int), &iinfo, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zgetrf_incpiv.c b/runtime/parsec/codelets/codelet_zgetrf_incpiv.c
index 44d5f0c9bed5a031544f5b35f22f0988f71ba9fe..775fbc0ab5ffbe829ec46eb28415ec409a418b11 100644
--- a/runtime/parsec/codelets/codelet_zgetrf_incpiv.c
+++ b/runtime/parsec/codelets/codelet_zgetrf_incpiv.c
@@ -90,18 +90,16 @@ CORE_zgetrf_incpiv_parsec(dague_execution_unit_t *context, dague_execution_conte
int info;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_SCRATCH, &IPIV,
- UNPACK_VALUE, &check_info,
- UNPACK_VALUE, &iinfo
- );
-
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_SCRATCH, &IPIV,
+ UNPACK_VALUE, &check_info,
+ UNPACK_VALUE, &iinfo );
CORE_zgetrf_incpiv(*m, *n, *ib, A, *lda, IPIV, &info);
@@ -117,14 +115,15 @@ void MORSE_TASK_zgetrf_incpiv(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zgetrf_incpiv_parsec, "getrf_inc",
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- sizeof(int)*nb, IPIV, SCRATCH,
- sizeof(int), &check_info, VALUE,
- sizeof(int), &iinfo, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zgetrf_incpiv_parsec, "getrf_inc",
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ sizeof(int)*nb, IPIV, SCRATCH,
+ sizeof(int), &check_info, VALUE,
+ sizeof(int), &iinfo, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zgetrf_nopiv.c b/runtime/parsec/codelets/codelet_zgetrf_nopiv.c
index 5f101c60d62a5013d8d5bdfcc2fd8e871943e13b..3b6b7ddc763109865759e9b14a84a28c0993796e 100644
--- a/runtime/parsec/codelets/codelet_zgetrf_nopiv.c
+++ b/runtime/parsec/codelets/codelet_zgetrf_nopiv.c
@@ -80,15 +80,14 @@ CORE_zgetrf_nopiv_parsec(dague_execution_unit_t *context, dague_execution_contex
int *iinfo;
int info;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_VALUE, &iinfo
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_VALUE, &iinfo );
CORE_zgetrf_nopiv(*m, *n, *ib, A, *lda, &info);
@@ -102,12 +101,13 @@ void MORSE_TASK_zgetrf_nopiv(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zgetrf_nopiv_parsec, "getrf_nopiv",
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- sizeof(int), &iinfo, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zgetrf_nopiv_parsec, "getrf_nopiv",
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ sizeof(int), &iinfo, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zhe2ge.c b/runtime/parsec/codelets/codelet_zhe2ge.c
new file mode 100644
index 0000000000000000000000000000000000000000..8e16a10e408d0df9de309b4980497461e5e67465
--- /dev/null
+++ b/runtime/parsec/codelets/codelet_zhe2ge.c
@@ -0,0 +1,74 @@
+/**
+ *
+ * @copyright (c) 2009-2014 The University of Tennessee and The University
+ * of Tennessee Research Foundation.
+ * All rights reserved.
+ * @copyright (c) 2012-2014 Inria. All rights reserved.
+ * @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
+ *
+ **/
+
+/**
+ *
+ * @file codelet_zhe2ge.c
+ *
+ * MORSE codelets kernel
+ * MORSE is a software package provided by Univ. of Tennessee,
+ * Univ. of California Berkeley and Univ. of Colorado Denver
+ *
+ * @precisions normal z -> c d s
+ *
+ **/
+
+#include "runtime/parsec/include/morse_parsec.h"
+
+/**
+ *
+ * @ingroup CORE_MORSE_Complex64_t
+ *
+ **/
+static inline int
+CORE_zhe2ge_parsec(dague_execution_unit_t *context,
+ dague_execution_context_t *this_task)
+{
+ MORSE_enum *uplo;
+ int *M;
+ int *N;
+ const MORSE_Complex64_t *A;
+ int *LDA;
+ MORSE_Complex64_t *B;
+ int *LDB;
+
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &LDB);
+
+ CORE_zhe2ge(*uplo, *M, *N, A, *LDA, B, *LDB);
+}
+
+
+void MORSE_TASK_zhe2ge(const MORSE_option_t *options,
+ MORSE_enum uplo,
+ int m, int n, int mb,
+ const MORSE_desc_t *A, int Am, int An, int lda,
+ const MORSE_desc_t *B, int Bm, int Bn, int ldb)
+{
+ dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
+
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zhe2ge_parsec, "he2ge",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR(A, MORSE_Complex64_t, Am, An), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn), OUTPUT | REGION_FULL,
+ sizeof(int), &ldb, VALUE,
+ 0);
+}
diff --git a/runtime/parsec/codelets/codelet_zhemm.c b/runtime/parsec/codelets/codelet_zhemm.c
index 5659b5a8be41ec8c551c03b812b82df1489dc165..628849093029ab9de7d28bb71951663c1eca9403 100644
--- a/runtime/parsec/codelets/codelet_zhemm.c
+++ b/runtime/parsec/codelets/codelet_zhemm.c
@@ -43,21 +43,20 @@ CORE_zhemm_parsec(dague_execution_unit_t *context, dague_execution_context_t *th
MORSE_Complex64_t *C;
int *LDC;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &side,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &LDB,
- UNPACK_VALUE, &beta,
- UNPACK_DATA, &C,
- UNPACK_VALUE, &LDC
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &LDB,
+ UNPACK_VALUE, &beta,
+ UNPACK_DATA, &C,
+ UNPACK_VALUE, &LDC );
CORE_zhemm(*side, *uplo, *M, *N,
*alpha, A, *LDA,
@@ -76,18 +75,19 @@ void MORSE_TASK_zhemm(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zhemm_parsec, "hemm",
- sizeof(MORSE_enum), &side, VALUE,
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(MORSE_Complex64_t), &alpha, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INPUT | REGION_FULL,
- sizeof(int), &ldb, VALUE,
- sizeof(MORSE_Complex64_t), &beta, VALUE,
- PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
- sizeof(int), &ldc, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zhemm_parsec, "hemm",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INPUT | REGION_FULL,
+ sizeof(int), &ldb, VALUE,
+ sizeof(MORSE_Complex64_t), &beta, VALUE,
+ PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
+ sizeof(int), &ldc, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zher2k.c b/runtime/parsec/codelets/codelet_zher2k.c
index 3209869df627f8731295c0b716386b197793ad01..ffef4285dd3ead8cd9b33628c1bc80bc265896b9 100644
--- a/runtime/parsec/codelets/codelet_zher2k.c
+++ b/runtime/parsec/codelets/codelet_zher2k.c
@@ -43,21 +43,20 @@ CORE_zher2k_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *C;
int *ldc;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &ldb,
- UNPACK_VALUE, &beta,
- UNPACK_DATA, &C,
- UNPACK_VALUE, &ldc
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &ldb,
+ UNPACK_VALUE, &beta,
+ UNPACK_DATA, &C,
+ UNPACK_VALUE, &ldc );
CORE_zher2k(*uplo, *trans, *n, *k,
*alpha, A, *lda,
@@ -76,18 +75,19 @@ void MORSE_TASK_zher2k(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zher2k_parsec, "her2k",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(MORSE_enum), &trans, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(MORSE_Complex64_t), &alpha, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INPUT | REGION_FULL,
- sizeof(int), &ldb, VALUE,
- sizeof(double), &beta, VALUE,
- PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
- sizeof(int), &ldc, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zher2k_parsec, "her2k",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INPUT | REGION_FULL,
+ sizeof(int), &ldb, VALUE,
+ sizeof(double), &beta, VALUE,
+ PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
+ sizeof(int), &ldc, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zherfb.c b/runtime/parsec/codelets/codelet_zherfb.c
new file mode 100644
index 0000000000000000000000000000000000000000..4071608ad805f95937cd86f8ddc33f3994331741
--- /dev/null
+++ b/runtime/parsec/codelets/codelet_zherfb.c
@@ -0,0 +1,91 @@
+/**
+ *
+ * @copyright (c) 2009-2014 The University of Tennessee and The University
+ * of Tennessee Research Foundation.
+ * All rights reserved.
+ * @copyright (c) 2012-2014 Inria. All rights reserved.
+ * @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
+ *
+ **/
+
+/**
+ *
+ * @file qwrapper_zherfb.c
+ *
+ * PLASMA core_blas quark wrapper
+ * PLASMA is a software package provided by Univ. of Tennessee,
+ * Univ. of California Berkeley and Univ. of Colorado Denver
+ *
+ * @version 2.8.0
+ * @author Hatem Ltaief
+ * @date 2010-11-15
+ * @precisions normal z -> c d s
+ *
+ **/
+#include "runtime/parsec/include/morse_parsec.h"
+
+static inline int
+CORE_zherfb_parsec(dague_execution_unit_t *context,
+ dague_execution_context_t *this_task)
+{
+ MORSE_enum *uplo;
+ int *n;
+ int *k;
+ int *ib;
+ int *nb;
+ MORSE_Complex64_t *A;
+ int *lda;
+ MORSE_Complex64_t *T;
+ int *ldt;
+ MORSE_Complex64_t *C;
+ int *ldc;
+ MORSE_Complex64_t *WORK;
+ int *ldwork;
+
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &ib,
+ UNPACK_VALUE, &nb,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_DATA, &C,
+ UNPACK_VALUE, &ldc,
+ UNPACK_SCRATCH, &WORK,
+ UNPACK_VALUE, &ldwork);
+
+ CORE_zherfb(*uplo, *n, *k, *ib, *nb,
+ A, *lda, T, *ldt,
+ C, *ldc, WORK, *ldwork);
+}
+
+void MORSE_TASK_zherfb(const MORSE_option_t *options,
+ MORSE_enum uplo,
+ int n, int k, int ib, int nb,
+ const MORSE_desc_t *A, int Am, int An, int lda,
+ const MORSE_desc_t *T, int Tm, int Tn, int ldt,
+ const MORSE_desc_t *C, int Cm, int Cn, int ldc)
+{
+ dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
+
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zherfb_parsec, "herfb",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &ib, VALUE,
+ sizeof(int), &nb, VALUE,
+ PASSED_BY_REF, RTBLKADDR(A, MORSE_Complex64_t, Am, An), (uplo == MorseUpper) ? INOUT | REGION_U : INOUT | REGION_L,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn), INPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ PASSED_BY_REF, RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn), (uplo == MorseUpper) ? INOUT | REGION_D | REGION_U : INOUT | REGION_D | REGION_L,
+ sizeof(int), &ldc, VALUE,
+ sizeof(MORSE_Complex64_t)*2*nb*nb, NULL, SCRATCH,
+ sizeof(int), &nb, VALUE,
+ 0);
+}
diff --git a/runtime/parsec/codelets/codelet_zherk.c b/runtime/parsec/codelets/codelet_zherk.c
index 8630b0eb47012e478afab767afd21002afa7776d..e97808c90ed3bc542553666f4fb5809c43364752 100644
--- a/runtime/parsec/codelets/codelet_zherk.c
+++ b/runtime/parsec/codelets/codelet_zherk.c
@@ -42,19 +42,18 @@ CORE_zherk_parsec(dague_execution_unit_t *context, dague_execution_context_t * t
MORSE_Complex64_t *C;
int *ldc;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_VALUE, &beta,
- UNPACK_DATA, &C,
- UNPACK_VALUE, &ldc
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_VALUE, &beta,
+ UNPACK_DATA, &C,
+ UNPACK_VALUE, &ldc );
CORE_zherk(*uplo, *trans, *n, *k,
*alpha, A, *lda,
@@ -71,17 +70,18 @@ void MORSE_TASK_zherk(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zherk_parsec, "herk",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(MORSE_enum), &trans, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(double), &alpha, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- sizeof(double), &beta, VALUE,
- PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
- sizeof(int), &ldc, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zherk_parsec, "herk",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(double), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ sizeof(double), &beta, VALUE,
+ PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
+ sizeof(int), &ldc, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zhessq.c b/runtime/parsec/codelets/codelet_zhessq.c
index f88d0638e1b3b988ae1939ea55cfa8c53f2b72d8..6e39d809908c2a2c4cfafa474afefef3715e16e0 100644
--- a/runtime/parsec/codelets/codelet_zhessq.c
+++ b/runtime/parsec/codelets/codelet_zhessq.c
@@ -31,13 +31,13 @@ CORE_zhessq_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *lda;
double *SCALESUMSQ;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &n,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &SCALESUMSQ
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &n,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &SCALESUMSQ );
CORE_zhessq( *uplo, *n, A, *lda, &SCALESUMSQ[0], &SCALESUMSQ[1]);
@@ -51,11 +51,12 @@ void MORSE_TASK_zhessq( const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zhessq_parsec, "hessq",
- sizeof(int), &uplo, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn ), INOUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zhessq_parsec, "hessq",
+ sizeof(int), &uplo, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn ), INOUT | REGION_FULL,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zlacpy.c b/runtime/parsec/codelets/codelet_zlacpy.c
index bde5319f7bcd5bf1bc18b6cbb144e2a0a8348bb9..7f287535b355ec862e6da1e1f9afb4b6ff651d0b 100644
--- a/runtime/parsec/codelets/codelet_zlacpy.c
+++ b/runtime/parsec/codelets/codelet_zlacpy.c
@@ -38,16 +38,15 @@ CORE_zlacpy_parsec(dague_execution_unit_t *context, dague_execution_context_t *
MORSE_Complex64_t *B;
int *LDB;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &LDB
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &LDB );
CORE_zlacpy(*uplo, *M, *N, A, *LDA, B, *LDB);
@@ -62,13 +61,14 @@ void MORSE_TASK_zlacpy(const MORSE_option_t *options,
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zlacpy_parsec, "lacpy",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), OUTPUT | REGION_FULL,
- sizeof(int), &ldb, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zlacpy_parsec, "lacpy",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), OUTPUT | REGION_FULL,
+ sizeof(int), &ldb, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zlag2c.c b/runtime/parsec/codelets/codelet_zlag2c.c
index cd7f2f8da374ac086751edc9e46ea36c542c105c..7b5c30af362dbd10869e20fca08c9761b5d1b18a 100644
--- a/runtime/parsec/codelets/codelet_zlag2c.c
+++ b/runtime/parsec/codelets/codelet_zlag2c.c
@@ -38,14 +38,14 @@ CORE_zlag2c_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *ldb;
int info;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &ldb,
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &ldb );
CORE_zlag2c( *m, *n, A, *lda, B, *ldb);
@@ -59,7 +59,7 @@ void MORSE_TASK_zlag2c(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zlag2c_parsec, "lag2c",
+ dague_insert_task(DAGUE_dtd_handle, CORE_zlag2c_parsec, "lag2c",
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
@@ -84,15 +84,14 @@ CORE_clag2z_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *B;
int *ldb;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &ldb,
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &ldb );
CORE_clag2z( *m, *n, A, *lda, B, *ldb );
@@ -106,7 +105,8 @@ void MORSE_TASK_clag2z(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_clag2z_parsec, "lag2z",
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_clag2z_parsec, "lag2z",
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex32_t, Am, An ), INPUT | REGION_FULL,
diff --git a/runtime/parsec/codelets/codelet_zlange.c b/runtime/parsec/codelets/codelet_zlange.c
index 031c9d189252d61a6e91be50543826f8d9075926..77f1f039c0fabb1c6d224c1b2d5c052e6e11d34b 100644
--- a/runtime/parsec/codelets/codelet_zlange.c
+++ b/runtime/parsec/codelets/codelet_zlange.c
@@ -33,16 +33,15 @@ CORE_zlange_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
double *work;
double *normA;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &norm,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA,
- UNPACK_SCRATCH, &work,
- UNPACK_DATA, &normA
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &norm,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_SCRATCH, &work,
+ UNPACK_DATA, &normA );
CORE_zlange( *norm, *M, *N, A, *LDA, work, normA );
@@ -58,15 +57,16 @@ void MORSE_TASK_zlange(const MORSE_option_t *options,
int szeW = max( M, N );
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zlange_parsec, "lange",
- sizeof(MORSE_enum), &norm, VALUE,
- sizeof(int), &M, VALUE,
- sizeof(int), &N, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &LDA, VALUE,
- sizeof(double)*szeW, NULL, SCRATCH,
- PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), OUTPUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zlange_parsec, "lange",
+ sizeof(MORSE_enum), &norm, VALUE,
+ sizeof(int), &M, VALUE,
+ sizeof(int), &N, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &LDA, VALUE,
+ sizeof(double)*szeW, NULL, SCRATCH,
+ PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), OUTPUT | REGION_FULL,
+ 0);
}
#if defined(PRECISION_d) || defined(PRECISION_s)
@@ -76,11 +76,10 @@ CORE_zlange_max_parsec(dague_execution_unit_t *context, dague_execution_context_
double *A;
double *normA;
- dague_dtd_unpack_args(this_task,
- UNPACK_DATA, &A,
- UNPACK_DATA, &normA
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_DATA, &A,
+ UNPACK_DATA, &normA );
if ( *A > *normA )
*normA = *A;
@@ -94,10 +93,11 @@ void MORSE_TASK_zlange_max(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zlange_max_parsec, "lange_max",
- PASSED_BY_REF, RTBLKADDR( A, double, Am, An ), INPUT | REGION_FULL,
- PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), OUTPUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zlange_max_parsec, "lange_max",
+ PASSED_BY_REF, RTBLKADDR( A, double, Am, An ), INPUT | REGION_FULL,
+ PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), OUTPUT | REGION_FULL,
+ 0);
}
#endif /* defined(PRECISION_d) || defined(PRECISION_s) */
diff --git a/runtime/parsec/codelets/codelet_zlanhe.c b/runtime/parsec/codelets/codelet_zlanhe.c
index 78540b6e10046a0915dc6e8f77878925c1fdda09..fffdb4bec17f6d54d9053880cd42ab6f244c7e98 100644
--- a/runtime/parsec/codelets/codelet_zlanhe.c
+++ b/runtime/parsec/codelets/codelet_zlanhe.c
@@ -33,15 +33,15 @@ CORE_zlanhe_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
double *work;
double *normA;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &norm,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &N,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA,
- UNPACK_SCRATCH, &work,
- UNPACK_DATA, &normA
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &norm,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &N,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_SCRATCH, &work,
+ UNPACK_DATA, &normA );
CORE_zlanhe( *norm, *uplo, *N, A, *LDA, work, normA);
@@ -57,13 +57,14 @@ void MORSE_TASK_zlanhe(const MORSE_option_t *options,
int szeW = max( 1, N );
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zlanhe_parsec, "LANHE",
- sizeof(MORSE_enum), &norm, VALUE,
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &N, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &LDA, VALUE,
- sizeof(double)*szeW, NULL, SCRATCH,
- PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), OUTPUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zlanhe_parsec, "LANHE",
+ sizeof(MORSE_enum), &norm, VALUE,
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &N, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &LDA, VALUE,
+ sizeof(double)*szeW, NULL, SCRATCH,
+ PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), OUTPUT | REGION_FULL,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zlansy.c b/runtime/parsec/codelets/codelet_zlansy.c
index fde4b15a6934048b837d558eb554fb1e0095d3bf..113d06c44fbe036d58ba918469e5135979c0e76b 100644
--- a/runtime/parsec/codelets/codelet_zlansy.c
+++ b/runtime/parsec/codelets/codelet_zlansy.c
@@ -33,16 +33,15 @@ CORE_zlansy_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
double *work;
double *normA;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &norm,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &N,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA,
- UNPACK_SCRATCH, &work,
- UNPACK_DATA, &normA
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &norm,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &N,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_SCRATCH, &work,
+ UNPACK_DATA, &normA );
CORE_zlansy( *norm, *uplo, *N, A, *LDA, work, normA);
@@ -58,13 +57,14 @@ void MORSE_TASK_zlansy(const MORSE_option_t *options,
int szeW = max( 1, N );
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zlansy_parsec, "lansy",
- sizeof(MORSE_enum), &norm, VALUE,
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &N, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &LDA, VALUE,
- sizeof(double)*szeW, NULL, SCRATCH,
- PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), OUTPUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zlansy_parsec, "lansy",
+ sizeof(MORSE_enum), &norm, VALUE,
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &N, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &LDA, VALUE,
+ sizeof(double)*szeW, NULL, SCRATCH,
+ PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), OUTPUT | REGION_FULL,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zlantr.c b/runtime/parsec/codelets/codelet_zlantr.c
index 8e4e22c9416e5c63d772633e4c6ea8a7582b176a..ef290a2a6cda59e869c57b1adc49fc1806483121 100644
--- a/runtime/parsec/codelets/codelet_zlantr.c
+++ b/runtime/parsec/codelets/codelet_zlantr.c
@@ -33,17 +33,17 @@ CORE_zlantr_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
double *work;
double *normA;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &norm,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &diag,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA,
- UNPACK_SCRATCH, &work,
- UNPACK_DATA, &normA
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &norm,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &diag,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_SCRATCH, &work,
+ UNPACK_DATA, &normA );
CORE_zlantr( *norm, *uplo, *diag, *M, *N, A, *LDA, work, normA);
@@ -60,15 +60,16 @@ void MORSE_TASK_zlantr(const MORSE_option_t *options,
int szeW = max( 1, N );
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zlantr_parsec, "lantr",
- sizeof(MORSE_enum), &norm, VALUE,
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(MORSE_enum), &diag, VALUE,
- sizeof(int), &M, VALUE,
- sizeof(int), &N, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &LDA, VALUE,
- sizeof(double)*szeW, NULL, SCRATCH,
- PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), OUTPUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zlantr_parsec, "lantr",
+ sizeof(MORSE_enum), &norm, VALUE,
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(MORSE_enum), &diag, VALUE,
+ sizeof(int), &M, VALUE,
+ sizeof(int), &N, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &LDA, VALUE,
+ sizeof(double)*szeW, NULL, SCRATCH,
+ PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), OUTPUT | REGION_FULL,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zlascal.c b/runtime/parsec/codelets/codelet_zlascal.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb373c70d90744e16dc6c35876386b449718f05e
--- /dev/null
+++ b/runtime/parsec/codelets/codelet_zlascal.c
@@ -0,0 +1,81 @@
+/**
+ *
+ * @copyright (c) 2009-2014 The University of Tennessee and The University
+ * of Tennessee Research Foundation.
+ * All rights reserved.
+ * @copyright (c) 2012-2014 Inria. All rights reserved.
+ * @copyright (c) 2012-2014, 2016 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
+ *
+ **/
+
+/**
+ *
+ * @file codelet_zlascal.c
+ *
+ * MORSE codelets kernel
+ * MORSE is a software package provided by Univ. of Tennessee,
+ * Univ. of California Berkeley and Univ. of Colorado Denver
+ *
+ * @version 2.5.0
+ * @comment This file has been automatically generated
+ * from Plasma 2.5.0 for MORSE 1.0.0
+ * @author Julien Langou
+ * @author Henricus Bouwmeester
+ * @author Mathieu Faverge
+ * @author Emmanuel Agullo
+ * @author Cedric Castagnede
+ * @date 2010-11-15
+ * @precisions normal z -> c d s
+ *
+ **/
+
+#include "runtime/parsec/include/morse_parsec.h"
+
+/***************************************************************************//**
+ *
+ * @ingroup CORE_MORSE_Complex64_t
+ *
+ **/
+static inline int
+CORE_zlascal_parsec(dague_execution_unit_t *context,
+ dague_execution_context_t *this_task)
+{
+ MORSE_enum *uplo;
+ int *M;
+ int *N;
+ MORSE_Complex64_t *alpha;
+ MORSE_Complex64_t *A;
+ int *LDA;
+
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA);
+
+ CORE_zlascal(*uplo, *M, *N, *alpha, A, *LDA);
+}
+
+void MORSE_TASK_zlascal(const MORSE_option_t *options,
+ MORSE_enum uplo,
+ int m, int n, int nb,
+ MORSE_Complex64_t alpha,
+ const MORSE_desc_t *A, int Am, int An, int lda)
+{
+ dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
+
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zlascal_parsec, "lascal",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR(A, MORSE_Complex64_t, Am, An), INOUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ 0);
+}
+
+
diff --git a/runtime/parsec/codelets/codelet_zlaset.c b/runtime/parsec/codelets/codelet_zlaset.c
index 66f540db439435580999d96c30ddf9f55891a408..8f81ee9a30ac3adbaeb08d864d88e6aba3182992 100644
--- a/runtime/parsec/codelets/codelet_zlaset.c
+++ b/runtime/parsec/codelets/codelet_zlaset.c
@@ -68,17 +68,15 @@ CORE_zlaset_parsec(dague_execution_unit_t *context, dague_execution_context_t *
MORSE_Complex64_t *A;
int *LDA;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_VALUE, &alpha,
- UNPACK_VALUE, &beta,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA
- );
-
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_VALUE, &alpha,
+ UNPACK_VALUE, &beta,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA );
CORE_zlaset(*uplo, *M, *N, *alpha, *beta, A, *LDA);
@@ -92,13 +90,14 @@ void MORSE_TASK_zlaset(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zlaset_parsec, "laset",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &M, VALUE,
- sizeof(int), &N, VALUE,
- sizeof(MORSE_Complex64_t), &alpha, VALUE,
- sizeof(MORSE_Complex64_t), &beta, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
- sizeof(int), &LDA, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zlaset_parsec, "laset",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &M, VALUE,
+ sizeof(int), &N, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ sizeof(MORSE_Complex64_t), &beta, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
+ sizeof(int), &LDA, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zlaset2.c b/runtime/parsec/codelets/codelet_zlaset2.c
index 7ff90dc92d2465aa8fb70d739757da629bfbc556..00986ce77734d5bd0d91c05853635320fa5b6afb 100644
--- a/runtime/parsec/codelets/codelet_zlaset2.c
+++ b/runtime/parsec/codelets/codelet_zlaset2.c
@@ -65,14 +65,14 @@ CORE_zlaset2_parsec(dague_execution_unit_t *context, dague_execution_context_t *
MORSE_Complex64_t *A;
int *LDA;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA );
CORE_zlaset2(*uplo, *M, *N, *alpha, A, *LDA);
@@ -85,12 +85,13 @@ void MORSE_TASK_zlaset2(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zlaset2_parsec, "laset2",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &M, VALUE,
- sizeof(int), &N, VALUE,
- sizeof(MORSE_enum), &alpha, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
- sizeof(int), &LDA, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zlaset2_parsec, "laset2",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &M, VALUE,
+ sizeof(int), &N, VALUE,
+ sizeof(MORSE_enum), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
+ sizeof(int), &LDA, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zlatro.c b/runtime/parsec/codelets/codelet_zlatro.c
new file mode 100644
index 0000000000000000000000000000000000000000..290b8be17b37643be6c18e7c3debb5a725bde0c8
--- /dev/null
+++ b/runtime/parsec/codelets/codelet_zlatro.c
@@ -0,0 +1,76 @@
+/**
+ *
+ * @copyright (c) 2009-2014 The University of Tennessee and The University
+ * of Tennessee Research Foundation.
+ * All rights reserved.
+ * @copyright (c) 2012-2014 Inria. All rights reserved.
+ * @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
+ *
+ **/
+
+/**
+ * @file qwrapper_zlatro.c
+ *
+ * PLASMA core_blas quark wrapper
+ * PLASMA is a software package provided by Univ. of Tennessee,
+ * Univ. of California Berkeley and Univ. of Colorado Denver
+ *
+ * @version 2.8.0
+ * @author Azzam Haidar
+ * @date 2010-11-15
+ * @precisions normal z -> c d s
+ *
+ **/
+#include "runtime/parsec/include/morse_parsec.h"
+
+static inline int
+CORE_zlatro_parsec(dague_execution_unit_t *context,
+ dague_execution_context_t *this_task)
+{
+ MORSE_enum *uplo;
+ MORSE_enum *trans;
+ int *M;
+ int *N;
+ const MORSE_Complex64_t *A;
+ int *LDA;
+ MORSE_Complex64_t *B;
+ int *LDB;
+
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &LDB);
+
+ CORE_zlatro(*uplo, *trans, *M, *N,
+ A, *LDA, B, *LDB);
+}
+
+/***************************************************************************//**
+ *
+ **/
+void MORSE_TASK_zlatro(const MORSE_option_t *options,
+ MORSE_enum uplo, MORSE_enum trans,
+ int m, int n, int mb,
+ const MORSE_desc_t *A, int Am, int An, int lda,
+ const MORSE_desc_t *B, int Bm, int Bn, int ldb)
+{
+ dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
+
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zlatro_parsec, "latro",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR(A, MORSE_Complex64_t, Am, An), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn), OUTPUT | REGION_FULL,
+ sizeof(int), &ldb, VALUE,
+ 0);
+}
diff --git a/runtime/parsec/codelets/codelet_zlauum.c b/runtime/parsec/codelets/codelet_zlauum.c
index 6c936cc8b3600c04e34b78fbe2b7adc281cd9d7c..d11bd483fe9c91d97a38f6fa0b1857d032d0ecc8 100644
--- a/runtime/parsec/codelets/codelet_zlauum.c
+++ b/runtime/parsec/codelets/codelet_zlauum.c
@@ -35,13 +35,12 @@ CORE_zlauum_parsec(dague_execution_unit_t *context, dague_execution_context_t *
MORSE_Complex64_t *A;
int *LDA;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &N,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &N,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA );
CORE_zlauum(*uplo, *N, A, *LDA);
@@ -54,10 +53,11 @@ void MORSE_TASK_zlauum(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zlauum_parsec, "lauum",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zlauum_parsec, "lauum",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zpamm.c b/runtime/parsec/codelets/codelet_zpamm.c
index b15f9eb6842e9bf604fc56608e338ceb612dd249..f8f86af48ae1dfeeb4f23667a2d03e5057e49c51 100644
--- a/runtime/parsec/codelets/codelet_zpamm.c
+++ b/runtime/parsec/codelets/codelet_zpamm.c
@@ -185,23 +185,23 @@ CORE_zpamm_parsec(dague_execution_unit_t *context, dague_execution_context_t *th
MORSE_Complex64_t *W;
int *LDW;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &op,
- UNPACK_VALUE, &side,
- UNPACK_VALUE, &storev,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_VALUE, &K,
- UNPACK_VALUE, &L,
- UNPACK_DATA, &A1,
- UNPACK_VALUE, &LDA1,
- UNPACK_DATA, &A2,
- UNPACK_VALUE, &LDA2,
- UNPACK_DATA, &V,
- UNPACK_VALUE, &LDV,
- UNPACK_DATA, &W,
- UNPACK_VALUE, &LDW
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &op,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &storev,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_VALUE, &K,
+ UNPACK_VALUE, &L,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &LDA1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &LDA2,
+ UNPACK_DATA, &V,
+ UNPACK_VALUE, &LDV,
+ UNPACK_DATA, &W,
+ UNPACK_VALUE, &LDW );
CORE_zpamm( *op, *side, *storev, *M, *N, *K, *L, A1, *LDA1, A2, *LDA2, V, *LDV, W, *LDW);
@@ -219,21 +219,22 @@ MORSE_TASK_zpamm(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zpamm_parsec, "pamm",
- sizeof(int), &op, VALUE,
- sizeof(MORSE_enum), &side, VALUE,
- sizeof(MORSE_enum), &storev, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(int), &l, VALUE,
- PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INPUT | REGION_FULL,
- sizeof(int), &lda1, VALUE,
- PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
- sizeof(int), &lda2, VALUE,
- PASSED_BY_REF, RTBLKADDR( V, MORSE_Complex64_t, Vm, Vn ), INPUT | REGION_FULL,
- sizeof(int), &ldv, VALUE,
- PASSED_BY_REF, RTBLKADDR( W, MORSE_Complex64_t, Wm, Wn ), INOUT | REGION_FULL,
- sizeof(int), &ldw, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zpamm_parsec, "pamm",
+ sizeof(int), &op, VALUE,
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &storev, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &l, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INPUT | REGION_FULL,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR( V, MORSE_Complex64_t, Vm, Vn ), INPUT | REGION_FULL,
+ sizeof(int), &ldv, VALUE,
+ PASSED_BY_REF, RTBLKADDR( W, MORSE_Complex64_t, Wm, Wn ), INOUT | REGION_FULL,
+ sizeof(int), &ldw, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zplghe.c b/runtime/parsec/codelets/codelet_zplghe.c
index 58485eba4fd5c0f883aee0868450745c74bad679..00bc531a33f60f4d199a9c6c196666a08b0d1845 100644
--- a/runtime/parsec/codelets/codelet_zplghe.c
+++ b/runtime/parsec/codelets/codelet_zplghe.c
@@ -35,18 +35,17 @@ CORE_zplghe_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *n0;
unsigned long long int *seed;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &bump,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_VALUE, &bigM,
- UNPACK_VALUE, &m0,
- UNPACK_VALUE, &n0,
- UNPACK_VALUE, &seed
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &bump,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_VALUE, &bigM,
+ UNPACK_VALUE, &m0,
+ UNPACK_VALUE, &n0,
+ UNPACK_VALUE, &seed );
CORE_zplghe( *bump, *m, *n, A, *lda, *bigM, *m0, *n0, *seed );
@@ -59,15 +58,16 @@ void MORSE_TASK_zplghe( const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zplghe_parsec, "zplghe",
- sizeof(double), &bump, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- sizeof(int), &bigM, VALUE,
- sizeof(int), &m0, VALUE,
- sizeof(int), &n0, VALUE,
- sizeof(unsigned long long int), &seed, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zplghe_parsec, "zplghe",
+ sizeof(double), &bump, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ sizeof(int), &bigM, VALUE,
+ sizeof(int), &m0, VALUE,
+ sizeof(int), &n0, VALUE,
+ sizeof(unsigned long long int), &seed, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zplgsy.c b/runtime/parsec/codelets/codelet_zplgsy.c
index d3a11a4bc2c95f221ed8888c2237170466502889..fa4d61fc61fbf57f7e23492f3d79a4857db51c54 100644
--- a/runtime/parsec/codelets/codelet_zplgsy.c
+++ b/runtime/parsec/codelets/codelet_zplgsy.c
@@ -35,17 +35,17 @@ CORE_zplgsy_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *n0;
unsigned long long int *seed;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &bump,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_VALUE, &bigM,
- UNPACK_VALUE, &m0,
- UNPACK_VALUE, &n0,
- UNPACK_VALUE, &seed
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &bump,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_VALUE, &bigM,
+ UNPACK_VALUE, &m0,
+ UNPACK_VALUE, &n0,
+ UNPACK_VALUE, &seed );
CORE_zplgsy( *bump, *m, *n, A, *lda, *bigM, *m0, *n0, *seed );
@@ -58,15 +58,16 @@ void MORSE_TASK_zplgsy( const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zplgsy_parsec, "zplgsy",
- sizeof(MORSE_Complex64_t), &bump, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- sizeof(int), &bigM, VALUE,
- sizeof(int), &m0, VALUE,
- sizeof(int), &n0, VALUE,
- sizeof(unsigned long long int), &seed, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zplgsy_parsec, "zplgsy",
+ sizeof(MORSE_Complex64_t), &bump, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ sizeof(int), &bigM, VALUE,
+ sizeof(int), &m0, VALUE,
+ sizeof(int), &n0, VALUE,
+ sizeof(unsigned long long int), &seed, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zplrnt.c b/runtime/parsec/codelets/codelet_zplrnt.c
index 7f0231912c5774a6223413c1f0d384ed6a915f51..52cf2efb8999f9663dfd60d62dd532bd14414160 100644
--- a/runtime/parsec/codelets/codelet_zplrnt.c
+++ b/runtime/parsec/codelets/codelet_zplrnt.c
@@ -34,17 +34,16 @@ CORE_zplrnt_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *n0;
unsigned long long int *seed;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_VALUE, &bigM,
- UNPACK_VALUE, &m0,
- UNPACK_VALUE, &n0,
- UNPACK_VALUE, &seed
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_VALUE, &bigM,
+ UNPACK_VALUE, &m0,
+ UNPACK_VALUE, &n0,
+ UNPACK_VALUE, &seed );
CORE_zplrnt( *m, *n, A, *lda, *bigM, *m0, *n0, *seed );
@@ -57,14 +56,15 @@ void MORSE_TASK_zplrnt( const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zplrnt_parsec, "zplrnt",
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- sizeof(int), &bigM, VALUE,
- sizeof(int), &m0, VALUE,
- sizeof(int), &n0, VALUE,
- sizeof(unsigned long long int), &seed, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zplrnt_parsec, "zplrnt",
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ sizeof(int), &bigM, VALUE,
+ sizeof(int), &m0, VALUE,
+ sizeof(int), &n0, VALUE,
+ sizeof(unsigned long long int), &seed, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zplssq.c b/runtime/parsec/codelets/codelet_zplssq.c
index 662e9b7755d3b77b5310571f9236486760cb6964..935bb1528bce87a3d5cd14e5969966e869814b54 100644
--- a/runtime/parsec/codelets/codelet_zplssq.c
+++ b/runtime/parsec/codelets/codelet_zplssq.c
@@ -60,10 +60,10 @@ CORE_zplssq_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
double *SCALESUMSQ;
double *SCLSSQ;
- dague_dtd_unpack_args(this_task,
- UNPACK_DATA, &SCALESUMSQ,
- UNPACK_DATA, &SCLSSQ
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_DATA, &SCALESUMSQ,
+ UNPACK_DATA, &SCLSSQ );
if( SCLSSQ[0] < SCALESUMSQ[0] ) {
SCLSSQ[1] = SCALESUMSQ[1] + (SCLSSQ[1] * (( SCLSSQ[0] / SCALESUMSQ[0] ) * ( SCLSSQ[0] / SCALESUMSQ[0] )));
@@ -81,10 +81,11 @@ void MORSE_TASK_zplssq( const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zplssq_parsec, "plssq",
- PASSED_BY_REF, RTBLKADDR( SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn ), INPUT | REGION_FULL,
- PASSED_BY_REF, RTBLKADDR( SCLSSQ, double, SCLSSQm, SCLSSQn ), INOUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zplssq_parsec, "plssq",
+ PASSED_BY_REF, RTBLKADDR( SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn ), INPUT | REGION_FULL,
+ PASSED_BY_REF, RTBLKADDR( SCLSSQ, double, SCLSSQm, SCLSSQn ), INOUT | REGION_FULL,
+ 0);
}
static int
@@ -92,10 +93,9 @@ CORE_zplssq2_parsec(dague_execution_unit_t *context, dague_execution_context_t *
{
double *RESULT;
- dague_dtd_unpack_args(this_task,
- UNPACK_DATA, &RESULT
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_DATA, &RESULT );
RESULT[0] = RESULT[0] * sqrt( RESULT[1] );
@@ -107,7 +107,8 @@ void MORSE_TASK_zplssq2( const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zplssq2_parsec, "plssq2",
- PASSED_BY_REF, RTBLKADDR( RESULT, double, RESULTm, RESULTn ), INOUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zplssq2_parsec, "plssq2",
+ PASSED_BY_REF, RTBLKADDR( RESULT, double, RESULTm, RESULTn ), INOUT | REGION_FULL,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zpotrf.c b/runtime/parsec/codelets/codelet_zpotrf.c
index 050b194c0edf4928e1b73df4062b3d957a56e3f8..bd3f02642dc1f0127664dbff167c081a8be2da2f 100644
--- a/runtime/parsec/codelets/codelet_zpotrf.c
+++ b/runtime/parsec/codelets/codelet_zpotrf.c
@@ -34,14 +34,13 @@ CORE_zpotrf_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *tempkm, *ldak, *iinfo;
MORSE_Complex64_t *A;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &tempkm,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &ldak,
- UNPACK_VALUE, &iinfo
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &tempkm,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &ldak,
+ UNPACK_VALUE, &iinfo );
CORE_zpotrf(*uplo, *tempkm, A, *ldak, iinfo);
@@ -55,11 +54,12 @@ void MORSE_TASK_zpotrf(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zpotrf_parsec, "potrf",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- sizeof(int), &iinfo, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zpotrf_parsec, "potrf",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ sizeof(int), &iinfo, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zssssm.c b/runtime/parsec/codelets/codelet_zssssm.c
index 3ef48666459c682d599b8037db819f58055ed550..0e44386e2b30e44c073b37a0288b9ca9ce983b95 100644
--- a/runtime/parsec/codelets/codelet_zssssm.c
+++ b/runtime/parsec/codelets/codelet_zssssm.c
@@ -41,24 +41,23 @@ CORE_zssssm_parsec(dague_execution_unit_t *context, dague_execution_context_t *
int *ldl2;
int *IPIV;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m1,
- UNPACK_VALUE, &n1,
- UNPACK_VALUE, &m2,
- UNPACK_VALUE, &n2,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A1,
- UNPACK_VALUE, &lda1,
- UNPACK_DATA, &A2,
- UNPACK_VALUE, &lda2,
- UNPACK_DATA, &L1,
- UNPACK_VALUE, &ldl1,
- UNPACK_DATA, &L2,
- UNPACK_VALUE, &ldl2,
- UNPACK_SCRATCH, &IPIV
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m1,
+ UNPACK_VALUE, &n1,
+ UNPACK_VALUE, &m2,
+ UNPACK_VALUE, &n2,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &lda1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &lda2,
+ UNPACK_DATA, &L1,
+ UNPACK_VALUE, &ldl1,
+ UNPACK_DATA, &L2,
+ UNPACK_VALUE, &ldl2,
+ UNPACK_SCRATCH, &IPIV );
CORE_zssssm(*m1, *n1, *m2, *n2, *k, *ib, A1, *lda1, A2, *lda2, L1, *ldl1, L2, *ldl2, IPIV);
@@ -75,21 +74,22 @@ void MORSE_TASK_zssssm(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zssssm_parsec, "ssssm",
- sizeof(int), &m1, VALUE,
- sizeof(int), &n1, VALUE,
- sizeof(int), &m2, VALUE,
- sizeof(int), &n2, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
- sizeof(int), &lda1, VALUE,
- PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
- sizeof(int), &lda2, VALUE,
- PASSED_BY_REF, RTBLKADDR( L1, MORSE_Complex64_t, L1m, L1n ), INPUT | REGION_FULL,
- sizeof(int), &ldl1, VALUE,
- PASSED_BY_REF, RTBLKADDR( L2, MORSE_Complex64_t, L2m, L2n ), INPUT | REGION_FULL,
- sizeof(int), &ldl2, VALUE,
- sizeof(int)*nb, IPIV, SCRATCH,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zssssm_parsec, "ssssm",
+ sizeof(int), &m1, VALUE,
+ sizeof(int), &n1, VALUE,
+ sizeof(int), &m2, VALUE,
+ sizeof(int), &n2, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR( L1, MORSE_Complex64_t, L1m, L1n ), INPUT | REGION_FULL,
+ sizeof(int), &ldl1, VALUE,
+ PASSED_BY_REF, RTBLKADDR( L2, MORSE_Complex64_t, L2m, L2n ), INPUT | REGION_FULL,
+ sizeof(int), &ldl2, VALUE,
+ sizeof(int)*nb, IPIV, SCRATCH,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zsymm.c b/runtime/parsec/codelets/codelet_zsymm.c
index 70bef988d266fe308caefaaba0a5a40680765701..63eeb66253984c7e5b0788998039d396d49701e6 100644
--- a/runtime/parsec/codelets/codelet_zsymm.c
+++ b/runtime/parsec/codelets/codelet_zsymm.c
@@ -38,22 +38,20 @@ CORE_zsymm_parsec(dague_execution_unit_t *context, dague_execution_context_t * t
MORSE_Complex64_t *C;
int *LDC;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &side,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &LDB,
- UNPACK_VALUE, &beta,
- UNPACK_DATA, &C,
- UNPACK_VALUE, &LDC
- );
-
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &LDB,
+ UNPACK_VALUE, &beta,
+ UNPACK_DATA, &C,
+ UNPACK_VALUE, &LDC );
CORE_zsymm(*side, *uplo, *M, *N,
*alpha, A, *LDA,
@@ -72,19 +70,19 @@ void MORSE_TASK_zsymm(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
-
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zsymm_parsec, "symm",
- sizeof(MORSE_enum), &side, VALUE,
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(MORSE_Complex64_t), &alpha, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INPUT | REGION_FULL,
- sizeof(int), &ldb, VALUE,
- sizeof(MORSE_Complex64_t), &beta, VALUE,
- PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
- sizeof(int), &ldc, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zsymm_parsec, "symm",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INPUT | REGION_FULL,
+ sizeof(int), &ldb, VALUE,
+ sizeof(MORSE_Complex64_t), &beta, VALUE,
+ PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
+ sizeof(int), &ldc, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zsyr2k.c b/runtime/parsec/codelets/codelet_zsyr2k.c
index 3cae995d28d1d79be540b760a0000f9516b829aa..72fdbb1fc889f793d06006dbce09a85150efb55f 100644
--- a/runtime/parsec/codelets/codelet_zsyr2k.c
+++ b/runtime/parsec/codelets/codelet_zsyr2k.c
@@ -38,21 +38,20 @@ CORE_zsyr2k_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *C;
int *ldc;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &ldb,
- UNPACK_VALUE, &beta,
- UNPACK_DATA, &C,
- UNPACK_VALUE, &ldc
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &ldb,
+ UNPACK_VALUE, &beta,
+ UNPACK_DATA, &C,
+ UNPACK_VALUE, &ldc );
CORE_zsyr2k(*uplo, *trans, *n, *k,
*alpha, A, *lda,
@@ -71,18 +70,19 @@ void MORSE_TASK_zsyr2k(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zsyr2k_parsec, "syr2k",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(MORSE_enum), &trans, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(MORSE_Complex64_t), &alpha, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INPUT | REGION_FULL,
- sizeof(int), &ldb, VALUE,
- sizeof(MORSE_Complex64_t), &beta, VALUE,
- PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
- sizeof(int), &ldc, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zsyr2k_parsec, "syr2k",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INPUT | REGION_FULL,
+ sizeof(int), &ldb, VALUE,
+ sizeof(MORSE_Complex64_t), &beta, VALUE,
+ PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
+ sizeof(int), &ldc, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zsyrk.c b/runtime/parsec/codelets/codelet_zsyrk.c
index 123925f3822bcc734690d106007935eee848f1f1..510e096f8d139ba883aa8dbce34e551084e4545c 100644
--- a/runtime/parsec/codelets/codelet_zsyrk.c
+++ b/runtime/parsec/codelets/codelet_zsyrk.c
@@ -36,19 +36,18 @@ CORE_zsyrk_parsec(dague_execution_unit_t *context, dague_execution_context_t *th
MORSE_Complex64_t *C;
int *ldc;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_VALUE, &beta,
- UNPACK_DATA, &C,
- UNPACK_VALUE, &ldc
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_VALUE, &beta,
+ UNPACK_DATA, &C,
+ UNPACK_VALUE, &ldc );
CORE_zsyrk(*uplo, *trans, *n, *k,
*alpha, A, *lda,
@@ -65,16 +64,17 @@ void MORSE_TASK_zsyrk(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zsyrk_parsec, "syrk",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(MORSE_enum), &trans, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(MORSE_Complex64_t), &alpha, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- sizeof(MORSE_Complex64_t), &beta, VALUE,
- PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
- sizeof(int), &ldc, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zsyrk_parsec, "syrk",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ sizeof(MORSE_Complex64_t), &beta, VALUE,
+ PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
+ sizeof(int), &ldc, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zsyssq.c b/runtime/parsec/codelets/codelet_zsyssq.c
index d0bf4b4f173ed918daf08a29886d791349185270..5db5be616979cda7e72b2eee1f054fd0fb12e85f 100644
--- a/runtime/parsec/codelets/codelet_zsyssq.c
+++ b/runtime/parsec/codelets/codelet_zsyssq.c
@@ -31,14 +31,13 @@ CORE_zsyssq_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *lda;
double *SCALESUMSQ;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &n,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &SCALESUMSQ
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &n,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &SCALESUMSQ );
CORE_zsyssq( *uplo, *n, A, *lda, &SCALESUMSQ[0], &SCALESUMSQ[1]);
@@ -52,11 +51,12 @@ void MORSE_TASK_zsyssq( const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zsyssq_parsec, "syssq",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn ), INOUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zsyssq_parsec, "syssq",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn ), INOUT | REGION_FULL,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zsytrf_nopiv.c b/runtime/parsec/codelets/codelet_zsytrf_nopiv.c
index 17f1a26a34b8be53f1efd79f9043c80e74709811..1c70a7c1f433fcdd237e0fdc42e337082479c620 100644
--- a/runtime/parsec/codelets/codelet_zsytrf_nopiv.c
+++ b/runtime/parsec/codelets/codelet_zsytrf_nopiv.c
@@ -32,14 +32,13 @@ CORE_zsytrf_nopiv_parsec(dague_execution_unit_t *context, dague_execution_contex
int *iinfo;
int info;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &n,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_VALUE, &iinfo
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &n,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_VALUE, &iinfo );
CORE_zsytf2_nopiv(*uplo, *n, A, *lda);
@@ -53,7 +52,8 @@ void MORSE_TASK_zsytrf_nopiv(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zsytrf_nopiv_parsec, "sytrf_nopiv",
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zsytrf_nopiv_parsec, "sytrf_nopiv",
sizeof(MORSE_enum), &uplo, VALUE,
sizeof(int), &n, VALUE,
PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
diff --git a/runtime/parsec/codelets/codelet_ztile_zero.c b/runtime/parsec/codelets/codelet_ztile_zero.c
index 4503ccff46b7a7bff67e8ac4f1fc86febb58c23e..366777c23cfc3e7abce17b7b2dc886672f76422e 100644
--- a/runtime/parsec/codelets/codelet_ztile_zero.c
+++ b/runtime/parsec/codelets/codelet_ztile_zero.c
@@ -33,14 +33,14 @@ CORE_ztile_zero_parsec(dague_execution_unit_t *context, dague_execution_context_
int *lda;
int x, y;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &X1,
- UNPACK_VALUE, &X2,
- UNPACK_VALUE, &Y1,
- UNPACK_VALUE, &Y2,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &X1,
+ UNPACK_VALUE, &X2,
+ UNPACK_VALUE, &Y1,
+ UNPACK_VALUE, &Y2,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda );
for (x = *X1; x < *X2; x++)
for (y = *Y1; y < *Y2; y++)
@@ -55,12 +55,13 @@ void MORSE_TASK_ztile_zero(const const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_ztile_zero_parsec, "tile zero",
- sizeof(int), &X1, VALUE,
- sizeof(int), &X2, VALUE,
- sizeof(int), &Y1, VALUE,
- sizeof(int), &Y2, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztile_zero_parsec, "tile zero",
+ sizeof(int), &X1, VALUE,
+ sizeof(int), &X2, VALUE,
+ sizeof(int), &Y1, VALUE,
+ sizeof(int), &Y2, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), OUTPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_ztradd.c b/runtime/parsec/codelets/codelet_ztradd.c
index 93634fc90e15bfcfc4fe88165a8ab3690931b4aa..6cc12eaa15331e989aba5d952f6160997d64beff 100644
--- a/runtime/parsec/codelets/codelet_ztradd.c
+++ b/runtime/parsec/codelets/codelet_ztradd.c
@@ -40,20 +40,18 @@ CORE_ztradd_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *B;
int *LDB;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA,
- UNPACK_VALUE, &beta,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &LDB
- );
-
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_VALUE, &beta,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &LDB );
CORE_ztradd(*uplo, *trans, *M, *N, *alpha, A, *LDA, *beta, B, *LDB);
@@ -127,7 +125,7 @@ void MORSE_TASK_ztradd(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(
+ dague_insert_task(
DAGUE_dtd_handle, CORE_ztradd_parsec, "tradd",
sizeof(MORSE_enum), &uplo, VALUE,
sizeof(MORSE_enum), &trans, VALUE,
diff --git a/runtime/parsec/codelets/codelet_ztrasm.c b/runtime/parsec/codelets/codelet_ztrasm.c
index 31990e484fbcc4164a00b62c725f14313c5dbbc1..91646d1df81ba781d0e23fe496ec3304811e97a1 100644
--- a/runtime/parsec/codelets/codelet_ztrasm.c
+++ b/runtime/parsec/codelets/codelet_ztrasm.c
@@ -34,16 +34,16 @@ CORE_ztrasm_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *lda;
double *work;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &storev,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &diag,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &work
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &storev,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &diag,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &work );
CORE_ztrasm(*storev, *uplo, *diag, *M, *N, A, *lda, work);
@@ -57,14 +57,15 @@ void MORSE_TASK_ztrasm(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_ztrasm_parsec, "trasm",
- sizeof(MORSE_enum), &storev, VALUE,
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(MORSE_enum), &diag, VALUE,
- sizeof(int), &M, VALUE,
- sizeof(int), &N, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), INOUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztrasm_parsec, "trasm",
+ sizeof(MORSE_enum), &storev, VALUE,
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(MORSE_enum), &diag, VALUE,
+ sizeof(int), &M, VALUE,
+ sizeof(int), &N, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( B, double, Bm, Bn ), INOUT | REGION_FULL,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_ztrmm.c b/runtime/parsec/codelets/codelet_ztrmm.c
index 4061d0e5919eb38ba7171bbedd30c333a6fc7541..8b67404ab5ae582d7dca44fcad976ccc33a52188 100644
--- a/runtime/parsec/codelets/codelet_ztrmm.c
+++ b/runtime/parsec/codelets/codelet_ztrmm.c
@@ -37,20 +37,19 @@ CORE_ztrmm_parsec(dague_execution_unit_t *context, dague_execution_context_t *th
MORSE_Complex64_t *B;
int *LDB;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &side,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &transA,
- UNPACK_VALUE, &diag,
- UNPACK_VALUE, &M,
- UNPACK_VALUE, &N,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA,
- UNPACK_DATA, &B,
- UNPACK_VALUE, &LDB
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &transA,
+ UNPACK_VALUE, &diag,
+ UNPACK_VALUE, &M,
+ UNPACK_VALUE, &N,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_DATA, &B,
+ UNPACK_VALUE, &LDB );
CORE_ztrmm(*side, *uplo,
*transA, *diag,
@@ -69,17 +68,18 @@ void MORSE_TASK_ztrmm(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_ztrmm_parsec, "trmm",
- sizeof(MORSE_enum), &side, VALUE,
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(MORSE_enum), &transA, VALUE,
- sizeof(MORSE_enum), &diag, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(MORSE_Complex64_t), &alpha, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INOUT | REGION_FULL,
- sizeof(int), &ldb, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztrmm_parsec, "trmm",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(MORSE_enum), &transA, VALUE,
+ sizeof(MORSE_enum), &diag, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INOUT | REGION_FULL,
+ sizeof(int), &ldb, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_ztrsm.c b/runtime/parsec/codelets/codelet_ztrsm.c
index d970d10658a5a32cdceb8057d42ef70cd0c9f98e..aadddb98c052b92b48f7b879b5b93d94de8248b9 100644
--- a/runtime/parsec/codelets/codelet_ztrsm.c
+++ b/runtime/parsec/codelets/codelet_ztrsm.c
@@ -31,19 +31,19 @@ CORE_ztrsm_parsec(dague_execution_unit_t *context, dague_execution_context_t *th
MORSE_Complex64_t *T;
MORSE_Complex64_t *C;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &side,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &diag,
- UNPACK_VALUE, &tempmm,
- UNPACK_VALUE, &nb,
- UNPACK_VALUE, &alpha,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldak,
- UNPACK_DATA, &C,
- UNPACK_VALUE, &ldam
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &diag,
+ UNPACK_VALUE, &tempmm,
+ UNPACK_VALUE, &nb,
+ UNPACK_VALUE, &alpha,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldak,
+ UNPACK_DATA, &C,
+ UNPACK_VALUE, &ldam );
CORE_ztrsm(*side, *uplo, *trans, *diag,
*tempmm, *nb, *alpha, T, *ldak,
@@ -60,17 +60,18 @@ void MORSE_TASK_ztrsm(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_ztrsm_parsec, "Trsm",
- sizeof(MORSE_enum), &side, VALUE,
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(MORSE_enum), &transA, VALUE,
- sizeof(MORSE_enum), &diag, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(MORSE_Complex64_t), &alpha, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INOUT | REGION_FULL,
- sizeof(int), &ldb, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztrsm_parsec, "Trsm",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(MORSE_enum), &transA, VALUE,
+ sizeof(MORSE_enum), &diag, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( B, MORSE_Complex64_t, Bm, Bn ), INOUT | REGION_FULL,
+ sizeof(int), &ldb, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_ztrssq.c b/runtime/parsec/codelets/codelet_ztrssq.c
index ee721b67421585d5f768eee3cca49627781b9b0a..0dd120420b6929c3a106b7ad7418d04096dd5d82 100644
--- a/runtime/parsec/codelets/codelet_ztrssq.c
+++ b/runtime/parsec/codelets/codelet_ztrssq.c
@@ -33,16 +33,15 @@ CORE_ztrssq_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *lda;
double *SCALESUMSQ;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &diag,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &SCALESUMSQ
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &diag,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &SCALESUMSQ );
CORE_ztrssq( *uplo, *diag, *m, *n, A, *lda, &SCALESUMSQ[0], &SCALESUMSQ[1]);
@@ -57,13 +56,14 @@ void MORSE_TASK_ztrssq( const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_ztrssq_parsec, "trssq",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(MORSE_enum), &diag, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn ), INOUT | REGION_FULL,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztrssq_parsec, "trssq",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(MORSE_enum), &diag, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn ), INOUT | REGION_FULL,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_ztrtri.c b/runtime/parsec/codelets/codelet_ztrtri.c
index 0fdc442d2f8d20f53c2dbdf0ffdb14f7379bbb7c..d296e2105f110e0ab0c423ad1010f1a5aef4df44 100644
--- a/runtime/parsec/codelets/codelet_ztrtri.c
+++ b/runtime/parsec/codelets/codelet_ztrtri.c
@@ -33,15 +33,14 @@ CORE_ztrtri_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int *iinfo;
int info;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &uplo,
- UNPACK_VALUE, &diag,
- UNPACK_VALUE, &N,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &LDA,
- UNPACK_VALUE, &iinfo
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &uplo,
+ UNPACK_VALUE, &diag,
+ UNPACK_VALUE, &N,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &LDA,
+ UNPACK_VALUE, &iinfo );
CORE_ztrtri(*uplo, *diag, *N, A, *LDA, &info);
@@ -56,12 +55,13 @@ void MORSE_TASK_ztrtri(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_ztrtri_parsec, "trtri",
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(MORSE_enum), &diag, VALUE,
- sizeof(int), &n, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- sizeof(int), &iinfo, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztrtri_parsec, "trtri",
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(MORSE_enum), &diag, VALUE,
+ sizeof(int), &n, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ sizeof(int), &iinfo, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_ztslqt.c b/runtime/parsec/codelets/codelet_ztslqt.c
index bea32cbaf9edf3718b1d92f922b7631f3b0651f4..bebbb862feea1ef62a3fcc6a7edb64c8bd8e87d1 100644
--- a/runtime/parsec/codelets/codelet_ztslqt.c
+++ b/runtime/parsec/codelets/codelet_ztslqt.c
@@ -37,20 +37,19 @@ CORE_ztslqt_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *TAU;
MORSE_Complex64_t *WORK;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A1,
- UNPACK_VALUE, &lda1,
- UNPACK_DATA, &A2,
- UNPACK_VALUE, &lda2,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_SCRATCH, &TAU,
- UNPACK_SCRATCH, &WORK
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &lda1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &lda2,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &TAU,
+ UNPACK_SCRATCH, &WORK );
CORE_ztslqt(*m, *n, *ib, A1, *lda1, A2, *lda2, T, *ldt, TAU, WORK);
@@ -65,18 +64,18 @@ void MORSE_TASK_ztslqt(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
-
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_ztslqt_parsec, "tslqt",
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
- sizeof(int), &lda1, VALUE,
- PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
- sizeof(int), &lda2, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztslqt_parsec, "tslqt",
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_ztsmlq.c b/runtime/parsec/codelets/codelet_ztsmlq.c
index 85de91aa0d1e2d6e23c9a519c26ed239b871ddf0..eaae120c5608975757f6a67cf51f9d9774cc79c4 100644
--- a/runtime/parsec/codelets/codelet_ztsmlq.c
+++ b/runtime/parsec/codelets/codelet_ztsmlq.c
@@ -44,29 +44,26 @@ CORE_ztsmlq_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *WORK;
int *ldwork;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &side,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &m1,
- UNPACK_VALUE, &n1,
- UNPACK_VALUE, &m2,
- UNPACK_VALUE, &n2,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A1,
- UNPACK_VALUE, &lda1,
- UNPACK_DATA, &A2,
- UNPACK_VALUE, &lda2,
- UNPACK_DATA, &V,
- UNPACK_VALUE, &ldv,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_SCRATCH, &WORK,
- UNPACK_VALUE, &ldwork
- );
-
-
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &m1,
+ UNPACK_VALUE, &n1,
+ UNPACK_VALUE, &m2,
+ UNPACK_VALUE, &n2,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &lda1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &lda2,
+ UNPACK_DATA, &V,
+ UNPACK_VALUE, &ldv,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &WORK,
+ UNPACK_VALUE, &ldwork );
CORE_ztsmlq(*side, *trans, *m1, *n1, *m2, *n2, *k, *ib,
A1, *lda1, A2, *lda2, V, *ldv, T, *ldt, WORK, *ldwork);
@@ -86,24 +83,25 @@ void MORSE_TASK_ztsmlq(const MORSE_option_t *options,
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_ztsmlq_parsec, "tsmlq",
- sizeof(MORSE_enum), &side, VALUE,
- sizeof(MORSE_enum), &trans, VALUE,
- sizeof(int), &m1, VALUE,
- sizeof(int), &n1, VALUE,
- sizeof(int), &m2, VALUE,
- sizeof(int), &n2, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
- sizeof(int), &lda1, VALUE,
- PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
- sizeof(int), &lda2, VALUE,
- PASSED_BY_REF, RTBLKADDR( V, MORSE_Complex64_t, Vm, Vn ), INPUT | REGION_FULL,
- sizeof(int), &ldv, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- sizeof(int), &ldwork, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztsmlq_parsec, "tsmlq",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &m1, VALUE,
+ sizeof(int), &n1, VALUE,
+ sizeof(int), &m2, VALUE,
+ sizeof(int), &n2, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR( V, MORSE_Complex64_t, Vm, Vn ), INPUT | REGION_FULL,
+ sizeof(int), &ldv, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ sizeof(int), &ldwork, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_ztsmlq_hetra1.c b/runtime/parsec/codelets/codelet_ztsmlq_hetra1.c
new file mode 100644
index 0000000000000000000000000000000000000000..5ec643a18ed0ad4bb8af68967e12f70f86cf7147
--- /dev/null
+++ b/runtime/parsec/codelets/codelet_ztsmlq_hetra1.c
@@ -0,0 +1,112 @@
+/**
+ *
+ * @copyright (c) 2009-2014 The University of Tennessee and The University
+ * of Tennessee Research Foundation.
+ * All rights reserved.
+ * @copyright (c) 2012-2014 Inria. All rights reserved.
+ * @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
+ *
+ **/
+
+/**
+ *
+ * @file codelet_ztsmlq_hetra1.c
+ *
+ * PLASMA core_blas quark wrapper
+ * PLASMA is a software package provided by Univ. of Tennessee,
+ * Univ. of California Berkeley and Univ. of Colorado Denver
+ *
+ * @version 2.8.0
+ * @author Hatem Ltaief
+ * @author Mathieu Faverge
+ * @author Jakub Kurzak
+ * @author Azzam Haidar
+ * @date 2010-11-15
+ * @precisions normal z -> c d s
+ *
+ **/
+#include "runtime/parsec/include/morse_parsec.h"
+
+static inline int
+CORE_ztsmlq_hetra1_parsec(dague_execution_unit_t *context,
+ dague_execution_context_t *this_task)
+{
+ MORSE_enum *side;
+ MORSE_enum *trans;
+ int *m1;
+ int *n1;
+ int *m2;
+ int *n2;
+ int *k;
+ int *ib;
+ MORSE_Complex64_t *A1;
+ int *lda1;
+ MORSE_Complex64_t *A2;
+ int *lda2;
+ MORSE_Complex64_t *V;
+ int *ldv;
+ MORSE_Complex64_t *T;
+ int *ldt;
+ MORSE_Complex64_t *WORK;
+ int *ldwork;
+
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &m1,
+ UNPACK_VALUE, &n1,
+ UNPACK_VALUE, &m2,
+ UNPACK_VALUE, &n2,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &lda1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &lda2,
+ UNPACK_DATA, &V,
+ UNPACK_VALUE, &ldv,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &WORK,
+ UNPACK_VALUE, &ldwork);
+
+ CORE_ztsmlq_hetra1(*side, *trans, *m1, *n1, *m2, *n2, *k, *ib,
+ A1, *lda1, A2, *lda2,
+ V, *ldv, T, *ldt,
+ WORK, *ldwork);
+}
+
+void MORSE_TASK_ztsmlq_hetra1(const MORSE_option_t *options,
+ MORSE_enum side, MORSE_enum trans,
+ int m1, int n1, int m2, int n2, int k, int ib, int nb,
+ const MORSE_desc_t *A1, int A1m, int A1n, int lda1,
+ const MORSE_desc_t *A2, int A2m, int A2n, int lda2,
+ const MORSE_desc_t *V, int Vm, int Vn, int ldv,
+ const MORSE_desc_t *T, int Tm, int Tn, int ldt)
+{
+ dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
+ int ldwork = side == MorseLeft ? ib : nb;
+
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztsmlq_hetra1_parsec, "tsmlq_hetra1",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &m1, VALUE,
+ sizeof(int), &n1, VALUE,
+ sizeof(int), &m2, VALUE,
+ sizeof(int), &n2, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n), INOUT | REGION_U | REGION_D,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn), INPUT | REGION_FULL,
+ sizeof(int), &ldv, VALUE,
+ PASSED_BY_REF, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn), INPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ sizeof(int), &ldwork, VALUE,
+ 0);
+}
diff --git a/runtime/parsec/codelets/codelet_ztsmqr.c b/runtime/parsec/codelets/codelet_ztsmqr.c
index 1d2e782e29b7f4052783975d9182936173b5d2e7..7369c2002e1d0f9e699b6817348d32ab825ed061 100644
--- a/runtime/parsec/codelets/codelet_ztsmqr.c
+++ b/runtime/parsec/codelets/codelet_ztsmqr.c
@@ -44,27 +44,26 @@ CORE_ztsmqr_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *WORK;
int *ldwork;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &side,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &m1,
- UNPACK_VALUE, &n1,
- UNPACK_VALUE, &m2,
- UNPACK_VALUE, &n2,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A1,
- UNPACK_VALUE, &lda1,
- UNPACK_DATA, &A2,
- UNPACK_VALUE, &lda2,
- UNPACK_DATA, &V,
- UNPACK_VALUE, &ldv,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_SCRATCH, &WORK,
- UNPACK_VALUE, &ldwork
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &m1,
+ UNPACK_VALUE, &n1,
+ UNPACK_VALUE, &m2,
+ UNPACK_VALUE, &n2,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &lda1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &lda2,
+ UNPACK_DATA, &V,
+ UNPACK_VALUE, &ldv,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &WORK,
+ UNPACK_VALUE, &ldwork );
CORE_ztsmqr(*side, *trans, *m1, *n1, *m2, *n2, *k, *ib,
A1, *lda1, A2, *lda2, V, *ldv, T, *ldt, WORK, *ldwork);
@@ -84,25 +83,25 @@ void MORSE_TASK_ztsmqr(const MORSE_option_t *options,
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
-
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_ztsmqr_parsec, "tsmqr",
- sizeof(MORSE_enum), &side, VALUE,
- sizeof(MORSE_enum), &trans, VALUE,
- sizeof(int), &m1, VALUE,
- sizeof(int), &n1, VALUE,
- sizeof(int), &m2, VALUE,
- sizeof(int), &n2, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
- sizeof(int), &lda1, VALUE,
- PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
- sizeof(int), &lda2, VALUE,
- PASSED_BY_REF, RTBLKADDR( V, MORSE_Complex64_t, Vm, Vn ), INPUT | REGION_FULL,
- sizeof(int), &ldv, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- sizeof(int), &ldwork, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztsmqr_parsec, "tsmqr",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &m1, VALUE,
+ sizeof(int), &n1, VALUE,
+ sizeof(int), &m2, VALUE,
+ sizeof(int), &n2, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR( V, MORSE_Complex64_t, Vm, Vn ), INPUT | REGION_FULL,
+ sizeof(int), &ldv, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ sizeof(int), &ldwork, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_ztsmqr_hetra1.c b/runtime/parsec/codelets/codelet_ztsmqr_hetra1.c
new file mode 100644
index 0000000000000000000000000000000000000000..72045d8f101e26216933f879b6ad3f75c896c29a
--- /dev/null
+++ b/runtime/parsec/codelets/codelet_ztsmqr_hetra1.c
@@ -0,0 +1,112 @@
+/**
+ *
+ * @copyright (c) 2009-2014 The University of Tennessee and The University
+ * of Tennessee Research Foundation.
+ * All rights reserved.
+ * @copyright (c) 2012-2014 Inria. All rights reserved.
+ * @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
+ *
+ **/
+
+/**
+ *
+ * @file codelets_ztsmqr_hetra1.c
+ *
+ * PLASMA core_blas quark wrapper
+ * PLASMA is a software package provided by Univ. of Tennessee,
+ * Univ. of California Berkeley and Univ. of Colorado Denver
+ *
+ * @version 2.8.0
+ * @author Hatem Ltaief
+ * @author Mathieu Faverge
+ * @author Jakub Kurzak
+ * @author Azzam Haidar
+ * @date 2010-11-15
+ * @precisions normal z -> c d s
+ *
+ **/
+#include "runtime/parsec/include/morse_parsec.h"
+
+static inline int
+CORE_ztsmqr_hetra1_parsec(dague_execution_unit_t *context,
+ dague_execution_context_t *this_task)
+{
+ MORSE_enum *side;
+ MORSE_enum *trans;
+ int *m1;
+ int *n1;
+ int *m2;
+ int *n2;
+ int *k;
+ int *ib;
+ MORSE_Complex64_t *A1;
+ int *lda1;
+ MORSE_Complex64_t *A2;
+ int *lda2;
+ MORSE_Complex64_t *V;
+ int *ldv;
+ MORSE_Complex64_t *T;
+ int *ldt;
+ MORSE_Complex64_t *WORK;
+ int *ldwork;
+
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &m1,
+ UNPACK_VALUE, &n1,
+ UNPACK_VALUE, &m2,
+ UNPACK_VALUE, &n2,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &lda1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &lda2,
+ UNPACK_DATA, &V,
+ UNPACK_VALUE, &ldv,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &WORK,
+ UNPACK_VALUE, &ldwork);
+
+ CORE_ztsmqr_hetra1(*side, *trans, *m1, *n1, *m2, *n2, *k, *ib,
+ A1, *lda1, A2, *lda2,
+ V, *ldv, T, *ldt,
+ WORK, *ldwork);
+}
+
+void MORSE_TASK_ztsmqr_hetra1(const MORSE_option_t *options,
+ MORSE_enum side, MORSE_enum trans,
+ int m1, int n1, int m2, int n2, int k, int ib, int nb,
+ const MORSE_desc_t *A1, int A1m, int A1n, int lda1,
+ const MORSE_desc_t *A2, int A2m, int A2n, int lda2,
+ const MORSE_desc_t *V, int Vm, int Vn, int ldv,
+ const MORSE_desc_t *T, int Tm, int Tn, int ldt)
+{
+ dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
+ int ldwork = side == MorseLeft ? ib : nb;
+
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztsmqr_hetra1_parsec, "tsmqr_hetra1",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &m1, VALUE,
+ sizeof(int), &n1, VALUE,
+ sizeof(int), &m2, VALUE,
+ sizeof(int), &n2, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR(A1, MORSE_Complex64_t, A1m, A1n), INOUT | REGION_L | REGION_D,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR(A2, MORSE_Complex64_t, A2m, A2n), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR(V, MORSE_Complex64_t, Vm, Vn), INPUT | REGION_FULL,
+ sizeof(int), &ldv, VALUE,
+ PASSED_BY_REF, RTBLKADDR(T, MORSE_Complex64_t, Tm, Tn), INPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ sizeof(int), &ldwork, VALUE,
+ 0);
+}
diff --git a/runtime/parsec/codelets/codelet_ztsqrt.c b/runtime/parsec/codelets/codelet_ztsqrt.c
index 9729db91c97556bc366b5e280f2b65e21960c47b..22a01de1f13053e3a22a3ebde028d6f74c27806b 100644
--- a/runtime/parsec/codelets/codelet_ztsqrt.c
+++ b/runtime/parsec/codelets/codelet_ztsqrt.c
@@ -37,20 +37,19 @@ CORE_ztsqrt_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *TAU;
MORSE_Complex64_t *WORK;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A1,
- UNPACK_VALUE, &lda1,
- UNPACK_DATA, &A2,
- UNPACK_VALUE, &lda2,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_SCRATCH, &TAU,
- UNPACK_SCRATCH, &WORK
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &lda1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &lda2,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &TAU,
+ UNPACK_SCRATCH, &WORK );
CORE_ztsqrt(*m, *n, *ib, A1, *lda1, A2, *lda2, T, *ldt, TAU, WORK);
@@ -65,18 +64,18 @@ void MORSE_TASK_ztsqrt(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
-
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_ztsqrt_parsec, "tsqrt",
- sizeof(MORSE_enum), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_D | REGION_U,
- sizeof(int), &lda1, VALUE,
- PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
- sizeof(int), &lda2, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztsqrt_parsec, "tsqrt",
+ sizeof(MORSE_enum), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_D | REGION_U,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_ztstrf.c b/runtime/parsec/codelets/codelet_ztstrf.c
index 2e4dcccd0ddd503a7c19cda7850ec7f499a8b6d7..fccfd039759169c5d4da3c4c10d7dcb22de014a1 100644
--- a/runtime/parsec/codelets/codelet_ztstrf.c
+++ b/runtime/parsec/codelets/codelet_ztstrf.c
@@ -43,24 +43,23 @@ CORE_ztstrf_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
int info;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &ib,
- UNPACK_VALUE, &nb,
- UNPACK_DATA, &U,
- UNPACK_VALUE, &ldu,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &L,
- UNPACK_VALUE, &ldl,
- UNPACK_SCRATCH, &IPIV,
- UNPACK_SCRATCH, &WORK,
- UNPACK_VALUE, &ldwork,
- UNPACK_VALUE, &check_info,
- UNPACK_VALUE, &iinfo
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &ib,
+ UNPACK_VALUE, &nb,
+ UNPACK_DATA, &U,
+ UNPACK_VALUE, &ldu,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &L,
+ UNPACK_VALUE, &ldl,
+ UNPACK_SCRATCH, &IPIV,
+ UNPACK_SCRATCH, &WORK,
+ UNPACK_VALUE, &ldwork,
+ UNPACK_VALUE, &check_info,
+ UNPACK_VALUE, &iinfo );
CORE_ztstrf(*m, *n, *ib, *nb, U, *ldu, A, *lda, L, *ldl, IPIV, WORK, *ldwork, &info);
@@ -77,21 +76,22 @@ void MORSE_TASK_ztstrf(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_ztstrf_parsec, "tstrf",
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &ib, VALUE,
- sizeof(int), &nb, VALUE,
- PASSED_BY_REF, RTBLKADDR( U, MORSE_Complex64_t, Um, Un ), INOUT | REGION_FULL,
- sizeof(int), &ldu, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( L, MORSE_Complex64_t, Lm, Ln ), OUTPUT | REGION_FULL,
- sizeof(int), &ldl, VALUE,
- sizeof(int)*nb, IPIV, SCRATCH,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- sizeof(int), &nb, VALUE,
- sizeof(int), &check_info, VALUE,
- sizeof(int), &iinfo, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_ztstrf_parsec, "tstrf",
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &ib, VALUE,
+ sizeof(int), &nb, VALUE,
+ PASSED_BY_REF, RTBLKADDR( U, MORSE_Complex64_t, Um, Un ), INOUT | REGION_FULL,
+ sizeof(int), &ldu, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INOUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( L, MORSE_Complex64_t, Lm, Ln ), OUTPUT | REGION_FULL,
+ sizeof(int), &ldl, VALUE,
+ sizeof(int)*nb, IPIV, SCRATCH,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ sizeof(int), &nb, VALUE,
+ sizeof(int), &check_info, VALUE,
+ sizeof(int), &iinfo, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zttlqt.c b/runtime/parsec/codelets/codelet_zttlqt.c
index bc44ec18c9f6e90e8324605e7d87852ce97b4be1..cbd733dedbf97b84fa91bb863e4aaa77bfe09bd4 100644
--- a/runtime/parsec/codelets/codelet_zttlqt.c
+++ b/runtime/parsec/codelets/codelet_zttlqt.c
@@ -37,20 +37,19 @@ CORE_zttlqt_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *TAU;
MORSE_Complex64_t *WORK;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A1,
- UNPACK_VALUE, &lda1,
- UNPACK_DATA, &A2,
- UNPACK_VALUE, &lda2,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_SCRATCH, &TAU,
- UNPACK_SCRATCH, &WORK
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &lda1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &lda2,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &TAU,
+ UNPACK_SCRATCH, &WORK );
CORE_zttlqt(*m, *n, *ib, A1, *lda1, A2, *lda2, T, *ldt, TAU, WORK);
@@ -66,17 +65,18 @@ void MORSE_TASK_zttlqt(const MORSE_option_t *options,
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zttlqt_parsec, "ttlqt",
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
- sizeof(int), &lda1, VALUE,
- PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
- sizeof(int), &lda2, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zttlqt_parsec, "ttlqt",
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zttmlq.c b/runtime/parsec/codelets/codelet_zttmlq.c
index 140891b18d60360cf63f758a258a6cb75221c933..a12ed573be8703a0c8e6d161ee97e95113492235 100644
--- a/runtime/parsec/codelets/codelet_zttmlq.c
+++ b/runtime/parsec/codelets/codelet_zttmlq.c
@@ -44,26 +44,26 @@ CORE_zttmlq_parsec(dague_execution_unit_t *context, dague_execution_context_t *
MORSE_Complex64_t *WORK;
int *ldwork;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &side,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &m1,
- UNPACK_VALUE, &n1,
- UNPACK_VALUE, &m2,
- UNPACK_VALUE, &n2,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A1,
- UNPACK_VALUE, &lda1,
- UNPACK_DATA, &A2,
- UNPACK_VALUE, &lda2,
- UNPACK_DATA, &V,
- UNPACK_VALUE, &ldv,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_SCRATCH, &WORK,
- UNPACK_VALUE, &ldwork
- );
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &m1,
+ UNPACK_VALUE, &n1,
+ UNPACK_VALUE, &m2,
+ UNPACK_VALUE, &n2,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &lda1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &lda2,
+ UNPACK_DATA, &V,
+ UNPACK_VALUE, &ldv,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &WORK,
+ UNPACK_VALUE, &ldwork );
CORE_zttmlq(*side, *trans, *m1, *n1, *m2, *n2, *k, *ib, A1, *lda1,
A2, *lda2, V, *ldv, T, *ldt, WORK, *ldwork);
@@ -83,24 +83,25 @@ void MORSE_TASK_zttmlq(const MORSE_option_t *options,
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zttmlq_parsec, "ttmlq",
- sizeof(MORSE_enum), &side, VALUE,
- sizeof(MORSE_enum), &trans, VALUE,
- sizeof(int), &m1, VALUE,
- sizeof(int), &n1, VALUE,
- sizeof(int), &m2, VALUE,
- sizeof(int), &n2, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
- sizeof(int), &lda1, VALUE,
- PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
- sizeof(int), &lda2, VALUE,
- PASSED_BY_REF, RTBLKADDR( V, MORSE_Complex64_t, Vm, Vn ), INPUT | REGION_FULL,
- sizeof(int), &ldv, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- sizeof(int), &ldwork, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zttmlq_parsec, "ttmlq",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &m1, VALUE,
+ sizeof(int), &n1, VALUE,
+ sizeof(int), &m2, VALUE,
+ sizeof(int), &n2, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR( V, MORSE_Complex64_t, Vm, Vn ), INPUT | REGION_FULL,
+ sizeof(int), &ldv, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ sizeof(int), &ldwork, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zttmqr.c b/runtime/parsec/codelets/codelet_zttmqr.c
index 8de4e5ca33e946d4c20b449957fbe3d0a0200b7d..9d66160ef9dc74bb9c2bcce4c949d2c44af14a05 100644
--- a/runtime/parsec/codelets/codelet_zttmqr.c
+++ b/runtime/parsec/codelets/codelet_zttmqr.c
@@ -44,32 +44,30 @@ CORE_zttmqr_parsec(dague_execution_unit_t *context, dague_execution_context_t *
MORSE_Complex64_t *WORK;
int *ldwork;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &side,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &m1,
- UNPACK_VALUE, &n1,
- UNPACK_VALUE, &m2,
- UNPACK_VALUE, &n2,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A1,
- UNPACK_VALUE, &lda1,
- UNPACK_DATA, &A2,
- UNPACK_VALUE, &lda2,
- UNPACK_DATA, &V,
- UNPACK_VALUE, &ldv,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_SCRATCH, &WORK,
- UNPACK_VALUE, &ldwork
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &m1,
+ UNPACK_VALUE, &n1,
+ UNPACK_VALUE, &m2,
+ UNPACK_VALUE, &n2,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &lda1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &lda2,
+ UNPACK_DATA, &V,
+ UNPACK_VALUE, &ldv,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &WORK,
+ UNPACK_VALUE, &ldwork );
CORE_zttmqr(*side, *trans, *m1, *n1, *m2, *n2, *k, *ib,
A1, *lda1, A2, *lda2, V, *ldv, T, *ldt, WORK, *ldwork);
-
return 0;
}
@@ -86,24 +84,25 @@ void MORSE_TASK_zttmqr(const MORSE_option_t *options,
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zttmqr_parsec, "ttmqr",
- sizeof(MORSE_enum), &side, VALUE,
- sizeof(MORSE_enum), &trans, VALUE,
- sizeof(int), &m1, VALUE,
- sizeof(int), &n1, VALUE,
- sizeof(int), &m2, VALUE,
- sizeof(int), &n2, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
- sizeof(int), &lda1, VALUE,
- PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
- sizeof(int), &lda2, VALUE,
- PASSED_BY_REF, RTBLKADDR( V, MORSE_Complex64_t, Vm, Vn ), INPUT | REGION_FULL,
- sizeof(int), &ldv, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- sizeof(int), &ldwork, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zttmqr_parsec, "ttmqr",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &m1, VALUE,
+ sizeof(int), &n1, VALUE,
+ sizeof(int), &m2, VALUE,
+ sizeof(int), &n2, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR( V, MORSE_Complex64_t, Vm, Vn ), INPUT | REGION_FULL,
+ sizeof(int), &ldv, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ sizeof(int), &ldwork, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zttqrt.c b/runtime/parsec/codelets/codelet_zttqrt.c
index ef2dd5c674eb8a06c45ff0e9fbe216fe21c00479..c6a70698289ba35cb05ff3ebf8911ecb1eff9255 100644
--- a/runtime/parsec/codelets/codelet_zttqrt.c
+++ b/runtime/parsec/codelets/codelet_zttqrt.c
@@ -37,21 +37,19 @@ CORE_zttqrt_parsec(dague_execution_unit_t *context, dague_execution_context_t *
MORSE_Complex64_t *TAU;
MORSE_Complex64_t *WORK;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A1,
- UNPACK_VALUE, &lda1,
- UNPACK_DATA, &A2,
- UNPACK_VALUE, &lda2,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_SCRATCH, &TAU,
- UNPACK_SCRATCH, &WORK
- );
-
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A1,
+ UNPACK_VALUE, &lda1,
+ UNPACK_DATA, &A2,
+ UNPACK_VALUE, &lda2,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_SCRATCH, &TAU,
+ UNPACK_SCRATCH, &WORK );
CORE_zttqrt(*m, *n, *ib, A1, *lda1, A2, *lda2, T, *ldt, TAU, WORK);
@@ -66,17 +64,18 @@ void MORSE_TASK_zttqrt(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zttqrt_parsec, "ttqrt",
- sizeof(MORSE_enum), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
- sizeof(int), &lda1, VALUE,
- PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
- sizeof(int), &lda2, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zttqrt_parsec, "ttqrt",
+ sizeof(MORSE_enum), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A1, MORSE_Complex64_t, A1m, A1n ), INOUT | REGION_FULL,
+ sizeof(int), &lda1, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A2, MORSE_Complex64_t, A2m, A2n ), INOUT | REGION_FULL,
+ sizeof(int), &lda2, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), OUTPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ sizeof(MORSE_Complex64_t)*nb, NULL, SCRATCH,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zunmlq.c b/runtime/parsec/codelets/codelet_zunmlq.c
index a123385136df4cab0c888a92d71103b43b9cd719..8a9142db89605d899476c30b41cbb842f5c3832a 100644
--- a/runtime/parsec/codelets/codelet_zunmlq.c
+++ b/runtime/parsec/codelets/codelet_zunmlq.c
@@ -40,23 +40,22 @@ CORE_zunmlq_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *WORK;
int *ldwork;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &side,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_DATA, &C,
- UNPACK_VALUE, &ldc,
- UNPACK_SCRATCH, &WORK,
- UNPACK_VALUE, &ldwork
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_DATA, &C,
+ UNPACK_VALUE, &ldc,
+ UNPACK_SCRATCH, &WORK,
+ UNPACK_VALUE, &ldwork );
CORE_zunmlq(*side, *trans, *m, *n, *k, *ib,
A, *lda, T, *ldt, C, *ldc, WORK, *ldwork);
@@ -73,21 +72,21 @@ void MORSE_TASK_zunmlq(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
-
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zunmlq_parsec, "unmlq",
- sizeof(MORSE_enum), &side, VALUE,
- sizeof(MORSE_enum), &trans, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
- sizeof(int), &ldc, VALUE,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- sizeof(int), &nb, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zunmlq_parsec, "unmlq",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_FULL,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
+ sizeof(int), &ldc, VALUE,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ sizeof(int), &nb, VALUE,
+ 0);
}
diff --git a/runtime/parsec/codelets/codelet_zunmqr.c b/runtime/parsec/codelets/codelet_zunmqr.c
index 9bac6d0e72cbb796320e17fcac2ad3b71ac04108..c07e46c11c792b11b03a71e4427b6bbcd0341984 100644
--- a/runtime/parsec/codelets/codelet_zunmqr.c
+++ b/runtime/parsec/codelets/codelet_zunmqr.c
@@ -40,23 +40,22 @@ CORE_zunmqr_parsec(dague_execution_unit_t *context, dague_execution_context_t *t
MORSE_Complex64_t *WORK;
int *ldwork;
- dague_dtd_unpack_args(this_task,
- UNPACK_VALUE, &side,
- UNPACK_VALUE, &trans,
- UNPACK_VALUE, &m,
- UNPACK_VALUE, &n,
- UNPACK_VALUE, &k,
- UNPACK_VALUE, &ib,
- UNPACK_DATA, &A,
- UNPACK_VALUE, &lda,
- UNPACK_DATA, &T,
- UNPACK_VALUE, &ldt,
- UNPACK_DATA, &C,
- UNPACK_VALUE, &ldc,
- UNPACK_SCRATCH, &WORK,
- UNPACK_VALUE, &ldwork
- );
-
+ dague_dtd_unpack_args(
+ this_task,
+ UNPACK_VALUE, &side,
+ UNPACK_VALUE, &trans,
+ UNPACK_VALUE, &m,
+ UNPACK_VALUE, &n,
+ UNPACK_VALUE, &k,
+ UNPACK_VALUE, &ib,
+ UNPACK_DATA, &A,
+ UNPACK_VALUE, &lda,
+ UNPACK_DATA, &T,
+ UNPACK_VALUE, &ldt,
+ UNPACK_DATA, &C,
+ UNPACK_VALUE, &ldc,
+ UNPACK_SCRATCH, &WORK,
+ UNPACK_VALUE, &ldwork );
CORE_zunmqr(*side, *trans, *m, *n, *k, *ib,
A, *lda, T, *ldt, C, *ldc, WORK, *ldwork);
@@ -73,20 +72,21 @@ void MORSE_TASK_zunmqr(const MORSE_option_t *options,
{
dague_dtd_handle_t* DAGUE_dtd_handle = (dague_dtd_handle_t *)(options->sequence->schedopt);
- insert_task_generic_fptr(DAGUE_dtd_handle, CORE_zunmqr_parsec, "unmqr",
- sizeof(MORSE_enum), &side, VALUE,
- sizeof(MORSE_enum), &trans, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(int), &k, VALUE,
- sizeof(int), &ib, VALUE,
- PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_L,
- sizeof(int), &lda, VALUE,
- PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
- sizeof(int), &ldt, VALUE,
- PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
- sizeof(int), &ldc, VALUE,
- sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
- sizeof(int), &nb, VALUE,
- 0);
+ dague_insert_task(
+ DAGUE_dtd_handle, CORE_zunmqr_parsec, "unmqr",
+ sizeof(MORSE_enum), &side, VALUE,
+ sizeof(MORSE_enum), &trans, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(int), &k, VALUE,
+ sizeof(int), &ib, VALUE,
+ PASSED_BY_REF, RTBLKADDR( A, MORSE_Complex64_t, Am, An ), INPUT | REGION_L,
+ sizeof(int), &lda, VALUE,
+ PASSED_BY_REF, RTBLKADDR( T, MORSE_Complex64_t, Tm, Tn ), INPUT | REGION_FULL,
+ sizeof(int), &ldt, VALUE,
+ PASSED_BY_REF, RTBLKADDR( C, MORSE_Complex64_t, Cm, Cn ), INOUT | REGION_FULL,
+ sizeof(int), &ldc, VALUE,
+ sizeof(MORSE_Complex64_t)*ib*nb, NULL, SCRATCH,
+ sizeof(int), &nb, VALUE,
+ 0);
}
diff --git a/runtime/parsec/control/runtime_async.c b/runtime/parsec/control/runtime_async.c
index ddb77532cc5a4b0379c8c9169f879e7ae6725d2c..d101ba7c1d61baee13917fc4f28055df460538f5 100644
--- a/runtime/parsec/control/runtime_async.c
+++ b/runtime/parsec/control/runtime_async.c
@@ -16,7 +16,7 @@
int RUNTIME_sequence_create(MORSE_context_t *morse, MORSE_sequence_t *sequence)
{
dague_context_t *dague = (dague_context_t *)morse->schedopt;
- dague_dtd_handle_t *dague_dtd_handle = dague_dtd_handle_new((dague_context_t *)morse->schedopt, 1);
+ dague_dtd_handle_t *dague_dtd_handle = dague_dtd_handle_new((dague_context_t *)morse->schedopt);
dague_enqueue(dague, (dague_handle_t*) dague_dtd_handle);
sequence->schedopt = dague_dtd_handle;
diff --git a/runtime/quark/codelets/codelet_zlascal.c b/runtime/quark/codelets/codelet_zlascal.c
index ab96da473c760287503e0a995452e0ba75203d52..747695ef445633a4f61dcbf54da76ab3faba6d92 100644
--- a/runtime/quark/codelets/codelet_zlascal.c
+++ b/runtime/quark/codelets/codelet_zlascal.c
@@ -58,12 +58,12 @@ void MORSE_TASK_zlascal(const MORSE_option_t *options,
quark_option_t *opt = (quark_option_t*)(options->schedopt);
DAG_CORE_LASCAL;
QUARK_Insert_Task(opt->quark, CORE_zlascal_quark, (Quark_Task_Flags*)opt,
- sizeof(MORSE_enum), &uplo, VALUE,
- sizeof(int), &m, VALUE,
- sizeof(int), &n, VALUE,
- sizeof(MORSE_Complex64_t), alpha, VALUE,
- sizeof(MORSE_Complex64_t)*nb*nb, RTBLKADDR(A, MORSE_Complex64_t, Am, An), INOUT,
- sizeof(int), &lda, VALUE,
+ sizeof(MORSE_enum), &uplo, VALUE,
+ sizeof(int), &m, VALUE,
+ sizeof(int), &n, VALUE,
+ sizeof(MORSE_Complex64_t), &alpha, VALUE,
+ sizeof(MORSE_Complex64_t)*nb*nb, RTBLKADDR(A, MORSE_Complex64_t, Am, An), INOUT,
+ sizeof(int), &lda, VALUE,
0);
}