/var/lib/jenkins/jobs/Skylark/workspace/sketch/dense_transform_Elemental_star_rowdist_local.hpp

Go to the documentation of this file.

#ifndef SKYLARK_DENSE_TRANSFORM_ELEMENTAL_STAR_ROWDIST_LOCAL_HPP
#define SKYLARK_DENSE_TRANSFORM_ELEMENTAL_STAR_ROWDIST_LOCAL_HPP

#include "../base/base.hpp"

#include "transforms.hpp"
#include "dense_transform_data.hpp"
#include "../utility/comm.hpp"
#include "../utility/get_communicator.hpp"

#include "sketch_params.hpp"
#include "dense_transform_Elemental_star_rowdist.hpp"

namespace skylark { namespace sketch {
template <typename ValueType,
          elem::Distribution RowDist,
          template <typename> class ValueDistribution>
struct dense_transform_t <
    elem::DistMatrix<ValueType, elem::STAR, RowDist>,
    elem::Matrix<ValueType>,
    ValueDistribution > :
        public dense_transform_data_t<ValueDistribution> {
    // Typedef matrix and distribution types so that we can use them regularly
    typedef ValueType value_type;
    typedef elem::DistMatrix<value_type, elem::STAR, RowDist> matrix_type;
    typedef elem::Matrix<value_type> output_matrix_type;
    typedef ValueDistribution<value_type> value_distribution_type;
    typedef dense_transform_data_t<ValueDistribution> data_type;

    dense_transform_t (int N, int S, double scale, base::context_t& context)
        : data_type (N, S, scale, context) {

    }


    dense_transform_t (dense_transform_t<matrix_type,
                                         output_matrix_type,
                                         ValueDistribution>& other)
        : data_type(other) {}


    dense_transform_t(const data_type& other_data)
        : data_type(other_data) {}


    template <typename Dimension>
    void apply (const matrix_type& A,
                output_matrix_type& sketch_of_A,
                Dimension dimension) const {

        switch(RowDist) {
        case elem::VR:
        case elem::VC:
            try {
                apply_impl_vdist (A, sketch_of_A, dimension);
            } catch (std::logic_error e) {
                SKYLARK_THROW_EXCEPTION (
                    base::elemental_exception()
                        << base::error_msg(e.what()) );
            } catch(boost::mpi::exception e) {
                SKYLARK_THROW_EXCEPTION (
                    base::mpi_exception()
                        << base::error_msg(e.what()) );
            }

            break;

        default:
            SKYLARK_THROW_EXCEPTION (
                base::unsupported_matrix_distribution() );
        }
    }

    int get_N() const { return this->_N; } 
    int get_S() const { return this->_S; } 
    const sketch_transform_data_t* get_data() const { return this; }

private:

    void apply_impl_vdist(const matrix_type& A,
                         output_matrix_type& sketch_of_A,
                         skylark::sketch::rowwise_tag tag) const {

        typedef elem::DistMatrix<value_type, elem::CIRC, elem::CIRC>
            intermediate_matrix_type;

        matrix_type sketch_of_A_STAR_RD(A.Height(),
                             data_type::_S);
        intermediate_matrix_type sketch_of_A_CIRC_CIRC(A.Height(),
                             data_type::_S);

        dense_transform_t<matrix_type, matrix_type, ValueDistribution>
            transform(*this);

        transform.apply(A, sketch_of_A_STAR_RD, tag);

        sketch_of_A_CIRC_CIRC = sketch_of_A_STAR_RD;

        boost::mpi::communicator world;
        MPI_Comm mpi_world(world);
        elem::Grid grid(mpi_world);
        int rank = world.rank();
        if (rank == 0) {
            sketch_of_A = sketch_of_A_CIRC_CIRC.Matrix();
        }
    }


    void apply_impl_vdist(const matrix_type& A,
                         output_matrix_type& sketch_of_A,
                         skylark::sketch::columnwise_tag tag) const {

        typedef elem::DistMatrix<value_type, elem::CIRC, elem::CIRC>
            intermediate_matrix_type;

        matrix_type sketch_of_A_STAR_RD(data_type::_S,
                                        A.Width());
        intermediate_matrix_type sketch_of_A_CIRC_CIRC(data_type::_S,
                                        A.Width());

        dense_transform_t<matrix_type, matrix_type, ValueDistribution>
            transform(*this);

        transform.apply(A, sketch_of_A_STAR_RD, tag);

        sketch_of_A_CIRC_CIRC = sketch_of_A_STAR_RD;

        boost::mpi::communicator world;
        MPI_Comm mpi_world(world);
        elem::Grid grid(mpi_world);
        int rank = world.rank();
        if (rank == 0) {
            sketch_of_A = sketch_of_A_CIRC_CIRC.Matrix();
        }
    }

};

} } 
#endif // SKYLARK_DENSE_TRANSFORM_ELEMENTAL_STAR_ROWDIST_LOCAL_HPP