Ticket #1998: main.cpp

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/casts.hpp>
#include <boost/serialization/split_member.hpp>
#include <algorithm>
#include <stdexcept>
#include <boost/mpi.hpp>
#include <iterator>
#include <fstream>

template<typename T>
class Mtx_Wrap {

        size_t Ndims;           ///< Total number of dimensions
        size_t *dimbuf;         ///< Buffer of dimensions, from the fastest to the slowest one

        size_t Nel;                     ///< Total number of elements into the data buffer
        T *data;                        ///< Buffer of data

        bool data_owned;        ///< TRUE only if the object owns its data

        template<class InIt>
        void set_dimensions(InIt dimB,InIt dimE) {

                using namespace boost::lambda;

                Ndims = static_cast<size_t>(std::distance(dimB,dimE));
                delete []dimbuf; dimbuf = NULL;
                if (Ndims>0) {
                        dimbuf = new size_t[Ndims];
                        std::transform(dimB,dimE,dimbuf,ll_static_cast<size_t>(_1));

                        Nel = std::accumulate(dimbuf,dimbuf+Ndims,1,std::multiplies<size_t>());
                } else {
                        Nel = 0;
                }
        }


        template<class InIt>
        void copy_data(InIt dB,InIt dE) {

                using namespace boost::lambda;

                if (Nel != static_cast<size_t>(std::distance(dB,dE))) {
                        throw std::runtime_error("Wrong number of data");
                }
                delete []data; data = NULL;

                if (Nel>0) {
                        data_owned = true;
                        data = new T[Nel];
                        std::transform(dB,dE,data,ll_static_cast<T>(_1));
                }
        }

        // Split serialization into save/load
        template<class Archive>
        void save(Archive & ar,const unsigned int version) const {

                ar << Ndims;
                ar.save_binary(dimbuf,Ndims*sizeof(size_t));
                ar << Nel;
                ar.save_binary(data,Nel*sizeof(size_t));
        }

        template<class Archive>
        void load(Archive & ar, const unsigned int version) {

                if (data_owned) {
                        delete []data;
                        data = NULL;
                }
                delete []dimbuf;
                dimbuf = NULL;

                ar >> Ndims;
                dimbuf = new size_t[Ndims];
                ar.load_binary(dimbuf,Ndims*sizeof(size_t));
                ar >> Nel;
                data_owned = true;
                data = new T[Nel];
                ar.load_binary(data,Nel*sizeof(size_t));
        }

        BOOST_SERIALIZATION_SPLIT_MEMBER()

        template<typename Taux> friend class Mtx_Wrap_RW;
        friend class boost::serialization::access;

public:

        Mtx_Wrap() : Ndims(0),dimbuf(NULL),Nel(0),data(NULL),data_owned(false) {}

        Mtx_Wrap(const Mtx_Wrap &rhs) : Ndims(0),dimbuf(NULL),Nel(0),data(NULL),data_owned(false) {

                set_dimensions(rhs.dimbuf,rhs.dimbuf+rhs.Ndims);

                copy_data(rhs.data,rhs.data + rhs.Nel);
        }

        ~Mtx_Wrap() {
                if (data_owned) {
                        delete []data;
                        data = NULL;
                }
                delete []dimbuf;
                dimbuf = NULL;
        }


        Mtx_Wrap & operator =(const Mtx_Wrap &rhs) {

                if (&rhs == this) return *this;

                set_dimensions(rhs.dimbuf,rhs.dimbuf+rhs.Ndims);

                copy_data(rhs.data,rhs.data + Nel);

                return *this;
        }

        template<class InItDim,class InItData>
        void set_data(InItDim dimB,InItDim dimE,InItData dB,InItData dE) {

                set_dimensions(dimB,dimE);

                if (data_owned) {
                        delete []data; data = NULL;
                }

                copy_data(dB,dE);
        }

};

namespace mpi = boost::mpi;
using namespace std;

int main(int argc, char* argv[]) {

        mpi::environment env(argc, argv);
        mpi::communicator world;

        int rank = world.rank();

        Mtx_Wrap<float>         mtx;

        if (rank == 0) {

                float   data[] = {1.1,2.2,3.3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21};
                size_t  dims[] = {1,21};

/*              float   data[] = {1.1,2.2,3.3};
                size_t  dims[] = {1,3};*/

                size_t  Ndims = sizeof(dims)/sizeof(*dims);
                size_t  Ndata = sizeof(data)/sizeof(*data);

                mtx.set_data(dims,dims+Ndims,data,data+Ndata);
        }

        mpi::broadcast(world,mtx,0);

        return 0;
}