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