// TODO: we might want to use multiple buffers at the same time void Measurement::WriteDataBin(FILE *f, int channel) { Timing t; long size_written; int i, j; const unsigned int length_datachunk = 1000000; char data_8bit[1000000]; // std::vector<char>data_8bit(1000); std::cerr << "Write binary data for channel " << (char)('A'+channel) << " ... "; t.Start(); // TODO: test if file exists if(channel < 0 || channel >= GetNumberOfChannels()) { throw "You can only write data for channels 0 - (N-1)."; } else { if(GetChannel(channel)->IsEnabled()) { /* size_written = fwrite(data[channel], sizeof(short), GetLengthFetched(), f); // make sure the data is written fflush(f); if(size_written < GetLengthFetched()) { FILE_LOG(logERROR) << "Measurement::WriteDataBin didn't manage to write to file."; }*/ // TODO: if only 8 bits int length_fetched = GetLengthFetched(); // int length_datachunk = data_8bit.size(); for(i=0; i<length_fetched; i+=length_datachunk) { if(GetSeries() == PICO_6000) { for(j=0; j<length_datachunk && i+j<length_fetched; j++) { data_8bit[j] = data[channel][i+j] >> 8; } size_written = fwrite(data_8bit, sizeof(char), j, f); } else { // TODO: test!!! size_written = fwrite(data[channel]+1, sizeof(data[0][0]), j, f); } fflush(f); if(size_written < j) { FILE_LOG(logERROR) << "Measurement::WriteDataBin didn't manage to write to file."; } } // size_written = fwrite(data[channel], sizeof(short), GetLengthFetched(), f); // make sure the data is written // fflush(f); // if(size_written < GetLengthFetched()) { // FILE_LOG(logERROR) << "Measurement::WriteDataBin didn't manage to write to file."; // } } else {
void SolveTheBGIP(BGIP_sharedPtr bgip) { // Specify the solution method. // (See above and in BGIP_SolverType.h) BGIP_SolverType::BGIP_Solver_t method = BGIP_SolverType::AM; try { Timing timer; timer.Start( SoftPrint(method) ); BayesianGameIdenticalPayoffSolver * bgip_solver = NewBGIPSolver(bgip, method); cout << "running " << SoftPrint(method) << "..."<<endl; cout << "...value is " << bgip_solver->Solve() << endl; timer.Stop( SoftPrint(method) ); delete bgip_solver; } catch(E& e) { e.Print(); } }
int main(int argc, char** argv) { Timing t; int i; // TODO: debug should be enabled with a command-line option // FILELog::ReportingLevel() = FILELog::FromString("DEBUG4"); // FILELog::ReportingLevel() = FILELog::FromString("DEBUG1"); FILELog::ReportingLevel() = FILELog::FromString("INFO"); FILE_LOG(logDEBUG4) << "starting"; t.Start(); try { Picoscope6000 *pico = new Picoscope6000(); Measurement *meas = new Measurement(pico); Channel *ch[4]; meas->SetTimebaseInPs(400); meas->EnableChannels(true,false,false,false); for(i=0; i<PICOSCOPE_N_CHANNELS; i++) { ch[i] = meas->GetChannel(i); FILE_LOG(logDEBUG4) << "main - Channel " << (char)('A'+i) << " has index " << ch[i]->GetIndex(); } Args x; x.parse_options(argc, argv, meas); if(x.IsJustHelp()) { return 0; } if(x.GetFilename() == NULL) { // TODO: maybe we want to use just text file throw("You have to provide some filename using '--name <filename>'.\n"); } // meas->SetTimebaseInPs(10000); // TODO: fixme for(i=0; i<PICOSCOPE_N_CHANNELS; i++) { ch[i]->SetVoltage(x.GetVoltage()); } // a->SetVoltage(U_100mV); // a[0]->SetVoltage(x.GetVoltage()); // meas->SetLength(GIGA(1)); meas->SetLength(x.GetLength()); if(x.GetNTraces() > 1) { meas->SetNTraces(x.GetNTraces()); // TODO: fix trigger FILE_LOG(logDEBUG4) << "main - checking for triggered events"; if(x.IsTriggered()) { for(i=0; i<PICOSCOPE_N_CHANNELS && !(ch[i]->IsEnabled()); i++); FILE_LOG(logDEBUG4) << "main - will trigger on channel " << (char)('A'+i); meas->SetTrigger(x.GetTrigger(ch[i])); } meas->AllocateMemoryRapidBlock(MEGA(50)); } else { meas->AllocateMemoryBlock(MEGA(50)); } // std::cerr << "test w5\n"; // it only makes sense to measure if we decided to use some positive number of samples if(x.GetLength()>0) { FILE *f = NULL; FILE *fb[4] = {NULL,NULL,NULL,NULL}, *ft[4] = {NULL,NULL,NULL,NULL}; struct tm *current; time_t now; time(&now); current = localtime(&now); for(i=0; i<PICOSCOPE_N_CHANNELS; i++) { if(ch[i]->IsEnabled()) { if(x.IsTextOutput()) { ft[i] = fopen(x.GetFilenameText(i), "wt"); if(ft[i] == NULL) { throw("Unable to open text file.\n"); // TODO: write filename } } if(x.IsBinaryOutput()) { fb[i] = fopen(x.GetFilenameBinary(i), "wb"); if(fb[i] == NULL) { throw("Unable to open binary file.\n"); // TODO: write filename } } } } /************************************************************/ double tmp_dbl; short tmp_short; pico->Open(); meas->InitializeSignalGenerator(); meas->RunBlock(); /* metadata */ f = fopen(x.GetFilenameMeta(), "wt"); if(f == NULL) { throw("Unable to open file with metadata.\n"); } fprintf(f, "command: "); for(i=0; i<argc; i++) { fprintf(f, " %s", argv[i]); } fprintf(f, "\n"); fprintf(f, "timestamp: %d-%02d-%02d %02d:%02d:%02d\n\n", current->tm_year+1900, current->tm_mon+1, current->tm_mday, current->tm_hour, current->tm_min, current->tm_sec); fprintf(f, "channels: "); for(i=0; i<PICOSCOPE_N_CHANNELS; i++) { if(ch[i]->IsEnabled()) { fprintf(f, "%c", 'A'+i); } } fprintf(f, "\n"); fprintf(f, "length: %ld\n", x.GetLength()); fprintf(f, "samples: %ld\n", x.GetNTraces()); // fprintf(f, "unit_x: %.1lf ns | %.1lf ns\n", meas->GetTimebaseInNs(), meas->GetReportedTimebaseInNs()); tmp_dbl = meas->GetTimebaseInNs(); fprintf(f, "unit_x: %.1lf ns\n", tmp_dbl); fprintf(f, "range_x: %.1lf ns\n", x.GetLength()*tmp_dbl); tmp_dbl = x.GetVoltageDouble(); fprintf(f, "unit_y: %.10le V\n", tmp_dbl*3.0757874015748e-5); // 1/(127*256) actually, but this might have to be fixed for series 4000 fprintf(f, "range_y: %g V\n", tmp_dbl); if(x.GetNTraces() > 1) { if(x.IsTriggered()) { fprintf(f, "trigger_ch: %c\n", (char)(meas->GetTrigger()->GetChannel()->GetIndex()+'A')); // fprintf(f, "trigger_xfrac: %g\n", meas->GetTrigger()->GetXFraction()); // fprintf(f, "trigger_yfrac: %g\n", meas->GetTrigger()->GetYFraction()); fprintf(f, "trigger_dx: %d (%g %% of %ld)\n", meas->GetLengthBeforeTrigger(), meas->GetLengthBeforeTrigger()*100.0/x.GetLength(), x.GetLength()); tmp_short = meas->GetTrigger()->GetThreshold(); tmp_dbl = meas->GetTrigger()->GetYFraction(); fprintf(f, "trigger_dy: %g V (%d)\n", meas->GetTrigger()->GetThresholdInVolts() /*tmp_dbl*x.GetVoltageDouble()*/, tmp_short); } } // fprintf(f, "unit_x: %.1lf ns | %.1lf ns\n", meas->GetTimebaseInNs(), meas->GetReportedTimebaseInNs()); fprintf(f, "out_bin: %s\n", x.IsBinaryOutput() ? "yes" : "no"); fprintf(f, "out_dat: %s\n", x.IsTextOutput() ? "yes" : "no"); // triggered (TODO: we could also ask for a single triggered event) if(x.GetNTraces() > 1) { unsigned int run=0; for(run=0; run<x.GetNRepeats() && !_kbhit(); run++) { //FILE_LOG(logINFO) << "Running experiment nr. " << run+1; if(run>0) { cerr << "\nRepeat #" << run+1 << endl; meas->RunBlock(); } while(meas->GetNextDataBulk() > 0) { for(i=0; i<PICOSCOPE_N_CHANNELS; i++) { if(ch[i]->IsEnabled()) { if(x.IsTextOutput()) { meas->WriteDataTxt(ft[i], i); // zero for channel A } if(x.IsBinaryOutput()) { meas->WriteDataBin(fb[i], i); // zero for channel A } } } } } if(run>1) { fprintf(f, "repeats: %u\n", run); } // tmp_dbl = meas->GetRatePerSecond(); // fprintf(f, "\nrate: \n"); // if(fabs(tmp_dbl) > 1e6) { // fprintf(f, "%.3f MS/s\n", tmp_dbl*1e-6); // } else if(fabs(tmp_dbl) > 1e3) { // fprintf(f, "%.3f kS/s\n", tmp_dbl*1e-3); // } else { // fprintf(f, "%f S/s\n", tmp_dbl); // } } else { unsigned int run=0; for(run=0; run<x.GetNRepeats() && !_kbhit(); run++) { if(run>0) { cerr << "\nRepeat #" << run+1 << endl; meas->RunBlock(); } while(meas->GetNextData() > 0) { for(i=0; i<PICOSCOPE_N_CHANNELS; i++) { if(ch[i]->IsEnabled()) { if(x.IsTextOutput()) { meas->WriteDataTxt(ft[i], i); // zero for channel A } if(x.IsBinaryOutput()) { meas->WriteDataBin(fb[i], i); // zero for channel A } } } } } if(run>1) { fprintf(f, "repeats: %u\n", run); } } fclose(f); for(i=0; i<PICOSCOPE_N_CHANNELS; i++) { if(ft[i] != NULL) { fclose(ft[i]); } if(fb[i] != NULL) { fclose(fb[i]); } } // apparently this doesn't work for some weird reason // meas->RunBlock(); meas->GetNextData(); // meas->RunBlock(); meas->GetNextData(); // meas->RunBlock(); meas->GetNextData(); // meas->RunBlock(); meas->GetNextData(); pico->Close(); t.Stop(); cerr << "Timing: " << t.GetSecondsDouble() << "s\n"; } delete pico; pico = NULL; delete meas; meas = NULL; } catch(Picoscope::PicoscopeException& ex) { cerr << "Some picoscope exception:" << endl << "Error number " << ex.GetErrorNumber() << ": " << ex.GetErrorMessage() << endl << '(' << ex.GetVerboseErrorMessage() << ')' << endl; try { // pico.Close(); } catch(...) {} } catch(Picoscope::PicoscopeUserException& ex) { cerr << "Some exception:" << endl << ex.GetErrorMessage() << endl; // catch any exceptions } catch(const char* s) { cerr << "Some exception has occurred:\n" << s << endl; } catch (std::bad_alloc& ba) { std::cerr << "Exception: bad_alloc: " << ba.what() << endl; } catch (const std::exception &exc) { // catch anything thrown within try block that derives from std::exception std::cerr << "Exception: " << exc.what() << endl; } catch(...) { cerr << "Some exception has occurred" << endl; } return 0; }
int main(int argc, char **argv) { DecPOMDPDiscreteInterface* decpomdp; try { ArgumentHandlers::Arguments args; argp_parse (&ArgumentHandlers::theArgpStruc, argc, argv, 0, 0, &args); Timing times; times.Start("Parsing"); //DecPOMDPDiscreteInterface* decpomdp = GetDecPOMDPDiscreteInterfaceFromArgs(args); TransitionObservationIndependentMADPDiscrete *toi=0; if((toi=dynamic_cast<TransitionObservationIndependentMADPDiscrete*>(decpomdp)) && args.qheur==eQMDP && !args.cache_flat_models /* otherwise * GetDecPOMDPDiscreteInterfaceFromArgs * already caches the flat * models */) { // we don't need a centralized obs model toi->CreateCentralizedSparseTransitionModel(); } times.Stop("Parsing"); if(!args.dryrun) directories::MADPCreateResultsDir("GMAA",*decpomdp); size_t horizon; if(args.infiniteHorizon) horizon=MAXHORIZON; else horizon=args.horizon; times.Start("Overall"); PlanningUnitMADPDiscreteParameters params; #if 0 // Caching doesn't seem worth the trouble if we're computing // just one thing (not to mention the memory savings) if(Qheur==eQMDP) // don't need any of this for solving the MDP params.SetComputeAll(false); else { params.SetComputeAll(true); params.SetUseSparseJointBeliefs(true); } #else params.SetComputeAll(false); if(args.sparse) params.SetUseSparseJointBeliefs(true); #endif times.Start("PlanningUnit"); NullPlanner np(params,horizon,decpomdp); times.Stop("PlanningUnit"); struct timeval tvStart, tvEnd; gettimeofday (&tvStart, NULL); QFunctionJAOHInterface* q=0; for(int restartI = 0; restartI < args.nrRestarts; restartI++) { // with hybrid heuristics already some computation is done // before Compute(), so start timing now times.Start("ComputeQ"); q = GetQheuristicFromArgs(&np, args); q->Compute(); times.Stop("ComputeQ"); // we want to keep the last q computed if(restartI<(args.nrRestarts-1)) delete q; } gettimeofday (&tvEnd, NULL); clock_t wallclockTime = static_cast<clock_t>(((tvEnd.tv_sec - tvStart.tv_sec) + static_cast<double>(tvEnd.tv_usec-tvStart.tv_usec)/1e6) * sysconf(_SC_CLK_TCK)); cout << "Wallclock: from " << tvStart.tv_sec << "." << tvStart.tv_usec << " until " << tvEnd.tv_sec << "." << tvEnd.tv_usec << " which took " << wallclockTime << " clock ticks" << endl; times.AddEvent("WallclockTime", wallclockTime); if(!args.dryrun) { times.Start("Save"); q->Save(); times.Stop("Save"); if(args.verbose >= 0) cout << "Q saved to " << q->GetCacheFilename() << endl; } times.Stop("Overall"); if(args.verbose >= 0) times.PrintSummary(); if(!args.dryrun) { stringstream ss; ss << directories::MADPGetResultsDir("GMAA",*decpomdp) << "/calculateQheuristic" << q->SoftPrintBrief() << "_h" << horizon; if(decpomdp->GetDiscount()!=1) ss << "_g" << decpomdp->GetDiscount(); ss << "_Timings"; times.Save(ss.str()); if(args.verbose >= 0) cout << "Timings saved to " << ss.str() << endl; } if(horizon!=MAXHORIZON) { double Vjb0=-DBL_MAX; for(Index a=0;a!=np.GetNrJointActions();++a) Vjb0=max(q->GetQ(Globals::INITIAL_JAOHI,a),Vjb0); cout << "Value of jaohI 0 = " << Vjb0 << endl; } delete q; } catch(E& e){ e.Print(); } cout << "cleanup..." << endl; delete decpomdp; }
unsigned long Measurement::GetNextDataBulk() { FILE_LOG(logDEBUG3) << "Measurement::GetNextDataBulk"; unsigned long i, j, index; short *overflow; uint32_t traces_asked_for, length_of_trace_fetched; // unsigned long length_of_trace_askedfor, length_of_trace_fetched; Timing t; // std::cerr << "(GetNextDataBulk: " << GetNextIndex() << ", " << GetMaxTracesToFetch() << ")\n"; // it makes no sense to read any further: we are already at the end if(GetNextIndex() >= GetNTraces()) { std::cerr << "Stop fetching data from ociloscope." << std::endl; return 0UL; } /* try { for(i=0; i<GetNumberOfChannels(); i++) { if(GetChannel(i)->IsEnabled()) { delete [] data[i]; data[i] = new short[GetMaxTracesToFetch()*GetLength()]; } } } catch(...) { std::cerr << "Unable to allocate memory in Measurement::AllocateMemoryBlock." << std::endl; throw; } /**/ traces_asked_for = GetMaxTracesToFetch(); if(GetNextIndex() + traces_asked_for > GetNTraces()) { traces_asked_for = GetNTraces() - GetNextIndex(); } // allocate buffers for(i=0; i<GetNumberOfChannels(); i++) { if(GetChannel(i)->IsEnabled()) { FILE_LOG(logDEBUG4) << "Measurement::GetNextDataBulk - memset data[i]" << GetLength()*traces_asked_for*sizeof(short); memset(data[i], 0, GetLength()*traces_asked_for*sizeof(short)); FILE_LOG(logDEBUG4) << "done"; } for(j=0; j<traces_asked_for; j++) { index = j+GetNextIndex(); if(GetChannel(i)->IsEnabled()) { if(data_allocated[i] == false) { throw "Unable to get data. Memory is not allocated."; } if(GetSeries() == PICO_4000) { // GetPicoscope()->SetStatus(ps4000SetDataBufferBulk( // GetHandle(), // handle // (PS4000_CHANNEL)i, // channel // data[i], // *buffer // GetMaxTraceLengthToFetch())); // bufferLength GetPicoscope()->SetStatus(ps4000SetDataBufferBulk( GetHandle(), // handle (PS4000_CHANNEL)i, // channel &data[i][j*GetLength()], // *buffer GetLength(), // bufferLength index)); // waveform } else { // unsigned long dj = (j+GetNextIndex()/GetMaxTracesToFetch())%traces_asked_for; // std::cerr << "-- (set data buffer bulk: [" << i << "][" << dj // << "], len:" << GetLength() << ", index:" << index // << ", from:" << GetNextIndex() // << ", to:" << GetNextIndex()+traces_asked_for-1 << "\n"; GetPicoscope()->SetStatus(ps6000SetDataBufferBulk( GetHandle(), // handle (PS6000_CHANNEL)i, // channel &data[i][j*GetLength()], // *buffer GetLength(), // bufferLength index, // waveform PS6000_RATIO_MODE_NONE)); // downSampleRatioMode } if(GetPicoscope()->GetStatus() != PICO_OK) { std::cerr << "Unable to set memory for channel." << std::endl; throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus()); } } } } // fetch data // length_of_trace_fetched = length_of_trace_askedfor; std::cerr << "Get data for traces " << GetNextIndex() << "-" << GetNextIndex()+traces_asked_for << " (" << 100.0*(GetNextIndex()+traces_asked_for)/GetNTraces() << "%) ... "; overflow = new short[traces_asked_for]; memset(overflow, 0, traces_asked_for*sizeof(short)); // std::cerr << "-- x1\n"; t.Start(); // std::cerr << "length of buffer: " << data_length[0] << ", length of requested trace: " << length_of_trace_askedfor << " ... "; if(GetSeries() == PICO_4000) { length_of_trace_fetched = GetLength(); GetPicoscope()->SetStatus(ps4000GetValuesBulk( GetHandle(), // handle &length_of_trace_fetched, // *noOfSamples // TODO: start index GetNextIndex(), // fromSegmentIndex GetNextIndex()+traces_asked_for-1, // toSegmentIndex // this could also be min(GetMaxTraceLengthToFetch(),wholeLength-startindex) overflow)); // *overflow } else { // TODO: not sure about this ... length_of_trace_fetched = GetLength(); GetPicoscope()->SetStatus(ps6000GetValuesBulk( GetHandle(), // handle &length_of_trace_fetched, // *noOfSamples // TODO: start index GetNextIndex(), // fromSegmentIndex GetNextIndex()+traces_asked_for-1, // toSegmentIndex // this could also be min(GetMaxTraceLengthToFetch(),wholeLength-startindex) 1, // downSampleRatio PS6000_RATIO_MODE_NONE, // downSampleRatioMode overflow)); // *overflow } t.Stop(); // std::cerr << "-- x2\n"; if(GetPicoscope()->GetStatus() != PICO_OK) { std::cerr << "Unable to set memory for channel." << std::endl; throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus()); } for(i=0; i<traces_asked_for; i++) { for(j=0; i<GetNumberOfChannels(); i++) { if(overflow[i] & (1<<j)) { FILE_LOG(logWARNING) << "Warning: Overflow on channel " << (char)('A'+j) << " of trace " << i+GetNextIndex() << ".\n"; } } } delete [] overflow; // if(length_of_trace_fetched != length_of_trace_askedfor) { // std::cerr << "Warning: The number of read samples was smaller than requested.\n"; // } // getting timestamps int64_t *timestamps; PS6000_TIME_UNITS *timeunits; timestamps = new int64_t[traces_asked_for]; timeunits = new PS6000_TIME_UNITS[traces_asked_for]; if(GetSeries() == PICO_4000) { // NOT YET IMPLEMENTED } else { FILE_LOG(logDEBUG2) << "ps6000GetValuesTriggerTimeOffsetBulk64(handle=" << GetHandle() << ", *timestamps, *timeunits, fromSegmentIndex=" << GetNextIndex() << ", toSegmentIndex=" << GetNextIndex()+traces_asked_for-1 << ")"; GetPicoscope()->SetStatus(ps6000GetValuesTriggerTimeOffsetBulk64( GetHandle(), // handle timestamps, // *times timeunits, // *timeUnits GetNextIndex(), // fromSegmentIndex GetNextIndex()+traces_asked_for-1)); // toSegmentIndex } if(GetPicoscope()->GetStatus() != PICO_OK) { std::cerr << "Unable to get timestamps." << std::endl; throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus()); } // for(i=0; i<traces_asked_for; i++) { // std::cerr << "time " << i << ": " << timestamps[i] << "\n"; // } SetRate(traces_asked_for, timestamps[0], timeunits[0], timestamps[traces_asked_for-1], timeunits[traces_asked_for-1]); // if(timeunits[0] != timeunits[traces_asked_for-1]) { // FILE_LOG(logWARNING) << "time unit of the first and last sample differ; rate is not reliable; TIMING seems to be broken anyway"; // } delete [] timestamps; delete [] timeunits; std::cerr << "OK ("<< t.GetSecondsDouble() <<"s)\n"; // std::cerr << "length of trace fetched: " << length_of_trace_fetched << "\n"; // std::cerr << "total length: " << traces_asked_for*length_of_trace_fetched << "\n"; SetLengthFetched(traces_asked_for*length_of_trace_fetched); // std::cerr << "-- next index is now " << GetNextIndex() << ", will be set to " << GetNextIndex() + traces_asked_for << "\n"; SetNextIndex(GetNextIndex()+traces_asked_for); // std::cerr << "-- next index is now " << GetNextIndex() << "\n"; // std::cerr << "-- return value " << traces_asked_for << "\n"; return traces_asked_for; }
// TODO: we might want to use multiple buffers at the same time // returns the length of data // TODO: the first part only needs to be called once; so we should move the code at the end of RunBlock // unless we want to alternate between allocated memory (to enable parallel readouts) unsigned long Measurement::GetNextData() { FILE_LOG(logDEBUG3) << "Measurement::GetNextData"; int i; short overflow=0; uint32_t length_of_trace_askedfor, length_of_trace_fetched; Timing t; // it makes no sense to read any further: we are already at the end if(GetNextIndex() >= GetLength()) { std::cerr << "Stop fetching data from osciloscope." << std::endl; return 0UL; } length_of_trace_askedfor = GetMaxTraceLengthToFetch(); if(GetNextIndex() + length_of_trace_askedfor > GetLength()) { length_of_trace_askedfor = GetLength() - GetNextIndex(); } // allocate buffers for(i=0; i<GetNumberOfChannels(); i++) { if(GetChannel(i)->IsEnabled()) { if(data_allocated[i] == false) { throw "Unable to get data. Memory is not allocated."; } if(GetSeries() == PICO_4000) { FILE_LOG(logDEBUG2) << "ps4000SetDataBuffer(handle=" << GetHandle() << ", channel=" << i << ", *buffer=<data[i]>, bufferLength=" << GetMaxTraceLengthToFetch() << ")"; GetPicoscope()->SetStatus(ps4000SetDataBuffer( GetHandle(), // handle (PS4000_CHANNEL)i, // channel data[i], // *buffer GetMaxTraceLengthToFetch())); // bufferLength } else { FILE_LOG(logDEBUG2) << "ps6000SetDataBuffer(handle=" << GetHandle() << ", channel=" << i << ", *buffer=<data[i]>, bufferLength=" << GetMaxTraceLengthToFetch() << ", downSampleRatioMode=PS6000_RATIO_MODE_NONE)"; GetPicoscope()->SetStatus(ps6000SetDataBuffer( GetHandle(), // handle (PS6000_CHANNEL)i, // channel data[i], // *buffer GetMaxTraceLengthToFetch(), // bufferLength PS6000_RATIO_MODE_NONE)); // downSampleRatioMode } if(GetPicoscope()->GetStatus() != PICO_OK) { std::cerr << "Unable to set memory for channel." << std::endl; throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus()); } } } // fetch data length_of_trace_fetched = length_of_trace_askedfor; std::cerr << "Get data for points " << GetNextIndex() << "-" << GetNextIndex()+length_of_trace_askedfor << " (" << 100.0*(GetNextIndex()+length_of_trace_askedfor)/GetLength() << "%) ... "; t.Start(); // std::cerr << "length of buffer: " << data_length[0] << ", length of requested trace: " << length_of_trace_askedfor << " ... "; if(GetSeries() == PICO_4000) { FILE_LOG(logDEBUG2) << "ps4000GetValues(handle=" << GetHandle() << ", startIndex=" << GetNextIndex() << ", *noOfSamples=" << length_of_trace_fetched << ", downSampleRatio=1, downSampleRatioMode=PS4000_RATIO_MODE_NONE, segmentIndex=0, *overflow)"; GetPicoscope()->SetStatus(ps4000GetValues( GetHandle(), // handle // TODO: start index GetNextIndex(), // startIndex // this could also be min(GetMaxTraceLengthToFetch(),wholeLength-startindex) &length_of_trace_fetched, // *noOfSamples 1, // downSampleRatio PS4000_RATIO_MODE_NONE, // downSampleRatioMode 0, // segmentIndex &overflow)); // *overflow FILE_LOG(logDEBUG2) << "-> length_of_trace_fetched=" << length_of_trace_fetched << "\n"; } else { FILE_LOG(logDEBUG2) << "ps6000GetValues(handle=" << GetHandle() << ", startIndex=" << GetNextIndex() << ", *noOfSamples=" << length_of_trace_fetched << ", downSampleRatio=1, downSampleRatioMode=PS6000_RATIO_MODE_NONE, segmentIndex=0, *overflow)"; GetPicoscope()->SetStatus(ps6000GetValues( GetHandle(), // handle // TODO: start index GetNextIndex(), // startIndex // this could also be min(GetMaxTraceLengthToFetch(),wholeLength-startindex) &length_of_trace_fetched, // *noOfSamples 1, // downSampleRatio PS6000_RATIO_MODE_NONE, // downSampleRatioMode 0, // segmentIndex &overflow)); // *overflow FILE_LOG(logDEBUG2) << "-> length_of_trace_fetched=" << length_of_trace_fetched << "\n"; } t.Stop(); if(GetPicoscope()->GetStatus() != PICO_OK) { std::cerr << "Unable to set memory for channel." << std::endl; throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus()); } if(overflow) { for(i=0; i<GetNumberOfChannels(); i++) { if(overflow & (1<<i)) { std::cerr << "Warning: Overflow on channel " << (char)('A'+i) << ".\n"; } } } if(length_of_trace_fetched != length_of_trace_askedfor) { std::cerr << "Warning: The number of read samples was smaller than requested.\n"; } std::cerr << "OK ("<< t.GetSecondsDouble() <<"s)\n"; SetLengthFetched(length_of_trace_fetched); SetNextIndex(GetNextIndex()+length_of_trace_fetched); return length_of_trace_fetched; }
void Measurement::RunBlock() { FILE_LOG(logDEBUG3) << "Measurement::RunBlock"; int i; Timing t; uint32_t max_length=0; // we will have to start reading our data from beginning again SetNextIndex(0); // test if channel settings have already been passed to picoscope // and only pass them again if that isn't the case FILE_LOG(logDEBUG4) << "Measurement::RunBlock - we have " << GetNumberOfChannels() << " channels"; for(i=0; i<GetNumberOfChannels(); i++) { FILE_LOG(logDEBUG4) << "Measurement::RunBlock - setting channel " << (char)('A'+i) << " (which holds index " << GetChannel(i)->GetIndex() << ")"; GetChannel(i)->SetChannelInPicoscope(); } // this fixes the timebase if more than a single channel is selected FixTimebase(); // timebase SetTimebaseInPicoscope(); // trigger if(IsTriggered()) { GetTrigger()->SetTriggerInPicoscope(); } // for rapid block mode if(GetNTraces() > 1) { // TODO - check that GetLength()*GetNumberOfEnabledChannels()*GetNTraces() doesn't exceed the limit if(GetSeries() == PICO_4000) { FILE_LOG(logDEBUG2) << "ps4000SetNoOfCaptures(handle=" << GetHandle() << ", nCaptures=" << GetNTraces() << ")"; GetPicoscope()->SetStatus(ps4000SetNoOfCaptures( GetHandle(), // handle GetNTraces())); // nCaptures } else { FILE_LOG(logDEBUG2) << "ps6000SetNoOfCaptures(handle=" << GetHandle() << ", nCaptures=" << GetNTraces() << ")"; GetPicoscope()->SetStatus(ps6000SetNoOfCaptures( GetHandle(), // handle GetNTraces())); // nCaptures } if(GetPicoscope()->GetStatus() != PICO_OK) { std::cerr << "Unable to set number of captures to " << GetNTraces() << std::endl; throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus()); } if(GetSeries() == PICO_4000) { FILE_LOG(logDEBUG2) << "ps4000MemorySegments(handle=" << GetHandle() << ", nSegments=" << GetNTraces() << ", &max_length=" << max_length << ")"; GetPicoscope()->SetStatus(ps4000MemorySegments( GetHandle(), // handle GetNTraces(), // nSegments &max_length)); FILE_LOG(logDEBUG2) << "->ps4000MemorySegments(... max_length=" << max_length << ")"; } else { FILE_LOG(logDEBUG2) << "ps6000MemorySegments(handle=" << GetHandle() << ", nSegments=" << GetNTraces() << ", &max_length=" << max_length << ")"; GetPicoscope()->SetStatus(ps6000MemorySegments( GetHandle(), // handle GetNTraces(), // nSegments &max_length)); FILE_LOG(logDEBUG2) << "->ps6000MemorySegments(... max_length=" << max_length << ")"; } if(GetPicoscope()->GetStatus() != PICO_OK) { std::cerr << "Unable to set number of segments to " << GetNTraces() << std::endl; throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus()); } if(max_length < GetLength()) { // TODO: times number of enabled channels std::cerr << "The maximum length of trace you can get with " << GetNTraces() << " traces is " << max_length << ", but you requested " << GetLength() << "\n"; throw; } if(GetSeries() == PICO_4000) { FILE_LOG(logDEBUG2) << "ps4000SetNoOfCaptures(handle=" << GetHandle() << ", nCaptures=" << GetNTraces() << ")"; GetPicoscope()->SetStatus(ps4000SetNoOfCaptures( GetHandle(), // handle GetNTraces())); // nCaptures } else { FILE_LOG(logDEBUG2) << "ps6000SetNoOfCaptures(handle=" << GetHandle() << ", nCaptures=" << GetNTraces() << ")"; GetPicoscope()->SetStatus(ps6000SetNoOfCaptures( GetHandle(), // handle GetNTraces())); // nCaptures } if(GetPicoscope()->GetStatus() != PICO_OK) { std::cerr << "Unable to set number of captures to " << GetNTraces() << std::endl; throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus()); } } //std::cerr << "\nPress a key to start fetching the data ...\n"; //_getch(); t.Start(); GetPicoscope()->SetReady(false); if(GetSeries() == PICO_4000) { FILE_LOG(logDEBUG2) << "ps4000RunBlock(handle=" << GetHandle() << ", noOfPreTriggerSamples=" << GetLengthBeforeTrigger() << ", noOfPostTriggerSamples=" << GetLengthAfterTrigger() << ", timebase=" << timebase << ", oversample=1, *timeIndisposedMs=NULL, segmentIndex=0, lpReady=CallBackBlock, *pParameter=NULL)"; GetPicoscope()->SetStatus(ps4000RunBlock( GetHandle(), // handle GetLengthBeforeTrigger(), // noOfPreTriggerSamples GetLengthAfterTrigger(), // noOfPostTriggerSamples timebase, // timebase 1, // ovesample NULL, // *timeIndisposedMs 0, // segmentIndex CallBackBlock, // lpReady NULL)); // *pParameter } else { FILE_LOG(logDEBUG2) << "ps6000RunBlock(handle=" << GetHandle() << ", noOfPreTriggerSamples=" << GetLengthBeforeTrigger() << ", noOfPostTriggerSamples=" << GetLengthAfterTrigger() << ", timebase=" << timebase << ", oversample=1, *timeIndisposedMs=NULL, segmentIndex=0, lpReady=CallBackBlock, *pParameter=NULL)"; GetPicoscope()->SetStatus(ps6000RunBlock( GetHandle(), // handle GetLengthBeforeTrigger(), // noOfPreTriggerSamples GetLengthAfterTrigger(), // noOfPostTriggerSamples timebase, // timebase 1, // ovesample NULL, // *timeIndisposedMs 0, // segmentIndex CallBackBlock, // lpReady NULL)); // *pParameter } if(GetPicoscope()->GetStatus() != PICO_OK) { std::cerr << "Unable to start collecting samples" << std::endl; throw Picoscope::PicoscopeException(GetPicoscope()->GetStatus()); } else { std::cerr << "Start collecting samples in " << ((GetNTraces() > 1) ? "rapid " : "") << "block mode ... "; } // TODO: maybe we want it to be asynchronous // TODO: catch the _kbhit event!!! // while (!Picoscope::IsReady() && !_kbhit()) { while (!Picoscope::IsReady()) { Sleep(200); } t.Stop(); std::cerr << "OK (" << t.GetSecondsDouble() << "s)\n"; // sets the index from where we want to start reading data to zero SetNextIndex(0UL); }
int main(int argc, char **argv) { ArgumentHandlers::Arguments args; argp_parse (&ArgumentHandlers::theArgpStruc, argc, argv, 0, 0, &args); int restarts = args.nrRestarts; srand(time(0)); int horizon=args.horizon; try { //start timers Timing Time; Time.Start("Overall"); DecPOMDPDiscreteInterface & decpomdp = * GetDecPOMDPDiscreteInterfaceFromArgs(args); //set the filename etc. string filename="/dev/null",timingsFilename="/dev/null"; ofstream of; stringstream ss; ss << directories::MADPGetResultsFilename("JESP",decpomdp,args) << SoftPrint(args.jesp) //the jesp type << "_h" << horizon << "_JESPrestarts"<< restarts; //check the method specific arguments and add them to file name switch(args.jesp) { case JESPtype::JESPExhaustive: break; case JESPtype::JESPDP: break; } if(!args.dryrun) { filename=ss.str(); timingsFilename=filename + "_Timings"; of.open(filename.c_str()); if(!of) { cout << "JESP: could not open " << filename << endl; cout << "Results will not be stored to disk." << endl; args.dryrun=true; } if(!args.dryrun) { cout << "Computing " << ss.str() << endl; //write headers of << "#horiz."<<"\t"; of << "value " <<"\t"; of << "ticks"<< "\t"; of << "utime" <<"\t"; of << "found jpol index\t(1tick=1/"<<sysconf(_SC_CLK_TCK)<<"s)\n"; of.flush(); } } //Initialization of the planner with typical options for JESP: Time.Start("PlanningUnit"); PlanningUnitMADPDiscreteParameters params; params.SetComputeAll(true); params.SetComputeJointActionObservationHistories(false); params.SetComputeJointObservationHistories(false); params.SetComputeJointBeliefs(false); if(args.sparse) params.SetUseSparseJointBeliefs(true); else params.SetUseSparseJointBeliefs(false); PlanningUnitDecPOMDPDiscrete* jesp = 0; if(args.jesp == JESPtype::JESPExhaustive) { jesp = new JESPExhaustivePlanner (params,horizon,&decpomdp); cout << "JESPExhaustivePlanner initialized" << endl; } else if(args.jesp == JESPtype::JESPDP) { jesp = new JESPDynamicProgrammingPlanner (params,horizon,&decpomdp); cout << "JESPDynamicProgrammingPlanner initialized" << endl; } Time.Stop("PlanningUnit"); cout << "JESP Planner initialized" << endl; for(int restartI = 0; restartI < restarts; restartI++) { //start all timers: Time.Start("Plan"); tms ts_before, ts_after; clock_t ticks_before, ticks_after; ticks_before = times(&ts_before); jesp->Plan(); double V = jesp->GetExpectedReward(); if(args.verbose >= 0) { cout << "value="<< V << endl; if(args.verbose) { jesp->GetJointPolicyPureVector()->Print(); cout << endl; } } //stop all timers ticks_after = times(&ts_after); clock_t ticks = ticks_after - ticks_before; clock_t utime = ts_after.tms_utime - ts_before.tms_utime; Time.Stop("Plan"); #if CHECK_RESULT ValueFunctionDecPOMDPDiscrete vf(jesp, jesp->GetJointPolicyPureVector()); double v = vf.CalculateV(true); cout << "Validated value (exact/approx):="<<v; SimulationDecPOMDPDiscrete sim(*jesp, 1000); SimulationResult simres = sim.RunSimulations( jesp->GetJointPolicyPureVector() ); v = simres.GetAvgReward(); cout << " / "<<v <<endl; #endif if(!args.dryrun) { of << horizon<<"\t"; char formvalue[10]; sprintf(formvalue, "%.6f", V); of << formvalue <<"\t"; of << ticks <<"\t"; of << utime <<"\t"; of << jesp->GetJointPolicyPureVector()->GetIndex() <<"\n"; of.flush(); } } delete jesp; Time.Stop("Overall"); if(args.verbose >= 0) { Time.PrintSummary(); } if(args.saveTimings && !args.dryrun) Time.Save(timingsFilename); } catch(E& e){ e.Print(); } }
int main(int argc, char **argv) { cout << "DICE: direct CE Policy Search"<<endl; cout << "-----------------------------"<<endl; // parse the command line arguments ArgumentHandlers::Arguments args; argp_parse (&ArgumentHandlers::theArgpStruc, argc, argv, 0, 0, &args); int restarts = args.nrCERestarts; srand(time(0)); int horizon = args.horizon; cout << "Horizon = " << horizon << endl; try { //start timers Timing Time; Time.Start("Overall"); DecPOMDPDiscreteInterface & decpomdp = * GetDecPOMDPDiscreteInterfaceFromArgs(args); // setup the output file stream string filename="/dev/null",timingsFilename="/dev/null"; ofstream of; stringstream ss; ss << directories::MADPGetResultsFilename("DICEPS",decpomdp,args) << "h" << horizon; // add the CE parameters into the output file name ss << "_CEr" << args.nrCERestarts << "_i" << args.nrCEIterations << "_s" << args.nrCESamples << "_sfu" << args.nrCESamplesForUpdate << "_a" << args.CE_alpha << "_ht" << args.CE_use_hard_threshold << "_evals" << args.nrCEEvalutionRuns; if(!args.dryrun) { directories::MADPCreateResultsDir("DICEPS",decpomdp); filename=ss.str(); timingsFilename=filename + "_Timings"; } of.open(filename.c_str()); if(!of) { cerr << "could not open " << filename << endl; return(1); } cout << "Computing " << ss.str() << endl; //write headers of << "#horiz."<<"\t"; of << "value " <<"\t"; of << "wctime"<< "\t"; of << "utime " <<"\t"; of << "stime " <<"\t"; of << "found jpol index\t(1tick=1/"<<sysconf(_SC_CLK_TCK)<<"s)\n"; of.flush(); //Initialization of the planner with typical options for JESP: Time.Start("PlanningUnit"); PlanningUnitMADPDiscreteParameters params; params.SetComputeAll(true); params.SetComputeJointActionObservationHistories(false); params.SetComputeJointActionHistories(false); params.SetComputeIndividualActionObservationHistories(false); params.SetComputeIndividualActionHistories(false); //params.SetComputeIndividualObservationHistories(false); // joint observations histories are needed for // efficient computation of joint actions params.SetComputeJointObservationHistories(true); params.SetComputeJointBeliefs(false); if(args.sparse) params.SetUseSparseJointBeliefs(true); else params.SetUseSparseJointBeliefs(false); DICEPSPlanner* planner; planner = new DICEPSPlanner (params, &decpomdp, horizon, //CE params args.nrCERestarts, args.nrCEIterations, args.nrCESamples, args.nrCESamplesForUpdate, args.CE_use_hard_threshold, //(gamma in CE papers) args.CE_alpha, //the learning rate args.nrCEEvalutionRuns //the number of evaluation runs , args.verbose ); Time.Stop("PlanningUnit"); cout << "DICEPSPlanner initialized" << endl; clock_t total_utime_diceps=0; double total_value=0; for(int restartI = 0; restartI < restarts; restartI++) { //start all timers: tms ts_before, ts_after; clock_t ticks_before, ticks_after; Time.Start("Plan"); ticks_before = times(&ts_before); planner->Plan(); //stop all timers ticks_after = times(&ts_after); Time.Stop("Plan"); clock_t ticks = ticks_after - ticks_before; clock_t utime = ts_after.tms_utime - ts_before.tms_utime; clock_t stime = ts_after.tms_stime - ts_before.tms_stime; total_utime_diceps+=utime; double V = planner->GetExpectedReward(); if(args.verbose >= 0) { cout << "value="<< V << endl; if(args.verbose) { planner->GetJointPolicyPureVector()->Print(); cout << endl; } } total_value+=V; of << horizon<<"\t"; char formvalue[10]; sprintf(formvalue, "%.6f", V); of << formvalue <<"\t"; of << ticks <<"\t"; of << utime <<"\t"; of << stime <<"\t"; of << "-1\n";//Cannot get index of joint pol., since "planner->GetJointPolicyPureVector()->GetIndex()" does not work of.flush(); // output average statistics after completing the last restart if(restartI==(restarts-1)) of << "# h " << args.horizon<<"\t" << " avg DICEPS time (s): " << (static_cast<double>(total_utime_diceps)/ sysconf(_SC_CLK_TCK))/restarts << " avg value: " << total_value/restarts << endl; } /* clean up */ Time.Stop("Overall"); if(args.verbose >= 0) { Time.PrintSummary(); planner->PrintTimersSummary(); } #if 0 if(//args.saveTimings && !args.dryrun) { Time.Save(timingsFilename); planner->SaveTimers(timingsFilename); } #endif delete planner; } catch(E& e){ e.Print(); } }
int main(int argc, char **argv) { ArgumentHandlers::Arguments args; argp_parse (&ArgumentHandlers::theArgpStruc, argc, argv, 0, 0, &args); try { Timing Time; cout << "Instantiating the problem..."<<endl; DecPOMDPDiscreteInterface* decpomdp = GetDecPOMDPDiscreteInterfaceFromArgs(args); cout << "...done."<<endl; //set up output files string filename="/dev/null", timingsFilename="/dev/null"; if(!args.dryrun) { stringstream ss; ss << directories::MADPGetResultsFilename("VI", *decpomdp, args) << "_h" << args.horizon; filename=ss.str(); timingsFilename=filename + "_Timings"; if(!file_exists(filename)) { cout << "VI: could not open " << filename <<endl; cout << "Results will not be stored to disk." <<endl; args.dryrun = true; } } //start VI PlanningUnitDecPOMDPDiscrete *np = new NullPlanner(args.horizon, decpomdp); MDPValueIteration vi(*np); cout << "Running value iteration..."<<endl; Time.Start("Plan"); vi.Plan(); Time.Stop("Plan"); cout << "...done."<<endl; QTable q = vi.GetQTable(0); //<- infinite horizon, so get 1 value function of stage 0 int nrRuns = args.nrRuns; //defaults to 1000, see argumentHandlers.h int seed = args.randomSeed; //defaults to 42 cout << "Simulating policy with nrRuns: " << nrRuns << " and seed: " << seed <<endl; SimulationDecPOMDPDiscrete sim(*np, nrRuns, seed); //write intermediate simulation results to file if(!args.dryrun) sim.SaveIntermediateResults(filename); vector<double> avgRewards; double r = runOneSimulation(q, np, sim); cout << "...done"<<endl; avgRewards.push_back(r); cout << "Avg rewards: " << SoftPrintVector(avgRewards) << endl; //write VI timing information to file if(!args.dryrun) Time.Save(timingsFilename); } catch(E& e){ e.Print(); } return(0); }