inline bool try_merge(Run& run, Iterator iter, Range const& range) { // if *iter intersects with, or is adjacent to, 'range'... if (can_merge(*iter, range)) { typedef typename Range::value_type value_type; typedef integer_traits<value_type> integer_traits; // merge range and *iter merge(*iter, range); // collapse all subsequent ranges that can merge with *iter: Iterator i = iter+1; // 1. skip subsequent ranges completely included in *iter while (i != run.end() && i->last <= iter->last) ++i; // 2. collapse next range if adjacent or overlapping with *iter if (i != run.end() && i->first-1 <= iter->last) { iter->last = i->last; ++i; } // erase all ranges that were collapsed run.erase(iter+1, i); return true; } return false; }
char* TextSelection::GetText () { if (anchor.GetParent() == moving.GetParent() && anchor.GetLocation () == moving.GetLocation()) return g_strdup (""); GString *gstr = g_string_new (""); TextPointer tp = anchor; while (tp.CompareTo_np (moving) < 0) { if (tp.GetParent()->Is (Type::RUN)) { Run *run = (Run*)tp.GetParent(); if (tp.GetParent() == moving.GetParent()) { // tp and moving are in the same element, so we append the substring and set tp = moving. g_string_append_len (gstr, run->GetText() + tp.ResolveLocation(), moving.ResolveLocation() - tp.ResolveLocation()); tp = moving; } else { g_string_append (gstr, run->GetText()); tp = run->GetContentEnd_np(); tp = tp.GetPositionAtOffset_np (1, tp.GetLogicalDirection()); } } else { tp = tp.GetPositionAtOffset_np (1, tp.GetLogicalDirection()); } } printf ("returning %s from TextSelection::GetText\n", gstr->str); return g_string_free (gstr, FALSE); }
void VTTScanner::skipRun(const Run& run) { ASSERT(run.start() <= end()); ASSERT(run.end() >= run.start()); ASSERT(run.end() <= end()); seekTo(run.end()); }
/*!\brief Estimating the necessary number of steps for each benchmark. // // \param run The parameters for the benchmark run. // \return void // // This function estimates the necessary number of steps for the given benchmark based on the // performance of the Blaze library. */ void estimateSteps( Run& run ) { using blazemark::element_t; using blaze::columnVector; ::blaze::setSeed( ::blazemark::seed ); const size_t N( run.getSize() ); blaze::DynamicVector<element_t,columnVector> a( N ), b( N ), c( N ); blaze::timing::WcTimer timer; double wct( 0.0 ); size_t steps( 1UL ); blazemark::blaze::init( a ); blazemark::blaze::init( b ); while( true ) { timer.start(); for( size_t i=0UL; i<steps; ++i ) { c = a * b; } timer.end(); wct = timer.last(); if( wct >= 0.2 ) break; steps *= 2UL; } if( c.size() != N ) std::cerr << " Line " << __LINE__ << ": ERROR detected!!!\n"; run.setSteps( blaze::max( 1UL, ( blazemark::runtime * steps ) / timer.last() ) ); }
bool operator<(const Run& run1, const Run& run2) { Run::RunStatus s1 = run1.getStatus(); Run::RunStatus s2 = run2.getStatus(); fptype t1 = run1.getTotalTime(); // time in seconds fptype t2 = run2.getTotalTime(); // add penalties if (s1 == Run::DQF) { t1 += 200000; } else if (s1 == Run::DNF) { t1 += 100000; } if (s2 == Run::DQF) { t2 += 200000; } else if (s2 == Run::DNF) { t2 += 100000; } return t1 < t2; }
void Paragraph::AddSpace(const size_t count) { Run run; RunItemBase* text = new Text(std::string(count, ' ')); run.add(text); Items->push_back(run); }
const Run<PPEvent>::iterator getMatchingExit(Run<PPEvent>::iterator It, const Run<PPEvent>::iterator &End) { using namespace fmt; const Run<PPEvent>::iterator Cur = It; while (It != End) { PPEventType T = It->event(); if (It->id() == Cur->id()) { switch(Cur->event()) { case RegionEnter: if (T == RegionExit) { return It; } break; case ScopEnter: if (T == ScopExit) { return It; } break; default: break; } } ++It; } //FIXME: Record an error event, this should not happen. static_assert("BUG: No matching Exit to this Entry", ""); return Cur; }
int sleep ( Run& run, Value& ret, Value* args, size_t nargs, const char_t* name, size_t len) { if (args[0].isIndexed()) { run.setError (QSE_AWK_EINVAL); return -1; } Awk::int_t x = args[0].toInt(); /*Value arg; if (run.getGlobal(idLastSleep, arg) == 0) qse_printf (QSE_T("GOOD: [%d]\n"), (int)arg.toInt()); else { qse_printf (QSE_T("BAD:\n")); } */ if (run.setGlobal (idLastSleep, x) <= -1) return -1; #if defined(_WIN32) ::Sleep ((DWORD)(x * 1000)); return ret.setInt (0); #elif defined(__OS2__) ::DosSleep ((ULONG)(x * 1000)); return ret.setInt (0); #else return ret.setInt (::sleep (x)); #endif }
/*!\brief Estimating the necessary number of steps for each benchmark. // // \param run The parameters for the benchmark run. // \return void // // This function estimates the necessary number of steps for the given benchmark based on the // performance of the Blaze library. */ void estimateSteps( Run& run ) { using blazemark::element_t; using blaze::columnMajor; ::blaze::setSeed( ::blazemark::seed ); const size_t N( run.getSize() ); const size_t F( run.getNonZeros() ); blaze::DynamicMatrix<element_t,columnMajor> A( N, N ), C( N, N ); blaze::CompressedMatrix<element_t,columnMajor> B( N, N, N*F ); blaze::timing::WcTimer timer; double wct( 0.0 ); size_t steps( 1UL ); blazemark::blaze::init( A ); blazemark::blaze::init( B, F ); while( true ) { timer.start(); for( size_t i=0UL; i<steps; ++i ) { C = A + B; } timer.end(); wct = timer.last(); if( wct >= 0.2 ) break; steps *= 2UL; } if( C.rows() != N ) std::cerr << " Line " << __LINE__ << ": ERROR detected!!!\n"; run.setSteps( blaze::max( 1UL, ( blazemark::runtime * steps ) / timer.last() ) ); }
/** Add a sample log (property) with value as string * @brief AddSampleLog::addStringLog * @param theRun * @param propName * @param propValue * @param propUnit */ void AddSampleLog::addStringLog(Run &theRun, const std::string &propName, const std::string &propValue, const std::string &propUnit) { theRun.addLogData(new PropertyWithValue<std::string>(propName, propValue)); theRun.getProperty(propName)->setUnits(propUnit); return; }
/*!\brief Estimating the necessary number of floating point operations. // // \param run The parameters for the benchmark run. // \return void // // This function estimates the number of floating point operations required for a single // computation of the (composite) arithmetic operation. */ void estimateFlops( Run& run ) { const size_t N( run.getSize() ); const size_t F( run.getNonZeros() ); run.setFlops( N*F ); }
Paragraph::Paragraph(const RId& rId, const OOX::CPath& filename, const long xEmu, const std::string& hRelativeFrom, const long yEmu, const std::string& vRelativeFrom, const long widthEmu, const long heightEmu) { RunItemBase* drawing = new Drawing(rId, filename, xEmu, hRelativeFrom, yEmu, vRelativeFrom, widthEmu, heightEmu); Run run; run.add(drawing); Items->push_back(run); }
Paragraph::Paragraph(const RId& rId, const OOX::CPath& filename, const long width, const long height) { RunItemBase* drawing = new Drawing(rId, filename, width, height); Run run; run.add(drawing); Items->push_back(run); }
void Paragraph::AddSpace(const size_t count, const nullable__<Logic::RunProperty>& property) { Run run; RunItemBase* text = new Text(std::string(count, ' ')); run.Property = property; run.add(text); Items->push_back(run); }
/** * Copy logs from the input workspace to the output workspace * and don't replace any mathcing logs in the output workspace. */ void CopyLogs::mergeKeepExisting( const std::vector<Kernel::Property *> &inputLogs, Run &outputRun) { for (auto prop : inputLogs) { // add the log only if it doesn't already exist if (!outputRun.hasProperty(prop->name())) { outputRun.addLogData(prop->clone()); } } }
/** * Copy logs from the input workspace to the output workspace * and don't replace any mathcing logs in the output workspace. */ void CopyLogs::mergeKeepExisting( const std::vector<Kernel::Property *> &inputLogs, Run &outputRun) { for (auto iter = inputLogs.begin(); iter != inputLogs.end(); ++iter) { Kernel::Property *prop = *iter; // add the log only if it doesn't already exist if (!outputRun.hasProperty(prop->name())) { outputRun.addLogData(prop->clone()); } } }
/** * Copy logs from the input workspace to the output workspace * and replace any matching logs with the ones from the input workspace. */ void CopyLogs::mergeReplaceExisting( const std::vector<Kernel::Property *> &inputLogs, Run &outputRun) { for (auto prop : inputLogs) { // if the log exists, remove and replace it if (outputRun.hasProperty(prop->name())) { outputRun.removeLogData(prop->name()); } outputRun.addLogData(prop->clone()); } }
// merge two runs and store info in first run. void Run::merge (Run& run) { // merge bucket ranges buckets.splice(buckets.end(), run.getBuckets()); totalFreq += run.getTotalFreq(); freqBounds.first = std::min(getLoFreq(), run.getLoFreq()); freqBounds.second = std::max(getHiFreq(), run.getHiFreq()); Bounds extBounds = run.getRangeBounds(); rangeBounds.first = std::min(extBounds.first, rangeBounds.first); rangeBounds.second = std::max(extBounds.second, rangeBounds.second); }
void Paragraph::AddBreak(const std::string& type) { if (type == "page" || type == "line" || type == "column") { Run run; Break* br = new Break(); br->Type = type; run.add(br); Items->push_back(run); } }
char* TextSelection::GetText () { GString *gstr; TextPointer tp; if (text) goto done; if (anchor.GetParent() == NULL || moving.GetParent() == NULL) { text = g_strdup (""); goto done; } if (anchor.GetParent() == moving.GetParent() && anchor.GetLocation () == moving.GetLocation()) { text = g_strdup (""); goto done; } gstr = g_string_new (""); tp = anchor; while (tp.CompareTo_np (moving) < 0) { DependencyObject *parent = tp.GetParent (); if (parent && parent->Is (Type::RUN)) { Run *run = (Run*)parent; if (parent == moving.GetParent()) { // tp and moving are in the same element, so we append the substring and set tp = moving. g_string_append_len (gstr, run->GetText() + tp.ResolveLocation(), moving.ResolveLocation() - tp.ResolveLocation()); tp = moving; } else { g_string_append (gstr, run->GetText()); tp = run->GetContentEnd_np(); tp = tp.GetPositionAtOffset_np (1, tp.GetLogicalDirection()); } } else { TextPointer new_tp = tp.GetPositionAtOffset_np (1, tp.GetLogicalDirection()); if (new_tp.CompareTo_np (tp) == 0) break; tp = new_tp; } } text = g_string_free (gstr, FALSE); done: return g_strdup (text); }
/** * Copy logs from the input workspace to the output workspace * and replace any matching logs with the ones from the input workspace. */ void CopyLogs::mergeReplaceExisting( const std::vector<Kernel::Property *> &inputLogs, Run &outputRun) { for (auto iter = inputLogs.begin(); iter != inputLogs.end(); ++iter) { Kernel::Property *prop = *iter; // if the log exists, remove and replace it if (outputRun.hasProperty(prop->name())) { outputRun.removeLogData(prop->name()); } outputRun.addLogData(prop->clone()); } }
inline void Thread::run(Runnable* r) { m()->acquire(); if (idle != NULL) { Run* i = idle; idle = idle->n; m()->release(); i->run(r); } else { m()->release(); (void) new Run(r); } }
/** * Wipe any existing logs in the output workspace and replace * them with the logs from the input workspace. */ void CopyLogs::wipeExisting(const std::vector<Kernel::Property *> &inputLogs, Run &outputRun) { auto outputLogs = outputRun.getLogData(); // remove each of the logs from the second workspace for (auto iter = outputLogs.begin(); iter != outputLogs.end(); ++iter) { outputRun.removeLogData((*iter)->name()); } // add all the logs from the new workspace for (auto iter = inputLogs.begin(); iter != inputLogs.end(); ++iter) { outputRun.addLogData((*iter)->clone()); } }
/** * Wipe any existing logs in the output workspace and replace * them with the logs from the input workspace. */ void CopyLogs::wipeExisting(const std::vector<Kernel::Property *> &inputLogs, Run &outputRun) { auto outputLogs = outputRun.getLogData(); // remove each of the logs from the second workspace for (auto &outputLog : outputLogs) { outputRun.removeLogData(outputLog->name()); } // add all the logs from the new workspace for (auto inputLog : inputLogs) { outputRun.addLogData(inputLog->clone()); } }
/** * Main function using class run */ int main(int argc, char **argv) { ros::init(argc, argv, "Run"); Run c = Run(); ros::Rate loop_rate(30); while (ros::ok()) { c.send(); loop_rate.sleep(); } return 0; }
/** Add a single value property * @brief AddSampleLog::addSingleValueProperty * @param theRun * @param propName * @param propValue * @param propUnit * @param propNumberType */ void AddSampleLog::addSingleValueProperty(Run &theRun, const std::string &propName, const std::string &propValue, const std::string &propUnit, const std::string &propNumberType) { // add a single value property, integer or double bool value_is_int(false); if (propNumberType != autoTypeOption) { value_is_int = (propNumberType == intTypeOption); } else { int intVal; if (Strings::convert(propValue, intVal)) { value_is_int = true; } } // set value if (value_is_int) { // convert to integer int intVal; int convert_to_int = Strings::convert(propValue, intVal); if (convert_to_int == 0) { // spit out error message and set to default value g_log.error() << "Error interpreting string '" << propValue << "' as NumberType Int."; throw std::runtime_error("Invalie integer input"); } theRun.addLogData(new PropertyWithValue<int>(propName, intVal)); } else { // convert to double double dblVal; int convert_to_dbl = Strings::convert(propValue, dblVal); if (convert_to_dbl == 0) { g_log.error() << "Error interpreting string '" << propValue << "' as NumberType Double."; throw std::runtime_error("Invalid double input."); } theRun.addLogData(new PropertyWithValue<double>(propName, dblVal)); g_log.information() << "added property " << propName << " with value " << dblVal << "\n"; } // add unit theRun.getProperty(propName)->setUnits(propUnit); return; }
bool VTTScanner::scanFloat(float& number) { Run integerRun = collectWhile<isASCIIDigit>(); seekTo(integerRun.end()); Run decimalRun(getPosition(), getPosition(), m_is8Bit); if (scan('.')) { decimalRun = collectWhile<isASCIIDigit>(); seekTo(decimalRun.end()); } // At least one digit required. if (integerRun.isEmpty() && decimalRun.isEmpty()) { // Restore to starting position. seekTo(integerRun.start()); return false; } size_t lengthOfFloat = Run(integerRun.start(), getPosition(), m_is8Bit).length(); bool validNumber; if (m_is8Bit) number = charactersToFloat(integerRun.start(), lengthOfFloat, &validNumber); else number = charactersToFloat(reinterpret_cast<const UChar*>(integerRun.start()), lengthOfFloat, &validNumber); if (!validNumber) number = std::numeric_limits<float>::max(); return true; }
bool VTTScanner::scanRun(const Run& run, const String& toMatch) { ASSERT(run.start() == position()); ASSERT(run.start() <= end()); ASSERT(run.end() >= run.start()); ASSERT(run.end() <= end()); size_t matchLength = run.length(); if (toMatch.length() > matchLength) return false; bool matched; if (m_is8Bit) matched = WTF::equal(toMatch.impl(), m_data.characters8, matchLength); else matched = WTF::equal(toMatch.impl(), m_data.characters16, matchLength); if (matched) seekTo(run.end()); return matched; }
/** * Extracts a property from run information * * This method extracts the property with the supplied name from the run *information, * using the appropriate AbstractDoubleValueExtractor. If the property is not *found, * an std::runtime_error exception is thrown. If there is no extractor for the *requested * data type, an std::invalid_argument exception is thrown. * * @param runInformation :: Run information that cotains the property with *propertyName * @param propertyName :: Property name that should be extracted * @return Value of property as double */ double PoldiInstrumentAdapter::extractPropertyFromRun( const Run &runInformation, const std::string &propertyName) const { if (!runInformation.hasProperty(propertyName)) { throw std::runtime_error("Cannot construct instrument without " + propertyName + "-property in log. Aborting."); } Kernel::Property *property = runInformation.getProperty(propertyName); AbstractDoubleValueExtractor_sptr extractor = getExtractorForProperty(property); if (!extractor) { throw std::invalid_argument( "Cannot extract chopper speed from run information."); } return (*extractor)(runInformation, propertyName); }
void renderPclPlot(PclPlot *pclPlot) { PclInstr *xInstr = NULL, *yInstr = NULL, *pixlenInstr = NULL, *dataInstr = NULL; Run *run = new Run(); RasterDecoder raster(this->bitmapPlotter); Point origin; while (pclPlot->good()) { if ( (yInstr = nextPclInstr(pclPlot,PCL_Y)) && (xInstr = nextPclInstr(pclPlot,PCL_X)) && (pixlenInstr = nextPclInstr(pclPlot,PCL_PIXEL_LEN)) && (dataInstr = nextPclInstr(pclPlot,PCL_RLE_DATA))) { run->init(yInstr, xInstr, pixlenInstr, dataInstr); while (raster.decode(run)) run->nextRun(); } } }