mirror of
https://github.com/vortexgpgpu/vortex.git
synced 2025-04-23 21:39:10 -04:00
merge fix
This commit is contained in:
Blaise Tine
parent
267521a1cb
commit
7887e6b432
4 changed files with 29 additions and 1359 deletions
|
|
@ -514,318 +514,18 @@ private:
|
|||
return 0;
|
||||
}
|
||||
|
||||
opae_drv_api_t api_;
|
||||
fpga_handle fpga_;
|
||||
MemoryAllocator global_mem_;
|
||||
DeviceConfig dcrs_;
|
||||
uint64_t dev_caps_;
|
||||
uint64_t isa_caps_;
|
||||
uint64_t global_mem_size_;
|
||||
uint64_t staging_wsid_;
|
||||
uint64_t staging_ioaddr_;
|
||||
uint8_t* staging_ptr_;
|
||||
uint64_t staging_size_;
|
||||
std::unordered_map<uint32_t, std::array<uint64_t, 32>> mpm_cache_;
|
||||
int profiling_id_;
|
||||
opae_drv_api_t api_;
|
||||
fpga_handle fpga_;
|
||||
MemoryAllocator global_mem_;
|
||||
DeviceConfig dcrs_;
|
||||
uint64_t dev_caps_;
|
||||
uint64_t isa_caps_;
|
||||
uint64_t global_mem_size_;
|
||||
uint64_t staging_wsid_;
|
||||
uint64_t staging_ioaddr_;
|
||||
uint8_t *staging_ptr_;
|
||||
uint64_t staging_size_;
|
||||
std::unordered_map<uint32_t, std::array<uint64_t, 32>> mpm_cache_;
|
||||
};
|
||||
|
||||
struct vx_buffer {
|
||||
vx_device* device;
|
||||
uint64_t addr;
|
||||
uint64_t size;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
extern int vx_dev_open(vx_device_h* hdevice) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
opae_drv_api_t api;
|
||||
memset(&api, 0, sizeof(opae_drv_api_t));
|
||||
if (drv_init(&api) !=0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// allocate device object
|
||||
auto device = new vx_device(api);
|
||||
if (nullptr == device) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// initialize device
|
||||
CHECK_ERR(device->init(), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("DEV_OPEN: hdevice=%p\n", (void*)device);
|
||||
|
||||
*hdevice = device;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dev_close(vx_device_h hdevice) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("DEV_CLOSE: hdevice=%p\n", hdevice);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
#ifdef SCOPE
|
||||
vx_scope_stop(hdevice);
|
||||
#endif
|
||||
|
||||
delete device;
|
||||
|
||||
drv_close();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dev_caps(vx_device_h hdevice, uint32_t caps_id, uint64_t *value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
vx_device *device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _value;
|
||||
|
||||
CHECK_ERR(device->get_caps(caps_id, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("DEV_CAPS: hdevice=%p, caps_id=%d, value=%ld\n", hdevice, caps_id, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_alloc(vx_device_h hdevice, uint64_t size, int flags, vx_buffer_h* hbuffer) {
|
||||
if (nullptr == hdevice
|
||||
|| nullptr == hbuffer
|
||||
|| 0 == size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("MEM_ALLOC: size=%ld, flags=0x%d\n", size, flags);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t dev_addr;
|
||||
CHECK_ERR(device->mem_alloc(size, flags, &dev_addr), {
|
||||
return err;
|
||||
});
|
||||
|
||||
auto buffer = new vx_buffer{device, dev_addr, size};
|
||||
if (nullptr == buffer) {
|
||||
device->mem_free(dev_addr);
|
||||
return -1;
|
||||
}
|
||||
|
||||
DBGPRINT("MEM_ALLOC: hdevice=%p, size=%ld, flags=0x%d, hbuffer=%p\n", hdevice, size, flags, (void*)buffer);
|
||||
|
||||
*hbuffer = buffer;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_reserve(vx_device_h hdevice, uint64_t address, uint64_t size, int flags, vx_buffer_h* hbuffer) {
|
||||
if (nullptr == hdevice
|
||||
|| nullptr == hbuffer
|
||||
|| 0 == size)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
CHECK_ERR(device->mem_reserve(address, size, flags), {
|
||||
return err;
|
||||
});
|
||||
|
||||
auto buffer = new vx_buffer{device, address, size};
|
||||
if (nullptr == buffer) {
|
||||
device->mem_free(address);
|
||||
return -1;
|
||||
}
|
||||
|
||||
DBGPRINT("MEM_RESERVE: hdevice=%p, address=0x%lx, size=%ld, flags=0x%d, hbuffer=%p\n", hdevice, address, size, flags, (void*)buffer);
|
||||
|
||||
*hbuffer = buffer;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_free(vx_buffer_h hbuffer) {
|
||||
if (nullptr == hbuffer)
|
||||
return 0;
|
||||
|
||||
DBGPRINT("MEM_FREE: hbuffer=%p\n", hbuffer);
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
vx_mem_access(hbuffer, 0, buffer->size, 0);
|
||||
|
||||
int err = device->mem_free(buffer->addr);
|
||||
|
||||
delete buffer;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
extern int vx_mem_access(vx_buffer_h hbuffer, uint64_t offset, uint64_t size, int flags) {
|
||||
if (nullptr == hbuffer)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("MEM_ACCESS: hbuffer=%p, offset=%ld, size=%ld, flags=%d\n", hbuffer, offset, size, flags);
|
||||
|
||||
return device->mem_access(buffer->addr + offset, size, flags);
|
||||
}
|
||||
|
||||
extern int vx_mem_address(vx_buffer_h hbuffer, uint64_t* address) {
|
||||
if (nullptr == hbuffer)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
|
||||
DBGPRINT("MEM_ADDRESS: hbuffer=%p, address=0x%lx\n", hbuffer, buffer->addr);
|
||||
|
||||
*address = buffer->addr;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_info(vx_device_h hdevice, uint64_t* mem_free, uint64_t* mem_used) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _mem_free, _mem_used;
|
||||
|
||||
CHECK_ERR(device->mem_info(&_mem_free, &_mem_used), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("MEM_INFO: hdevice=%p, mem_free=%ld, mem_used=%ld\n", hdevice, _mem_free, _mem_used);
|
||||
|
||||
if (mem_free) {
|
||||
*mem_free = _mem_free;
|
||||
}
|
||||
|
||||
if (mem_used) {
|
||||
*mem_used = _mem_used;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_copy_to_dev(vx_buffer_h hbuffer, const void* host_ptr, uint64_t dst_offset, uint64_t size) {
|
||||
if (nullptr == hbuffer || nullptr == host_ptr)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((dst_offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("COPY_TO_DEV: hbuffer=%p, host_addr=%p, dst_offset=%ld, size=%ld\n", hbuffer, host_ptr, dst_offset, size);
|
||||
|
||||
return device->upload(buffer->addr + dst_offset, host_ptr, size);
|
||||
}
|
||||
|
||||
extern int vx_copy_from_dev(void* host_ptr, vx_buffer_h hbuffer, uint64_t src_offset, uint64_t size) {
|
||||
if (nullptr == hbuffer || nullptr == host_ptr)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((src_offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("COPY_FROM_DEV: hbuffer=%p, host_addr=%p, src_offset=%ld, size=%ld\n", hbuffer, host_ptr, src_offset, size);
|
||||
|
||||
return device->download(host_ptr, buffer->addr + src_offset, size);
|
||||
}
|
||||
|
||||
extern int vx_start(vx_device_h hdevice, vx_buffer_h hkernel, vx_buffer_h harguments) {
|
||||
if (nullptr == hdevice || nullptr == hkernel || nullptr == harguments)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("START: hdevice=%p, hkernel=%p, harguments=%p\n", hdevice, hkernel, harguments);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
auto kernel = ((vx_buffer*)hkernel);
|
||||
auto arguments = ((vx_buffer*)harguments);
|
||||
|
||||
return device->start(kernel->addr, arguments->addr);
|
||||
}
|
||||
|
||||
extern int vx_ready_wait(vx_device_h hdevice, uint64_t timeout) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("READY_WAIT: hdevice=%p, timeout=%ld\n", hdevice, timeout);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
return device->ready_wait(timeout);
|
||||
}
|
||||
|
||||
extern int vx_dcr_read(vx_device_h hdevice, uint32_t addr, uint32_t* value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = (vx_device*)hdevice;
|
||||
|
||||
uint32_t _value;
|
||||
|
||||
CHECK_ERR(device->dcr_read(addr, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("DCR_READ: hdevice=%p, addr=0x%x, value=0x%x\n", hdevice, addr, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dcr_write(vx_device_h hdevice, uint32_t addr, uint32_t value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("DCR_WRITE: hdevice=%p, addr=0x%x, value=0x%x\n", hdevice, addr, value);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
return device->dcr_write(addr, value);
|
||||
}
|
||||
|
||||
extern int vx_mpm_query(vx_device_h hdevice, uint32_t addr, uint32_t core_id, uint64_t* value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _value;
|
||||
|
||||
CHECK_ERR(device->mpm_query(addr, core_id, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("MPM_QUERY: hdevice=%p, addr=0x%x, core_id=%d, value=0x%lx\n", hdevice, addr, core_id, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
#include <callbacks.inc>
|
||||
|
|
@ -242,296 +242,12 @@ public:
|
|||
|
||||
private:
|
||||
|
||||
RAM ram_;
|
||||
Processor processor_;
|
||||
MemoryAllocator global_mem_;
|
||||
DeviceConfig dcrs_;
|
||||
std::future<void> future_;
|
||||
std::unordered_map<uint32_t, std::array<uint64_t, 32>> mpm_cache_;
|
||||
int profiling_id_;
|
||||
RAM ram_;
|
||||
Processor processor_;
|
||||
MemoryAllocator global_mem_;
|
||||
DeviceConfig dcrs_;
|
||||
std::future<void> future_;
|
||||
std::unordered_map<uint32_t, std::array<uint64_t, 32>> mpm_cache_;
|
||||
};
|
||||
|
||||
struct vx_buffer {
|
||||
vx_device* device;
|
||||
uint64_t addr;
|
||||
uint64_t size;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
extern int vx_dev_open(vx_device_h* hdevice) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = new vx_device();
|
||||
if (device == nullptr)
|
||||
return -1;
|
||||
|
||||
CHECK_ERR(device->init(), {
|
||||
delete device;
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("DEV_OPEN: hdevice=%p\n", (void*)device);
|
||||
|
||||
*hdevice = device;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dev_close(vx_device_h hdevice) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("DEV_CLOSE: hdevice=%p\n", hdevice);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
delete device;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dev_caps(vx_device_h hdevice, uint32_t caps_id, uint64_t *value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
vx_device *device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _value;
|
||||
|
||||
CHECK_ERR(device->get_caps(caps_id, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("DEV_CAPS: hdevice=%p, caps_id=%d, value=%ld\n", hdevice, caps_id, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_alloc(vx_device_h hdevice, uint64_t size, int flags, vx_buffer_h* hbuffer) {
|
||||
if (nullptr == hdevice
|
||||
|| nullptr == hbuffer
|
||||
|| 0 == size)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t dev_addr;
|
||||
CHECK_ERR(device->mem_alloc(size, flags, &dev_addr), {
|
||||
return err;
|
||||
});
|
||||
|
||||
auto buffer = new vx_buffer{device, dev_addr, size};
|
||||
if (nullptr == buffer) {
|
||||
device->mem_free(dev_addr);
|
||||
return -1;
|
||||
}
|
||||
|
||||
DBGPRINT("MEM_ALLOC: hdevice=%p, size=%ld, flags=0x%d, hbuffer=%p\n", hdevice, size, flags, (void*)buffer);
|
||||
|
||||
*hbuffer = buffer;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_reserve(vx_device_h hdevice, uint64_t address, uint64_t size, int flags, vx_buffer_h* hbuffer) {
|
||||
if (nullptr == hdevice
|
||||
|| nullptr == hbuffer
|
||||
|| 0 == size)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
CHECK_ERR(device->mem_reserve(address, size, flags), {
|
||||
return err;
|
||||
});
|
||||
|
||||
auto buffer = new vx_buffer{device, address, size};
|
||||
if (nullptr == buffer) {
|
||||
device->mem_free(address);
|
||||
return -1;
|
||||
}
|
||||
|
||||
DBGPRINT("MEM_RESERVE: hdevice=%p, address=0x%lx, size=%ld, flags=0x%d, hbuffer=%p\n", hdevice, address, size, flags, (void*)buffer);
|
||||
|
||||
*hbuffer = buffer;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_free(vx_buffer_h hbuffer) {
|
||||
if (nullptr == hbuffer)
|
||||
return 0;
|
||||
|
||||
DBGPRINT("MEM_FREE: hbuffer=%p\n", hbuffer);
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
vx_mem_access(hbuffer, 0, buffer->size, 0);
|
||||
|
||||
int err = device->mem_free(buffer->addr);
|
||||
|
||||
delete buffer;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
extern int vx_mem_access(vx_buffer_h hbuffer, uint64_t offset, uint64_t size, int flags) {
|
||||
if (nullptr == hbuffer)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("MEM_ACCESS: hbuffer=%p, offset=%ld, size=%ld, flags=%d\n", hbuffer, offset, size, flags);
|
||||
|
||||
return device->mem_access(buffer->addr + offset, size, flags);
|
||||
}
|
||||
|
||||
extern int vx_mem_address(vx_buffer_h hbuffer, uint64_t* address) {
|
||||
if (nullptr == hbuffer)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
|
||||
DBGPRINT("MEM_ADDRESS: hbuffer=%p, address=0x%lx\n", hbuffer, buffer->addr);
|
||||
|
||||
*address = buffer->addr;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_info(vx_device_h hdevice, uint64_t* mem_free, uint64_t* mem_used) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _mem_free, _mem_used;
|
||||
|
||||
CHECK_ERR(device->mem_info(&_mem_free, &_mem_used), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("MEM_INFO: hdevice=%p, mem_free=%ld, mem_used=%ld\n", hdevice, _mem_free, _mem_used);
|
||||
|
||||
if (mem_free) {
|
||||
*mem_free = _mem_free;
|
||||
}
|
||||
|
||||
if (mem_used) {
|
||||
*mem_used = _mem_used;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_copy_to_dev(vx_buffer_h hbuffer, const void* host_ptr, uint64_t dst_offset, uint64_t size) {
|
||||
if (nullptr == hbuffer || nullptr == host_ptr)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((dst_offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("COPY_TO_DEV: hbuffer=%p, host_addr=%p, dst_offset=%ld, size=%ld\n", hbuffer, host_ptr, dst_offset, size);
|
||||
|
||||
return device->upload(buffer->addr + dst_offset, host_ptr, size);
|
||||
}
|
||||
|
||||
extern int vx_copy_from_dev(void* host_ptr, vx_buffer_h hbuffer, uint64_t src_offset, uint64_t size) {
|
||||
if (nullptr == hbuffer || nullptr == host_ptr)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((src_offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("COPY_FROM_DEV: hbuffer=%p, host_addr=%p, src_offset=%ld, size=%ld\n", hbuffer, host_ptr, src_offset, size);
|
||||
|
||||
return device->download(host_ptr, buffer->addr + src_offset, size);
|
||||
}
|
||||
|
||||
extern int vx_start(vx_device_h hdevice, vx_buffer_h hkernel, vx_buffer_h harguments) {
|
||||
if (nullptr == hdevice || nullptr == hkernel || nullptr == harguments)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("START: hdevice=%p, hkernel=%p, harguments=%p\n", hdevice, hkernel, harguments);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
auto kernel = ((vx_buffer*)hkernel);
|
||||
auto arguments = ((vx_buffer*)harguments);
|
||||
|
||||
return device->start(kernel->addr, arguments->addr);
|
||||
}
|
||||
|
||||
extern int vx_ready_wait(vx_device_h hdevice, uint64_t timeout) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("READY_WAIT: hdevice=%p, timeout=%ld\n", hdevice, timeout);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
return device->ready_wait(timeout);
|
||||
}
|
||||
|
||||
extern int vx_dcr_read(vx_device_h hdevice, uint32_t addr, uint32_t* value) {
|
||||
if (nullptr == hdevice || NULL == value)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint32_t _value;
|
||||
|
||||
CHECK_ERR(device->dcr_read(addr, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("DCR_READ: hdevice=%p, addr=0x%x, value=0x%x\n", hdevice, addr, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dcr_write(vx_device_h hdevice, uint32_t addr, uint32_t value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("DCR_WRITE: hdevice=%p, addr=0x%x, value=0x%x\n", hdevice, addr, value);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
return device->dcr_write(addr, value);
|
||||
}
|
||||
|
||||
extern int vx_mpm_query(vx_device_h hdevice, uint32_t addr, uint32_t core_id, uint64_t* value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _value;
|
||||
|
||||
CHECK_ERR(device->mpm_query(addr, core_id, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("MPM_QUERY: hdevice=%p, addr=0x%x, core_id=%d, value=0x%lx\n", hdevice, addr, core_id, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
#include <callbacks.inc>
|
||||
|
|
@ -236,297 +236,13 @@ public:
|
|||
}
|
||||
|
||||
private:
|
||||
Arch arch_;
|
||||
RAM ram_;
|
||||
Processor processor_;
|
||||
MemoryAllocator global_mem_;
|
||||
DeviceConfig dcrs_;
|
||||
std::future<void> future_;
|
||||
std::unordered_map<uint32_t, std::array<uint64_t, 32>> mpm_cache_;
|
||||
int profiling_id_;
|
||||
Arch arch_;
|
||||
RAM ram_;
|
||||
Processor processor_;
|
||||
MemoryAllocator global_mem_;
|
||||
DeviceConfig dcrs_;
|
||||
std::future<void> future_;
|
||||
std::unordered_map<uint32_t, std::array<uint64_t, 32>> mpm_cache_;
|
||||
};
|
||||
|
||||
struct vx_buffer {
|
||||
vx_device* device;
|
||||
uint64_t addr;
|
||||
uint64_t size;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
extern int vx_dev_open(vx_device_h* hdevice) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = new vx_device();
|
||||
if (device == nullptr)
|
||||
return -1;
|
||||
|
||||
CHECK_ERR(device->init(), {
|
||||
delete device;
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("DEV_OPEN: hdevice=%p\n", (void*)device);
|
||||
|
||||
*hdevice = device;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dev_close(vx_device_h hdevice) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("DEV_CLOSE: hdevice=%p\n", hdevice);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
delete device;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dev_caps(vx_device_h hdevice, uint32_t caps_id, uint64_t *value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
vx_device *device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _value;
|
||||
|
||||
CHECK_ERR(device->get_caps(caps_id, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("DEV_CAPS: hdevice=%p, caps_id=%d, value=%ld\n", hdevice, caps_id, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_alloc(vx_device_h hdevice, uint64_t size, int flags, vx_buffer_h* hbuffer) {
|
||||
if (nullptr == hdevice
|
||||
|| nullptr == hbuffer
|
||||
|| 0 == size)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t dev_addr;
|
||||
CHECK_ERR(device->mem_alloc(size, flags, &dev_addr), {
|
||||
return err;
|
||||
});
|
||||
|
||||
auto buffer = new vx_buffer{device, dev_addr, size};
|
||||
if (nullptr == buffer) {
|
||||
device->mem_free(dev_addr);
|
||||
return -1;
|
||||
}
|
||||
|
||||
DBGPRINT("MEM_ALLOC: hdevice=%p, size=%ld, flags=0x%d, hbuffer=%p\n", hdevice, size, flags, (void*)buffer);
|
||||
|
||||
*hbuffer = buffer;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_reserve(vx_device_h hdevice, uint64_t address, uint64_t size, int flags, vx_buffer_h* hbuffer) {
|
||||
if (nullptr == hdevice
|
||||
|| nullptr == hbuffer
|
||||
|| 0 == size)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
CHECK_ERR(device->mem_reserve(address, size, flags), {
|
||||
return err;
|
||||
});
|
||||
|
||||
auto buffer = new vx_buffer{device, address, size};
|
||||
if (nullptr == buffer) {
|
||||
device->mem_free(address);
|
||||
return -1;
|
||||
}
|
||||
|
||||
DBGPRINT("MEM_RESERVE: hdevice=%p, address=0x%lx, size=%ld, flags=0x%d, hbuffer=%p\n", hdevice, address, size, flags, (void*)buffer);
|
||||
|
||||
*hbuffer = buffer;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_free(vx_buffer_h hbuffer) {
|
||||
if (nullptr == hbuffer)
|
||||
return 0;
|
||||
|
||||
DBGPRINT("MEM_FREE: hbuffer=%p\n", hbuffer);
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
vx_mem_access(hbuffer, 0, buffer->size, 0);
|
||||
|
||||
int err = device->mem_free(buffer->addr);
|
||||
|
||||
delete buffer;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
extern int vx_mem_access(vx_buffer_h hbuffer, uint64_t offset, uint64_t size, int flags) {
|
||||
if (nullptr == hbuffer)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("MEM_ACCESS: hbuffer=%p, offset=%ld, size=%ld, flags=%d\n", hbuffer, offset, size, flags);
|
||||
|
||||
return device->mem_access(buffer->addr + offset, size, flags);
|
||||
}
|
||||
|
||||
extern int vx_mem_address(vx_buffer_h hbuffer, uint64_t* address) {
|
||||
if (nullptr == hbuffer)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
|
||||
DBGPRINT("MEM_ADDRESS: hbuffer=%p, address=0x%lx\n", hbuffer, buffer->addr);
|
||||
|
||||
*address = buffer->addr;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_info(vx_device_h hdevice, uint64_t* mem_free, uint64_t* mem_used) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _mem_free, _mem_used;
|
||||
|
||||
CHECK_ERR(device->mem_info(&_mem_free, &_mem_used), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("MEM_INFO: hdevice=%p, mem_free=%ld, mem_used=%ld\n", hdevice, _mem_free, _mem_used);
|
||||
|
||||
if (mem_free) {
|
||||
*mem_free = _mem_free;
|
||||
}
|
||||
|
||||
if (mem_used) {
|
||||
*mem_used = _mem_used;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_copy_to_dev(vx_buffer_h hbuffer, const void* host_ptr, uint64_t dst_offset, uint64_t size) {
|
||||
if (nullptr == hbuffer || nullptr == host_ptr)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((dst_offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("COPY_TO_DEV: hbuffer=%p, host_addr=%p, dst_offset=%ld, size=%ld\n", hbuffer, host_ptr, dst_offset, size);
|
||||
|
||||
return device->upload(buffer->addr + dst_offset, host_ptr, size);
|
||||
}
|
||||
|
||||
extern int vx_copy_from_dev(void* host_ptr, vx_buffer_h hbuffer, uint64_t src_offset, uint64_t size) {
|
||||
if (nullptr == hbuffer || nullptr == host_ptr)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((src_offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("COPY_FROM_DEV: hbuffer=%p, host_addr=%p, src_offset=%ld, size=%ld\n", hbuffer, host_ptr, src_offset, size);
|
||||
|
||||
return device->download(host_ptr, buffer->addr + src_offset, size);
|
||||
}
|
||||
|
||||
extern int vx_start(vx_device_h hdevice, vx_buffer_h hkernel, vx_buffer_h harguments) {
|
||||
if (nullptr == hdevice || nullptr == hkernel || nullptr == harguments)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("START: hdevice=%p, hkernel=%p, harguments=%p\n", hdevice, hkernel, harguments);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
auto kernel = ((vx_buffer*)hkernel);
|
||||
auto arguments = ((vx_buffer*)harguments);
|
||||
|
||||
return device->start(kernel->addr, arguments->addr);
|
||||
}
|
||||
|
||||
extern int vx_ready_wait(vx_device_h hdevice, uint64_t timeout) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("READY_WAIT: hdevice=%p, timeout=%ld\n", hdevice, timeout);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
return device->ready_wait(timeout);
|
||||
}
|
||||
|
||||
extern int vx_dcr_read(vx_device_h hdevice, uint32_t addr, uint32_t* value) {
|
||||
if (nullptr == hdevice || NULL == value)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint32_t _value;
|
||||
|
||||
CHECK_ERR(device->dcr_read(addr, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("DCR_READ: hdevice=%p, addr=0x%x, value=0x%x\n", hdevice, addr, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dcr_write(vx_device_h hdevice, uint32_t addr, uint32_t value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("DCR_WRITE: hdevice=%p, addr=0x%x, value=0x%x\n", hdevice, addr, value);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
return device->dcr_write(addr, value);
|
||||
}
|
||||
|
||||
extern int vx_mpm_query(vx_device_h hdevice, uint32_t addr, uint32_t core_id, uint64_t* value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _value;
|
||||
|
||||
CHECK_ERR(device->mpm_query(addr, core_id, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("MPM_QUERY: hdevice=%p, addr=0x%x, core_id=%d, value=0x%lx\n", hdevice, addr, core_id, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
#include <callbacks.inc>
|
||||
|
|
@ -811,466 +811,4 @@ private:
|
|||
#endif
|
||||
};
|
||||
|
||||
struct vx_buffer {
|
||||
vx_device* device;
|
||||
uint64_t addr;
|
||||
uint64_t size;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
extern int vx_dev_open(vx_device_h* hdevice) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
int device_index = DEFAULT_DEVICE_INDEX;
|
||||
const char* device_index_s = getenv("XRT_DEVICE_INDEX");
|
||||
if (device_index_s != nullptr) {
|
||||
device_index = atoi(device_index_s);
|
||||
}
|
||||
|
||||
const char* xlbin_path_s = getenv("XRT_XCLBIN_PATH");
|
||||
if (xlbin_path_s == nullptr) {
|
||||
xlbin_path_s = DEFAULT_XCLBIN_PATH;
|
||||
}
|
||||
|
||||
#ifdef CPP_API
|
||||
|
||||
auto xrtDevice = xrt::device(device_index);
|
||||
auto uuid = xrtDevice.load_xclbin(xlbin_path_s);
|
||||
auto xrtKernel = xrt::ip(xrtDevice, uuid, KERNEL_NAME);
|
||||
auto xclbin = xrt::xclbin(xlbin_path_s);
|
||||
|
||||
auto device_name = xrtDevice.get_info<xrt::info::device::name>();
|
||||
|
||||
/*{
|
||||
uint32_t num_banks = 0;
|
||||
uint64_t bank_size = 0;
|
||||
uint64_t mem_base = 0;
|
||||
|
||||
auto mem_json = nlohmann::json::parse(xrtDevice.get_info<xrt::info::device::memory>());
|
||||
if (!mem_json.is_null()) {
|
||||
uint32_t index = 0;
|
||||
for (auto& mem : mem_json["board"]["memory"]["memories"]) {
|
||||
auto enabled = mem["enabled"].get<std::string>();
|
||||
if (enabled == "true") {
|
||||
if (index == 0) {
|
||||
mem_base = std::stoull(mem["base_address"].get<std::string>(), nullptr, 16);
|
||||
bank_size = std::stoull(mem["range_bytes"].get<std::string>(), nullptr, 16);
|
||||
}
|
||||
++index;
|
||||
}
|
||||
}
|
||||
num_banks = index;
|
||||
}
|
||||
|
||||
fprintf(stderr, "[VXDRV] memory description: base=0x%lx, size=0x%lx, count=%d\n", mem_base, bank_size, num_banks);
|
||||
}*/
|
||||
|
||||
/*{
|
||||
std::cout << "Device" << device_index << " : " << xrtDevice.get_info<xrt::info::device::name>() << std::endl;
|
||||
std::cout << " bdf : " << xrtDevice.get_info<xrt::info::device::bdf>() << std::endl;
|
||||
std::cout << " kdma : " << xrtDevice.get_info<xrt::info::device::kdma>() << std::endl;
|
||||
std::cout << " max_freq : " << xrtDevice.get_info<xrt::info::device::max_clock_frequency_mhz>() << std::endl;
|
||||
std::cout << " memory : " << xrtDevice.get_info<xrt::info::device::memory>() << std::endl;
|
||||
std::cout << " thermal : " << xrtDevice.get_info<xrt::info::device::thermal>() << std::endl;
|
||||
std::cout << " m2m : " << std::boolalpha << xrtDevice.get_info<xrt::info::device::m2m>() << std::dec << std::endl;
|
||||
std::cout << " nodma : " << std::boolalpha << xrtDevice.get_info<xrt::info::device::nodma>() << std::dec << std::endl;
|
||||
|
||||
std::cout << "Memory info :" << std::endl;
|
||||
for (const auto& mem_bank : xclbin.get_mems()) {
|
||||
std::cout << " index : " << mem_bank.get_index() << std::endl;
|
||||
std::cout << " tag : " << mem_bank.get_tag() << std::endl;
|
||||
std::cout << " type : " << (int)mem_bank.get_type() << std::endl;
|
||||
std::cout << " base_address : 0x" << std::hex << mem_bank.get_base_address() << std::endl;
|
||||
std::cout << " size : 0x" << (mem_bank.get_size_kb() * 1000) << std::dec << std::endl;
|
||||
std::cout << " used :" << mem_bank.get_used() << std::endl;
|
||||
}
|
||||
}*/
|
||||
|
||||
// get platform info
|
||||
platform_info_t platform_info;
|
||||
CHECK_ERR(get_platform_info(device_name, &platform_info), {
|
||||
fprintf(stderr, "[VXDRV] Error: platform not supported: %s\n", device_name.c_str());
|
||||
return err;
|
||||
});
|
||||
|
||||
CHECK_HANDLE(device, new vx_device(xrtDevice, xrtKernel, platform_info), {
|
||||
return -1;
|
||||
});
|
||||
|
||||
#else
|
||||
|
||||
CHECK_HANDLE(xrtDevice, xrtDeviceOpen(device_index), {
|
||||
return -1;
|
||||
});
|
||||
|
||||
#ifndef XRTSIM
|
||||
|
||||
CHECK_ERR(xrtDeviceLoadXclbinFile(xrtDevice, xlbin_path_s), {
|
||||
dump_xrt_error(xrtDevice, err);
|
||||
xrtDeviceClose(xrtDevice);
|
||||
return err;
|
||||
});
|
||||
|
||||
xuid_t uuid;
|
||||
CHECK_ERR(xrtDeviceGetXclbinUUID(xrtDevice, uuid), {
|
||||
dump_xrt_error(xrtDevice, err);
|
||||
xrtDeviceClose(xrtDevice);
|
||||
return err;
|
||||
});
|
||||
|
||||
CHECK_HANDLE(xrtKernel, xrtPLKernelOpenExclusive(xrtDevice, uuid, KERNEL_NAME), {
|
||||
xrtDeviceClose(xrtDevice);
|
||||
return -1;
|
||||
});
|
||||
|
||||
#else
|
||||
|
||||
xrtKernelHandle xrtKernel = nullptr;
|
||||
|
||||
#endif
|
||||
|
||||
int device_name_size;
|
||||
xrtXclbinGetXSAName(xrtDevice, nullptr, 0, &device_name_size);
|
||||
std::vector<char> device_name(device_name_size);
|
||||
xrtXclbinGetXSAName(xrtDevice, device_name.data(), device_name_size, nullptr);
|
||||
|
||||
// get platform info
|
||||
platform_info_t platform_info;
|
||||
CHECK_ERR(get_platform_info(device_name.data(), &platform_info), {
|
||||
fprintf(stderr, "[VXDRV] Error: platform not supported: %s\n", device_name.data());
|
||||
return err;
|
||||
});
|
||||
|
||||
CHECK_HANDLE(device, new vx_device(xrtDevice, xrtKernel, platform_info), {
|
||||
xrtKernelClose(xrtKernel);
|
||||
xrtDeviceClose(xrtDevice);
|
||||
return -1;
|
||||
});
|
||||
|
||||
#endif
|
||||
|
||||
// initialize device
|
||||
CHECK_ERR(device->init(), {
|
||||
return err;
|
||||
});
|
||||
|
||||
#ifdef SCOPE
|
||||
{
|
||||
scope_callback_t callback;
|
||||
callback.registerWrite = [](vx_device_h hdevice, uint64_t value)->int {
|
||||
auto device = (vx_device*)hdevice;
|
||||
uint32_t value_lo = (uint32_t)(value);
|
||||
uint32_t value_hi = (uint32_t)(value >> 32);
|
||||
CHECK_ERR(device->write_register(MMIO_SCP_ADDR, value_lo), {
|
||||
return err;
|
||||
});
|
||||
CHECK_ERR(device->write_register(MMIO_SCP_ADDR + 4, value_hi), {
|
||||
return err;
|
||||
});
|
||||
return 0;
|
||||
};
|
||||
callback.registerRead = [](vx_device_h hdevice, uint64_t* value)->int {
|
||||
auto device = (vx_device*)hdevice;
|
||||
uint32_t value_lo, value_hi;
|
||||
CHECK_ERR(device->read_register(MMIO_SCP_ADDR, &value_lo), {
|
||||
return err;
|
||||
});
|
||||
CHECK_ERR(device->read_register(MMIO_SCP_ADDR + 4, &value_hi), {
|
||||
return err;
|
||||
});
|
||||
*value = (((uint64_t)value_hi) << 32) | value_lo;
|
||||
return 0;
|
||||
};
|
||||
int ret = vx_scope_start(&callback, device, 0, -1);
|
||||
if (ret != 0) {
|
||||
delete device;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
DBGPRINT("DEV_OPEN: hdevice=%p\n", (void*)device);
|
||||
|
||||
*hdevice = device;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dev_close(vx_device_h hdevice) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("DEV_CLOSE: hdevice=%p\n", hdevice);
|
||||
|
||||
#ifdef SCOPE
|
||||
vx_scope_stop(hdevice);
|
||||
#endif
|
||||
|
||||
auto device = (vx_device*)hdevice;
|
||||
|
||||
delete device;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dev_caps(vx_device_h hdevice, uint32_t caps_id, uint64_t *value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
vx_device *device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _value;
|
||||
|
||||
CHECK_ERR(device->get_caps(caps_id, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("DEV_CAPS: hdevice=%p, caps_id=%d, value=%ld\n", hdevice, caps_id, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_alloc(vx_device_h hdevice, uint64_t size, int flags, vx_buffer_h* hbuffer) {
|
||||
if (nullptr == hdevice
|
||||
|| nullptr == hbuffer
|
||||
|| 0 == size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("MEM_ALLOC: size=%ld, flags=0x%d\n", size, flags);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t dev_addr;
|
||||
CHECK_ERR(device->mem_alloc(size, flags, &dev_addr), {
|
||||
return err;
|
||||
});
|
||||
|
||||
auto buffer = new vx_buffer{device, dev_addr, size};
|
||||
if (nullptr == buffer) {
|
||||
device->mem_free(dev_addr);
|
||||
return -1;
|
||||
}
|
||||
|
||||
DBGPRINT("MEM_ALLOC: hdevice=%p, size=%ld, flags=0x%d, hbuffer=%p\n", hdevice, size, flags, (void*)buffer);
|
||||
|
||||
*hbuffer = buffer;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_reserve(vx_device_h hdevice, uint64_t address, uint64_t size, int flags, vx_buffer_h* hbuffer) {
|
||||
if (nullptr == hdevice
|
||||
|| nullptr == hbuffer
|
||||
|| 0 == size)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
CHECK_ERR(device->mem_reserve(address, size, flags), {
|
||||
return err;
|
||||
});
|
||||
|
||||
auto buffer = new vx_buffer{device, address, size};
|
||||
if (nullptr == buffer) {
|
||||
device->mem_free(address);
|
||||
return -1;
|
||||
}
|
||||
|
||||
DBGPRINT("MEM_RESERVE: hdevice=%p, address=0x%lx, size=%ld, flags=0x%d, hbuffer=%p\n", hdevice, address, size, flags, (void*)buffer);
|
||||
|
||||
*hbuffer = buffer;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_free(vx_buffer_h hbuffer) {
|
||||
if (nullptr == hbuffer)
|
||||
return 0;
|
||||
|
||||
DBGPRINT("MEM_FREE: hbuffer=%p\n", hbuffer);
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
vx_mem_access(hbuffer, 0, buffer->size, 0);
|
||||
|
||||
int err = device->mem_free(buffer->addr);
|
||||
|
||||
delete buffer;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
extern int vx_mem_access(vx_buffer_h hbuffer, uint64_t offset, uint64_t size, int flags) {
|
||||
if (nullptr == hbuffer)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("MEM_ACCESS: hbuffer=%p, offset=%ld, size=%ld, flags=%d\n", hbuffer, offset, size, flags);
|
||||
|
||||
return device->mem_access(buffer->addr + offset, size, flags);
|
||||
}
|
||||
|
||||
extern int vx_mem_address(vx_buffer_h hbuffer, uint64_t* address) {
|
||||
if (nullptr == hbuffer)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
|
||||
DBGPRINT("MEM_ADDRESS: hbuffer=%p, address=0x%lx\n", hbuffer, buffer->addr);
|
||||
|
||||
*address = buffer->addr;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_mem_info(vx_device_h hdevice, uint64_t* mem_free, uint64_t* mem_used) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _mem_free, _mem_used;
|
||||
|
||||
CHECK_ERR(device->mem_info(&_mem_free, &_mem_used), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("MEM_INFO: hdevice=%p, mem_free=%ld, mem_used=%ld\n", hdevice, _mem_free, _mem_used);
|
||||
|
||||
if (mem_free) {
|
||||
*mem_free = _mem_free;
|
||||
}
|
||||
|
||||
if (mem_used) {
|
||||
*mem_used = _mem_used;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_copy_to_dev(vx_buffer_h hbuffer, const void* host_ptr, uint64_t dst_offset, uint64_t size) {
|
||||
if (nullptr == hbuffer || nullptr == host_ptr)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((dst_offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("COPY_TO_DEV: hbuffer=%p, host_addr=%p, dst_offset=%ld, size=%ld\n", hbuffer, host_ptr, dst_offset, size);
|
||||
|
||||
CHECK_ERR(device->upload(buffer->addr + dst_offset, host_ptr, size), {
|
||||
return err;
|
||||
});
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_copy_from_dev(void* host_ptr, vx_buffer_h hbuffer, uint64_t src_offset, uint64_t size) {
|
||||
if (nullptr == hbuffer || nullptr == host_ptr)
|
||||
return -1;
|
||||
|
||||
auto buffer = ((vx_buffer*)hbuffer);
|
||||
auto device = ((vx_device*)buffer->device);
|
||||
|
||||
if ((src_offset + size) > buffer->size)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("COPY_FROM_DEV: hbuffer=%p, host_addr=%p, src_offset=%ld, size=%ld\n", hbuffer, host_ptr, src_offset, size);
|
||||
|
||||
CHECK_ERR(device->download(host_ptr, buffer->addr + src_offset, size), {
|
||||
return err;
|
||||
});
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_start(vx_device_h hdevice, vx_buffer_h hkernel, vx_buffer_h harguments) {
|
||||
if (nullptr == hdevice || nullptr == hkernel || nullptr == harguments)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("START: hdevice=%p, hkernel=%p, harguments=%p\n", hdevice, hkernel, harguments);
|
||||
|
||||
//wait_for_enter("\nPress ENTER to continue after setting up ILA trigger...");
|
||||
|
||||
auto device = (vx_device*)hdevice;
|
||||
auto kernel = ((vx_buffer*)hkernel);
|
||||
auto arguments = ((vx_buffer*)harguments);
|
||||
|
||||
return device->start(kernel->addr, arguments->addr);
|
||||
}
|
||||
|
||||
extern int vx_ready_wait(vx_device_h hdevice, uint64_t timeout) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("READY_WAIT: hdevice=%p, timeout=%ld\n", hdevice, timeout);
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
CHECK_ERR(device->ready_wait(timeout), {
|
||||
return err;
|
||||
});
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dcr_read(vx_device_h hdevice, uint32_t addr, uint32_t* value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = (vx_device*)hdevice;
|
||||
|
||||
uint32_t _value;
|
||||
|
||||
CHECK_ERR(device->dcr_read(addr, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("DCR_READ: hdevice=%p, addr=0x%x, value=0x%x\n", hdevice, addr, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern int vx_dcr_write(vx_device_h hdevice, uint32_t addr, uint32_t value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
DBGPRINT("DCR_WRITE: hdevice=%p, addr=0x%x, value=0x%x\n", hdevice, addr, value);
|
||||
|
||||
auto device = (vx_device*)hdevice;
|
||||
|
||||
return device->dcr_write(addr, value);
|
||||
}
|
||||
|
||||
extern int vx_mpm_query(vx_device_h hdevice, uint32_t addr, uint32_t core_id, uint64_t* value) {
|
||||
if (nullptr == hdevice)
|
||||
return -1;
|
||||
|
||||
auto device = ((vx_device*)hdevice);
|
||||
|
||||
uint64_t _value;
|
||||
|
||||
CHECK_ERR(device->mpm_query(addr, core_id, &_value), {
|
||||
return err;
|
||||
});
|
||||
|
||||
DBGPRINT("MPM_QUERY: hdevice=%p, addr=0x%x, core_id=%d, value=0x%lx\n", hdevice, addr, core_id, _value);
|
||||
|
||||
*value = _value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
#include <callbacks.inc>
|
||||
Loading…
Add table
Add a link
Reference in a new issue