Skip to content
Snippets Groups Projects
Commit 8ea0d226 authored by Simon Spinner's avatar Simon Spinner
Browse files

Add classes for standalone parameterization agent.

parent 0a1e43e2
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 260 additions and 601 deletions
tools.descartes.prisma.parameterization/src/tools/descartes/prisma/parameterization/MappingModel.java deleted 100644 → 0
+ 0
− 300
View file @ 0a1e43e2
package tools.descartes.prisma.parameterization;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.AssemblyContext;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.Signature;
import edu.kit.ipd.descartes.mm.resourceconfiguration.ActiveResourceSpecification;
import edu.kit.ipd.descartes.mm.resourceconfiguration.ConfigurationSpecification;
import edu.kit.ipd.descartes.mm.resourceconfiguration.ProcessingResourceSpecification;
import edu.kit.ipd.descartes.mm.resourceconfiguration.SchedulingPolicy;
import edu.kit.ipd.descartes.mm.resourcelandscape.Container;
import edu.kit.ipd.descartes.mm.resourcetype.ResourceType;
import tools.descartes.librede.configuration.ConfigurationFactory;
import tools.descartes.librede.configuration.ExternalCall;
import tools.descartes.librede.configuration.ModelEntity;
import tools.descartes.librede.configuration.Resource;
import tools.descartes.librede.configuration.ResourceDemand;
import tools.descartes.librede.configuration.SchedulingStrategy;
import tools.descartes.librede.configuration.Service;
import tools.descartes.librede.configuration.Task;
import tools.descartes.librede.configuration.WorkloadDescription;
public class MappingModel {
private static class ResourceMapping {
public Container container;
public Resource resource;
}
private static class ServiceMapping {
public AssemblyContext context;
public Signature signature;
public Container container;
public Service service;
}
private static class ExternalCallKey {
public final Service service;
public final Service calledService;
public ExternalCallKey(Service service, Service calledService) {
super();
this.service = service;
this.calledService = calledService;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((calledService == null) ? 0 : calledService.hashCode());
result = prime * result + ((service == null) ? 0 : service.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ExternalCallKey other = (ExternalCallKey) obj;
if (calledService == null) {
if (other.calledService != null)
return false;
} else if (!calledService.equals(other.calledService))
return false;
if (service == null) {
if (other.service != null)
return false;
} else if (!service.equals(other.service))
return false;
return true;
}
}
private BiMap<edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.ResourceDemand, ResourceDemand> demands = HashBiMap.create();
private BiMap<ExternalCallKey, ExternalCall> calls = HashBiMap.create();
private Map<String, ServiceMapping> services = new HashMap<>();
private Map<String, ResourceMapping> resources = new HashMap<>();
private Set<ModelEntity> newEntities = new HashSet<>();
private Set<String> unmappedServices = new HashSet<>();
private Set<String> unmappedResources = new HashSet<>();
private WorkloadDescription workload = ConfigurationFactory.eINSTANCE.createWorkloadDescription();
public WorkloadDescription getWorkload() {
return workload;
}
public void reset() {
newEntities.clear();
unmappedResources.clear();
unmappedServices.clear();
unmappedResources.addAll(resources.keySet());
unmappedServices.addAll(services.keySet());
}
public Set<ModelEntity> getNewEntities() {
return newEntities;
}
public ExternalCall getLibredeCall(edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.ExternalCall dmlCall) {
return calls.get(dmlCall);
}
public edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.ResourceDemand getDmlDemand(ResourceDemand libredeDemand) {
return demands.inverse().get(libredeDemand);
}
public Set<edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.ExternalCall> getDmlCalls() {
return calls.keySet();
}
public void removeUnmappedEntites() {
Set<String> servicesToUnmap = new HashSet<>(unmappedServices);
for (String serviceName : servicesToUnmap) {
ServiceMapping sm = services.get(serviceName);
if (sm != null) {
unmapService(sm.service);
}
}
Set<String> resourcesToUnmap = new HashSet<>(unmappedResources);
for (String resourceName : resourcesToUnmap) {
ResourceMapping rm = resources.get(resourceName);
if (rm != null) {
unmapResource(rm.resource);
}
}
}
public void unmapService(Service service) {
workload.getServices().remove(service);
services.remove(service.getName());
newEntities.remove(service);
unmappedServices.remove(service.getName());
for (Task task : service.getTasks()) {
newEntities.remove(task);
if (task instanceof ResourceDemand) {
demands.inverse().remove(task);
} else if (task instanceof ExternalCall) {
calls.inverse().remove(task);
}
}
}
public void unmapResource(Resource resource) {
workload.getResources().remove(resource);
resources.remove(resource);
newEntities.remove(resource);
unmappedResources.remove(resource);
}
public void unmapExternalCall(ExternalCall call) {
newEntities.remove(call);
calls.inverse().remove(call);
}
public Service mapService(AssemblyContext context, Signature signature, Container container) {
return mapService(context.getName() + "#" + signature.getName(), context, signature, container); // TODO: cases with several providing roles with the same interfaces are there
}
public Service mapService(String serviceName, AssemblyContext context, Signature signature, Container container) {
unmappedServices.remove(serviceName);
ServiceMapping mapping = services.get(serviceName);
if (mapping == null) {
Service service = ConfigurationFactory.eINSTANCE.createService();
service.setName(serviceName);
mapping = new ServiceMapping();
mapping.context = context;
mapping.signature = signature;
mapping.container = container;
mapping.service = service;
services.put(serviceName, mapping);
workload.getServices().add(service);
newEntities.add(service);
}
return mapping.service;
}
public ResourceDemand mapResourceDemand(Resource resource, Service service, edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.ResourceDemand dmlDemand) {
ResourceDemand demand = demands.get(dmlDemand);
if (demand != null) {
return demand;
} else {
demand = ConfigurationFactory.eINSTANCE.createResourceDemand();
demand.setResource(resource);
demand.setName(resource.getName());
service.getTasks().add(demand);
demands.put(dmlDemand, demand);
newEntities.add(demand);
return demand;
}
}
public boolean contains(edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.ResourceDemand dmlDemand) {
return demands.containsValue(dmlDemand);
}
public Resource mapResource(Container container, ResourceType resType) {
String resourceName = container.getName() + "_" + resType.getName();
ResourceMapping rm = resources.get(resourceName);
ProcessingResourceSpecification procRes = getProcessingResource(container, resType);
if (procRes != null) {
if (rm == null) {
rm = new ResourceMapping();
rm.resource = ConfigurationFactory.eINSTANCE.createResource();
rm.container = container;
resources.put(resourceName, rm);
workload.getResources().add(rm.resource);
newEntities.add(rm.resource);
}
rm.resource.setName(resourceName);
rm.resource.setNumberOfServers(procRes.getNrOfParProcUnits().getNumber());
rm.resource.setSchedulingStrategy(convertSchedulingStrategy(procRes.getSchedulingPolicy()));
} else {
return null;
}
unmappedResources.remove(resourceName);
return rm.resource;
}
public ExternalCall mapExternalCall(Service service, Service calledService, edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.ExternalCall dmlCall) {
ExternalCallKey key = new ExternalCallKey(service, calledService);
ExternalCall call = calls.get(key);
if (call != null) {
return call;
} else {
call = ConfigurationFactory.eINSTANCE.createExternalCall();
call.setCalledService(calledService);
call.setName(calledService.getName());
service.getTasks().add(call);
calls.put(key, call);
newEntities.add(call);
return call;
}
}
public Signature getSignature(Service service) {
ServiceMapping mapping = services.get(service.getName());
if (mapping == null) {
return null;
}
return mapping.signature;
}
public AssemblyContext getAssemblyContext(Service service) {
ServiceMapping mapping = services.get(service.getName());
if (mapping == null) {
return null;
}
return mapping.context;
}
public Container getContainer(Service service) {
return services.get(service.getName()).container;
}
public Container getContainer(Resource resource) {
return resources.get(resource.getName()).container;
}
private SchedulingStrategy convertSchedulingStrategy(SchedulingPolicy policy) {
switch(policy) {
case DELAY:
return SchedulingStrategy.IS;
case FCFS:
return SchedulingStrategy.FCFS;
case PROCESSOR_SHARING:
return SchedulingStrategy.PS;
case RANDOM:
case NA:
default:
return SchedulingStrategy.UNKOWN;
}
}
private ProcessingResourceSpecification getProcessingResource(Container container, ResourceType resType) {
for (ConfigurationSpecification spec : container.getConfigSpec()) {
if (spec instanceof ActiveResourceSpecification) {
ActiveResourceSpecification active = (ActiveResourceSpecification)spec;
for (ProcessingResourceSpecification proc : active.getProcessingResourceSpecifications()) {
if (proc.getActiveResourceType().equals(resType)) {
return proc;
}
}
}
}
return null;
}
}
tools.descartes.prisma.parameterization/src/tools/descartes/prisma/parameterization/PrismaDataSource.java 0 → 100644
+ 85
− 0
View file @ 8ea0d226
package tools.descartes.prisma.parameterization;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import tools.descartes.librede.configuration.ModelEntity;
import tools.descartes.librede.configuration.TraceConfiguration;
import tools.descartes.librede.datasource.AbstractDataSource;
import tools.descartes.librede.datasource.TraceEvent;
import tools.descartes.librede.datasource.TraceKey;
import tools.descartes.librede.linalg.LinAlg;
import tools.descartes.librede.repository.TimeSeries;
import tools.descartes.librede.units.Quantity;
import tools.descartes.librede.units.Time;
import tools.descartes.librede.units.UnitsFactory;
import tools.descartes.prisma.core.MessageBus;
import tools.descartes.prisma.core.MessageBus.Listener;
import tools.descartes.prisma.core.agent.AgentController;
import tools.descartes.prisma.core.messages.MonitoringStatisticsMessage;
import tools.descartes.prisma.core.scopes.ModelVariableScope;
import tools.descartes.prisma.model.sensor.Sensor;
public class PrismaDataSource extends AbstractDataSource {
private static final Log log = LogFactory.getLog(PrismaDataSource.class);
private final AgentController controller;
private final Map<Sensor<?>, TraceKey> entityMapping = new HashMap<>();
public PrismaDataSource(AgentController controller) {
this.controller = controller;
}
public void addSensorMapping(Sensor<?> sensor, ModelEntity entity) {
Quantity<Time> interval = UnitsFactory.eINSTANCE.createQuantity(sensor.getInterval(), Time.MILLISECONDS);
TraceKey key = new TraceKey(sensor.getMetric(), sensor.getUnit(), interval, entity,
sensor.getAggregation());
entityMapping.put(sensor, key);
}
@Override
public void load() throws IOException {
ModelVariableScope scope = (ModelVariableScope) controller.getContainerScope();
MessageBus bus = controller.getContainerScope().getMessageBus();
String queueName = controller.getAgent().getId() + ".MonitoringStatistics";
bus.createQueue(queueName);
bus.bindQueue(queueName, scope.getMonitoringStatisticsPort(), "#");
bus.addMessageListener(queueName, new Listener() {
@Override
public void newMessage(String exchange, String routingKey, Map<String, Object> headers, String message) {
newMonitoringData(new MonitoringStatisticsMessage(controller.getModelRepository(), headers, message));
}
});
}
private void newMonitoringData(MonitoringStatisticsMessage message) {
Sensor<?> sensor = message.getSensor();
TraceKey key = entityMapping.get(sensor);
if (key != null) {
TimeSeries series = new TimeSeries(LinAlg.vector(message.getTimestamps()),
LinAlg.vector(message.getValues()));
TraceEvent e = new TraceEvent(key, series,
UnitsFactory.eINSTANCE.createQuantity(series.getEndTime(), Time.MILLISECONDS));
notifyListeners(e);
} else {
log.warn("Unkown sensor.");
}
}
@Override
public void close() throws IOException {
// TODO Auto-generated method stub
}
@Override
public List<TraceKey> addTrace(TraceConfiguration configuration) throws IOException {
return null;
}
}
tools.descartes.prisma.parameterization/src/tools/descartes/prisma/parameterization/RepositoryDump.java 0 → 100644
+ 175
− 0
View file @ 8ea0d226
package tools.descartes.prisma.parameterization;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Path;
import java.util.Collections;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
import tools.descartes.librede.configuration.ConfigurationFactory;
import tools.descartes.librede.configuration.DataSourceConfiguration;
import tools.descartes.librede.configuration.EstimationSpecification;
import tools.descartes.librede.configuration.ExporterConfiguration;
import tools.descartes.librede.configuration.FileTraceConfiguration;
import tools.descartes.librede.configuration.InputSpecification;
import tools.descartes.librede.configuration.LibredeConfiguration;
import tools.descartes.librede.configuration.ModelEntity;
import tools.descartes.librede.configuration.OutputSpecification;
import tools.descartes.librede.configuration.TraceToEntityMapping;
import tools.descartes.librede.configuration.ValidationSpecification;
import tools.descartes.librede.configuration.ValidatorConfiguration;
import tools.descartes.librede.configuration.WorkloadDescription;
import tools.descartes.librede.connector.dml.DmlExport;
import tools.descartes.librede.datasource.csv.CsvDataSource;
import tools.descartes.librede.linalg.Matrix;
import tools.descartes.librede.linalg.Vector;
import tools.descartes.librede.metrics.Aggregation;
import tools.descartes.librede.metrics.Metric;
import tools.descartes.librede.repository.IMonitoringRepositoryVisitor;
import tools.descartes.librede.repository.MemoryObservationRepository;
import tools.descartes.librede.repository.TimeSeries;
import tools.descartes.librede.units.Quantity;
import tools.descartes.librede.units.Time;
import tools.descartes.librede.units.UnitsFactory;
import tools.descartes.librede.validation.ResponseTimeValidator;
import tools.descartes.librede.validation.UtilizationValidator;
public class RepositoryDump implements IMonitoringRepositoryVisitor {
private static final Log log = LogFactory.getLog(RepositoryDump.class);
private static final int DEFAULT_WINDOW_SIZE = 60;
private InputSpecification specification;
private Path outputPath;
private DataSourceConfiguration dataSource;
private EcoreUtil.Copier copier;
private LibredeConfiguration configuration;
private Quantity<Time> maxStartTime;
private Quantity<Time> minEndTime;
private Quantity<Time> maxInterval;
public void dumpRepository(Path outputPath, MemoryObservationRepository repository) {
this.outputPath = outputPath;
configuration = ConfigurationFactory.eINSTANCE.createLibredeConfiguration();
specification = ConfigurationFactory.eINSTANCE.createInputSpecification();
configuration.setInput(specification);
dataSource = ConfigurationFactory.eINSTANCE.createDataSourceConfiguration();
dataSource.setName("CSV DataSource");
dataSource.setType(CsvDataSource.class.getName());
specification.getDataSources().add(dataSource);
copier = new EcoreUtil.Copier();
configuration.setWorkloadDescription((WorkloadDescription) copier.copy(repository.getWorkload()));
repository.accept(this);
EstimationSpecification estimation = ConfigurationFactory.eINSTANCE.createEstimationSpecification();
estimation.setStartTimestamp(maxStartTime);
estimation.setEndTimestamp(minEndTime);
estimation.setStepSize(maxInterval);
estimation.setRecursive(false);
estimation.setWindow(DEFAULT_WINDOW_SIZE);
// TODO: initialize approaches
configuration.setEstimation(estimation);
ValidationSpecification validation = ConfigurationFactory.eINSTANCE.createValidationSpecification();
validation.setValidateEstimates(true);
validation.setValidationFolds(1);
ValidatorConfiguration utilValidator = ConfigurationFactory.eINSTANCE.createValidatorConfiguration();
utilValidator.setType(UtilizationValidator.class.getName());
validation.getValidators().add(utilValidator);
ValidatorConfiguration rtValidator = ConfigurationFactory.eINSTANCE.createValidatorConfiguration();
rtValidator.setType(ResponseTimeValidator.class.getName());
validation.getValidators().add(rtValidator);
configuration.setValidation(validation);
OutputSpecification output = ConfigurationFactory.eINSTANCE.createOutputSpecification();
ExporterConfiguration export = ConfigurationFactory.eINSTANCE.createExporterConfiguration();
export.setName("DML Export");
export.setType(DmlExport.class.getName());
output.getExporters().add(export);
configuration.setOutput(output);
storeConfiguration();
}
@Override
public void visitTimeSeries(ModelEntity entity, Metric<?> metric, Aggregation aggregation,
Quantity<Time> aggregationInterval, TimeSeries data) {
Path traceFilePath = outputPath.resolve(entity.getName() + "-" + metric.getId() + "-" + aggregation + ".csv");
FileTraceConfiguration trace = ConfigurationFactory.eINSTANCE.createFileTraceConfiguration();
trace.setMetric(metric);
trace.setUnit(metric.getDimension().getBaseUnit());
trace.setInterval(aggregationInterval);
trace.setAggregation(aggregation);
trace.setDataSource(dataSource);
trace.setFile(traceFilePath.toString());
TraceToEntityMapping mapping = ConfigurationFactory.eINSTANCE.createTraceToEntityMapping();
// Get the copied model entity to avoid side-effects on the original
// repository.
mapping.setEntity((ModelEntity) copier.get(entity));
mapping.setTraceColumn(0);
trace.getMappings().add(mapping);
specification.getObservations().add(trace);
saveTimeSeries(traceFilePath, data);
// Update the start and end times
if (maxStartTime == null || maxStartTime.getValue(Time.MILLISECONDS) < data.getStartTime()) {
maxStartTime = UnitsFactory.eINSTANCE.createQuantity(data.getStartTime(), Time.MILLISECONDS);
}
if (minEndTime == null || minEndTime.getValue(Time.MILLISECONDS) > data.getEndTime()) {
minEndTime = UnitsFactory.eINSTANCE.createQuantity(data.getEndTime(), Time.MILLISECONDS);
}
// Update aggregation interval
if (maxInterval == null || maxInterval.compareTo(aggregationInterval) < 0) {
maxInterval = UnitsFactory.eINSTANCE.createQuantity(aggregationInterval.getValue(),
aggregationInterval.getUnit());
}
}
private void saveTimeSeries(Path filePath, TimeSeries series) {
try (PrintWriter out = new PrintWriter(filePath.toFile())) {
Vector time = series.getTime();
Matrix data = series.getData();
for (int i = 0; i < series.samples(); i++) {
out.print(time.get(i));
out.print(", ");
out.print(data.get(i, 0));
}
} catch (IOException e) {
log.error("Erorr writing time series data.", e);
}
}
private void storeConfiguration() {
Resource.Factory.Registry reg = Resource.Factory.Registry.INSTANCE;
Map<String, Object> m = reg.getExtensionToFactoryMap();
m.put("librede", new XMIResourceFactoryImpl());
ResourceSet rset = new ResourceSetImpl();
Resource libredeRes = rset.createResource(URI.createFileURI(outputPath.toString()));
libredeRes.getContents().add(configuration);
try {
libredeRes.save(Collections.emptyMap());
} catch (IOException e) {
log.error("Could not save LibReDE configuration", e);
}
}
}
tools.descartes.prisma.parameterization/src/tools/descartes/prisma/parameterization/WorkloadDescriptionDerivation.java deleted 100644 → 0
+ 0
− 301
View file @ 0a1e43e2
package tools.descartes.prisma.parameterization;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import javax.security.auth.login.Configuration;
import org.apache.log4j.Logger;
import edu.kit.ipd.descartes.mm.applicationlevel.parameterdependencies.ModelVariableCharacterizationType;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.AssemblyConnector;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.AssemblyContext;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.BasicComponent;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.ComposedStructure;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.CompositeComponent;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.InterfaceProvidingRole;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.InterfaceRequiringRole;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.ProvidingDelegationConnector;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.RepositoryComponent;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.RequiringDelegationConnector;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.Signature;
import edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.AbstractAction;
import edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.BranchAction;
import edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.ComponentInternalBehavior;
import edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.ExternalCallAction;
import edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.FineGrainedBehavior;
import edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.ForkAction;
import edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.InternalAction;
import edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.LoopAction;
import edu.kit.ipd.descartes.mm.applicationlevel.servicebehavior.ResourceDemand;
import edu.kit.ipd.descartes.mm.applicationlevel.system.System;
import edu.kit.ipd.descartes.mm.deployment.Deployment;
import edu.kit.ipd.descartes.mm.deployment.DeploymentContext;
import edu.kit.ipd.descartes.mm.resourcelandscape.Container;
import edu.kit.ipd.descartes.mm.resourcetype.ProcessingResourceType;
import tools.descartes.librede.configuration.ConfigurationFactory;
import tools.descartes.librede.configuration.ExternalCall;
import tools.descartes.librede.configuration.ModelEntity;
import tools.descartes.librede.configuration.Resource;
import tools.descartes.librede.configuration.SchedulingStrategy;
import tools.descartes.librede.configuration.Service;
public class WorkloadDescriptionDerivation {
private static final Logger log = Logger.getLogger(WorkloadDescriptionDerivation.class);
// Set of all fully analyzed services
private final Set<Service> completeServices = new HashSet<>();
private MappingModel mapping = new MappingModel();
private Map<AssemblyContext, Container> deploymentMapping = new HashMap<>();
private Resource delayResource = null;
public MappingModel getMapping() {
return mapping;
}
public void updateWorkloadDescription(Deployment deployment) {
mapping.reset();
completeServices.clear();
deploymentMapping.clear();
for (DeploymentContext depCtx : deployment.getDeploymentContexts()) {
addDeployment(depCtx.getAssemblyContext(), depCtx.getResourceContainer());
}
Stack<ComposedStructure> callStack = new Stack<ComposedStructure>();
System system = deployment.getSystem();
callStack.push(system);
for (AssemblyContext ctx : system.getAssemblyContexts()) {
Container deploymentTarget = deploymentMapping.get(ctx);
if (deploymentTarget != null) {
visitAssemblyContext(callStack, deploymentTarget, ctx);
} else {
log.warn("Assembly context " + ctx.getName() + " is not deployed on any container.");
}
}
// Remove all empty services
// List<Service> nonemptyServices = new LinkedList<>();
// for (Service curService : completeServices) {
// if (curService.getTasks().isEmpty()) {
// List<ExternalCall> calls = new ArrayList<>(curService.getIncomingCalls());
// for (ExternalCall curCall : calls) {
// curCall.getService().getTasks().remove(curCall);
// mapping.unmapExternalCall(curCall);
// }
// mapping.unmapService(curService);
// } else {
// nonemptyServices.add(curService);
// }
// }
addDelayResource();
mapping.removeUnmappedEntites();
}
private void addDeployment(AssemblyContext ctx, Container container) {
deploymentMapping.put(ctx, container);
if (ctx.getEncapsulatedComponent() instanceof CompositeComponent) {
CompositeComponent composite = (CompositeComponent)ctx.getEncapsulatedComponent();
for (AssemblyContext child : composite.getAssemblyContexts()) {
addDeployment(child, container);
}
}
}
private void addDelayResource() {
if (delayResource == null) {
delayResource = ConfigurationFactory.eINSTANCE.createResource();
delayResource.setName("Delay");
delayResource.setSchedulingStrategy(SchedulingStrategy.IS);
delayResource.setNumberOfServers(1);
mapping.getWorkload().getResources().add(delayResource);
}
for (ModelEntity curEntity : mapping.getNewEntities()) {
if (curEntity instanceof Service) {
Service curService = (Service)curEntity;
if (curService.getIncomingCalls().isEmpty()) {
tools.descartes.librede.configuration.ResourceDemand delayDemand = ConfigurationFactory.eINSTANCE.createResourceDemand();
delayDemand.setName("Delay");
delayDemand.setResource(delayResource);
curService.getTasks().add(delayDemand);
}
}
}
}
private void visitAssemblyContext(Stack<ComposedStructure> callStack, Container deploymentTarget, AssemblyContext assembly) {
RepositoryComponent component = assembly.getEncapsulatedComponent();
if (component instanceof BasicComponent) {
for (InterfaceProvidingRole role : assembly.getEncapsulatedComponent().getInterfaceProvidingRoles()) {
for (Signature sig : role.getInterface().getSignatures()) {
determineTasks(callStack, deploymentTarget, assembly, component, role, sig);
}
}
} else {
CompositeComponent composite = (CompositeComponent)assembly.getEncapsulatedComponent();
callStack.push(composite);
for (AssemblyContext child : composite.getAssemblyContexts()) {
visitAssemblyContext(callStack, deploymentTarget, child);
}
callStack.pop();
}
}
private void determineTasks(Stack<ComposedStructure> callStack, Container deploymentTarget, AssemblyContext assembly, RepositoryComponent component, InterfaceProvidingRole role, Signature sig) {
BasicComponent implementation = (BasicComponent)component;
FineGrainedBehavior behavior = getImplementationBehavior(implementation, role, sig);
if (behavior != null) {
Service service = mapping.mapService(assembly, sig, deploymentTarget);
if (!completeServices.contains(service)) {
visitComponentInternalBehavior(service, callStack, deploymentTarget, assembly, sig, behavior.getBehavior(), "");
completeServices.add(service);
// if (service.getName().startsWith("specj-mfg/specj-mfg/WorkOrderSession#org.spec.jent.ejb.mfg.session.WorkOrderService")) {
// // WORKAROUND: for specjent
// // The WorkOrderService interface is called internally and externally
// // Introduce an additional component to mark it as a system interface
// Service proxyService = mapping.mapService("Proxy:" + service.getName(), assembly, sig, deploymentTarget);
// if (proxyService.getTasks().isEmpty()) {
// ExternalCall call = ConfigurationFactory.eINSTANCE.createExternalCall();
// call.setCalledService(service);
// call.setName(service.getName());
// proxyService.getTasks().add(call);
// }
// }
}
} else {
log.warn("No fine-grained behavior found for component " + component.getName());
}
}
private FineGrainedBehavior getImplementationBehavior(BasicComponent component, InterfaceProvidingRole role, Signature sig) {
for (FineGrainedBehavior currentBehavior : component.getFineGrainedBehavior()) {
if (currentBehavior.getInterfaceProvidingRole().equals(role)
&& currentBehavior.getDescribedSignature().equals(sig)) {
return currentBehavior;
}
}
return null;
}
private ProvidingDelegationConnector getDelegationConnector(CompositeComponent composite, InterfaceProvidingRole role) {
for (ProvidingDelegationConnector connector : composite.getProvidingDelegationConnectors()) {
if (connector.getOuterInterfaceProvidingRole().equals(role)) {
return connector;
}
}
return null;
}
private void visitComponentInternalBehavior(Service service, Stack<ComposedStructure> callStack, Container deploymentTarget, AssemblyContext assembly, Signature signature, ComponentInternalBehavior behavior, String path) {
int i = 0;
path = path + "/actions.";
for (AbstractAction action : behavior.getActions()) {
if (action instanceof ForkAction) {
// Only consider threads for which we will wait for completion
// Other types of threads do not influence the response time behavior of the current service.
if (((ForkAction)action).isWithSynchronizationBarrier()) {
forEachComponentInternalBehavior(service, callStack, deploymentTarget, assembly, signature, ((ForkAction) action).getForkedBehaviors(), path + i +"/forkedBehaviors");
}
} else if (action instanceof BranchAction) {
forEachComponentInternalBehavior(service, callStack, deploymentTarget, assembly, signature, ((BranchAction) action).getBranches(), path + i + "/branches");
} else if (action instanceof LoopAction) {
forEachComponentInternalBehavior(service, callStack, deploymentTarget, assembly, signature, Collections.singletonList(((LoopAction) action).getLoopBodyBehavior()), path + i + "/loopBodyBehavior");
} else if (action instanceof InternalAction) {
visitInternalAction(service, deploymentTarget, assembly, signature, (InternalAction)action, path + i);
} else if (action instanceof ExternalCallAction) {
visitExternalCallAction(service, callStack, (ExternalCallAction) action);
}
i++;
}
}
private void forEachComponentInternalBehavior(Service service, Stack<ComposedStructure> callStack, Container deploymentTarget, AssemblyContext assembly, Signature signature, List<ComponentInternalBehavior> behaviors, String path) {
int j = 0;
for (ComponentInternalBehavior b : behaviors) {
visitComponentInternalBehavior(service, callStack, deploymentTarget, assembly, signature, b, path + path + "." + j);
j++;
}
}
private void visitExternalCallAction(Service service, Stack<ComposedStructure> callStack, ExternalCallAction action) {
InterfaceRequiringRole requiringRole = action.getExternalCall().getInterfaceRequiringRole();
AssemblyContext providingCtx = getCalledAssemblyContext(callStack, requiringRole);
Container targetContainer = deploymentMapping.get(providingCtx);
if (providingCtx != null) {
Service calledService = mapping.mapService(providingCtx, action.getExternalCall().getSignature(), targetContainer);
// Recursive calls are currently not supported.
if (!calledService.equals(service)) {
mapping.mapExternalCall(service, calledService, action.getExternalCall());
}
} else {
log.warn("No providing assembly context found for requiring role " + requiringRole.getName());
}
}
private AssemblyContext getCalledAssemblyContext(Stack<ComposedStructure> callStack, InterfaceRequiringRole requiringRole) {
ComposedStructure parent = callStack.peek();
for (AssemblyConnector connector : parent.getAssemblyConnectors()) {
if (connector.getInterfaceRequiringRole().equals(requiringRole)) {
return getInnerAssemblyContext(connector.getProvidingAssemblyContext(), connector.getInterfaceProvidingRole());
}
}
for (RequiringDelegationConnector connector : parent.getRequiringDelegationConnectors()) {
if (connector.getInnerInterfaceRequiringRole().equals(requiringRole)) {
// We have to go up one level in the callstack to determine the called component
callStack.pop();
AssemblyContext providingCtx = getCalledAssemblyContext(callStack, connector.getOuterInterfaceRequiringRole());
// Restore call stack
callStack.push(parent);
return providingCtx;
}
}
return null;
}
private AssemblyContext getInnerAssemblyContext(AssemblyContext ctx, InterfaceProvidingRole role) {
if (ctx.getEncapsulatedComponent() instanceof BasicComponent) {
return ctx;
} else {
CompositeComponent composite = (CompositeComponent)ctx.getEncapsulatedComponent();
for (ProvidingDelegationConnector del : composite.getProvidingDelegationConnectors()) {
if (del.getOuterInterfaceProvidingRole().equals(role)) {
return getInnerAssemblyContext(del.getAssemblyContext(), del.getInnerInterfaceProvidingRole());
}
}
}
return ctx;
}
private void visitInternalAction(Service parent, Container deploymentTarget, AssemblyContext assembly, Signature signature, InternalAction action, String path) {
for (ResourceDemand demand : action.getResourceDemand()) {
if (demand.getCharacterization() == ModelVariableCharacterizationType.EMPIRICAL) {
if (demand.getResourceType() instanceof ProcessingResourceType) {
Resource curResource = mapping.mapResource(deploymentTarget, demand.getResourceType());
if (curResource == null) {
log.warn("No processing resource of type " + demand.getResourceType() + " found in container " + deploymentTarget.getName() + ".");
continue;
}
Service curService = mapping.mapService(assembly, signature, deploymentTarget);
mapping.mapResourceDemand(curResource, curService, demand);
}
}
}
}
}
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment