hybrid_util.h

// -*-c++-*-
#ifndef STORMM_HYBRID_UTIL_H
#define STORMM_HYBRID_UTIL_H
 
#include "copyright.h"
#include "DataTypes/common_types.h"
#include "DataTypes/stormm_vector_types.h"
#include "gpu_details.h"
#include "hybrid.h"
#ifdef STORMM_USE_HPC
#  include "hpc_hybrid_util.h"
#endif
 
namespace stormm {
namespace card {
 
using data_types::isHpcVectorType;
using data_types::isFloatingPointScalarType;
using data_types::isSignedIntegralScalarType;
using data_types::isUnsignedIntegralScalarType;
  
void confirmCpuMemory(HybridFormat tfmt, const std::string &message,
                      const char* class_caller = nullptr,
                      const char* method_caller = nullptr);

void confirmGpuMemory(HybridFormat tfmt, const std::string &message,
                      const char* class_caller = nullptr,
                      const char* method_caller = nullptr);
 
#ifdef STORMM_USE_HPC
void confirmHostVisibleToGpu(HybridFormat tfmt, const std::string &message,
                             const char* class_caller, const char* method_caller);

void markCopyInstructions(HybridFormat dest_format, HybridFormat orig_format, bool *do_hhc,
                          bool *do_hdc, bool *do_dhc, bool *do_ddc, bool *use_kernel);
#endif

void checkFormatCompatibility(HybridTargetLevel request, HybridFormat native,
                              const char* class_caller, const char* method_caller);
  
size_t screenHybridTransfer(size_t destination_size, size_t original_size, size_t length,
                            size_t destination_offset, size_t original_offset, const char* caller);

template <typename T>
void deepCopy(Hybrid<T> *destination, const Hybrid<T> &original, size_t length = 0,
              size_t destination_offset = 0, size_t original_offset = 0,
              const GpuDetails &gpu = null_gpu);
 
template <typename T>
void deepCopy(Hybrid<T> *destination, const Hybrid<T> &original, const GpuDetails &gpu,
              size_t length = 0, size_t destination_offset = 0, size_t original_offset = 0);

template <typename Tdest, typename Torig>
void deepRecast(Hybrid<Tdest> *destination, const Hybrid<Torig> &original, double scale,
                size_t length = 0, size_t destination_offset = 0, size_t original_offset = 0,
                const GpuDetails &gpu = null_gpu);
 
template <typename Tdest, typename Torig>
void deepRecast(Hybrid<Tdest> *destination, const Hybrid<Torig> &original,
                const Hybrid<int> &overflow, double scale, size_t length = 0,
                size_t destination_offset = 0, size_t original_offset = 0,
                const GpuDetails &gpu = null_gpu);
 
} // namespace card
} // namespace stormm
 
#include "hybrid_util.tpp"
 
#endif