uint Mgr::makeSummaryMetricsIncr(bool needAllStats, uint srcBegId, uint srcEndId) { if (srcBegId == Mgr::npos) { srcBegId = 0; } if (srcEndId == Mgr::npos) { srcEndId = m_metrics.size(); } uint firstId = Mgr::npos; for (uint i = srcBegId; i < srcEndId; ++i) { Metric::ADesc* m = m_metrics[i]; Metric::ADesc* mNew = makeSummaryMetricIncr("Sum", m); if (needAllStats) { makeSummaryMetricIncr("Mean", m); makeSummaryMetricIncr("StdDev", m); makeSummaryMetricIncr("CfVar", m); makeSummaryMetricIncr("Min", m); makeSummaryMetricIncr("Max", m); } if (firstId == Mgr::npos) { firstId = mNew->id(); } } computePartners(); return firstId; }
void Mgr::zeroDBInfo() const { for (uint i = 0; i < m_metrics.size(); ++i) { Metric::ADesc* m = m_metrics[i]; if (m->hasDBInfo()) { m->zeroDBInfo(); } } }
Metric::ADesc* Mgr::findLastVisible() const { Metric::ADesc* found = NULL; for (int i = m_metrics.size() - 1; i >= 0; --i) { // i may be < 0 Metric::ADesc* m = m_metrics[i]; if (m->isVisible()) { found = m; break; } } return found; }
Metric::ADesc* Mgr::findFirstVisible() const { Metric::ADesc* found = NULL; for (uint i = 0; i < m_metrics.size(); ++i) { Metric::ADesc* m = m_metrics[i]; if (m->isVisible()) { found = m; break; } } return found; }
// Assumes: metrics are of type Metric::SampledDesc and values are // only at leaves (CCT::Stmt) void MetricComponentsFact::make(Prof::CallPath::Profile& prof) { using namespace Prof; // ------------------------------------------------------------ // Create destination metric descriptors and mapping from source // metrics to destination metrics // ------------------------------------------------------------ std::vector<uint> metricSrcIds; std::vector<uint> metricDstIds; Metric::Mgr* metricMgr = prof.metricMgr(); uint numMetrics_orig = metricMgr->size(); for (uint mId = 0; mId < numMetrics_orig; ++mId) { Metric::ADesc* m = metricMgr->metric(mId); if (MetricComponentsFact::isTimeMetric(m)) { DIAG_Assert(typeid(*m) == typeid(Metric::SampledDesc), DIAG_UnexpectedInput << "temporary sanity check"); MetricComponentsFact::convertToWorkMetric(m); metricSrcIds.push_back(m->id()); Metric::ADesc* m_new = m->clone(); m_new->nameBase("overhead"); m_new->description("parallel overhead"); metricMgr->insert(m_new); DIAG_Assert(m_new->id() >= numMetrics_orig, "Currently, we assume new metrics are added at the end of the metric vector."); metricDstIds.push_back(m_new->id()); } } if (metricSrcIds.empty()) { return; } // ------------------------------------------------------------ // Create values for metric components // ------------------------------------------------------------ make(prof.cct()->root(), metricSrcIds, metricDstIds, false); }
std::ostream& Mgr::dump(std::ostream& os, const char* pfx) const { os << pfx << "[ metric table:" << std::endl; for (uint i = 0; i < m_metrics.size(); i++) { Metric::ADesc* m = m_metrics[i]; os << pfx << " " << m->id() << ": " << m->toString() << std::endl; } os << pfx << "]" << std::endl; os << pfx << "[ unique-name-to-metric:" << std::endl; for (StringToADescMap::const_iterator it = m_uniqnmToMetricMap.begin(); it != m_uniqnmToMetricMap.end(); ++it) { const string& nm = it->first; Metric::ADesc* m = it->second; os << pfx << " " << nm << " -> " << m->toString() << std::endl; } os << pfx << "]" << std::endl; return os; }
void Mgr::computePartners() { StringToADescMap metricsIncl; StringToADescMap metricsExcl; // ------------------------------------------------------- // populate maps // ------------------------------------------------------- for (uint i = 0; i < m_metrics.size(); ++i) { Metric::ADesc* m = m_metrics[i]; string nm = m->namePfxBaseSfx(); StringToADescMap* metricsMap = NULL; switch (m->type()) { case ADesc::TyIncl: metricsMap = &metricsIncl; break; case ADesc::TyExcl: metricsMap = &metricsExcl; break; default: break; } if (metricsMap) { DIAG_MsgIf(0, "Metric::Mgr::computePartners: insert: " << nm << " [" << m->name() << "]"); std::pair<StringToADescMap::iterator, bool> ret = metricsMap->insert(make_pair(nm, m)); DIAG_Assert(ret.second, "Metric::Mgr::computePartners: Found duplicate entry inserting:\n\t" << m->toString() << "\nOther entry:\n\t" << ret.first->second->toString()); } } // ------------------------------------------------------- // find partners // ------------------------------------------------------- for (uint i = 0; i < m_metrics.size(); ++i) { Metric::ADesc* m = m_metrics[i]; string nm = m->namePfxBaseSfx(); StringToADescMap* metricsMap = NULL; switch (m->type()) { case ADesc::TyIncl: metricsMap = &metricsExcl; break; case ADesc::TyExcl: metricsMap = &metricsIncl; break; default: break; } if (metricsMap) { StringToADescMap::iterator it = metricsMap->find(nm); if (it != metricsMap->end()) { Metric::ADesc* partner = it->second; m->partner(partner); DIAG_MsgIf(0, "Metric::Mgr::computePartners: found: " << m->name() << " -> " << partner->name()); } } } }
Metric::DerivedDesc* Mgr::makeSummaryMetric(const string mDrvdTy, const Metric::ADesc* mSrc, const Metric::ADescVec& mOpands) { Metric::AExpr** opands = new Metric::AExpr*[mOpands.size()]; for (uint i = 0; i < mOpands.size(); ++i) { Metric::ADesc* m = mOpands[i]; opands[i] = new Metric::Var(m->name(), m->id()); } bool doDispPercent = true; bool isPercent = false; bool isVisible = true; // This is a cheesy way of creating the metrics, but it is good // enough for now. Metric::AExpr* expr = NULL; if (mDrvdTy.find("Sum", 0) == 0) { expr = new Metric::Plus(opands, mOpands.size()); } else if (mDrvdTy.find("Mean", 0) == 0) { expr = new Metric::Mean(opands, mOpands.size()); doDispPercent = false; } else if (mDrvdTy.find("StdDev", 0) == 0) { expr = new Metric::StdDev(opands, mOpands.size()); doDispPercent = false; } else if (mDrvdTy.find("CfVar", 0) == 0) { expr = new Metric::CoefVar(opands, mOpands.size()); doDispPercent = false; } else if (mDrvdTy.find("%CfVar", 0) == 0) { expr = new Metric::RStdDev(opands, mOpands.size()); isPercent = true; } else if (mDrvdTy.find("Min", 0) == 0) { expr = new Metric::Min(opands, mOpands.size()); doDispPercent = false; } else if (mDrvdTy.find("Max", 0) == 0) { expr = new Metric::Max(opands, mOpands.size()); doDispPercent = false; } else { DIAG_Die(DIAG_UnexpectedInput); } string mNmFmt = mSrc->nameToFmt(); string mNmBase = mSrc->nameBase() + ":" + mDrvdTy; const string& mDesc = mSrc->description(); DerivedDesc* m = new DerivedDesc(mNmFmt, mDesc, expr, isVisible, true/*isSortKey*/, doDispPercent, isPercent); m->nameBase(mNmBase); m->nameSfx(""); // clear; cf. Prof::CallPath::Profile::RFlg_NoMetricSfx m->zeroDBInfo(); // clear insert(m); expr->accumId(m->id()); if (expr->hasAccum2()) { string m2NmBase = mNmBase + ":accum2"; DerivedDesc* m2 = new DerivedDesc(mNmFmt, mDesc, NULL/*expr*/, false/*isVisible*/, false/*isSortKey*/, false/*doDispPercent*/, false/*isPercent*/); m2->nameBase(m2NmBase); m2->nameSfx(""); // clear; cf. Prof::CallPath::Profile::RFlg_NoMetricSfx m2->zeroDBInfo(); // clear insert(m2); expr->accum2Id(m2->id()); } if (expr->hasNumSrcVar()) { string m3NmBase = mNmBase + ":num-src"; Metric::NumSource* m3Expr = new Metric::NumSource(mOpands.size()); DerivedDesc* m3 = new DerivedDesc(mNmFmt, mDesc, m3Expr, false/*isVisible*/, false/*isSortKey*/, false/*doDispPercent*/, false/*isPercent*/); m3->nameBase(m3NmBase); m3->nameSfx(""); // clear; cf. Prof::CallPath::Profile::RFlg_NoMetricSfx m3->zeroDBInfo(); // clear insert(m3); m3Expr->accumId(m3->id()); expr->numSrcVarId(m3->id()); } return m; }
uint Mgr::makeSummaryMetrics(bool needAllStats, bool needMultiOccurance, uint srcBegId, uint srcEndId) { StringToADescVecMap nmToMetricMap; std::vector<Metric::ADescVec*> metricGroups; if (srcBegId == Mgr::npos) { srcBegId = 0; } if (srcEndId == Mgr::npos) { srcEndId = m_metrics.size(); } uint threshold = (needMultiOccurance) ? 2 : 1; // ------------------------------------------------------- // collect like metrics // ------------------------------------------------------- for (uint i = srcBegId; i < srcEndId; ++i) { Metric::ADesc* m = m_metrics[i]; string nm = m->nameGeneric(); StringToADescVecMap::iterator it = nmToMetricMap.find(nm); if (it != nmToMetricMap.end()) { Metric::ADescVec& mvec = it->second; mvec.push_back(m); } else { std::pair<StringToADescVecMap::iterator, bool> ret = nmToMetricMap.insert(make_pair(nm, Metric::ADescVec(1, m))); Metric::ADescVec* grp = &(ret.first->second); metricGroups.push_back(grp); } } // ------------------------------------------------------- // create summary metrics // ------------------------------------------------------- uint firstId = Mgr::npos; for (uint i = 0; i < metricGroups.size(); ++i) { const Metric::ADescVec& mVec = *(metricGroups[i]); if (mVec.size() >= threshold) { const Metric::ADesc* m = mVec[0]; Metric::ADesc* mNew = makeSummaryMetric("Sum", m, mVec); if (needAllStats) { makeSummaryMetric("Mean", m, mVec); makeSummaryMetric("StdDev", m, mVec); makeSummaryMetric("CfVar", m, mVec); makeSummaryMetric("Min", m, mVec); makeSummaryMetric("Max", m, mVec); } if (firstId == Mgr::npos) { firstId = mNew->id(); } } } computePartners(); return firstId; }
// make: ...temporary holding pattern... void MPIBlameShiftIdlenessFact::make(Prof::CallPath::Profile& prof) { using namespace Prof; // ------------------------------------------------------------ // Create destination metric descriptors and mapping from source // metrics to destination metrics // ------------------------------------------------------------ std::vector<uint> metricSrcIds; std::vector<uint> metricBalanceIds; std::vector<uint> metricImbalInclIds, metricImbalExclIds; std::vector<uint> metricIdleInclIds; Metric::Mgr* metricMgr = prof.metricMgr(); uint numMetrics_orig = metricMgr->size(); for (uint mId = 0; mId < numMetrics_orig; ++mId) { Metric::ADesc* m = metricMgr->metric(mId); // find main source metric if (MetricComponentsFact::isTimeMetric(m) && MetricComponentsFact::isDerivedMetric(m, s_sum) && m->type() == Metric::ADesc::TyIncl && m->isVisible() /* not a temporary */) { DIAG_Assert(m->computedType() == Prof::Metric::ADesc::ComputedTy_NonFinal, DIAG_UnexpectedInput); metricSrcIds.push_back(m->id()); // FIXME: For now we use only Metric::ADesc::DerivedIncrDesc() // We should also support Metric::ADesc::DerivedDesc() DIAG_Assert(typeid(*m) == typeid(Metric::DerivedIncrDesc), DIAG_UnexpectedInput); Metric::DerivedIncrDesc* m_imbalIncl = static_cast<Metric::DerivedIncrDesc*>(m->clone()); m_imbalIncl->nameBase("imbalance" + s_sum); m_imbalIncl->description("imbalance for MPI SPMD executions"); m_imbalIncl->expr(new Metric::SumIncr(Metric::IData::npos, // FIXME:Sum Metric::IData::npos)); Metric::DerivedIncrDesc* m_imbalExcl = static_cast<Metric::DerivedIncrDesc*>(m_imbalIncl->clone()); m_imbalExcl->type(Metric::ADesc::TyExcl); m_imbalExcl->expr(new Metric::SumIncr(Metric::IData::npos, Metric::IData::npos)); m_imbalIncl->partner(m_imbalExcl); m_imbalExcl->partner(m_imbalIncl); Metric::DerivedIncrDesc* m_idleIncl = static_cast<Metric::DerivedIncrDesc*>(m->clone()); m_idleIncl->nameBase("idleness" + s_sum); m_idleIncl->description("idleness for MPI executions"); m_idleIncl->partner(NULL); m_idleIncl->expr(new Metric::SumIncr(Metric::IData::npos, // FIXME:Sum Metric::IData::npos)); metricMgr->insert(m_imbalIncl); metricMgr->insert(m_imbalExcl); metricMgr->insert(m_idleIncl); m_imbalIncl->expr()->accumId(m_imbalIncl->id()); m_imbalExcl->expr()->accumId(m_imbalExcl->id()); m_idleIncl->expr()->accumId(m_idleIncl->id()); DIAG_Assert(m_imbalIncl->id() >= numMetrics_orig && m_imbalExcl->id() >= numMetrics_orig, "Currently, we assume new metrics are added at the end of the metric vector."); metricImbalInclIds.push_back(m_imbalIncl->id()); metricImbalExclIds.push_back(m_imbalExcl->id()); metricIdleInclIds.push_back(m_idleIncl->id()); } // find secondary source metric if (MetricComponentsFact::isTimeMetric(m) && MetricComponentsFact::isDerivedMetric(m, s_cfvar) && m->type() == Metric::ADesc::TyIncl && m->isVisible() /* not a temporary */) { DIAG_Assert(m->computedType() == Prof::Metric::ADesc::ComputedTy_NonFinal, DIAG_UnexpectedInput); metricBalanceIds.push_back(m->id()); } } DIAG_Assert(metricSrcIds.size() == metricBalanceIds.size(), DIAG_UnexpectedInput); if (metricSrcIds.empty()) { return; } // ------------------------------------------------------------ // Create values for metric components // ------------------------------------------------------------ // Note that metrics are non-finalized! CCT::ANode* cctRoot = prof.cct()->root(); uint metricBalancedId = metricBalanceIds[0]; Metric::AExprIncr* metricBalancedExpr = dynamic_cast<Metric::DerivedIncrDesc*>(metricMgr->metric(metricBalancedId))->expr(); Metric::IData cctRoot_mdata(*cctRoot); metricBalancedExpr->finalize(cctRoot_mdata); double balancedThreshold = 1.2 * cctRoot_mdata.demandMetric(metricBalancedId); makeMetrics(cctRoot, metricSrcIds, metricImbalInclIds, metricImbalExclIds, metricIdleInclIds, metricBalancedId, metricBalancedExpr, balancedThreshold, NULL, NULL); VMAIntervalSet metricDstInclIdSet; for (uint i = 0; i < metricImbalInclIds.size(); ++i) { uint mId = metricImbalInclIds[i]; metricDstInclIdSet.insert(VMAInterval(mId, mId + 1)); // [ ) mId = metricIdleInclIds[i]; metricDstInclIdSet.insert(VMAInterval(mId, mId + 1)); // [ ) } cctRoot->aggregateMetricsIncl(metricDstInclIdSet); }