public Granularity getGranularity() { return layer.getGranularity(); }
/** * 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()); }
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); }
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); } } }
/** * Returns the total time range contained by this layer at the given time. */ public TimeRange getTotalRange(Time now) { Time startGranOffset = Time.inNanos(bigGran.getNanos() * bigGransIncludeStart); Time startTime = now.alignDownToGranularity(bigGran).plus(startGranOffset); if (startTime.isBefore(Time.inNanos(0))) { throw new IllegalArgumentException("Layer start time went negative. Use a bigger 'now'. now=" + now); } return TimeRange.between(startTime, startTime.plus(getTotalTime())); }
private GranularityLayer makeSingleLayerFromSpec(GranularitySpec spec) { Granularity gran = spec.gran; return new GranularityLayer(gran, gran.times(2), spec.includeStart.divideBy(gran), spec.excludeStart.divideBy(gran)); }
/** * Return the total range that the layer defines. */ public TimeRange getTotalRange() { if (range == null) { range = layer.getTotalRange(time); } return range; }
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 + "]"); } } }
public RollUpStructure build() { if (specs.size() < 1) { throw new IllegalStateException("Attempted to build a structure with < 1 layer"); } if (specs.size() == 1) { return new RollUpStructure(Arrays.asList(makeSingleLayerFromSpec(specs.get(0)))); } sort(specs); massageFinestSpecToAlignOnParentGranularity(); massageSpecsWithAutoEndTimes(); massageSpecsToAlignOnParentGranularities(); massageLargestSpecToContainChildGranularity(); List<GranularityLayer> layers = new ArrayList<GranularityLayer>(); for (int i=0; i<specs.size(); i++) { GranularitySpec spec = specs.get(i); Granularity gran = spec.gran; Granularity parentGran = spec.gran; if (i != specs.size() - 1) { parentGran = specs.get(i+1).gran; } layers.add(new GranularityLayer(gran, parentGran, spec.includeStart.divideBy(gran), spec.excludeStart.divideBy(gran))); } return new RollUpStructure(layers); }
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 + "]"); } } }
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()); } } }
public int compareTo(GranularityLayer o) { return gran.compareTo(o.getGranularity()); } }
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); }
public TimeRangeSplitter makeSplitter(FrozenRollUpStructure struct, FuzzyTimeRange range, int minCells) { GranularityLayer smallestLayer = findSmallestUsableLayer(struct, range, minCells); return new TimeRangeSplitter(struct, smallestLayer.getGranularity()); }
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 + "]"); } }
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; }
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; } }