generate_build_info.sh

#!/bin/bash

# ==============================================================================
# generate_build_info.sh
#
# A script to generate build_info.h for Makefile-based builds.
# It attempts to detect system information, compiler flags, and library versions
# to provide a feature-rich build report similar to the CMake system.
# ==============================================================================

# set -e # Exit immediately if a command exits with a non-zero status.

if [ -z "$1" ]; then
  echo "Usage: $0 <output_file_path>"
  exit 1
fi
OUTPUT_FILE=$1

# --- Helper Functions ---

# Function to get version from a command's output
# Usage: get_version_from_command "<command>" "<regex>"
get_version_from_command() {
  local cmd="$1"
  local regex="$2"
  if command -v "$cmd" >/dev/null; then
    local output=$($cmd 2>&1)
    if [[ $output =~ $regex ]]; then
      echo "${BASH_REMATCH[1]}"
      return 0
    fi
  fi
  return 1
}

# Function to get version from a header file
# Usage: get_version_from_header "<header_path>" "<regex>"
get_version_from_header() {
  local header_path="$1"
  local regex="$2"
  if [ -f "$header_path" ]; then
    local line=$(grep -E "$regex" "$header_path" | head -n 1)
    if [[ $line =~ $regex ]]; then
      echo "${BASH_REMATCH[1]}"
      return 0
    fi
  fi
  return 1
}

# --- Main Detection Logic ---

# 1. Basic Info
PLATFORM_NAME="CPU"
BUILD_USER=$(whoami)
BUILD_HOST=$(hostname)
CXX_COMPILER_PATH="${CXX:-g++}"
CXX_COMPILER_VERSION=$($CXX_COMPILER_PATH --version 2>&1 | head -n 1)
CXX_FLAGS="${CXXFLAGS:-}"
LINKER_FLAGS="${LDFLAGS:-}"
CUDA_FLAGS="${CUDAFLAGS:-}"

# Detect Platform based on environment variables
if [ "${USE_ROCM}" == "ON" ]; then PLATFORM_NAME="CPU + AMD ROCm"; fi
if [ "${USE_CUDA}" == "ON" ]; then PLATFORM_NAME="CPU + NVIDIA CUDA"; fi
if [ "${ENABLE_ELPA}" == "ON" ] && [ "${ENABLE_LCAO}" == "ON" ]; then PLATFORM_NAME="${PLATFORM_NAME} + ELPA"; fi

# 2. MPI
MPI_IMPLEMENTATION="no"
MPI_VERSION="no"
if [ "${ENABLE_MPI}" == "ON" ]; then
  MPI_IMPLEMENTATION="Unknown"
  MPI_COMPILER="${MPI_CXX_COMPILER:-mpicxx}"
  if command -v "$MPI_COMPILER" >/dev/null; then
    # Intel MPI (oneAPI)
    version=$(get_version_from_command "$MPI_COMPILER --version" "Intel\(R\) oneAPI DPC\+\+/C\+\+ Compiler ([0-9]+\.[0-9]+\.[0-9]+)")
    if [ -n "$version" ]; then
      MPI_IMPLEMENTATION="Intel MPI"
      MPI_VERSION="$version"
    fi
    # Intel MPI (classic)
    if [ -z "$version" ]; then
      version=$(get_version_from_command "$MPI_COMPILER --version" "icpc \(ICC\) ([0-9]+\.[0-9]+\.[0-9]+)")
      if [ -n "$version" ]; then
        MPI_IMPLEMENTATION="Intel MPI"
        MPI_VERSION="$version"
      fi
    fi
    # OpenMPI
    if [ -z "$version" ]; then
      version=$(get_version_from_command "$MPI_COMPILER --version" "Open MPI ([0-9]+\.[0-9]+\.[0-9]+)")
      if [ -n "$version" ]; then
        MPI_IMPLEMENTATION="OpenMPI"
        MPI_VERSION="$version"
      fi
    fi
    # MPICH
    if [ -z "$version" ]; then
      version=$(get_version_from_command "$MPI_COMPILER --version" "MPICH Version: ([0-9]+\.[0-9]+\.[0-9]+)")
      if [ -n "$version" ]; then
        MPI_IMPLEMENTATION="MPICH"
        MPI_VERSION="$version"
      fi
    fi
    # Fallback via mpirun
    if [ -z "$version" ] && command -v mpirun >/dev/null; then
      mr_out=$(mpirun --version 2>&1)
      if [[ $mr_out =~ Open\ MPI\ ([0-9]+\.[0-9]+\.[0-9]+) ]]; then
        MPI_IMPLEMENTATION="OpenMPI"
        MPI_VERSION="${BASH_REMATCH[1]}"
      elif [[ $mr_out =~ MPICH\ Version:\ ([0-9]+\.[0-9]+\.[0-9]+) ]]; then
        MPI_IMPLEMENTATION="MPICH"
        MPI_VERSION="${BASH_REMATCH[1]}"
      fi
    fi
  fi
  if [ "$MPI_VERSION" == "no" ]; then MPI_VERSION="yes (version unknown)"; else MPI_VERSION="yes (v$MPI_VERSION)"; fi
else
  MPI_IMPLEMENTATION="no"
  MPI_VERSION="no"
fi

# 3. OpenMP
OPENMP_VERSION="no"
if [[ "$CXX_FLAGS" == *"-fopenmp"* ]]; then
  OPENMP_VERSION="yes (version unknown)"
  # Try to get version from compiler
  if command -v "$CXX_COMPILER_PATH" >/dev/null; then
    version=$($CXX_COMPILER_PATH -dM -E - </dev/null 2>&1 | grep '#define _OPENMP ' | awk '{print $3}')
    if [ -n "$version" ]; then
      # Convert YYYYMM to a more readable format if possible
      year=$((version / 10000))
      month=$((version % 10000))
      OPENMP_VERSION="yes (v${year}.${month})"
    fi
  fi
fi

# 4. MKL
MKL_SUPPORT="no"
if [ -n "$MKLROOT" ]; then
  MKL_SUPPORT="yes (version unknown)"
  version=$(get_version_from_header "$MKLROOT/include/mkl_version.h" "INTEL_MKL_VERSION ([0-9]+)")
  if [ -n "$version" ]; then
    major=$((version / 10000))
    minor=$(((version % 10000) / 100))
    patch=$((version % 100))
    MKL_SUPPORT="yes (v${major}.${minor}.${patch})"
  fi
fi

# 5. Libxc
LIBXC_VERSION="no"
if [ "${ENABLE_LIBXC}" == "ON" ]; then
  LIBXC_VERSION="yes (version unknown)"
  # Try pkg-config first
  if command -v pkg-config >/dev/null; then
    version=$(pkg-config --modversion libxc 2>/dev/null)
    if [ -n "$version" ]; then LIBXC_VERSION="yes (v$version)"; fi
  fi
  # Fallback to header
  if [[ "$LIBXC_VERSION" == *"unknown"* ]]; then
    # Assuming standard include paths
    version=$(get_version_from_header "/usr/include/libxc/libxc.h" "LIBXC_VERSION_ \"([0-9]+\.[0-9]+\.[0-9]+)\"")
    if [ -n "$version" ]; then LIBXC_VERSION="yes (v$version)"; fi
  fi
fi

# 6. CUDA
CUDA_VERSION="no"
if [ "${USE_CUDA}" == "ON" ]; then
  CUDA_VERSION="yes (version unknown)"
  if [ -n "$CUDA_HOME" ]; then
    version=$(get_version_from_command "$CUDA_HOME/bin/nvcc --version" "release ([0-9]+\.[0-9]+)")
    if [ -n "$version" ]; then CUDA_VERSION="yes (v$version)"; fi
  elif command -v nvcc >/dev/null; then
    version=$(get_version_from_command "nvcc --version" "release ([0-9]+\.[0-9]+)")
    if [ -n "$version" ]; then CUDA_VERSION="yes (v$version)"; fi
  fi
fi

# 7. ROCm/HIP
ROCM_VERSION="no"
if [ "${USE_ROCM}" == "ON" ]; then
  ROCM_VERSION="yes (version unknown)"
  if [ -n "$ROCM_PATH" ]; then
    version=$(get_version_from_command "$ROCM_PATH/bin/hipcc --version" "HIP version: ([0-9]+\.[0-9]+\.[0-9]+)")
    if [ -n "$version" ]; then ROCM_VERSION="yes (v$version)"; fi
  elif command -v hipcc >/dev/null; then
    version=$(get_version_from_command "hipcc --version" "HIP version: ([0-9]+\.[0-9]+\.[0-9]+)")
    if [ -n "$version" ]; then ROCM_VERSION="yes (v$version)"; fi
  fi
fi

# 8. DeePMD-kit
DEEPMD_VERSION="no"
if [ -n "$DeePMD_DIR" ]; then
  DEEPMD_VERSION="yes (version unknown)"
  version=$(get_version_from_header "$DeePMD_DIR/include/deepmd/version.h" "global_install_prefix=\".*deepmd-kit-([0-9]+\.[0-9]+\.[0-9]+)\"")
  if [ -n "$version" ]; then DEEPMD_VERSION="yes (v$version)"; else DEEPMD_VERSION="yes (path: $DeePMD_DIR)"; fi
fi

# 9. ELPA
ELPA_VERSION="no"
if [ "${ENABLE_ELPA}" == "ON" ] && [ -n "$ELPA_DIR" ]; then
  ELPA_VERSION="yes (version unknown)"
  if [ -f "$ELPA_DIR/bin/elpa2_print_version" ]; then
    version=$("$ELPA_DIR/bin/elpa2_print_version" 2>/dev/null)
    if [ -n "$version" ]; then ELPA_VERSION="yes ($version)"; fi
  else
    ELPA_VERSION="yes (path: $ELPA_DIR)"
  fi
fi

# 10. Cereal
CEREAL_VERSION="no"
if [ -n "$CEREAL_DIR" ]; then
  CEREAL_VERSION="yes (version unknown)"
  major=$(get_version_from_header "$CEREAL_DIR/include/cereal/version.hpp" "__CEREAL_VERSION_MAJOR[[:space:]]+([0-9]+)")
  minor=$(get_version_from_header "$CEREAL_DIR/include/cereal/version.hpp" "__CEREAL_VERSION_MINOR[[:space:]]+([0-9]+)")
  patch=$(get_version_from_header "$CEREAL_DIR/include/cereal/version.hpp" "__CEREAL_VERSION_PATCH[[:space:]]+([0-9]+)")
  if [ -n "$major" ] && [ -n "$minor" ] && [ -n "$patch" ]; then
    CEREAL_VERSION="yes (v${major}.${minor}.${patch})"
  else
    CEREAL_VERSION="yes (path: $CEREAL_DIR)"
  fi
fi

# 11. LibRI
LIBRI_VERSION="no"
if [ -n "$LIBRI_DIR" ]; then
  LIBRI_VERSION="yes (version unknown)"
  major=$(get_version_from_header "$LIBRI_DIR/include/RI/version.h" "__LIBRI_VERSION_MAJOR[[:space:]]+([0-9]+)")
  minor=$(get_version_from_header "$LIBRI_DIR/include/RI/version.h" "__LIBRI_VERSION_MINOR[[:space:]]+([0-9]+)")
  patch=$(get_version_from_header "$LIBRI_DIR/include/RI/version.h" "__LIBRI_VERSION_PATCH[[:space:]]+([0-9]+)")
  if [ -n "$major" ] && [ -n "$minor" ] && [ -n "$patch" ]; then
    LIBRI_VERSION="yes (v${major}.${minor}.${patch})"
  else
    LIBRI_VERSION="yes (path: $LIBRI_DIR)"
  fi
fi

# 12. LibComm
LIBCOMM_VERSION="no"
if [ -n "$LIBCOMM_DIR" ]; then
  LIBCOMM_VERSION="yes (path: $LIBCOMM_DIR)"
fi

# 13. FFTW (non-MKL)
FFTW3_VERSION="no"
if [ -z "$MKLROOT" ] && [ -n "$FFTW3_INCLUDE_DIR" ]; then
  FFTW3_VERSION="yes (version unknown)"
  hdr="$FFTW3_INCLUDE_DIR/fftw3.h"
  version=$(get_version_from_header "$hdr" "FFTW_VERSION\s+\"([^\"]+)\"")
  if [ -n "$version" ]; then FFTW3_VERSION="yes (v$version)"; fi
fi

# CUDA-aware MPI
CUDA_AWARE_MPI="no"
if [ "${USE_CUDA}" == "ON" ]; then
  if command -v ompi_info >/dev/null; then
    out=$(ompi_info --parsable --all 2>/dev/null)
    if echo "$out" | grep -q "mpi_built_with_cuda_support:value:true"; then
      CUDA_AWARE_MPI="yes"
    else
      CUDA_AWARE_MPI="no (or undetectable)"
    fi
  else
    CUDA_AWARE_MPI="no (or undetectable)"
  fi
fi
# --- Final File Generation ---

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
INPUT_FILE="${SCRIPT_DIR}/source/source_io/build_info.h.in"

# Use sed to replace all placeholders with detected values
# Note the use of different delimiters (#) for paths to avoid conflicts with /
sed \
  -e "s#@ABACUS_PLATFORM_NAME@#$PLATFORM_NAME#g" \
  -e "s#@ABACUS_BUILD_TYPE@#${BUILD_TYPE:-Release}#g" \
  -e "s#@ABACUS_BUILD_USER@#$BUILD_USER#g" \
  -e "s#@ABACUS_BUILD_HOST@#$BUILD_HOST#g" \
  -e "s#@ABACUS_CXX_COMPILER_ID@#${CXX_COMPILER_ID:-Unknown}#g" \
  -e "s#@ABACUS_CXX_COMPILER_PATH@#$CXX_COMPILER_PATH#g" \
  -e "s#@ABACUS_CXX_COMPILER_VERSION@#$CXX_COMPILER_VERSION#g" \
  -e "s#@ABACUS_CXX_FLAGS@#$CXX_FLAGS#g" \
  -e "s#@ABACUS_LINKER_FLAGS@#$LINKER_FLAGS#g" \
  -e "s#@ABACUS_CUDA_FLAGS@#$CUDA_FLAGS#g" \
  -e "s#@ABACUS_MPI_IMPLEMENTATION@#$MPI_IMPLEMENTATION#g" \
  -e "s#@ABACUS_MPI_VERSION@#$MPI_VERSION#g" \
  -e "s#@ABACUS_CUDA_AWARE_MPI@#$CUDA_AWARE_MPI#g" \
  -e "s#@ABACUS_OPENMP_VERSION@#$OPENMP_VERSION#g" \
  -e "s#@ABACUS_MKL_SUPPORT@#$MKL_SUPPORT#g" \
  -e "s#@ABACUS_LIBXC_VERSION@#$LIBXC_VERSION#g" \
  -e "s#@ABACUS_FFTW_VERSION@#$FFTW3_VERSION#g" \
  -e "s#@ABACUS_CUDA_VERSION@#$CUDA_VERSION#g" \
  -e "s#@ABACUS_ROCM_VERSION@#$ROCM_VERSION#g" \
  -e "s#@ABACUS_DEEPMD_VERSION@#$DEEPMD_VERSION#g" \
  -e "s#@ABACUS_ELPA_VERSION@#$ELPA_VERSION#g" \
  -e "s#@ABACUS_CEREAL_VERSION@#$CEREAL_VERSION#g" \
  -e "s#@ABACUS_LIBRI_VERSION@#$LIBRI_VERSION#g" \
  -e "s#@ABACUS_LIBCOMM_VERSION@#$LIBCOMM_VERSION#g" \
  -e "s#@ABACUS_ASAN_STATUS@#${ENABLE_ASAN:-no}#g" \
  -e "s#@ABACUS_CMAKE_OPTIONS@#Not available with Makefile#g" \
  -e "s#@ABACUS_CMAKE_FIND_PACKAGES@#Not available with Makefile#g" \
  "$INPUT_FILE" >"$OUTPUT_FILE"

echo "Generated $OUTPUT_FILE successfully."