BLAS compatibility library

CMakeLists.txt

@@ -15,6 +15,10 @@ set(APFP_PROFILING OFF CACHE BOOL "Enable profiling in generated kernels.")
 set(APFP_SAVE_TEMPS OFF CACHE BOOL "Save temporary files from kernel builds.")
 set_property(CACHE APFP_SEMANTICS PROPERTY STRINGS GMP MPFR)
 
+# One day we might accept both
+set(APFP_INTERFACE_TYPE ${APFP_SEMANTICS})
+# but not today
+
 # Validation and derived numbers
 math(EXPR APFP_ALIGNED "${APFP_BITS} % 512")
 if(NOT APFP_ALIGNED EQUAL 0)
@@ -30,7 +34,7 @@ find_package(GMP REQUIRED)
 find_package(Threads REQUIRED)
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic -Wno-unused-label -Wno-unknown-pragmas -Wno-class-memaccess -DAPFP_${APFP_SEMANTICS}_SEMANTICS")
-include_directories(${CMAKE_BINARY_DIR} include SYSTEM hlslib/include ${Vitis_INCLUDE_DIRS} )
+include_directories(${CMAKE_BINARY_DIR} include SYSTEM hlslib/include ${Vitis_INCLUDE_DIRS} interface)
 
 configure_file(include/Config.h.in Config.h)
 
@@ -40,7 +44,7 @@ set(APFP_KERNEL_FILES device/MatrixMultiplication.cpp
 
 # Setup FPGA kernel targets
 add_vitis_kernel(MatrixMultiplication FILES ${APFP_KERNEL_FILES}
- INCLUDE_DIRS include hlslib/include ${CMAKE_BINARY_DIR}
+ INCLUDE_DIRS include hlslib/include ${CMAKE_BINARY_DIR} ${GMP_INCLUDES}
  HLS_FLAGS "-DAP_INT_MAX_W=${APFP_MAX_BITS} -DAPFP_${APFP_SEMANTICS}_SEMANTICS"
  HLS_CONFIG "config_compile -pipeline_style frp\nconfig_dataflow -fifo_depth 16"
  DEPENDS ${CMAKE_BINARY_DIR}/Config.h
@@ -66,9 +70,9 @@ add_library(simulation ${APFP_KERNEL_FILES})
 target_compile_options(simulation PRIVATE -Wno-unknown-pragmas -DAP_INT_MAX_W=${APFP_MAX_BITS})
 target_link_libraries(simulation ${CMAKE_THREAD_LIBS_INIT})
 
-add_library(ApfpHostlib SHARED interface/Apfp.cpp)
-target_link_libraries(ApfpHostlib ${Vitis_LIBRARIES} ${GMP_LIBRARIES}) 
-target_compile_definitions(ApfpHostlib PRIVATE HLSLIB_SIMULATE_OPENCL)
+add_library(apfpHostlib SHARED interface/Apfp.cpp interface/ApfpBlas.cpp interface/ApfpInterfaceType.cpp)
+target_link_libraries(apfpHostlib ${Vitis_LIBRARIES} ${GMP_LIBRARIES}) 
+target_compile_definitions(apfpHostlib PRIVATE HLSLIB_SIMULATE_OPENCL)
 
 # Executable used to run in simulation mode, calling the kernel as a C++ function directly
 add_executable(TestSimulation host/TestProgram.cpp)
@@ -84,7 +88,20 @@ enable_testing()
 add_test(TestSimulation TestSimulation 4 4 4)
 add_library(Catch host/Catch.cpp)
 add_executable(UnitTests host/UnitTests.cpp)
-target_link_libraries(UnitTests Catch ${GMP_LIBRARIES} ${MPFR_LIBRARIES} apfp simulation)
+target_link_libraries(UnitTests Catch ${GMP_LIBRARIES} ${MPFR_LIBRARIES} apfp apfpHostlib simulation)
 add_test(UnitTests UnitTests)
 
-install(TARGETS ApfpHostlib)
+add_executable(BlasUnitTests host/BlasUnitTests.cpp)
+target_link_libraries(BlasUnitTests Catch ${GMP_LIBRARIES} ${MPFR_LIBRARIES} apfp apfpHostlib simulation)
+
+install(TARGETS apfpHostlib)
+install(FILES
+ interface/Apfp.h
+ interface/ApfpBlas.h
+ interface/ApfpInterfaceType.h
+ ${CMAKE_BINARY_DIR}/Config.h
+ DESTINATION include/apfp)
+install(FILES
+ ${CMAKE_BINARY_DIR}/MatrixMultiplication_hw.xclbin
+ ${CMAKE_BINARY_DIR}/MatrixMultiplication_hw_emu.xclbin
+ DESTINATION lib)

device/MatrixMultiplication.cpp

@@ -6,10 +6,15 @@
 
 #include "ArithmeticOperations.h"
 
+// All memory accesses are column-major!
+// I.e. a(i,j) = a[i + LDA * j]
+// AB = sum_k a(i,k) b(k, j) = sum_k a[i + LDA * k] * b[k + LDA * j]
+// LDA (leading dimension of A) = stride
+
 // Annoyingly we have to specialize the innermost loop on whether multiple DRAM flits per number are required or not,
 // because HLS otherwise gets confused by pragmas applied to a loop of size 1 in the latter case.
 template <int lines_per_number>
-void ReadAInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &a_to_feeder, const int size_k, const int n0,
+void ReadAInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &a_to_feeder, const int size_n, const int n0,
  const int k) {
 #pragma HLS INLINE
  DramLine num[kLinesPerNumber];
@@ -19,7 +24,7 @@ void ReadAInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &a_to_fee
  for (int i = 0; i < kLinesPerNumber; ++i) {
 #pragma HLS PIPELINE II = 1
 #pragma HLS LOOP_FLATTEN
- num[i] = mem[((n0 * kTileSizeN + n1) * size_k + k) * kLinesPerNumber + i];
+ num[i] = mem[((n0 * kTileSizeN + n1) + k * size_n) * kLinesPerNumber + i];
  if (i == kLinesPerNumber - 1) {
  a_to_feeder.Push(PackedFloat(num));
  }
@@ -28,15 +33,15 @@ void ReadAInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &a_to_fee
 }
 
 template <>
-void ReadAInner<1>(DramLine const *const mem, hlslib::Stream<PackedFloat> &a_to_feeder, const int size_k, const int n0,
+void ReadAInner<1>(DramLine const *const mem, hlslib::Stream<PackedFloat> &a_to_feeder, const int size_n, const int n0,
  const int k) {
 #pragma HLS INLINE
 ReadA_N:
  for (int n1 = 0; n1 < kTileSizeN; ++n1) {
 #pragma HLS PIPELINE II = 1
 #pragma HLS LOOP_FLATTEN
  DramLine num[1];
- num[0] = mem[(n0 * kTileSizeN + n1) * size_k + k];
+ num[0] = mem[((n0 * kTileSizeN + n1) + k * size_n) * kLinesPerNumber];
  a_to_feeder.Push(PackedFloat(num));
  }
 }
@@ -51,7 +56,7 @@ void ReadA(DramLine const *const mem, hlslib::Stream<PackedFloat> &a_to_feeder,
  for (int m0 = 0; m0 < tiles_m; ++m0) {
  ReadA_K:
  for (int k = 0; k < size_k; ++k) {
- ReadAInner<kLinesPerNumber>(mem, a_to_feeder, size_k, n0, k);
+ ReadAInner<kLinesPerNumber>(mem, a_to_feeder, size_n, n0, k);
  }
  }
  }
@@ -90,7 +95,7 @@ void FeedA(hlslib::Stream<PackedFloat> &a_to_feeder, hlslib::Stream<PackedFloat>
 ////////////////////////////////////////////////////////////////////////////////
 
 template <int lines_per_number>
-void ReadBInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &b_to_feeder, const int size_m, const int m0,
+void ReadBInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &b_to_feeder, const int size_k, const int m0,
  const int k) {
 #pragma HLS INLINE
  DramLine num[kLinesPerNumber];
@@ -100,7 +105,7 @@ void ReadBInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &b_to_fee
  for (int i = 0; i < kLinesPerNumber; ++i) {
 #pragma HLS PIPELINE II = 1
 #pragma HLS LOOP_FLATTEN
- num[i] = mem[(k * size_m + m0 * kTileSizeM + m1) * kLinesPerNumber + i];
+ num[i] = mem[(k + (m0 * kTileSizeM + m1) * size_k) * kLinesPerNumber + i];
  if (i == kLinesPerNumber - 1) {
  b_to_feeder.Push(PackedFloat(num));
  }
@@ -109,15 +114,15 @@ void ReadBInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &b_to_fee
 }
 
 template <>
-void ReadBInner<1>(DramLine const *const mem, hlslib::Stream<PackedFloat> &b_to_feeder, const int size_m, const int m0,
+void ReadBInner<1>(DramLine const *const mem, hlslib::Stream<PackedFloat> &b_to_feeder, const int size_k, const int m0,
  const int k) {
 #pragma HLS INLINE
 ReadB_M:
  for (int m1 = 0; m1 < kTileSizeM; ++m1) {
 #pragma HLS PIPELINE II = 1
 #pragma HLS LOOP_FLATTEN
  DramLine num[1];
- num[0] = mem[k * size_m + m0 * kTileSizeM + m1];
+ num[0] = mem[(k + (m0 * kTileSizeM + m1) * size_k) * kLinesPerNumber];
  b_to_feeder.Push(PackedFloat(num));
  }
 }
@@ -132,7 +137,7 @@ void ReadB(DramLine const *const mem, hlslib::Stream<PackedFloat> &b_to_feeder,
  for (int m0 = 0; m0 < tiles_m; ++m0) {
  ReadB_K:
  for (int k = 0; k < size_k; ++k) {
- ReadBInner<kLinesPerNumber>(mem, b_to_feeder, size_m, m0, k);
+ ReadBInner<kLinesPerNumber>(mem, b_to_feeder, size_k, m0, k);
  }
  }
  }
@@ -169,7 +174,7 @@ void FeedB(hlslib::Stream<PackedFloat> &b_to_feeder, hlslib::Stream<PackedFloat>
 ////////////////////////////////////////////////////////////////////////////////
 
 template <int lines_per_number>
-void ReadCInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &c_to_feeder, const int size_m, const int n0,
+void ReadCInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &c_to_feeder, const int size_n, const int n0,
  const int m0, const int n1) {
 #pragma HLS INLINE
 ReadC_M:
@@ -179,7 +184,7 @@ void ReadCInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &c_to_fee
  for (int i = 0; i < kLinesPerNumber; ++i) {
 #pragma HLS PIPELINE II = 1
 #pragma HLS LOOP_FLATTEN
- num[i] = mem[((n0 * kTileSizeN + n1) * size_m + m0 * kTileSizeM + m1) * kLinesPerNumber + i];
+ num[i] = mem[((n0 * kTileSizeN + n1) + (m0 * kTileSizeM + m1) * size_n) * kLinesPerNumber + i];
  if (i == kLinesPerNumber - 1) {
  c_to_feeder.Push(PackedFloat(num));
  }
@@ -188,15 +193,15 @@ void ReadCInner(DramLine const *const mem, hlslib::Stream<PackedFloat> &c_to_fee
 }
 
 template <>
-void ReadCInner<1>(DramLine const *const mem, hlslib::Stream<PackedFloat> &c_to_feeder, const int size_m, const int n0,
+void ReadCInner<1>(DramLine const *const mem, hlslib::Stream<PackedFloat> &c_to_feeder, const int size_n, const int n0,
  const int m0, const int n1) {
 #pragma HLS INLINE
 ReadC_M:
  for (int m1 = 0; m1 < kTileSizeM; ++m1) {
 #pragma HLS PIPELINE II = 1
 #pragma HLS LOOP_FLATTEN
  DramLine num[1];
- num[0] = mem[(n0 * kTileSizeN + n1) * size_m + m0 * kTileSizeM + m1];
+ num[0] = mem[((n0 * kTileSizeN + n1) + (m0 * kTileSizeM + m1) * size_n) * kLinesPerNumber];
  c_to_feeder.Push(PackedFloat(num));
  }
 }
@@ -210,7 +215,7 @@ void ReadC(DramLine const *const mem, hlslib::Stream<PackedFloat> &c_to_feeder,
  for (int m0 = 0; m0 < tiles_m; ++m0) {
  ReadC_N:
  for (int n1 = 0; n1 < kTileSizeN; ++n1) {
- ReadCInner<kLinesPerNumber>(mem, c_to_feeder, size_m, n0, m0, n1);
+ ReadCInner<kLinesPerNumber>(mem, c_to_feeder, size_n, n0, m0, n1);
  }
  }
  }
@@ -290,7 +295,7 @@ void WriteCInner(hlslib::Stream<PackedFloat> &from_kernel, DramLine *const mem,
  }
  const bool in_bounds = (n0 * kTileSizeN + n1 < size_n) && (m0 * kTileSizeM + m1 < size_m);
  if (in_bounds) {
- mem[((n0 * kTileSizeN + n1) * size_m + m0 * kTileSizeM + m1) * kLinesPerNumber + i] = num[i];
+ mem[((n0 * kTileSizeN + n1) + (m0 * kTileSizeM + m1) * size_n) * kLinesPerNumber + i] = num[i];
  }
  }
  }
@@ -308,7 +313,7 @@ void WriteCInner<1>(hlslib::Stream<PackedFloat> &from_kernel, DramLine *const me
  from_kernel.Pop().UnpackFlits(num);
  const bool in_bounds = (n0 * kTileSizeN + n1 < size_n) && (m0 * kTileSizeM + m1 < size_m);
  if (in_bounds) {
- mem[(n0 * kTileSizeN + n1) * size_m + m0 * kTileSizeM + m1] = num[0];
+ mem[((n0 * kTileSizeN + n1) + (m0 * kTileSizeM + m1) * size_n) * kLinesPerNumber] = num[0];
  }
  }
 }
@@ -354,7 +359,7 @@ void Compute(hlslib::Stream<PackedFloat> &a_in, hlslib::Stream<PackedFloat> &b_i
  const PackedFloat c_read = c_in.Pop();
  const PackedFloat a = (m1 == 0) ? a_read : a_buffer;
  const PackedFloat b = (n1 == 0) ? b_read : b_buffer[m1];
- const PackedFloat c = (k == 0) ? c_read : c_buffer[n1 * kTileSizeM + m1];
+ const PackedFloat c = (k == 0) ? c_read : c_buffer[n1 + m1 * kTileSizeN];
  a_buffer = a;
  b_buffer[m1] = b;
  // Ignore contributions from out-of-bound indices
@@ -363,7 +368,7 @@ void Compute(hlslib::Stream<PackedFloat> &a_in, hlslib::Stream<PackedFloat> &b_i
  const auto res = MultiplyAccumulate(in_bounds ? a : PackedFloat::Zero(),
  in_bounds ? b : PackedFloat::Zero(), c);
  // Write back to buffer
- c_buffer[n1 * kTileSizeM + m1] = res;
+ c_buffer[n1 + m1 * kTileSizeN] = res;
  c_out.Push(res);
  }
  }