Thneed load/save (#19700)
* start thneed load/save
* compiling
* fix loading
* build thneed model in scons
* don't hardcode /data/openpilot
* release files
* those too
* support for loading/saving binary kernels
* save binaries out of json band
* make binary a command line flag to the compiler
* need include assert
* fix shadowed common in SConscript
* cleanup run.h
* hmm, the recurrent buffer wasn't 0ed
* ugh, unique ptr
* remove power constraint, refactor record
* Revert "remove power constraint, refactor record"
This reverts commit bb6fa52db6df59cd9d6420a6f630430e35af8a5e.
* print on thneed stop
* fingers crossed for this one
* recorded
* just curious
* okay okay, pass tests?
* cleanups
* refactor wait
Co-authored-by: Comma Device <device@comma.ai>
Co-authored-by: Adeeb Shihadeh <adeebshihadeh@gmail.com>
old-commit-hash: 59fac9fdc6
commatwo_master
George Hotz
4 years ago
committed by
GitHub
parent
5c2c6691b2
commit
3484683199
12 changed files with 561 additions and 97 deletions
@ -0,0 +1,41 @@ |
|||||||
|
#include "thneedmodel.h" |
||||||
|
#include <assert.h> |
||||||
|
|
||||||
|
ThneedModel::ThneedModel(const char *path, float *loutput, size_t loutput_size, int runtime) { |
||||||
|
thneed = new Thneed(true); |
||||||
|
thneed->record = 0; |
||||||
|
thneed->load(path); |
||||||
|
thneed->clexec(); |
||||||
|
thneed->find_inputs_outputs(); |
||||||
|
|
||||||
|
recorded = false; |
||||||
|
output = loutput; |
||||||
|
} |
||||||
|
|
||||||
|
void ThneedModel::addRecurrent(float *state, int state_size) { |
||||||
|
recurrent = state; |
||||||
|
} |
||||||
|
|
||||||
|
void ThneedModel::addTrafficConvention(float *state, int state_size) { |
||||||
|
trafficConvention = state; |
||||||
|
} |
||||||
|
|
||||||
|
void ThneedModel::addDesire(float *state, int state_size) { |
||||||
|
desire = state; |
||||||
|
} |
||||||
|
|
||||||
|
void ThneedModel::execute(float *net_input_buf, int buf_size) { |
||||||
|
float *inputs[4] = {recurrent, trafficConvention, desire, net_input_buf}; |
||||||
|
if (!recorded) { |
||||||
|
thneed->record = THNEED_RECORD; |
||||||
|
thneed->copy_inputs(inputs); |
||||||
|
thneed->clexec(); |
||||||
|
thneed->copy_output(output); |
||||||
|
thneed->stop(); |
||||||
|
|
||||||
|
recorded = true; |
||||||
|
} else { |
||||||
|
thneed->execute(inputs, output); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
@ -0,0 +1,24 @@ |
|||||||
|
#pragma once |
||||||
|
|
||||||
|
#include "runmodel.h" |
||||||
|
#include "thneed/thneed.h" |
||||||
|
|
||||||
|
class ThneedModel : public RunModel { |
||||||
|
public: |
||||||
|
ThneedModel(const char *path, float *loutput, size_t loutput_size, int runtime); |
||||||
|
void addRecurrent(float *state, int state_size); |
||||||
|
void addTrafficConvention(float *state, int state_size); |
||||||
|
void addDesire(float *state, int state_size); |
||||||
|
void execute(float *net_input_buf, int buf_size); |
||||||
|
private: |
||||||
|
Thneed *thneed = NULL; |
||||||
|
bool recorded; |
||||||
|
|
||||||
|
float *output; |
||||||
|
|
||||||
|
// recurrent and desire
|
||||||
|
float *recurrent; |
||||||
|
float *trafficConvention; |
||||||
|
float *desire; |
||||||
|
}; |
||||||
|
|
||||||
@ -0,0 +1,34 @@ |
|||||||
|
#include <string.h> |
||||||
|
#include "thneed.h" |
||||||
|
#include "../runners/snpemodel.h" |
||||||
|
|
||||||
|
#define TEMPORAL_SIZE 512 |
||||||
|
#define DESIRE_LEN 8 |
||||||
|
#define TRAFFIC_CONVENTION_LEN 2 |
||||||
|
|
||||||
|
// TODO: This should probably use SNPE directly.
|
||||||
|
int main(int argc, char* argv[]) { |
||||||
|
#define OUTPUT_SIZE 0x10000 |
||||||
|
float *output = (float*)calloc(OUTPUT_SIZE, sizeof(float)); |
||||||
|
SNPEModel mdl(argv[1], output, 0, USE_GPU_RUNTIME); |
||||||
|
|
||||||
|
float state[TEMPORAL_SIZE] = {0}; |
||||||
|
float desire[DESIRE_LEN] = {0}; |
||||||
|
float traffic_convention[TRAFFIC_CONVENTION_LEN] = {0}; |
||||||
|
float *input = (float*)calloc(0x1000000, sizeof(float));; |
||||||
|
|
||||||
|
mdl.addRecurrent(state, TEMPORAL_SIZE); |
||||||
|
mdl.addDesire(desire, DESIRE_LEN); |
||||||
|
mdl.addTrafficConvention(traffic_convention, TRAFFIC_CONVENTION_LEN); |
||||||
|
|
||||||
|
// first run
|
||||||
|
printf("************** execute 1 **************\n"); |
||||||
|
memset(output, 0, OUTPUT_SIZE * sizeof(float)); |
||||||
|
mdl.execute(input, 0); |
||||||
|
|
||||||
|
// save model
|
||||||
|
bool save_binaries = (argc > 3) && (strcmp(argv[3], "--binary") == 0); |
||||||
|
mdl.thneed->save(argv[2], save_binaries); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
@ -0,0 +1,290 @@ |
|||||||
|
#include <set> |
||||||
|
#include <assert.h> |
||||||
|
#include "thneed.h" |
||||||
|
#include "json11.hpp" |
||||||
|
using namespace json11; |
||||||
|
|
||||||
|
extern map<cl_program, string> g_program_source; |
||||||
|
|
||||||
|
void Thneed::load(const char *filename) { |
||||||
|
printf("Thneed::load: loading from %s\n", filename); |
||||||
|
|
||||||
|
FILE *f = fopen(filename, "rb"); |
||||||
|
fseek(f, 0L, SEEK_END); |
||||||
|
int sz = ftell(f); |
||||||
|
fseek(f, 0L, SEEK_SET); |
||||||
|
char *buf = (char*)malloc(sz); |
||||||
|
fread(buf, 1, sz, f); |
||||||
|
fclose(f); |
||||||
|
|
||||||
|
int jsz = *(int *)buf; |
||||||
|
string jj(buf+4, jsz); |
||||||
|
string err; |
||||||
|
Json jdat = Json::parse(jj, err); |
||||||
|
|
||||||
|
map<cl_mem, cl_mem> real_mem; |
||||||
|
real_mem[NULL] = NULL; |
||||||
|
|
||||||
|
int ptr = 4+jsz; |
||||||
|
for (auto &obj : jdat["objects"].array_items()) { |
||||||
|
auto mobj = obj.object_items(); |
||||||
|
int sz = mobj["size"].int_value(); |
||||||
|
cl_mem clbuf = NULL; |
||||||
|
|
||||||
|
if (mobj["buffer_id"].string_value().size() > 0) { |
||||||
|
// image buffer must already be allocated
|
||||||
|
clbuf = real_mem[*(cl_mem*)(mobj["buffer_id"].string_value().data())]; |
||||||
|
assert(mobj["needs_load"].bool_value() == false); |
||||||
|
} else { |
||||||
|
if (mobj["needs_load"].bool_value()) { |
||||||
|
//printf("loading %p %d @ 0x%X\n", clbuf, sz, ptr);
|
||||||
|
clbuf = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR | CL_MEM_READ_WRITE, sz, &buf[ptr], NULL); |
||||||
|
ptr += sz; |
||||||
|
} else { |
||||||
|
clbuf = clCreateBuffer(context, CL_MEM_READ_WRITE, sz, NULL, NULL); |
||||||
|
} |
||||||
|
} |
||||||
|
assert(clbuf != NULL); |
||||||
|
|
||||||
|
if (mobj["arg_type"] == "image2d_t" || mobj["arg_type"] == "image1d_t") { |
||||||
|
cl_image_desc desc = {0}; |
||||||
|
desc.image_type = (mobj["arg_type"] == "image2d_t") ? CL_MEM_OBJECT_IMAGE2D : CL_MEM_OBJECT_IMAGE1D_BUFFER; |
||||||
|
desc.image_width = mobj["width"].int_value(); |
||||||
|
desc.image_height = mobj["height"].int_value(); |
||||||
|
desc.image_row_pitch = mobj["row_pitch"].int_value(); |
||||||
|
desc.buffer = clbuf; |
||||||
|
|
||||||
|
cl_image_format format; |
||||||
|
format.image_channel_order = CL_RGBA; |
||||||
|
format.image_channel_data_type = CL_HALF_FLOAT; |
||||||
|
|
||||||
|
clbuf = clCreateImage(context, CL_MEM_READ_WRITE, &format, &desc, NULL, NULL); |
||||||
|
assert(clbuf != NULL); |
||||||
|
} |
||||||
|
|
||||||
|
real_mem[*(cl_mem*)(mobj["id"].string_value().data())] = clbuf; |
||||||
|
} |
||||||
|
|
||||||
|
map<string, cl_program> g_programs; |
||||||
|
for (auto &obj : jdat["programs"].object_items()) { |
||||||
|
const char *srcs[1]; |
||||||
|
srcs[0] = (const char *)obj.second.string_value().c_str(); |
||||||
|
size_t length = obj.second.string_value().size(); |
||||||
|
|
||||||
|
if (record & THNEED_DEBUG) printf("building %s with size %zu\n", obj.first.c_str(), length); |
||||||
|
|
||||||
|
cl_program program = clCreateProgramWithSource(context, 1, srcs, &length, NULL); |
||||||
|
int err = clBuildProgram(program, 1, &device_id, "", NULL, NULL); |
||||||
|
if (err != 0) { |
||||||
|
printf("got err %d\n", err); |
||||||
|
size_t length; |
||||||
|
char buffer[2048]; |
||||||
|
clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &length); |
||||||
|
buffer[length] = '\0'; |
||||||
|
printf("%s\n", buffer); |
||||||
|
} |
||||||
|
assert(err == 0); |
||||||
|
|
||||||
|
g_programs[obj.first] = program; |
||||||
|
} |
||||||
|
|
||||||
|
for (auto &obj : jdat["binaries"].array_items()) { |
||||||
|
string name = obj["name"].string_value(); |
||||||
|
size_t length = obj["length"].int_value(); |
||||||
|
const unsigned char *srcs[1]; |
||||||
|
srcs[0] = (const unsigned char *)&buf[ptr]; |
||||||
|
ptr += length; |
||||||
|
|
||||||
|
if (record & THNEED_DEBUG) printf("binary %s with size %zu\n", name.c_str(), length); |
||||||
|
|
||||||
|
cl_int err; |
||||||
|
cl_program program = clCreateProgramWithBinary(context, 1, &device_id, &length, srcs, NULL, &err); |
||||||
|
assert(program != NULL && err == CL_SUCCESS); |
||||||
|
err = clBuildProgram(program, 1, &device_id, "", NULL, NULL); |
||||||
|
assert(err == CL_SUCCESS); |
||||||
|
|
||||||
|
g_programs[name] = program; |
||||||
|
} |
||||||
|
|
||||||
|
for (auto &obj : jdat["kernels"].array_items()) { |
||||||
|
auto gws = obj["global_work_size"]; |
||||||
|
auto lws = obj["local_work_size"]; |
||||||
|
auto kk = shared_ptr<CLQueuedKernel>(new CLQueuedKernel(this)); |
||||||
|
|
||||||
|
kk->name = obj["name"].string_value(); |
||||||
|
kk->program = g_programs[kk->name]; |
||||||
|
kk->work_dim = obj["work_dim"].int_value(); |
||||||
|
for (int i = 0; i < kk->work_dim; i++) { |
||||||
|
kk->global_work_size[i] = gws[i].int_value(); |
||||||
|
kk->local_work_size[i] = lws[i].int_value(); |
||||||
|
} |
||||||
|
kk->num_args = obj["num_args"].int_value(); |
||||||
|
for (int i = 0; i < kk->num_args; i++) { |
||||||
|
string arg = obj["args"].array_items()[i].string_value(); |
||||||
|
int arg_size = obj["args_size"].array_items()[i].int_value(); |
||||||
|
kk->args_size.push_back(arg_size); |
||||||
|
if (arg_size == 8) { |
||||||
|
cl_mem val = *(cl_mem*)(arg.data()); |
||||||
|
val = real_mem[val]; |
||||||
|
kk->args.push_back(string((char*)&val, sizeof(val))); |
||||||
|
} else { |
||||||
|
kk->args.push_back(arg); |
||||||
|
} |
||||||
|
} |
||||||
|
kq.push_back(kk); |
||||||
|
} |
||||||
|
|
||||||
|
free(buf); |
||||||
|
clFinish(command_queue); |
||||||
|
} |
||||||
|
|
||||||
|
void Thneed::save(const char *filename, bool save_binaries) { |
||||||
|
printf("Thneed::save: saving to %s\n", filename); |
||||||
|
|
||||||
|
// get kernels
|
||||||
|
std::vector<Json> kernels; |
||||||
|
std::set<string> saved_objects; |
||||||
|
std::vector<Json> objects; |
||||||
|
std::map<string, string> programs; |
||||||
|
std::map<string, string> binaries; |
||||||
|
|
||||||
|
for (auto &k : kq) { |
||||||
|
kernels.push_back(k->to_json()); |
||||||
|
|
||||||
|
// check args for objects
|
||||||
|
int i = 0; |
||||||
|
for (auto &a : k->args) { |
||||||
|
if (a.size() == 8) { |
||||||
|
if (saved_objects.find(a) == saved_objects.end()) { |
||||||
|
saved_objects.insert(a); |
||||||
|
cl_mem val = *(cl_mem*)(a.data()); |
||||||
|
if (val != NULL) { |
||||||
|
bool needs_load = k->arg_names[i] == "weights" || k->arg_names[i] == "biases"; |
||||||
|
|
||||||
|
auto jj = Json::object({ |
||||||
|
{"id", a}, |
||||||
|
{"arg_type", k->arg_types[i]}, |
||||||
|
}); |
||||||
|
|
||||||
|
if (k->arg_types[i] == "image2d_t" || k->arg_types[i] == "image1d_t") { |
||||||
|
cl_mem buf; |
||||||
|
clGetImageInfo(val, CL_IMAGE_BUFFER, sizeof(buf), &buf, NULL); |
||||||
|
string aa = string((char *)&buf, sizeof(buf)); |
||||||
|
jj["buffer_id"] = aa; |
||||||
|
|
||||||
|
size_t width, height, row_pitch; |
||||||
|
clGetImageInfo(val, CL_IMAGE_WIDTH, sizeof(width), &width, NULL); |
||||||
|
clGetImageInfo(val, CL_IMAGE_HEIGHT, sizeof(height), &height, NULL); |
||||||
|
clGetImageInfo(val, CL_IMAGE_ROW_PITCH, sizeof(row_pitch), &row_pitch, NULL); |
||||||
|
jj["width"] = (int)width; |
||||||
|
jj["height"] = (int)height; |
||||||
|
jj["row_pitch"] = (int)row_pitch; |
||||||
|
jj["size"] = (int)(height * row_pitch); |
||||||
|
jj["needs_load"] = false; |
||||||
|
|
||||||
|
if (saved_objects.find(aa) == saved_objects.end()) { |
||||||
|
saved_objects.insert(aa); |
||||||
|
size_t sz; |
||||||
|
clGetMemObjectInfo(buf, CL_MEM_SIZE, sizeof(sz), &sz, NULL); |
||||||
|
// save the buffer
|
||||||
|
objects.push_back(Json::object({ |
||||||
|
{"id", aa}, |
||||||
|
{"arg_type", "<image buffer>"}, |
||||||
|
{"needs_load", needs_load}, |
||||||
|
{"size", (int)sz} |
||||||
|
})); |
||||||
|
if (needs_load) assert(sz == height * row_pitch); |
||||||
|
} |
||||||
|
} else { |
||||||
|
size_t sz = 0; |
||||||
|
clGetMemObjectInfo(val, CL_MEM_SIZE, sizeof(sz), &sz, NULL); |
||||||
|
jj["size"] = (int)sz; |
||||||
|
jj["needs_load"] = needs_load; |
||||||
|
} |
||||||
|
|
||||||
|
objects.push_back(jj); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
i++; |
||||||
|
} |
||||||
|
|
||||||
|
if (save_binaries) { |
||||||
|
int err; |
||||||
|
size_t binary_size = 0; |
||||||
|
err = clGetProgramInfo(k->program, CL_PROGRAM_BINARY_SIZES, sizeof(binary_size), &binary_size, NULL); |
||||||
|
assert(err == 0); |
||||||
|
assert(binary_size > 0); |
||||||
|
string sv(binary_size, '\x00'); |
||||||
|
|
||||||
|
uint8_t* bufs[1] = { (uint8_t*)sv.data(), }; |
||||||
|
err = clGetProgramInfo(k->program, CL_PROGRAM_BINARIES, sizeof(bufs), &bufs, NULL); |
||||||
|
assert(err == 0); |
||||||
|
|
||||||
|
binaries[k->name] = sv; |
||||||
|
} else { |
||||||
|
programs[k->name] = g_program_source[k->program]; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
vector<string> saved_buffers; |
||||||
|
for (auto &obj : objects) { |
||||||
|
auto mobj = obj.object_items(); |
||||||
|
cl_mem val = *(cl_mem*)(mobj["id"].string_value().data()); |
||||||
|
int sz = mobj["size"].int_value(); |
||||||
|
if (mobj["needs_load"].bool_value()) { |
||||||
|
char *buf = (char *)malloc(sz); |
||||||
|
if (mobj["arg_type"] == "image2d_t" || mobj["arg_type"] == "image1d_t") { |
||||||
|
assert(false); |
||||||
|
} else { |
||||||
|
// buffers alloced with CL_MEM_HOST_WRITE_ONLY, hence this hack
|
||||||
|
//hexdump((uint32_t*)val, 0x100);
|
||||||
|
|
||||||
|
// the worst hack in thneed, the flags are at 0x14
|
||||||
|
((uint32_t*)val)[0x14] &= ~CL_MEM_HOST_WRITE_ONLY; |
||||||
|
cl_int ret = clEnqueueReadBuffer(command_queue, val, CL_TRUE, 0, sz, buf, 0, NULL, NULL); |
||||||
|
assert(ret == CL_SUCCESS); |
||||||
|
} |
||||||
|
//printf("saving buffer: %d %p %s\n", sz, buf, mobj["arg_type"].string_value().c_str());
|
||||||
|
saved_buffers.push_back(string(buf, sz)); |
||||||
|
free(buf); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
std::vector<Json> jbinaries; |
||||||
|
for (auto &obj : binaries) { |
||||||
|
jbinaries.push_back(Json::object({{"name", obj.first}, {"length", (int)obj.second.size()}})); |
||||||
|
saved_buffers.push_back(obj.second); |
||||||
|
} |
||||||
|
|
||||||
|
Json jdat = Json::object({ |
||||||
|
{"kernels", kernels}, |
||||||
|
{"objects", objects}, |
||||||
|
{"programs", programs}, |
||||||
|
{"binaries", jbinaries}, |
||||||
|
}); |
||||||
|
|
||||||
|
string str = jdat.dump(); |
||||||
|
int jsz = str.length(); |
||||||
|
|
||||||
|
FILE *f = fopen(filename, "wb"); |
||||||
|
fwrite(&jsz, 1, sizeof(jsz), f); |
||||||
|
fwrite(str.data(), 1, jsz, f); |
||||||
|
for (auto &s : saved_buffers) { |
||||||
|
fwrite(s.data(), 1, s.length(), f); |
||||||
|
} |
||||||
|
fclose(f); |
||||||
|
} |
||||||
|
|
||||||
|
Json CLQueuedKernel::to_json() const { |
||||||
|
return Json::object { |
||||||
|
{ "name", name }, |
||||||
|
{ "work_dim", (int)work_dim }, |
||||||
|
{ "global_work_size", Json::array { (int)global_work_size[0], (int)global_work_size[1], (int)global_work_size[2] } }, |
||||||
|
{ "local_work_size", Json::array { (int)local_work_size[0], (int)local_work_size[1], (int)local_work_size[2] } }, |
||||||
|
{ "num_args", (int)num_args }, |
||||||
|
{ "args", args }, |
||||||
|
{ "args_size", args_size }, |
||||||
|
}; |
||||||
|
} |
||||||
|
|
||||||
Loading…
Reference in new issue