Improving memory efficiency for Spinhalf and sparse matrices

.gitignore

@@ -7,6 +7,8 @@ run.sh
 build
 build_julia_wrapper.sh
 *.prof
+*.heap
+heap.pdf
 *.prof.pdf
 */build/*
 install

CMakeLists.txt

@@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.19)
 
 project(
   xdiag
-  VERSION 0.4.1
+  VERSION 0.5.0
   LANGUAGES CXX
 )
 
@@ -28,7 +28,13 @@ message(STATUS "Compiler version: " ${CMAKE_CXX_COMPILER_VERSION})
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 include("cmake/sources.cmake")
+include("cmake/instantiations.cmake")
 
+detect_grouped_sources(
+    "${XDIAG_SOURCES}"
+    XDIAG_GROUPED_SOURCES
+    XDIAG_NORMAL_SOURCES
+  )
 
 # Set release build as default
 if(NOT CMAKE_BUILD_TYPE)

benchmarks/bitset/CMakeLists.txt

@@ -0,0 +1,5 @@
+cmake_minimum_required(VERSION 3.19)
+project(benchmark_heisenberg_chain)
+find_package(xdiag REQUIRED HINTS "~/Research/Software/xdiag/install")
+add_executable(main main.cpp)
+target_link_libraries(main PRIVATE xdiag::xdiag)

benchmarks/bitset/main.cpp

@@ -0,0 +1,30 @@
+#include <xdiag/utils/timing.hpp>
+#include <xdiag/bits/bitset.hpp>
+#include <xdiag/combinatorics/combinations/combinations.hpp>
+
+using namespace xdiag;
+
+int main() try {
+  using combinatorics::Combinations;
+  using bits::Bitset;
+
+  int n = 34;
+  int k = 6;
+  int64_t cnt1 = 0;
+  tic();
+  for (auto s : Combinations<uint64_t>(n, k)) {
+    ++cnt1;
+  }
+  toc();
+
+  int64_t cnt2 = 0;
+  tic();
+  for (auto s : Combinations<Bitset<uint16_t, 4>>(n, k)) {
+    ++cnt2;
+  }
+  toc();
+  Log("{} {}", cnt1, cnt2);
+
+} catch (Error e) {
+  error_trace(e);
+}

benchmarks/bitset/readme.txt

@@ -0,0 +1,15 @@
+### MEMORY PROFILE ###
+- compile xdiag using
+
+cmake -S . -B build -D CMAKE_CXX_COMPILER=icpx -D CMAKE_CXX_FLAGS="-L/home/awietek/Research/Software/gperftools/build -ltcmalloc -g"
+
+- install xdiag
+- compile application using
+
+cmake -S . -B build -D CMAKE_CXX_COMPILER=icpx -D CMAKE_CXX_FLAGS="-L/home/awietek/Research/Software/gperftools/build -ltcmalloc -g"
+
+- run using
+HEAPPROFILE=heap ./build/main 28
+
+- visualize using
+pprof --pdf ./build/main heap.0001.heap > heap.pdf

benchmarks/combinatorics/CMakeLists.txt

@@ -0,0 +1,5 @@
+cmake_minimum_required(VERSION 3.19)
+project(benchmark_heisenberg_chain)
+find_package(xdiag REQUIRED HINTS "~/Research/Software/xdiag/install")
+add_executable(main main.cpp)
+target_link_libraries(main PRIVATE xdiag::xdiag)

benchmarks/combinatorics/main.cpp

@@ -0,0 +1,194 @@
+#include <xdiag/bits/bitarray.hpp>
+#include <xdiag/bits/bitset.hpp>
+#include <xdiag/bits/to_string.hpp>
+#include <xdiag/combinatorics/bounded_multisets/bounded_multisets.hpp>
+#include <xdiag/combinatorics/bounded_partitions/bounded_partitions.hpp>
+#include <xdiag/combinatorics/bounded_partitions/schaefer_table.hpp>
+#include <xdiag/combinatorics/combinations/combinations.hpp>
+#include <xdiag/combinatorics/combinations/lin_table.hpp>
+#include <xdiag/combinatorics/subsets/subsets.hpp>
+#include <xdiag/utils/timing.hpp>
+
+using namespace xdiag;
+
+int main() try {
+  using namespace xdiag::bits;
+  using namespace xdiag::combinatorics;
+
+  constexpr bool time_index = false;
+
+  // Subsets
+  {
+    int n = 16;
+    int64_t cnt = 0;
+    auto subs = Subsets<uint64_t>(n);
+    auto t0 = rightnow();
+    for (auto s : subs) {
+      if constexpr (time_index)
+        if (subs.index(s) != cnt) {
+          Log("{} {}", to_string(s, n), subs.index(s));
+        }
+      ++cnt;
+      // Log("{}", to_string(make_bitset(s), n));
+    }
+    auto t1 = rightnow();
+    auto td = duration_cast<microseconds>(t1 - t0).count();
+    double t = (double)td;
+    Log("Subsets: {} {} {} ", cnt, t, t / cnt);
+  }
+
+  // Combinations
+  {
+    int n = 24;
+    int k = 12;
+    int64_t cnt = 0;
+    auto combs = Combinations<uint64_t>(n, k);
+    auto t0 = rightnow();
+    for (auto s : combs) {
+      if constexpr (time_index)
+
+        if (combs.index(s) != cnt) {
+          Log("{} {}", to_string(s, n), combs.index(s));
+        }
+      ++cnt;
+      // Log("{}", to_string(make_bitset(s), n));
+    }
+    auto t1 = rightnow();
+    auto td = duration_cast<microseconds>(t1 - t0).count();
+    double t = (double)td;
+    Log("Combinations (short): {} {} {} ", cnt, t, t / cnt);
+  }
+
+  // LinTable
+  {
+    int n = 24;
+    int k = 12;
+    int64_t cnt = 0;
+    auto combs = LinTable<uint64_t>(n, k);
+    auto t0 = rightnow();
+    for (auto s : combs) {
+      if constexpr (time_index)
+
+        if (combs.index(s) != cnt) {
+          Log("{} {}", to_string(s, n), combs.index(s));
+        }
+      ++cnt;
+      // Log("{}", to_string(make_bitset(s), n));
+    }
+    auto t1 = rightnow();
+    auto td = duration_cast<microseconds>(t1 - t0).count();
+    double t = (double)td;
+    Log("LinTable: {} {} {} ", cnt, t, t / cnt);
+  }
+
+  {
+    int n = 80;
+    int k = 4;
+    int64_t cnt = 0;
+    auto combs = Combinations<Bitset<uint64_t, 2>>(n, k);
+    auto t0 = rightnow();
+    for (auto s : combs) {
+      if constexpr (time_index)
+
+        if (combs.index(s) != cnt) {
+          Log("{} {}", to_string(s, n), combs.index(s));
+        }
+      ++cnt;
+      // Log("{}", to_string(s, n));
+    }
+    auto t1 = rightnow();
+    auto td = duration_cast<microseconds>(t1 - t0).count();
+    double t = (double)td;
+    Log("Combinations (long): {} {} {} ", cnt, t, t / cnt);
+  }
+
+  {
+    int64_t n = 12;
+    int64_t q = 4;
+    int64_t cnt = 0;
+    using A = BitArray<uint64_t, 2>;
+    auto bms = BoundedMultisets<A>(n, q);
+    auto t0 = rightnow();
+    for (auto s : bms) {
+      if constexpr (time_index)
+
+        if (bms.index(s) != cnt) {
+          Log("{} {}", to_string(s, n), bms.index(s));
+        }
+      ++cnt;
+      // Log("{}", to_string(s, n));
+    }
+    auto t1 = rightnow();
+    auto td = duration_cast<microseconds>(t1 - t0).count();
+    double t = (double)td;
+    Log("BoundedMultisets: {} {} {} ", cnt, t, t / cnt);
+  }
+
+  {
+    int64_t n = 12;
+    int64_t total = 12;
+    int64_t q = 4;
+    int64_t cnt = 0;
+    using A = BitArray<uint64_t, 2>;
+    auto bps = BoundedPartitions<A>(n, total, q);
+    auto t0 = rightnow();
+    for (auto s : bps) {
+      if constexpr (time_index)
+        if (bps.index(s) != cnt) {
+          Log("{} {}", to_string(s, n), bps.index(s));
+        }
+      ++cnt;
+    }
+    auto t1 = rightnow();
+    auto td = duration_cast<microseconds>(t1 - t0).count();
+    double t = (double)td;
+    Log("BoundedPartitions (short): {} {} {} ", cnt, t, t / cnt);
+  }
+
+
+  {
+    int64_t n = 50;
+    int64_t total = 4;
+    int64_t q = 4;
+    int64_t cnt = 0;
+    using A = BitArray<BitsetStatic2, 2>;
+    auto bps = BoundedPartitions<A>(n, total, q);
+    auto t0 = rightnow();
+    for (auto s : bps) {
+      if constexpr (time_index)
+        if (bps.index(s) != cnt) {
+          Log("{} {}", to_string(s, n), bps.index(s));
+        }
+      ++cnt;
+    }
+    auto t1 = rightnow();
+    auto td = duration_cast<microseconds>(t1 - t0).count();
+    double t = (double)td;
+    Log("BoundedPartitions (long): {} {} {} ", cnt, t, t / cnt);
+  }
+
+
+  {
+    int64_t n = 12;
+    int64_t total = 12;
+    int64_t q = 4;
+    int64_t cnt = 0;
+    using A = BitArray<uint64_t, 2>;
+    auto bps = SchaeferTable<A>(n, total, q);
+    auto t0 = rightnow();
+    for (auto s : bps) {
+      if constexpr (time_index)
+        if (bps.index(s) != cnt) {
+          Log("{} {}", to_string(s, n), bps.index(s));
+        }
+      ++cnt;
+    }
+    auto t1 = rightnow();
+    auto td = duration_cast<microseconds>(t1 - t0).count();
+    double t = (double)td;
+    Log("SchaeferTable: {} {} {} ", cnt, t, t / cnt);
+  }
+
+} catch (Error e) {
+  error_trace(e);
+}

benchmarks/combinatorics/readme.txt

@@ -0,0 +1,15 @@
+### MEMORY PROFILE ###
+- compile xdiag using
+
+cmake -S . -B build -D CMAKE_CXX_COMPILER=icpx -D CMAKE_CXX_FLAGS="-L/home/awietek/Research/Software/gperftools/build -ltcmalloc -g"
+
+- install xdiag
+- compile application using
+
+cmake -S . -B build -D CMAKE_CXX_COMPILER=icpx -D CMAKE_CXX_FLAGS="-L/home/awietek/Research/Software/gperftools/build -ltcmalloc -g"
+
+- run using
+HEAPPROFILE=heap ./build/main 28
+
+- visualize using
+pprof --pdf ./build/main heap.0001.heap > heap.pdf

benchmarks/representative_table/CMakeLists.txt

@@ -0,0 +1,5 @@
+cmake_minimum_required(VERSION 3.19)
+project(benchmark_heisenberg_chain)
+find_package(xdiag REQUIRED HINTS "~/Research/Software/xdiag/install")
+add_executable(main main.cpp)
+target_link_libraries(main PRIVATE xdiag::xdiag)

benchmarks/representative_table/main.cpp

@@ -0,0 +1,25 @@
+#include <xdiag/combinatorics/combinations/combinations.hpp>
+#include <xdiag/symmetries/action/site_permutation.hpp>
+#include <xdiag/symmetries/cyclic_group.hpp>
+#include <xdiag/symmetries/tables/representative_table.hpp>
+#include <xdiag/utils/timing.hpp>
+
+using namespace xdiag;
+
+int main() try {
+  using bits::Bitset;
+  using combinatorics::Combinations;
+  using namespace symmetries;
+
+  int n = 36;
+  int k = 18;
+  auto combs = Combinations<uint64_t>(n, k);
+  auto irrep = cyclic_group_irrep(n, 0); // trivial: all chi=1
+  auto sp = SitePermutation(irrep.group());
+  tic();
+  auto table = RepresentativeTable<Combinations<uint64_t>>(combs, sp, irrep);
+  toc();
+
+} catch (Error e) {
+  error_trace(e);
+}

benchmarks/representative_table/readme.txt

@@ -0,0 +1,15 @@
+### MEMORY PROFILE ###
+- compile xdiag using
+
+cmake -S . -B build -D CMAKE_CXX_COMPILER=icpx -D CMAKE_CXX_FLAGS="-L/home/awietek/Research/Software/gperftools/build -ltcmalloc -g"
+
+- install xdiag
+- compile application using
+
+cmake -S . -B build -D CMAKE_CXX_COMPILER=icpx -D CMAKE_CXX_FLAGS="-L/home/awietek/Research/Software/gperftools/build -ltcmalloc -g"
+
+- run using
+HEAPPROFILE=heap ./build/main 28
+
+- visualize using
+pprof --pdf ./build/main heap.0001.heap > heap.pdf

benchmarks/sparse/readme.txt

@@ -0,0 +1,15 @@
+### MEMORY PROFILE ###
+- compile xdiag using
+
+cmake -S . -B build -D CMAKE_CXX_COMPILER=icpx -D CMAKE_CXX_FLAGS="-L/home/awietek/Research/Software/gperftools/build -ltcmalloc -g"
+
+- install xdiag
+- compile application using
+
+cmake -S . -B build -D CMAKE_CXX_COMPILER=icpx -D CMAKE_CXX_FLAGS="-L/home/awietek/Research/Software/gperftools/build -ltcmalloc -g"
+
+- run using
+HEAPPROFILE=heap ./build/main 28
+
+- visualize using
+pprof --pdf ./build/main heap.0001.heap > heap.pdf

cmake/generate_instantiation.cmake

@@ -0,0 +1,17 @@
+# Script-mode entry point for build-time instantiation file generation.
+#
+# Invoked by add_custom_command as:
+#   cmake -DSOURCE_FILE=<abs>
+#         -DSOURCE_ROOT=<abs>
+#         -DINCLUDE_ROOT=<abs>
+#         -DOUTPUT_DIR=<abs>
+#         -P generate_instantiation.cmake
+
+include("${CMAKE_CURRENT_LIST_DIR}/instantiations.cmake")
+
+generate_instantiation_files(
+  "${SOURCE_FILE}"
+  "${SOURCE_ROOT}"
+  "${INCLUDE_ROOT}"
+  "${OUTPUT_DIR}"
+)