static inline thread_t * get_queue(void) { DPRINTF("\n"); // LIST_DUMP(&runq); DPRINTF("return: %p\n", LIST_GET(runq.next, list, thread_t)); return LIST_GET(runq.next, list, thread_t); }
std::vector<cv::Ptr<cv::dnn::Layer> > List_to_vector_Ptr_Layer(JNIEnv* env, jobject list) { static jclass juArrayList = ARRAYLIST(env); jmethodID m_size = LIST_SIZE(env, juArrayList); jmethodID m_get = LIST_GET(env, juArrayList); static jclass jLayerClass = LAYER(env); jint len = env->CallIntMethod(list, m_size); std::vector< cv::Ptr<cv::dnn::Layer> > result; result.reserve(len); for (jint i=0; i<len; i++) { jobject element = static_cast<jobject>(env->CallObjectMethod(list, m_get, i)); cv::Ptr<cv::dnn::Layer>* layer_ptr = (cv::Ptr<cv::dnn::Layer>*) GETNATIVEOBJ(env, jLayerClass, element) ; cv::Ptr<cv::dnn::Layer> layer = *(layer_ptr); result.push_back(layer); env->DeleteLocalRef(element); } return result; }
std::vector<MatShape> List_to_vector_MatShape(JNIEnv* env, jobject list) { static jclass juArrayList = ARRAYLIST(env); jmethodID m_size = LIST_SIZE(env, juArrayList); jmethodID m_get = LIST_GET(env, juArrayList); static jclass jMatOfInt = MATOFINT(env); jint len = env->CallIntMethod(list, m_size); std::vector<MatShape> result; result.reserve(len); for (jint i=0; i<len; i++) { jobject element = static_cast<jobject>(env->CallObjectMethod(list, m_get, i)); cv::Mat& mat = *((cv::Mat*) GETNATIVEOBJ(env, jMatOfInt, element) ); MatShape matshape = (MatShape) mat; result.push_back(matshape); env->DeleteLocalRef(element); } return result; }
/** * slice string/list * string.slice(a,b) [a,b), b is not included * string.slice(0,-1) = string.slice(0,len(string)) * @since 2016-11-19 * <code> * 'test'.slice(0,1) = 't' * 'test'.slice(0,-1) = 'test' * </code> */ Object obj_slice(Object self, Object first, Object second) { int start = GET_NUM(first); int end = GET_NUM(second); Object ret = NONE_OBJECT; if (IS_STR(self)) { int length = GET_STR_LEN(self); start = start >= 0 ? start : start + length + 1; end = end >= 0 ? end : end + length + 1; if (start < 0 || start > length) { start = 0; } if (end < 0 || end > length) { end = length; // do not overflow; } if (end <= start) { return string_alloc("", 0); } return string_alloc(GET_STR(self) + start, end - start); } else if (IS_LIST(self)) { int length = LIST_LEN(self); start = start > 0 ? start : start + length + 1; end = end > 0 ? end : end + length + 1; if (start < 0 || start > length) { start = 0; } if (end < 0 || end > length) { end = length; } int i = 0; ret = list_new(end - start); for (i = start; i < end ; i++) { obj_append(ret, LIST_GET(self, i)); } } else { tm_raise("slice not implemented for type %s", tm_type(self.type)); } return ret; }
void do_distribute(FILE *origin_fp, List *partials) { long split_count = ((Partial *)LIST_GET(partials, 0))->split_count; int parity_count = partials->length - split_count; assert(parity_count == 0 || parity_count == 1); // Separate partials into splits and parities. List *splits = new_list(); Partial *parity = NULL; LIST_REWIND(partials); for (long i=0; i<split_count; i++) { Partial *p = (Partial *)LIST_NEXT(partials); assert(p->split_count == split_count); assert(p->index == i); DV_INC_REF(p); LIST_PUSH(splits, p); } if (parity_count == 1) { Partial *p = (Partial *)LIST_NEXT(partials); assert(p->split_count == split_count); assert(p->index == split_count); parity = p; } long buff_size = 1024; char buffer[buff_size]; // write conteent_length header; long content_length = dv_file_size(origin_fp); long header_size = snprintf(buffer, buff_size, "content_length: %ld\n\n", content_length); if (header_size == buff_size) { dv_error("The buffer size is too short to create content_length header."); } LIST_REWIND(splits); for (long i=0; i<header_size; i++) { // Split char into bits and write. for (int j=0; j<8; j++) { if (! LIST_HAS_NEXT(splits)) { LIST_REWIND(splits); } PARTIAL_PUTB(LIST_NEXT(splits), buffer[i] & (1 << j)); } } // Read from origin_fp and write to splits. int c; while ((c = dv_fgetc(origin_fp)) != EOF) { // Split char into bits and write for (int i=0; i<8; i++) { if (! (LIST_HAS_NEXT(splits))) { LIST_REWIND(splits); } PARTIAL_PUTB(LIST_NEXT(splits), c & (1 << i)); } } // Create parity if necesary. if (parity) { take_parity(splits, parity); } }
/** ** evaluate byte code. ** @param f: Frame ** @return evaluated value. */ Object tm_eval(TmFrame* f) { Object* locals = f->locals; Object* top = f->stack; Object cur_fnc = f->fnc; Object globals = get_globals(cur_fnc); // TODO use code cache to replace unsigned char* unsigned char* pc = f->pc; const char* func_name_sz = get_func_name_sz(cur_fnc); Object x, k, v; Object ret = NONE_OBJECT; int i; #if INTERP_DB printf("File \"%s\": enter function %s\n",get_func_file_sz(cur_fnc), get_func_name_sz(cur_fnc)); #endif while (1) { i = (pc[1] << 8) | pc[2]; #if INTERP_DB printf("%30s%2d: %d frame = %d, top = %d\n","", pc[0], i, tm->cur, (int) (top - f->stack)); #endif switch (pc[0]) { case OP_NUMBER: { double d = atof((char*)pc + 3); pc += i; v = tm_number(d); /* obj_append(tm->constants,v);*/ dict_set(tm->constants, v, NONE_OBJECT); break; } case OP_STRING: { v = string_alloc((char*)pc + 3, i); pc += i; /* obj_append(tm->constants,v); */ dict_set(tm->constants, v, NONE_OBJECT); break; } case OP_IMPORT: { // TODO // tm_import(globals) Object import_func = tm_get_global(globals, "_import"); arg_start(); arg_push(globals); Object modname, attr; if (i == 1) { modname = TM_POP(); arg_push(modname); // arg1 } else { attr = TM_POP(); modname = TM_POP(); arg_push(modname); arg_push(attr); } call_function(import_func); break; } case OP_CONSTANT: { TM_PUSH(GET_CONST(i)); break; } case OP_NONE: { TM_PUSH(NONE_OBJECT); break; } case OP_LOAD_LOCAL: { TM_PUSH(locals[i]); break; } case OP_STORE_LOCAL: locals[i] = TM_POP(); break; case OP_LOAD_GLOBAL: { /* tm_printf("load global %o\n", GET_CONST(i)); */ int idx = dict_get_attr(GET_DICT(globals), i); if (idx == -1) { idx = dict_get_attr(GET_DICT(tm->builtins), i); if (idx == -1) { tm_raise("NameError: name %o is not defined", GET_CONST(i)); } else { Object value = GET_DICT(tm->builtins)->nodes[idx].val; // OPTIMIZE // set the builtin to `globals()` obj_set(globals, GET_CONST(i), value); idx = dict_get_attr(GET_DICT(globals), i); pc[0] = OP_FAST_LD_GLO; code16(pc+1, idx); // OPTIMIZE END TM_PUSH(value); } } else { TM_PUSH(GET_DICT(globals)->nodes[idx].val); pc[0] = OP_FAST_LD_GLO; code16(pc+1, idx); } break; } case OP_STORE_GLOBAL: { x = TM_POP(); int idx = dict_set_attr(GET_DICT(globals), i, x); pc[0] = OP_FAST_ST_GLO; code16(pc+1, idx); break; } case OP_FAST_LD_GLO: { TM_PUSH(GET_DICT(globals)->nodes[i].val); break; } case OP_FAST_ST_GLO: { GET_DICT(globals)->nodes[i].val = TM_POP(); break; } case OP_LIST: { TM_PUSH(list_new(2)); FRAME_CHECK_GC(); break; } case OP_APPEND: v = TM_POP(); x = TM_TOP(); tm_assert(IS_LIST(x), "tm_eval: OP_APPEND require list"); list_append(GET_LIST(x), v); break; case OP_DICT_SET: v = TM_POP(); k = TM_POP(); x = TM_TOP(); tm_assert(IS_DICT(x), "tm_eval: OP_DICT_SET require dict"); obj_set(x, k, v); break; case OP_DICT: { TM_PUSH(dict_new()); FRAME_CHECK_GC(); break; } TM_OP(OP_ADD, obj_add) TM_OP(OP_SUB, obj_sub) TM_OP(OP_MUL, obj_mul) TM_OP(OP_DIV, obj_div) TM_OP(OP_MOD, obj_mod) TM_OP(OP_GET, obj_get) case OP_SLICE: { Object second = TM_POP(); Object first = TM_POP(); *top = obj_slice(*top, first, second); break; } case OP_EQEQ: { *(top-1) = tm_number(obj_equals(*(top-1), *top)); top--; break; } case OP_NOTEQ: { *(top-1) = tm_number(!obj_equals(*(top-1), *top)); top--; break; } case OP_LT: { *(top-1) = tm_number(obj_cmp(*(top-1), *top)<0); top--; break; } case OP_LTEQ: { *(top-1) = tm_number(obj_cmp(*(top-1), *top)<=0); top--; break; } case OP_GT: { *(top-1) = tm_number(obj_cmp(*(top-1), *top)>0); top--; break; } case OP_GTEQ: { *(top-1) = tm_number(obj_cmp(*(top-1), *top)>=0); top--; break; } case OP_IN: { *(top-1) = tm_number(obj_in(*(top-1), *top)); top--; break; } case OP_AND: { *(top-1) = tm_number(is_true_obj(*(top-1)) && is_true_obj(*top)); top--; break; } case OP_OR: { *(top-1) = tm_number(is_true_obj(*(top-1)) || is_true_obj(*top)); top--; break; } case OP_NOT:{ *top = tm_number(!is_true_obj(*top)); break; } case OP_SET: k = TM_POP(); x = TM_POP(); v = TM_POP(); #if INTERP_DB tm_printf("Self %o, Key %o, Val %o\n", x, k, v); #endif obj_set(x, k, v); break; case OP_POP: { top--; break; } case OP_NEG: TM_TOP() = obj_neg(TM_TOP()); break; case OP_CALL: { f->top = top; top -= i; arg_set_arguments(top + 1, i); Object func = TM_POP(); TM_PUSH(call_function(func)); // TM_PUSH(call_function(func)); tm->frame = f; FRAME_CHECK_GC(); break; } case OP_APPLY: { f->top = top; Object args = TM_POP(); tm_assert_type(args, TYPE_LIST, "tm_eval: OP_APPLY"); arg_set_arguments(LIST_NODES(args), LIST_LEN(args)); Object func = TM_POP(); x = call_function(func); TM_PUSH(x); tm->frame = f; FRAME_CHECK_GC(); break; } case OP_LOAD_PARAMS: { int parg = pc[1]; int varg = pc[2]; if (tm->arg_cnt < parg || tm->arg_cnt > parg + varg) { tm_raise("ArgError,parg=%d,varg=%d,given=%d", parg, varg, tm->arg_cnt); } for(i = 0; i < tm->arg_cnt; i++){ locals[i] = tm->arguments[i]; } break; } case OP_LOAD_PARG: { int parg = i; for (i = 0; i < parg; i++) { locals[i] = arg_take_obj(func_name_sz); } break; } case OP_LOAD_NARG: { int arg_index = i; Object list = list_new(tm->arg_cnt); while (arg_remains() > 0) { obj_append(list, arg_take_obj(func_name_sz)); } locals[arg_index] = list; break; } case OP_ITER: { *top = iter_new(*top); break; } case OP_NEXT: { Object *next = next_ptr(*top); if (next != NULL) { TM_PUSH(*next); break; } else { pc += i * 3; continue; } break; } case OP_DEF: { Object mod = GET_FUNCTION(cur_fnc)->mod; Object fnc = func_new(mod, NONE_OBJECT, NULL); pc = func_resolve(GET_FUNCTION(fnc), pc); GET_FUNCTION_NAME(fnc) = GET_CONST(i); TM_PUSH(fnc); continue; } case OP_RETURN: { ret = TM_POP(); goto end; } case OP_ROT: { int half = i / 2; int j; for (j = 0; j < half; j++) { Object temp = *(top - j); *(top-j) = *(top - i + j + 1); *(top-i+j+1) = temp; } break; } case OP_UNPACK: { x = TM_POP(); tm_assert_type(x, TYPE_LIST, "tm_eval:UNPACK"); int j; for(j = LIST_LEN(x)-1; j >= 0; j--) { TM_PUSH(LIST_GET(x, j)); } break; } case OP_DEL: { k = TM_POP(); x = TM_POP(); obj_del(x, k); break; } case OP_POP_JUMP_ON_FALSE: { if (!is_true_obj(TM_POP())) { pc += i * 3; continue; } break; } case OP_JUMP_ON_TRUE: { if (is_true_obj(TM_TOP())) { pc += i * 3; continue; } break; } case OP_JUMP_ON_FALSE: { if (!is_true_obj(TM_TOP())) { pc += i * 3; continue; } break; } case OP_UP_JUMP: pc -= i * 3; continue; case OP_JUMP: pc += i * 3; continue; case OP_EOP: case OP_EOF: { ret = NONE_OBJECT; goto end; } case OP_LOAD_EX: { top = f->last_top; TM_PUSH(tm->ex); break; } case OP_SETJUMP: { f->last_top = top; f->jmp = pc + i * 3; break; } case OP_CLR_JUMP: { f->jmp = NULL; break;} case OP_LINE: { f->lineno = i; break;} case OP_DEBUG: { #if 0 Object fdebug = tm_get_global(globals, "__debug__"); f->top = top; tm_call(0, fdebug, 1, tm_number(tm->frame - tm->frames)); break; #endif } case OP_FILE: { // module name here. break; } default: tm_raise("BAD INSTRUCTION, %d\n globals() = \n%o", pc[0], GET_FUNCTION_GLOBALS(f->fnc)); goto end; } pc += 3; } end: /* if (top != f->stack) { tm_raise("tm_eval: operand stack overflow"); }*/ pop_frame(); return ret; }