private long countExecutionTypes(List<OverlappingExecution> overlappings, Overlapping countFor) {
long result = 0;
for (OverlappingExecution eachOverLapping : overlappings) {
if (eachOverLapping.getMode() == countFor) {
result++;
}
}
return result;
}
// overlapinfo = Eine Unit und welche Executions sich mit den Executions der Unit überlappen (kann
// sich auch mit sich selbst überlappen)
// execution info, eine Unit und welche Executions diese hat
public Map<Unit, Map<Unit, Double>> assesOverlappingRisk(
Map<Unit, List<OverlappingExecution>> overlapInfo,
Map<Unit, List<UnitExecution>> executionInfo) {
ConcurrentHashMap<Unit, Map<Unit, Double>> hiddenConcurrencyRiskFactors =
new ConcurrentHashMap<>();
for (final Entry<Unit, List<UnitExecution>> eachUnit : executionInfo.entrySet()) {
Unit unit = eachUnit.getKey();
List<UnitExecution> executions = eachUnit.getValue();
// wie oft wurde die Unit ausgeführt
final int executionCount = executions.size();
// gives me the executions that overlap with the specific unit of this loop
List<OverlappingExecution> overlap = overlapInfo.get(unit);
// holds all overlappings of the the sepcific unit of this loop iteration
// separated by the unit which it is overlapping to (can include itself)
// So I know that my current unit overlaps with this units in this list and how often and how
// intense (overlappingmode)
// allowing me to determine the overlapping risk from unit A with each other unit
// mainly this filteres out NoOverlappingOccurrences
ConcurrentHashMap<Unit, List<OverlappingExecution>> specificOverlapping =
new ConcurrentHashMap<>();
// filtering of no overlapping modes
// separating each overlapping based on the unit that produced it
for (OverlappingExecution eachOverlapping : overlap) {
if (eachOverlapping.getMode() != Overlapping.NoOverlapping) {
Unit overlappingUnit = eachOverlapping.getUnit();
List<OverlappingExecution> overlapingsList = specificOverlapping.get(overlappingUnit);
if (overlapingsList == null) {
overlapingsList = new ArrayList<>();
specificOverlapping.put(overlappingUnit, overlapingsList);
}
overlapingsList.add(eachOverlapping);
}
}
// calculate overlapping factor for each unit which the current list iteration unit has
// overlappings with
// the factor depends currently only on the total amount of executions of the iteration unit
// Checks, for example, if executions of this unit always overlap with executions of a
// different unit
// the concurrentExecution risk factor is normalized to 1
/*It uses the type of the concurrency
*The amount of concurrent Executions
*The relative amount of concurrent executions (all Executions to Concurrent Executions)
*Always for to Units A and B, to determine how likely A is executed and at the same time a execution of B occurs
*/
ConcurrentHashMap<Unit, Double> hiddenConcurrencyRiskFactor = new ConcurrentHashMap<>();
// key and the unit in the overlapping execution must be equal
// because this list holds the overlappings separated by their origin unit that produced the
// overlapping
for (final Entry<Unit, List<OverlappingExecution>> eachOverlappingUnit :
specificOverlapping.entrySet()) {
Unit otherUnitImOverlappingWith = eachOverlappingUnit.getKey();
long totalExecutions = executionCount;
long concurrentExecutions = eachOverlappingUnit.getValue().size();
long amountOfNearlyConcurrentExecutions =
countExecutionTypes(eachOverlappingUnit.getValue(), Overlapping.AlmostOverlapping);
long amountOfCompletelyConcurrentExecutions =
countExecutionTypes(eachOverlappingUnit.getValue(), Overlapping.CompleteOverlapping);
long amountOfPartlyConcurrentExecutions =
countExecutionTypes(eachOverlappingUnit.getValue(), Overlapping.StartOrEndOverlapping);
double concurrentciesFoundFactor = concurrentExecutions / (double) totalExecutions;
double completeConcurrFactor =
amountOfCompletelyConcurrentExecutions * MainConfiguration.valueCompleteOverlap;
double nearlyConcurrentFactor =
amountOfNearlyConcurrentExecutions * MainConfiguration.valueNearlyOverlap;
double partlyConcurrentFactor =
amountOfPartlyConcurrentExecutions * MainConfiguration.valuePartlyOverlap;
double sumConcurrFactor =
completeConcurrFactor + nearlyConcurrentFactor + partlyConcurrentFactor;
double realtiveConcurrFactor = sumConcurrFactor / concurrentExecutions;
double finalConcurrFactor = realtiveConcurrFactor * concurrentciesFoundFactor;
hiddenConcurrencyRiskFactor.put(otherUnitImOverlappingWith, finalConcurrFactor);
}
hiddenConcurrencyRiskFactors.put(eachUnit.getKey(), hiddenConcurrencyRiskFactor);
}
// search for the unit pair that has the highest concurrency risk to use this information
// to construct a rough relative concurrency risk rating
double maximumConcurrencyRisk = Double.MIN_VALUE;
for (final Entry<Unit, Map<Unit, Double>> eachUnit : hiddenConcurrencyRiskFactors.entrySet()) {
if (!eachUnit.getValue().isEmpty()) {
double currentIterationMax = Collections.max(eachUnit.getValue().values());
if (currentIterationMax > maximumConcurrencyRisk) {
maximumConcurrencyRisk = currentIterationMax;
}
}
}
double averageSum = 0;
for (final Entry<Unit, Map<Unit, Double>> eachUnit : hiddenConcurrencyRiskFactors.entrySet()) {
double currentTotal = 0;
for (Double value : eachUnit.getValue().values()) {
currentTotal += value;
}
if (!eachUnit.getValue().isEmpty()) {
averageSum += currentTotal / eachUnit.getValue().size();
}
}
System.out.println("Maximum identified concurrency risk is:" + maximumConcurrencyRisk);
System.out.println(
"Average identified concurrency risk is:"
+ averageSum / hiddenConcurrencyRiskFactors.size());
return hiddenConcurrencyRiskFactors;
}