// ----------------------------------------------------------------
static char* test_no_overlap() {
mlhmmv_t* pmap = mlhmmv_alloc();
int error = 0;
printf("----------------------------------------------------------------\n");
printf("empty map:\n");
mlhmmv_print(pmap);
sllmv_t* pmvkeys1 = sllmv_single(imv(3));
mv_t value1 = mv_from_int(4LL);
printf("\n");
printf("keys1: ");
sllmv_print(pmvkeys1);
printf("value1: %s\n", mv_alloc_format_val(&value1));
mlhmmv_put(pmap, pmvkeys1, &value1);
printf("map:\n");
mlhmmv_print(pmap);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys1, &error), &value1));
sllmv_t* pmvkeys2 = sllmv_double(smv("abcde"), imv(-6));
mv_t value2 = mv_from_int(7);
printf("\n");
printf("keys2: ");
sllmv_print(pmvkeys2);
printf("value2: %s\n", mv_alloc_format_val(&value2));
mlhmmv_put(pmap, pmvkeys2, &value2);
printf("map:\n");
mlhmmv_print(pmap);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys2, &error), &value2));
sllmv_t* pmvkeys3 = sllmv_triple(imv(0), smv("fghij"), imv(0));
mv_t value3 = mv_from_int(0LL);
printf("\n");
printf("keys3: ");
sllmv_print(pmvkeys3);
printf("value3: %s\n", mv_alloc_format_val(&value3));
mlhmmv_put(pmap, pmvkeys3, &value3);
printf("map:\n");
mlhmmv_print(pmap);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys3, &error), &value3));
sllmv_free(pmvkeys1);
mlhmmv_free(pmap);
return NULL;
}
// ----------------------------------------------------------------
static char* test_overlap() {
mlhmmv_t* pmap = mlhmmv_alloc();
int error = 0;
printf("----------------------------------------------------------------\n");
sllmv_t* pmvkeys = sllmv_single(imv(3));
mv_t* ptermval = imv(4);
mlhmmv_put(pmap, pmvkeys, ptermval);
mlhmmv_print(pmap);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
ptermval = imv(5);
mlhmmv_put(pmap, pmvkeys, ptermval);
mlhmmv_print(pmap);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
pmvkeys = sllmv_double(imv(3), smv("x"));
ptermval = imv(6);
mlhmmv_put(pmap, pmvkeys, ptermval);
mlhmmv_print(pmap);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
ptermval = imv(7);
mlhmmv_put(pmap, pmvkeys, ptermval);
mlhmmv_print(pmap);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
pmvkeys = sllmv_triple(imv(3), imv(9), smv("y"));
ptermval = smv("z");
mlhmmv_put(pmap, pmvkeys, ptermval);
mlhmmv_print(pmap);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
pmvkeys = sllmv_triple(imv(3), imv(9), smv("z"));
ptermval = smv("y");
mlhmmv_put(pmap, pmvkeys, ptermval);
mlhmmv_print(pmap);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
mlhmmv_free(pmap);
return NULL;
}
void abcd::distributeRhs()
{
mpi::broadcast(inter_comm, use_xf, 0);
if(icntl[Controls::block_size] < nrhs) icntl[Controls::block_size] = nrhs;
mpi::broadcast(inter_comm, icntl[Controls::block_size], 0);
if(comm.rank() == 0) {
int r_pos = 0;
// Build my part of the RHS
//int r = std::accumulate(partitions.begin(), partitions.end(), 0, sum_rows);
int r = 0;
for(int i = 0; i < nb_local_parts; i++){
r += partitions[i].dim(0);
}
if(rhs == nullptr){
rhs = new double[n_l * nrhs];
srand(10);
B = MV_ColMat_double(m_l, icntl[Controls::block_size]);
nrmXf = 0;
Xf = MV_ColMat_double(A.dim(1), nrhs);
for(int j = 0; j < nrhs; j++){
for(int i = 0; i < A.dim(1); i++){
rhs[i + j * n_l] = (double)((rand())%100+1)/99.0;
}
}
for(int j = 0; j < nrhs; j++){
VECTOR_double xf_col(A.dim(1));
for(int i = 0; i < A.dim(1); i++) {
xf_col[i] = rhs[i + j * A.dim(1)];
}
Xf.setCol(xf_col, j);
}
MV_ColMat_double BB = smv(A, Xf);
for(int j = 0; j < nrhs; j++){
double unscaled;
for(int i = 0; i < A.dim(1); i++) {
unscaled = rhs[i + j * A.dim(1)] * dcol_[i];
if(abs(unscaled) > nrmXf) nrmXf = abs(unscaled);
Xf(i, j) = unscaled;
}
}
for(int j = 0; j < nrhs; j++){
//VECTOR_double t(rhs+j*m_l, m_l);
//B.setCol(t, j);
//B.push_back(t);
B(MV_VecIndex(0, m_l-1), MV_VecIndex(0,nrhs-1)) = BB;
}
} else {
B = MV_ColMat_double(m_l, icntl[Controls::block_size], 0);
if(row_perm.size() != 0){
for(int j = 0; j < nrhs; j++){
for(int i = 0; i < m_l; i++) {
B(i, j) = rhs[row_perm[i] + j*m_l];
}
}
} else {
for(int j = 0; j < nrhs; j++){
for(int i = 0; i < m_l; i++) {
B(i, j) = rhs[i + j*m_l];
}
}
}
diagScaleRhs(B);
}
int good_rhs = 0;
if (infNorm(B) == 0) {
good_rhs = -9;
mpi::broadcast(inter_comm, good_rhs, 0);
stringstream err_msg;
err_msg << "On process [" << comm.rank() << "], the given right-hand side is zero";
info[Controls::status] = good_rhs;
throw std::runtime_error(err_msg.str());
}
mpi::broadcast(inter_comm, good_rhs, 0);
if(icntl[Controls::block_size] > nrhs) {
double *rdata = new double[n_l * (icntl[Controls::block_size] - nrhs)];
srand(n_l);
for(int i=0; i< n_l*(icntl[Controls::block_size]-nrhs); i++){
rdata[i] = (double)((rand())%10)/99.9 + 1;
//rdata[i] = i+1;
}
MV_ColMat_double BR(rdata, n_l, icntl[Controls::block_size] - nrhs, MV_Matrix_::ref);
MV_ColMat_double RR = smv(A, BR);
B(MV_VecIndex(0,B.dim(0)-1),MV_VecIndex(nrhs,icntl[Controls::block_size]-1)) =
RR(MV_VecIndex(0,B.dim(0)-1), MV_VecIndex(0, icntl[Controls::block_size]-nrhs - 1));
delete[] rdata;
}
r_pos += r;
double *b_ptr = B.ptr();
// temp solution :
// send Xf to everybody
double *xf_ptr = Xf.ptr();
// for other masters except me!
for(int k = 1; k < parallel_cg; k++) {
inter_comm.send(k, 171, xf_ptr, Xf.dim(0));
}
// for other masters except me!
for(int k = 1; k < parallel_cg; k++) {
// get the partitions that will be sent to the master
inter_comm.send(k, 17, nrhs);
}
for(int k = 1; k < parallel_cg; k++) {
for(int j = 0; j < icntl[Controls::block_size]; j++) {
for(size_t i = 0; i < partitionsSets[k].size(); i++){
int p = partitionsSets[k][i];
inter_comm.send(k, 18, b_ptr + strow[p] + j * m_l, nbrows[p]);
}
}
}
if(!use_xf){
MV_ColMat_double BB(B);
B = MV_ColMat_double(m, icntl[Controls::block_size], 0);
int pos = 0;
for(size_t i = 0; i < partitionsSets[0].size(); i++){
int p = partitionsSets[0][i];
for(int j = 0; j < nbrows[p]; j++){
for(int k = 0; k < icntl[Controls::block_size]; k++){
B(pos, k) = BB(strow[p] + j, k);
}
pos++;
}
}
}
} else {
int good_rhs;
mpi::broadcast(inter_comm, good_rhs, 0);
if (good_rhs != 0) {
info[Controls::status] = good_rhs;
stringstream err_msg;
err_msg << "On process [" << comm.rank() << "], leaving due to an error on the master";
throw std::runtime_error(err_msg.str());
}
Xf = MV_ColMat_double(n_o, 1, 0);
double *xf_ptr = Xf.ptr();
inter_comm.recv(0, 171, xf_ptr, n_o);
inter_comm.recv(0, 17, nrhs);
int size_rhs = m*icntl[Controls::block_size];
rhs = new double[size_rhs];
for(int i = 0; i < m * icntl[Controls::block_size]; i++) rhs[i] = 0;
B = MV_ColMat_double(m, icntl[Controls::block_size], 0);
for(int j = 0; j < icntl[Controls::block_size]; j++) {
int p = 0;
for(int k = 0; k < nb_local_parts; k++){
inter_comm.recv(0, 18, rhs + p + j * m, partitions[k].dim(0));
p+= partitions[k].dim(0);
}
VECTOR_double t(rhs+j*m, m);
B.setCol(t, j);
}
delete[] rhs;
}
// and distribute max iterations
mpi::broadcast(inter_comm, icntl[Controls::itmax], 0);
mpi::broadcast(inter_comm, dcntl[Controls::threshold], 0);
#ifdef WIP
mpi::broadcast(inter_comm, dcntl[Controls::aug_filter], 0);
#endif //WIP
// A = CompRow_Mat_double();
}
// ----------------------------------------------------------------
static char* test_resize() {
mlhmmv_t* pmap = mlhmmv_alloc();
int error;
printf("----------------------------------------------------------------\n");
for (int i = 0; i < 2*MLHMMV_INITIAL_ARRAY_LENGTH; i++)
mlhmmv_put(pmap, sllmv_single(imv(i)), imv(-i));
mlhmmv_print(pmap);
printf("\n");
for (int i = 0; i < 2*MLHMMV_INITIAL_ARRAY_LENGTH; i++)
mlhmmv_put(pmap, sllmv_double(smv("a"), imv(i)), imv(-i));
mlhmmv_print(pmap);
printf("\n");
for (int i = 0; i < 2*MLHMMV_INITIAL_ARRAY_LENGTH; i++)
mlhmmv_put(pmap, sllmv_triple(imv(i*100), imv(i % 4), smv("b")), smv("term"));
mlhmmv_print(pmap);
sllmv_t* pmvkeys = sllmv_single(imv(2));
mv_t* ptermval = imv(-2);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
pmvkeys = sllmv_double(smv("a"), imv(9));
ptermval = imv(-9);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
pmvkeys = sllmv_double(smv("a"), imv(31));
ptermval = imv(-31);
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
pmvkeys = sllmv_triple(imv(0), imv(0), smv("b"));
ptermval = smv("term");
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
pmvkeys = sllmv_triple(imv(100), imv(1), smv("b"));
ptermval = smv("term");
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
pmvkeys = sllmv_triple(imv(1700), imv(1), smv("b"));
ptermval = smv("term");
mu_assert_lf(mv_equals_si(mlhmmv_get(pmap, pmvkeys, &error), ptermval));
mlhmmv_free(pmap);
return NULL;
}
