underling.h

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_H
#define UNDERLING_H
 
#include <stddef.h>
#include <stdio.h>
#include <mpi.h>
#include <underling/visibility.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef double underling_real;
 
typedef struct underling_extents {
    int start[4];
 
    int size[4];
 
    int stride[4];
 
    int order[4];
 
    size_t extent;
} underling_extents;
 
extern const underling_extents UNDERLING_EXTENTS_INVALID;
 
void
underling_fprint_extents(
        const underling_extents *extents,
        FILE *output_file) UNDERLING_API;
 
int
underling_extents_cmp(const underling_extents * const e1,
                      const underling_extents * const e2) UNDERLING_API;
 
int underling_only_init(int *argc, char **argv[]) UNDERLING_API;
 
int underling_init(int *argc, char **argv[], int nthreads) UNDERLING_API;
 
void underling_only_cleanup() UNDERLING_API;
 
void underling_cleanup() UNDERLING_API;
 
typedef struct underling_grid_s *underling_grid;
 
underling_grid
underling_grid_create(
        MPI_Comm comm,
        int n0,
        int n1,
        int n2,
        int pA,
        int pB) UNDERLING_API;
 
int
underling_grid_pA_size(
        const underling_grid grid) UNDERLING_API;
 
int
underling_grid_pB_size(
        const underling_grid grid) UNDERLING_API;
 
void
underling_grid_destroy(
        underling_grid grid) UNDERLING_API;
 
void
underling_fprint_grid(
        const underling_grid grid,
        FILE *output_file) UNDERLING_API;
 
typedef struct underling_problem_s *underling_problem;
 
underling_problem
underling_problem_create(
        underling_grid grid,
        int howmany,
        unsigned transposed_flags) UNDERLING_API;
 
void
underling_problem_destroy(
        underling_problem problem) UNDERLING_API;
 
void
underling_fprint_problem(
        const underling_problem problem,
        FILE *output_file) UNDERLING_API;
 
underling_extents
underling_local_extents(
        const underling_problem problem,
        int i) UNDERLING_API;
 
size_t
underling_local(
        const underling_problem problem,
        int i,
        int *start,
        int *size,
        int *stride,
        int *order) UNDERLING_API;
 
size_t
underling_local_memory(
        const underling_problem problem) UNDERLING_API;
 
size_t
underling_local_memory_optimum(
        const underling_problem problem) UNDERLING_API;
 
size_t
underling_local_memory_maximum(
        const underling_grid    grid,
        const underling_problem problem) UNDERLING_API;
 
size_t
underling_local_memory_minimum(
        const underling_grid    grid,
        const underling_problem problem) UNDERLING_API;
 
size_t
underling_global_memory(
        const underling_grid    grid,
        const underling_problem problem) UNDERLING_API;
 
size_t
underling_global_memory_optimum(
        const underling_grid    grid,
        const underling_problem problem) UNDERLING_API;
 
#define UNDERLING_TRANSPOSE_LONG_N2_TO_LONG_N1 (1U << 0)
 
#define UNDERLING_TRANSPOSE_LONG_N1_TO_LONG_N0 (1U << 1)
 
#define UNDERLING_TRANSPOSE_LONG_N0_TO_LONG_N1 (1U << 2)
 
#define UNDERLING_TRANSPOSE_LONG_N1_TO_LONG_N2 (1U << 3)
 
#define UNDERLING_TRANSPOSE_NONE (1U << 4)
 
#define UNDERLING_TRANSPOSE_ALL                       \
         (   UNDERLING_TRANSPOSE_LONG_N2_TO_LONG_N1   \
           | UNDERLING_TRANSPOSE_LONG_N1_TO_LONG_N0   \
           | UNDERLING_TRANSPOSE_LONG_N0_TO_LONG_N1   \
           | UNDERLING_TRANSPOSE_LONG_N1_TO_LONG_N2 )
 
typedef struct underling_plan_s *underling_plan;
 
underling_plan
underling_plan_create(
        const underling_problem problem,
        underling_real * in,
        underling_real * out,
        unsigned transpose_flags,
        unsigned fftw_rigor_flags) UNDERLING_API;
 
void
underling_plan_destroy(
        underling_plan plan) UNDERLING_API;
 
void
underling_fprint_plan(
        const underling_plan plan,
        FILE *output_file) UNDERLING_API;
 
int
underling_execute_long_n2_to_long_n1(
        const underling_plan plan,
        underling_real * in,
        underling_real * out) UNDERLING_API;
 
int
underling_execute_long_n1_to_long_n0(
        const underling_plan plan,
        underling_real * in,
        underling_real * out) UNDERLING_API;
 
int
underling_execute_long_n0_to_long_n1(
        const underling_plan plan,
        underling_real * in,
        underling_real * out) UNDERLING_API;
 
int
underling_execute_long_n1_to_long_n2(
        const underling_plan plan,
        underling_real * in,
        underling_real * out) UNDERLING_API;
 
#define UNDERLING_TRANSPOSED_LONG_N2 (1U << 4)
 
#define UNDERLING_TRANSPOSED_LONG_N0 (1U << 5)
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// Quasi-hidden setting used for debugging deadlock conditions
MPI_Comm
underling_debug_transpose(
        MPI_Comm comm) UNDERLING_API;
#endif
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif // UNDERLING_H