adaptive-monitoring-framework

diff --git a/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/MonitoringCycle.java b/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/MonitoringCycle.java
index d7afe7f..d6de8df 100644
--- a/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/MonitoringCycle.java
+++ b/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/MonitoringCycle.java
@@ -3,20 +3,24 @@ package br.ufrgs.inf.prosoft.tigris.sampling;
 public class MonitoringCycle {
     private double averageProcTimesSample;
     private double stdProcTimesSample;
+    private final FrequencyDataSet sample;
     private double averageProcTimesPopulation;
     private double stdProcTimesPopulation;
     private long sampleSize;
     private long populationSize;
+    private final FrequencyDataSet population;
     private long monitoringCycleTime;
 
     public MonitoringCycle(FrequencyDataSet sample, FrequencyDataSet population, long monitoringCycleTime) {
         this.averageProcTimesSample = sample.getMeanExecutionTime();
         this.stdProcTimesSample = sample.getStdExecutionTime();
         this.sampleSize = sample.getTotalItems();
+        this.sample = sample;
 
         this.averageProcTimesPopulation = population.getMeanExecutionTime();
         this.stdProcTimesPopulation = population.getStdExecutionTime();
         this.populationSize = population.getTotalItems();
+        this.population = population;
         this.monitoringCycleTime = monitoringCycleTime;
     }
 
@@ -28,6 +32,8 @@ public class MonitoringCycle {
         this.stdProcTimesPopulation = 0;
         this.populationSize = 0;
         this.monitoringCycleTime = 0;
+        this.sample = new FrequencyDataSet();
+        this.population = new FrequencyDataSet();
     }
 
     public long getMonitoringCycleTime() {

diff --git a/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/Sampling.java b/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/Sampling.java
index 846e92a..55ea996 100644
--- a/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/Sampling.java
+++ b/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/Sampling.java
@@ -227,14 +227,17 @@ public class Sampling {
 
     //sample proportion is the same as population
     private boolean isSameProportion(double decayingConfidenceFactor) {
+        if (decayingConfidenceFactor == 0.0) //maximum cycle time reached
+            return true;
+
         return population.getGranularities().stream().allMatch(
                 granularity -> {
                     double popProportion = population.getProportion(granularity);
                     double samProportion = sample.getProportion(granularity);
                     double error = popProportion - (popProportion * decayingConfidenceFactor);
 
-                    return samProportion <= popProportion + error &&
-                            samProportion >= popProportion - error;
+                    return (samProportion > popProportion) || (samProportion <= popProportion + error &&
+                            samProportion >= popProportion - error);
                 });
     }
 
@@ -350,6 +353,7 @@ public class Sampling {
         if (samplingRate < 0.01)
             samplingRate = 0.01;
 
+        this.resetSamplingDistribution();
         return getSamplingRate();
     }
 }

diff --git a/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/SamplingAspect.java b/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/SamplingAspect.java
index cacd089..ee10160 100644
--- a/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/SamplingAspect.java
+++ b/tigris/src/main/java/br/ufrgs/inf/prosoft/tigris/sampling/SamplingAspect.java
@@ -3,6 +3,7 @@ package br.ufrgs.inf.prosoft.tigris.sampling;
 import br.ufrgs.inf.prosoft.tigris.configuration.annotation.TigrisConfiguration;
 import br.ufrgs.inf.prosoft.tigris.exceptions.ConfigurationException;
 import br.ufrgs.inf.prosoft.tigris.utils.ConfigurationUtils;
+import org.apache.commons.math3.stat.descriptive.SummaryStatistics;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
@@ -10,6 +11,12 @@ import org.aspectj.lang.annotation.Pointcut;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.OptionalDouble;
+import java.util.Set;
+
 import static java.lang.System.nanoTime;
 
 @Aspect
@@ -82,7 +89,7 @@ public class SamplingAspect implements Runnable {
 
     static Logger logger = LoggerFactory.getLogger(SamplingAspect.class);
 
-    public static boolean enabled = false;
+    public static boolean enabled = true;
 
     public static boolean samplingEnabled = true;
 
@@ -118,14 +125,30 @@ public class SamplingAspect implements Runnable {
     }
 
     public static boolean adaptSamplingRateInverselyProportionalOps = false;
-    public static void addOperationsPerSecondAndAdapt (int operationsPerSecond) {
+
+    public static void computeCycle (int sec, Set<Integer> markers) {
+        if (!sampling.isAdaptiveSamplingRate() && markers != null && markers.contains(sec)) {
+            if (samplingEnabled) { //uniform or inversely proportional
+                final MonitoringCycle monitoringCycle = sampling.endMonitoringCycle();
+                mseMap.put(sec, monitoringCycle.getAverageProcTimesSample());
+            } else { //no monitoring
+                OptionalDouble mean = monitoring.currentMonitoring.values().stream().mapToDouble(SummaryStatistics::getMean)
+                        .average();
+                monitoring.currentMonitoring.clear();
+                mseMap.put(sec, mean.getAsDouble());
+            }
+        }
+    }
+
+    public static void addOperationsPerSecondAndAdapt (int operationsPerSecond, int sec, Set<Integer> markers) {
+        computeCycle(sec, markers);
 
         if (adaptSamplingRateInverselyProportionalOps) {
             currentSamplingRate = sampling.adaptSamplingRateInverselyProportional(operationsPerSecond);
             return;
         }
 
-        if (SamplingAspect.enabled && sampling.isAdaptiveSamplingRate()) {
+        if (sampling.isAdaptiveSamplingRate()) {
             currentSamplingRate = sampling.getSamplingRate();
             currentNormalBehavior = monitoring.baselinesPerSecondToNormal.getPercentile(50);
             currentNormalMonitoring = monitoring.monitoringPerSecondToNormal.getPercentile(50);
@@ -141,11 +164,16 @@ public class SamplingAspect implements Runnable {
 
             if (!sampling.isPerformanceBaselineEnabled() && sampling.isReady()) {
                 logger.info("Sample is ready, releasing for analysis and resetting...");
+                mseMap.put(sec, sampling.getSample().getMeanExecutionTime());
+                cycleMarkers.add(sec);
                 cycle = sampling.endMonitoringCycle();
             }
         }
     }
 
+    public static Map<Integer, Double> mseMap = new HashMap<>();
+    public static Set<Integer> cycleMarkers = new HashSet<>();
+
     public static PerformanceBaselineDataSet monitoring = new PerformanceBaselineDataSet();
 
     static double currentSamplingRate;