dma and demo kernels

tests/regression/rickroll/.gitignore

@@ -0,0 +1,6 @@
+*.bin
+*.dump
+*.elf
+sgemm_wg
+.depend
+kernel.radiance.elf

tests/regression/rickroll/Makefile

@@ -0,0 +1,9 @@
+PROJECT = rickroll
+
+SRCS = main.cpp common.h
+
+VX_SRCS = kernel.cpp
+
+OPTS ?= -n16
+
+include ../common.mk

tests/regression/rickroll/common.h

@@ -0,0 +1,18 @@
+#ifndef _COMMON_H_
+#define _COMMON_H_
+
+#include <cstdint>
+
+#define KERNEL_ARG_DEV_MEM_ADDR 0x7fff0000
+#define DEV_SMEM_START_ADDR 0xff000000
+
+typedef struct {
+  uint32_t dim_m;
+  uint32_t dim_n;
+  uint32_t dim_k;
+  uint64_t addr_a;
+  uint64_t addr_b;
+  uint64_t addr_c;
+} kernel_arg_t;
+
+#endif

tests/regression/rickroll/display_color.py

@@ -0,0 +1,128 @@
+import time
+import os
+import struct
+from PIL import Image
+from io import BytesIO
+import subprocess
+import numpy as np
+import base64
+import cv2
+
+use_fpga = False
+buffer_width = 16
+
+# buffer_depth = 0x152
+# frame_width = 240
+# frame_height = 180
+# upscale = 6
+buffer_depth = 1800
+frame_width = 160
+frame_height = 120
+upscale = 1
+
+
+buffer_size = int(buffer_depth * buffer_width * 1.5)
+truncate = 0 # 300 if use_fpga else 0
+
+def follow(filename):
+    frame_count = 0
+    with open(filename, "r") as file:
+        while True:
+            current_position = file.tell()
+            line = file.readline()
+            if not line:
+                time.sleep(0.001)
+                continue
+            if "fb0" in line and len(line) < (61 if use_fpga else 41):
+                file.seek(current_position)
+                time.sleep(0.001)
+                continue
+            if truncate and (" 0151 " in line):
+                frame_count += 1
+                if frame_count == truncate:
+                    with open(filename, "w") as f:
+                        f.truncate(0)
+                    frame_count = 0
+            yield line
+
+def process_frame(frame_data):
+    bits = np.unpackbits(np.frombuffer(frame_data, dtype=np.uint8))
+    bits = bits[:frame_width * frame_height]
+    image_array = bits.reshape((frame_height, frame_width))
+    # image_array = np.flipud(np.fliplr(image_array))
+    image_array = (image_array * 255).astype(np.uint8)
+
+    raw_array = np.frombuffer(frame_data, dtype=np.uint8)
+    y_size = frame_width * frame_height
+    c_size = y_size // 4
+    y_array = raw_array[:y_size].reshape((frame_height, frame_width))
+    cr_array, cb_array = raw_array[y_size : y_size + c_size].reshape((frame_height // 2, frame_width // 2)), raw_array[y_size + c_size : y_size + 2 * c_size].reshape((frame_height // 2, frame_width // 2))
+
+    cb_upscaled = cv2.resize(cb_array, (frame_width, frame_height), interpolation=cv2.INTER_LINEAR)
+    cr_upscaled = cv2.resize(cr_array, (frame_width, frame_height), interpolation=cv2.INTER_LINEAR)
+    
+    # Merge the channels back to YCrCb format
+    ycrcb_frame = cv2.merge((y_array, cb_upscaled, cr_upscaled))
+    bgr_frame = cv2.cvtColor(ycrcb_frame, cv2.COLOR_YCrCb2BGR)
+    is_success, buffer = cv2.imencode(".png", bgr_frame)
+    io_buf = BytesIO(buffer)
+
+    # filtered_image_array = image_array
+
+    # filtered_image_array = cv2.fastNlMeansDenoising(image_array, None, h=72, templateWindowSize=8, searchWindowSize=8)
+    # filtered_image_array = cv2.GaussianBlur(image_array, (3, 3), 0)
+
+    # filtered_image_array = cv2.blur(image_array, (2, 2))
+    # filtered_image_array = cv2.fastNlMeansDenoising(filtered_image_array, None, h=72, templateWindowSize=4, searchWindowSize=4)
+
+    # filtered_image_array = np.kron(filtered_image_array, np.ones((upscale, upscale), dtype=np.uint8))
+
+    # image = Image.fromarray(filtered_image_array, mode='L')
+
+    return io_buf
+
+def display_image(img):
+    # img = img.resize((frame_width * upscale, frame_height * upscale), Image.NEAREST)
+    # img.save(output, format='PNG')
+    output = img
+    
+    output.seek(0)
+    # subprocess.run(["/home/eecs/yrh/.iterm2/imgcat"], input=output.read())
+    image_data = output.getvalue()
+    b64_image_data = base64.b64encode(image_data).decode('utf-8')
+
+    print("\033]", end='')
+    print(f"1337;File=inline=1", end='')
+    print(f";size={len(image_data)}", end='')
+    print(f";name={base64.b64encode('tmp.png'.encode()).decode('utf-8')}", end='')
+    # print(f";width={frame_width * upscale * 4};height={frame_height * upscale * 4}", end='')
+    print(f":{b64_image_data}", end='')
+    print("\a", end='')
+    print('\n')
+
+def main():
+    if not use_fpga:
+        filename = "/scratch/yrh/chipyard/sims/vcs/output/chipyard.harness.TestHarness.RadianceClusterConfig/kernel.radiance.out"
+    else:
+        filename = "/scratch/yrh/firesim-rundir/sim_slot_0/synthesized-prints.out0"
+    # frame_data = {}
+    frame_data0 = bytearray(buffer_size)
+    for line in follow(filename):
+        if not "fb0" in line:
+            continue
+        tokens = line.split()
+        if not len(tokens) == (5 if use_fpga else 3):
+            continue
+        offset, data = tokens[3 if use_fpga else 1:]
+        offset0 = int(offset, 16)
+
+        frame_data0[offset0 * buffer_width : (offset0 + 1) * buffer_width] = bytes.fromhex(data)[::-1]
+
+        if offset0 == buffer_depth - 1:
+            img = process_frame(frame_data0)
+            display_image(img)
+            frame_data0 = bytearray(buffer_size)
+
+if __name__ == "__main__":
+    main()
+

tests/regression/rickroll/kernel.cpp

@@ -0,0 +1,92 @@
+#include <stdint.h>
+#include <vx_intrinsics.h>
+#include <vx_print.h>
+#include <vx_spawn.h>
+#include "common.h"
+
+#define rd_cycles(x) asm volatile ("csrr %0, mcycle" : "=r" (x))
+#define HW_TID() ({uint32_t gtid; asm volatile ("csrr %0, mhartid" : "=r" (gtid)); gtid;})
+#define PRINTF(...) sprintf((char *) (0xff010000UL), __VA_ARGS__)
+
+inline void threadblock_barrier(unsigned int barrier_id, unsigned int count) {
+  vx_fence();
+  vx_barrier(barrier_id, count);
+}
+
+void kernel_body(int task_id, kernel_arg_t *__UNIFORM__ arg) {
+  vx_tmc(0xff);
+  const volatile uint32_t *const A = (const volatile uint32_t *const) arg->addr_a;
+
+  #define WORKERS 128
+
+  // #define WORDS 1350
+  // #define LINES 338
+  // #define ITERS 11 // = 1350 / 128
+
+  #define WORDS 7200
+  #define LINES 1800
+  #define T_ITERS 57
+
+  #define mark_fb0() \
+    vx_tmc(0x80); if (task_id == 127) *(((volatile uint32_t *) 0xff011000UL)) = LINES; \
+    vx_fence(); vx_barrier(0, 8); vx_tmc(0xff)
+  #define mark_fb1() \
+    vx_tmc(0x80); if (task_id == 127) *(((volatile uint32_t *) 0xff011004UL)) = LINES; \
+    vx_fence(); vx_barrier(1, 8); vx_tmc(0xff)
+  #define write_fb0(addr, value) *(((volatile uint32_t *) 0xff018000UL) + addr) = (value)
+  #define write_fb1(addr, value) *(((volatile uint32_t *) 0xff020000UL) + addr) = (value)
+
+  #define CYCLES_TO_WAIT 240000
+
+  uint64_t cycles0, cycles1;
+  cycles0 = 0;
+
+  while (true) {
+    volatile uint32_t v0, v1;
+    for (int i = 0; i < 5301; i += 1) {
+      v0 = A[i * WORDS + task_id];
+      v1 = A[i * WORDS + WORKERS + task_id];
+      int offset0 = 0 * WORKERS + task_id;
+      int offset1 = 1 * WORKERS + task_id;
+
+      for (int j = 1; j < T_ITERS; j += 2) {
+        write_fb0(offset0, v0);
+        offset0 += 2 * WORKERS;
+        v0 = A[(i + 0) * WORDS + offset0];
+        write_fb0(offset1, v1);
+        offset1 += 2 * WORKERS;
+        v1 = A[(i + 0) * WORDS + offset1];
+      }
+      write_fb0(offset0, v0);
+      write_fb0(offset1, v1);
+
+      /*offset0 += 2 * WORKERS;
+      v0 = A[(i + 0) * WORDS + offset0];
+      write_fb0(offset0, v0);*/
+
+      if (task_id == 0) {
+        rd_cycles(cycles1);
+        while (cycles1 - cycles0 < CYCLES_TO_WAIT) {
+          rd_cycles(cycles1);
+        }
+        cycles0 = cycles1;
+      }
+
+      threadblock_barrier(0, 8);
+      mark_fb0();
+    }
+  }
+}
+
+int main() {
+  kernel_arg_t *arg = (kernel_arg_t *)KERNEL_ARG_DEV_MEM_ADDR;
+
+#ifdef RADIANCE
+  vx_spawn_tasks_cluster(128, (vx_spawn_tasks_cb)kernel_body, arg);
+#else
+  // NOTE: This kernel assumes contiguous thread scheduling for efficient shared
+  // memory allocation, and therefore does not work with original vx_spawn_tasks
+  vx_spawn_tasks_contiguous(8, (vx_spawn_tasks_cb)kernel_body, arg);
+#endif
+  return 0;
+}

tests/regression/rickroll/main.cpp

@@ -0,0 +1,274 @@
+#include <iostream>
+#include <fstream>
+#include <unistd.h>
+#include <string.h>
+#include <vortex.h>
+#include <vector>
+#include "common.h"
+
+#define RT_CHECK(_expr)                                         \
+   do {                                                         \
+     int _ret = _expr;                                          \
+     if (0 == _ret)                                             \
+       break;                                                   \
+     printf("Error: '%s' returned %d!\n", #_expr, (int)_ret);   \
+     cleanup();                                                       \
+     exit(-1);                                                  \
+   } while (false)
+
+///////////////////////////////////////////////////////////////////////////////
+
+const char* kernel_file = "kernel.bin";
+uint32_t count = 0;
+
+std::vector<float> src_a_data;
+std::vector<float> src_b_data;
+std::vector<float> ref_data;
+
+vx_device_h device = nullptr;
+std::vector<uint8_t> staging_buf;
+kernel_arg_t kernel_arg = {};
+
+static void show_usage() {
+   std::cout << "Vortex Test." << std::endl;
+   std::cout << "Usage: [-k: kernel] [-n words] [-h: help]" << std::endl;
+}
+
+static void parse_args(int argc, char **argv) {
+  int c;
+  while ((c = getopt(argc, argv, "n:k:h?")) != -1) {
+    switch (c) {
+    case 'n':
+      count = atoi(optarg);
+      break;
+    case 'k':
+      kernel_file = optarg;
+      break;
+    case 'h':
+    case '?': {
+      show_usage();
+      exit(0);
+    } break;
+    default:
+      show_usage();
+      exit(-1);
+    }
+  }
+}
+
+void cleanup() {
+  if (device) {
+    vx_mem_free(device, kernel_arg.addr_a);
+    vx_mem_free(device, kernel_arg.addr_b);
+    vx_mem_free(device, kernel_arg.addr_c);
+    vx_dev_close(device);
+  }
+}
+
+void generate_source_matrix(uint32_t dim_m, uint32_t dim_n, uint32_t dim_k) {
+  src_a_data.resize(dim_m * dim_k);
+  src_b_data.resize(dim_k * dim_n);
+
+  for (uint32_t i = 0; i < src_a_data.size(); ++i) {
+    src_a_data[i] = static_cast<float>(i);
+    std::cout << "A: " << i << ": value=" << src_a_data[i] << std::endl;
+  }
+  for (uint32_t i = 0; i < src_b_data.size(); ++i) {
+    src_b_data[i] = static_cast<float>(i);
+    std::cout << "B: " << i << ": value=" << src_b_data[i] << std::endl;
+  }
+}
+
+void generate_reference_matmul(uint32_t dim_m, uint32_t dim_n, uint32_t dim_k) {
+  ref_data.resize(dim_m * dim_n);
+
+  for (uint32_t i = 0; i < dim_m; ++i) {
+    for (uint32_t j = 0; j < dim_n; ++j) {
+      float ref = 0.0f;
+      for (uint32_t k = 0; k < dim_k; ++k) {
+        ref += src_a_data[dim_k * i + k] * src_b_data[dim_n * k + j];
+      }
+      ref_data.at(dim_n * i + j) = ref;
+    }
+  }
+}
+
+int run_test(const kernel_arg_t& kernel_arg,
+             uint32_t buf_size,
+             uint32_t dim_m, uint32_t dim_n) {
+  // start device
+  std::cout << "start device" << std::endl;
+  RT_CHECK(vx_start(device));
+
+  // wait for completion
+  std::cout << "wait for completion" << std::endl;
+  RT_CHECK(vx_ready_wait(device, VX_MAX_TIMEOUT));
+
+  // download destination buffer
+  std::cout << "download destination buffer" << std::endl;
+  RT_CHECK(vx_copy_from_dev(device, staging_buf.data(), kernel_arg.addr_c, buf_size));
+
+  // verify result
+  std::cout << "verify result" << std::endl;
+  {
+    int errors = 0;
+    auto buf_ptr = (float*)staging_buf.data();
+    for (uint32_t i = 0; i < dim_m * dim_n; ++i) {
+      float ref = ref_data.at(i);
+      float cur = buf_ptr[i];
+      if (std::abs((cur - ref) / ref) > 1e-6) {
+        std::cout << "error at result #" << std::dec << i
+                  << std::hex << ": actual=" << cur << ", expected=" << ref << std::endl;
+        ++errors;
+      }
+    }
+    if (errors != 0) {
+      std::cout << "Found " << std::dec << errors << " errors!" << std::endl;
+      std::cout << "FAILED!" << std::endl;
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+  // parse command arguments
+  parse_args(argc, argv);
+
+  if (count == 0) {
+    count = 1;
+  }
+
+  std::srand(50);
+
+  // open device connection
+  std::cout << "open device connection" << std::endl;
+  RT_CHECK(vx_dev_open(&device));
+
+  // FIXME: hardcoded
+  uint32_t dim_m = 64;
+  uint32_t dim_n = 64;
+  uint32_t dim_k = 64;
+
+  generate_source_matrix(dim_m, dim_n, dim_k);
+  generate_reference_matmul(dim_m, dim_n, dim_k);
+
+  uint32_t src_a_buf_size = src_a_data.size() * sizeof(src_a_data[0]);
+  uint32_t src_b_buf_size = src_b_data.size() * sizeof(src_b_data[0]);
+  uint32_t dst_buf_size = ref_data.size() * sizeof(src_a_data[0]);
+
+  std::cout << "buffer size: " << dst_buf_size << " bytes" << std::endl;
+
+  // upload program
+  std::cout << "upload program" << std::endl;
+  RT_CHECK(vx_upload_kernel_file(device, kernel_file));
+
+  // allocate device memory
+  std::cout << "allocate device memory" << std::endl;
+  RT_CHECK(vx_mem_alloc(device, src_a_buf_size, VX_MEM_TYPE_GLOBAL, &kernel_arg.addr_a));
+  RT_CHECK(vx_mem_alloc(device, src_b_buf_size, VX_MEM_TYPE_GLOBAL, &kernel_arg.addr_b));
+  RT_CHECK(vx_mem_alloc(device, dst_buf_size, VX_MEM_TYPE_GLOBAL, &kernel_arg.addr_c));
+
+  kernel_arg.dim_m = dim_m;
+  kernel_arg.dim_n = dim_n;
+  kernel_arg.dim_k = dim_k;
+
+  std::cout << "dev_addr_a=0x" << std::hex << kernel_arg.addr_a << std::endl;
+  std::cout << "dev_addr_b=0x" << std::hex << kernel_arg.addr_b << std::endl;
+  std::cout << "dev_addr_c=0x" << std::hex << kernel_arg.addr_c << std::endl;
+
+  // allocate staging buffer
+  {
+    std::cout << "allocate staging buffer" << std::endl;
+    uint32_t staging_buf_size = std::max<uint32_t>(
+        src_a_buf_size,
+        std::max<uint32_t>(
+            src_b_buf_size,
+            std::max<uint32_t>(dst_buf_size, sizeof(kernel_arg_t))));
+    staging_buf.resize(staging_buf_size);
+  }
+
+  // upload kernel argument
+  {
+    std::cout << "upload kernel argument" << std::endl;
+    auto buf_ptr = staging_buf.data();
+    kernel_arg.addr_a = (uint64_t) 0x20000;
+    kernel_arg.addr_b = (uint64_t) 0x28000;
+    kernel_arg.addr_c = (uint64_t) 0xc0000000ULL;
+    memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t));
+
+    std::cout << "uploading argument buffer to device, device mem address="
+              << std::hex << KERNEL_ARG_DEV_MEM_ADDR << ", size=" << std::dec
+              << sizeof(kernel_arg_t) << " bytes\n";
+    std::ofstream file("args.bin", std::ios::binary | std::ios::out);
+    if (!file) {
+        std::cerr << "error: failed to open args.bin for writing\n";
+        exit(EXIT_FAILURE);
+    }
+    file.write(reinterpret_cast<char *>(staging_buf.data()),
+               sizeof(kernel_arg_t));
+    file.close();
+
+    RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t)));
+  }
+
+  // upload source buffer
+  {
+    {
+        auto buf_ptr = staging_buf.data();
+        memcpy(buf_ptr, src_a_data.data(), src_a_data.size() * sizeof(float));
+        RT_CHECK(vx_copy_to_dev(device, kernel_arg.addr_a, staging_buf.data(),
+                                src_a_buf_size));
+
+        std::cout << "uploading source A matrix to device, device mem address="
+                  << std::hex << kernel_arg.addr_a << ", size=" << std::dec
+                  << src_a_buf_size << " bytes\n";
+        std::ofstream file("input.a.bin", std::ios::binary | std::ios::out);
+        if (!file) {
+        std::cerr << "error: failed to open args.bin for writing\n";
+        exit(EXIT_FAILURE);
+        }
+        file.write(reinterpret_cast<char *>(buf_ptr), src_a_buf_size);
+        file.close();
+    }
+    {
+        auto buf_ptr = staging_buf.data();
+        memcpy(buf_ptr, src_b_data.data(), src_b_data.size() * sizeof(float));
+        RT_CHECK(vx_copy_to_dev(device, kernel_arg.addr_b, staging_buf.data(),
+                                src_b_buf_size));
+
+        std::cout << "uploading source B matrix to device, device mem address="
+                  << std::hex << kernel_arg.addr_b << ", size=" << std::dec
+                  << src_b_buf_size << " bytes\n";
+        std::ofstream file("input.b.bin", std::ios::binary | std::ios::out);
+        if (!file) {
+        std::cerr << "error: failed to open args.bin for writing\n";
+        exit(EXIT_FAILURE);
+        }
+        file.write(reinterpret_cast<char *>(buf_ptr), src_b_buf_size);
+        file.close();
+    }
+  }
+
+  // clear destination buffer
+  {
+    std::cout << "clear destination buffer" << std::endl;
+    auto buf_ptr = (int32_t*)staging_buf.data();
+    for (uint32_t i = 0; i < ref_data.size(); ++i) {
+      buf_ptr[i] = 0xdeadbeef;
+    }
+    RT_CHECK(vx_copy_to_dev(device, kernel_arg.addr_c, staging_buf.data(), dst_buf_size));
+  }
+
+  // run tests
+  std::cout << "run tests" << std::endl;
+  RT_CHECK(run_test(kernel_arg, dst_buf_size, kernel_arg.dim_m, kernel_arg.dim_n));
+  std::cout << "PASSED!" << std::endl;
+
+  // cleanup
+  std::cout << "cleanup" << std::endl;
+  cleanup();
+
+  return 0;
+}