Examples with InstanceObject org.osate.aadl2.instance.InstanceObject used on opensource projects

Example 66 with InstanceObject

use of org.osate.aadl2.instance.InstanceObject in project osate2 by osate.

the class BusLoadAnalysis method analysisBody.

public void analysisBody(final IProgressMonitor monitor, final Element obj) {
    if (obj instanceof InstanceObject) {
        SystemInstance root = ((InstanceObject) obj).getSystemInstance();
        monitor.beginTask(actionName, IProgressMonitor.UNKNOWN);
        final SOMIterator soms = new SOMIterator(root);
        while (soms.hasNext()) {
            final SystemOperationMode som = soms.nextSOM();
            checkBusLoads(root, som);
        }
        monitor.done();
    } else {
        Dialog.showError("Bound Bus Bandwidth Analysis Error", "Can only check system instances");
    }
}

Example 67 with InstanceObject

use of org.osate.aadl2.instance.InstanceObject in project osate2 by osate.

the class NotBoundResourceAnalysisHandler method doAaxlAction.

@Override
public void doAaxlAction(IProgressMonitor monitor, Element obj) {
    // Get the system instance (if any)
    final SystemInstance si = (obj instanceof InstanceObject) ? ((InstanceObject) obj).getSystemInstance() : null;
    if (si != null) {
        monitor.beginTask(getActionName(), IProgressMonitor.UNKNOWN);
        NotBoundResourceAnalysis logic = null;
        logic = new NotBoundResourceAnalysis(this);
        final SOMIterator soms = new SOMIterator(si);
        while (soms.hasNext()) {
            logic.analyzeResourceBudget(si, soms.next());
        }
        monitor.done();
    }
}

Example 68 with InstanceObject

use of org.osate.aadl2.instance.InstanceObject in project osate2 by osate.

the class ResoluteInterface method executeResoluteFunctionOnce.

/**
 * invokes Resolute claim function on targetComponent or targetElement if not null.
 * instanceroot is used to initialize the Resolute evaluation context.
 * targetComponent is the evaluation context
 * targetElement is the model element within the component instance or null.
 * parameterObjects is a list of additional parameters of types RealLiteral, IntegerLiteral, StringLiteral, BooleanLiteral
 * parameterObjects can be null or an empty list.
 * The return value is an Issue object with subissues for the list of issues returned in the Resolute ClaimResult.
 * If the proof fails then the top Issue is set to FAIL, if successful it is set to SUCCESS
 */
public EObject executeResoluteFunctionOnce(EObject fundef, final ComponentInstance targetComponent, final InstanceObject targetElement, List<PropertyExpression> parameterObjects) {
    FunctionDefinition fd = (FunctionDefinition) fundef;
    initializeResoluteContext(targetComponent.getSystemInstance());
    EvaluationContext context = new EvaluationContext(targetComponent, sets, featToConnsMap);
    // check for claim function
    FnCallExpr fcncall = createWrapperFunctionCall(fd, targetElement, parameterObjects);
    if (fcncall != null) {
        // if (fcncall.getFn().getBody() instanceof ClaimBody) {
        // using com.rockwellcollins.atc.resolute.analysis.results.ClaimResult
        ResoluteProver prover = new ResoluteProver(context) {

            @Override
            protected ResoluteEvaluator createResoluteEvaluator() {
                return new ResoluteEvaluator(context, varStack.peek()) {

                    @Override
                    public ResoluteValue caseThisExpr(ThisExpr object) {
                        // We prepare a thisexpr with either the component instance as context object or a single reference to a model element
                        // See createWrapperFunctionCall
                        NamedElement curr = context.getThisInstance();
                        if (object.getSub() != null) {
                            curr = object.getSub().getBase();
                        }
                        return new NamedElementValue(curr);
                    }
                };
            }
        };
        try {
            ResoluteResult res = prover.doSwitch(fcncall);
            return doResoluteResults(res);
        } catch (ResoluteFailException e) {
            return ResultUtil.createFailureResult(e.getMessage(), targetElement);
        }
    // } else {
    // // computational function
    // ResoluteEvaluator engine = new ResoluteEvaluator(context, null) {
    // @Override
    // public ResoluteValue caseThisExpr(ThisExpr object) {
    // // We prepare a thisexpr with either the component instance as context object or a single reference to a model element
    // // See createWrapperFunctionCall
    // NamedElement curr = context.getThisInstance();
    // if (object.getSub() != null) {
    // curr = object.getSub().getBase();
    // }
    // return new NamedElementValue(curr);
    // }
    // };
    // Object res = engine.doSwitch(fcncall);
    // return null;
    // }
    } else {
        return ResultUtil.createErrorDiagnostic("Could not find Resolute Function " + fd.getName(), fd);
    }
}

Example 69 with InstanceObject

use of org.osate.aadl2.instance.InstanceObject in project osate2 by osate.

the class CheckBindingConstraints method runAnalysis.

public static List<Issue> runAnalysis(IProgressMonitor monitor, SystemInstance si) {
    List<Issue> issuesList = new ArrayList<>();
    SubMonitor subMonitor = SubMonitor.convert(monitor, 100);
    System.out.println(si.getSystemOperationModes().size());
    SubMonitor loopMonitor = subMonitor.split(100).setWorkRemaining(si.getSystemOperationModes().size());
    for (SOMIterator somIter = new SOMIterator(si); somIter.hasNext(); ) {
        SystemOperationMode som = somIter.next();
        SubMonitor iterationMonitor = loopMonitor.split(1);
        iterationMonitor.setWorkRemaining(8);
        // Processor binding
        SubMonitor processorChild = iterationMonitor.split(2);
        subMonitor.setTaskName("Getting Processor Binding Components");
        processorChild.split(1);
        List<ComponentInstance> processorBindingComponents = getComponents(monitor, si, ComponentCategory.THREAD, ComponentCategory.VIRTUAL_PROCESSOR, ComponentCategory.DEVICE).collect(Collectors.toList());
        processorChild.setTaskName("Checking Processor Bindings");
        processorChild.split(1);
        issuesList.addAll(checkBindingConstraints(processorBindingComponents.stream(), "processor", GetProperties::getActualProcessorBinding, GetProperties::getAllowedProcessorBinding, GetProperties::getAllowedProcessorBindingClass, som));
        // Dispatch Protocol
        subMonitor.setTaskName("Checking Dispacth Protocols");
        SubMonitor dispatchChild = iterationMonitor.split(1);
        issuesList.addAll(checkDispatchProtocol(processorBindingComponents.stream(), som));
        // Memory binding
        subMonitor.setTaskName("Getting Memory Components");
        SubMonitor memrChild = iterationMonitor.split(2);
        memrChild.split(1);
        Stream<ComponentInstance> memoryBindingComponents = getComponents(monitor, si, ComponentCategory.THREAD, ComponentCategory.DEVICE, ComponentCategory.DATA, ComponentCategory.SUBPROGRAM, ComponentCategory.PROCESSOR, ComponentCategory.VIRTUAL_PROCESSOR);
        subMonitor.setTaskName("Checking Memory Bindings");
        memrChild.split(1);
        Stream<FeatureInstance> memoryBindingFeatures = getFeatures(monitor, si, FeatureCategory.DATA_PORT, FeatureCategory.EVENT_DATA_PORT);
        Stream<InstanceObject> memoryBindingElements = Stream.concat(memoryBindingComponents, memoryBindingFeatures);
        issuesList.addAll(checkBindingConstraints(memoryBindingElements, "memory", GetProperties::getActualMemoryBinding, GetProperties::getAllowedMemoryBinding, GetProperties::getAllowedMemoryBindingClass, som));
        // Connection binding (only handles connection and virtual bus)
        subMonitor.setTaskName("Checking Connection Bindings");
        SubMonitor conenctionChild = iterationMonitor.split(1);
        Stream<ComponentInstance> connectionBindingComponents = getComponents(monitor, si, ComponentCategory.VIRTUAL_BUS);
        Stream<ConnectionInstance> connectionBindingConnections = getConnections(monitor, si);
        List<InstanceObject> connectionBindingElements = Stream.concat(connectionBindingComponents, connectionBindingConnections).collect(Collectors.toList());
        issuesList.addAll(checkBindingConstraints(connectionBindingElements.stream(), "connection", GetProperties::getActualConnectionBinding, GetProperties::getAllowedConnectionBinding, GetProperties::getAllowedConnectionBindingClass, som));
        // Connection Quality of Service
        subMonitor.setTaskName("Checking Connection Quality of Services");
        SubMonitor qualityChild = iterationMonitor.split(1);
        issuesList.addAll(checkRequiredAndProvided(connectionBindingElements.stream(), GetProperties::getRequiredConnectionQualityOfService, "Required_Connection_Quality_Of_Service", GetProperties::getProvidedConnectionQualityOfService, qos -> qos.getName(), som));
        // Virtual Bus Class
        subMonitor.setTaskName("Checking Virtual Bus Bindings");
        SubMonitor busChild = iterationMonitor.split(1);
        Function<ComponentInstance, Collection<ComponentClassifier>> getProvidedVBClass = boundElement -> {
            Stream<ComponentClassifier> providedProperty = GetProperties.getProvidedVirtualBusClass(boundElement).stream();
            Stream<ComponentClassifier> providedBySubcomponent = boundElement.getComponentInstances().stream().map(subcomponent -> subcomponent.getClassifier());
            return Stream.concat(providedProperty, providedBySubcomponent).collect(Collectors.toSet());
        };
        issuesList.addAll(checkRequiredAndProvided(connectionBindingElements.stream(), GetProperties::getRequiredVirtualBusClass, "Required_Virtual_Bus_Class", getProvidedVBClass, vbClass -> vbClass.getName(), som));
        busChild.setWorkRemaining(0);
    }
    subMonitor.setWorkRemaining(0);
    return issuesList;
}

Example 70 with InstanceObject

use of org.osate.aadl2.instance.InstanceObject in project osate2 by osate.

the class DeploymentProperties method getAllowedPhysicalAccess.

public static Optional<List<InstanceObject>> getAllowedPhysicalAccess(NamedElement lookupContext, Optional<Mode> mode) {
    Property property = getAllowedPhysicalAccess_Property(lookupContext);
    try {
        PropertyExpression value = CodeGenUtil.lookupProperty(property, lookupContext, mode);
        PropertyExpression resolved = CodeGenUtil.resolveNamedValue(value, lookupContext, mode);
        return Optional.of(((ListValue) resolved).getOwnedListElements().stream().map(element1 -> {
            PropertyExpression resolved1 = CodeGenUtil.resolveNamedValue(element1, lookupContext, mode);
            return ((InstanceReferenceValue) resolved1).getReferencedInstanceObject();
        }).collect(Collectors.toList()));
    } catch (PropertyNotPresentException e) {
        return Optional.empty();
    }
}