void AddUserDlg::init(const QStringList &groups, PsiAccount *pa)
{
setupUi(this);
setModal(false);
setAttribute(Qt::WA_DeleteOnClose);
d = new Private;
d->pa = pa;
d->pa->dialogRegister(this);
d->jt = 0;
d->tasks = new TaskList;
connect(d->tasks, SIGNAL(started()), busy, SLOT(start()));
connect(d->tasks, SIGNAL(finished()), busy, SLOT(stop()));
setWindowTitle(CAP(windowTitle()));
setWindowIcon(IconsetFactory::icon("psi/addContact").icon());
#if QT_VERSION >= 0x040500
setWindowFlags(Qt::Dialog | Qt::WindowTitleHint | Qt::WindowMinimizeButtonHint | Qt::WindowCloseButtonHint | Qt::CustomizeWindowHint);
#endif
d->busy = busy;
QString str = tr("<None>");
cb_group->addItem(str);
QStringList temp=groups;
temp.sort();
cb_group->addItems(temp);
str = tr("Hidden");
if (!groups.contains(str)) {
cb_group->addItem(str);
}
cb_group->setAutoCompletion(true);
pb_add->setDefault(true);
connect(pb_add, SIGNAL(clicked()), SLOT(ok()));
connect(pb_close, SIGNAL(clicked()), SLOT(cancel()));
connect(pb_transGet, SIGNAL(clicked()), SLOT(getTransID()));
connect(tb_vCard, SIGNAL(clicked()), SLOT(getVCardActivated()));
connect(tb_resolveNick, SIGNAL(clicked()), SLOT(resolveNickActivated()));
connect(le_jid, SIGNAL(textChanged(QString)), SLOT(jid_Changed()));
ck_authreq->setChecked(true);
ck_close->setChecked(true);
le_jid->setFocus();
}
void AddUserDlg::init(const QStringList &groups, PsiAccount *pa)
{
setupUi(this);
setModal(false);
d = new Private;
d->pa = pa;
d->pa->dialogRegister(this);
d->jt = 0;
d->tasks = new TaskList;
connect(d->tasks, SIGNAL(started()), busy, SLOT(start()));
connect(d->tasks, SIGNAL(finished()), busy, SLOT(stop()));
setWindowTitle(CAP(caption()));
setWindowIcon(IconsetFactory::icon("psi/addContact").icon());
d->busy = busy;
QString str = tr("<None>");
cb_group->insertItem(str);
QStringList temp=groups;
temp.sort();
cb_group->insertStringList(temp);
str = ContactView::tr("Hidden");
if (!groups.contains(str)) {
cb_group->insertItem(str);
}
cb_group->setAutoCompletion(true);
pb_add->setDefault(true);
connect(pb_add, SIGNAL(clicked()), SLOT(ok()));
connect(pb_close, SIGNAL(clicked()), SLOT(cancel()));
connect(pb_transGet, SIGNAL(clicked()), SLOT(getTransID()));
connect(tb_vCard, SIGNAL(clicked()), SLOT(getVCardActivated()));
connect(tb_resolveNick, SIGNAL(clicked()), SLOT(resolveNickActivated()));
connect(le_jid, SIGNAL(textChanged(QString)), SLOT(jid_Changed()));
ck_authreq->setChecked(true);
ck_close->setChecked(true);
le_jid->setFocus();
}
/**
* Chain the retranslation blocks. This method enforces that, for
* each region block, all its successor have distinct SrcKeys.
*/
void RegionDesc::chainRetransBlocks() {
jit::vector<Chain> chains;
BlockToChainMap block2chain;
// 1. Initially assign each region block to its own chain.
for (auto b : blocks()) {
auto bid = b->id();
auto cid = chains.size();
chains.push_back({cid, {bid}});
block2chain[bid] = cid;
}
// 2. For each block, if it has 2 successors with the same SrcKey,
// then merge the successors' chains into one.
for (auto b : blocks()) {
auto bid = b->id();
const auto& succSet = succs(bid);
for (auto it1 = succSet.begin(); it1 != succSet.end(); it1++) {
auto bid1 = *it1;
auto cid1 = block2chain[bid1];
for (auto it2 = it1 + 1; it2 != succSet.end(); it2++) {
auto bid2 = *it2;
auto cid2 = block2chain[bid2];
if (data(bid1).block->start() == data(bid2).block->start()) {
mergeChains(chains[cid1], chains[cid2], block2chain);
}
}
}
}
// 3. Sort each chain. In general, we want to sort each chain in
// decreasing order of profile weights. However, note that this
// transformation can turn acyclic graphs into cyclic ones (see
// example below). Therefore, if JitLoops are disabled, we
// instead sort each chain following the original block order,
// which prevents loops from being generated if the region was
// originally acyclic.
//
// Here's an example showing how an acyclic CFG can become cyclic
// by chaining its retranslation blocks:
//
// - Region before chaining retranslation blocks, where B2' and B2"
// are retranslations starting at the same SrcKey:
// B1 -> B2'
// B1 -> B2"
// B2' -> B3
// B3 -> B2"
//
// - Region after sorting the chain as B2" -R-> B2':
// B1 -> B2"
// B2" -R-> B2'
// B2' -> B3
// B3 -> B2"
// Note the cycle: B2" -R-> B2' -> B3 -> B2".
//
auto profData = mcg->tx().profData();
auto weight = [&](RegionDesc::BlockId bid) {
return hasTransID(bid) ? profData->absTransCounter(getTransID(bid)) : 0;
};
auto sortGeneral = [&](RegionDesc::BlockId bid1, RegionDesc::BlockId bid2) {
return weight(bid1) > weight(bid2);
};
using SortFun = std::function<bool(RegionDesc::BlockId, RegionDesc::BlockId)>;
SortFun sortFunc = sortGeneral;
hphp_hash_map<RegionDesc::BlockId, uint32_t> origBlockOrder;
if (!RuntimeOption::EvalJitLoops) {
for (uint32_t i = 0; i < m_blocks.size(); i++) {
origBlockOrder[m_blocks[i]->id()] = i;
}
auto sortAcyclic = [&](RegionDesc::BlockId bid1, RegionDesc::BlockId bid2) {
return origBlockOrder[bid1] < origBlockOrder[bid2];
};
sortFunc = sortAcyclic;
}
TRACE(1, "chainRetransBlocks: computed chains:\n");
for (auto& c : chains) {
std::sort(c.blocks.begin(), c.blocks.end(), sortFunc);
if (Trace::moduleEnabled(Trace::region, 1) && c.blocks.size() > 0) {
FTRACE(1, " -> {} (w={})", c.blocks[0], weight(c.blocks[0]));
for (size_t i = 1; i < c.blocks.size(); i++) {
FTRACE(1, ", {} (w={})", c.blocks[i], weight(c.blocks[i]));
}
FTRACE(1, "\n");
}
}
// 4. Set the nextRetrans blocks according to the computed chains.
for (auto& c : chains) {
if (c.blocks.size() == 0) continue;
for (size_t i = 0; i < c.blocks.size() - 1; i++) {
setNextRetrans(c.blocks[i], c.blocks[i + 1]);
}
}
// 5. For each block with multiple successors in the same chain,
// only keep the successor that first appears in the chain.
for (auto b : blocks()) {
auto& succSet = data(b->id()).succs;
for (auto s : succSet) {
auto& c = chains[block2chain[s]];
auto selectedSucc = findFirstInSet(c, succSet);
for (auto other : c.blocks) {
if (other == selectedSucc) continue;
succSet.erase(other);
}
}
}
// 6. Reorder the blocks in the region in topological order (if
// region is acyclic), since the previous steps may break it.
sortBlocks();
}
RegionDescPtr selectHotTrace(TransID triggerId,
const ProfData* profData,
TransCFG& cfg,
TransIDSet& selectedSet,
TransIDVec* selectedVec) {
auto region = std::make_shared<RegionDesc>();
TransID tid = triggerId;
TransID prevId = kInvalidTransID;
selectedSet.clear();
if (selectedVec) selectedVec->clear();
PostConditions accumPostConds;
// Maps from BlockIds to accumulated post conditions for that block.
// Used to determine if we can add branch-over edges by checking the
// pre-conditions of the successor block.
hphp_hash_map<RegionDesc::BlockId, PostConditions> blockPostConds;
uint32_t numBCInstrs = 0;
while (!selectedSet.count(tid)) {
RegionDescPtr blockRegion = profData->transRegion(tid);
if (blockRegion == nullptr) break;
// Break if region would be larger than the specified limit.
auto newInstrSize = numBCInstrs + blockRegion->instrSize();
if (newInstrSize > RuntimeOption::EvalJitMaxRegionInstrs) {
FTRACE(2, "selectHotTrace: breaking region at Translation {} because "
"size ({}) would exceed of maximum translation limit\n",
tid, newInstrSize);
break;
}
// If the debugger is attached, only allow single-block regions.
if (prevId != kInvalidTransID && isDebuggerAttachedProcess()) {
FTRACE(2, "selectHotTrace: breaking region at Translation {} "
"because of debugger is attached\n", tid);
break;
}
// Break if block is not the first and it corresponds to the main
// function body entry. This is to prevent creating multiple
// large regions containing the function body (starting at various
// DV funclets).
if (prevId != kInvalidTransID) {
const Func* func = profData->transFunc(tid);
Offset bcOffset = profData->transStartBcOff(tid);
if (func->base() == bcOffset) {
FTRACE(2, "selectHotTrace: breaking region because reached the main "
"function body entry at Translation {} (BC offset {})\n",
tid, bcOffset);
break;
}
}
if (prevId != kInvalidTransID) {
auto sk = profData->transSrcKey(tid);
if (profData->optimized(sk)) {
FTRACE(2, "selectHotTrace: breaking region because next sk already "
"optimized, for Translation {}\n", tid);
break;
}
}
bool hasPredBlock = !region->empty();
RegionDesc::BlockId predBlockId = (hasPredBlock ?
region->blocks().back().get()->id() : 0);
auto const& newFirstBlock = blockRegion->entry();
auto newFirstBlockId = newFirstBlock->id();
auto newLastBlockId = blockRegion->blocks().back()->id();
// Add blockRegion's blocks and arcs to region.
region->append(*blockRegion);
numBCInstrs += blockRegion->instrSize();
if (hasPredBlock) {
region->addArc(predBlockId, newFirstBlockId);
}
// When Eval.JitLoops is set, insert back-edges in the region if
// they exist in the TransCFG.
if (RuntimeOption::EvalJitLoops) {
assertx(hasTransID(newFirstBlockId));
auto newTransId = getTransID(newFirstBlockId);
// Don't add the arc if the last opcode in the source block ends
// the region.
if (!breaksRegion(*profData->transLastInstr(newTransId))) {
auto& blocks = region->blocks();
for (auto iOther = 0; iOther < blocks.size(); iOther++) {
auto other = blocks[iOther];
auto otherFirstBlockId = other.get()->id();
if (!hasTransID(otherFirstBlockId)) continue;
auto otherTransId = getTransID(otherFirstBlockId);
if (cfg.hasArc(newTransId, otherTransId)) {
region->addArc(newLastBlockId, otherFirstBlockId);
}
}
}
}
if (cfg.outArcs(tid).size() > 1) {
region->setSideExitingBlock(blockRegion->entry()->id());
}
selectedSet.insert(tid);
if (selectedVec) selectedVec->push_back(tid);
Op lastOp = *(profData->transLastInstr(tid));
if (breaksRegion(lastOp)) {
FTRACE(2, "selectHotTrace: breaking region because of last instruction "
"in Translation {}: {}\n", tid, opcodeToName(lastOp));
break;
}
auto outArcs = cfg.outArcs(tid);
if (outArcs.size() == 0) {
FTRACE(2, "selectHotTrace: breaking region because there's no successor "
"for Translation {}\n", tid);
break;
}
auto newLastBlock = blockRegion->blocks().back();
discardPoppedTypes(accumPostConds,
blockRegion->entry()->initialSpOffset());
mergePostConds(accumPostConds, newLastBlock->postConds());
blockPostConds[newLastBlock->id()] = accumPostConds;
TransCFG::ArcPtrVec possibleOutArcs;
for (auto arc : outArcs) {
RegionDesc::BlockPtr possibleNext =
profData->transRegion(arc->dst())->entry();
if (preCondsAreSatisfied(possibleNext, accumPostConds)) {
possibleOutArcs.emplace_back(arc);
}
}
if (possibleOutArcs.size() == 0) {
FTRACE(2, "selectHotTrace: breaking region because postcondition check "
"pruned all successors of Translation {}\n", tid);
break;
}
auto maxWeight = std::numeric_limits<int64_t>::min();
TransCFG::Arc* maxArc = nullptr;
for (auto arc : possibleOutArcs) {
if (arc->weight() >= maxWeight) {
maxWeight = arc->weight();
maxArc = arc;
}
}
assertx(maxArc != nullptr);
prevId = tid;
tid = maxArc->dst();
}
FTRACE(3, "selectHotTrace: before chainRetransBlocks:\n{}\n", show(*region));
region->chainRetransBlocks();
FTRACE(3, "selectHotTrace: after chainRetransBlocks:\n{}\n", show(*region));
return region;
}