int FL_ChipErase(U32 FAdr) { U32 aAdr; U16 TDat; FAdr = PHYSICAL_ADR(FAdr); aAdr = FAdr & VALADRBITS; GenerateSequence( FAdr, SecEraCmd1); GenerateSequence( FAdr, ChpEraCmd2); do { TDat = RdDatMemWord( aAdr); //EbPrCStrHex8((CSTR*)"\n ->Rd1Back:",TDat); if (TDat&0x0080) { FastReset(aAdr); // Terminate AutoMode return 0; } else if ((TDat&0x0028)==0x0028) { FastReset(aAdr); // Terminate AutoMode return -1; // Failure Case } } while (1); }
void LaunchSeqScan(std::unique_ptr<storage::DataTable> &hyadapt_table) { auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); std::unique_ptr<executor::ExecutorContext> context( new executor::ExecutorContext(txn)); // Column ids to be added to logical tile after scan. std::vector<oid_t> column_ids; std::vector<oid_t> hyadapt_column_ids; oid_t query_column_count = projectivity * column_count; GenerateSequence(hyadapt_column_ids, query_column_count); for (oid_t col_itr = 0; col_itr < query_column_count; col_itr++) { column_ids.push_back(hyadapt_column_ids[col_itr]); } // Create and set up seq scan executor auto predicate = GetPredicate(); planner::IndexScanPlan::IndexScanDesc dummy_index_scan_desc; planner::HybridScanPlan hybrid_scan_node(hyadapt_table.get(), predicate, column_ids, dummy_index_scan_desc, HybridScanType::SEQUENTIAL); executor::HybridScanExecutor hybrid_scan_executor(&hybrid_scan_node, context.get()); ExecuteTest(&hybrid_scan_executor); txn_manager.CommitTransaction(txn); }
int FL_GetSectProt(U32 FAdr) { U32 aAdr; U16 Flag; FAdr = PHYSICAL_ADR(FAdr); GenerateSequence( FAdr, AutoSelCmd); aAdr = FAdr & VALADRBITS; aAdr |= LoAdrxx02; Flag = RdDatMemWord( aAdr); /* Protect Bit Status */ FastReset(FAdr); /* Terminate AutoMode */ return Flag; }
int FL_SectorErase(U32 FAdr) { U32 aAdr; U16 TDat; U32 TimeOut; FAdr = PHYSICAL_ADR(FAdr); aAdr = FAdr & VALADRBITS; GenerateSequence( aAdr, SecEraCmd1); GenerateSequence( FAdr, SecEraCmd2); TimeOut = 0x01000000; do { TDat = RdDatMemWord( FAdr); if (TDat==0xFFFF) { FastReset(aAdr); /* Terminate AutoMode */ return 0; } } while (TimeOut--); return 1; }
void SuffixArrayMain(int NumSeq, int SeqLen, int KLet) { GenerateSuffixList(); srand(time(NULL)); string Sequence; int c=0; while (c < NumSeq) { Sequence = GenerateSequence(SeqLen,KLet); if (!Sequence.empty()) { c++; } } }
void be_sequence::Generate (be_ClientHeader& source) { DDS_StdString scopedName = typeName; if (BE_Globals::ignore_interfaces && IsInterfaceDependant ()) { return; } if (Generated ()) { return; } if (anonymous && !isPrimitiveSeq && !isStringSeq && (!baseType->IsSequenceType () || generatedSequences.find (baseType->TypeName ()) == generatedSequences.end ())) { be_root::DeferSequence (this); deferred = pbtrue; return; } if (generatedSequences.find (scopedName) == generatedSequences.end ()) { Generated (pbtrue); generatedSequences[scopedName] = scopedName; if (anonymous) { baseType->GenerateFwdDecls (source); } GenerateSequence (source); GenerateAuxTypes (source); be_root::AddStreamOps (*this); be_root::AddAnyOps (*this); be_root::AddPutGetOps (*this); be_root::AddImplementations (*this); be_root::AddTypedef (*this); be_root::AddTypecode (*this); } }
void LaunchHybridScan(std::unique_ptr<storage::DataTable> &hyadapt_table) { std::vector<oid_t> column_ids; std::vector<oid_t> column_ids_second; oid_t query_column_count = projectivity * column_count; std::vector<oid_t> hyadapt_column_ids; GenerateSequence(hyadapt_column_ids, query_column_count); for (oid_t col_itr = 0; col_itr < query_column_count; col_itr++) { column_ids.push_back(hyadapt_column_ids[col_itr]); column_ids_second.push_back(hyadapt_column_ids[col_itr]); } auto index = hyadapt_table->GetIndex(0); std::vector<oid_t> key_column_ids; std::vector<ExpressionType> expr_types; std::vector<type::Value> values; std::vector<expression::AbstractExpression *> runtime_keys; CreateIndexScanPredicate(key_column_ids, expr_types, values); planner::IndexScanPlan::IndexScanDesc index_scan_desc( index, key_column_ids, expr_types, values, runtime_keys); auto predicate = GetPredicate(); planner::HybridScanPlan hybrid_scan_plan(hyadapt_table.get(), predicate, column_ids_second, index_scan_desc, HybridScanType::HYBRID); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); auto txn = txn_manager.BeginTransaction(); std::unique_ptr<executor::ExecutorContext> context( new executor::ExecutorContext(txn)); executor::HybridScanExecutor hybrid_scan_executor(&hybrid_scan_plan, context.get()); ExecuteTest(&hybrid_scan_executor); txn_manager.CommitTransaction(txn); }
void be_sequence::Generate (be_ClientImplementation& source) { DDS_StdString scopedName = typeName; if (BE_Globals::ignore_interfaces && IsInterfaceDependant ()) { return; } if ( ! ( anonymous && !isPrimitiveSeq && !isStringSeq && !baseType->Generated() ) && (generatedSequencesInstantiations.find(scopedName) == generatedSequencesInstantiations.end())) { GenerateSequence(source); } }
/*---------------------------------------------------------------------------*/ OpU16 FL_WriteWord(U32 FAdr, U16 Data) { U32 WaitDelay; U32 TDat1; FAdr = PHYSICAL_ADR(FAdr); GenerateSequence( FAdr, ProgramCmd); WrDatMemWord(FAdr, Data); TDat1 = RdDatMemWord(FAdr); //PrCStrHex8((CSTR*)"\n ->Rd1Back:",TDat1); PrCStrHex8((CSTR*)" ->Rd2Back:",TDat2); PrCStrHex8((CSTR*)" ->Rd3Back:",TDat3); WaitDelay = 0x100000; do { TDat1 = RdDatMemWord(FAdr); if (TDat1==Data) WaitDelay = 0; else WaitDelay --; } while (WaitDelay); return TDat1; }
int FL_AutoSelect(U32 FAdr, U16 *MCode, U16 *DCode) { U32 aAdr; U16 Data; FAdr = PHYSICAL_ADR(FAdr); GenerateSequence( FAdr, AutoSelCmd); aAdr = FAdr & VALADRBITS; aAdr |= LoAdrxx00; Data = RdDatMemWord(aAdr); *MCode = Data; /* read device ID */ aAdr = FAdr & VALADRBITS; aAdr |= LoAdrxx01; Data = RdDatMemWord(aAdr); *DCode = Data; /* read Manufacture Code */ FastReset(FAdr); /* Terminate AutoMode */ return 1; }
// Main Entry Point void RunBenchmark() { // Initialize settings peloton_layout_mode = state.layout_mode; peloton_projectivity = state.projectivity; // Generate sequence GenerateSequence(state.column_count); // Single run if (state.experiment_type == EXPERIMENT_TYPE_INVALID) { CreateAndLoadTable((LayoutType)peloton_layout_mode); switch (state.operator_type) { case OPERATOR_TYPE_DIRECT: RunDirectTest(); break; case OPERATOR_TYPE_AGGREGATE: RunAggregateTest(); break; case OPERATOR_TYPE_ARITHMETIC: RunArithmeticTest(); break; case OPERATOR_TYPE_JOIN: RunJoinTest(); break; default: std::cout << "Unsupported test type : " << state.operator_type << "\n"; break; } } // Experiment else { switch (state.experiment_type) { case EXPERIMENT_TYPE_PROJECTIVITY: RunProjectivityExperiment(); break; case EXPERIMENT_TYPE_SELECTIVITY: RunSelectivityExperiment(); break; case EXPERIMENT_TYPE_OPERATOR: RunOperatorExperiment(); break; case EXPERIMENT_TYPE_VERTICAL: RunVerticalExperiment(); break; case EXPERIMENT_TYPE_SUBSET: RunSubsetExperiment(); break; case EXPERIMENT_TYPE_ADAPT: RunAdaptExperiment(); break; case EXPERIMENT_TYPE_WEIGHT: RunWeightExperiment(); break; case EXPERIMENT_TYPE_REORG: RunReorgExperiment(); break; case EXPERIMENT_TYPE_DISTRIBUTION: RunDistributionExperiment(); break; case EXPERIMENT_TYPE_JOIN: RunJoinExperiment(); break; case EXPERIMENT_TYPE_INSERT: RunInsertExperiment(); break; case EXPERIMENT_TYPE_VERSION: RunVersionExperiment(); break; case EXPERIMENT_TYPE_HYRISE: RunHyriseExperiment(); break; case EXPERIMENT_TYPE_CONCURRENCY: RunConcurrencyExperiment(); break; default: std::cout << "Unsupported experiment type : " << state.experiment_type << "\n"; break; } } }
int SynthProject::Generate(int todisk, long from, long to) { SeqState oldState = seq.GetState(); if (oldState != seqOff) Stop(); mixInfo->InitMixer(); if (todisk) return GenerateToFile(from, to); long nbuf = 4; if (prjOptions.playBuf < 0.01) prjOptions.playBuf = 0.01; #ifdef _WIN32 WaveOutDirect wvd; if (wvd.Setup(fl_xid(mainWnd), prjOptions.playBuf, nbuf)) return -1; #endif #ifdef UNIX WaveOutALSA wvd; if (wvd.Setup(prjOptions.waveDevice, prjOptions.playBuf, nbuf)) return -1; #endif mgr.Init(&mix, &wvd); nlConverter cvt; cvt.SetInstrManager(&mgr); cvt.SetSequencer(&seq); cvt.SetSampleRate(synthParams.sampleRate); if (GenerateSequence(cvt)) return -1; if (prjGenerate) prjGenerate->AddMessage("Start sequencer..."); if (theProject->prjMidiIn.IsOn()) oldState |= seqPlay; // Generate the output... wop = &wvd; bsInt32 fromSamp = from*synthParams.isampleRate; bsInt32 toSamp = to*synthParams.isampleRate; if (seq.GetTrackCount() > 1 || oldState & seqPlay) seq.SequenceMulti(mgr, fromSamp, toSamp, seqSeqOnce | (oldState & seqPlay)); else seq.Sequence(mgr, fromSamp, toSamp); wop = 0; AmpValue lv, rv; long pad = (long) (synthParams.sampleRate * prjOptions.playBuf) * nbuf; while (pad-- > 0) { mix.Out(&lv, &rv); wvd.Output2(lv, rv); } wvd.Shutdown(); // re-initialize in case of dynamic mixer control changes mixInfo->InitMixer(); return 0; }