From a68d3c982ed0dd4ef5bbc9e0c22b9ecf9565b924 Mon Sep 17 00:00:00 2001 From: uphantom Date: Fri, 28 Aug 2015 17:41:14 +0800 Subject: fastnn version 1.0 --- fastnn/io/Example.cpp | 186 +++++++++++++++++++++++++++++++++++++ fastnn/io/Example.h | 49 ++++++++++ fastnn/io/example.c | 249 ++++++++++++++++++++++++++++++++++++++++++++++++++ fastnn/io/example.lua | 38 ++++++++ 4 files changed, 522 insertions(+) create mode 100644 fastnn/io/Example.cpp create mode 100644 fastnn/io/Example.h create mode 100644 fastnn/io/example.c create mode 100644 fastnn/io/example.lua (limited to 'fastnn/io') diff --git a/fastnn/io/Example.cpp b/fastnn/io/Example.cpp new file mode 100644 index 0000000..8f200b7 --- /dev/null +++ b/fastnn/io/Example.cpp @@ -0,0 +1,186 @@ + +#include +#include +#include + + +extern "C" { + +#include "../threads/lib/THThread.h" +#include "Example.h" +#include "stdlib.h" +#include "stdio.h" + +#include "../../nerv/lib/matrix/generic/elem_type.h" +#include "common.h" + +extern Matrix* nerv_matrix_cuda_float_create(long nrow, long ncol, Status *status); +void nerv_matrix_cuda_float_copy_fromd(Matrix *a, const Matrix *b, + int a_begin, int b_begin, int b_end, + Status *status); + +struct Example +{ + std::vector inputs; + std::string id; + int refcount; +}; + +struct ExamplesRepository +{ + int buffer_size_; + THSemaphore *full_semaphore_; + THSemaphore *empty_semaphore_; + THMutex *examples_mutex_; + + std::deque examples_; + bool done_; + int refcount; + int gpuid; +}; + +Example* Example_new() +{ + Example *example = new Example; //(Example*)malloc(sizeof(Example)); + example->refcount = 1; + return example; +} + +Example* Example_newWithId(long id) +{ + Example* example = (Example*)(id); + __sync_fetch_and_add(&example->refcount, 1); + return example; +} + +long Example_id(Example *example) +{ + return (long)(example); +} + +void Example_destroy(Example* example) +{ + //printf("Example_destroy: %d\n", example->inputs.size()); + if (NULL != example && __sync_fetch_and_add(&example->refcount, -1) == 1) + { + delete example; + example = NULL; + } +} + +int Example_size(Example* example) +{ + return example->inputs.size(); +} + +Matrix* Example_at(Example* example, int idx) +{ + return example->inputs.at(idx); +} + +void Example_pushback(Example* example, Matrix* m) +{ + Status status; + Matrix *newm = nerv_matrix_cuda_float_create(m->nrow, m->ncol, &status); + nerv_matrix_cuda_float_copy_fromd(newm, m, 0, 0, m->nrow, &status); + //__sync_fetch_and_add(&m->refcount, 1); + return example->inputs.push_back(newm); +} + +////////////////////////////////////////////////////////////// + + +ExamplesRepository* ExamplesRepository_new(int buffersize) +{ + ExamplesRepository *repo = new ExamplesRepository; //(ExamplesRepository*)malloc(sizeof(ExamplesRepository)); + repo->buffer_size_ = buffersize; + repo->full_semaphore_ = THSemaphore_new(0); + repo->empty_semaphore_ = THSemaphore_new(buffersize); + repo->examples_mutex_ = THMutex_new(); +// repo->examples_ = new std::deque(); + repo->done_ = false; + repo->refcount = 1; + repo->gpuid = -1; + return repo; +} + +ExamplesRepository* ExamplesRepository_newWithId(long id) +{ + ExamplesRepository *repo = (ExamplesRepository*)(id); + __sync_fetch_and_add(&repo->refcount, 1); + return repo; +} + +long ExamplesRepository_id(ExamplesRepository* repo) +{ + return (long)(repo); +} + +int ExamplesRepository_getGpuId(ExamplesRepository* repo) +{ + return repo->gpuid; +} + +void ExamplesRepository_setGpuId(ExamplesRepository* repo, int gpuid) +{ + repo->gpuid = gpuid; +} + +void ExamplesRepository_destroy(ExamplesRepository* repo) +{ + if (NULL != repo && __sync_fetch_and_add(&repo->refcount, -1) == 1) + { + if (repo->full_semaphore_) + THSemaphore_free(repo->full_semaphore_); + if (repo->empty_semaphore_) + THSemaphore_free(repo->empty_semaphore_); + if (repo->examples_mutex_) + THMutex_free(repo->examples_mutex_); + delete repo; + repo = NULL; + } +} + +void AcceptExample(ExamplesRepository *repo, Example *example) +{ + THSemaphore_wait(repo->empty_semaphore_); + THMutex_lock(repo->examples_mutex_); + __sync_fetch_and_add(&example->refcount, 1); + repo->examples_.push_back(example); + THMutex_unlock(repo->examples_mutex_); + THSemaphore_signal(repo->full_semaphore_); +} + +void ExamplesDone(ExamplesRepository *repo) +{ + for (int i = 0; i < repo->buffer_size_; i++) + THSemaphore_wait(repo->empty_semaphore_); + + repo->done_ = true; + THSemaphore_signal(repo->full_semaphore_); +} + +Example* ProvideExample(ExamplesRepository *repo) +{ + Example *ans = NULL; + THSemaphore_wait(repo->full_semaphore_); + if (repo->done_) + { + THSemaphore_signal(repo->full_semaphore_); // Increment the semaphore so + // the call by the next thread will not block. + return NULL; // no examples to return-- all finished. + } + else + { + THMutex_lock(repo->examples_mutex_); + ans = repo->examples_.front(); + repo->examples_.pop_front(); + THMutex_unlock(repo->examples_mutex_); + THSemaphore_signal(repo->empty_semaphore_); + } + return ans; +} + +} + + diff --git a/fastnn/io/Example.h b/fastnn/io/Example.h new file mode 100644 index 0000000..1c462ab --- /dev/null +++ b/fastnn/io/Example.h @@ -0,0 +1,49 @@ +#ifndef NERV_FASTNN_EXAMPLE_H +#define NERV_FASTNN_EXAMPLE_H + + +#ifdef __cplusplus +extern "C" { +#endif + +#include "matrix/matrix.h" +#include "stdbool.h" +#define STRLEN 1024 + + + +typedef struct ExamplesRepository ExamplesRepository; +typedef struct Example Example; + +ExamplesRepository* ExamplesRepository_new(int buffersize); +ExamplesRepository* ExamplesRepository_newWithId(long id); +long ExamplesRepository_id(ExamplesRepository* reop); +void ExamplesRepository_destroy(ExamplesRepository* reop); +void AcceptExample(ExamplesRepository *repo, Example *example); +void ExamplesDone(ExamplesRepository *repo); +Example* ProvideExample(ExamplesRepository *repo); +void ExamplesRepository_setGpuId(ExamplesRepository* repo, int gpuid); +int ExamplesRepository_getGpuId(ExamplesRepository* repo); + + +Example* Example_new(); +Example* Example_newWithId(long id); +long Example_id(Example* example); +void Example_destroy(Example* example); +int Example_size(Example* example); +Matrix* Example_at(Example* example, int idx); +void Example_pushback(Example* example, Matrix* m); + + + + + + + + +#ifdef __cplusplus +} // closing brace for extern "C" + +#endif // end Example + +#endif diff --git a/fastnn/io/example.c b/fastnn/io/example.c new file mode 100644 index 0000000..f2f0916 --- /dev/null +++ b/fastnn/io/example.c @@ -0,0 +1,249 @@ + +#include +#include + +#include +#include +#include + + + +#include "../threads/lib/luaTHRD.h" +#include "Example.h" + + +const char *fastnn_example_repo_tname = "fastnn.CExamplesRepo"; +const char *fastnn_example_tname = "fastnn.CExample"; + +static int example_repo_new(lua_State *L) +{ + ExamplesRepository *repo = NULL ; + int buffersize; + bool shared; + long id; + if(lua_gettop(L) == 2 && lua_isboolean(L, 2)) + { + shared = lua_toboolean(L, 2); + if (shared) + { + id = luaL_checkinteger(L, 1); + repo = ExamplesRepository_newWithId(id); + } + else + { + buffersize = luaL_checkinteger(L, 1); + repo = ExamplesRepository_new(buffersize); + } + } + else + luaL_error(L, "example: example repo new invalid arguments"); + if (!repo) + luaL_error(L, "example: example new failed"); + + luaTHRD_pushudata(L, repo, fastnn_example_repo_tname); + + return 1; +} + +static int example_repo_newfromid(lua_State *L) +{ + ExamplesRepository *repo = NULL ; + if(lua_gettop(L) == 1) + { + long id = luaL_checkinteger(L, 1); + repo = ExamplesRepository_newWithId(id); + } + else + luaL_error(L, "example: example repo new invalid arguments"); + if (!repo) + luaL_error(L, "example: example new failed"); + + luaTHRD_pushudata(L, repo, fastnn_example_repo_tname); + + return 1; +} + +static int example_repo_tostring(lua_State *L) +{ + char str[STRLEN]; + ExamplesRepository *repo = luaTHRD_checkudata(L, 1, fastnn_example_repo_tname); + snprintf(str, STRLEN, "%s <%lx>", fastnn_example_repo_tname, ExamplesRepository_id(repo)); + lua_pushstring(L, str); + return 1; +} + +static int example_repo_id(lua_State *L) +{ + ExamplesRepository *repo = luaTHRD_checkudata(L, 1, fastnn_example_repo_tname); + lua_pushinteger(L, ExamplesRepository_id(repo)); + return 1; +} + +static int example_repo_get_gpuid(lua_State *L) +{ + ExamplesRepository *repo = luaTHRD_checkudata(L, 1, fastnn_example_repo_tname); + lua_pushinteger(L, ExamplesRepository_getGpuId(repo)); + return 1; +} + +static int example_repo_set_gpuid(lua_State *L) +{ + ExamplesRepository *repo = luaTHRD_checkudata(L, 1, fastnn_example_repo_tname); + int gpuid = luaL_checkinteger(L, 2); + ExamplesRepository_setGpuId(repo, gpuid); + return 0; +} + +static int example_repo_accept(lua_State *L) +{ + ExamplesRepository *repo = luaTHRD_checkudata(L, 1, fastnn_example_repo_tname); + Example *example = luaTHRD_checkudata(L, 2, fastnn_example_tname); + AcceptExample(repo, example); + return 0; +} + +static int example_repo_provide(lua_State *L) +{ + ExamplesRepository *repo = luaTHRD_checkudata(L, 1, fastnn_example_repo_tname); + Example *example = ProvideExample(repo); + if (NULL != example) + { + luaTHRD_pushudata(L, example, fastnn_example_tname); + return 1; + } + else + return 0; +} + +static int example_repo_done(lua_State *L) +{ + ExamplesRepository *repo = luaTHRD_checkudata(L, 1, fastnn_example_repo_tname); + ExamplesDone(repo); + return 0; +} + +static int example_repo_destroy(lua_State *L) +{ + ExamplesRepository *repo = luaTHRD_checkudata(L, 1, fastnn_example_repo_tname); + ExamplesRepository_destroy(repo); + return 0; +} + +/******************************************/ + +static int example_new(lua_State *L) +{ + + Example *example = NULL; + if(lua_gettop(L) == 0) + { + example = Example_new(); + } + else if(lua_gettop(L) == 1) + { + long id = luaL_checkinteger(L, 1); + example = Example_newWithId(id); + } + else + luaL_error(L, "example: example new invalid arguments"); + if (!example) + luaL_error(L, "example: example failed"); + + luaTHRD_pushudata(L, example, fastnn_example_tname); + + return 1; +} + +static int example_id(lua_State *L) +{ + Example *example = luaTHRD_checkudata(L, 1, fastnn_example_tname); + lua_pushinteger(L, Example_id(example)); + return 1; +} + +static int example_tostring(lua_State *L) +{ + char str[STRLEN]; + Example* example = luaTHRD_checkudata(L, 1, fastnn_example_tname); + snprintf(str, STRLEN, "%s <%lx>", fastnn_example_tname, Example_id(example)); + lua_pushstring(L, str); + return 1; +} + +static int example_size(lua_State *L) +{ + Example *example = luaTHRD_checkudata(L, 1, fastnn_example_tname); + lua_pushinteger(L, Example_size(example)); + return 1; +} + +static int example_at(lua_State *L) +{ + Example *example = luaTHRD_checkudata(L, 1, fastnn_example_tname); + int idx = luaL_checkinteger(L, 2); + Matrix *m = Example_at(example, idx); + luaTHRD_pushudata(L, m, "nerv.CuMatrixFloat"); + //luaT_pushudata(L, m, "nerv.CuMatrixFloat"); + return 1; +} + +static int example_pushback(lua_State *L) +{ + Example *example = luaTHRD_checkudata(L, 1, fastnn_example_tname); + Matrix *m = luaTHRD_checkudata(L, 2, "nerv.CuMatrixFloat"); + //Matrix *m = luaT_checkudata(L, 2, "nerv.CuMatrixFloat"); + Example_pushback(example, m); + return 0; +} + +static int example_destroy(lua_State *L) +{ + Example *example = luaTHRD_checkudata(L, 1, fastnn_example_tname); + Example_destroy(example); + //printf("example_destroy ... end\n"); + return 0; +} + + +static const struct luaL_Reg example_repo__ [] = { + {"new", example_repo_new}, + {"newfromid", example_repo_newfromid}, + {"__tostring", example_repo_tostring}, + {"id", example_repo_id}, + {"get_gpuid", example_repo_get_gpuid}, + {"set_gpuid", example_repo_set_gpuid}, + {"accept", example_repo_accept}, + {"provide", example_repo_provide}, + {"done", example_repo_done}, + {"free", example_repo_destroy}, + {NULL, NULL} +}; + +static const struct luaL_Reg example__ [] = { + {"new", example_new}, + {"__tostring", example_tostring}, + {"id", example_id}, + {"size", example_size}, + {"at", example_at}, + {"pushback", example_pushback}, + {"free", example_destroy}, + {NULL, NULL} +}; + +void fastnn_init_example(lua_State *L) +{ + luaT_newmetatable(L, fastnn_example_tname, NULL, example_new, example_destroy, NULL); + luaL_register(L, NULL, example__); + lua_pop(L, 1); +} + +void fastnn_init_example_repo(lua_State *L) +{ + luaT_newmetatable(L, fastnn_example_repo_tname, NULL, example_repo_new, example_repo_destroy, NULL); + luaL_register(L, NULL, example_repo__); + lua_pop(L, 1); +} + + + + diff --git a/fastnn/io/example.lua b/fastnn/io/example.lua new file mode 100644 index 0000000..8808791 --- /dev/null +++ b/fastnn/io/example.lua @@ -0,0 +1,38 @@ + +local T = require 'libthreads' +local C = require 'libfastnn' + +local ExamplesRepo = nerv.class("fastnn.ExamplesRepo") +local Example = nerv.class("fastnn.Example") + +fastnn.CExamplesRepo = C.CExamplesRepo +fastnn.CExample = C.CExample + +function ExamplesRepo:__init(shareid) + if nil ~= shareid then + -- print(shareid) + self.repo = C.CExamplesRepo(shareid, true) + -- print(self.repo:__tostring()) + end +end + + +function Example:PrepareData(data, global_transf, trains_id) + local example = fastnn.CExample() + if nil ~= data then + for id, cm in pairs(data) do + if trains_id[id] and nil ~= global_transf then + local tcm = nerv.speech_utils.normalize(cm, global_transf) + example:pushback(tcm) + else + example:pushback(cm) + end + + end + end + + return example +end + + + -- cgit v1.2.3-70-g09d2