i kinda forgot most of changes
This commit is contained in:
joshua
@@ -90,7 +90,7 @@ int main()
|
||||
vx_wmma();
|
||||
store_wmma_result();
|
||||
vx_tmc(1);
|
||||
print_wmma_result();
|
||||
// print_wmma_result();
|
||||
|
||||
return 0;
|
||||
}
|
||||
9
tests/regression/sgemm_tcore/Makefile
Normal file
9
tests/regression/sgemm_tcore/Makefile
Normal file
@@ -0,0 +1,9 @@
|
||||
PROJECT = sgemm_tcore
|
||||
|
||||
SRCS = main.cpp common.h
|
||||
|
||||
VX_SRCS = kernel.cpp
|
||||
|
||||
OPTS ?= -n16
|
||||
|
||||
include ../common.mk
|
||||
18
tests/regression/sgemm_tcore/common.h
Normal file
18
tests/regression/sgemm_tcore/common.h
Normal file
@@ -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
|
||||
285
tests/regression/sgemm_tcore/kernel.cpp
Normal file
285
tests/regression/sgemm_tcore/kernel.cpp
Normal file
@@ -0,0 +1,285 @@
|
||||
#define RISCV_CUSTOM3 0x7B
|
||||
|
||||
#include <stdint.h>
|
||||
#include <vx_intrinsics.h>
|
||||
#include <vx_print.h>
|
||||
#include <vx_spawn.h>
|
||||
#include "common.h"
|
||||
|
||||
#define BM 16
|
||||
#define BN 16
|
||||
#define BK 8
|
||||
|
||||
inline void vx_wmma() {
|
||||
asm volatile (".insn r %0, 0, 0, x0, x0, x0" :: "i"(RISCV_CUSTOM3));
|
||||
}
|
||||
|
||||
void vx_wmma_load(volatile float *smem_A, volatile float *smem_B, int warp_x, int warp_y, int thread_in_warp) {
|
||||
int tid = thread_in_warp;
|
||||
int tg = tid / 4;
|
||||
|
||||
// load A
|
||||
int row = tid % 4;
|
||||
row += (tg * 8) % 16;
|
||||
row += (tg / 4) * 4;
|
||||
|
||||
int smem_A_m = 32;
|
||||
int smem_A_n = 8;
|
||||
int smem_B_m = 8;
|
||||
int smem_B_n = 32;
|
||||
|
||||
int A_offset = (row + BM * warp_y) * smem_A_n;
|
||||
|
||||
asm volatile ("flw f0, %0" :: "m"(smem_A[A_offset + 0]));
|
||||
asm volatile ("flw f1, %0" :: "m"(smem_A[A_offset + 1]));
|
||||
asm volatile ("flw f2, %0" :: "m"(smem_A[A_offset + 2]));
|
||||
asm volatile ("flw f3, %0" :: "m"(smem_A[A_offset + 3]));
|
||||
asm volatile ("flw f4, %0" :: "m"(smem_A[A_offset + 4]));
|
||||
asm volatile ("flw f5, %0" :: "m"(smem_A[A_offset + 5]));
|
||||
asm volatile ("flw f6, %0" :: "m"(smem_A[A_offset + 6]));
|
||||
asm volatile ("flw f7, %0" :: "m"(smem_A[A_offset + 7]));
|
||||
|
||||
// load B
|
||||
int col = tid % 4;
|
||||
col += ((tg % 4) / 2) * 8;
|
||||
col += (tg / 4) * 4;
|
||||
|
||||
asm volatile ("flw f8 , %0" :: "m"(smem_B[(0 * smem_B_n) + warp_x * BN + col]));
|
||||
asm volatile ("flw f9 , %0" :: "m"(smem_B[(1 * smem_B_n) + warp_x * BN + col]));
|
||||
asm volatile ("flw f10, %0" :: "m"(smem_B[(2 * smem_B_n) + warp_x * BN + col]));
|
||||
asm volatile ("flw f11, %0" :: "m"(smem_B[(3 * smem_B_n) + warp_x * BN + col]));
|
||||
asm volatile ("flw f12, %0" :: "m"(smem_B[(4 * smem_B_n) + warp_x * BN + col]));
|
||||
asm volatile ("flw f13, %0" :: "m"(smem_B[(5 * smem_B_n) + warp_x * BN + col]));
|
||||
asm volatile ("flw f14, %0" :: "m"(smem_B[(6 * smem_B_n) + warp_x * BN + col]));
|
||||
asm volatile ("flw f15, %0" :: "m"(smem_B[(7 * smem_B_n) + warp_x * BN + col]));
|
||||
}
|
||||
|
||||
inline void initialize_C() {
|
||||
// initialize C to zeros
|
||||
asm volatile ("fmv.w.x f16, x0");
|
||||
asm volatile ("fmv.w.x f17, x0");
|
||||
asm volatile ("fmv.w.x f18, x0");
|
||||
asm volatile ("fmv.w.x f19, x0");
|
||||
asm volatile ("fmv.w.x f20, x0");
|
||||
asm volatile ("fmv.w.x f21, x0");
|
||||
asm volatile ("fmv.w.x f22, x0");
|
||||
asm volatile ("fmv.w.x f23, x0");
|
||||
}
|
||||
|
||||
inline void write_results(
|
||||
volatile float *local_warp_results,
|
||||
int thread_in_warp,
|
||||
int warp_x,
|
||||
int warp_y,
|
||||
int dim_m,
|
||||
int dim_n,
|
||||
float *C,
|
||||
int threadblock_id_x,
|
||||
int threadblock_id_y
|
||||
) {
|
||||
int tid = thread_in_warp;
|
||||
int tg = tid / 4;
|
||||
|
||||
asm volatile ("fsw f16, %0" :: "m"(local_warp_results[tid*8+0]));
|
||||
asm volatile ("fsw f17, %0" :: "m"(local_warp_results[tid*8+1]));
|
||||
asm volatile ("fsw f18, %0" :: "m"(local_warp_results[tid*8+2]));
|
||||
asm volatile ("fsw f19, %0" :: "m"(local_warp_results[tid*8+3]));
|
||||
asm volatile ("fsw f20, %0" :: "m"(local_warp_results[tid*8+4]));
|
||||
asm volatile ("fsw f21, %0" :: "m"(local_warp_results[tid*8+5]));
|
||||
asm volatile ("fsw f22, %0" :: "m"(local_warp_results[tid*8+6]));
|
||||
asm volatile ("fsw f23, %0" :: "m"(local_warp_results[tid*8+7]));
|
||||
|
||||
/*
|
||||
col = ((threadgroup % 4) // 2) * 8
|
||||
row = (threadgroup * 8) % 16
|
||||
row += (threadgroup // 4) * 4
|
||||
offsets = [(0, 0), (0, 1), (2, 0), (2, 1), (0, 4), (0, 5), (2, 4), (2, 5)]
|
||||
offset = offsets[register-16]
|
||||
row += offset[0]
|
||||
col += offset[1]
|
||||
thread_offsets = [(0, 0), (1, 0), (0, 2), (1, 2)]
|
||||
thread_offset = thread_offsets[thread % 4]
|
||||
row += thread_offset[0]
|
||||
col += thread_offset[1]
|
||||
return (row, col)
|
||||
*/
|
||||
|
||||
int local_col = ((tg % 4) / 2) * 8;
|
||||
int local_row = (tg * 8) % 16;
|
||||
local_row += (tg / 4) * 4;
|
||||
|
||||
// int row_offsets[8] = {0, 0, 2, 2, 0, 0, 2, 2};
|
||||
// int col_offsets[8] = {0, 1, 0, 1, 4, 5, 4, 5};
|
||||
|
||||
// int thread_row_offsets[4] = {0, 1, 0, 1};
|
||||
// int thread_col_offsets[4] = {0, 0, 2, 2};
|
||||
int thread_row_offset = (tid % 4) % 2;
|
||||
int thread_col_offset = ((tid % 4) / 2) * 2;
|
||||
|
||||
float *global_offset_C = C + (threadblock_id_y * BM * 2 + warp_y * BM) * dim_n + threadblock_id_x * BN * 2 + warp_x * BM;
|
||||
for (int i = 0; i < 8; i += 1) {
|
||||
int row_offset = ((i / 2) % 2) * 2;
|
||||
int col_offset = (i / 4) * 4 + i % 2;
|
||||
|
||||
int adjusted_local_row = local_row + thread_row_offset + row_offset;
|
||||
int adjusted_local_col = local_col + thread_col_offset + col_offset;
|
||||
|
||||
float v = local_warp_results[tid*8+i];
|
||||
global_offset_C[adjusted_local_row * dim_n + adjusted_local_col] = v;
|
||||
}
|
||||
}
|
||||
|
||||
void threadblock_barrier(unsigned int tid_in_threadblock, unsigned int barrier_id, unsigned int count) {
|
||||
vx_fence();
|
||||
vx_barrier(barrier_id, count);
|
||||
}
|
||||
|
||||
void thread_block_gemm(kernel_arg_t *__UNIFORM__ arg,
|
||||
const uint32_t tid_in_threadblock,
|
||||
const uint32_t threadblock_dim_x,
|
||||
const uint32_t threadblock_dim_y,
|
||||
const uint32_t threadblock_id_x,
|
||||
const uint32_t threadblock_id_y,
|
||||
const uint32_t threadblock_id,
|
||||
float *sharedmem_per_threadblock) {
|
||||
const float *A = (const float *)arg->addr_a;
|
||||
const float *B = (const float *)arg->addr_b;
|
||||
float *C = (float *)arg->addr_c;
|
||||
|
||||
const uint32_t dim_m = arg->dim_m;
|
||||
const uint32_t dim_n = arg->dim_n;
|
||||
const uint32_t dim_k = arg->dim_k;
|
||||
|
||||
// FIXME: Output block size is assumed to be square, i.e. BM == BN
|
||||
// const uint32_t BM = threadblock_dim_y;
|
||||
// const uint32_t BN = threadblock_dim_y;
|
||||
// const uint32_t BK = threadblock_dim_x;
|
||||
// constexpr uint32_t BM = 8;
|
||||
// constexpr uint32_t BN = 8;
|
||||
// constexpr uint32_t BK = 2;
|
||||
|
||||
const uint32_t warp_in_threadblock = tid_in_threadblock / 32;
|
||||
const uint32_t tid_in_warp = tid_in_threadblock % 32;
|
||||
const uint32_t warp_x = warp_in_threadblock % 2;
|
||||
const uint32_t warp_y = warp_in_threadblock / 2;
|
||||
|
||||
const uint32_t global_a_row = threadblock_dim_y * threadblock_id_y;
|
||||
|
||||
// 32 * 8 block of A, being loaded by 4 warps
|
||||
const uint32_t local_a_row = warp_y * BM + warp_x * (BM / 2) + (tid_in_warp / BK);
|
||||
const uint32_t local_a_col = tid_in_warp % BK;
|
||||
|
||||
// 8 * 32 block of B, being loaded by 4 warps
|
||||
// do a fat coalesced load
|
||||
const uint32_t global_b_col = threadblock_dim_x * threadblock_id_x;
|
||||
const uint32_t local_b_row = warp_in_threadblock;
|
||||
const uint32_t local_b_col = tid_in_warp;
|
||||
|
||||
|
||||
volatile float *local_a = sharedmem_per_threadblock;
|
||||
const size_t local_a_elems = (threadblock_dim_y * BK);
|
||||
volatile float *local_b = sharedmem_per_threadblock + local_a_elems;
|
||||
const size_t local_b_elems = (threadblock_dim_x * BK);
|
||||
volatile float *local_warp_results = local_b + local_b_elems + (warp_in_threadblock * BM * BN);
|
||||
|
||||
// clear out C
|
||||
initialize_C();
|
||||
|
||||
for (uint32_t k = 0; k < dim_k; k += BK) {
|
||||
// Data move from GMEM to SMEM
|
||||
//
|
||||
// Make sure global offset values for A and B are contiguous between
|
||||
// neighboring threads to ensure GMEM coalescing. (not possible for A here, but for B it's doable)
|
||||
|
||||
// coalesced load from global memory -> unit-stride store into shared memory
|
||||
uint32_t global_a_offset =
|
||||
dim_k * (global_a_row + local_a_row) + (k + local_a_col);
|
||||
uint32_t shared_a_offset =
|
||||
BK * local_a_row + local_a_col;
|
||||
|
||||
local_a[shared_a_offset] = A[global_a_offset];
|
||||
|
||||
global_a_offset += dim_k * (BM / 4);
|
||||
shared_a_offset += BK * (BM / 4);
|
||||
|
||||
local_a[shared_a_offset] = A[global_a_offset];
|
||||
|
||||
uint32_t global_b_offset =
|
||||
dim_n * (k + local_b_row) + (global_b_col + local_b_col);
|
||||
uint32_t shared_b_offset =
|
||||
(BN * 2) * (local_b_row) + local_b_col;
|
||||
|
||||
local_b[shared_b_offset] = B[global_b_offset];
|
||||
|
||||
global_b_offset += dim_n * (BK / 2);
|
||||
shared_b_offset += (BN * 2) * (BK / 2);
|
||||
|
||||
local_b[shared_b_offset] = B[global_b_offset];
|
||||
|
||||
// want all 4 warps to reach barrier before moving on (just use barrier 0 for now)
|
||||
threadblock_barrier(tid_in_threadblock, 0, 4);
|
||||
|
||||
// perform wmma
|
||||
vx_wmma_load(local_a, local_b, warp_x, warp_y, tid_in_warp);
|
||||
vx_wmma();
|
||||
|
||||
// same as above
|
||||
threadblock_barrier(tid_in_threadblock, 0, 4);
|
||||
}
|
||||
|
||||
write_results(
|
||||
local_warp_results,
|
||||
tid_in_warp,
|
||||
warp_x,
|
||||
warp_y,
|
||||
dim_m,
|
||||
dim_n,
|
||||
C,
|
||||
threadblock_id_x,
|
||||
threadblock_id_y
|
||||
);
|
||||
}
|
||||
|
||||
void kernel_body(int task_id, kernel_arg_t *__UNIFORM__ arg) {
|
||||
// @perf: All threads are running these compute whose result is mostly same
|
||||
// across the threadblock
|
||||
const int NT = 32; // vx_num_threads();
|
||||
const int NW = 4; // vx_num_warps();
|
||||
const uint32_t threads_per_threadblock = NT * NW;
|
||||
|
||||
// matches 4 warp capacity
|
||||
const uint32_t threadblock_dim_x = 2 * BN;
|
||||
const uint32_t threadblock_dim_y = 2 * BM;
|
||||
const int threadblock_id = task_id / threads_per_threadblock;
|
||||
const int tid_in_threadblock = task_id % threads_per_threadblock;
|
||||
|
||||
const uint32_t dim_m = arg->dim_m;
|
||||
const uint32_t dim_n = arg->dim_n;
|
||||
const uint32_t dim_n_in_blocks = dim_n / threadblock_dim_x;
|
||||
const int threadblock_id_x = threadblock_id % dim_n_in_blocks;
|
||||
const int threadblock_id_y = threadblock_id / dim_n_in_blocks;
|
||||
|
||||
// "static" shared memory allocation. This would determine threadblock
|
||||
// occupancy of a single cluster
|
||||
// only 1 threadblock running at a time, so this is ok
|
||||
float *sharedmem_per_threadblock =
|
||||
(float *)DEV_SMEM_START_ADDR; // + (2 * BM * BK) + (2 * BN * BK) * threadblock_id;
|
||||
|
||||
thread_block_gemm(arg, tid_in_threadblock, threadblock_dim_x,
|
||||
threadblock_dim_y, threadblock_id_x, threadblock_id_y,
|
||||
threadblock_id, sharedmem_per_threadblock);
|
||||
}
|
||||
|
||||
int main() {
|
||||
kernel_arg_t *arg = (kernel_arg_t *)KERNEL_ARG_DEV_MEM_ADDR;
|
||||
int NT = vx_num_threads();
|
||||
|
||||
// TODO: add support for edge-case (m, n not divisible by 16)
|
||||
const uint32_t grid_size = arg->dim_m * arg->dim_n * NT / (BM * BN);
|
||||
|
||||
// for now, simplifying assumption of just 1 core
|
||||
// vx_spawn_tasks_contiguous first runs warps 1 through NW, then NW+1 through 2*NW, etc.
|
||||
// we can thus treat 1 through NW as a single threadblock for the purposes of the optimization.
|
||||
vx_spawn_tasks_contiguous(grid_size, (vx_spawn_tasks_cb)kernel_body, arg);
|
||||
return 0;
|
||||
}
|
||||
270
tests/regression/sgemm_tcore/main.cpp
Normal file
270
tests/regression/sgemm_tcore/main.cpp
Normal file
@@ -0,0 +1,270 @@
|
||||
#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();
|
||||
memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t));
|
||||
RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), 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();
|
||||
}
|
||||
|
||||
// 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;
|
||||
}
|
||||
Reference in New Issue
Block a user