public Granularity getGranularity() { return layer.getGranularity(); }
private void assertGranularitiesAreNested() { for (int i=1; i<layers.size(); i++) { Granularity prev = layers.get(i - 1).getGranularity(); Granularity cur = layers.get(i).getGranularity(); if (cur.alignsOnGranularity(prev) == false) { throw new IllegalArgumentException("Granularity [" + cur + "] is not a multiple of [" + prev + "]"); } } }
public int compareTo(GranularityLayer o) { return gran.compareTo(o.getGranularity()); } }
void assertLayerTimeEncapsulatesChild(Time now) { for (int i=1; i<layers.size(); i++) { TimeRange prev = layers.get(i - 1).getTotalRange(now); TimeRange cur = layers.get(i).getTotalRange(now); if (cur.containsOrAlignsWith(prev) == false) { throw new IllegalArgumentException("Granularity [" + layers.get(i).getGranularity() + "] does not encapsulate the time of [" + layers.get(i - 1).getGranularity() + "]: cur=" + cur + " prev=" + prev); } } }
public void logStructure(RollUpStructure struct) { if (!logging) { return; } long totCells = 0; log.info("Metric rollup structure constructed:"); for (GranularityLayer layer : struct.getLayers()) { long cells = layer.getNumCells(); totCells += cells; log.info(String.format("Granularity=%-20s %d cells", layer.getGranularity(), Long.valueOf(cells))); } log.info("Total cells used: " + totCells); }
private void initFrozenLayers() { this.layersAscending = new ArrayList<FrozenGranularityLayer>(); this.layersDescending = new LinkedList<FrozenGranularityLayer>(); this.frozenLayers = new HashMap<Granularity, FrozenGranularityLayer>(); FrozenGranularityLayer child = null; for (GranularityLayer layer : getLayers()) { FrozenGranularityLayer frozen = new FrozenGranularityLayer(layer, child, time); frozenLayers.put(layer.getGranularity(), frozen); layersAscending.add(frozen); layersDescending.add(0, frozen); child = frozen; } }
private static GranularityList makeGranularityListFromStruct(RollUpStructure struct) { List<Granularity> grans = new ArrayList<Granularity>(); for (GranularityLayer layer : struct.getLayers()) { grans.add(layer.getGranularity()); } return new GranularityList(grans); }
/** * @param layersList A list of layers, with granularities in increasing order. Each layer's * granularity must be a multiple of the previous layer. */ public RollUpStructure(List<GranularityLayer> layersList) { layers = unmodifiableList(layersList); layerMap = new HashMap<Granularity, GranularityLayer>(); for (GranularityLayer layer : layersList) { layerMap.put(layer.getGranularity(), layer); } Time fakeNow = Time.inDays(1000); assertStructureIsValid(fakeNow); }
private void assertStructureValid() { for (GranularityLayer layer : struct.getLayers()) { PageDefinition def = pageDefs.getDefinition(layer.getGranularity()); Granularity width = def.getPageWidth(); if (layer.getTotalTime().isSmallerThan(width.times(numPagesPerLayer)) == false) { throw new IllegalStateException(width + " times " + numPagesPerLayer + " not bigger than layer " + layer.getGranularity() + " width of " + layer.getTotalTime()); } long entriesPerPage = def.getEntriesPerPage(); if (entriesPerPage < 3) { throw new IllegalStateException("Layer " + layer.getGranularity() + " does not have >= 3 entries per page"); } if (entriesPerPage >= 30) { throw new IllegalStateException("Layer " + layer.getGranularity() + " has " + entriesPerPage + "entries per page. We want < 30"); } if (!width.isEvenMultipleOf(layer.getGranularity())) { throw new IllegalStateException("Width of page " + width + " for gran=" + layer.getGranularity() + " is not an even multiple of " + layer.getGranularity()); } } }
void assertNoCellHasPartialChildren(Time now) { for (int i=1; i<layers.size(); i++) { GranularityLayer childLayer = layers.get(i-1); TimeRange prev = childLayer.getTotalRange(now); Granularity curGran = layers.get(i).getGranularity(); if (!prev.getStartTime().alignsOnGranularity(curGran)) { throw new IllegalArgumentException("Granularity [" + childLayer.getGranularity() + "] starts at time [" + prev.getStartTime() + " which does not align on parent granularity [" + curGran + "]"); } if (!prev.getEndTime().alignsOnGranularity(curGran)) { throw new IllegalArgumentException("Granularity [" + childLayer.getGranularity() + "] ends at time [" + prev.getEndTime() + " which does not align on parent granularity [" + curGran + "]"); } } }
FrozenCell(FrozenGranularityLayer granLayer, TimeRange timeRange) { layer = granLayer; range = timeRange; if(timeRange.getDuration() != granLayer.getLayer().getGranularity().getNanos()) { throw new IllegalArgumentException("Cell with range [" + timeRange + "] does not exist in layer [" + granLayer + "]"); } }
public TimeRangeSplitter makeSplitter(FrozenRollUpStructure struct, FuzzyTimeRange range, int minCells) { GranularityLayer smallestLayer = findSmallestUsableLayer(struct, range, minCells); return new TimeRangeSplitter(struct, smallestLayer.getGranularity()); }
GranularityTimes getOldestAllowedTimesOrEndTime(Time endTime) { GranularityTimes oldestAllowedTimes = getOldestAllowedTimeForGranularity(); for (GranularityLayer g : struct.getLayers()) { if (endTime.isAfter(oldestAllowedTimes.get(g.getGranularity()))) { oldestAllowedTimes.put(g.getGranularity(), endTime); } } return oldestAllowedTimes; }
/** * Makes a page definition which satisfies the layer requirements. * * The following is true about the result: * The page's width will be a multiple of the layer's entry granularity * The page's width * pagesPerLayer will be >= the layer's total time */ private static PageDefinition makeDefinitionForLayer(GranularityLayer layer, int pagesPerLayer) { Time pageWidth = layer.getTotalTime().divideBy(pagesPerLayer - 1); Time alignedWidth = pageWidth.alignUpToGranularity(layer.getGranularity()); return new PageDefinition(layer.getGranularity(), alignedWidth.asGranularity()); }
Granularity gran = layer.getGranularity(); TimeRange fillableRange = timeRange.intersect(getTotalRange()); if (fillableRange == null) {
/** * Returns the smallest layer which should be used to make a query for minCells across the given range. */ public GranularityLayer findSmallestUsableLayer(FrozenRollUpStructure struct, FuzzyTimeRange range, int minCells) { Granularity requiredGran = Granularity.inNanos(range.getIn().getDuration() / minCells); GranularityLayer useLayer = null; for (GranularityLayer layer : struct.getLayers()) { Granularity layerGran = layer.getGranularity(); if (layerGran.isBiggerThan(requiredGran)) { break; } else { useLayer = layer; } } if (useLayer == null) { return struct.getLayers().get(0); } return useLayer; } }