monitor.hpp

Go to the documentation of this file.

//============================================================================
// vSMC/include/vsmc/core/monitor.hpp
//----------------------------------------------------------------------------
//                         vSMC: Scalable Monte Carlo
//----------------------------------------------------------------------------
// Copyright (c) 2013,2014, Yan Zhou
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//============================================================================

#ifndef VSMC_CORE_MONITOR_HPP
#define VSMC_CORE_MONITOR_HPP

#include <vsmc/internal/common.hpp>
#include <vsmc/integrate/is_integrate.hpp>
#include <vsmc/utility/aligned_memory.hpp>

#define VSMC_RUNTIME_ASSERT_CORE_MONITOR_ID(func) \
    VSMC_RUNTIME_ASSERT((id < dim()),                                        \
            ("**Monitor::"#func"** INVALID ID NUMBER ARGUMENT"))

#define VSMC_RUNTIME_ASSERT_CORE_MONITOR_ITER(func) \
    VSMC_RUNTIME_ASSERT((iter < iter_size()),                                \
            ("**Monitor::"#func"** INVALID ITERATION NUMBER ARGUMENT"))

#define VSMC_RUNTIME_ASSERT_CORE_MONITOR_FUNCTOR(func, caller, name) \
    VSMC_RUNTIME_ASSERT(static_cast<bool>(func),                             \
            ("**Monitor::"#caller"** INVALID "#name" OBJECT"))               \

namespace vsmc {

template <typename T>
class Monitor
{
    public :

    typedef T value_type;
    typedef cxx11::function<
        void (std::size_t, std::size_t, const Particle<T> &, double *)>
        eval_type;

    explicit Monitor (std::size_t dim, const eval_type &eval,
            bool record_only = false) :
        dim_(dim), eval_(eval), recording_(true), record_only_(record_only),
        name_(dim) {}

    std::size_t dim () const {return dim_;}

    std::size_t iter_size () const {return index_.size();}

    void reserve (std::size_t num)
    {
        index_.reserve(num);
        record_.reserve(dim_ * num);
    }

    bool empty () const {return !static_cast<bool>(eval_);}

    std::string &name (std::size_t id)
    {
        VSMC_RUNTIME_ASSERT_CORE_MONITOR_ID(name);

        return name_[id];
    }

    const std::string &name (std::size_t id) const
    {
        VSMC_RUNTIME_ASSERT_CORE_MONITOR_ID(name);

        return name_[id];
    }

    std::size_t index (std::size_t iter) const
    {
        VSMC_RUNTIME_ASSERT_CORE_MONITOR_ITER(index);

        return index_[iter];
    }

    double record (std::size_t id) const
    {
        std::size_t iter = iter_size() ? iter_size() - 1 : iter_size();
        VSMC_RUNTIME_ASSERT_CORE_MONITOR_ID(record);
        VSMC_RUNTIME_ASSERT_CORE_MONITOR_ITER(record);

        return record_[iter * dim_ + id];
    }

    double record (std::size_t id, std::size_t iter) const
    {
        VSMC_RUNTIME_ASSERT_CORE_MONITOR_ID(record);
        VSMC_RUNTIME_ASSERT_CORE_MONITOR_ITER(record);

        return record_[iter * dim_ + id];
    }

    template <typename OutputIter>
    void read_index (OutputIter first) const
    {std::copy(index_.begin(), index_.end(), first);}

    const std::size_t *index_data () const {return &index_[0];}

    const double *record_data () const {return &record_[0];}

    template <typename OutputIter>
    void read_record (std::size_t id, OutputIter first) const
    {
        const std::size_t N = iter_size();
        const double *riter = &record_[id];
        for (std::size_t i = 0; i != N; ++i, ++first, riter += dim_)
            *first = *riter;
    }

    template <typename OutputIterIter>
    void read_record_matrix (OutputIterIter first) const
    {
        for (std::size_t d = 0; d != dim_; ++d, ++first)
            read_record(d, *first);
    }

    template <MatrixOrder Order, typename OutputIter>
    void read_record_matrix (OutputIter first) const
    {
        const std::size_t N = iter_size();
        if (Order == ColMajor) {
            for (std::size_t d = 0; d != dim_; ++d) {
                const double *riter = &record_[d];
                for (std::size_t i = 0; i != N; ++i, ++first, riter += dim_)
                    *first = *riter;
            }
        }

        if (Order == RowMajor)
            std::copy(record_.begin(), record_.end(), first);
    }

    void set_eval (const eval_type &new_eval) {eval_ = new_eval;}

    void eval (std::size_t iter, const Particle<T> &particle)
    {
        if (!recording_)
            return;

        VSMC_RUNTIME_ASSERT_CORE_MONITOR_FUNCTOR(eval_, eval, EVALUATION);

        result_.resize(dim_);
        double *const rptr = &result_[0];
        if (record_only_) {
            eval_(iter, dim_, particle, rptr);
            push_back(iter, rptr);

            return;
        }

        const std::size_t N = static_cast<std::size_t>(particle.size());
        buffer_.resize(N * dim_);
        double *const bptr = &buffer_[0];
        const double *const wptr = particle.weight_set().weight_data();
        eval_(iter, dim_, particle, bptr);
        is_integrate_(static_cast<ISIntegrate::size_type>(N),
                static_cast<ISIntegrate::size_type>(dim_), bptr, wptr, rptr);
        push_back(iter, rptr);
    }

    void clear ()
    {
        index_.clear();
        record_.clear();
    }

    bool recording () const {return recording_;}

    void turn_on () {recording_ = true;}

    void turn_off () {recording_ = false;}

    private :

    std::size_t dim_;
    eval_type eval_;
    bool recording_;
    bool record_only_;
    std::vector<std::string> name_;
    std::vector<std::size_t> index_;
    std::vector<double, AlignedAllocator<double> > record_;
    std::vector<double, AlignedAllocator<double> > result_;
    std::vector<double, AlignedAllocator<double> > buffer_;
    ISIntegrate is_integrate_;

    void push_back (std::size_t iter, const double *rptr)
    {
        index_.push_back(iter);
        for (std::size_t d = 0; d != dim_; ++d)
            record_.push_back(rptr[d]);
    }
}; // class Monitor

} // namespace vsmc

#endif // VSMC_CORE_MONITOR_HPP