/** * Searches the directory for a data page with enough free space to store a record of the given * size. If no suitable page is found, this creates a new data page. */ protected PageId getAvailPage(int reclen) { for (int i = 0; i < pages.size(); i++) { PageId pid = pages.get(i); Page page = new Page(); global.Minibase.BufferManager.pinPage(pid, page, false); HFPage hfpage = new HFPage(); hfpage.copyPage(page); if (hfpage.getFreeSpace() >= reclen) { global.Minibase.BufferManager.unpinPage(pid, true); return pid; } global.Minibase.BufferManager.unpinPage(pid, false); } Page page = new Page(); PageId pid = global.Minibase.BufferManager.newPage(page, 1); HFPage hfpage = new HFPage(page); // initialize HFPage hfpage.setCurPage(pid); pages.add(pid); pids.add(pid.pid); current.setNextPage(pid); hfpage.setPrevPage(current.getCurPage()); current = hfpage; global.Minibase.BufferManager.unpinPage(pid, true); return pid; }
/** * Deletes the heap file from the database, freeing all of its pages. * * @throws ChainException */ public void deleteFile() throws ChainException { if (delete) throw new ChainException(null, "files have already been deleted"); for (int i = 0; i < pages.size(); i++) try { global.Minibase.DiskManager.deallocate_page(pages.get(i)); } catch (Exception e) { throw new ChainException(null, "fail to deallocate page"); } global.Minibase.DiskManager.delete_file_entry(name); pages = null; pids = null; recordNumber = 0; delete = true; }
/** * Inserts a new record into the file and returns its RID. * * @throws IllegalArgumentException if the record is too large */ public RID insertRecord(byte[] record) throws IllegalArgumentException, ChainException { if (record.length > GlobalConst.MAX_TUPSIZE) throw new IllegalArgumentException("the record's size is too large"); for (int i = 0; i < pages.size(); i++) { PageId pid = pages.get(i); Page page = new Page(); global.Minibase.BufferManager.pinPage(pid, page, false); HFPage hfpage = new HFPage(page); hfpage.setCurPage(pid); hfpage.setData(page.getData()); if (hfpage.getFreeSpace() > record.length) { RID rid = hfpage.insertRecord(record); recordNumber++; global.Minibase.BufferManager.unpinPage(pid, true); return rid; } global.Minibase.BufferManager.unpinPage(pid, false); } Page page = new Page(); PageId pid = global.Minibase.BufferManager.newPage(page, 1); HFPage hfpage = new HFPage(page); // initialize HFPage hfpage.initDefaults(); hfpage.setCurPage(pid); // hfpage.print(); RID rid = hfpage.insertRecord(record); pages.add(pid); pids.add(pid.pid); hfpage.setNextPage(pid); hfpage.setPrevPage(current.getCurPage()); current = hfpage; global.Minibase.BufferManager.unpinPage(pid, true); // hfpage.print(); // System.out.println ("The PID is "+pid); recordNumber++; return rid; }
// TODO : if start or end is already in the highway, will occur the problem, need to fix public static double routingHierarchy( long startNode, long endNode, int startTime, int dayIndex, ArrayList<Long> pathNodeList) { // System.out.println("start finding the path..."); int debug = 0; try { if (!OSMData.nodeHashMap.containsKey(startNode) || !OSMData.nodeHashMap.containsKey(endNode)) { System.err.println("cannot find start or end node!"); return -1; } if (startNode == endNode) { System.out.println("start node is the same as end node."); return 0; } NodeInfo start = OSMData.nodeHashMap.get(startNode); NodeInfo end = OSMData.nodeHashMap.get(endNode); double minDistance = Geometry.calculateDistance(start.getLocation(), end.getLocation()); if (minDistance < 5) { // use normal A* algorithm to calculate small distance return routingAStar( start.getNodeId(), end.getNodeId(), OSMRouteParam.START_TIME, OSMRouteParam.DAY_INDEX, pathNodeList); } SearchingSharing sharingData = new SearchingSharing(); HashMap<Long, NodeInfoHelper> nodeForwardCache = new HashMap<Long, NodeInfoHelper>(); HashMap<Long, NodeInfoHelper> nodeReverseCache = new HashMap<Long, NodeInfoHelper>(); ForwardSearching forwardSearching = new ForwardSearching( startNode, endNode, startTime, dayIndex, sharingData, nodeForwardCache); ReverseSearching reverseSearching = new ReverseSearching(endNode, startNode, sharingData, nodeReverseCache); // two thread run simultaneously Thread forwardThread = new Thread(forwardSearching); Thread reverseThread = new Thread(reverseSearching); // search forward forwardThread.start(); // let forward searching for a while // Thread.sleep(100); // search reverse reverseThread.start(); // waiting for thread finish forwardThread.join(); reverseThread.join(); // get the searching intersects ArrayList<Long> intersectList = sharingData.getIntersectList(); // pick the least cost one according to time-dependent double minCost = Double.MAX_VALUE; ArrayList<Long> minCostPath = new ArrayList<Long>(); for (long intersect : intersectList) { NodeInfoHelper current = nodeForwardCache.get(intersect); // cost from source to intersect double cost = current.getCost(); current = nodeReverseCache.get(intersect); // update the reverse cost as forward cost current.setCost(cost); ArrayList<Long> reversePath = new ArrayList<Long>(); double totalCost = Double.MAX_VALUE; // recalculate from intersect to destination while (true) { long nodeId = current.getNodeId(); int timeIndex = startTime + (int) (current.getCost() / OSMParam.SECOND_PER_MINUTE / OSMRouteParam.TIME_INTERVAL); if (timeIndex > OSMRouteParam.TIME_RANGE - 1) // time [6am - 9 pm], we regard times after 9pm as constant edge weights timeIndex = OSMRouteParam.TIME_RANGE - 1; long nextNodeId = current.getParentId(); double arriveTime = current.getCost(); // arrive end if (nextNodeId == 0) { totalCost = arriveTime; break; } // add node reversePath.add(nextNodeId); // calculate cost according adjlist LinkedList<ToNodeInfo> adjNodeList = OSMData.adjListHashMap.get(nodeId); double costTime = 0; for (ToNodeInfo toNode : adjNodeList) { if (toNode.getNodeId() == nextNodeId) { int travelTime; // forward searching is time dependent if (toNode.isFix()) // fix time travelTime = toNode.getTravelTime(); else // fetch from time array travelTime = toNode.getSpecificTravelTime(dayIndex, timeIndex); costTime = arriveTime + (double) travelTime / OSMParam.MILLI_PER_SECOND; break; } } current = nodeReverseCache.get(nextNodeId); if (costTime == 0) System.err.println("cost time cannot be zero!"); else current.setCost(costTime); } // process the left nodes to real destination long lastNode = reversePath.get(reversePath.size() - 1); if (lastNode != endNode) { NodeInfo last = OSMData.nodeHashMap.get(lastNode); NodeInfo dest = OSMData.nodeHashMap.get(endNode); EdgeInfo onEdge = last.getEdgeFromNodes(dest); current = nodeReverseCache.get(lastNode); int totalDistance = onEdge.getDistance(); int distance; long toNodeId; if (onEdge.getStartNode() == lastNode) { // from start to middle distance = onEdge.getStartDistance(endNode); toNodeId = onEdge.getEndNode(); } else { // from end to middle distance = onEdge.getEndDistance(endNode); toNodeId = onEdge.getStartNode(); } LinkedList<ToNodeInfo> adjNodeList = OSMData.adjListHashMap.get(lastNode); double costTime = 0; int timeIndex = startTime + (int) (totalCost / OSMParam.SECOND_PER_MINUTE / OSMRouteParam.TIME_INTERVAL); if (timeIndex > OSMRouteParam.TIME_RANGE - 1) // time [6am - 9 pm], we regard times after 9pm as constant edge weights timeIndex = OSMRouteParam.TIME_RANGE - 1; for (ToNodeInfo toNode : adjNodeList) { if (toNode.getNodeId() == toNodeId) { int travelTime; // forward searching is time dependent if (toNode.isFix()) // fix time travelTime = toNode.getTravelTime(); else // fetch from time array travelTime = toNode.getSpecificTravelTime(dayIndex, timeIndex); costTime = (double) travelTime / OSMParam.MILLI_PER_SECOND; break; } } if (costTime != 0) { costTime *= (double) distance / totalDistance; } totalCost += costTime; // add cost reversePath.add(endNode); // add dest } // if found less cost path, build forward path if (totalCost < minCost) { ArrayList<Long> forwardPath = new ArrayList<Long>(); minCost = totalCost; current = nodeForwardCache.get(intersect); long traceNodeId = current.getParentId(); while (traceNodeId != 0) { forwardPath.add(traceNodeId); // add node current = nodeForwardCache.get(traceNodeId); traceNodeId = current.getParentId(); } Collections.reverse(forwardPath); // reverse the path list // record min-cost path, combine forward path and reverse path minCostPath = new ArrayList<Long>(); minCostPath.addAll(forwardPath); minCostPath.add(intersect); minCostPath.addAll(reversePath); // output kml // OSMOutput.generatePathKML(nodeHashMap, pathNodeList, "path_" + intersect); // ArrayList<Long> intersectNode = new ArrayList<Long>(); // intersectNode.add(intersect); // OSMOutput.generatePathNodeKML(nodeHashMap, intersectNode, "intersect_" + intersect); } } pathNodeList.addAll(minCostPath); return minCost; } catch (Exception e) { e.printStackTrace(); System.err.println("routingHierarchy: debug code " + debug); } return 0; }