Use ELF for insts in some programming examples (#2578)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: jgmelber

programming_examples/basic/memcpy/Makefile

@@ -54,10 +54,10 @@ build/${targetname}.mlir: ${srcdir}/${aie_py_src}
 # movement configuration, compute core program memories). 
 build/final.xclbin: build/${targetname}.mlir build/passThrough.cc.o
 	mkdir -p ${@D}
-	cd ${@D} && aiecc.py --aie-generate-xclbin --aie-generate-npu-insts --no-compile-host \
+	cd ${@D} && aiecc.py --aie-generate-xclbin --no-compile-host \
 	            --xclbin-name=${@F} \
 				--no-xchesscc --no-xbridge \
-				--aie-generate-npu --npu-insts-name=insts.bin $(<:%=../%)
+				--aie-generate-elf --elf-name=insts.elf $(<:%=../%)
 
 # Host code: Program executed on the CPU that will invoke our NPU design
 # and verify its outputs.
@@ -73,7 +73,7 @@ else
 endif
 
 run: ${targetname}.exe build/final.xclbin
-	${powershell} ./$< -x build/final.xclbin -i build/insts.bin -k MLIR_AIE -l ${length}
+	${powershell} ./$< -x build/final.xclbin -i build/insts.elf -k MLIR_AIE -l ${length}
 
 clean:
-	rm -rf build _build inst aie.mlir.prj core_* test.elf ${targetname}.exe
+	rm -rf build _build inst aie.mlir.prj core_* test.elf ${targetname}.exe

programming_examples/basic/memcpy/test.cpp

@@ -21,6 +21,10 @@
 #include "xrt/xrt_device.h"
 #include "xrt/xrt_kernel.h"
 
+#include "xrt/experimental/xrt_elf.h"
+#include "xrt/experimental/xrt_ext.h"
+#include "xrt/experimental/xrt_module.h"
+
 #include "test_utils.h"
 
 int main(int argc, const char *argv[]) {
@@ -60,19 +64,14 @@ int main(int argc, const char *argv[]) {
     return 1;
   }
 
-  std::vector<uint32_t> instr_v =
-      test_utils::load_instr_binary(vm["instr"].as<std::string>());
-
-  int verbosity = vm["verbosity"].as<int>();
-  if (verbosity >= 1)
-    std::cout << "Sequence instr count: " << instr_v.size() << std::endl;
-
   int N = vm["length"].as<int>();
   if ((N % 1024)) {
     std::cerr << "Length must be a multiple of 1024." << std::endl;
     return 1;
   }
 
+  int verbosity = vm["verbosity"].as<int>();
+
   // Start the XRT test code
   // Get a device handle
   unsigned int device_index = 0;
@@ -105,6 +104,9 @@ int main(int argc, const char *argv[]) {
 
   device.register_xclbin(xclbin);
 
+  xrt::elf elf(vm["instr"].as<std::string>());
+  xrt::module mod{elf};
+
   // get a hardware context
   if (verbosity >= 1)
     std::cout << "Getting hardware context." << std::endl;
@@ -113,14 +115,10 @@ int main(int argc, const char *argv[]) {
   // get a kernel handle
   if (verbosity >= 1)
     std::cout << "Getting handle to kernel:" << kernelName << std::endl;
-  auto kernel = xrt::kernel(context, kernelName);
+  auto kernel = xrt::ext::kernel(context, mod, kernelName);
 
-  auto bo_instr = xrt::bo(device, instr_v.size() * sizeof(int),
-                          XCL_BO_FLAGS_CACHEABLE, kernel.group_id(1));
-  auto bo_inA = xrt::bo(device, N * sizeof(int32_t), XRT_BO_FLAGS_HOST_ONLY,
-                        kernel.group_id(3));
-  auto bo_out = xrt::bo(device, N * sizeof(int32_t), XRT_BO_FLAGS_HOST_ONLY,
-                        kernel.group_id(4));
+  xrt::bo bo_inA = xrt::ext::bo{device, N * sizeof(int32_t)};
+  xrt::bo bo_out = xrt::ext::bo{device, N * sizeof(int32_t)};
 
   if (verbosity >= 1)
     std::cout << "Writing data into buffer objects." << std::endl;
@@ -131,22 +129,18 @@ int main(int argc, const char *argv[]) {
     srcVecA.push_back(i + 1);
   memcpy(bufInA, srcVecA.data(), (srcVecA.size() * sizeof(uint32_t)));
 
-  void *bufInstr = bo_instr.map<void *>();
-  memcpy(bufInstr, instr_v.data(), instr_v.size() * sizeof(int));
-
-  bo_instr.sync(XCL_BO_SYNC_BO_TO_DEVICE);
   bo_inA.sync(XCL_BO_SYNC_BO_TO_DEVICE);
 
   if (verbosity >= 1)
     std::cout << "Running Kernel." << std::endl;
   unsigned int opcode = 3;
   // Setup run to configure
-  auto cfg_run = kernel(opcode, bo_instr, instr_v.size(), bo_inA, bo_out);
-  cfg_run.wait();
+  auto cfg_run = kernel(opcode, 0, 0, bo_inA, bo_out);
+  cfg_run.wait2();
   auto start = std::chrono::high_resolution_clock::now();
   // Test run
-  auto run = kernel(opcode, bo_instr, instr_v.size(), bo_inA, bo_out);
-  run.wait();
+  auto run = kernel(opcode, 0, 0, bo_inA, bo_out);
+  run.wait2();
   auto stop = std::chrono::high_resolution_clock::now();
   const float npu_time =
       std::chrono::duration_cast<std::chrono::microseconds>(stop - start)

programming_examples/basic/vector_scalar_add/Makefile

@@ -30,9 +30,9 @@ build/aie.mlir: ${srcdir}/${aie_py_src}
 
 build/final.xclbin: build/aie.mlir
 	mkdir -p ${@D}
-	cd ${@D} && aiecc.py --aie-generate-xclbin --aie-generate-npu-insts --no-compile-host \
+	cd ${@D} && aiecc.py --aie-generate-xclbin --aie-generate-elf --no-compile-host \
 		--no-xchesscc --no-xbridge \
-		--xclbin-name=${@F} --npu-insts-name=insts.bin ${<F}
+		--xclbin-name=${@F} --elf-name=insts.elf ${<F}
 
 ${targetname}.exe: ${srcdir}/test.cpp
 	rm -rf _build
@@ -46,7 +46,7 @@ else
 endif
 
 run: ${targetname}.exe build/final.xclbin
-	${powershell} ./$< -x build/final.xclbin -i build/insts.bin -k MLIR_AIE
+	${powershell} ./$< -x build/final.xclbin -i build/insts.elf -k MLIR_AIE
 
 clean:
 	rm -rf build _build ${targetname}.exe

programming_examples/basic/vector_scalar_add/test.cpp

@@ -20,6 +20,10 @@
 #include "xrt/xrt_device.h"
 #include "xrt/xrt_kernel.h"
 
+#include "xrt/experimental/xrt_elf.h"
+#include "xrt/experimental/xrt_ext.h"
+#include "xrt/experimental/xrt_module.h"
+
 #include "test_utils.h"
 
 int main(int argc, const char *argv[]) {
@@ -40,12 +44,6 @@ int main(int argc, const char *argv[]) {
   constexpr int IN_SIZE = 1024;
   constexpr int OUT_SIZE = 1024;
 
-  // Load instruction sequence
-  std::vector<uint32_t> instr_v =
-      test_utils::load_instr_binary(vm["instr"].as<std::string>());
-  if (verbosity >= 1)
-    std::cout << "Sequence instr count: " << instr_v.size() << "\n";
-
   // ------------------------------------------------------
   // Get device, load the xclbin & kernel and register them
   // ------------------------------------------------------
@@ -86,21 +84,21 @@ int main(int argc, const char *argv[]) {
     std::cout << "Getting hardware context.\n";
   xrt::hw_context context(device, xclbin.get_uuid());
 
+  // Load instr ELF
+  xrt::elf elf(vm["instr"].as<std::string>());
+  xrt::module mod{elf};
+
   // Get a kernel handle
   if (verbosity >= 1)
     std::cout << "Getting handle to kernel:" << kernelName << "\n";
-  auto kernel = xrt::kernel(context, kernelName);
+  auto kernel = xrt::ext::kernel(context, mod, kernelName);
 
   // ------------------------------------------------------
   // Initialize input/ output buffer sizes and sync them
   // ------------------------------------------------------
 
-  auto bo_instr = xrt::bo(device, instr_v.size() * sizeof(int),
-                          XCL_BO_FLAGS_CACHEABLE, kernel.group_id(1));
-  auto bo_inA = xrt::bo(device, IN_SIZE * sizeof(int32_t),
-                        XRT_BO_FLAGS_HOST_ONLY, kernel.group_id(3));
-  auto bo_out = xrt::bo(device, OUT_SIZE * sizeof(int32_t),
-                        XRT_BO_FLAGS_HOST_ONLY, kernel.group_id(4));
+  xrt::bo bo_inA = xrt::ext::bo{device, IN_SIZE * sizeof(int32_t)};
+  xrt::bo bo_out = xrt::ext::bo{device, OUT_SIZE * sizeof(int32_t)};
 
   if (verbosity >= 1)
     std::cout << "Writing data into buffer objects.\n";
@@ -111,16 +109,12 @@ int main(int argc, const char *argv[]) {
     srcVecA.push_back(i + 1);
   memcpy(bufInA, srcVecA.data(), (srcVecA.size() * sizeof(uint32_t)));
 
-  void *bufInstr = bo_instr.map<void *>();
-  memcpy(bufInstr, instr_v.data(), instr_v.size() * sizeof(int));
-
-  bo_instr.sync(XCL_BO_SYNC_BO_TO_DEVICE);
   bo_inA.sync(XCL_BO_SYNC_BO_TO_DEVICE);
 
   if (verbosity >= 1)
     std::cout << "Running Kernel.\n";
   unsigned int opcode = 3;
-  auto run = kernel(opcode, bo_instr, instr_v.size(), bo_inA, bo_out);
+  auto run = kernel(opcode, 0, 0, bo_inA, bo_out);
   run.wait();
 
   bo_out.sync(XCL_BO_SYNC_BO_FROM_DEVICE);

programming_examples/basic/vector_scalar_add_runlist/Makefile

@@ -30,9 +30,9 @@ build/aie.mlir: ${srcdir}/${aie_py_src}
 
 build/final.xclbin: build/aie.mlir
 	mkdir -p ${@D}
-	cd ${@D} && aiecc.py --aie-generate-xclbin --aie-generate-npu-insts --no-compile-host \
+	cd ${@D} && aiecc.py --aie-generate-xclbin --aie-generate-elf --no-compile-host \
 		--no-xchesscc --no-xbridge \
-		--xclbin-name=${@F} --npu-insts-name=insts.bin ${<F}
+		--xclbin-name=${@F} --elf-name=insts.elf ${<F}
 
 ${targetname}.exe: ${srcdir}/test.cpp
 	rm -rf _build
@@ -46,7 +46,7 @@ else
 endif
 
 run: ${targetname}.exe build/final.xclbin
-	${powershell} ./$< -x build/final.xclbin -i build/insts.bin -k MLIR_AIE
+	${powershell} ./$< -x build/final.xclbin -i build/insts.elf -k MLIR_AIE
 
 clean:
 	rm -rf build _build ${targetname}.exe

programming_examples/basic/vector_scalar_add_runlist/README.md

@@ -10,6 +10,8 @@
 
 # Vector Scalar Addition Runlist:
 
+> NOTE: The `xrt::runlist` feature is not implemented on Phoenix (NPU1)
+
 This design takes the simple Vector Scalar Addition example and shows how you can use the XRT runlist feature to chain multiple commands together. 
 
 This design shows an extremely simple single AIE design, which is incrementing every value in an input vector.
@@ -62,4 +64,4 @@ To run the design:
 
 ```shell
 make run
-```
+```

programming_examples/basic/vector_scalar_add_runlist/run_makefile.lit

@@ -16,7 +16,11 @@
 #include <string>
 #include <vector>
 
+#include "xrt/experimental/xrt_elf.h"
+#include "xrt/experimental/xrt_ext.h"
 #include "xrt/experimental/xrt_kernel.h" // for xrt::runlist
+#include "xrt/experimental/xrt_module.h"
+
 #include "xrt/xrt_aie.h"
 #include "xrt/xrt_bo.h"
 #include "xrt/xrt_device.h"
@@ -42,12 +46,6 @@ int main(int argc, const char *argv[]) {
   constexpr int IN_SIZE = 1024;
   constexpr int OUT_SIZE = 1024;
 
-  // Load instruction sequence
-  std::vector<uint32_t> instr_v =
-      test_utils::load_instr_binary(vm["instr"].as<std::string>());
-  if (verbosity >= 1)
-    std::cout << "Sequence instr count: " << instr_v.size() << "\n";
-
   // ------------------------------------------------------
   // Get device, load the xclbin & kernel and register them
   // ------------------------------------------------------
@@ -83,6 +81,9 @@ int main(int argc, const char *argv[]) {
               << "\n";
   device.register_xclbin(xclbin);
 
+  xrt::elf elf(vm["instr"].as<std::string>());
+  xrt::module mod{elf};
+
   // Get a hardware context
   if (verbosity >= 1)
     std::cout << "Getting hardware context.\n";
@@ -91,23 +92,15 @@ int main(int argc, const char *argv[]) {
   // Get a kernel handle
   if (verbosity >= 1)
     std::cout << "Getting handle to kernel:" << kernelName << "\n";
-  auto kernel = xrt::kernel(context, kernelName);
+  auto kernel = xrt::ext::kernel(context, mod, kernelName);
 
   // ------------------------------------------------------
   // Initialize input/ output buffer sizes and sync them
   // ------------------------------------------------------
 
-  auto bo_instr_0 = xrt::bo(device, instr_v.size() * sizeof(int),
-                            XCL_BO_FLAGS_CACHEABLE, kernel.group_id(1));
-  auto bo_inA_0 = xrt::bo(device, IN_SIZE * sizeof(int32_t),
-                          XRT_BO_FLAGS_HOST_ONLY, kernel.group_id(3));
-  auto bo_out_0 = xrt::bo(device, OUT_SIZE * sizeof(int32_t),
-                          XRT_BO_FLAGS_HOST_ONLY, kernel.group_id(4));
-
-  auto bo_instr_1 = xrt::bo(device, instr_v.size() * sizeof(int),
-                            XCL_BO_FLAGS_CACHEABLE, kernel.group_id(1));
-  auto bo_out_1 = xrt::bo(device, OUT_SIZE * sizeof(int32_t),
-                          XRT_BO_FLAGS_HOST_ONLY, kernel.group_id(4));
+  xrt::bo bo_inA_0 = xrt::ext::bo{device, IN_SIZE * sizeof(int32_t)};
+  xrt::bo bo_out_0 = xrt::ext::bo{device, OUT_SIZE * sizeof(int32_t)};
+  xrt::bo bo_out_1 = xrt::ext::bo{device, OUT_SIZE * sizeof(int32_t)};
 
   if (verbosity >= 1)
     std::cout << "Writing data into buffer objects.\n";
@@ -121,15 +114,7 @@ int main(int argc, const char *argv[]) {
   uint32_t *bufInA_0 = bo_inA_0.map<uint32_t *>();
   memcpy(bufInA_0, srcVecA.data(), (srcVecA.size() * sizeof(uint32_t)));
 
-  // Getting handles to the instruction sequence BOs and copy data to them
-  void *bufInstr_0 = bo_instr_0.map<void *>();
-  void *bufInstr_1 = bo_instr_1.map<void *>();
-  memcpy(bufInstr_0, instr_v.data(), instr_v.size() * sizeof(int));
-  memcpy(bufInstr_1, instr_v.data(), instr_v.size() * sizeof(int));
-
   // Synchronizing BOs
-  bo_instr_0.sync(XCL_BO_SYNC_BO_TO_DEVICE);
-  bo_instr_1.sync(XCL_BO_SYNC_BO_TO_DEVICE);
   bo_inA_0.sync(XCL_BO_SYNC_BO_TO_DEVICE);
 
   unsigned int opcode = 3;
@@ -140,16 +125,16 @@ int main(int argc, const char *argv[]) {
   // Creating the first run
   xrt::run run0 = xrt::run(kernel);
   run0.set_arg(0, opcode);
-  run0.set_arg(1, bo_instr_0);
-  run0.set_arg(2, instr_v.size());
+  run0.set_arg(1, 0);
+  run0.set_arg(2, 0);
   run0.set_arg(3, bo_inA_0);
   run0.set_arg(4, bo_out_0);
 
   // Creating the second run
   xrt::run run1 = xrt::run(kernel);
   run1.set_arg(0, opcode);
-  run1.set_arg(1, bo_instr_1);
-  run1.set_arg(2, instr_v.size());
+  run1.set_arg(1, 0);
+  run1.set_arg(2, 0);
   run1.set_arg(3, bo_out_0);
   run1.set_arg(4, bo_out_1);
 

programming_examples/basic/vector_scalar_add_runlist/run_makefile_placed.lit

@@ -50,10 +50,10 @@ build/${targetname}.mlir: ${srcdir}/${aie_py_src}
 
 build/final.xclbin: build/${targetname}.mlir build/${targetname}.cc.o
 	mkdir -p ${@D}
-	cd ${@D} && aiecc.py --aie-generate-xclbin --aie-generate-npu-insts --no-compile-host \
+	cd ${@D} && aiecc.py --aie-generate-xclbin --no-compile-host \
 	            --xclbin-name=${@F} \
 				--no-xchesscc --no-xbridge \
-				--aie-generate-npu --npu-insts-name=insts.bin $(<:%=../%)
+				--aie-generate-elf --elf-name=insts.elf $(<:%=../%)
 
 ${targetname}.exe: ${srcdir}/test.cpp
 	rm -rf _build
@@ -67,7 +67,7 @@ else
 endif
 
 run: ${targetname}.exe build/final.xclbin
-	${powershell} ./$< -x build/final.xclbin -i build/insts.bin -k MLIR_AIE -l ${length}
+	${powershell} ./$< -x build/final.xclbin -i build/insts.elf -k MLIR_AIE -l ${length}
 
 clean:
 	rm -rf build _build inst aie.mlir.prj core_* test.elf ${targetname}.exe