debug_print.hpp

// Copyright (c) Lawrence Livermore National Security, LLC and
// other Serac Project Developers. See the top-level LICENSE file for
// details.
//
// SPDX-License-Identifier: (BSD-3-Clause)
 
#pragma once
 
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string>
#include <typeinfo>
#include <vector>
 
#include "mfem.hpp"
#include "axom/core.hpp"
 
#ifdef __GNUG__
#include <cxxabi.h>
#include <cstdlib>
#endif
 
#include "serac/infrastructure/memory.hpp"
#include "serac/numerics/functional/element_restriction.hpp"
 
namespace serac {
 
template <typename T>
std::string typeString(T& var)
{
  // Remove reference, but keep the const/volatile qualifiers.
  const char* name = typeid(var).name();
#ifdef __GNUG__
  int status = -4;  // Arbitrary value to eliminate the compiler warning
  char* demangled = abi::__cxa_demangle(name, nullptr, nullptr, &status);
  std::string result((status == 0) ? demangled : name);
  std::free(demangled);
  if constexpr (std::is_const_v<T>) {
    result = "const " + result;
  }
  return result;
#else
  // Return name if compiler doesn't support GNU's extensions (most do)
  return name;
#endif
}
 
template <typename T>
void writeToFile(std::vector<T> v, std::string filename)
{
  std::ofstream outfile(filename);
  for (int i = 0; i < v.size(); i++) {
    outfile << v[i] << std::endl;
  }
  outfile.close();
}
 
void writeToFile(mfem::Vector v, std::string filename)
{
  std::ofstream outfile(filename);
  for (int i = 0; i < v.Size(); i++) {
    outfile << v[i] << std::endl;
  }
  outfile.close();
}
 
void writeToFile(mfem::SparseMatrix A, std::string filename)
{
  std::ofstream outfile(filename);
  A.PrintMM(outfile);
  outfile.close();
}
 
std::ostream& operator<<(std::ostream& out, DoF dof)
{
  out << "{" << dof.index() << ", " << dof.sign() << ", " << dof.orientation() << "}";
  return out;
}
 
template <typename T>
void writeToFile(axom::Array<T, 2, serac::detail::host_memory_space> arr, std::string filename)
{
  std::ofstream outfile(filename);
 
  for (axom::IndexType i = 0; i < arr.shape()[0]; i++) {
    outfile << "{";
    for (axom::IndexType j = 0; j < arr.shape()[1]; j++) {
      outfile << arr(i, j);
      if (j < arr.shape()[1] - 1) outfile << ", ";
    }
    outfile << "}\n";
  }
 
  outfile.close();
}
 
template <typename T>
void writeToFile(axom::Array<T, 3, serac::detail::host_memory_space> arr, std::string filename)
{
  std::ofstream outfile(filename);
 
  outfile << std::setprecision(16);
 
  for (axom::IndexType i = 0; i < arr.shape()[0]; i++) {
    outfile << "{";
    for (axom::IndexType j = 0; j < arr.shape()[1]; j++) {
      outfile << "{";
      for (axom::IndexType k = 0; k < arr.shape()[2]; k++) {
        outfile << arr(i, j, k);
        if (k < arr.shape()[2] - 1) outfile << ", ";
      }
      outfile << "}";
      if (j < arr.shape()[1] - 1) outfile << ", ";
    }
    outfile << "}\n";
  }
 
  outfile.close();
}
 
#ifdef __CUDACC__
#include <cuda_runtime.h>
#include <iostream>
void printCUDAMemUsage()
{
  int deviceCount = 0;
  cudaGetDeviceCount(&deviceCount);
  int i = 0;
  cudaSetDevice(i);
 
  size_t freeBytes, totalBytes;
  cudaMemGetInfo(&freeBytes, &totalBytes);
  size_t usedBytes = totalBytes - freeBytes;
 
  std::cout << "Device Number: " << i << std::endl;
  std::cout << " Total Memory (MB): " << (totalBytes / 1024.0 / 1024.0) << std::endl;
  std::cout << " Free Memory (MB): " << (freeBytes / 1024.0 / 1024.0) << std::endl;
  std::cout << " Used Memory (MB): " << (usedBytes / 1024.0 / 1024.0) << std::endl;
}
 
#endif
 
}  // namespace serac