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); }