public synchronized void gatherLatestDatapointsLocking(long catId, int history) { waitForLock(); mDatapointCache.populateLatest(catId, history); TimeSeries ts = getSeriesByIdNonlocking(catId); if (ts == null) { unlock(); return; } if (ts.getDbRow().getSynthetic() == false) { ts.clearSeries(); EntryDbTable.Row entry = mDbh.fetchLastCategoryEntry(catId); if (entry != null) { ArrayList<Datapoint> l = mDatapointCache.getLast(catId, history); if (l == null || l.size() < 1 || entry.getTimestamp() > l.get(0).mMillis || entry.getValue() != l.get(0).mValue.y) { mDatapointCache.clearCache(catId); mDatapointCache.populateLatest(catId, history); l = mDatapointCache.getLast(catId, history); } l = aggregateDatapoints(l, ts.getDbRow().getType()); ts.setDatapoints(null, l, null, true); } } unlock(); }
private void aggregateDatapoints(TimeSeries ts) { ArrayList<Datapoint> pre; ArrayList<Datapoint> range; ArrayList<Datapoint> post; pre = aggregateDatapoints(ts.getVisiblePre(), ts.getDbRow().getType()); range = aggregateDatapoints(ts.getVisible(), ts.getDbRow().getType()); post = aggregateDatapoints(ts.getVisiblePost(), ts.getDbRow().getType()); ts.setDatapoints(pre, range, post, true); return; }
public synchronized void gatherSeries(long milliStart, long milliEnd) { ArrayList<Datapoint> pre, range, post; boolean has_data; long oldAggregationMs = mAggregationMs; mQueryStart = milliStart; mQueryEnd = milliEnd; setCollectionTimes(milliStart, milliEnd); for (int i = 0; i < mSeries.size(); i++) { has_data = false; TimeSeries ts = mSeries.get(i); if (ts == null || ts.getDbRow().getSynthetic()) continue; if (ts.isEnabled() == false) { boolean skip = true; for (int j = 0; j < ts.getDependees().size(); j++) { if (ts.getDependees().get(j).isEnabled() == true) { skip = false; break; } } if (skip == true) continue; } mDatapointCache.populateRange( ts.getDbRow().getId(), mCollectionStart, mCollectionEnd, mAggregationMs); pre = mDatapointCache.getDataBefore(ts.getDbRow().getId(), mHistory, mCollectionStart); if (pre != null && pre.size() > 0) has_data = true; range = mDatapointCache.getDataInRange(ts.getDbRow().getId(), mCollectionStart, mCollectionEnd); if (range != null && range.size() > 0) has_data = true; post = mDatapointCache.getDataAfter(ts.getDbRow().getId(), 1, mCollectionEnd); if (post != null && range.size() > 0) has_data = true; if (has_data == true) ts.setDatapoints(pre, range, post, true); } generateSynthetics(); ArrayList<TimeSeries> enabledSeries = getAllEnabledSeries(); for (int i = 0; i < enabledSeries.size(); i++) { aggregateDatapoints(enabledSeries.get(i)); } mAggregationMs = oldAggregationMs; return; }
public TimeSeries getSeriesByNameNonlocking(String name) { for (int i = 0; i < mSeries.size(); i++) { TimeSeries ts = mSeries.get(i); if (ts != null && ts.getDbRow().getCategoryName().equals(name)) return ts; } return null; }
private TimeSeries getSeriesByIdNonlocking(long catId) { for (int i = 0; i < mSeries.size(); i++) { TimeSeries ts = mSeries.get(i); if (ts != null && ts.getDbRow().getId() == catId) return ts; } return null; }
private void setDependees(TimeSeries ts) { ts.getDependees().clear(); for (int i = 0; i < mSeries.size(); i++) { TimeSeries dependee = getSeries(i); if (ts == null || dependee == null || ts == dependee) continue; if (dependee.getDbRow().getSynthetic() == true) { Formula formula = mFormulaCache.getFormula(dependee.getDbRow().getId()); ArrayList<String> names = formula.getDependentNames(); if (names != null && names.contains(ts.getDbRow().getCategoryName())) ts.addDependee(dependee); } } return; }
private void setDependents(TimeSeries synth) { if (synth.getDbRow().getSynthetic() == false) return; Formula formula = mFormulaCache.getFormula(synth.getDbRow().getId()); ArrayList<String> names = formula.getDependentNames(); if (names == null) return; synth.getDependents().clear(); for (int i = 0; i < mSeries.size(); i++) { TimeSeries ts = mSeries.get(i); if (ts == null || ts == synth) continue; if (names.contains(ts.getDbRow().getCategoryName())) synth.addDependent(ts); } return; }
public long getSeriesIdLocking(int i) { long id = -1; waitForLock(); TimeSeries ts = getSeries(i); if (ts != null) id = ts.getDbRow().getId(); unlock(); return id; }
public CategoryDbTable.Row getSeriesMetaLocking(int i) { CategoryDbTable.Row row = null; waitForLock(); TimeSeries ts = getSeries(i); row = new CategoryDbTable.Row(ts.getDbRow()); unlock(); return row; }
private void generateSynthetics() { for (int i = 0; i < mSeries.size(); i++) { TimeSeries synth = mSeries.get(i); if (synth == null || synth.getDbRow().getSynthetic() == false || synth.isEnabled() == false) continue; generateSynthetic(synth); } }
public void updateTimeSeriesData(long start, long end, boolean flushCache) { for (int i = 0; i < mSeries.size(); i++) { TimeSeries ts = mSeries.get(i); if (ts != null && ts.isEnabled() == true) { long catId = ts.getDbRow().getId(); updateTimeSeriesDataLocking(catId, start, end, flushCache); } } }
private void generateSynthetic(TimeSeries synth) { Formula formula = mFormulaCache.getFormula(synth.getDbRow().getId()); long ms; long firstVisibleMs = Long.MAX_VALUE; long lastVisibleMs = Long.MIN_VALUE; for (int j = 0; j < synth.getDependents().size(); j++) { TimeSeries ts = synth.getDependents().get(j); List<Datapoint> range = ts.getVisible(); if (range != null) { ms = range.get(0).mMillis; if (ms < firstVisibleMs) firstVisibleMs = ms; ms = range.get(range.size() - 1).mMillis; if (ms > lastVisibleMs) lastVisibleMs = ms; } } ArrayList<Datapoint> calculated = formula.apply(synth.getDependents()); ArrayList<Datapoint> pre = new ArrayList<Datapoint>(); ArrayList<Datapoint> visible = new ArrayList<Datapoint>(); ArrayList<Datapoint> post = new ArrayList<Datapoint>(); for (int j = 0; j < calculated.size(); j++) { Datapoint d = calculated.get(j); d.mCatId = synth.getDbRow().getId(); d.mSynthetic = true; if (d.mMillis < firstVisibleMs) pre.add(d); else if (d.mMillis <= lastVisibleMs) visible.add(d); else post.add(d); } pre = aggregateDatapoints(pre, synth.getDbRow().getType()); visible = aggregateDatapoints(visible, synth.getDbRow().getType()); post = aggregateDatapoints(post, synth.getDbRow().getType()); synth.setDatapoints(pre, visible, post, true); }
public synchronized void updateCategoryTrend(long catId) { String trendStr = "trend_unknown"; float stdDev = 0.0f; float lastTrend = 0.0f; float newTrend = 0.0f; gatherLatestDatapointsLocking(catId, mHistory); TimeSeries ts = getSeriesByIdLocking(catId); if (ts == null) return; if (ts.getDbRow().getSynthetic() == true) return; lastTrend = ts.getTrendStats().mTrendPrev; newTrend = ts.getTrendStats().mTrend; stdDev = ts.getValueStats().mStdDev; TrendState state = Number.getTrendState(lastTrend, newTrend, ts.getDbRow().getGoal(), mSensitivity, stdDev); trendStr = Number.mapTrendStateToString(state); mDbh.updateCategoryTrend(catId, trendStr, newTrend); if (ts.getDependees() != null && ts.getDependees().size() > 0) { for (int i = 0; i < ts.getDependees().size(); i++) { TimeSeries dependee = ts.getDependees().get(i); for (int j = 0; j < dependee.getDependents().size(); j++) { TimeSeries tmp = dependee.getDependents().get(j); if (tmp != null) gatherLatestDatapointsLocking(tmp.getDbRow().getId(), mHistory); } Formula formula = mFormulaCache.getFormula(dependee.getDbRow().getId()); ArrayList<Datapoint> calculated = formula.apply(dependee.getDependents()); dependee.setDatapoints(null, calculated, null, true); lastTrend = dependee.getTrendStats().mTrendPrev; newTrend = dependee.getTrendStats().mTrend; stdDev = dependee.getValueStats().mStdDev; state = Number.getTrendState( lastTrend, newTrend, dependee.getDbRow().getGoal(), mSensitivity, stdDev); trendStr = Number.mapTrendStateToString(state); mDbh.updateCategoryTrend(dependee.getDbRow().getId(), trendStr, newTrend); } } }