llvm.org GIT mirror llvm / 0849f5a
* Eliminate `using' directive * Make code layout more consistent git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@9427 91177308-0d34-0410-b5e6-96231b3b80d8 Misha Brukman 16 years ago
2 changed file(s) with 198 addition(s) and 234 deletion(s). Raw diff Collapse all Expand all
2121 #include "llvm/CodeGen/MachineBasicBlock.h"
2222 #include "llvm/Support/CFG.h"
2323 #include "Support/PostOrderIterator.h"
24 using std::cerr;
2524
2625 std::ostream &operator<<(std::ostream &os, const NodeDelayPair* nd) {
2726 return os << "Delay for node " << nd->node->getNodeId()
4241
4342
4443 void
45 SchedPriorities::initialize()
46 {
44 SchedPriorities::initialize() {
4745 initializeReadyHeap(graph);
4846 }
4947
5048
5149 void
52 SchedPriorities::computeDelays(const SchedGraph* graph)
53 {
50 SchedPriorities::computeDelays(const SchedGraph* graph) {
5451 po_iterator poIter = po_begin(graph), poEnd =po_end(graph);
55 for ( ; poIter != poEnd; ++poIter)
56 {
57 const SchedGraphNode* node = *poIter;
58 cycles_t nodeDelay;
59 if (node->beginOutEdges() == node->endOutEdges())
60 nodeDelay = node->getLatency();
61 else
62 {
63 // Iterate over the out-edges of the node to compute delay
64 nodeDelay = 0;
65 for (SchedGraphNode::const_iterator E=node->beginOutEdges();
66 E != node->endOutEdges(); ++E)
67 {
68 cycles_t sinkDelay = getNodeDelay((SchedGraphNode*)(*E)->getSink());
69 nodeDelay = std::max(nodeDelay, sinkDelay + (*E)->getMinDelay());
70 }
71 }
72 getNodeDelayRef(node) = nodeDelay;
73 }
74 }
75
76
77 void
78 SchedPriorities::initializeReadyHeap(const SchedGraph* graph)
79 {
52 for ( ; poIter != poEnd; ++poIter) {
53 const SchedGraphNode* node = *poIter;
54 cycles_t nodeDelay;
55 if (node->beginOutEdges() == node->endOutEdges())
56 nodeDelay = node->getLatency();
57 else {
58 // Iterate over the out-edges of the node to compute delay
59 nodeDelay = 0;
60 for (SchedGraphNode::const_iterator E=node->beginOutEdges();
61 E != node->endOutEdges(); ++E) {
62 cycles_t sinkDelay = getNodeDelay((SchedGraphNode*)(*E)->getSink());
63 nodeDelay = std::max(nodeDelay, sinkDelay + (*E)->getMinDelay());
64 }
65 }
66 getNodeDelayRef(node) = nodeDelay;
67 }
68 }
69
70
71 void
72 SchedPriorities::initializeReadyHeap(const SchedGraph* graph) {
8073 const SchedGraphNode* graphRoot = (const SchedGraphNode*)graph->getRoot();
8174 assert(graphRoot->getMachineInstr() == NULL && "Expect dummy root");
8275
8780
8881 #undef TEST_HEAP_CONVERSION
8982 #ifdef TEST_HEAP_CONVERSION
90 cerr << "Before heap conversion:\n";
83 std::cerr << "Before heap conversion:\n";
9184 copy(candsAsHeap.begin(), candsAsHeap.end(),
92 ostream_iterator(cerr,"\n"));
85 ostream_iterator(std::cerr,"\n"));
9386 #endif
9487
9588 candsAsHeap.makeHeap();
9790 nextToTry = candsAsHeap.begin();
9891
9992 #ifdef TEST_HEAP_CONVERSION
100 cerr << "After heap conversion:\n";
93 std::cerr << "After heap conversion:\n";
10194 copy(candsAsHeap.begin(), candsAsHeap.end(),
102 ostream_iterator(cerr,"\n"));
95 ostream_iterator(std::cerr,"\n"));
10396 #endif
10497 }
10598
10699 void
107 SchedPriorities::insertReady(const SchedGraphNode* node)
108 {
100 SchedPriorities::insertReady(const SchedGraphNode* node) {
109101 candsAsHeap.insert(node, nodeDelayVec[node->getNodeId()]);
110102 candsAsSet.insert(node);
111103 mcands.clear(); // ensure reset choices is called before any more choices
112104 earliestReadyTime = std::min(earliestReadyTime,
113105 getEarliestReadyTimeForNode(node));
114106
115 if (SchedDebugLevel >= Sched_PrintSchedTrace)
116 {
117 cerr << " Node " << node->getNodeId() << " will be ready in Cycle "
118 << getEarliestReadyTimeForNode(node) << "; "
119 << " Delay = " <<(long)getNodeDelay(node) << "; Instruction: \n";
120 cerr << " " << *node->getMachineInstr() << "\n";
121 }
107 if (SchedDebugLevel >= Sched_PrintSchedTrace) {
108 std::cerr << " Node " << node->getNodeId() << " will be ready in Cycle "
109 << getEarliestReadyTimeForNode(node) << "; "
110 << " Delay = " <<(long)getNodeDelay(node) << "; Instruction: \n"
111 << " " << *node->getMachineInstr() << "\n";
112 }
122113 }
123114
124115 void
125116 SchedPriorities::issuedReadyNodeAt(cycles_t curTime,
126 const SchedGraphNode* node)
127 {
117 const SchedGraphNode* node) {
128118 candsAsHeap.removeNode(node);
129119 candsAsSet.erase(node);
130120 mcands.clear(); // ensure reset choices is called before any more choices
131121
132 if (earliestReadyTime == getEarliestReadyTimeForNode(node))
133 {// earliestReadyTime may have been due to this node, so recompute it
134 earliestReadyTime = HUGE_LATENCY;
135 for (NodeHeap::const_iterator I=candsAsHeap.begin();
136 I != candsAsHeap.end(); ++I)
137 if (candsAsHeap.getNode(I))
138 earliestReadyTime = std::min(earliestReadyTime,
139 getEarliestReadyTimeForNode(candsAsHeap.getNode(I)));
140 }
122 if (earliestReadyTime == getEarliestReadyTimeForNode(node)) {
123 // earliestReadyTime may have been due to this node, so recompute it
124 earliestReadyTime = HUGE_LATENCY;
125 for (NodeHeap::const_iterator I=candsAsHeap.begin();
126 I != candsAsHeap.end(); ++I)
127 if (candsAsHeap.getNode(I)) {
128 earliestReadyTime =
129 std::min(earliestReadyTime,
130 getEarliestReadyTimeForNode(candsAsHeap.getNode(I)));
131 }
132 }
141133
142134 // Now update ready times for successors
143135 for (SchedGraphNode::const_iterator E=node->beginOutEdges();
144 E != node->endOutEdges(); ++E)
145 {
146 cycles_t& etime = getEarliestReadyTimeForNodeRef((SchedGraphNode*)(*E)->getSink());
147 etime = std::max(etime, curTime + (*E)->getMinDelay());
148 }
136 E != node->endOutEdges(); ++E) {
137 cycles_t& etime =
138 getEarliestReadyTimeForNodeRef((SchedGraphNode*)(*E)->getSink());
139 etime = std::max(etime, curTime + (*E)->getMinDelay());
140 }
149141 }
150142
151143
159151 //----------------------------------------------------------------------
160152
161153 inline int
162 SchedPriorities::chooseByRule1(std::vector& mcands)
163 {
154 SchedPriorities::chooseByRule1(std::vector& mcands) {
164155 return (mcands.size() == 1)? 0 // only one choice exists so take it
165156 : -1; // -1 indicates multiple choices
166157 }
167158
168159 inline int
169 SchedPriorities::chooseByRule2(std::vector& mcands)
170 {
160 SchedPriorities::chooseByRule2(std::vector& mcands) {
171161 assert(mcands.size() >= 1 && "Should have at least one candidate here.");
172162 for (unsigned i=0, N = mcands.size(); i < N; i++)
173163 if (instructionHasLastUse(methodLiveVarInfo,
177167 }
178168
179169 inline int
180 SchedPriorities::chooseByRule3(std::vector& mcands)
181 {
170 SchedPriorities::chooseByRule3(std::vector& mcands) {
182171 assert(mcands.size() >= 1 && "Should have at least one candidate here.");
183172 int maxUses = candsAsHeap.getNode(mcands[0])->getNumOutEdges();
184173 int indexWithMaxUses = 0;
185 for (unsigned i=1, N = mcands.size(); i < N; i++)
186 {
187 int numUses = candsAsHeap.getNode(mcands[i])->getNumOutEdges();
188 if (numUses > maxUses)
189 {
190 maxUses = numUses;
191 indexWithMaxUses = i;
192 }
193 }
174 for (unsigned i=1, N = mcands.size(); i < N; i++) {
175 int numUses = candsAsHeap.getNode(mcands[i])->getNumOutEdges();
176 if (numUses > maxUses) {
177 maxUses = numUses;
178 indexWithMaxUses = i;
179 }
180 }
194181 return indexWithMaxUses;
195182 }
196183
197184 const SchedGraphNode*
198185 SchedPriorities::getNextHighest(const SchedulingManager& S,
199 cycles_t curTime)
200 {
186 cycles_t curTime) {
201187 int nextIdx = -1;
202188 const SchedGraphNode* nextChoice = NULL;
203189
204190 if (mcands.size() == 0)
205191 findSetWithMaxDelay(mcands, S);
206192
207 while (nextIdx < 0 && mcands.size() > 0)
208 {
209 nextIdx = chooseByRule1(mcands); // rule 1
210
211 if (nextIdx == -1)
212 nextIdx = chooseByRule2(mcands); // rule 2
213
214 if (nextIdx == -1)
215 nextIdx = chooseByRule3(mcands); // rule 3
216
217 if (nextIdx == -1)
218 nextIdx = 0; // default to first choice by delays
219
220 // We have found the next best candidate. Check if it ready in
221 // the current cycle, and if it is feasible.
222 // If not, remove it from mcands and continue. Refill mcands if
223 // it becomes empty.
224 nextChoice = candsAsHeap.getNode(mcands[nextIdx]);
225 if (getEarliestReadyTimeForNode(nextChoice) > curTime
226 || ! instrIsFeasible(S, nextChoice->getMachineInstr()->getOpCode()))
227 {
228 mcands.erase(mcands.begin() + nextIdx);
229 nextIdx = -1;
230 if (mcands.size() == 0)
231 findSetWithMaxDelay(mcands, S);
232 }
233 }
234
235 if (nextIdx >= 0)
193 while (nextIdx < 0 && mcands.size() > 0) {
194 nextIdx = chooseByRule1(mcands); // rule 1
195
196 if (nextIdx == -1)
197 nextIdx = chooseByRule2(mcands); // rule 2
198
199 if (nextIdx == -1)
200 nextIdx = chooseByRule3(mcands); // rule 3
201
202 if (nextIdx == -1)
203 nextIdx = 0; // default to first choice by delays
204
205 // We have found the next best candidate. Check if it ready in
206 // the current cycle, and if it is feasible.
207 // If not, remove it from mcands and continue. Refill mcands if
208 // it becomes empty.
209 nextChoice = candsAsHeap.getNode(mcands[nextIdx]);
210 if (getEarliestReadyTimeForNode(nextChoice) > curTime
211 || ! instrIsFeasible(S, nextChoice->getMachineInstr()->getOpCode()))
236212 {
237213 mcands.erase(mcands.begin() + nextIdx);
238 return nextChoice;
239 }
240 else
214 nextIdx = -1;
215 if (mcands.size() == 0)
216 findSetWithMaxDelay(mcands, S);
217 }
218 }
219
220 if (nextIdx >= 0) {
221 mcands.erase(mcands.begin() + nextIdx);
222 return nextChoice;
223 } else
241224 return NULL;
242225 }
243226
257240
258241 nextToTry = next;
259242
260 if (SchedDebugLevel >= Sched_PrintSchedTrace)
261 {
262 cerr << " Cycle " << (long)getTime() << ": "
263 << "Next highest delay = " << (long)maxDelay << " : "
264 << mcands.size() << " Nodes with this delay: ";
265 for (unsigned i=0; i < mcands.size(); i++)
266 cerr << candsAsHeap.getNode(mcands[i])->getNodeId() << ", ";
267 cerr << "\n";
268 }
243 if (SchedDebugLevel >= Sched_PrintSchedTrace) {
244 std::cerr << " Cycle " << (long)getTime() << ": "
245 << "Next highest delay = " << (long)maxDelay << " : "
246 << mcands.size() << " Nodes with this delay: ";
247 for (unsigned i=0; i < mcands.size(); i++)
248 std::cerr << candsAsHeap.getNode(mcands[i])->getNodeId() << ", ";
249 std::cerr << "\n";
250 }
269251 }
270252 }
271253
2121 #include "llvm/CodeGen/MachineBasicBlock.h"
2222 #include "llvm/Support/CFG.h"
2323 #include "Support/PostOrderIterator.h"
24 using std::cerr;
2524
2625 std::ostream &operator<<(std::ostream &os, const NodeDelayPair* nd) {
2726 return os << "Delay for node " << nd->node->getNodeId()
4241
4342
4443 void
45 SchedPriorities::initialize()
46 {
44 SchedPriorities::initialize() {
4745 initializeReadyHeap(graph);
4846 }
4947
5048
5149 void
52 SchedPriorities::computeDelays(const SchedGraph* graph)
53 {
50 SchedPriorities::computeDelays(const SchedGraph* graph) {
5451 po_iterator poIter = po_begin(graph), poEnd =po_end(graph);
55 for ( ; poIter != poEnd; ++poIter)
56 {
57 const SchedGraphNode* node = *poIter;
58 cycles_t nodeDelay;
59 if (node->beginOutEdges() == node->endOutEdges())
60 nodeDelay = node->getLatency();
61 else
62 {
63 // Iterate over the out-edges of the node to compute delay
64 nodeDelay = 0;
65 for (SchedGraphNode::const_iterator E=node->beginOutEdges();
66 E != node->endOutEdges(); ++E)
67 {
68 cycles_t sinkDelay = getNodeDelay((SchedGraphNode*)(*E)->getSink());
69 nodeDelay = std::max(nodeDelay, sinkDelay + (*E)->getMinDelay());
70 }
71 }
72 getNodeDelayRef(node) = nodeDelay;
73 }
74 }
75
76
77 void
78 SchedPriorities::initializeReadyHeap(const SchedGraph* graph)
79 {
52 for ( ; poIter != poEnd; ++poIter) {
53 const SchedGraphNode* node = *poIter;
54 cycles_t nodeDelay;
55 if (node->beginOutEdges() == node->endOutEdges())
56 nodeDelay = node->getLatency();
57 else {
58 // Iterate over the out-edges of the node to compute delay
59 nodeDelay = 0;
60 for (SchedGraphNode::const_iterator E=node->beginOutEdges();
61 E != node->endOutEdges(); ++E) {
62 cycles_t sinkDelay = getNodeDelay((SchedGraphNode*)(*E)->getSink());
63 nodeDelay = std::max(nodeDelay, sinkDelay + (*E)->getMinDelay());
64 }
65 }
66 getNodeDelayRef(node) = nodeDelay;
67 }
68 }
69
70
71 void
72 SchedPriorities::initializeReadyHeap(const SchedGraph* graph) {
8073 const SchedGraphNode* graphRoot = (const SchedGraphNode*)graph->getRoot();
8174 assert(graphRoot->getMachineInstr() == NULL && "Expect dummy root");
8275
8780
8881 #undef TEST_HEAP_CONVERSION
8982 #ifdef TEST_HEAP_CONVERSION
90 cerr << "Before heap conversion:\n";
83 std::cerr << "Before heap conversion:\n";
9184 copy(candsAsHeap.begin(), candsAsHeap.end(),
92 ostream_iterator(cerr,"\n"));
85 ostream_iterator(std::cerr,"\n"));
9386 #endif
9487
9588 candsAsHeap.makeHeap();
9790 nextToTry = candsAsHeap.begin();
9891
9992 #ifdef TEST_HEAP_CONVERSION
100 cerr << "After heap conversion:\n";
93 std::cerr << "After heap conversion:\n";
10194 copy(candsAsHeap.begin(), candsAsHeap.end(),
102 ostream_iterator(cerr,"\n"));
95 ostream_iterator(std::cerr,"\n"));
10396 #endif
10497 }
10598
10699 void
107 SchedPriorities::insertReady(const SchedGraphNode* node)
108 {
100 SchedPriorities::insertReady(const SchedGraphNode* node) {
109101 candsAsHeap.insert(node, nodeDelayVec[node->getNodeId()]);
110102 candsAsSet.insert(node);
111103 mcands.clear(); // ensure reset choices is called before any more choices
112104 earliestReadyTime = std::min(earliestReadyTime,
113105 getEarliestReadyTimeForNode(node));
114106
115 if (SchedDebugLevel >= Sched_PrintSchedTrace)
116 {
117 cerr << " Node " << node->getNodeId() << " will be ready in Cycle "
118 << getEarliestReadyTimeForNode(node) << "; "
119 << " Delay = " <<(long)getNodeDelay(node) << "; Instruction: \n";
120 cerr << " " << *node->getMachineInstr() << "\n";
121 }
107 if (SchedDebugLevel >= Sched_PrintSchedTrace) {
108 std::cerr << " Node " << node->getNodeId() << " will be ready in Cycle "
109 << getEarliestReadyTimeForNode(node) << "; "
110 << " Delay = " <<(long)getNodeDelay(node) << "; Instruction: \n"
111 << " " << *node->getMachineInstr() << "\n";
112 }
122113 }
123114
124115 void
125116 SchedPriorities::issuedReadyNodeAt(cycles_t curTime,
126 const SchedGraphNode* node)
127 {
117 const SchedGraphNode* node) {
128118 candsAsHeap.removeNode(node);
129119 candsAsSet.erase(node);
130120 mcands.clear(); // ensure reset choices is called before any more choices
131121
132 if (earliestReadyTime == getEarliestReadyTimeForNode(node))
133 {// earliestReadyTime may have been due to this node, so recompute it
134 earliestReadyTime = HUGE_LATENCY;
135 for (NodeHeap::const_iterator I=candsAsHeap.begin();
136 I != candsAsHeap.end(); ++I)
137 if (candsAsHeap.getNode(I))
138 earliestReadyTime = std::min(earliestReadyTime,
139 getEarliestReadyTimeForNode(candsAsHeap.getNode(I)));
140 }
122 if (earliestReadyTime == getEarliestReadyTimeForNode(node)) {
123 // earliestReadyTime may have been due to this node, so recompute it
124 earliestReadyTime = HUGE_LATENCY;
125 for (NodeHeap::const_iterator I=candsAsHeap.begin();
126 I != candsAsHeap.end(); ++I)
127 if (candsAsHeap.getNode(I)) {
128 earliestReadyTime =
129 std::min(earliestReadyTime,
130 getEarliestReadyTimeForNode(candsAsHeap.getNode(I)));
131 }
132 }
141133
142134 // Now update ready times for successors
143135 for (SchedGraphNode::const_iterator E=node->beginOutEdges();
144 E != node->endOutEdges(); ++E)
145 {
146 cycles_t& etime = getEarliestReadyTimeForNodeRef((SchedGraphNode*)(*E)->getSink());
147 etime = std::max(etime, curTime + (*E)->getMinDelay());
148 }
136 E != node->endOutEdges(); ++E) {
137 cycles_t& etime =
138 getEarliestReadyTimeForNodeRef((SchedGraphNode*)(*E)->getSink());
139 etime = std::max(etime, curTime + (*E)->getMinDelay());
140 }
149141 }
150142
151143
159151 //----------------------------------------------------------------------
160152
161153 inline int
162 SchedPriorities::chooseByRule1(std::vector& mcands)
163 {
154 SchedPriorities::chooseByRule1(std::vector& mcands) {
164155 return (mcands.size() == 1)? 0 // only one choice exists so take it
165156 : -1; // -1 indicates multiple choices
166157 }
167158
168159 inline int
169 SchedPriorities::chooseByRule2(std::vector& mcands)
170 {
160 SchedPriorities::chooseByRule2(std::vector& mcands) {
171161 assert(mcands.size() >= 1 && "Should have at least one candidate here.");
172162 for (unsigned i=0, N = mcands.size(); i < N; i++)
173163 if (instructionHasLastUse(methodLiveVarInfo,
177167 }
178168
179169 inline int
180 SchedPriorities::chooseByRule3(std::vector& mcands)
181 {
170 SchedPriorities::chooseByRule3(std::vector& mcands) {
182171 assert(mcands.size() >= 1 && "Should have at least one candidate here.");
183172 int maxUses = candsAsHeap.getNode(mcands[0])->getNumOutEdges();
184173 int indexWithMaxUses = 0;
185 for (unsigned i=1, N = mcands.size(); i < N; i++)
186 {
187 int numUses = candsAsHeap.getNode(mcands[i])->getNumOutEdges();
188 if (numUses > maxUses)
189 {
190 maxUses = numUses;
191 indexWithMaxUses = i;
192 }
193 }
174 for (unsigned i=1, N = mcands.size(); i < N; i++) {
175 int numUses = candsAsHeap.getNode(mcands[i])->getNumOutEdges();
176 if (numUses > maxUses) {
177 maxUses = numUses;
178 indexWithMaxUses = i;
179 }
180 }
194181 return indexWithMaxUses;
195182 }
196183
197184 const SchedGraphNode*
198185 SchedPriorities::getNextHighest(const SchedulingManager& S,
199 cycles_t curTime)
200 {
186 cycles_t curTime) {
201187 int nextIdx = -1;
202188 const SchedGraphNode* nextChoice = NULL;
203189
204190 if (mcands.size() == 0)
205191 findSetWithMaxDelay(mcands, S);
206192
207 while (nextIdx < 0 && mcands.size() > 0)
208 {
209 nextIdx = chooseByRule1(mcands); // rule 1
210
211 if (nextIdx == -1)
212 nextIdx = chooseByRule2(mcands); // rule 2
213
214 if (nextIdx == -1)
215 nextIdx = chooseByRule3(mcands); // rule 3
216
217 if (nextIdx == -1)
218 nextIdx = 0; // default to first choice by delays
219
220 // We have found the next best candidate. Check if it ready in
221 // the current cycle, and if it is feasible.
222 // If not, remove it from mcands and continue. Refill mcands if
223 // it becomes empty.
224 nextChoice = candsAsHeap.getNode(mcands[nextIdx]);
225 if (getEarliestReadyTimeForNode(nextChoice) > curTime
226 || ! instrIsFeasible(S, nextChoice->getMachineInstr()->getOpCode()))
227 {
228 mcands.erase(mcands.begin() + nextIdx);
229 nextIdx = -1;
230 if (mcands.size() == 0)
231 findSetWithMaxDelay(mcands, S);
232 }
233 }
234
235 if (nextIdx >= 0)
193 while (nextIdx < 0 && mcands.size() > 0) {
194 nextIdx = chooseByRule1(mcands); // rule 1
195
196 if (nextIdx == -1)
197 nextIdx = chooseByRule2(mcands); // rule 2
198
199 if (nextIdx == -1)
200 nextIdx = chooseByRule3(mcands); // rule 3
201
202 if (nextIdx == -1)
203 nextIdx = 0; // default to first choice by delays
204
205 // We have found the next best candidate. Check if it ready in
206 // the current cycle, and if it is feasible.
207 // If not, remove it from mcands and continue. Refill mcands if
208 // it becomes empty.
209 nextChoice = candsAsHeap.getNode(mcands[nextIdx]);
210 if (getEarliestReadyTimeForNode(nextChoice) > curTime
211 || ! instrIsFeasible(S, nextChoice->getMachineInstr()->getOpCode()))
236212 {
237213 mcands.erase(mcands.begin() + nextIdx);
238 return nextChoice;
239 }
240 else
214 nextIdx = -1;
215 if (mcands.size() == 0)
216 findSetWithMaxDelay(mcands, S);
217 }
218 }
219
220 if (nextIdx >= 0) {
221 mcands.erase(mcands.begin() + nextIdx);
222 return nextChoice;
223 } else
241224 return NULL;
242225 }
243226
257240
258241 nextToTry = next;
259242
260 if (SchedDebugLevel >= Sched_PrintSchedTrace)
261 {
262 cerr << " Cycle " << (long)getTime() << ": "
263 << "Next highest delay = " << (long)maxDelay << " : "
264 << mcands.size() << " Nodes with this delay: ";
265 for (unsigned i=0; i < mcands.size(); i++)
266 cerr << candsAsHeap.getNode(mcands[i])->getNodeId() << ", ";
267 cerr << "\n";
268 }
243 if (SchedDebugLevel >= Sched_PrintSchedTrace) {
244 std::cerr << " Cycle " << (long)getTime() << ": "
245 << "Next highest delay = " << (long)maxDelay << " : "
246 << mcands.size() << " Nodes with this delay: ";
247 for (unsigned i=0; i < mcands.size(); i++)
248 std::cerr << candsAsHeap.getNode(mcands[i])->getNodeId() << ", ";
249 std::cerr << "\n";
250 }
269251 }
270252 }
271253