void LocalVector<ValueType>::MoveToHostAsync(void) {
LOG_DEBUG(this, "LocalVector::MoveToHostAsync()",
"");
assert(this->asyncf == false);
if (_paralution_available_accelerator() == false)
LOG_VERBOSE_INFO(4,"*** info: LocalVector::MoveToAcceleratorAsync() no accelerator available - doing nothing");
if ( (_paralution_available_accelerator() == true) &&
(this->vector_ == this->vector_accel_)) {
this->vector_host_ = new HostVector<ValueType>(this->local_backend_);
// Copy to host
this->vector_host_->CopyFromAsync(*this->vector_accel_);
this->asyncf = true;
LOG_VERBOSE_INFO(4, "*** info: LocalVector::MoveToHostAsync() accelerator to host transfer (started)");
}
}
bool HostVector<ValueType>::Check(void) const {
bool check = true;
if (this->size_ > 0) {
for (int i=0; i<this->size_; ++i)
if ((paralution_abs(this->vec_[i]) ==
std::numeric_limits<ValueType>::infinity()) || // inf
(this->vec_[i] != this->vec_[i])) { // NaN
LOG_VERBOSE_INFO(2,"*** error: Vector:Check - problems with vector data");
return false;
}
if ((paralution_abs(this->size_) ==
std::numeric_limits<int>::infinity()) || // inf
( this->size_ != this->size_)) { // NaN
LOG_VERBOSE_INFO(2,"*** error: Vector:Check - problems with vector size");
return false;
}
} else {
assert(this->size_ == 0);
assert(this->vec_ == NULL);
}
return check;
}
void LocalVector<ValueType>::MoveToHost(void) {
LOG_DEBUG(this, "LocalVector::MoveToHost()",
"");
if (_paralution_available_accelerator() == false)
LOG_VERBOSE_INFO(4,"*** info: LocalVector::MoveToHost() no accelerator available - doing nothing");
if ( (_paralution_available_accelerator() == true) &&
(this->vector_ == this->vector_accel_)) {
this->vector_host_ = new HostVector<ValueType>(this->local_backend_);
// Copy to host
this->vector_host_->CopyFrom(*this->vector_accel_);
this->vector_ = this->vector_host_;
delete this->vector_accel_;
this->vector_accel_ = NULL;
LOG_VERBOSE_INFO(4, "*** info: LocalVector::MoveToHost() accelerator to host transfer");
}
}
void LocalVector<ValueType>::Sync(void) {
LOG_DEBUG(this, "LocalVector::Sync()",
"");
// check for active async transfer
if (this->asyncf == true) {
// The Move*Async function is active
if ( (this->vector_accel_ != NULL) &&
(this->vector_host_ != NULL)) {
// MoveToHostAsync();
if ( (_paralution_available_accelerator() == true) &&
(this->vector_ == this->vector_accel_)) {
_paralution_sync();
this->vector_ = this->vector_host_;
delete this->vector_accel_;
this->vector_accel_ = NULL;
LOG_VERBOSE_INFO(4, "*** info: LocalVector::MoveToHostAsync() accelerator to host transfer (synced)");
}
// MoveToAcceleratorAsync();
if ( (_paralution_available_accelerator() == true) &&
(this->vector_ == this->vector_host_)) {
_paralution_sync();
this->vector_ = this->vector_accel_;
delete this->vector_host_;
this->vector_host_ = NULL;
LOG_VERBOSE_INFO(4, "*** info: LocalVector::MoveToAcceleratorAsync() host to accelerator transfer (synced)");
}
} else {
// The Copy*Async function is active
_paralution_sync();
LOG_VERBOSE_INFO(4, "*** info: LocalVector::Copy*Async() transfer (synced)");
}
}
this->asyncf = false;
}
void LocalVector<ValueType>::SetRandom(const ValueType a, const ValueType b, const int seed) {
LOG_DEBUG(this, "LocalVector::SetRandom()",
"");
if (this->get_size() > 0) {
// host only
bool on_host = this->is_host();
if (on_host == false)
this->MoveToHost();
assert(this->vector_ == this->vector_host_);
this->vector_host_->SetRandom(a, b, seed);
if (on_host == false) {
LOG_VERBOSE_INFO(2, "*** warning: LocalVector::SetRandom() is performed on the host");
this->MoveToAccelerator();
}
}
}
bool LocalVector<ValueType>::Check(void) const {
LOG_DEBUG(this, "LocalVector::Check()",
"");
bool check = false;
if (this->is_accel() == true) {
LocalVector<ValueType> vec;
vec.CopyFrom(*this);
check = vec.Check();
LOG_VERBOSE_INFO(2, "*** warning: LocalVector::Check() is performed on the host");
} else {
check = this->vector_->Check();
}
return check;
}
void MixedPrecisionDC<OperatorTypeH, VectorTypeH, ValueTypeH,
OperatorTypeL, VectorTypeL, ValueTypeL>::MoveToAcceleratorLocalData_(void) {
if (this->build_ == true) {
LOG_VERBOSE_INFO(2, "MixedPrecisionDC: the inner solver is always performed on the accel; this function does nothing");
}
}
void LocalVector<ValueType>::Prolongation(const LocalVector<ValueType> &vec_coarse, const LocalVector<int> &map) {
LOG_DEBUG(this, "LocalVector::Prolongation()",
"");
assert(&vec_coarse != NULL);
assert(&map != NULL);
assert(&vec_coarse != this);
assert( ( (this->vector_ == this->vector_host_) && (vec_coarse.vector_ == vec_coarse.vector_host_)) ||
( (this->vector_ == this->vector_accel_) && (vec_coarse.vector_ == vec_coarse.vector_accel_) ) );
assert( ( (this->vector_ == this->vector_host_) && (map.vector_ == map.vector_host_)) ||
( (this->vector_ == this->vector_accel_) && (map.vector_ == map.vector_accel_) ) );
if (this->get_size() > 0) {
bool err = this->vector_->Prolongation(*vec_coarse.vector_, *map.vector_);
if ((err == false) && (this->is_host() == true)) {
LOG_INFO("Computation of LocalVector::Prolongation() fail");
this->info();
FATAL_ERROR(__FILE__, __LINE__);
}
if (err == false) {
this->MoveToHost();
LocalVector<int> map_tmp;
map_tmp.CopyFrom(map);
LocalVector<ValueType> vec_coarse_tmp;
vec_coarse_tmp.CopyFrom(vec_coarse);
if (this->vector_->Prolongation(*vec_coarse_tmp.vector_, *map_tmp.vector_) == false) {
LOG_INFO("Computation of LocalVector::Prolongation() fail");
this->info();
FATAL_ERROR(__FILE__, __LINE__);
}
LOG_VERBOSE_INFO(2, "*** warning: LocalVector::Prolongation() is performed on the host");
this->MoveToAccelerator();
}
}
}
void MixedPrecisionDC<OperatorTypeH, VectorTypeH, ValueTypeH,
OperatorTypeL, VectorTypeL, ValueTypeL>::SolveNonPrecond_(const VectorTypeH &rhs,
VectorTypeH *x) {
assert(x != NULL);
assert(x != &rhs);
assert(this->op_ != NULL);
assert(this->Solver_L_ != NULL);
assert(this->build_ == true);
this->x_h_ = x;
// initial residual = b - Ax
this->op_h_->Apply(*this->x_h_, &this->r_h_);
this->r_h_.ScaleAdd(ValueTypeH(-1.0), rhs);
this->iter_ctrl_.InitResidual(this->Norm(this->r_h_));
while (!this->iter_ctrl_.CheckResidual(this->Norm(this->r_h_))) {
// cast to lower precision
// TODO
// use template
this->r_l_.CopyFromDouble(this->r_h_);
this->r_l_.MoveToAccelerator();
this->d_l_.Clear();
this->d_l_.MoveToAccelerator();
LOG_VERBOSE_INFO(2, "MixedPrecisionDC: starting the internal solver [" << 8*sizeof(ValueTypeL) << "bit]");
// set the initial solution to zero
this->d_l_.Allocate("d_l",this->r_l_.get_size());
this->d_l_.Zeros();
// solver the inner problem (low)
this->Solver_L_->Solve(this->r_l_,
&this->d_l_);
this->r_l_.Clear();
this->r_l_.MoveToHost();
this->d_l_.MoveToHost();
LOG_VERBOSE_INFO(2, "MixedPrecisionDC: defect correcting on the host [" << 8*sizeof(ValueTypeH) << "bit]");
// TODO
// use template
this->d_h_.CopyFromFloat(this->d_l_);
this->x_h_->AddScale(this->d_h_, ValueTypeH(1.0));
// initial residual = b - Ax
this->op_h_->Apply(*this->x_h_, &this->r_h_);
this->r_h_.ScaleAdd(ValueTypeH(-1.0), rhs);
}
}
