openmp.hpp

Go to the documentation of this file.

// Copyright (c) 2014-2023, Lawrence Livermore National Security, LLC.
// Produced at the Lawrence Livermore National Laboratory.
// Written by the LBANN Research Team (B. Van Essen, et al.) listed in
// the CONTRIBUTORS file. <lbann-dev@llnl.gov>
//
// LLNL-CODE-697807.
// All rights reserved.
//
// This file is part of LBANN: Livermore Big Artificial Neural Network
// Toolkit. For details, see http://software.llnl.gov/LBANN or
// https://github.com/LLNL/LBANN.
//
// Licensed under the Apache License, Version 2.0 (the "Licensee"); you
// may not use this file except in compliance with the License.  You may
// obtain a copy of the License at:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied. See the License for the specific language governing
// permissions and limitations under the license.

#ifndef LBANN_UTILS_DNN_LIB_OPENMP_HPP
#define LBANN_UTILS_DNN_LIB_OPENMP_HPP

#include "lbann/utils/dim_helpers.hpp"
#include "lbann/utils/dnn_enums.hpp"
#include "lbann/utils/exception.hpp"

#include <h2/meta/Core.hpp>
#include <h2/meta/TypeList.hpp>

namespace lbann {

struct openmp_backend
{
  static constexpr auto device = El::Device::CPU;

  struct unnecessary
  {
  };

  template <typename T>
  static auto data_type()
  {
    return unnecessary{};
  }

  class TensorDescriptor
  {
  public:
    using backend_type = openmp_backend;

    static constexpr auto device = backend_type::device;

    using dnnTensorDescriptor_t = unnecessary;

    using dnnDataType_t = unnecessary;

    using dnnTensorFormat_t = unnecessary;

  public:

    TensorDescriptor() = default;
    ~TensorDescriptor() noexcept = default;
    TensorDescriptor(TensorDescriptor const&) = default;
    TensorDescriptor(TensorDescriptor&&) = default;
    TensorDescriptor& operator=(TensorDescriptor const&) = default;
    TensorDescriptor& operator=(TensorDescriptor&&) = default;

    void swap(TensorDescriptor& other) {}
    void reset(dnnTensorDescriptor_t) {}

    dnnTensorDescriptor_t release() noexcept { return {}; }

    dnnTensorDescriptor_t get() const noexcept { return {}; }

    operator dnnTensorDescriptor_t() const noexcept { return this->get(); }

    void create() noexcept {}

    template <typename DimT>
    void
    set(dnnDataType_t, std::vector<DimT> const&, std::vector<DimT> const& = {})
    {}

    template <typename... IntTs>
    void set(dnnDataType_t, IntTs...)
    {}
#if !(defined LBANN_HAS_CUDNN)
    // This function is required for API compatibility.
    void set(dnnDataType_t /*data_type*/,
             dnnTensorFormat_t /*format*/,
             std::vector<int> const& /*dims*/)
    {}
#endif // !LBANN_HAS_CUDNN

  }; // class TensorDescriptor

  template <typename DataT, typename ScalarT>
  static void softmax_forward(ScalarT const& alpha_in,
                              TensorDescriptor const& xDesc,
                              El::Matrix<DataT, device> const& x,
                              ScalarT const& beta_in,
                              TensorDescriptor const& yDesc,
                              El::Matrix<DataT, device>& y,
                              El::SyncInfo<device> const& si,
                              softmax_mode mode,
                              softmax_alg alg = softmax_alg::ACCURATE);

  template <typename DataT, typename ScalarT>
  static void logsoftmax_forward(ScalarT const& alpha_in,
                                 TensorDescriptor const& xDesc,
                                 El::Matrix<DataT, device> const& x,
                                 ScalarT const& beta_in,
                                 TensorDescriptor const& yDesc,
                                 El::Matrix<DataT, device>& y,
                                 El::SyncInfo<device> const& si,
                                 softmax_mode mode)
  {
    LBANN_ERROR("Not yet implemented.");
  }

  template <typename DataT, typename ScalarT>
  static void softmax_backward(ScalarT const& alpha_in,
                               TensorDescriptor const& yDesc,
                               El::Matrix<DataT, device> const& y,
                               TensorDescriptor const& dyDesc,
                               El::Matrix<DataT, device> const& dy,
                               ScalarT const& beta_in,
                               TensorDescriptor const& dxDesc,
                               El::Matrix<DataT, device>& dx,
                               El::SyncInfo<device> const& si,
                               softmax_mode mode,
                               softmax_alg alg = softmax_alg::ACCURATE);

  template <typename DataT, typename ScalarT>
  static void logsoftmax_backward(ScalarT const& alpha_in,
                                  TensorDescriptor const& yDesc,
                                  El::Matrix<DataT, device> const& y,
                                  TensorDescriptor const& dyDesc,
                                  El::Matrix<DataT, device> const& dy,
                                  ScalarT const& beta_in,
                                  TensorDescriptor const& dxDesc,
                                  El::Matrix<DataT, device>& dx,
                                  El::SyncInfo<device> const& si,
                                  softmax_mode mode,
                                  softmax_alg alg = softmax_alg::ACCURATE)
  {
    LBANN_ERROR("Not yet implemented.");
  }

}; // struct openmp_backend

} // namespace lbann
#endif // LBANN_UTILS_DNN_LIB_OPENMP_HPP