/** Finds shortcuts, does not change the underlying graph. */
void findShortcuts(ShortcutHandler sch) {
long tmpDegreeCounter = 0;
EdgeIterator incomingEdges = vehicleInExplorer.setBaseNode(sch.getNode());
// collect outgoing nodes (goal-nodes) only once
while (incomingEdges.next()) {
int u_fromNode = incomingEdges.getAdjNode();
// accept only uncontracted nodes
if (g.getLevel(u_fromNode) != 0) continue;
double v_u_weight = incomingEdges.getDistance();
int skippedEdge1 = incomingEdges.getEdge();
int incomingEdgeOrigCount = getOrigEdgeCount(skippedEdge1);
// collect outgoing nodes (goal-nodes) only once
EdgeIterator outgoingEdges = vehicleOutExplorer.setBaseNode(sch.getNode());
// force fresh maps etc as this cannot be determined by from node alone (e.g. same from node
// but different avoidNode)
algo.clear();
tmpDegreeCounter++;
while (outgoingEdges.next()) {
int w_toNode = outgoingEdges.getAdjNode();
// add only uncontracted nodes
if (g.getLevel(w_toNode) != 0 || u_fromNode == w_toNode) {
continue;
}
// Limit weight as ferries or forbidden edges can increase local search too much.
// If we decrease the correct weight we only explore less and introduce more shortcuts.
// I.e. no change to accuracy is made.
double existingDirectWeight = v_u_weight + outgoingEdges.getDistance();
algo.setLimitWeight(existingDirectWeight)
.setLimitVisitedNodes((int) meanDegree * 100)
.setEdgeFilter(levelEdgeFilter.setAvoidNode(sch.getNode()));
dijkstraSW.start();
dijkstraCount++;
int endNode = algo.findEndNode(u_fromNode, w_toNode);
dijkstraSW.stop();
// compare end node as the limit could force dijkstra to finish earlier
if (endNode == w_toNode && algo.getWeight(endNode) <= existingDirectWeight)
// FOUND witness path, so do not add shortcut
continue;
sch.foundShortcut(
u_fromNode,
w_toNode,
existingDirectWeight,
outgoingEdges,
skippedEdge1,
incomingEdgeOrigCount);
}
}
if (sch instanceof AddShortcutHandler) {
// sliding mean value when using "*2" => slower changes
meanDegree = (meanDegree * 2 + tmpDegreeCounter) / 3;
// meanDegree = (meanDegree + tmpDegreeCounter) / 2;
}
}
private Set<List<Integer>> distributions(int bound, List<GrammarProductionElement> elems) {
distroTimer.start();
int sumSize = elems.size();
List<Integer> lowerBounds = lowerBounds(elems, bound);
List<Integer> upperBounds = upperBounds(elems, bound, lowerBounds);
Set<List<Integer>> result = distributor.distribute2(sumSize, bound, lowerBounds, upperBounds);
distroTimer.stop();
return result;
}
public static void main(String[] args) {
int N = 10000000;
int K = 1;
Integer[] newArray = new Integer[N];
StopWatch sw = new StopWatch();
while (K <= N) {
newArray = createArray(N, K);
Sorting obj = new Sorting(newArray);
newArray = (Integer[]) obj.selectionsort();
System.out.println("The time needed for K=" + K + " is " + sw.elapsedTime());
K = K * 2;
System.out.println(
"The number of comparisons is "
+ obj.compareCount()
+ "; "
+ "The number of exchanges is "
+ obj.exchangeCount()
+ "; "
+ "The number of copies is "
+ obj.copyCount()
+ "; ");
}
}
public static void finish() {
if (!makeThunk) {
Record.finish();
if (monitor) monitorThread.finish();
setExecStatus("done", false);
outputMap.printEasy(getFile("output.map"));
StopWatch.getStats().printEasy(getFile("time.map"));
if (create) stderr.println(virtualExecDir);
if (LogInfo.getNumErrors() > 0 || LogInfo.getNumWarnings() > 0)
stderr.printf("%d errors, %d warnings\n", LogInfo.getNumErrors(), LogInfo.getNumWarnings());
if (startMainTrack) end_track();
}
System.exit(exitCode);
}
@Override
public PrepareContractionHierarchies doWork() {
checkGraph();
if (prepareEncoder == null) throw new IllegalStateException("No vehicle encoder set.");
if (prepareWeighting == null) throw new IllegalStateException("No weight calculation set.");
allSW.start();
super.doWork();
initFromGraph();
if (!prepareEdges()) return this;
if (!prepareNodes()) return this;
contractNodes();
return this;
}
public void run() {
StopWatch st = null;
if (GPResourceHome.perfProfile.PROFILE) {
st = new StopWatch(false, false, true);
st.start();
}
StopWatch ct = new StopWatch();
int numWorkers = 0;
try {
if (GPResourceHome.commonState == null) {
GPResourceHome.load_common();
}
} catch (Exception e) {
e.printStackTrace();
}
ct.start();
while (true) {
if (GPResourceHome.perfProfile.PROFILE) {
st.stop();
GPResourceHome.perfProfile.addSample("notification_engine_worker", st.getElapsedTimeMX());
st.reset();
st.start();
}
GPResource gpResource = null;
try {
// logger.debug("gpResource.notificationWorkerQ.remove()...");
gpResource = (GPResource) GPResourceHome.commonState.getNextResource();
// gpResource =
// (GPResource)GPResourceHome.commonState.notificationWorkerQ.remove();//GPResourceHome.commonState.notificationQ.waitUntilNotEmpty();
boolean sentOK = false;
if (gpResource != null
&& gpResource.taskQ != null
&& gpResource.taskPendQ != null
&& (gpResource.taskQ.size() + gpResource.taskPendQ.size()) > 0)
// if (gpResource != null)
{
Task task = null;
// if (gpResource.DATA_AWARE_SCHEDULER && !gpResource.MAX_CACHE_HIT)
if (gpResource.DATA_AWARE_SCHEDULER) {
// synchronized(gpResource)
// {
// task = (Task)gpResource.taskQ.remove();
task = (Task) gpResource.taskQ.removeNoWait();
if (task == null) {
task = (Task) gpResource.taskPendQ.remove();
}
logger.debug(
"GPService:NotificationEngine:sendNotification(): removed task "
+ task.getExecutable().getId()
+ " from gpResource.taskQ... gpResource.taskQ.size() = "
+ gpResource.taskQ.size());
gpResource.taskPendQ.insert(task);
logger.debug(
"GPService:NotificationEngine:sendNotification(): inserted task "
+ task.getExecutable().getId()
+ " into gpResource.taskPendQ... gpResource.taskPendQ.size() = "
+ gpResource.taskPendQ.size());
// }
}
logger.debug(
"GPService:NotificationEngine:sendNotification(): key = "
+ String.valueOf(gpResource.resourceKey)
+ " ...");
// if (gpResourceHome.sendNotification(gpResource.resourceKey))
boolean sendNotificationTest = false;
if (gpResourceHome.useTCPCore) {
sendNotificationTest = gpResourceHome.sendNotificationTCPCore(gpResource);
}
// else if (gpResource.DATA_AWARE_SCHEDULER && !gpResource.MAX_CACHE_HIT)
else if (gpResource.DATA_AWARE_SCHEDULER) {
sendNotificationTest = gpResourceHome.sendNotification(gpResource, task);
} /*
else if (gpResourceHome.localFork)
{
sendNotificationTest = gpResourceHome.sendNotificationLocal(gpResource);
} */ else {
sendNotificationTest = gpResourceHome.sendNotification(gpResource);
}
if (sendNotificationTest) {
setNotificationsSent();
logger.debug(
"Notification for key "
+ String.valueOf(gpResource.resourceKey)
+ " sent successfully!");
// if (gpResource.DATA_AWARE_SCHEDULER)
// {
// gpResource.taskPendQ.insert(task);
// logger.debug("GPService:NotificationEngine:sendNotification(): inserted task into
// gpResource.taskPendQ... gpResource.taskPendQ.size() = " +
// gpResource.taskPendQ.size());
// }
// insert back in to try again later... this is a hack to ensure that we never run out
// of notification messages :)
// if (!gpResourceHome.useTCPCore)
// if (gpResource != null && gpResource.taskQ != null && (gpResource.taskQ.size() +
// gpResource.taskPendQ.size()) > 0 && (gpResource.taskQ.size() +
// gpResource.taskPendQ.size()) <= GPResourceHome.maxNumNotificationWorkerThreads*2)
// {
// logger.debug("there is still work to be collected and we have dipped below the
// number of notification threads, insert back into the notification queue...");
// GPResourceHome.commonState.notificationWorkerQ.insert(gpResource);
// }
} else {
logger.debug(
"Notification for key " + String.valueOf(gpResource.resourceKey) + " failed!");
// if (gpResource.DATA_AWARE_SCHEDULER && !gpResource.MAX_CACHE_HIT)
if (gpResource.DATA_AWARE_SCHEDULER) {
// synchronized(gpResource)
// {
// gpResource.taskPendQ.removeTask(task);
// should insert back at the front... fix this
// gpResource.taskQ.insertFront(task);
// }
// logger.debug("GPService:NotificationEngine:sendNotification(): inserted task " +
// task.getExecutable().getId() + " into gpResource.taskQ... gpResource.taskQ.size() =
// " + gpResource.taskQ.size());
}
// insert back in to try again later...
// if ((gpResource.taskQ.size() + gpResource.taskPendQ.size()) > 0)
// {
// logger.debug("there is still work to be collected, insert back into the
// notification queue...");
// GPResourceHome.commonState.notificationWorkerQ.insert(gpResource);
// used for throtling notifications...
/*
try
{
System.currentTimeMillis();
Thread.sleep(20);
}
catch (Exception sss)
{
} */
// }
}
}
if (MAX_NOT_PER_SEC > 0 && getNotificationsSent() >= MAX_NOT_PER_SEC) {
long timeLeft = NOT_TIME_QUANTA - ct.getElapsedTime();
if (timeLeft > 20)
try {
logger.debug(
getNotificationsSent()
+ " notifications sent in "
+ ct.getElapsedTime()
+ " ms, sleeping for "
+ timeLeft
+ " ms");
// System.currentTimeMillis();
Thread.sleep(timeLeft);
} catch (Exception sss) {
}
}
if (ct.getElapsedTime() >= NOT_TIME_QUANTA) {
if (getNotificationsSent() > 0) {
logger.debug(
"***NotificationEngineWorker(): "
+ getNotificationsSent()
+ " notifications sent to workers in "
+ ct.getElapsedTime()
+ " ms, maximum allowed notifications "
+ MAX_NOT_PER_SEC
+ " per "
+ NOT_TIME_QUANTA
+ " ms...");
}
ct.reset();
resetNotificationsSent();
ct.start();
}
// if (GPResourceHome.commonState.resourceQ.size() > 0 &&
// GPResourceHome.commonState.getWaitingTasks() <= 0)
if (GPResourceHome.commonState.getWaitingTasks() <= 0) {
try {
Thread.sleep(100);
} catch (Exception e) {
if (logger.isDebugEnabled()) e.printStackTrace();
}
}
} catch (Exception eee) {
logger.debug("Error in NotificationEngineWorker thread: " + eee);
if (logger.isDebugEnabled()) eee.printStackTrace();
// continue;
// if (gpResource != null && gpResource.taskQ != null && gpResource.taskQ.size() +
// gpResource.taskPendQ.size() > 0)
// if (gpResource != null && gpResource.taskQ != null)
// {
// logger.debug("there is still work to be collected, insert back into the notification
// queue...");
// GPResourceHome.commonState.notificationWorkerQ.insert(gpResource);
// }
}
}
}
void contractNodes() {
meanDegree = g.getAllEdges().getMaxId() / g.getNodes();
int level = 1;
counter = 0;
int initSize = sortedNodes.getSize();
int logSize =
(int) Math.round(Math.max(10, sortedNodes.getSize() / 100 * logMessagesPercentage));
if (logMessagesPercentage == 0) logSize = Integer.MAX_VALUE;
// preparation takes longer but queries are slightly faster with preparation
// => enable it but call not so often
boolean periodicUpdate = true;
StopWatch periodSW = new StopWatch();
int updateCounter = 0;
int periodicUpdatesCount =
Math.max(10, sortedNodes.getSize() / 100 * periodicUpdatesPercentage);
if (periodicUpdatesPercentage == 0) periodicUpdate = false;
// disable as preparation is slower and query time does not benefit
int lastNodesLazyUpdates =
lastNodesLazyUpdatePercentage == 0
? 0
: sortedNodes.getSize() / 100 * lastNodesLazyUpdatePercentage;
StopWatch lazySW = new StopWatch();
// Recompute priority of uncontracted neighbors.
// Without neighborupdates preparation is faster but we need them
// to slightly improve query time. Also if not applied too often it decreases the shortcut
// number.
boolean neighborUpdate = true;
if (neighborUpdatePercentage == 0) neighborUpdate = false;
StopWatch neighborSW = new StopWatch();
LevelGraphStorage lg = ((LevelGraphStorage) g);
while (!sortedNodes.isEmpty()) {
// periodically update priorities of ALL nodes
if (periodicUpdate && counter > 0 && counter % periodicUpdatesCount == 0) {
periodSW.start();
sortedNodes.clear();
int len = g.getNodes();
for (int node = 0; node < len; node++) {
if (g.getLevel(node) != 0) continue;
int priority = oldPriorities[node] = calculatePriority(node);
sortedNodes.insert(node, priority);
}
periodSW.stop();
updateCounter++;
}
if (counter % logSize == 0) {
// TODO necessary?
System.gc();
logger.info(
Helper.nf(counter)
+ ", updates:"
+ updateCounter
+ ", nodes: "
+ Helper.nf(sortedNodes.getSize())
+ ", shortcuts:"
+ Helper.nf(newShortcuts)
+ ", dijkstras:"
+ Helper.nf(dijkstraCount)
+ ", t(dijk):"
+ (int) dijkstraSW.getSeconds()
+ ", t(period):"
+ (int) periodSW.getSeconds()
+ ", t(lazy):"
+ (int) lazySW.getSeconds()
+ ", t(neighbor):"
+ (int) neighborSW.getSeconds()
+ ", meanDegree:"
+ (long) meanDegree
+ ", algo:"
+ algo.getMemoryUsageAsString()
+ ", "
+ Helper.getMemInfo());
dijkstraSW = new StopWatch();
periodSW = new StopWatch();
lazySW = new StopWatch();
neighborSW = new StopWatch();
}
counter++;
int polledNode = sortedNodes.pollKey();
if (sortedNodes.getSize() < lastNodesLazyUpdates) {
lazySW.start();
int priority = oldPriorities[polledNode] = calculatePriority(polledNode);
if (!sortedNodes.isEmpty() && priority > sortedNodes.peekValue()) {
// current node got more important => insert as new value and contract it later
sortedNodes.insert(polledNode, priority);
lazySW.stop();
continue;
}
lazySW.stop();
}
// contract!
newShortcuts += addShortcuts(polledNode);
g.setLevel(polledNode, level);
level++;
EdgeSkipIterator iter = vehicleAllExplorer.setBaseNode(polledNode);
while (iter.next()) {
int nn = iter.getAdjNode();
if (g.getLevel(nn) != 0)
// already contracted no update necessary
continue;
if (neighborUpdate && rand.nextInt(100) < neighborUpdatePercentage) {
neighborSW.start();
int oldPrio = oldPriorities[nn];
int priority = oldPriorities[nn] = calculatePriority(nn);
if (priority != oldPrio) sortedNodes.update(nn, oldPrio, priority);
neighborSW.stop();
}
if (removesHigher2LowerEdges) lg.disconnect(vehicleAllTmpExplorer, iter);
}
}
// Preparation works only once so we can release temporary data.
// The preparation object itself has to be intact to create the algorithm.
close();
logger.info(
"took:"
+ (int) allSW.stop().getSeconds()
+ ", new shortcuts: "
+ newShortcuts
+ ", "
+ prepareWeighting
+ ", "
+ prepareEncoder
+ ", removeHigher2LowerEdges:"
+ removesHigher2LowerEdges
+ ", dijkstras:"
+ dijkstraCount
+ ", t(dijk):"
+ (int) dijkstraSW.getSeconds()
+ ", t(period):"
+ (int) periodSW.getSeconds()
+ ", t(lazy):"
+ (int) lazySW.getSeconds()
+ ", t(neighbor):"
+ (int) neighborSW.getSeconds()
+ ", meanDegree:"
+ (long) meanDegree
+ ", initSize:"
+ initSize
+ ", periodic:"
+ periodicUpdatesPercentage
+ ", lazy:"
+ lastNodesLazyUpdatePercentage
+ ", neighbor:"
+ neighborUpdatePercentage);
}
