static int
contextvar_del(PyContextVar *var)
{
var->var_cached = NULL;
PyContext *ctx = context_get();
if (ctx == NULL) {
return -1;
}
PyHamtObject *vars = ctx->ctx_vars;
PyHamtObject *new_vars = _PyHamt_Without(vars, (PyObject *)var);
if (new_vars == NULL) {
return -1;
}
if (vars == new_vars) {
Py_DECREF(new_vars);
PyErr_SetObject(PyExc_LookupError, (PyObject *)var);
return -1;
}
Py_SETREF(ctx->ctx_vars, new_vars);
return 0;
}
PyContextToken *
PyContextVar_Set(PyContextVar *var, PyObject *val)
{
if (!PyContextVar_CheckExact(var)) {
PyErr_SetString(
PyExc_TypeError, "an instance of ContextVar was expected");
return NULL;
}
PyContext *ctx = context_get();
if (ctx == NULL) {
return NULL;
}
PyObject *old_val = NULL;
int found = _PyHamt_Find(ctx->ctx_vars, (PyObject *)var, &old_val);
if (found < 0) {
return NULL;
}
Py_XINCREF(old_val);
PyContextToken *tok = token_new(ctx, var, old_val);
Py_XDECREF(old_val);
if (contextvar_set(var, val)) {
Py_DECREF(tok);
return NULL;
}
return tok;
}
int
PyContextVar_Reset(PyContextVar *var, PyContextToken *tok)
{
if (tok->tok_used) {
PyErr_Format(PyExc_RuntimeError,
"%R has already been used once", tok);
return -1;
}
if (var != tok->tok_var) {
PyErr_Format(PyExc_ValueError,
"%R was created by a different ContextVar", tok);
return -1;
}
PyContext *ctx = context_get();
if (ctx != tok->tok_ctx) {
PyErr_Format(PyExc_ValueError,
"%R was created in a different Context", tok);
return -1;
}
tok->tok_used = 1;
if (tok->tok_oldval == NULL) {
return contextvar_del(var);
}
else {
return contextvar_set(var, tok->tok_oldval);
}
}
vector * gpu_matrix_vector_mul_scalar(vector * v_x, double alpha) {
size_t datasize;
cl_int status;
vector * output;
cl_mem buffer_data_x;
vector_buffer buffer_v_x;
cl_command_queue cmd_queue;
cl_kernel kernel;
cl_event write_buffer_events[1],
read_buffer_events[1];
output = malloc(sizeof(vector));
output->length = v_x->length;
output->stride = 1;
output->data = malloc(sizeof(double) * v_x->length);
datasize = gpu_matrix_vector_datasize(v_x);
cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
buffer_data_x = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
buffer_v_x = gpu_matrix_vector_to_vector_buffer(
v_x, buffer_data_x
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_x,
CL_TRUE, 0, datasize,
v_x->data, 0, NULL, write_buffer_events
);
clWaitForEvents(1, write_buffer_events);
gpu_matrix_vector_buffer_mul_scalar_BANG(&buffer_v_x, alpha, cmd_queue);
// Print write buffer profilling information
status = clEnqueueReadBuffer(
cmd_queue,
buffer_data_x,
CL_TRUE,
0,
datasize,
output->data,
0,
NULL,
read_buffer_events
);
clReleaseMemObject(buffer_data_x);
clReleaseEvent(read_buffer_events[0]);
clReleaseEvent(write_buffer_events[0]);
return output;
}
ObjectNode *op_Alias
(ExecuteHandler execute, Context *context, Node *node){
const char *func_name = node->childs[0].name;
ObjectNode *tmp = context_get(context, node->childs[1].name); //(char *)newObjectNode(2, &node->childs[1]);
context_set(context, func_name, tmp);
return newObjectNode(NTYPE_NONE, 0);
}
void init_file_sys(Object *cxt) {
Object *file_object = context_get(cxt, "File");
set(cxt, file_object, "open:", new_func(cxt, native_file_open));
set(cxt, file_object, "open:mode:", new_func(cxt, native_file_open_mode));
set(cxt, file_object, "close", new_func(cxt, native_file_close));
set(cxt, file_object, "read:into:offset:length:", new_func(cxt, native_file_read_into_offset_length));
set(cxt, file_object, "eof", new_func(cxt, native_file_eof));
}
Fixnum is_exception(Object *cxt, Object *ex) {
Object *parent = get_parent(cxt, ex);
if ( parent == context_get(cxt, "Exception") ) {
return 1;
}
else {
return 0;
}
}
PyContext *
PyContext_CopyCurrent(void)
{
PyContext *ctx = context_get();
if (ctx == NULL) {
return NULL;
}
return context_new_from_vars(ctx->ctx_vars);
}
index_t gpu_matrix_vector_iamin(vector * v_x) {
size_t datasize = gpu_matrix_vector_datasize(v_x);
cl_int status;
index_t output;
cl_mem buffer_data, buffer_indices;
cl_command_queue cmd_queue;
cl_kernel kernel;
index_t remaining_length = v_x->length;
cl_event write_buffer_events[1],
read_buffer_events[1];
vector_buffer buffer_v_x;
cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
buffer_data = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data,
CL_TRUE, 0, datasize,
v_x->data, 0, NULL, write_buffer_events
);
buffer_v_x = gpu_matrix_vector_to_vector_buffer(v_x, buffer_data);
gpu_matrix_vector_buffer_abs_BANG(&buffer_v_x, cmd_queue);
buffer_indices = gpu_matrix_vector_buffer_imin(&buffer_v_x, cmd_queue);
// Print write buffer profilling information
status = clEnqueueReadBuffer(
cmd_queue,
buffer_indices,
CL_TRUE,
0,
sizeof(index_t),
&output,
0,
NULL,
read_buffer_events
);
clReleaseMemObject(buffer_data);
clReleaseMemObject(buffer_indices);
clReleaseEvent(read_buffer_events[0]);
clReleaseEvent(write_buffer_events[0]);
return output;
}
void gpu_matrix_vector_scal(vector * v_x, double alpha) {
size_t global_work_size[1] = { v_x->length };
vector * output;
size_t datasize = gpu_matrix_vector_datasize(v_x);
cl_int status;
cl_command_queue cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
cl_event write_buffer_events[2], read_buffer_events[1], enqueue_events[1];
cl_mem buffer_x, buffer_y, buffer_output, buffer_local_cache;
vector_buffer buffer_v_x, buffer_v_y;
buffer_x = buffers_create(
CL_MEM_READ_ONLY,
datasize,
NULL,
&status
);
buffer_v_x = gpu_matrix_vector_to_vector_buffer(v_x, buffer_x);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_x,
CL_FALSE, 0, datasize,
v_x->data, 0, NULL, write_buffer_events
);
clWaitForEvents(1, write_buffer_events);
gpu_matrix_vector_buffer_scal_BANG(
&buffer_v_x,
alpha,
cmd_queue
);
clEnqueueReadBuffer(
cmd_queue,
buffer_x,
CL_TRUE,
0,
datasize,
v_x->data,
0,
NULL,
read_buffer_events
);
clReleaseEvent(write_buffer_events[0]);
clReleaseEvent(read_buffer_events[0]);
}
MODULE load_session_context (void)
{
DESCR
symbols; /* Symbol descriptor */
context_load (SCOPE_GLOBAL, msg_do-> global_size, msg_do-> global_data);
context_load (SCOPE_LOCAL, msg_do-> local_size, msg_do-> local_data);
/* Normally if either of these two blocks are not found, we're
* starting a new session. The form symbol table is populated
* with all the HTTP environment symbols passed from WTPMAN at
* the start of the session.
*/
if (!context_get (SCOPE_GLOBAL, "_sess", &session, sizeof (session)))
{
memset (&session, 0, sizeof (session));
session.disable_actions = DISABLE_HIDDEN;
}
if (!context_getsym (SCOPE_GLOBAL, "_sym", &session.symbols))
{
symbols.size = msg_do-> env_size;
symbols.data = msg_do-> env_data;
session.symbols = descr2symb (&symbols);
}
session.buffer_ = &buffer;
session.program_callcode = msg_do-> call_result;
session.back_used = FALSE;
if (strlen (msg_do-> http_data) == 7
&& streq (msg_do-> http_data, "refresh"))
{
session.back_used = TRUE;
msg_do-> http_data [0] = '\0';
}
strcpy (session.program_name, msg_do-> program);
strncpy ((char *) buffer.data, msg_do-> http_data, BUFFER_MAX);
buffer.data [BUFFER_MAX] = 0;
sym_assume_symbol (session.symbols, "uri", msg_do-> http_uri);
}
static int
contextvar_set(PyContextVar *var, PyObject *val)
{
var->var_cached = NULL;
PyThreadState *ts = PyThreadState_Get();
PyContext *ctx = context_get();
if (ctx == NULL) {
return -1;
}
PyHamtObject *new_vars = _PyHamt_Assoc(
ctx->ctx_vars, (PyObject *)var, val);
if (new_vars == NULL) {
return -1;
}
Py_SETREF(ctx->ctx_vars, new_vars);
var->var_cached = val; /* borrow */
var->var_cached_tsid = ts->id;
var->var_cached_tsver = ts->context_ver;
return 0;
}
Object *new_exception(Object *cxt, Object *frame, Object *reason) {
Object *ex = new_object(cxt, context_get(cxt, "Exception"));
set(cxt, ex, "frame", frame);
set(cxt, ex, "reason", reason);
return ex;
}
struct resolv_context *
__resolv_context_get (void)
{
return context_get (false);
}
struct resolv_context *
__resolv_context_get_preinit (void)
{
return context_get (true);
}
vector * gpu_matrix_vector_add_arbitary(unsigned count, vector * arr_v[]) {
if (count == 1) {
return gpu_matrix_vector_copy(arr_v[0]);
} else if (count == 0) {
// Have fun mingling with the NULL pointer
return NULL;
}
size_t datasize;
cl_int status;
vector * output;
cl_mem buffer_data;
cl_command_queue cmd_queue;
cl_kernel kernel;
cl_event write_buffer_events_arr[10];
cl_event *write_buffer_events,
read_buffer_events[1];
vector_buffer buffer_v_this;
if (count < 10) {
write_buffer_events = write_buffer_events_arr;
} else {
write_buffer_events = malloc(sizeof(cl_event) * count);
}
// increate write_buffer_events and read_buffer_events if count is not enough
output = malloc(sizeof(vector));
output->length = arr_v[0]->length;
output->stride = 1;
output->data = malloc(sizeof(double) * arr_v[0]->length);
datasize = gpu_matrix_vector_datasize(arr_v[0]);
cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
buffer_data = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
buffer_v_this = gpu_matrix_vector_to_vector_buffer(
arr_v[0], buffer_data
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data,
CL_TRUE, 0, datasize,
arr_v[0]->data, 0, NULL, write_buffer_events
);
clWaitForEvents(1, write_buffer_events);
clReleaseEvent(write_buffer_events[0]);
// Naive implementation, Improvements later
for (unsigned i = 1 ; i < count ; i++) {
cl_mem buffer_data_next;
vector_buffer buffer_v_next;
buffer_data_next = buffers_create(
CL_MEM_READ_ONLY,
datasize,
NULL,
&status
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_next,
CL_TRUE, 0 ,datasize,
arr_v[i]->data, 0, NULL, write_buffer_events+i
);
buffer_v_next = gpu_matrix_vector_to_vector_buffer(
arr_v[i], buffer_data_next
);
clWaitForEvents(1, write_buffer_events+i);
gpu_matrix_vector_buffer_add_BANG(&buffer_v_this, &buffer_v_next, cmd_queue);
clReleaseEvent(write_buffer_events[i]);
clReleaseMemObject(buffer_data_next);
}
// Print write buffer profilling information
status = clEnqueueReadBuffer(
cmd_queue,
buffer_data,
CL_TRUE,
0,
datasize,
output->data,
0,
NULL,
read_buffer_events
);
clReleaseMemObject(buffer_data);
clReleaseEvent(read_buffer_events[0]);
if (count >= 10) {
free(write_buffer_events);
}
return output;
}
static char
get_options(lopt * opt, ImlibImage * im)
{
size_t handle = 0, index = 0, traverse = 0;
context *ctx;
if (im->key)
{
char *key = strdup(im->key);
char *tok = strtok(key, ",");
traverse = 0;
while (tok)
{
char *value = strchr(tok, '=');
if (!value)
{
value = tok;
tok = "index";
}
else
{
*value = '\0';
value++;
}
if (!strcasecmp(tok, "index"))
index = str2uint(value, index);
else if (!strcasecmp(tok, "context"))
handle = str2uint(value, handle);
else if (!strcasecmp(tok, "traverse"))
traverse = str2int(value, traverse);
tok = strtok(NULL, ",");
}
free(key);
}
else
traverse = 1;
if (!handle)
{
ImlibImageTag *htag = __imlib_GetTag(im, "context");
if (htag && htag->val)
handle = htag->val;
}
if (handle)
ctx = context_get(handle);
else if (!(ctx = context_get_by_name(im->real_file)) &&
!(ctx = context_create(im->real_file)))
return 0;
if (!index)
{
ImlibImageTag *htag = __imlib_GetTag(im, "index");
if (htag && htag->val)
index = htag->val;
}
if (index < 0 || index > id3_tag_get_numframes(ctx->tag) ||
(index == 0 && id3_tag_get_numframes(ctx->tag) < 1))
{
if (index)
fprintf(stderr, "No picture frame # %d found\n", index);
context_delref(ctx);
return 0;
}
if (!index)
index = 1;
opt->ctx = ctx;
opt->index = index;
opt->traverse = traverse;
opt->cache_level = (id3_tag_get_numframes(ctx->tag) > 1 ? 1 : 0);
return 1;
}
double gpu_matrix_vector_dot(vector * v_x, vector * v_y) {
size_t datasize = gpu_matrix_vector_datasize(v_x);
size_t global_work_size[1];
cl_int status;
double output;
cl_mem buffer_data_output, buffer_data_x, buffer_data_y;
vector_buffer buffer_v_x, buffer_v_y;
cl_command_queue cmd_queue;
cl_event write_buffer_events[2],
read_buffer_events[1];
datasize = gpu_matrix_vector_datasize(v_x);
global_work_size[0] = v_x->length;
cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
buffer_data_x = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
buffer_v_x = gpu_matrix_vector_to_vector_buffer(v_x, buffer_data_x);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_x,
CL_FALSE, 0, datasize,
v_x->data, 0, NULL,
write_buffer_events
);
buffer_data_y = buffers_create(
CL_MEM_READ_ONLY,
datasize,
NULL,
&status
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_y,
CL_FALSE, 0, datasize,
v_y->data, 0, NULL,
write_buffer_events+1
);
buffer_v_y = gpu_matrix_vector_to_vector_buffer(v_y, buffer_data_y);
clWaitForEvents(2, write_buffer_events);
gpu_matrix_vector_buffer_mul_BANG(&buffer_v_x, &buffer_v_y, cmd_queue);
gpu_matrix_vector_buffer_asum_BANG(&buffer_v_x, cmd_queue);
clEnqueueReadBuffer(
cmd_queue,
buffer_v_x.buffer,
CL_TRUE,
0,
sizeof(double),
&output,
0,
NULL,
read_buffer_events
);
clWaitForEvents(1, read_buffer_events);
// Release buffer objects
clReleaseMemObject(buffer_v_x.buffer);
clReleaseEvent(read_buffer_events[0]);
clReleaseEvent(write_buffer_events[0]);
clReleaseEvent(write_buffer_events[1]);
return output;
}
void gpu_matrix_vector_rot(
vector * v_x,
vector * v_y,
double c,
double s
){
cl_kernel kernel;
cl_command_queue cmd_queue;
cl_int status;
cl_event read_buffer_events[2], write_buffer_events[2];
size_t datasize = gpu_matrix_vector_datasize(v_x);
cl_mem buffer_data_x, buffer_data_y;
vector_buffer buffer_v_x, buffer_v_y;
cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
buffer_data_x = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
buffer_data_y = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_x,
CL_FALSE, 0, datasize,
v_x->data, 0, NULL,
write_buffer_events
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_y,
CL_FALSE, 0, datasize,
v_y->data, 0, NULL,
write_buffer_events+1
);
clWaitForEvents(2, write_buffer_events);
buffer_v_x = gpu_matrix_vector_to_vector_buffer(v_x, buffer_data_x);
buffer_v_y = gpu_matrix_vector_to_vector_buffer(v_x, buffer_data_y);
gpu_matrix_vector_buffer_rot_BANG(&buffer_v_x, &buffer_v_y, c, s, cmd_queue);
status = clEnqueueReadBuffer(
cmd_queue,
buffer_v_x.buffer,
CL_TRUE,
0,
datasize,
v_x->data,
0,
NULL,
read_buffer_events
);
status = clEnqueueReadBuffer(
cmd_queue,
buffer_v_y.buffer,
CL_TRUE,
0,
datasize,
v_y->data,
0,
NULL,
read_buffer_events+1
);
clWaitForEvents(2, read_buffer_events);
}
Object *new_file(Object *cxt, FILE *file) {
Object *obj = new_object(cxt, context_get(cxt, "File"));
obj->buffer = (Buffer *) new_file_buffer(cxt, file);
return obj;
}
ObjectNode *op_Quote
(ExecuteHandler execute, Context *context, Node *node){
return context_get(context, node->childs[0].name);
}
