/*! \file C_threads_tasks.hpp
\brief tasks executed asynchronously with threads
\author Atsushi Suzuki, Laboratoire Jacques-Louis Lions
\date Apr. 22th 2013
\date Jul. 12th 2015
\date Nov. 30th 2016
*/
// This file is part of Dissection
//
// Dissection is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Linking Dissection statically or dynamically with other modules is making
// a combined work based on Disssection. Thus, the terms and conditions of
// the GNU General Public License cover the whole combination.
//
// As a special exception, the copyright holders of Dissection give you
// permission to combine Dissection program with free software programs or
// libraries that are released under the GNU LGPL and with independent modules
// that communicate with Dissection solely through the Dissection-fortran
// interface. You may copy and distribute such a system following the terms of
// the GNU GPL for Dissection and the licenses of the other code concerned,
// provided that you include the source code of that other code when and as
// the GNU GPL requires distribution of source code and provided that you do
// not modify the Dissection-fortran interface.
//
// Note that people who make modified versions of Dissection are not obligated
// to grant this special exception for their modified versions; it is their
// choice whether to do so. The GNU General Public License gives permission to
// release a modified version without this exception; this exception also makes
// it possible to release a modified version which carries forward this
// exception. If you modify the Dissection-fortran interface, this exception
// does not apply to your modified version of Dissection, and you must remove
// this exception when you distribute your modified version.
//
// This exception is an additional permission under section 7 of the GNU
// General Public License, version 3 ("GPLv3")
//
// Dissection is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Dissection. If not, see .
//
#ifndef _C_THREADS_TASKS_
#define _C_THREADS_TASKS_
#include
#include
# include "Compiler/blas.hpp"
# include "Compiler/OptionCompiler.hpp"
#include
#include
#include
#include
#include
#include "Compiler/elapsed_time.hpp"
# include "Algebra/SquareMatrix.hpp"
# include "Algebra/SquareBlockMatrix.hpp"
# include "Algebra/RectBlockMatrix.hpp"
# include "Algebra/ColumnMatrix.hpp"
# include "Splitters/BisectionTree.hpp"
# include "Algebra/CSR_matrix.hpp"
# include "Driver/TridiagBlockMatrix.hpp"
using namespace std;
// set manually the same value defined in Moudels/blak_blocksize.f90
#define SIZE_B1 240
#define SIZE_DGEMM_SYMM_DTRSV 40
//#define SIZE_B1 600
//#define SIZE_DGEMM_SYMM_DTRSV 100
#define C_DHALF_SCHUR_BLOCK_GEMM 1.0
#define C_DHALF_SCHUR_BLOCK_GEMV 2.0
#define FW_SOLVESCLAE_DTRSM 3.0
#define BLAS3_GEMM_OPT 0.5
// #define TASK_NAME_SIZE 256
const string _null_name;
struct source_dist_index {
int source;
int dist;
int global_i;
int global_j;
~source_dist_index() {}
source_dist_index() {}
source_dist_index(int source_, int dist_, int global_i_, int global_j_) :
source(source_), dist(dist_), global_i(global_i_), global_j(global_j_) {}
source_dist_index(const source_dist_index &im)
{
// if (&im != this) { : no need to be declared
source = im.source;
dist = im.dist;
global_i = im.global_i;
global_j = im.global_j;
// }
}
};
template
struct C_Dsub_task {
int ir_bgn;
int ir_end;
int jc_bgn;
int jc_end;
int ir_bgn_src;
int ir_bgn_src2;
int jc_bgn_src;
int jc_bgn_src2;
int dst_row;
SquareBlockMatrix *dst_mtrx;
RectBlockMatrix *dst_pt;
int ir_block;
int jc_block;
RectBlockMatrix *dst_pt2;
int ir2_block;
int jc2_block;
SquareBlockMatrix *src_pt;
SquareBlockMatrix *src_pt2;
void (*func)(C_Dsub_task *);
bool isSkip;
int atomic_size;
int atomic_id;
int parallel_max;
int parallel_id;
long *ops_complexity;
int father_id;
int child0_id;
int child1_id;
int level;
bool verbose;
bool debug;
int child_id;
FILE *fp;
~C_Dsub_task() {
delete ops_complexity;
}
C_Dsub_task() {}
C_Dsub_task(int atomic_size_,
int atomic_id_,
int ir_bgn_,
int ir_end_,
int jc_bgn_,
int jc_end_,
int ir_bgn_src_,
int ir_bgn_src2_,
int jc_bgn_src_,
int jc_bgn_src2_,
int dst_row_,
SquareBlockMatrix* dst_mtrx_,
RectBlockMatrix *dst_pt_,
int ir_block_,
int jc_block_,
RectBlockMatrix *dst_pt2_,
int ir2_block_,
int jc2_block_,
SquareBlockMatrix *src_pt_,
SquareBlockMatrix *src_pt2_,
void (*func_)(C_Dsub_task *),
bool isSkip_,
long ops_complexity_,
int father_id_,
int level_,
bool verbose_,
FILE *fp_) :
ir_bgn(ir_bgn_),
ir_end(ir_end_),
jc_bgn(jc_bgn_),
jc_end(jc_end_),
ir_bgn_src(ir_bgn_src_),
ir_bgn_src2(ir_bgn_src2_),
jc_bgn_src(jc_bgn_src_),
jc_bgn_src2(jc_bgn_src2_),
dst_row(dst_row_),
dst_mtrx(dst_mtrx_),
dst_pt(dst_pt_),
ir_block(ir_block_),
jc_block(jc_block_),
dst_pt2(dst_pt2_),
ir2_block(ir2_block_),
jc2_block(jc2_block_),
src_pt(src_pt_),
src_pt2(src_pt2_),
func(func_),
isSkip(isSkip_),
atomic_size(atomic_size_),
atomic_id(atomic_id_),
father_id(father_id_),
level(level_),
verbose(verbose_),
fp(fp_)
{
debug = false;
child_id = 0;
ops_complexity = new long;
*ops_complexity = ops_complexity_;
}
C_Dsub_task(const C_Dsub_task &im)
{
atomic_size = im.atomic_size;
atomic_id = im.atomic_id;
ir_bgn = im.ir_bgn;
ir_end = im.ir_end;
jc_bgn = im.jc_bgn;
jc_end = im.jc_end;
ir_bgn_src = im.ir_bgn_src;
ir_bgn_src2 = im.ir_bgn_src2;
jc_bgn_src = im.jc_bgn_src;
jc_bgn_src2 = im.jc_bgn_src2;
dst_row = im.dst_row;
dst_mtrx = im.dst_mtrx;
dst_pt = im.dst_pt;
ir_block = im.ir_block;
jc_block = im.jc_block;
dst_pt2 = im.dst_pt2;
ir2_block = im.ir2_block;
jc2_block = im.jc2_block;
src_pt = im.src_pt;
src_pt2 = im.src_pt2;
func = im.func;
isSkip = im.isSkip;
father_id = im.father_id;
level = im.level;
verbose = im.verbose;
debug = im.debug;
child_id = im.child_id;
fp = im.fp;
ops_complexity = new long;
*ops_complexity = *(im.ops_complexity); // copy value
}
};
typedef struct {
double pivot;
double w;
double eps;
double delta;
} pivot_param;
#define DIST_TASK_CRITICAL 20
#define TASK_WAITING 0
#define TASK_WORKING 1
#define TASK_DONE 2
#define TASK_SINGLE 8
#define TASK_PARALLEL 9
#define C_DUMMY 1
#define C_DIAG_START 2
#define C_DFULL 4
#define C_DFULL_SYM_GAUSS 5
#define C_DINV_DL_TIMESU 6
#define C_DHALF_SCHUR_B 70
#define C_DHALF_SCHUR_BT 71
#define C_DTRSM 8
#define C_DTRSM1 9
#define C_DTRSMSCALE 10
#define C_DGEMM 16
#define C_DGEMM1 17
#define C_DGEMM_LOCAL_MULT 18
#define C_DGEMM_LOCAL_TWO 19
#define C_DGEMM_DIRECT_TWO 20
#define C_DSUB 32
#define C_DSUB1 33
#define C_DEALLOCATE 34
#define C_DEALLOCATE1 35
#define C_DEALLOCLOCALSCHUR 36
#define C_DEALLOCLOWER 40
#define C_FILLMATRIX 64
#define C_FILLMATRIX1 65
#define C_SPARSESYMBFACT 128
#define C_SPARSENUMFACT 256
#define C_SPARSESCHUR 257
#define C_SPARSELOCALSCHUR 512
#define C_SPARSELOCALSCHUR1 513
#define C_SPARSESOLVER 384
#define C_FWBW 1024
#define C_SPARSESYMFW 1025
#define C_SPARSESYMBW 1026
#define C_DSUB_FWBW 1027
#define C_DENSE_SYMFW_DIAG 1028
#define C_DENSE_SYMFW_OFFDIAG 1029
#define C_STRIPS_SYMFW_OFFDIAG 1030
#define C_DENSE_SYMSCALE 1031
#define C_DENSE_SYMFILL 1032
template
struct C_SparseSymbFact_arg {
TridiagBlockMatrix **tridiag;
int nrow;
int colors;
int *color_mask;
const CSR_indirect* csr_diag;
long *ops_complexity;
long *nopd;
long *nops;
bool verbose;
FILE **fp;
~C_SparseSymbFact_arg() {
delete ops_complexity;
delete nopd;
delete nops;
}
C_SparseSymbFact_arg() {}
C_SparseSymbFact_arg (TridiagBlockMatrix **tridiag_,
int colors_,
int *color_mask_,
int nrow_,
const CSR_indirect* csr_diag_,
bool verbose_,
FILE **fp_
) :
tridiag(tridiag_),
nrow(nrow_),
colors(colors_),
color_mask(color_mask_),
csr_diag(csr_diag_),
verbose(verbose_),
fp(fp_) {
ops_complexity = new long;
nopd = new long;
nops = new long;
}
C_SparseSymbFact_arg(const C_SparseSymbFact_arg &im)
{
tridiag = im.tridiag;
colors = im.colors;
color_mask = im.color_mask;
nrow = im.nrow;
csr_diag = im.csr_diag;
ops_complexity = new long;
*ops_complexity = *(im.ops_complexity);
nopd = new long;
*nopd = *(im.nopd);
nops = new long;
*nops = *(im.nops);
verbose = im.verbose;
fp = im.fp;
}
};
template
struct C_SparseNumFact_arg {
TridiagBlockMatrix **tridiag;
bool isSym;
int colors;
int *color_mask;
int nnz;
T *coefs;
int nrow;
int ncol;
const CSR_indirect* csr_diag;
const CSR_indirect* csr_offdiag;
SquareBlockMatrix* D; // to store pivot information
double *eps_pivot;
double *pivot;
bool *kernel_detection;
bool *higher_precision;
int *dim_aug_kern;
U *eps_machine;
SquareBlockMatrix* localSchur;
long *ops_complexity;
long *nopd;
long *nops;
bool verbose;
elapsed_t *tt;
FILE **fp;
int nb;
~C_SparseNumFact_arg() {
delete ops_complexity;
delete nopd;
delete nops;
delete [] tt;
}
C_SparseNumFact_arg() {}
C_SparseNumFact_arg (TridiagBlockMatrix **tridiag_,
bool isSym_,
int colors_,
int *color_mask_,
int nnz_,
T *coefs_,
int nrow_,
int ncol_,
const CSR_indirect* csr_diag_,
const CSR_indirect* csr_offdiag_,
SquareBlockMatrix* D_,
double *eps_pivot_,
double *pivot_,
bool *kernel_detection_,
bool *higher_precision_,
int *dim_aug_kern_,
U *eps_machine_,
SquareBlockMatrix* localSchur_,
bool verbose_,
FILE **fp_,
int nb_) :
tridiag(tridiag_),
isSym(isSym_),
colors(colors_),
color_mask(color_mask_),
nnz(nnz_),
coefs(coefs_),
nrow(nrow_),
ncol(ncol_),
csr_diag(csr_diag_),
csr_offdiag(csr_offdiag_),
D(D_),
eps_pivot(eps_pivot_),
pivot(pivot_),
kernel_detection(kernel_detection_),
higher_precision(higher_precision_),
dim_aug_kern(dim_aug_kern_),
eps_machine(eps_machine_),
localSchur(localSchur_),
verbose(verbose_),
fp(fp_),
nb(nb_)
{
ops_complexity = new long;
nopd = new long;
nops = new long;
tt = new elapsed_t[5];
}
C_SparseNumFact_arg(const C_SparseNumFact_arg &im)
{
tridiag = im.tridiag;
isSym = im.isSym;
colors = im.colors;
color_mask = im.color_mask;
nnz = im.nnz;
coefs = im.coefs;
nrow = im.nrow;
ncol = im.ncol;
csr_diag = im.csr_diag;
csr_offdiag = im.csr_offdiag;
D = im.D;
eps_pivot = im.eps_pivot;
pivot = im.pivot;
kernel_detection = im.kernel_detection;
higher_precision = im.higher_precision;
dim_aug_kern = im.dim_aug_kern;
eps_machine = im.eps_machine;
localSchur = im.localSchur;
ops_complexity = new long;
*ops_complexity = *(im.ops_complexity);
nopd = new long;
*nopd = *(im.nopd);
nops = new long;
*nops = *(im.nops);
verbose = im.verbose;
tt = im.tt;
fp = im.fp;
nb = im.nb;
}
};
template
struct C_FillMatrix_arg {
bool isSym;
SquareBlockMatrix* D;
RectBlockMatrix* upper;
RectBlockMatrix* lower;
const CSR_indirect *csr_diag;
const CSR_indirect *csr_offdiag;
T *coefs;
long *ops_complexity;
bool verbose;
FILE **fp;
int nb;
~C_FillMatrix_arg() {
delete ops_complexity;
}
C_FillMatrix_arg() {}
C_FillMatrix_arg (bool isSym_,
SquareBlockMatrix* D_,
RectBlockMatrix* upper_,
RectBlockMatrix* lower_,
const CSR_indirect *csr_diag_,
const CSR_indirect *csr_offdiag_,
T *coefs_,
bool verbose_,
FILE **fp_,
int nb_) :
isSym(isSym_),
D(D_),
upper(upper_),
lower(lower_),
csr_diag(csr_diag_),
csr_offdiag(csr_offdiag_),
coefs(coefs_),
verbose(verbose_),
fp(fp_),
nb(nb_)
{
ops_complexity = new long;
}
C_FillMatrix_arg(const C_FillMatrix_arg &im)
{
isSym = im.isSym;
D = im.D;
upper = im.upper;
lower = im.lower;
csr_diag = im.csr_diag;
csr_offdiag = im.csr_offdiag;
coefs =im.coefs;
ops_complexity = new long;
*ops_complexity = *(im.ops_complexity);
verbose = im.verbose;
fp = im.fp;
nb = im.nb;
}
};
template
struct C_dfull_gauss_arg {
int task_position;
int id_level;
int num_block;
int id_block;
SquareBlockMatrix* D;
SquareBlockMatrix* localSchur;
ColumnMatrix *a;
// ColumnMatrix *diag; // T **diag;
int *permute_block;
int n;
int upper_ncol;
int nrow;
int i1_block;
double *eps_piv;
double *pivot;
double *pivot0;
double *pivot1;
bool isSym;
long *ops_complexity;
bool *kernel_detection;
int *aug_dim;
U *eps_machine;
bool *quit;
int to_next_task;
bool verbose;
FILE **fp;
int nb;
~C_dfull_gauss_arg() {
delete ops_complexity;
}
C_dfull_gauss_arg() {}
C_dfull_gauss_arg(bool isSym_,
int task_position_,
int id_level_,
int num_block_,
int id_block_,
SquareBlockMatrix* D_,
SquareBlockMatrix* localSchur_,
ColumnMatrix *a_, //T **a_,
// ColumnMatrix *diag_, //T **diag_,
int *permute_block_,
int n_,
int upper_ncol_,
int nrow_,
int i1_block_,
double *eps_piv_,
double *pivot_,
double *pivot0_,
double *pivot1_,
bool *kernel_detection_,
int *aug_dim_,
U *eps_machine_,
bool verbose_,
FILE **fp_,
int nb_) :
task_position(task_position_),
id_level(id_level_),
num_block(num_block_),
id_block(id_block_),
D(D_),
// lower(lower_),
localSchur(localSchur_),
a(a_),
// diag(diag_),
permute_block(permute_block_),
n(n_),
upper_ncol(upper_ncol_),
nrow(nrow_),
i1_block(i1_block_),
eps_piv(eps_piv_),
pivot(pivot_),
pivot0(pivot0_),
pivot1(pivot1_),
isSym(isSym_),
kernel_detection(kernel_detection_),
aug_dim(aug_dim_),
eps_machine(eps_machine_),
to_next_task(0),
verbose(verbose_),
fp(fp_),
nb(nb_) {
ops_complexity = new long;
}
C_dfull_gauss_arg(const C_dfull_gauss_arg &im)
{
isSym = im.isSym;
task_position = im.task_position;
id_level = im.id_level;
num_block = im.num_block;
id_block = im.id_block;
D = im.D;
localSchur = im.localSchur;
a = im.a;
// diag = im.diag;
permute_block = im.permute_block;
n = im.n;
upper_ncol = im.upper_ncol;
nrow = im.nrow;
i1_block = im.i1_block;
eps_piv = im.eps_piv;
pivot = im.pivot;
pivot0 = im.pivot0;
pivot1 = im.pivot1;
ops_complexity = new long;
*ops_complexity = *(im.ops_complexity);
kernel_detection = im.kernel_detection;
aug_dim = im.aug_dim;
eps_machine = im.eps_machine;
fp = im.fp;
nb = im.nb;
quit = im.quit;
to_next_task = im.to_next_task;
}
};
template
struct C_dinvDL_timesU_arg{
bool isSym;
int task_position;
int id_level;
int num_block;
int id_block;
SquareBlockMatrix* D;
ColumnMatrix* a; // T **a;
int n;
int nrow;
int ncol;
int i1_block;
int jj_block;
long *ops_complexity;
bool verbose;
FILE **fp;
int nb;
~C_dinvDL_timesU_arg() {
delete ops_complexity;
}
C_dinvDL_timesU_arg() {}
C_dinvDL_timesU_arg(bool isSym_,
int task_position_,
int id_level_,
int num_block_,
int id_block_,
SquareBlockMatrix* D_,
ColumnMatrix *a_,
int n_,
int nrow_,
int ncol_,
int i1_block_,
int jj_block_,
bool verbose_,
FILE **fp_,
int nb_) :
isSym(isSym_),
task_position(task_position_),
id_level(id_level_),
num_block(num_block_),
id_block(id_block_),
D(D_),
a(a_),
n(n_),
nrow(nrow_),
ncol(ncol_),
i1_block(i1_block_),
jj_block(jj_block_),
verbose(verbose_),
fp(fp_),
nb(nb_) {
ops_complexity = new long;
}
C_dinvDL_timesU_arg(const C_dinvDL_timesU_arg &im)
{
isSym = im.isSym;
task_position = im.task_position;
id_level = im.id_level;
num_block = im.num_block;
id_block = im.id_block;
D = im.D;
a = im.a;
n = im.n;
nrow = im.nrow;
ncol = im.ncol;
i1_block = im.i1_block;
jj_block = im.jj_block;
ops_complexity = new long;
*ops_complexity = *(im.ops_complexity);
verbose = im.verbose;
fp = im.fp;
nb = im.nb;
}
};
template
struct C_dupdateb_Schur_arg{
bool isSym;
int task_position;
int id_level;
int num_block;
int id_block;
SquareBlockMatrix* D;
ColumnMatrix *a; // T **a;
int n;
int nrow;
int ncol;
int b_size;
int i1_block;
int ii_block;
int jj_block;
long *ops_complexity;
bool verbose;
FILE **fp;
int nb;
~C_dupdateb_Schur_arg() {
delete ops_complexity;
}
C_dupdateb_Schur_arg() {}
C_dupdateb_Schur_arg(int isSym_,
int task_position_,
int id_level_,
int num_block_,
int id_block_,
SquareBlockMatrix* D_,
ColumnMatrix *a_, // T **a_,
int n_,
int nrow_,
int ncol_,
int b_size_,
int i1_block_,
int ii_block_,
int jj_block_,
bool verbose_,
FILE **fp_,
int nb_) :
isSym(isSym_),
task_position(task_position_),
id_level(id_level_),
num_block(num_block_),
id_block(id_block_),
D(D_),
a(a_),
n(n_),
nrow(nrow_),
ncol(ncol_),
b_size(b_size_),
i1_block(i1_block_),
ii_block(ii_block_),
jj_block(jj_block_),
verbose(verbose_),
fp(fp_),
nb(nb_) {
ops_complexity = new long;
}
C_dupdateb_Schur_arg(const C_dupdateb_Schur_arg &im)
{
isSym = im.isSym;
task_position = im.task_position;
id_level = im.id_level;
num_block = im.num_block;
id_block = im.id_block;
D = im.D;
a = im.a;
n = im.n;
nrow = im.nrow;
ncol = im.ncol;
b_size = im.b_size;
i1_block = im.i1_block;
ii_block = im.ii_block;
jj_block = im.jj_block;
ops_complexity = new long;
*ops_complexity = *(im.ops_complexity);
verbose = im.verbose;
fp = im.fp;
nb = im.nb;
}
};
template
struct DTRSMScale_arg {
SquareBlockMatrix* LDLt;
RectBlockMatrix* upper; // double *x;
RectBlockMatrix* lower; // double *z;
int nrow;
int ncol;
int kblock;
int lblock;
int mblock;
vector* singLocNodes0;
bool localPermute;
bool isSym;
long *ops_complexity;
bool verbose;
FILE **fp;
int nb;
bool debug;
~DTRSMScale_arg() {
delete ops_complexity;
}
DTRSMScale_arg() {}
DTRSMScale_arg(bool isSym_,
SquareBlockMatrix *LDLt_,
RectBlockMatrix* upper_, // double *x_;
RectBlockMatrix* lower_, // double *z_;
int nrow_,
int ncol_,
int kblock_,
int lblock_,
int mblock_,
vector* singLocNodes0_,
bool localPermute_,
bool verbose_,
FILE **fp_,
int nb_) :
LDLt(LDLt_),
upper(upper_),
lower(lower_),
nrow(nrow_),
ncol(ncol_),
kblock(kblock_),
lblock(lblock_),
mblock(mblock_),
singLocNodes0(singLocNodes0_),
localPermute(localPermute_),
isSym(isSym_),
verbose(verbose_),
fp(fp_),
nb(nb_)
{
debug = false;
ops_complexity = new long;
}
DTRSMScale_arg(const DTRSMScale_arg &im)
{
LDLt = im.LDLt;
upper = im.upper;
lower = im.lower;
// offset = im.offset;
nrow = im.nrow;
ncol = im.ncol;
kblock = im.kblock;
lblock = im.lblock;
mblock = im.mblock;
singLocNodes0 = im.singLocNodes0;
ops_complexity = new long;
*ops_complexity = *(im.ops_complexity);
localPermute = im.localPermute;
isSym = im.isSym;
verbose = im.verbose;
fp = im.fp;
nb = im.nb;
debug = im.debug;
}
};
template
struct DSchurGEMM_arg {
bool isSym;
bool isTrans;
RectBlockMatrix* lower;
RectBlockMatrix* upper;
int nrow;
int i_block; // row block index
int j_block; // column block index
SquareBlockMatrix *localSchur;
long *ops_complexity;
bool verbose;
FILE **fp;
int nb;
~DSchurGEMM_arg() {
delete ops_complexity;
}
DSchurGEMM_arg() {}
DSchurGEMM_arg(bool isSym_,
bool isTrans_,
RectBlockMatrix* lower_,
RectBlockMatrix* upper_,
int nrow_,
int i_block_,
int j_block_,
SquareBlockMatrix *localSchur_,
bool verbose_,
FILE **fp_,
int nb_) :
isSym(isSym_),
isTrans(isTrans_),
lower(lower_),
upper(upper_),
nrow(nrow_),
i_block(i_block_),
j_block(j_block_),
localSchur(localSchur_),
verbose(verbose_),
fp(fp_),
nb(nb_)
{
ops_complexity = new long;
}
DSchurGEMM_arg(const DSchurGEMM_arg &im)
{
isSym = im.isSym;
isTrans = im.isTrans;
lower = im.lower;
upper = im.upper;
nrow = im.nrow;
i_block = im.i_block;
j_block = im.j_block;
localSchur = im.localSchur;
*ops_complexity = *(im.ops_complexity);
verbose = im.verbose;
fp = im.fp;
nb = im.nb;
}
};
template
struct DSchurGEMM_two_arg {
bool isSym;
bool isTrans;
RectBlockMatrix* lower0;
RectBlockMatrix* upper0;
int nrow0;
RectBlockMatrix* lower1;
RectBlockMatrix* upper1;
int nrow1;
int i_block; // row block index
int j_block; // column block index
SquareBlockMatrix *localSchur;
long *ops_complexity;
bool isSkip;
bool verbose;
FILE **fp;
int nb;
~DSchurGEMM_two_arg() {
delete ops_complexity;
}
DSchurGEMM_two_arg() {}
DSchurGEMM_two_arg(bool isSym_,
bool isTrans_,
RectBlockMatrix* lower0_,
RectBlockMatrix* upper0_,
int nrow0_,
RectBlockMatrix* lower1_,
RectBlockMatrix* upper1_,
int nrow1_,
int i_block_,
int j_block_,
SquareBlockMatrix *localSchur_,
bool isSkip_,
bool verbose_,
FILE **fp_,
int nb_) :
isSym(isSym_),
isTrans(isTrans_),
lower0(lower0_),
upper0(upper0_),
nrow0(nrow0_),
lower1(lower1_),
upper1(upper1_),
nrow1(nrow1_),
i_block(i_block_),
j_block(j_block_),
localSchur(localSchur_),
isSkip(isSkip_),
verbose(verbose_),
fp(fp_),
nb(nb_)
{
ops_complexity = new long;
}
DSchurGEMM_two_arg(const DSchurGEMM_two_arg &im)
{
isSym = im.isSym;
isTrans = im.isTrans;
lower0 = im.lower0;
upper0 = im.upper0;
nrow0 = im.nrow0;
lower1 = im.lower1;
upper1 = im.upper1;
nrow1 = im.nrow1;
i_block = im.i_block;
j_block = im.j_block;
localSchur = im.localSchur;
*ops_complexity = *(im.ops_complexity);
isSkip = im.isSkip;
verbose = im.verbose;
fp = im.fp;
nb = im.nb;
}
};
template
struct C_deallocLower_arg {
bool isSym;
RectBlockMatrix* lower;
long *ops_complexity;
~C_deallocLower_arg() {
delete ops_complexity;
}
C_deallocLower_arg() {}
C_deallocLower_arg(bool isSym_,
RectBlockMatrix* lower_,
long ops_complexity_) :
isSym(isSym_),
lower(lower_)
{
ops_complexity = new long;
*ops_complexity = ops_complexity_;
}
C_deallocLower_arg(const C_deallocLower_arg &im)
{
isSym = im.isSym;
lower = im.lower;
ops_complexity = new long;
*ops_complexity = *(im.ops_complexity);
}
};
template
struct C_deallocLocalSchur_arg {
bool isSym;
SquareBlockMatrix* localSchur;
int i_block;
int j_block;
long *ops_complexity;
bool verbose;
FILE **fp;
int nb;
~C_deallocLocalSchur_arg() {
delete ops_complexity;
}
C_deallocLocalSchur_arg() {}
C_deallocLocalSchur_arg(bool isSym_,
SquareBlockMatrix *localSchur_,
int i_block_,
int j_block_,
bool verbose_,
FILE **fp_,
int nb_) :
isSym(isSym_),
localSchur(localSchur_),
i_block(i_block_),
j_block(j_block_),
verbose(verbose_),
fp(fp_),
nb(nb_) {
ops_complexity = new long;
}
C_deallocLocalSchur_arg(const C_deallocLocalSchur_arg &im)
{
isSym = im.isSym;
i_block = im.i_block;
j_block = im.j_block;
localSchur = im.localSchur;
ops_complexity = im.ops_complexity;
verbose = im.verbose;
fp = im.fp;
nb = im.nb;
}
};
struct C_dummy_arg {
long *ops_complexity;
bool verbose;
FILE **fp;
int nb;
~C_dummy_arg() {
delete ops_complexity;
}
C_dummy_arg() {}
C_dummy_arg(bool verbose_,
FILE **fp_,
int nb_) :
verbose(verbose_),
fp(fp_),
nb(nb_) {
ops_complexity = new long;
*ops_complexity = (-1L);
}
C_dummy_arg(const C_dummy_arg & im)
{
ops_complexity = im.ops_complexity;
fp = im.fp;
nb = im.nb;
}
};
template
struct C_SparseFw_arg {
int colors;
int nb;
bool isSym;
int dim;
bool **isTrans;
int **nrhs;
// void* diag_sparse;
TridiagBlockMatrix **tridiag;
T **x;
T **yi;
T **zi;
T *coef; // SparseMatrix* ptDA; //
int n_diag;
int n_offdiag;
int *ptRows;
int *indCols;
int *indVals;
int *indVals_unsym;
int *loc2glob_diag;
long *ops_complexity;
~C_SparseFw_arg() {
delete ops_complexity;
}
C_SparseFw_arg() {}
C_SparseFw_arg(int colors_,
int nb_,
bool isSym_,
int dim_,
bool **isTrans_,
int **nrhs_,
TridiagBlockMatrix **tridiag_,
T **x_,
T **yi_,
T **zi_,
T *coef_, // SparseMatrix* ptDA_, //
int n_diag_,
int n_offdiag_,
int *ptRows_,
int *indCols_,
int *indVals_,
int *indVals_unsym_,
int *loc2glob_diag_) :
colors(colors_),
nb(nb_),
isSym(isSym_),
dim(dim_),
isTrans(isTrans_),
nrhs(nrhs_),
tridiag(tridiag_),
x(x_),
yi(yi_),
zi(zi_),
coef(coef_), // ptDA(ptDA_), //
n_diag(n_diag_),
n_offdiag(n_offdiag_),
ptRows(ptRows_),
indCols(indCols_),
indVals(indVals_),
indVals_unsym(indVals_unsym_),
loc2glob_diag(loc2glob_diag_) {
ops_complexity = new long;
}
C_SparseFw_arg(const C_SparseFw_arg &im)
{
colors = im.colors;
nb = im.nb;
isSym = im.isSym;
dim = im.dim;
isTrans = im.isTrans;
nrhs = im.nrhs;
tridiag = im.tridiag;
x = im.x;
yi = im.yi;
zi = im.zi;
coef = im.coef; // ptDA = im.ptDA; //
n_diag = im.n_diag;
n_offdiag = im.n_offdiag;
ptRows = im.ptRows;
indCols = im.indCols;
indVals = im.indVals;
indVals_unsym = im.indVals_unsym;
loc2glob_diag = im.loc2glob_diag;
}
};
template
struct C_SparseBw_arg {
int colors;
int nb;
bool isSym; // not used, for debugging
int dim;
bool **isTrans;
int **nrhs;
Dissection::Tree *btree;
int level_last;
TridiagBlockMatrix **tridiag;
T **x;
T ***yy;
T **xi;
T **yi;
T **zi;
T *coef; // SparseMatrix* ptDA; //
int *ptRows;
int *indCols;
int *indVals;
int *indVals_unsym;
long *ops_complexity;
~C_SparseBw_arg() {
delete ops_complexity;
}
C_SparseBw_arg() {}
C_SparseBw_arg(int colors_,
int nb_,
bool isSym_,
int dim_,
bool **isTrans_,
int **nrhs_,
Dissection::Tree *btree_,
int level_last_,
TridiagBlockMatrix **tridiag_,
T **x_,
T ***yy_,
T **xi_,
T **yi_,
T **zi_,
T *coef_, // SparseMatrix* ptDA_, //
int *ptRows_,
int *indCols_,
int *indVals_,
int *indVals_unsym_) :
colors(colors_),
nb(nb_),
isSym(isSym_),
dim(dim_),
isTrans(isTrans_),
nrhs(nrhs_),
btree(btree_),
level_last(level_last_),
// diag_sparse(diag_sparse_),
tridiag(tridiag_),
x(x_),
yy(yy_),
xi(xi_),
yi(yi_),
zi(zi_),
coef(coef_), // ptDA(ptDA_), //
ptRows(ptRows_),
indCols(indCols_),
indVals(indVals_),
indVals_unsym(indVals_unsym_) {
ops_complexity = new long;
}
C_SparseBw_arg(const C_SparseBw_arg &im)
{
colors = im.colors;
nb = im.nb;
isSym = im.isSym;
dim = im.dim;
isTrans = im.isTrans;
nrhs = im.nrhs;
btree = im.btree;
level_last = im.level_last;
tridiag = im.tridiag;
x = im.x;
yy = im.yy;
xi = im.xi;
yi = im.yi;
zi = im.zi;
coef = im.coef; // ptDA = im.ptDA; //
ptRows = im.ptRows;
indCols = im.indCols;
indVals = im.indVals;
indVals_unsym = im.indVals_unsym;
}
};
struct C_task {
int task_id;
int referred;
char *task_name; // is allocated by char [] when structure is constructed
bool task_name_allocated;
void *func_arg;
void (*func)(void *);
int atomic_size;
int atomic_id;
unsigned char status;
list* parents;
list* parents_work;
int parallel_max;
int parallel_id;
long *ops_complexity; // value is assigned in func_arg->ops_complexity
long flop;
elapsed_t t0, t1;
int thread_id;
int broadcast_deadlock;
bool quit_queue;
int to_next_task;
bool verbose;
FILE ***fp;
~C_task() {
if (task_name_allocated) {
delete [] task_name;
}
delete parents;
delete parents_work;
}
C_task() {}
C_task(int task_id_,
string task_name_,
void *func_arg_,
void (*func_)(void *),
int atomic_size_,
int atomic_id_,
long *ops_complexity_ ) :
task_id(task_id_),
referred(0),
func_arg(func_arg_),
func(func_),
atomic_size(atomic_size_),
atomic_id(atomic_id_),
status(TASK_WAITING),
parallel_max(1),
parallel_id(0),
ops_complexity(ops_complexity_),
broadcast_deadlock(0),
quit_queue(false),
to_next_task(0) {
if (!task_name_.empty()) {
task_name = new char[task_name_.length() + 1];
strcpy(task_name, task_name_.c_str());
task_name_allocated = true;
}
else {
task_name_allocated = false;
}
parents = new list;
parents_work = new list;
get_realtime(&t0); // reset time as created one
COPYTIME(t1, t0);
thread_id = (-1); // not executed yet
}
C_task(const C_task &im)
{
task_id = im.task_id;
referred = im.referred;
if (im.task_name_allocated) {
task_name = new char[strlen(im.task_name) + 1];
strcpy(task_name, im.task_name);
task_name_allocated = true;
}
else {
task_name_allocated = false;
}
func_arg = im.func_arg;
func = im.func;
atomic_size = im.atomic_size;
atomic_id = im.atomic_id;
status = im.status;
parents = im.parents;
parents_work = im.parents_work;
parallel_max = im.parallel_max;
parallel_id = im.parallel_id;
ops_complexity = im.ops_complexity; // copy pointer
// nops = im.nops;
flop = im.flop;
t0 = im.t0;
t1 = im.t1;
thread_id = im.thread_id;
quit_queue = im.quit_queue;
to_next_task = im.to_next_task;
verbose = im.verbose;
fp = im.fp;
}
};
struct C_task_seq {
int task_id;
int referred;
char *task_name; // is allocated by char [] when structure is constructed
bool task_name_allocated;
int mutex_id;
int parallel_single; // TASK_PARALLEL/TASK_SINGLE
int num_threads;
// how to describe some (DFullLDLt)s which are shared
// assignment of processor group for DFullLDLt is done by statically
// 5 processors is assigned to 2 + 1 + 1 + 1 / 3 + 2 / 5
// with concerning task size
int level;
int phase;
vector *queue;
int begin;
int end;
unsigned char status;
int pos;
long ops_complexity;
~C_task_seq() {
if (task_name_allocated) {
delete [] task_name;
}
}
C_task_seq() {}
C_task_seq(int task_id_,
string task_name_,
int mutex_id_,
int parallel_single_,
int num_threads_,
int level_,
int phase_,
vector *queue_,
int begin_,
int end_,
long ops_complexity_) :
task_id(task_id_),
referred(0),
// task_name(task_name_),
mutex_id(mutex_id_),
parallel_single(parallel_single_),
num_threads(num_threads_),
level(level_),
phase(phase_),
queue(queue_),
begin(begin_),
end(end_),
status(TASK_WAITING),
pos(begin_),
ops_complexity(ops_complexity_) {
if (!task_name_.empty()) {
task_name = new char[task_name_.length() + 1];
strcpy(task_name, task_name_.c_str());
task_name_allocated = true;
}
else {
task_name_allocated = false;
}
} ;
C_task_seq(const C_task_seq &im)
{
task_id = im.task_id;
referred = im.referred;
if (im.task_name_allocated) {
task_name = new char[strlen(im.task_name) + 1];
strcpy(task_name, im.task_name);
task_name_allocated = true;
}
else {
task_name_allocated = false;
}
mutex_id = im.mutex_id;
parallel_single = im.parallel_single;
num_threads = im.num_threads;
level = im.level;
phase = im.phase;
queue = im.queue; // copy pointer
begin = im.begin;
end = im.end;
status = im.status;
pos = im.pos;
ops_complexity = im.ops_complexity;
}
};
bool C_task_seq_complexity_smaller(C_task_seq *a, C_task_seq *b);
bool C_task_seq_complexity_greater(C_task_seq *a, C_task_seq *b);
bool C_task_seq_beginidx_smaller(C_task_seq *a, C_task_seq *b);
struct index_strip {
int begin_dst;
int begin_src;
int width;
~index_strip() {}
index_strip() {}
index_strip(int begin_dst_, int begin_src_, int width_) :
begin_dst(begin_dst_),
begin_src(begin_src_),
width(width_) {}
index_strip(const index_strip &im)
{
begin_dst = im.begin_dst;
begin_src = im.begin_src;
width = im.width;
}
};
struct index_strip2 {
int begin_dst;
int begin_src0;
int begin_src1;
int width;
~index_strip2() {}
index_strip2() {}
index_strip2(int begin_dst_, int begin_src0_, int begin_src1_, int width_) :
begin_dst(begin_dst_),
begin_src0(begin_src0_),
begin_src1(begin_src1_),
width(width_) {}
index_strip2(const index_strip2 &im)
{
begin_dst = im.begin_dst;
begin_src0 = im.begin_src0;
begin_src1 = im.begin_src1;
width = im.width;
}
};
template
struct child_contribution {
int child_id;
int diag_size;
int offdiag_size;
list diag_strip;
list offdiag_strip;
int father_row;
SquareBlockMatrix *father_diag_pt;
RectBlockMatrix *father_offdiag_pt;
RectBlockMatrix *father_offdiag_unsym_pt;
int child_row;
SquareBlockMatrix* child_pt;
// double **child_pt;
~child_contribution() {}
child_contribution() {}
child_contribution(int child_id_,
int diag_size_,
int offdiag_size_,
list diag_strip_,
list offdiag_strip_,
SquareBlockMatrix *father_diag_pt_,
RectBlockMatrix *father_offdiag_pt_,
RectBlockMatrix *father_offdiag_unsym_pt_,
int child_row_,
SquareBlockMatrix* child_pt_ ) :
child_id(child_id_),
diag_size(diag_size_),
offdiag_size(offdiag_size_),
diag_strip(diag_strip_),
offdiag_strip(offdiag_strip_),
father_row(diag_size_), // father_row(father_row_),
father_diag_pt(father_diag_pt_),
father_offdiag_pt(father_offdiag_pt_),
father_offdiag_unsym_pt(father_offdiag_unsym_pt_),
child_row(child_row_),
child_pt(child_pt_) {}
child_contribution(const child_contribution &im)
{
child_id = im.child_id;
diag_size = im.diag_size;
offdiag_size = im.offdiag_size;
diag_strip = im.diag_strip;
offdiag_strip = im.offdiag_strip;
father_row = im.father_row;
father_diag_pt = im.father_diag_pt;
father_offdiag_pt = im.father_offdiag_pt;
father_offdiag_unsym_pt = im.father_offdiag_unsym_pt;
child_row = im.child_row;
child_pt = im.child_pt;
}
};
struct diag_contribution {
int child_id;
int child_row;
int child_column;
int father_row;
list diag_strip;
~diag_contribution() {}
diag_contribution() {}
diag_contribution(int child_id_,
int child_row_,
int child_column_,
int father_row_,
list diag_strip_) :
child_id(child_id_),
child_row(child_row_),
child_column(child_column_),
father_row(father_row_),
diag_strip(diag_strip_) {}
diag_contribution(const diag_contribution &im)
{
child_id = im.child_id;
child_row = im.child_row;
child_column = im.child_column;
father_row = im.father_row;
diag_strip = im.diag_strip;
}
};
template
struct C_Dsub_FwBw_arg {
int dim;
int **nrhs;
int n_diag;
bool access_global;
int level;
Dissection::Tree *btree;
list* diag_contribs;
T **x;
T **yi;
T ***zi;
int *loc2glob_diag;
long *ops_complexity;
~C_Dsub_FwBw_arg() {
delete ops_complexity;
}
C_Dsub_FwBw_arg() {}
C_Dsub_FwBw_arg(int dim_,
int **nrhs_,
int n_diag_,
bool access_global_,
int level_,
Dissection::Tree *btree_,
list* diag_contribs_,
T **x_,
T **yi_,
T ***zi_,
int *loc2glob_diag_) :
dim(dim_),
nrhs(nrhs_),
n_diag(n_diag_),
access_global(access_global_),
level(level_),
btree(btree_),
diag_contribs(diag_contribs_),
x(x_),
yi(yi_),
zi(zi_),
loc2glob_diag(loc2glob_diag_) {
ops_complexity = new long;
}
C_Dsub_FwBw_arg(const C_Dsub_FwBw_arg &im)
{
dim = im.dim;
nrhs = im.nrhs;
n_diag = im.n_diag;
level = im.level;
access_global = im.access_global;
btree = im.btree;
diag_contribs = im.diag_contribs;
x = im.x;
yi = im.yi;
zi = im.zi;
loc2glob_diag = im.loc2glob_diag;
ops_complexity = im.ops_complexity;
}
};
template
struct C_Dfill_FwBw_arg {
int **nrhs;
int d;
int level;
Dissection::Tree *btree;
int n_offdiag;
T ***yi;
T **zi;
long *ops_complexity;
~C_Dfill_FwBw_arg() {
delete ops_complexity;
}
C_Dfill_FwBw_arg() {}
C_Dfill_FwBw_arg(int **nrhs_,
int d_,
int level_,
Dissection::Tree *btree_,
int n_offdiag_,
T ***yi_,
T **zi_) :
nrhs(nrhs_),
d(d_),
level(level_),
btree(btree_),
n_offdiag(n_offdiag_),
yi(yi_),
zi(zi_) {
ops_complexity = new long;
}
C_Dfill_FwBw_arg(const C_Dfill_FwBw_arg &im)
{
nrhs = im.nrhs;
d = im.d;
level = im.level;
btree = im.btree;
n_offdiag = im.n_offdiag;
yi = im.yi;
zi = im.zi;
ops_complexity = im.ops_complexity;
}
};
template
struct C_DenseFwBw_arg
{
bool isSym;
bool isBackward;
int dim;
bool **isTrans;
int **nrhs;
int n_diag;
int nrow;
int k_block;
int kk;
T **xi;
T **wi;
T **yi;
T **x;
SquareBlockMatrix *LDLt;
bool isFirstBlock;
bool isLastBlock;
int *loc2glob;
long *ops_complexity;
bool verbose;
FILE **fp;
~C_DenseFwBw_arg() {
delete ops_complexity;
}
C_DenseFwBw_arg() {}
C_DenseFwBw_arg(bool isSym_,
bool isBackward_,
int dim_,
bool **isTrans_,
int **nrhs_,
int n_diag_,
int nrow_,
int k_block_,
int kk_,
T **xi_,
T **wi_,
T **yi_,
T **x_,
SquareBlockMatrix *LDLt_,
bool isFirstBlock_,
bool isLastBlock_,
int *loc2glob_,
bool verbose_,
FILE **fp_) :
isSym(isSym_),
isBackward(isBackward_),
dim(dim_),
isTrans(isTrans_),
nrhs(nrhs_),
n_diag(n_diag_),
nrow(nrow_),
k_block(k_block_),
kk(kk_),
xi(xi_),
wi(wi_),
yi(yi_),
x(x_),
LDLt(LDLt_),
isFirstBlock(isFirstBlock_),
isLastBlock(isLastBlock_),
loc2glob(loc2glob_),
verbose(verbose_),
fp(fp_)
{
ops_complexity = new long;
}
C_DenseFwBw_arg(C_DenseFwBw_arg &im)
{
isSym = im.isSym;
isBackward = im.isBackward;
dim = im.dim;
isTrans = im.isTrans;
nrhs = im.nrhs;
n_diag = im.n_diag;
nrow = im.nrow;
k_block = im.k_block;
kk = im.kk;
xi = im.xi;
wi = im.wi;
yi = im.yi;
x = im.x;
LDLt = im.LDLt;
isFirstBlock = im.isFirstBlock;
isLastBlock = im.isLastBlock;
loc2glob = im.loc2glob;
verbose = im.verbose;
fp = im.fp;
}
};
template
struct C_DenseFwBwOffdiag_arg
{
bool trans;
bool isLower;
int dim;
bool **isTrans;
int **nrhs;
int lda;
int ldb;
int ldc;
int nrow;
int ncol;
T **xi;
int ii;
T **yi;
T **zi;
int jj;
SquareBlockMatrix *LDLt;
int i_block;
int j_block;
T alpha;
T beta;
long *ops_complexity;
~C_DenseFwBwOffdiag_arg() {
delete ops_complexity;
}
C_DenseFwBwOffdiag_arg() {}
C_DenseFwBwOffdiag_arg(bool trans_,
bool isLower_,
int dim_,
bool **isTrans_,
int **nrhs_,
int lda_,
int ldb_,
int ldc_,
int nrow_,
int ncol_,
T **xi_,
int ii_,
T **yi_,
T **zi_,
int jj_,
SquareBlockMatrix *LDLt_,
int i_block_,
int j_block_,
T alpha_,
T beta_) :
trans(trans_),
isLower(isLower_),
dim(dim_),
isTrans(isTrans_),
nrhs(nrhs_),
lda(lda_),
ldb(ldb_),
ldc(ldc_),
nrow(nrow_),
ncol(ncol_),
xi(xi_),
ii(ii_),
yi(yi_),
zi(zi_),
jj(jj_),
LDLt(LDLt_),
i_block(i_block_),
j_block(j_block_),
alpha(alpha_),
beta(beta_)
{
ops_complexity = new long;
}
C_DenseFwBwOffdiag_arg(C_DenseFwBwOffdiag_arg &im)
{
trans = im.trans;
isLower = im.isLower;
dim = im.dim;
isTrans = im.isTrans;
nrhs = im.nrhs;
lda = im.lda;
ldb = im.ldb;
ldc = im.ldc;
nrow = im.nrow;
ncol = im.ncol;
xi = im.xi;
ii = im.ii;
yi = im.yi;
zi = im.zi;
jj = im.jj;
LDLt = im.LDLt;
i_block = im.i_block;
j_block = im.j_block;
alpha = im.alpha;
beta = im.beta;
ops_complexity = im.ops_complexity;
}
};
template
struct C_StripsFwBwOffdiag_arg
{
bool isLower;
int dim;
bool **isTrans;
int **nrhs;
int lda;
int ldb;
int ldc;
int nrow;
int ncol;
T **xi;
int ii;
T **yi;
int jj;
RectBlockMatrix *upper;
RectBlockMatrix *lower;
int i_block;
int j_block;
T alpha;
T beta;
long *ops_complexity;
~C_StripsFwBwOffdiag_arg() {
delete ops_complexity;
}
C_StripsFwBwOffdiag_arg() {}
C_StripsFwBwOffdiag_arg(bool isLower_,
int dim_,
bool **isTrans_,
int **nrhs_,
int lda_,
int ldb_,
int ldc_,
int nrow_,
int ncol_,
T **xi_,
int ii_,
T **yi_,
int jj_,
RectBlockMatrix *upper_,
RectBlockMatrix *lower_,
int i_block_,
int j_block_,
T alpha_,
T beta_) :
isLower(isLower_),
dim(dim_),
isTrans(isTrans_),
nrhs(nrhs_),
lda(lda_),
ldb(ldb_),
ldc(ldc_),
nrow(nrow_),
ncol(ncol_),
xi(xi_),
ii(ii_),
yi(yi_),
jj(jj_),
upper(upper_),
lower(lower_),
i_block(i_block_),
j_block(j_block_),
alpha(alpha_),
beta(beta_)
{
ops_complexity = new long;
}
C_StripsFwBwOffdiag_arg(C_StripsFwBwOffdiag_arg &im)
{
isLower = im.isLower;
dim = im.dim;
isTrans = im.isTrans;
nrhs = im.nrhs;
lda = im.lda;
ldb = im.ldb;
ldc = im.ldc;
nrow = im.nrow;
ncol = im.ncol;
xi = im.xi;
ii = im.ii;
yi = im.yi;
jj = im.jj;
upper = im.upper;
lower = im.lower;
i_block = im.i_block;
j_block = im.j_block;
alpha = im.alpha;
beta = im.beta;
ops_complexity = im.ops_complexity;
}
};
#define RESTRICT
void print_strips(const char *name, list &strips, FILE *fp);
void print_strips(const char *name, list &strips, FILE *fp);
void assign_tasks_statically(list *queue_static,
list &queue_dynamic,
long *nops_sum,
list &task_seq_tmp,
const int task_id,
const char *task_name_,
const int level,
const int phase,
const long nops_block_total,
int num_threads);
template
int count_diag_negative(SquareBlockMatrix& Diag);
template<>
int count_diag_negative(SquareBlockMatrix& Diag);
template<>
int count_diag_negative >(SquareBlockMatrix >& Diag);
template<>
int count_diag_negative(SquareBlockMatrix& Diag);
template<>
int count_diag_negative >(SquareBlockMatrix >& Diag);
template<>
int count_diag_negative(SquareBlockMatrix& Diag);
template<>
int count_diag_negative >(SquareBlockMatrix >& Diag);
template
int count_diag_negative(SubSquareMatrix& Diag);
template<>
int count_diag_negative(SubSquareMatrix& Diag);
template<>
int count_diag_negative >(SubSquareMatrix >& Diag);
template<>
int count_diag_negative(SubSquareMatrix& Diag);
template<>
int count_diag_negative >(SubSquareMatrix >& Diag);
template<>
int count_diag_negative(SubSquareMatrix& Diag);
template<>
int count_diag_negative >(SubSquareMatrix >& Diag);
template
void full_gauss3(int *n0,
T *a,
const int n,
double *pivot,
int *permute,
const bool isSym,
const double eps,
const bool verbose,
FILE *fp);
void CopyUpper2LowerSymm(double RESTRICT *s, const double RESTRICT *s_t,
const int size_b2,
int i, int block_nrow, int ncol);
void CopyUpper2LowerSquare(double RESTRICT *s, const double RESTRICT *s_t,
const int size_b2,
int i, int j, int block_nrow, int block_ncol,
int ncol);
template
void C_SparseSymbFact(void *arg_);
template
void C_SparseNumFact(void *arg_);
template
void C_SparseLocalSchur(void *arg_);
template
void dump_matrix(FILE *fp, const int nrow, T *a);
template<>
void dump_matrix(FILE *fp, const int nrow, double *a);
template
void dump_matrix(FILE *fp, const int nrow, const int ncol, T *a);
template<>
void dump_matrix(FILE *fp, const int nrow, const int ncol, double *a);
template
void dump_matrix(FILE *fp, const int kk,
const int nrow, const int ncol, const int nn, T *a);
template
void dump_matrix(FILE *fp,
RectBlockMatrix &a);
template
void dump_matrix(FILE *fp,
SquareBlockMatrix &a);
template
void dump_matrix(FILE *fp, const int nrow, const int nnz, int *prow,
int *indcols, int *indvals, T *a);
template
void C_dfull_gauss_b(void *arg_);
template
void C_dinvDL_timesU(void *arg_);
template
void C_dupdateb_Schur_diag(void *arg_);
template
void C_dupdateb_Schur_offdiag(void *arg_);
template
void C_gauss_whole_pivot(void *arg_);
template
void C_dupdateb_Schur_offdiag_t(void *arg_);
void C_CopyLowerMatrix(int n, const double *A, double *LDlt);
void C_DTRSMScale_solve_seq(void *arg_);
template
void C_FillSymMatrix(void *arg_);
template
void C_FillMatrix_diag(void *arg_);
template
void C_FillMatrix_offdiag(void *arg_);
template
void DSchurGEMM_diag(void *arg_);
template
void DSchurGEMM_diag_two(void *arg_);
template
void DSchurGEMM_offdiag(void *arg_);
template
void DSchurGEMM_offdiag_two(void *arg_);
template
void C_DTRSMScale_diag_upper(void *arg_);
template
void C_DTRSMScale_offdiag_upper(void *arg_);
template
void C_DTRSMScale_diag_lower(void *arg_);
template
void C_DTRSMScale_offdiag_lower(void *arg_);
template
void C_DTRSMScale_solve(void *arg_);
template
void C_deallocLower(void *arg_);
template
void C_deallocLocalSchur(void *arg_);
template
void C_SparseFw(void *arg_);
template
void C_SparseBw(void *arg_);
template
void C_Dsub_FwBw(void *arg_);
template
void C_DenseFwBw_diag(void *arg_);
template
void C_DenseFwBw_offdiag(void *arg_);
template
void C_StripsFwBw_offdiag(void *arg_);
template
void C_Dfill_FwBw(void *arg_);
template
void erase_task(C_task *& task);
void C_dummy(void *arg_);
#define imin(a, b) ((a) < (b) ? (a) : (b))
#define imax(a, b) ((a) > (b) ? (a) : (b))
int compare_DTRSMScale_task(const void *_a, const void *_b);
int compare_DSchurGEMM_task(const void* _a, const void* _b);
int compare_source_dist_index(const void *_a, const void *_b);
int convert_array2strip(list &strips,
vector& array);
int combine_two_strips(list &stripsa,
list &stripsb,
list &stripsc,
list &strips0,
list &strips1,
const int size);
void copy_two_strips(list &strips2,
list &strips0,
list &strips1);
void split_two_strips(list &strips0,
list &strips1,
list &strips2,
index_strip strip0,
index_strip strip1);
template
int dimKernDense(vector &singIdx,
const int n,
const int aug_dim,
const U eps_machine,
const double eps_piv,
SquareBlockMatrix &D,
T *a,
const bool refactorize,
const bool isBlocked,
const bool isSym,
const bool verbose,
FILE *fp);
template
void calc_relative_norm(double *norm_l2, double *norm_infty,
const T *v, const T *u, const int dim);
template<>
void calc_relative_norm(double *norm_l2, double *norm_infty,
const double *v, const double *u,
const int dim);
template<>
void calc_relative_norm(double *norm_l2, double *norm_infty,
const quadruple *v, const quadruple *u,
const int dim);
template<>
void calc_relative_norm >(double *norm_l2, double *norm_infty,
const complex *v,
const complex *u,
const int dim);
template<>
void calc_relative_norm >(double *norm_l2,
double *norm_infty,
const complex *v,
const complex *u,
const int dim);
template
void calc_relative_normscaled(double *norm_l2, double *norm_infty,
const T *v, const T *u, const U *w,
const int dim);
template<>
void calc_relative_normscaled(double *norm_l2, double *norm_infty,
const double *v, const double *u,
const double *w,
const int dim);
template<>
void calc_relative_normscaled(double *norm_l2, double *norm_infty,
const quadruple *v, const quadruple *u,
const quadruple *w,
const int dim);
template<>
void calc_relative_normscaled(double *norm_l2, double *norm_infty,
const quadruple *v, const quadruple *u,
const double *w,
const int dim);
template<>
void calc_relative_normscaled,
double>(double *norm_l2, double *norm_infty,
const complex *v,
const complex *u,
const double *w,
const int dim);
template<>
void calc_relative_normscaled,
quadruple>(double *norm_l2,
double *norm_infty,
const complex *v,
const complex *u,
const quadruple *w,
const int dim);
template<>
void calc_relative_normscaled,
double>(double *norm_l2,
double *norm_infty,
const complex *v,
const complex *u,
const double *w,
const int dim);
int CSR_sym2unsym(CSR_indirect *unsym,
const int *ptSymRows, const int *indSymCols,
const int *map_eqn, const int *remap_eqn,
const int dim,
const bool upper_flag = true,
const bool verbose = false, FILE *fp = NULL);
bool CSR_unsym2unsym(CSR_indirect *unsym,
const int *ptUnSymRows, const int *indUnSymCols,
const int *map_eqn, const int *remap_eqn,
const int dim, const bool vebose, FILE *fp);
void swap_queues_n(vector &queue,
vector &queue_index,
const int ii,
const int jj,
const int n,
vector &tmp,
vector &tmp_index);
int EraseNullParents(vector &queue);
int EraseNullParents(C_task *task);
bool compare_task_name(C_task *first, C_task *second);
extern "C" {
void c_getrealtime_(uint64_t &tmprofiles, const int &m);
void c_fileout_(uint64_t &fp_prt, char *strgs, const int &force_stderr);
}
void swap_2x2pivots(const int way,
int *pivot_width, int *permute_q,
const int dim_augkern, const int nn0,
const int n_dim, double *a1, long double *aq,
double *d1, long double *d1q, double *a_fact);
template void dump_vectors(int nrow, int nn0, T *v,
string fname);
void ComputeSVD(double *b, const double *a_, const int n);
#endif