Word restoreValue(Fragment *F, Word *vals, IRRef ref) { IRIns *ir = IR(ref); HeapInfo *hp; Closure *cl; int j; // We only need to treat allocations specially. if (ir->o != IR_NEW) return vals[ref]; hp = &F->heap[ir->op2]; // Store has *not* been sunken, i.e., allocation occurred on-trace if (!ir_issunken(ir)) return vals[ref]; // Otherwise we need to do the allocation now, possibly recursively // // TODO: Can we have mutually recursive sunken refs? recordEvent(EV_ALLOC, 1 + hp->nfields); cl = allocClosure(wordsof(ClosureHeader) + hp->nfields); setInfo(cl, (InfoTable*)vals[ir->op1]); DBG_PR("(alloc[%lu])", wordsof(ClosureHeader) + hp->nfields); for (j = 0; j < hp->nfields; j++) cl->payload[j] = restoreValue(F, vals, getHeapInfoField(F, hp, j)); return (Word)cl; }
bool RestoreTask::performTask() { Logger l( className(), "performTask" ); int index = 0; if( _I(_data_set[0]["normalized"]) ){ Logger::log_info("Data was normalized")(); try{ while( valid_for_normalizing_column[index] != _IND(DatabaseColumnFinal) ) { Logger::log_info(valid_for_normalizing_column[index])(); DataSet::Type type = _data_set[1][valid_for_normalizing_column[index]].getType(); Logger::log_info( " -> RestoreTask::restoreValue" ); Logger::log_info_end(); for( int i = 1; i < _data_set.size(); i++ ) { if( type == DataSet::TypeInt ) _data_set[i][valid_for_normalizing_column[index]] = restoreValue( _I(_data_set[i][valid_for_normalizing_column[index]]), _minmax[valid_for_normalizing_column[index]]); else if( type == DataSet::TypeDouble ) _data_set[i][valid_for_normalizing_column[index]] = restoreValue( _D(_data_set[i][valid_for_normalizing_column[index]]), _minmax[valid_for_normalizing_column[index]]); } Logger::log_info( " <- RestoreTask::restoreValue" ); Logger::log_info_end(); index++; } } catch( Exception &e ){ Logger::log_except( "Problem performing RestoreTask", e.what() ); return false; } catch( ... ){ Logger::log_except( "Problem performing RestoreTask" ); return false; } } else{ Logger::log_info("Data wasn't normalized")(); } return true; }
/** * restore_model() - construct an SVM "MODEL" structure from the given * MEX structure. */ MODEL *restore_model(const mxArray *mxStruct ) { char strPtr[KPARM_CUSTOM_LEN],*buff; long words, doc; mxArray *kstruct,*kstring,*svec; MODEL *model = NULL; KERNEL_PARM *kparm; int buflen; model = (MODEL *)my_malloc(sizeof(MODEL)); model->sv_num = (long) restoreValue(mxStruct,"sv_num"); model->at_upper_bound = (long) restoreValue(mxStruct,"upper_bound"); model->b = restoreValue(mxStruct,"b"); model->totwords = (long) restoreValue(mxStruct, "totwords"); model->totdoc = (long) restoreValue(mxStruct, "totdoc"); model->loo_error = restoreValue(mxStruct, "loo_error"); model->loo_recall = restoreValue(mxStruct, "loo_recall"); model->xa_error = restoreValue(mxStruct, "xa_error"); model->xa_recall = restoreValue(mxStruct, "xa_recall"); model->xa_precision = restoreValue(mxStruct, "xa_precision"); model->maxdiff = restoreValue(mxStruct, "maxdiff"); model->r_delta_sq = restoreValue(mxStruct, "r_delta_sq"); model->r_delta_avg = restoreValue(mxStruct, "r_delta_avg"); model->model_length = restoreValue(mxStruct, "model_length"); model->loss = restoreValue(mxStruct, "loss"); model->vcdim = restoreValue(mxStruct, "vcdim"); model->alpha = restoreArray(mxStruct, "alpha"); model->lin_weights = restoreArray(mxStruct, "lin_weights"); model->index = restoreArrayLong(mxStruct, "index"); kstruct = mxGetField(mxStruct, 0, "kernel_parm"); kparm = &(model->kernel_parm); kparm->kernel_type = (long) restoreValue(kstruct,"kernel_type"); kparm->poly_degree = (long) restoreValue(kstruct,"poly_degree"); kparm->rbf_gamma = (double) restoreValue(kstruct,"rbf_gamma"); kparm->coef_lin = (double) restoreValue(kstruct,"coef_lin"); kparm->coef_const = (double) restoreValue(kstruct,"coef_const"); kstring = mxGetField(kstruct,0,"custom"); buflen = (mxGetM(kstring) * mxGetN(kstring) * sizeof(mxChar)) + 2; buff = my_malloc(buflen); mxGetString(kstring,buff, buflen); strcpy((*kparm).custom, buff); my_free(buff); /* if (model->supvec != NULL) { */ svec = mxGetField(mxStruct,0,"supvec"); if (svec == NULL) { printf("Warning: supvec field was not found."); } else { mexToDOC(svec, NULL, &model->supvec, NULL, NULL, NULL); } return model; }
void DesignerSettings::fromSettings(QSettings *settings) { settings->beginGroup(QLatin1String(DesignerSettingsGroupKey::QML_SETTINGS_GROUP)); settings->beginGroup(QLatin1String(DesignerSettingsGroupKey::QML_DESIGNER_SETTINGS_GROUP)); restoreValue(settings, DesignerSettingsKey::ITEMSPACING, 6); restoreValue(settings, DesignerSettingsKey::CONTAINERPADDING, 8); restoreValue(settings, DesignerSettingsKey::CANVASWIDTH, 10000); restoreValue(settings, DesignerSettingsKey::CANVASHEIGHT, 10000); restoreValue(settings, DesignerSettingsKey::ROOT_ELEMENT_INIT_WIDTH, 640); restoreValue(settings, DesignerSettingsKey::ROOT_ELEMENT_INIT_HEIGHT, 480); restoreValue(settings, DesignerSettingsKey::WARNING_FOR_FEATURES_IN_DESIGNER, true); restoreValue(settings, DesignerSettingsKey::WARNING_FOR_QML_FILES_INSTEAD_OF_UIQML_FILES, true); restoreValue(settings, DesignerSettingsKey::WARNING_FOR_DESIGNER_FEATURES_IN_EDITOR, false); restoreValue(settings, DesignerSettingsKey::SHOW_DEBUGVIEW, false); restoreValue(settings, DesignerSettingsKey::ENABLE_DEBUGVIEW, false); restoreValue(settings, DesignerSettingsKey::ALWAYS_SAFE_IN_CRUMBLEBAR, false); restoreValue(settings, DesignerSettingsKey::USE_ONLY_FALLBACK_PUPPET, true); restoreValue(settings, DesignerSettingsKey::TYPE_OF_QSTR_FUNCTION, 0); restoreValue(settings, DesignerSettingsKey::PUPPET_FALLBACK_DIRECTORY); restoreValue(settings, DesignerSettingsKey::PUPPET_TOPLEVEL_BUILD_DIRECTORY); restoreValue(settings, DesignerSettingsKey::CONTROLS_STYLE); restoreValue(settings, DesignerSettingsKey::SHOW_PROPERTYEDITOR_WARNINGS, false); restoreValue(settings, DesignerSettingsKey::ENABLE_MODEL_EXCEPTION_OUTPUT, false); restoreValue(settings, DesignerSettingsKey::PUPPET_KILL_TIMEOUT, 3000); // this has no ui at the moment restoreValue(settings, DesignerSettingsKey::DEBUG_PUPPET, QString()); restoreValue(settings, DesignerSettingsKey::FORWARD_PUPPET_OUTPUT, QString()); restoreValue(settings, DesignerSettingsKey::REFORMAT_UI_QML_FILES, true); restoreValue(settings, DesignerSettingsKey::IGNORE_DEVICE_PIXEL_RATIO, false); restoreValue(settings, DesignerSettingsKey::STATESEDITOR_EXPANDED, true); restoreValue(settings, DesignerSettingsKey::NAVIGATOR_SHOW_ONLY_VISIBLE_ITEMS, true); restoreValue(settings, DesignerSettingsKey::STANDALONE_MODE, false); settings->endGroup(); settings->endGroup(); }
int irEngine(Capability *cap, Fragment *F) { static Inst disp[] = { #define IRIMPL(name, f, o1, o2) &&op_##name, IRDEF(IRIMPL) #undef IRIMPL &&stop }; IRRef ref; Thread *T = cap->T; Word nphis = F->nphis; Word *base = T->base - 1; Word szins = F->nins - F->nk; Word vals_[szins + nphis]; Word *phibuf = &vals_[szins]; /* For parallel copy of PHI nodes */ Word *vals = vals_ - (int)F->nk; IRIns *pc = F->ir + REF_FIRST; IRRef pcref = REF_FIRST; IRIns *pcmax = F->ir + F->nins; IRIns *pcloop = F->nloop ? F->ir + F->nloop + 1 : pc; //int count = 100; DBG_PR("*** Executing trace.\n" "*** base = %p\n" "*** pc = %p\n" "*** pcmax = %p (%d)\n" "*** loop = %p (%d)\n", base, pc, pcmax, (int)(pcmax - pc), pcloop, (int)(pcloop - pc)); for (ref = F->nk; ref < REF_BIAS; ref++) { switch (IR(ref)->o) { case IR_KINT: vals[ref] = (Word)IR(ref)->i; break; case IR_KBASEO: vals[ref] = (Word)(T->base + IR(ref)->i); break; case IR_KWORD: vals[ref] = (Word)(F->kwords[IR(ref)->u]); break; default: LC_ASSERT(0); break; } DBG_LVL(2, "%d, %" FMT_WordX "\n", ref - REF_BIAS, vals[ref]); } vals[REF_BASE] = (Word)base; goto *disp[pc->o]; # define DISPATCH_NEXT \ if (irt_type(pc->t) != IRT_VOID && pc->o != IR_PHI) { \ if (irt_type(pc->t) == IRT_I32) \ DBG_LVL(2, " ===> %" FMT_Int "\n", vals[pcref]); \ else \ DBG_LVL(2, " ===> 0x%" FMT_WordX "\n", vals[pcref]); } \ ++pc; ++pcref; \ if (LC_UNLIKELY(pc >= pcmax)) { pc = pcloop; pcref = F->nloop + 1; } \ if (pc->o != IR_NOP) { \ DBG_LVL(2, "[%d] ", pcref - REF_BIAS); \ IF_DBG_LVL(2, printIR(F, *pc)); } \ goto *disp[pc->o] op_NOP: op_FRAME: op_RET: op_LOOP: DISPATCH_NEXT; op_PHI: { /* PHI nodes represent parallel assignments, so as soon as we discover the first PHI node, we perform all assignments in parallel. */ LC_ASSERT(nphis > 0); u2 i; DBG_LVL(3, " ( "); for (i = 0; i < nphis; i++) { DBG_LVL(3, "%d ", irref_int(pc[i].op2)); phibuf[i] = vals[pc[i].op2]; } DBG_LVL(3, ") --> ( "); for (i = 0; i < nphis; i++) { DBG_LVL(3, "%d ", irref_int(pc[i].op1)); vals[pc[i].op1] = phibuf[i]; } DBG_LVL(3, ") [%d phis]\n", (int)nphis); pc += nphis - 1; //vals[pc->op1] = vals[pc->op2]; DISPATCH_NEXT; } op_LT: recordEvent(EV_CMP, 0); if (!((WordInt)vals[pc->op1] < (WordInt)vals[pc->op2])) goto guard_failed; DISPATCH_NEXT; op_GE: recordEvent(EV_CMP, 0); if (!((WordInt)vals[pc->op1] >= (WordInt)vals[pc->op2])) goto guard_failed; DISPATCH_NEXT; op_LE: recordEvent(EV_CMP, 0); if (!((WordInt)vals[pc->op1] <= (WordInt)vals[pc->op2])) goto guard_failed; DISPATCH_NEXT; op_GT: recordEvent(EV_CMP, 0); if (!((WordInt)vals[pc->op1] > (WordInt)vals[pc->op2])) goto guard_failed; DISPATCH_NEXT; op_EQ: recordEvent(EV_CMP, 0); if (!((WordInt)vals[pc->op1] == (WordInt)vals[pc->op2])) { goto guard_failed; } DISPATCH_NEXT; op_NE: recordEvent(EV_CMP, 0); if (!((WordInt)vals[pc->op1] != (WordInt)vals[pc->op2])) goto guard_failed; DISPATCH_NEXT; op_ADD: recordEvent(EV_ALU, 0); vals[pcref] = vals[pc->op1] + vals[pc->op2]; DISPATCH_NEXT; op_SUB: recordEvent(EV_ALU, 0); vals[pcref] = vals[pc->op1] - vals[pc->op2]; DISPATCH_NEXT; op_MUL: recordEvent(EV_MUL, 0); vals[pcref] = (WordInt)vals[pc->op1] * (WordInt)vals[pc->op2]; DISPATCH_NEXT; op_DIV: recordEvent(EV_REMDIV, 0); if (LC_LIKELY(vals[pc->op2] != 0)) vals[pcref] = (WordInt)vals[pc->op1] / (WordInt)vals[pc->op2]; else LC_ASSERT(0); DISPATCH_NEXT; op_REM: recordEvent(EV_REMDIV, 0); if (LC_LIKELY(vals[pc->op2] != 0)) vals[pcref] = (WordInt)vals[pc->op1] % (WordInt)vals[pc->op2]; else LC_ASSERT(0); DISPATCH_NEXT; op_FREF: vals[pcref] = (Word)(((Closure*)vals[pc->op1])->payload + (pc->op2 - 1)); DISPATCH_NEXT; op_FLOAD: recordEvent(EV_LOAD, 0); vals[pcref] = *((Word*)vals[pc->op1]); DISPATCH_NEXT; op_SLOAD: recordEvent(EV_LOAD, 0); vals[pcref] = base[pc->op1]; DISPATCH_NEXT; op_ILOAD: recordEvent(EV_LOAD, 0); vals[pcref] = (Word)getInfo(vals[pc->op1]); DISPATCH_NEXT; op_NEW: if (!ir_issunken(pc)) { // do actual allocation on trace HeapInfo *hp = &F->heap[pc->op2]; int j; recordEvent(EV_ALLOC, hp->nfields + 1); Closure *cl = allocClosure(wordsof(ClosureHeader) + hp->nfields); setInfo(cl, (InfoTable*)vals[pc->op1]); for (j = 0; j < hp->nfields; j++) { cl->payload[j] = vals[getHeapInfoField(F, hp, j)]; } vals[pcref] = (Word)cl; } else { vals[pcref] = 0; // to trigger an error if accessed } DISPATCH_NEXT; op_UPDATE: { recordEvent(EV_UPDATE, 0); Closure *oldnode = (Closure *)vals[pc->op1]; Closure *newnode = (Closure *)base[pc->op2]; setInfo(oldnode, (InfoTable*)&stg_IND_info); oldnode->payload[0] = (Word)newnode; DISPATCH_NEXT; } op_RLOAD: op_FSTORE: op_RENAME: op_BNOT: op_BAND: op_BOR: op_BXOR: op_BSHL: op_BSHR: op_BSAR: op_BROL: op_BROR: // These should never be executed. op_BASE: op_KINT: op_KWORD: op_KBASEO: LC_ASSERT(0); guard_failed: DBG_PR("Exiting at %d\n", pcref - REF_BIAS); { int i; SnapShot *snap = 0; SnapEntry *se; for (i = 0; i < F->nsnap; i++) { if (F->snap[i].ref == pcref) { snap = &F->snap[i]; break; } } LC_ASSERT(snap != 0); snap->count++; se = F->snapmap + snap->mapofs; DBG_PR("Snapshot: %d, Snap entries: %d, slots = %d\n", i, snap->nent, snap->nslots); recordEvent(EV_EXIT, snap->nent); for (i = 0; i < snap->nent; i++, se++) { BCReg s = snap_slot(*se); IRRef r = snap_ref(*se); DBG_PR("base[%d] = ", s - 1); base[s] = restoreValue(F, vals, r); IF_DBG_LVL(1, printSlot(stderr, base + s); fprintf(stderr, "\n")); //DBG_PR("0x%" FMT_WordX "\n", base[s]); } DBG_PR("Base slot: %d\n", se[1]); // se[1] = T->pc = (BCIns *)F->startpc + (int)se[0]; T->base = base + se[1]; T->top = base + snap->nslots; //printFrame(T->base, T->top); return 0; } stop: return 1; }