plib.dynproc m_proc; //plib::dynproc<void, FT *, nl_fptype *, nl_fptype *, nl_fptype *, nl_fptype ** > m_proc;
public matrix_solver_GCR_t(devices.nld_solver main_solver, string name, matrix_solver_t_net_list_t nets, solver.solver_parameters_t params_, size_t size)
: base(main_solver, name, nets, params_, size)
{
mat = new plib.pGEmatrix_cr <FT, FT_OPS, int_SIZE>((uint16_t)size); //mat(static_cast<typename mat_type::index_type>(size))
m_proc = new plib.dynproc();
size_t iN = this.size();
// build the final matrix
std.vector <std.vector <unsigned> > fill = new std.vector <std.vector <unsigned> >(iN);
fill.Fill(() => { return(new std.vector <unsigned>()); });
size_t raw_elements = 0;
for (size_t k = 0; k < iN; k++)
{
fill[k].resize(iN, (unsigned)plib.pGEmatrix_cr <FT, FT_OPS, int_SIZE> .constants_e.FILL_INFINITY);
foreach (var j in this.m_terms[k].m_nz)
{
fill[k][j] = 0;
raw_elements++;
}
}
var gr = mat.gaussian_extend_fill_mat(fill);
this.log_fill(fill, mat);
mat.build_from_fill_mat(fill);
for (mat_index_type k = 0; k < iN; k++)
{
size_t cnt = 0;
// build pointers into the compressed row format matrix for each terminal
for (size_t j = 0; j < this.m_terms[k].railstart(); j++)
{
int other = this.m_terms[k].m_connected_net_idx[j];
for (var i = mat.row_idx[k]; i < mat.row_idx[k + 1]; i++)
{
if (other == (int)mat.col_idx[i])
{
this.m_mat_ptr.op(k)[j] = new Pointer <FT>(mat.A, i); //this->m_mat_ptr[k][j] = &mat.A[i];
cnt++;
break;
}
}
}
nl_assert(cnt == this.m_terms[k].railstart());
this.m_mat_ptr.op(k)[this.m_terms[k].railstart()] = new Pointer <FT>(mat.A, mat.diag[k]); //this->m_mat_ptr[k][this->m_terms[k].railstart()] = &mat.A[mat.diag[k]];
}
this.state().log().verbose.op("maximum fill: {0}", gr.first);
this.state().log().verbose.op("Post elimination occupancy ratio: {1} Ops: {0}", gr.second,
(matrix_solver_t_fptype)mat.nz_num / (matrix_solver_t_fptype)(iN * iN));
this.state().log().verbose.op(" Pre elimination occupancy ratio: {0}",
(matrix_solver_t_fptype)raw_elements / (matrix_solver_t_fptype)(iN * iN));
// FIXME: Move me
//
if (this.state().static_solver_lib().isLoaded())
{
string symname = static_compile_name();
m_proc.load(this.state().static_solver_lib(), symname);
if (m_proc.resolved())
{
this.state().log().info.op("External static solver {0} found ...", symname);
}
else
{
this.state().log().warning.op("External static solver {0} not found ...", symname);
}
}
}
} //void gaussian_back_substitution(V1 &V, const V2 &RHS)
//template <typename V1>
//void gaussian_back_substitution(V1 &V)
//template <typename M>
void build_parallel_gaussian_execution_scheme(std.vector <std.vector <unsigned> > fill) //void build_parallel_gaussian_execution_scheme(const M &fill)
{
// calculate parallel scheme for gaussian elimination
std.vector <std.vector <size_t> > rt = new std.vector <std.vector <size_t> >(base.size());
for (size_t k = 0; k < base.size(); k++)
{
rt[k] = new std.vector <size_t>();
for (size_t j = k + 1; j < base.size(); j++)
{
if (fill[j][k] < (size_t)pmatrix_cr <B, B_OPS, int_N> .constants_e.FILL_INFINITY)
{
rt[k].push_back(j);
}
}
}
std.vector <size_t> levGE = new std.vector <size_t>(base.size(), 0);
size_t cl = 0;
for (size_t k = 0; k < base.size(); k++)
{
if (levGE[k] >= cl)
{
std.vector <size_t> t = rt[k];
for (size_t j = k + 1; j < base.size(); j++)
{
bool overlap = false;
// is there overlap
if (plib.container.contains(t, j))
{
overlap = true;
}
foreach (var x in rt[j])
{
if (plib.container.contains(t, x))
{
overlap = true;
break;
}
}
if (overlap)
{
levGE[j] = cl + 1;
}
else
{
t.push_back(j);
foreach (var x in rt[j])
{
t.push_back(x);
}
}
}
cl++;
}
}
m_ge_par.clear();
m_ge_par.resize(cl + 1);
m_ge_par.Fill(() => { return(new std.vector <size_t>()); });
for (size_t k = 0; k < base.size(); k++)
{
m_ge_par[levGE[k]].push_back(k);
}
//for (std::size_t k = 0; k < m_ge_par.size(); k++)
// printf("%d %d\n", (int) k, (int) m_ge_par[k].size());
}
