int main(void)
{
typedef gtl::sparse_graph<GraphNode, GraphEdge> graph_type;
graph_type g;
g.add_node(GraphNode(0));
g.add_node(GraphNode(1));
g.add_node(GraphNode(2));
g.add_node(GraphNode(3));
g.add_node(GraphNode(4));
g.add_node(GraphNode(5));
g.add_edge(GraphEdge(0, 1));
std::cout << g;
gtl::graphsearch_dfs<graph_type> pathFinder(g, 0 , 1);
if (pathFinder.found()) {
std::cout << "found!" << std::endl;
}
else {
std::cout << "not found!" << std::endl;
}
system("pause");
return 0;
}
void CCLayerSorter::createGraphNodes(LayerList::iterator first, LayerList::iterator last)
{
#if !defined( NDEBUG )
LOG(CCLayerSorter, "Creating graph nodes:\n");
#endif
float minZ = FLT_MAX;
float maxZ = -FLT_MAX;
for (LayerList::const_iterator it = first; it < last; it++) {
m_nodes.append(GraphNode(it->get()));
GraphNode& node = m_nodes.at(m_nodes.size() - 1);
CCRenderSurface* renderSurface = node.layer->renderSurface();
if (!node.layer->drawsContent() && !renderSurface)
continue;
#if !defined( NDEBUG )
LOG(CCLayerSorter, "Layer %d (%d x %d)\n", node.layer->debugID(), node.layer->bounds().width(), node.layer->bounds().height());
#endif
TransformationMatrix drawTransform;
float layerWidth, layerHeight;
if (renderSurface) {
drawTransform = renderSurface->drawTransform();
layerWidth = 0.5 * renderSurface->contentRect().width();
layerHeight = 0.5 * renderSurface->contentRect().height();
} else {
drawTransform = node.layer->drawTransform();
layerWidth = 0.5 * node.layer->bounds().width();
layerHeight = 0.5 * node.layer->bounds().height();
}
FloatPoint3D c1 = drawTransform.mapPoint(FloatPoint3D(-layerWidth, layerHeight, 0));
FloatPoint3D c2 = drawTransform.mapPoint(FloatPoint3D(layerWidth, layerHeight, 0));
FloatPoint3D c3 = drawTransform.mapPoint(FloatPoint3D(layerWidth, -layerHeight, 0));
FloatPoint3D c4 = drawTransform.mapPoint(FloatPoint3D(-layerWidth, -layerHeight, 0));
node.normal = (c2 - c1).cross(c3 - c1);
node.c1 = FloatPoint(c1.x(), c1.y());
node.c2 = FloatPoint(c2.x(), c2.y());
node.c3 = FloatPoint(c3.x(), c3.y());
node.c4 = FloatPoint(c4.x(), c4.y());
node.origin = c1;
node.boundingBox.fitToPoints(node.c1, node.c2, node.c3, node.c4);
maxZ = max(c4.z(), max(c3.z(), max(c2.z(), max(maxZ, c1.z()))));
minZ = min(c4.z(), min(c3.z(), min(c2.z(), min(minZ, c1.z()))));
}
if (last - first)
m_zRange = fabsf(maxZ - minZ);
}
//returns id of the node
int Graph2D::addNode(float x, float y, float z)
{
m_nodes.push_back(GraphNode(x,y,z));
// add column
for ( unsigned i = 0; i < m_adj.size(); ++i ) {
m_adj[i].push_back(0);
}
//add new row
m_adj.push_back( std::vector< int >(m_adj.size()) );
m_adj[m_adj.size()-1].resize(m_adj.size(), 0);
return m_nodes.size() - 1;
}
void CCLayerSorter::createGraphNodes(LayerList::iterator first, LayerList::iterator last)
{
#if !defined( NDEBUG )
LOG(CCLayerSorter, "Creating graph nodes:\n");
#endif
float minZ = FLT_MAX;
float maxZ = -FLT_MAX;
for (LayerList::const_iterator it = first; it < last; it++) {
m_nodes.append(GraphNode(*it));
GraphNode& node = m_nodes.at(m_nodes.size() - 1);
CCRenderSurface* renderSurface = node.layer->renderSurface();
if (!node.layer->drawsContent() && !renderSurface)
continue;
#if !defined( NDEBUG )
LOG(CCLayerSorter, "Layer %d (%d x %d)\n", node.layer->debugID(), node.layer->bounds().width(), node.layer->bounds().height());
#endif
TransformationMatrix drawTransform;
float layerWidth, layerHeight;
if (renderSurface) {
drawTransform = renderSurface->drawTransform();
layerWidth = renderSurface->contentRect().width();
layerHeight = renderSurface->contentRect().height();
} else {
drawTransform = node.layer->drawTransform();
layerWidth = node.layer->bounds().width();
layerHeight = node.layer->bounds().height();
}
node.shape = LayerShape(layerWidth, layerHeight, drawTransform);
maxZ = max(maxZ, node.shape.transformOrigin.z());
minZ = min(minZ, node.shape.transformOrigin.z());
}
m_zRange = fabsf(maxZ - minZ);
}
std::list<GraphNode> AffinityTask::BFS(const TaskSet& taskSet, const GraphNode& start, const GraphNode& target, const Affinity& excludeID, const TaskSet& excludeTask)
{
std::list<GraphNode> returnList;
//prepare link map
std::unordered_map<CPUID, TaskSet> cpuToTaskList;
std::unordered_map<AffinityTask*, Affinity> taskToCPUList;
for(auto task : taskSet)
{
if(excludeTask.find(task) != excludeTask.end())
continue;
Affinity affinityCopy(task->affinity);
for(auto cpu : excludeID)
affinityCopy.erase(cpu);
taskToCPUList.insert(std::pair<AffinityTask*, Affinity>(task, affinityCopy));
for(CPUID cpu : affinityCopy)
{
if(cpuToTaskList.find(cpu) == cpuToTaskList.end())
cpuToTaskList.insert(std::pair<CPUID, TaskSet>(cpu, TaskSet()));
cpuToTaskList.find(cpu)->second.insert(task);
}
}
//procedure BFS(G,v) is
std::unordered_map<CPUID, AffinityTask*> cpuToPrevTask;
std::unordered_map<AffinityTask*, CPUID> taskToPrevCPU;
bool reachable = false;
std::queue<GraphNode> queue;//create a queue Q, true is Job, false is processor
std::unordered_set<CPUID> visitedCPU; //create a set V
std::unordered_set<AffinityTask*> visitedTask; //create a set V
if(start.isTask())
visitedTask.insert(start.getTask()); //add v to V
else
visitedCPU.insert(start.getCPUID());
queue.push(start); //enqueue v onto Q
while(!queue.empty())//while Q is not empty loop
{
auto currentItem = queue.front(); //t ← Q.dequeue()
queue.pop();
if(currentItem.isTask())
{
if(target.isTask())
if(target.getTask() == currentItem.getTask()) //if t is what we are looking for then
{
//return t
reachable = true;
break;
}
}
else
{
if(!target.isTask())
if(target.getCPUID() == currentItem.getCPUID()) //if t is what we are looking for then
{
//return t
reachable = true;
break;
}
}
//for all edges e in G.adjacentEdges(t) loop
if(currentItem.isTask())
{
AffinityTask* curTask = currentItem.getTask();
assert(curTask != nullptr);
for(CPUID adjacentCPU : taskToCPUList.find(curTask)->second) //u ← G.adjacentVertex(t,e)
{
if(visitedCPU.find(adjacentCPU) == visitedCPU.end()) //if u is not in V then
{
visitedCPU.insert(adjacentCPU); //add u to V
queue.push(GraphNode(adjacentCPU)); //enqueue u onto Q
assert(cpuToPrevTask.find(adjacentCPU) == cpuToPrevTask.end());
cpuToPrevTask.insert(std::pair<CPUID,AffinityTask*>(adjacentCPU, curTask));
}
}
}
else
{
CPUID curCPU = currentItem.getCPUID();
auto iter = cpuToTaskList.find(curCPU);
if(iter == cpuToTaskList.end())
{
continue;
}
assert(iter->second.size() > 0);
for(AffinityTask* adjacentTask : iter->second) //u ← G.adjacentVertex(t,e)
{
if(visitedTask.find(adjacentTask) == visitedTask.end())
{
visitedTask.insert(adjacentTask);
queue.push(GraphNode(adjacentTask));
assert(taskToPrevCPU.find(adjacentTask) == taskToPrevCPU.end());
taskToPrevCPU.insert(std::pair<AffinityTask*,CPUID>(adjacentTask, curCPU));
}
}
}
}
if(reachable)
{
GraphNode current = target;
while(true)
{
returnList.push_front(current);
if(current.isTask())
{
auto cpu_iter = taskToPrevCPU.find(current.getTask());
if(cpu_iter == taskToPrevCPU.end())
{
assert(start.isTask());
assert(current.getTask() == start.getTask());
break;
}
current = cpu_iter->second;
}
else
{
auto task_iter = cpuToPrevTask.find(current.getCPUID());
if(task_iter == cpuToPrevTask.end())
{
assert(!start.isTask());
assert(current.getCPUID() == start.getCPUID());
break;
}
current = task_iter->second;
}
}
}
return returnList;
}
