output.h

Go to the documentation of this file.

#ifndef FPMAS_OUTPUT_H
#define FPMAS_OUTPUT_H
 
#include <fstream>
#include <sstream>
#include "fpmas/api/runtime/runtime.h"
#include "fpmas/scheduler/scheduler.h"
#include "fpmas/api/io/output.h"
#include "fpmas/communication/communication.h"
 
namespace fpmas { namespace io {
    using api::io::Watcher;
 
    struct Void {};
 
 
    template<typename T>
        struct Local  {
            typedef T Type;
            typedef Void Params;
 
            class Single {
                private:
                    Watcher<T> watcher;
                public:
                    Single(
                            api::communication::MpiCommunicator&,
                            int,
                            const Watcher<T>& watcher,
                            const Params&)
                        : watcher(watcher) {}
                    T operator()() {
                        return watcher();
                    }
            };
            class All {
                private:
                    Watcher<T> watcher;
                public:
                    All(
                            api::communication::MpiCommunicator&,
                            const Watcher<T>& watcher,
                            const Params&)
                        : watcher(watcher) {}
 
                    T operator()() {
                        return watcher();
                    }
 
            };
        };
 
    template<typename T, typename BinaryOp = std::plus<T>, template<typename> class Mpi = communication::TypedMpi>
        struct Reduce {
            typedef T Type;
            typedef Void Params;
 
            class Single {
                private:
                    Mpi<T> mpi;
                    int root;
                    Watcher<T> watcher;
                    BinaryOp binary_op;
 
                public:
                    Single(
                            api::communication::MpiCommunicator& comm,
                            int root,
                            const Watcher<T>& watcher,
                            const Params&)
                        : mpi(comm), root(root), watcher(watcher) {}
 
                    T operator()() {
                        return fpmas::communication::reduce(mpi, root, watcher(), binary_op);
                    }
            };
 
            class All {
                private:
                    Mpi<T> mpi;
                    Watcher<T> watcher;
                    BinaryOp binary_op;
 
                public:
                    All(
                            api::communication::MpiCommunicator& comm,
                            const Watcher<T>& watcher,
                            const Params&)
                        : mpi(comm), watcher(watcher) {}
 
                    T operator()() {
                        return fpmas::communication::all_reduce(mpi, watcher(), binary_op);
                    }
            };
        };
 
 
    class Cout : public api::io::OutputStream {
        public:
            std::ostream& get() override {
                return std::cout;
            }
    };
 
    class StringOutput : public api::io::OutputStream {
        private:
            std::ostringstream out;
        public:
            std::ostringstream& get() override {
                return out;
            }
 
            std::string str() const {
                return out.str();
            }
    };
 
    class FileOutput : public api::io::OutputStream {
        private:
        std::ofstream file;
        std::string filename;
        std::ios::openmode mode;
 
        public:
        FileOutput() {}
 
        FileOutput(
                std::string filename,
                std::ios::openmode mode = std::ios::out
                );
 
        FileOutput(
                std::string file_format,
                int rank,
                std::ios::openmode mode = std::ios::out
                );
 
        FileOutput(
                std::string file_format,
                api::scheduler::TimeStep step,
                std::ios::openmode mode = std::ios::out
                );
        FileOutput(
                std::string file_format,
                int rank,
                api::scheduler::TimeStep step,
                std::ios::openmode mode = std::ios::out
                );
 
        std::ofstream& get() override;
    };
 
    class DynamicFileOutput : public api::io::OutputStream {
        private:
            std::string fileformat;
            int rank;
            api::runtime::Runtime& runtime;
            FileOutput current_output;
            std::ios::openmode mode;
 
        public:
            DynamicFileOutput(
                    std::string fileformat,
                    api::communication::MpiCommunicator& comm,
                    api::runtime::Runtime& runtime,
                    std::ios::openmode mode = std::ios::out
                    ) :
                fileformat(fileformat), rank(comm.getRank()), runtime(runtime),
                mode(mode) {
                }
 
            std::ofstream& get() override {
                current_output = FileOutput(
                        fileformat, rank,
                        api::scheduler::time_step(runtime.currentDate()),
                        mode);
 
                return current_output.get();
            }
    };
 
    class OutputTask : public scheduler::TaskBase<api::scheduler::Task> {
        private:
            api::io::Output& output;
        public:
            OutputTask(api::io::Output& output)
                : output(output) {}
 
            void run() override {
                output.dump();
            }
    };
 
    class OutputBase : public api::io::Output {
        private:
            OutputTask output_task {*this};
            scheduler::Job _job {{output_task}};
        protected:
            api::io::OutputStream& output_stream;
 
        public:
            OutputBase(api::io::OutputStream& output_stream)
                : output_stream(output_stream) {
                }
 
        public:
            const api::scheduler::Job& job() override {
                return _job;
            }
    };
}}
#endif