underling.hpp

Go to the documentation of this file.

//-----------------------------------------------------------------------bl-
// underling 0.3.1: an FFTW MPI-based library for 3D pencil decompositions
// https://github.com/RhysU/underling
//
// Copyright (C) 2010--2013, 2026 Rhys Ulerich
// Copyright (C) 2012, 2013 The PECOS Development Team
//
// This file is part of underling.
//
// underling is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// underling is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with underling.  If not, see <http://www.gnu.org/licenses/>.
//-----------------------------------------------------------------------el-
// $Id$
 
#ifndef UNDERLING_HPP
#define UNDERLING_HPP
 
#include <ostream>
#include <underling/underling.h>
 
namespace underling {
 
typedef underling_real real;
 
typedef underling_extents extents;
 
namespace transpose {
 
    enum { // Anonymous to avoid introducing an unnecessary type
 
        long_n2_to_long_n1 = UNDERLING_TRANSPOSE_LONG_N2_TO_LONG_N1,
 
        long_n1_to_long_n0 = UNDERLING_TRANSPOSE_LONG_N1_TO_LONG_N0,
 
        long_n0_to_long_n1 = UNDERLING_TRANSPOSE_LONG_N0_TO_LONG_N1,
 
        long_n1_to_long_n2 = UNDERLING_TRANSPOSE_LONG_N1_TO_LONG_N2,
 
        all                =  UNDERLING_TRANSPOSE_ALL,
 
        none               =  UNDERLING_TRANSPOSE_NONE
 
    };
 
}
 
namespace transposed {
 
    enum { // Anonymous to avoid introducing an unnecessary type
 
        long_n2 = UNDERLING_TRANSPOSED_LONG_N2,
 
        long_n0 = UNDERLING_TRANSPOSED_LONG_N0
 
    };
 
}
 
class noncopyable
{
protected:
    noncopyable () {}
    ~noncopyable () {}
 
private:
    noncopyable (const noncopyable &);
    noncopyable & operator = (const noncopyable &);
};
 
class grid : private noncopyable {
public:
 
    grid(MPI_Comm comm, int n0, int n1, int n2, int pA = 0, int pB = 0)
        : grid_(underling_grid_create(comm, n0, n1, n2, pA, pB))
    {};
 
    template< class InputIterator1, class InputIterator2 >
    grid(MPI_Comm comm, InputIterator1 n, InputIterator2 p)
        : grid_(NULL)
    {
        const int n0 = *n++; const int n1 = *n++; const int n2 = *n;
        const int pA = *p++; const int pB = *p;
 
        grid_ = underling_grid_create(comm, n0, n1, n2, pA, pB);
    }
 
    template< class InputIterator >
    grid(MPI_Comm comm, InputIterator n)
        : grid_(NULL)
    {
        const int n0 = *n++; const int n1 = *n++; const int n2 = *n;
 
        grid_ = underling_grid_create(comm, n0, n1, n2, 0, 0);
    }
 
    ~grid() { underling_grid_destroy(grid_); }
 
    int pA_size() const { return underling_grid_pA_size(grid_); }
 
    int pB_size() const { return underling_grid_pB_size(grid_); }
 
    underling_grid get() const { return grid_; }
 
    operator bool () const { return grid_ != NULL; };
 
private:
    underling_grid grid_; 
};
 
class problem : private noncopyable {
public:
 
    problem(const grid &g, int howmany, unsigned transposed_flags = 0)
        : problem_(underling_problem_create(
                g.get(), howmany, transposed_flags))
    {};
 
    ~problem() { underling_problem_destroy(problem_); }
 
    underling_problem get() const { return problem_; }
 
    underling_extents local_extents(int i) const
    {
        return underling_local_extents(problem_, i);
    }
 
    size_t local(int i,
                 int *start  = NULL,
                 int *size   = NULL,
                 int *stride = NULL,
                 int *order  = NULL) const
    {
        return underling_local(problem_, i, start, size, stride, order);
    }
 
    size_t local_memory() const
    {
        return underling_local_memory(problem_);
    }
 
    size_t local_memory_optimum() const
    {
        return underling_local_memory_optimum(problem_);
    }
 
    operator bool () const { return problem_ != NULL; };
 
private:
    underling_problem problem_; 
};
 
inline
size_t local_memory_maximum(const grid &g, const problem &p)
{
    return underling_local_memory_maximum(g.get(), p.get());
}
 
inline
size_t local_memory_minimum(const grid &g, const problem &p)
{
    return underling_local_memory_minimum(g.get(), p.get());
}
 
inline
size_t global_memory(const grid &g, const problem &p)
{
    return underling_global_memory(g.get(), p.get());
}
 
inline
size_t global_memory_optimum(const grid &g, const problem &p)
{
    return underling_global_memory_optimum(g.get(), p.get());
}
 
class plan : private noncopyable {
public:
 
    plan(const problem &p,
         underling_real * in,
         underling_real * out,
         unsigned transpose_flags  = 0,
         unsigned fftw_rigor_flags = 0)
        : plan_(underling_plan_create(p.get(),
                                      in,
                                      out,
                                      transpose_flags,
                                      fftw_rigor_flags))
    {}
 
    ~plan() { underling_plan_destroy(plan_); }
 
    underling_plan get() const { return plan_; }
 
    int execute_long_n2_to_long_n1(underling_real * in,
                                   underling_real * out) const
    {
        return underling_execute_long_n2_to_long_n1(plan_, in, out);
    }
 
    int execute_long_n1_to_long_n0(underling_real * in,
                                   underling_real * out) const
    {
        return underling_execute_long_n1_to_long_n0(plan_, in, out);
    }
 
    int execute_long_n0_to_long_n1(underling_real * in,
                                   underling_real * out) const
    {
        return underling_execute_long_n0_to_long_n1(plan_, in, out);
    }
 
    int execute_long_n1_to_long_n2(underling_real * in,
                                   underling_real * out) const
    {
        return underling_execute_long_n1_to_long_n2(plan_, in, out);
    }
 
    operator bool () const { return plan_ != NULL; };
 
private:
    underling_plan plan_;  
};
 
} // namespace underling
 
template< typename charT, typename traits >
std::basic_ostream<charT,traits>& operator<<(
        std::basic_ostream<charT,traits> &os,
        const underling::extents &e)
{
    return os << '['
              << e.start[0] << ',' << (e.start[0] + e.size[0])
              << ")x["
              << e.start[1] << ',' << (e.start[1] + e.size[1])
              << ")x["
              << e.start[2] << ',' << (e.start[2] + e.size[2])
              << ")x["
              << e.start[3] << ',' << (e.start[3] + e.size[3])
              << ')';
}
 
inline
bool operator==(const underling::extents &e1,
                const underling::extents &e2) {
    return !underling_extents_cmp(&e1, &e2);
}
 
#endif // UNDERLING_HPP