oct-sysinfo.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018-2026 The Octave Project Developers
//
// See the file COPYRIGHT.md in the top-level directory of this
// distribution or <https://octave.org/copyright/>.
//
// This file is part of Octave.
//
// Octave is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Octave is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Octave; see the file COPYING.  If not, see
// <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////
 
#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif
 
#include <sstream>
#include <string>
 
#include "f77-fcn.h"
#include "oct-shlib.h"
#include "oct-sysinfo.h"
 
// Hack to stringize macro results.
#define xSTRINGIZE(x) #x
#define STRINGIZE(x) xSTRINGIZE(x)
 
OCTAVE_BEGIN_NAMESPACE(octave)
OCTAVE_BEGIN_NAMESPACE(sys)
 
std::string blas_version ()
{
  dynamic_library dyn_libs ("");
 
  if (! dyn_libs)
    return "unknown BLAS";
 
  std::string retval;
 
  // Check for functions that are specific to certain BLAS implementations.
 
  // FlexiBLAS
  typedef void (*flexi_f_type) (int *, int *, int *);
  flexi_f_type flexi_f_ptr = reinterpret_cast<flexi_f_type>
                             (dyn_libs.search ("flexiblas_get_version"));
 
  if (flexi_f_ptr)
    {
      int v_major = 0;
      int v_minor = 0;
      int v_patch = 0;
      flexi_f_ptr (&v_major, &v_minor, &v_patch);
 
      std::ostringstream s;
      s << "FlexiBLAS Version "
        << v_major << "." << v_minor << "." << v_patch;
 
      retval = s.str ();
    }
 
  // OpenBLAS
  typedef char *(*open_fcn_type) ();
  open_fcn_type open_f_ptr = reinterpret_cast<open_fcn_type>
                             (dyn_libs.search ("openblas_get_config"));
 
  if (open_f_ptr)
    {
      if (! retval.empty ())
        retval += "\n";
 
      retval += "OpenBLAS (config: " + std::string (open_f_ptr ()) + ")";
    }
 
  // OpenBLAS with minimal extension functions included in the library
  else if (dyn_libs.search ("openblas_get_num_threads"))
    {
      if (! retval.empty ())
        retval += "\n";
 
      retval += "OpenBLAS (config: unknown)";
    }
 
  // GotoBLAS(2)
  if (dyn_libs.search ("gotoblas_profile_init"))
    {
      if (! retval.empty ())
        retval += "\n";
 
      retval += "GotoBLAS(2)";
    }
 
  // ATLAS
  // FIXME: If we are really interested, we could use a pipe to
  // redirect the output of "ATL_buildinfo".
  if (dyn_libs.search ("ATL_buildinfo"))
    {
      if (! retval.empty ())
        retval += "\n";
 
      retval += "ATLAS";
    }
 
  // ACML
  typedef void (*acml_f_type) (int *, int *, int *);
  acml_f_type acml_f_ptr = reinterpret_cast<acml_f_type>
                           (dyn_libs.search ("acmlversion"));
 
  if (acml_f_ptr)
    {
      int v_major = 0;
      int v_minor = 0;
      int v_patch = 0;
      acml_f_ptr (&v_major, &v_minor, &v_patch);
 
      std::ostringstream s;
      s << "ACML BLAS Version "
        << v_major << "." << v_minor << "." << v_patch;
 
      if (! retval.empty ())
        retval += "\n";
 
      retval += s.str ();
    }
 
  // Intel MKL
  typedef void (*mkl_f_type) (char *, int);
  mkl_f_type mkl_f_ptr = reinterpret_cast<mkl_f_type>
                         (dyn_libs.search ("mkl_get_version_string"));
 
  if (mkl_f_ptr)
    {
      char buf[198] = {};
      // MKL overwrites buffer.  Read (LENGTH-1) bytes to keep '\0' terminator.
      mkl_f_ptr (buf, (198 - 1));
 
      if (! retval.empty ())
        retval += "\n";
 
      retval += std::string (buf);
    }
 
  // Otherwise
  if (retval.empty ())
    retval = "unknown or reference BLAS";
 
  return retval;
}
 
std::string
lapack_version ()
{
  std::string retval = "unknown LAPACK";
 
  dynamic_library dyn_libs ("");
 
  if (! dyn_libs)
    return retval;
 
  // query LAPACK version
  typedef F77_RET_T
    (*ilaver_fcn_type) (const F77_INT&, const F77_INT&, const F77_INT&);
  ilaver_fcn_type f_ptr = reinterpret_cast<ilaver_fcn_type>
                          (dyn_libs.search (STRINGIZE (F77_FUNC (ilaver, ILAVER))));
 
  if (f_ptr)
    {
      int v_major = 0;
      int v_minor = 0;
      int v_patch = 0;
      f_ptr (v_major, v_minor, v_patch);
 
      std::ostringstream s;
      s << "Linear Algebra PACKage Version "
        << v_major << "." << v_minor << "." << v_patch;
 
      retval = s.str ();
    }
 
  return retval;
}
 
OCTAVE_END_NAMESPACE(sys)
OCTAVE_END_NAMESPACE(octave)