mixed-spmv.hpp

 
 *    template <typename ValueType, typename ValueDistribution, typename Engine>
 *    typename std::enable_if<!gko::is_complex_s<ValueType>::value, ValueType>::type
 *    get_rand_value(ValueDistribution&& value_dist, Engine&& gen)
 *    {
 *        return value_dist(gen);
 *    }
 *    
 *    
 *    template <typename ValueType, typename ValueDistribution, typename Engine>
 *    typename std::enable_if<gko::is_complex_s<ValueType>::value, ValueType>::type
 *    get_rand_value(ValueDistribution&& value_dist, Engine&& gen)
 *    {
 *        return ValueType(value_dist(gen), value_dist(gen));
 *    }
 *    
 *    
 *    double timing(std::shared_ptr<const gko::Executor> exec,
 *                  std::shared_ptr<const gko::LinOp> A,
 *                  std::shared_ptr<const gko::LinOp> b,
 *                  std::shared_ptr<gko::LinOp> x)
 *    {
 *        int warmup = 2;
 *        int rep = 10;
 *        for (int i = 0; i < warmup; i++) {
 *            A->apply(b, x);
 *        }
 *        double total_sec = 0;
 *        for (int i = 0; i < rep; i++) {
 *            auto xx = x->clone();
 *            exec->synchronize();
 *            auto start = std::chrono::steady_clock::now();
 *            A->apply(b, xx);
 *            exec->synchronize();
 *            auto stop = std::chrono::steady_clock::now();
 *            std::chrono::duration<double> duration_time = stop - start;
 *            total_sec += duration_time.count();
 *            if (i + 1 == rep) {
 *                x->copy_from(xx);
 *            }
 *        }
 *    
 *        return total_sec / rep;
 *    }
 *    
 *    
 *    }  // namespace
 *    
 *    
 *    int main(int argc, char* argv[])
 *    {
 *        using HighPrecision = double;
 *        using RealValueType = gko::remove_complex<HighPrecision>;
 *        using LowPrecision = float;
 *        using IndexType = int;
 *        using hp_vec = gko::matrix::Dense<HighPrecision>;
 *        using lp_vec = gko::matrix::Dense<LowPrecision>;
 *        using real_vec = gko::matrix::Dense<RealValueType>;
 *        using hp_mtx = gko::matrix::Ell<HighPrecision, IndexType>;
 *        using lp_mtx = gko::matrix::Ell<LowPrecision, IndexType>;
 *    
 *        std::cout << gko::version_info::get() << std::endl;
 *    
 *        if (argc == 2 && (std::string(argv[1]) == "--help")) {
 *            std::cerr << "Usage: " << argv[0] << " [executor] " << std::endl;
 *            std::exit(-1);
 *        }
 *    
 *        const auto executor_string = argc >= 2 ? argv[1] : "reference";
 *        std::map<std::string, std::function<std::shared_ptr<gko::Executor>()>>
 *            exec_map{
 *                {"omp", [] { return gko::OmpExecutor::create(); }},
 *                {"cuda",
 *                 [] {
 *                     return gko::CudaExecutor::create(0,
 *                                                      gko::OmpExecutor::create());
 *                 }},
 *                {"hip",
 *                 [] {
 *                     return gko::HipExecutor::create(0, gko::OmpExecutor::create());
 *                 }},
 *                {"dpcpp",
 *                 [] {
 *                     return gko::DpcppExecutor::create(0,
 *                                                       gko::OmpExecutor::create());
 *                 }},
 *                {"reference", [] { return gko::ReferenceExecutor::create(); }}};
 *    
 *        const auto exec = exec_map.at(executor_string)();  // throws if not valid
 *    
 *    
 *        auto hp_A = share(gko::read<hp_mtx>(std::ifstream("data/A.mtx"), exec));
 *        auto lp_A = share(gko::read<lp_mtx>(std::ifstream("data/A.mtx"), exec));
 *        auto A_dim = hp_A->get_size();
 *        auto b_dim = gko::dim<2>{A_dim[1], 1};
 *        auto x_dim = gko::dim<2>{A_dim[0], b_dim[1]};
 *        auto host_b = hp_vec::create(exec->get_master(), b_dim);
 *        std::default_random_engine rand_engine(32);
 *        auto dist = std::uniform_real_distribution<RealValueType>(0.0, 1.0);
 *        for (int i = 0; i < host_b->get_size()[0]; i++) {
 *            host_b->at(i, 0) = get_rand_value<HighPrecision>(dist, rand_engine);
 *        }
 *        auto hp_b = share(gko::clone(exec, host_b));
 *        auto lp_b = share(lp_vec::create(exec));
 *        lp_b->copy_from(hp_b);
 *    
 *        auto hp_x = share(hp_vec::create(exec, x_dim));
 *        auto lp_x = share(lp_vec::create(exec, x_dim));
 *        auto hplp_x = share(hp_x->clone());
 *        auto lplp_x = share(hp_x->clone());
 *        auto lphp_x = share(hp_x->clone());
 *    
 *    
 *        auto hp_sec = timing(exec, hp_A, hp_b, hp_x);
 *        auto lp_sec = timing(exec, lp_A, lp_b, lp_x);
 *        auto hplp_sec = timing(exec, hp_A, lp_b, hplp_x);
 *        auto lplp_sec = timing(exec, lp_A, lp_b, lplp_x);
 *        auto lphp_sec = timing(exec, lp_A, hp_b, lphp_x);
 *    
 *    
 *        auto neg_one = gko::initialize<hp_vec>({-1.0}, exec);
 *        auto hp_x_norm = gko::initialize<real_vec>({0.0}, exec->get_master());
 *        auto lp_diff_norm = gko::initialize<real_vec>({0.0}, exec->get_master());
 *        auto hplp_diff_norm = gko::initialize<real_vec>({0.0}, exec->get_master());
 *        auto lplp_diff_norm = gko::initialize<real_vec>({0.0}, exec->get_master());
 *        auto lphp_diff_norm = gko::initialize<real_vec>({0.0}, exec->get_master());
 *        auto lp_diff = hp_x->clone();
 *        auto hplp_diff = hp_x->clone();
 *        auto lplp_diff = hp_x->clone();
 *        auto lphp_diff = hp_x->clone();
 *    
 *        hp_x->compute_norm2(hp_x_norm);
 *        lp_diff->add_scaled(neg_one, lp_x);
 *        lp_diff->compute_norm2(lp_diff_norm);
 *        hplp_diff->add_scaled(neg_one, hplp_x);
 *        hplp_diff->compute_norm2(hplp_diff_norm);
 *        lplp_diff->add_scaled(neg_one, lplp_x);
 *        lplp_diff->compute_norm2(lplp_diff_norm);
 *        lphp_diff->add_scaled(neg_one, lphp_x);
 *        lphp_diff->compute_norm2(lphp_diff_norm);
 *        exec->synchronize();
 *    
 *        std::cout.precision(10);
 *        std::cout << std::scientific;
 *        std::cout << "High Precision time(s): " << hp_sec << std::endl;
 *        std::cout << "High Precision result norm: " << hp_x_norm->at(0)
 *                  << std::endl;
 *        std::cout << "Low Precision time(s): " << lp_sec << std::endl;
 *        std::cout << "Low Precision relative error: "
 *                  << lp_diff_norm->at(0) / hp_x_norm->at(0) << "\n";
 *        std::cout << "Hp * Lp -> Hp time(s): " << hplp_sec << std::endl;
 *        std::cout << "Hp * Lp -> Hp relative error: "
 *                  << hplp_diff_norm->at(0) / hp_x_norm->at(0) << "\n";
 *        std::cout << "Lp * Lp -> Hp time(s): " << lplp_sec << std::endl;
 *        std::cout << "Lp * Lp -> Hp relative error: "
 *                  << lplp_diff_norm->at(0) / hp_x_norm->at(0) << "\n";
 *        std::cout << "Lp * Hp -> Hp time(s): " << lplp_sec << std::endl;
 *        std::cout << "Lp * Hp -> Hp relative error: "
 *                  << lphp_diff_norm->at(0) / hp_x_norm->at(0) << "\n";
 *    }
 * @endcode
*/