Stencil.hpp

Go to the documentation of this file.

/*
 * Copyright © 2020-2024 Jan-Oliver Opdenhövel, Paderborn Center for Parallel Computing, Paderborn
 * University
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
 * associated documentation files (the “Software”), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge, publish, distribute,
 * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
 * NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#pragma once
#include "GenericID.hpp"
#include "Helpers.hpp"
#include "Index.hpp"
#include <bit>
#include <sycl/ext/intel/ac_types/ac_int.hpp>
#include <variant>
 
namespace stencil {
 
template <typename Cell, uindex_t stencil_radius, typename TimeDependentValue = std::monostate>
    requires std::semiregular<Cell> && (stencil_radius >= 1)
class Stencil {
  public:
    static constexpr uindex_t diameter = 2 * stencil_radius + 1;
 
    static constexpr unsigned long bits_stencil = std::bit_width(diameter);
 
    using index_stencil_t = ac_int<bits_stencil, true>;
 
    using uindex_stencil_t = ac_int<bits_stencil, false>;
 
    using StencilID = GenericID<index_stencil_t>;
 
    using StencilUID = GenericID<uindex_stencil_t>;
 
    Stencil(ID id, UID grid_range, uindex_t iteration, uindex_t subiteration,
            TimeDependentValue tdv)
        : id(id), iteration(iteration), subiteration(subiteration), grid_range(grid_range),
          time_dependent_value(tdv), internal() {}
 
    Stencil(ID id, UID grid_range, uindex_t iteration, uindex_t subiteration,
            TimeDependentValue tdv, Cell raw[diameter][diameter])
        : id(id), iteration(iteration), subiteration(subiteration), grid_range(grid_range),
          time_dependent_value(tdv), internal() {
#pragma unroll
        for (uindex_t c = 0; c < diameter; c++) {
#pragma unroll
            for (uindex_t r = 0; r < diameter; r++) {
                internal[c][r] = raw[c][r];
            }
        }
    }
 
    Cell const &operator[](ID id) const {
        return internal[id.c + stencil_radius][id.r + stencil_radius];
    }
 
    Cell &operator[](ID id) { return internal[id.c + stencil_radius][id.r + stencil_radius]; }
 
    Cell const &operator[](StencilID id) const {
        return internal[id.c + index_stencil_t(stencil_radius)]
                       [id.r + index_stencil_t(stencil_radius)];
    }
 
    Cell &operator[](StencilID id) {
        return internal[id.c + index_stencil_t(stencil_radius)]
                       [id.r + index_stencil_t(stencil_radius)];
    }
 
    Cell const &operator[](UID id) const { return internal[id.c][id.r]; }
 
    Cell &operator[](UID id) { return internal[id.c][id.r]; }
 
    Cell const &operator[](StencilUID id) const { return internal[id.c][id.r]; }
 
    Cell &operator[](StencilUID id) { return internal[id.c][id.r]; }
 
    const ID id;
 
    const uindex_t iteration;
 
    const uindex_t subiteration;
 
    const UID grid_range;
 
    const TimeDependentValue time_dependent_value;
 
  private:
    Cell internal[diameter][diameter];
};
} // namespace stencil