PR agent fix: libxsmm install/export, ld guard, TA_LIBXSMM=ON test gate

- Install libxsmm.a+headers into TA's prefix; split TiledArray_LIBXSMM into
  BUILD/INSTALL interfaces so the exported config has no build-tree leak.
- Guard 64->32-bit narrowing of lda/ldb/ldc in libxsmm_gemm_le64.
- Make the libxsmm sub-make parallelism configurable (LIBXSMM_BUILD_NJOBS).
- Add a TA_LIBXSMM=1 CTest gate + a direct scale_libxsmm_dgemm numerical test.

Author: zhihao-deng

external/libxsmm.cmake

@@ -70,6 +70,10 @@ else ()
         set(_libxsmm_cxx ${CMAKE_CXX_COMPILER})
     endif ()
 
+    # parallelism for the libxsmm sub-make (overridable; default mirrors the
+    # project's typical build budget rather than hardcoding into the command)
+    set(LIBXSMM_BUILD_NJOBS 6 CACHE STRING "Parallel jobs for the libxsmm sub-make")
+
     # libxsmm Make knobs:
     #   STATIC=1   build libxsmm.a (we link the archive into tiledarray)
     #   FORTRAN=0  skip the Fortran interface (no gfortran needed)
@@ -93,7 +97,7 @@ else ()
             BUILD_IN_SOURCE 1
             CONFIGURE_COMMAND ""
             #--Build step----------------- build + install in one make invocation
-            BUILD_COMMAND make -j6 STATIC=1 FORTRAN=0 BLAS=0
+            BUILD_COMMAND make -j${LIBXSMM_BUILD_NJOBS} STATIC=1 FORTRAN=0 BLAS=0
                           CC=${_libxsmm_cc} CXX=${_libxsmm_cxx} AR=${CMAKE_AR}
                           PREFIX=${_LIBXSMM_INSTALL_DIR} install
             BUILD_BYPRODUCTS ${LIBXSMM_BUILD_BYPRODUCTS}
@@ -112,16 +116,37 @@ else ()
 
 endif (_LIBXSMM_INSTALL_DIR)
 
+# Fold libxsmm's static lib + headers into TiledArray's OWN install prefix, so
+# the exported TiledArray config is self-contained and does not reference TA's
+# build tree (which a downstream find_package(TiledArray) consumer like MPQC
+# would otherwise link against -- and which breaks once the build tree is
+# wiped/relocated). Done for both the fetched and the prebuilt cases so the TA
+# install is identical either way.
+install(FILES "${_LIBXSMM_INSTALL_DIR}/lib/libxsmm.a"
+        DESTINATION "${TILEDARRAY_INSTALL_LIBDIR}" COMPONENT tiledarray)
+install(DIRECTORY "${_LIBXSMM_INSTALL_DIR}/include/"
+        DESTINATION "${TILEDARRAY_INSTALL_INCLUDEDIR}" COMPONENT tiledarray)
+
 # Synthetic target carrying the include dir, the static archive, and the gating
-# define. PUBLIC propagation (via _TILEDARRAY_DEPENDENCIES) makes
-# TILEDARRAY_HAS_LIBXSMM + the include path visible to consumers (e.g. MPQC).
+# define. PUBLIC propagation (via _TILEDARRAY_DEPENDENCIES) makes the libxsmm.a
+# link requirement reach consumers (libtiledarray is a static archive, so its
+# undefined libxsmm symbols are resolved at the consumer's final link), plus
+# TILEDARRAY_HAS_LIBXSMM + the include path. The link/include paths are split
+# into BUILD_INTERFACE (TA's build tree) and INSTALL_INTERFACE (the installed
+# copy above), so the exported config never references the build tree. The
+# include INSTALL_INTERFACE is relative (CMake prepends the import prefix); the
+# link library INSTALL_INTERFACE must be an absolute path to the installed
+# archive -- CMake does NOT prepend the import prefix to INTERFACE_LINK_LIBRARIES
+# entries, so a relative path there would be resolved against the consumer's cwd
+# and fail to link. Absolute CMAKE_INSTALL_PREFIX is leak-free (the install tree
+# is the stable final location, unlike the build tree).
 add_library(TiledArray_LIBXSMM INTERFACE)
 set_target_properties(TiledArray_LIBXSMM
         PROPERTIES
         INTERFACE_INCLUDE_DIRECTORIES
-        "$<BUILD_INTERFACE:${_LIBXSMM_INSTALL_DIR}/include>;$<INSTALL_INTERFACE:include>"
+        "$<BUILD_INTERFACE:${_LIBXSMM_INSTALL_DIR}/include>;$<INSTALL_INTERFACE:${TILEDARRAY_INSTALL_INCLUDEDIR}>"
         INTERFACE_LINK_LIBRARIES
-        "${_LIBXSMM_INSTALL_DIR}/lib/libxsmm.a;${CMAKE_DL_LIBS}"
+        "$<BUILD_INTERFACE:${_LIBXSMM_INSTALL_DIR}/lib/libxsmm.a>;$<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}/${TILEDARRAY_INSTALL_LIBDIR}/libxsmm.a>;${CMAKE_DL_LIBS}"
         INTERFACE_COMPILE_DEFINITIONS
         "TILEDARRAY_HAS_LIBXSMM"
         )

src/TiledArray/math/libxsmm_gemm.cpp

@@ -9,6 +9,7 @@
 #ifdef TILEDARRAY_HAS_LIBXSMM
 #include <cstdlib>
 #include <cstring>
+#include <limits>
 #include <mutex>
 #include <libxsmm.h>
 #endif
@@ -51,6 +52,11 @@ bool libxsmm_gemm_le64(bool trans_a, bool trans_b, std::int64_t m,
   // libxsmm SMM has no alpha and only beta in {0,1} (LIBXSMM_GEMM_NO_BYPASS).
   if (alpha != 1.0) return false;
   if (beta != 0.0 && beta != 1.0) return false;
+  // libxsmm_blasint is 32-bit; refuse leading dims that would narrow silently.
+  // (M,N,K are already <=64; lda/ldb/ldc are strides and unbounded in general.)
+  constexpr std::int64_t bi_max =
+      static_cast<std::int64_t>(std::numeric_limits<libxsmm_blasint>::max());
+  if (lda > bi_max || ldb > bi_max || ldc > bi_max) return false;
 
   static std::once_flag init_flag;
   std::call_once(init_flag, [] {

tests/CMakeLists.txt

@@ -192,6 +192,18 @@ else()
           )
 endif()
 
+# When libxsmm is enabled, also run the strided-GEMM suites with the libxsmm
+# fast path forced ON (TA_LIBXSMM=1), so its numerics are gated against the
+# in-suite references (the default-OFF run above does not exercise libxsmm).
+if (TA_LIBXSMM)
+  add_test(NAME tiledarray/unit/run-libxsmm
+           COMMAND $<TARGET_FILE:${executable}> --log_level=unit_scope
+                   --run_test=arena_strided_dgemm_suite:arena_einsum_unit_suite)
+  set_tests_properties(tiledarray/unit/run-libxsmm
+          PROPERTIES FIXTURES_REQUIRED TA_UNIT_TESTS_EXEC
+          ENVIRONMENT "${TA_UNIT_TESTS_ENVIRONMENT};TA_LIBXSMM=1")
+endif()
+
 if (NOT TARGET test-cases-tiledarray)
   add_custom_target_subproject(tiledarray test-cases)
 endif()

tests/arena_strided_dgemm.cpp

@@ -2109,4 +2109,56 @@ BOOST_AUTO_TEST_CASE(ce_ce_seg_killswitch_matches_left) {
   }
 }
 
+// Directly validate the scale-path libxsmm entry point
+// (TiledArray::detail::scale_libxsmm_dgemm) for BOTH scale regimes' transpose
+// configs -- tot_x_t maps to (trans_a=true, trans_b=false) and t_x_tot maps to
+// (trans_a=false, trans_b=false). The ce+e / ce+ce arena tests above already
+// exercise libxsmm_gemm_le64 for these same transpose patterns, but the scale
+// wrapper itself (tensor.cpp) is otherwise only reachable through Tensor::gemm;
+// this gates its numerics standalone. When libxsmm is not active (built without
+// TILEDARRAY_HAS_LIBXSMM, or TA_LIBXSMM=0) the wrapper returns false and writes
+// nothing, so the numeric check is keyed on the returned flag.
+BOOST_AUTO_TEST_CASE(scale_path_libxsmm_matches_reference) {
+  // Row-major C(m x n) = beta*C + op_a(A)(m x k) . op_b(B)(k x n), alpha=1,
+  // matching scale_libxsmm_dgemm / blas::gemm semantics.
+  auto ref_gemm = [](bool ta, bool tb, long m, long n, long k,
+                     const std::vector<double>& A, long lda,
+                     const std::vector<double>& B, long ldb, double beta,
+                     std::vector<double>& C, long ldc) {
+    for (long i = 0; i < m; ++i)
+      for (long j = 0; j < n; ++j) {
+        double acc = 0.0;
+        for (long p = 0; p < k; ++p) {
+          const double av = ta ? A[p * lda + i] : A[i * lda + p];
+          const double bv = tb ? B[j * ldb + p] : B[p * ldb + j];
+          acc += av * bv;
+        }
+        C[i * ldc + j] = beta * C[i * ldc + j] + acc;
+      }
+  };
+  struct Cfg { bool ta, tb; long m, n, k; };
+  for (const Cfg cfg : {Cfg{true, false, 5, 7, 4},     // tot_x_t shape
+                        Cfg{false, false, 6, 3, 8}}) {  // t_x_tot shape
+    const long m = cfg.m, n = cfg.n, k = cfg.k;
+    const long lda = cfg.ta ? m : k;  // A is (k x m) if trans_a else (m x k)
+    const long ldb = cfg.tb ? k : n;  // B is (n x k) if trans_b else (k x n)
+    const long ldc = n;
+    std::vector<double> A(static_cast<std::size_t>(m) * k),
+        B(static_cast<std::size_t>(k) * n),
+        C(static_cast<std::size_t>(m) * n, 0.3);
+    for (std::size_t i = 0; i < A.size(); ++i) A[i] = 0.1 * double(i) + 0.5;
+    for (std::size_t i = 0; i < B.size(); ++i) B[i] = 0.2 * double(i) - 0.3;
+    std::vector<double> Cref = C;
+    ref_gemm(cfg.ta, cfg.tb, m, n, k, A, lda, B, ldb, /*beta=*/1.0, Cref, ldc);
+    const bool ran = TA::detail::scale_libxsmm_dgemm(
+        cfg.ta, cfg.tb, m, n, k, A.data(), lda, B.data(), ldb, /*beta=*/1.0,
+        C.data(), ldc);
+    if (ran) {
+      for (long i = 0; i < m * n; ++i)
+        BOOST_CHECK_CLOSE(C[static_cast<std::size_t>(i)],
+                          Cref[static_cast<std::size_t>(i)], 1e-10);
+    }
+  }
+}
+
 BOOST_AUTO_TEST_SUITE_END()