bool IsMirror(Node *root)
{
typedef list<Node *> NodeList;
NodeList leftList;
NodeList rightList;
if (!root)
{
// an empty tree is mirrored
return true;
}
leftList.push_back(root->left);
rightList.push_back(root->right);
// BFS traversal.
// Pushing children to the lists and then comparing their values.
while (!leftList.empty() && !rightList.empty())
{
Node *left = leftList.front();
leftList.pop_front();
Node *right = rightList.front();
rightList.pop_front();
if (!left && !right)
{
continue;
}
else if (!left || !right)
{
return false;
}
if (left->value != right->value)
{
return false;
}
leftList.push_back(left->left);
leftList.push_back(left->right);
// the insert order is reversed in right sub-tree
rightList.push_back(right->right);
rightList.push_back(right->left);
}
// Both lists should be empty, otherwise this is not a mirrored binary tree.
return leftList.empty() && rightList.empty();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
////// Performs a breadth first search to find shortest available path (with non-saturated path capacities)
////// between a search node and a sink node. The function uses a search graph to perform the search and
////// store parent-child relationship of the nodes in the graph.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
void PerformBFS(const Graph& graph,
SearchGraph& sgraph,
int source,
int sink,
Path* augpath)
{
NodeList nlist;
nlist.push_back(source);
int u, v;
int i;
SearchNode snode_u, snode_v;
bool found = false;
vector<int> nbr_nodes;
while (nlist.size() > 0)
{
u = nlist[0];
GetNeighboringNodes(u, graph, &nbr_nodes);
snode_u = sgraph[u];
for (i = 0; i < (int) nbr_nodes.size(); i++)
{
v = nbr_nodes[i];
snode_v = sgraph[v];
if (snode_v.color == -1)
{
snode_v.color = 0;
snode_v.dist = snode_u.dist + 1;
snode_v.parent = u;
sgraph[v] = snode_v;
nlist.push_back(v);
}
if (v == sink)
{
found = true;
break;
}
}
nlist.pop_front();
snode_u.color = 1;
sgraph[u] = snode_u;
if (found == true)
break;
}
if (found == true)
FindAugmentingPath(sgraph, source, sink, augpath);
}
void emptyTree(NodeSet roots)
{
TreeNode *tempNode = 0, *parentNode = 0;
NodeSetIter setIter;
NodeList nodeList;
NodeListIter listIter;
for(setIter=roots.begin(); setIter!=roots.end(); ++setIter)
{
tempNode=0;
parentNode=0;
if(*setIter!=0)
{
nodeList.push_front(*setIter);
while (nodeList.size()!=0)
{
listIter=nodeList.begin();
tempNode=(*listIter);
nodeList.pop_front();
if (tempNode->right==0 && tempNode->left==0)
{
parentNode=tempNode->parent;
if (parentNode->right->ID==tempNode->ID)
parentNode->right = 0;
else
parentNode->left=0;
delete tempNode;
tempNode=0;
}
else
{
if(tempNode->right!=0)
nodeList.push_front(tempNode->right);
if(tempNode->left!=0)
nodeList.push_front(tempNode->left);
}
}
}
nodeList.clear();
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
////// Given a residual graph with no path from the source and sink node, the sunction outputs an assignment list
////// which assigns each node to either belonging to the source tree or the sink tree. It performs breadth first
////// search on the residual graph to find the children of the source tress. Any remaining nodes are aressigned
////// to the sink node.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
void ComputeAssignments(const Graph& graph, int source, int sink, vector<int>* assignments)
{
SearchGraph sgraph;
assignments->clear();
const int nnodes = graph.size();
InitSearchGraph(&sgraph, nnodes, source);
assignments->resize(nnodes, -1);
NodeList nlist;
nlist.push_back(source);
int u, v;
int i;
SearchNode snode_u, snode_v;
bool found = false;
vector<int> nbr_nodes;
while (nlist.size() > 0)
{
u = nlist[0];
(*assignments)[u] = 1;
GetNeighboringNodes(u, graph, &nbr_nodes);
snode_u = sgraph[u];
for (i = 0; i < (int) nbr_nodes.size(); i++)
{
v = nbr_nodes[i];
snode_v = sgraph[v];
if (snode_v.color == -1)
{
snode_v.color = 0;
snode_v.dist = snode_u.dist + 1;
snode_v.parent = u;
sgraph[v] = snode_v;
nlist.push_back(v);
}
}
nlist.pop_front();
snode_u.color = 1;
sgraph[u] = snode_u;
}
}
//
// FindLoops
//
// Find loops and build loop forest using Havlak's algorithm, which
// is derived from Tarjan. Variable names and step numbering has
// been chosen to be identical to the nomenclature in Havlak's
// paper (which is similar to the one used by Tarjan).
//
void FindLoops() {
if (!CFG_->GetStartBasicBlock()) return;
int size = CFG_->GetNumNodes();
IntSetVector non_back_preds(size);
IntListVector back_preds(size);
IntVector header(size);
CharVector type(size);
IntVector last(size);
NodeVector nodes(size);
BasicBlockMap number;
// Step a:
// - initialize all nodes as unvisited.
// - depth-first traversal and numbering.
// - unreached BB's are marked as dead.
//
for (MaoCFG::NodeMap::iterator bb_iter =
CFG_->GetBasicBlocks()->begin();
bb_iter != CFG_->GetBasicBlocks()->end(); ++bb_iter) {
number[(*bb_iter).second] = kUnvisited;
}
DFS(CFG_->GetStartBasicBlock(), &nodes, &number, &last, 0);
// Step b:
// - iterate over all nodes.
//
// A backedge comes from a descendant in the DFS tree, and non-backedges
// from non-descendants (following Tarjan).
//
// - check incoming edges 'v' and add them to either
// - the list of backedges (back_preds) or
// - the list of non-backedges (non_back_preds)
//
for (int w = 0; w < size; w++) {
header[w] = 0;
type[w] = BB_NONHEADER;
BasicBlock *node_w = nodes[w].bb();
if (!node_w) {
type[w] = BB_DEAD;
continue; // dead BB
}
if (node_w->GetNumPred()) {
for (BasicBlockIter inedges = node_w->in_edges()->begin();
inedges != node_w->in_edges()->end(); ++inedges) {
BasicBlock *node_v = *inedges;
int v = number[ node_v ];
if (v == kUnvisited) continue; // dead node
if (IsAncestor(w, v, &last))
back_preds[w].push_back(v);
else
non_back_preds[w].insert(v);
}
}
}
// Start node is root of all other loops.
header[0] = 0;
// Step c:
//
// The outer loop, unchanged from Tarjan. It does nothing except
// for those nodes which are the destinations of backedges.
// For a header node w, we chase backward from the sources of the
// backedges adding nodes to the set P, representing the body of
// the loop headed by w.
//
// By running through the nodes in reverse of the DFST preorder,
// we ensure that inner loop headers will be processed before the
// headers for surrounding loops.
//
for (int w = size-1; w >= 0; w--) {
NodeList node_pool; // this is 'P' in Havlak's paper
BasicBlock *node_w = nodes[w].bb();
if (!node_w) continue; // dead BB
// Step d:
IntList::iterator back_pred_iter = back_preds[w].begin();
IntList::iterator back_pred_end = back_preds[w].end();
for (; back_pred_iter != back_pred_end; back_pred_iter++) {
int v = *back_pred_iter;
if (v != w)
node_pool.push_back(nodes[v].FindSet());
else
type[w] = BB_SELF;
}
// Copy node_pool to worklist.
//
NodeList worklist;
NodeList::iterator niter = node_pool.begin();
NodeList::iterator nend = node_pool.end();
for (; niter != nend; ++niter)
worklist.push_back(*niter);
if (!node_pool.empty())
type[w] = BB_REDUCIBLE;
// work the list...
//
while (!worklist.empty()) {
UnionFindNode x = *worklist.front();
worklist.pop_front();
// Step e:
//
// Step e represents the main difference from Tarjan's method.
// Chasing upwards from the sources of a node w's backedges. If
// there is a node y' that is not a descendant of w, w is marked
// the header of an irreducible loop, there is another entry
// into this loop that avoids w.
//
// The algorithm has degenerated. Break and
// return in this case.
//
size_t non_back_size = non_back_preds[x.dfs_number()].size();
if (non_back_size > kMaxNonBackPreds) {
lsg_->KillAll();
return;
}
IntSet::iterator non_back_pred_iter =
non_back_preds[x.dfs_number()].begin();
IntSet::iterator non_back_pred_end =
non_back_preds[x.dfs_number()].end();
for (; non_back_pred_iter != non_back_pred_end; non_back_pred_iter++) {
UnionFindNode y = nodes[*non_back_pred_iter];
UnionFindNode *ydash = y.FindSet();
if (!IsAncestor(w, ydash->dfs_number(), &last)) {
type[w] = BB_IRREDUCIBLE;
non_back_preds[w].insert(ydash->dfs_number());
} else {
if (ydash->dfs_number() != w) {
NodeList::iterator nfind = find(node_pool.begin(),
node_pool.end(), ydash);
if (nfind == node_pool.end()) {
worklist.push_back(ydash);
node_pool.push_back(ydash);
}
}
}
}
}
// Collapse/Unionize nodes in a SCC to a single node
// For every SCC found, create a loop descriptor and link it in.
//
if (!node_pool.empty() || (type[w] == BB_SELF)) {
SimpleLoop* loop = lsg_->CreateNewLoop();
// At this point, one can set attributes to the loop, such as:
//
// the bottom node:
// IntList::iterator iter = back_preds[w].begin();
// loop bottom is: nodes[*backp_iter].node);
//
// the number of backedges:
// back_preds[w].size()
//
// whether this loop is reducible:
// type[w] != BB_IRREDUCIBLE
//
// TODO(rhundt): Define those interfaces in the Loop Forest.
//
nodes[w].set_loop(loop);
for (niter = node_pool.begin(); niter != node_pool.end(); niter++) {
UnionFindNode *node = (*niter);
// Add nodes to loop descriptor.
header[node->dfs_number()] = w;
node->Union(&nodes[w]);
// Nested loops are not added, but linked together.
if (node->loop())
node->loop()->set_parent(loop);
else
loop->AddNode(node->bb());
}
lsg_->AddLoop(loop);
} // node_pool.size
} // Step c
} // FindLoops
void DemandCalculator::CalcDemand(LinkGraphJob &job, Tscaler scaler)
{
NodeList supplies;
NodeList demands;
uint num_supplies = 0;
uint num_demands = 0;
for (NodeID node = 0; node < job.Size(); node++) {
scaler.AddNode(job[node]);
if (job[node].Supply() > 0) {
supplies.push_back(node);
num_supplies++;
}
if (job[node].Demand() > 0) {
demands.push_back(node);
num_demands++;
}
}
if (num_supplies == 0 || num_demands == 0) return;
/* Mean acceptance attributed to each node. If the distribution is
* symmetric this is relative to remote supply, otherwise it is
* relative to remote demand. */
scaler.SetDemandPerNode(num_demands);
uint chance = 0;
while (!supplies.empty() && !demands.empty()) {
NodeID from_id = supplies.front();
supplies.pop_front();
for (uint i = 0; i < num_demands; ++i) {
assert(!demands.empty());
NodeID to_id = demands.front();
demands.pop_front();
if (from_id == to_id) {
/* Only one node with supply and demand left */
if (demands.empty() && supplies.empty()) return;
demands.push_back(to_id);
continue;
}
int32 supply = scaler.EffectiveSupply(job[from_id], job[to_id]);
assert(supply > 0);
/* Scale the distance by mod_dist around max_distance */
int32 distance = this->max_distance - (this->max_distance -
(int32)job[from_id][to_id].Distance()) * this->mod_dist / 100;
/* Scale the accuracy by distance around accuracy / 2 */
int32 divisor = this->accuracy * (this->mod_dist - 50) / 100 +
this->accuracy * distance / this->max_distance + 1;
assert(divisor > 0);
uint demand_forw = 0;
if (divisor <= supply) {
/* At first only distribute demand if
* effective supply / accuracy divisor >= 1
* Others are too small or too far away to be considered. */
demand_forw = supply / divisor;
} else if (++chance > this->accuracy * num_demands * num_supplies) {
/* After some trying, if there is still supply left, distribute
* demand also to other nodes. */
demand_forw = 1;
}
demand_forw = min(demand_forw, job[from_id].UndeliveredSupply());
scaler.SetDemands(job, from_id, to_id, demand_forw);
if (scaler.HasDemandLeft(job[to_id])) {
demands.push_back(to_id);
} else {
num_demands--;
}
if (job[from_id].UndeliveredSupply() == 0) break;
}
if (job[from_id].UndeliveredSupply() != 0) {
supplies.push_back(from_id);
} else {
num_supplies--;
}
}
}