Examples with ComponentClassifier org.osate.aadl2.ComponentClassifier used on opensource projects

Example 36 with ComponentClassifier

use of org.osate.aadl2.ComponentClassifier in project osate2 by osate.

the class ContractualElementImpl method setTarget.

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public void setTarget(ComponentClassifier newTarget) {
    ComponentClassifier oldTarget = target;
    target = newTarget;
    if (eNotificationRequired())
        eNotify(new ENotificationImpl(this, Notification.SET, ReqSpecPackage.CONTRACTUAL_ELEMENT__TARGET, oldTarget, target));
}

Example 37 with ComponentClassifier

use of org.osate.aadl2.ComponentClassifier in project osate2 by osate.

the class FlowLatencyAnalysisSwitch method processSamplingAndQueuingTimes.

/*
	 * boundBusOrRequiredClassifier is a ComponentInstance if it is a bus bound to connection instance, or a
	 * ComponentClassifier if it is a virtual bus required by a connection connnection or vb.
	 *
	 * bindingConnection is the ConnectionInstance that boundBusOrRequiredClassifier is bound to if
	 * boundBusOrRequiredClassifier is a componentInstance. Otherwise it is null.
	 */
private void processSamplingAndQueuingTimes(final NamedElement boundBusOrRequiredClassifier, final ConnectionInstance bindingConnection, final LatencyContributor latencyContributor) {
    // XXX: [Code Coverage] boundBus cannot be null.
    if (boundBusOrRequiredClassifier != null) {
        final ComponentCategory cc = boundBusOrRequiredClassifier instanceof ComponentInstance ? ((ComponentInstance) boundBusOrRequiredClassifier).getCategory() : ((ComponentClassifier) boundBusOrRequiredClassifier).getCategory();
        double period = hasPeriod.contains(cc) ? PropertyUtils.getScaled(TimingProperties::getPeriod, boundBusOrRequiredClassifier, TimeUnits.MS).orElse(0.0) : 0.0;
        if (period > 0) {
            // add sampling latency due to the protocol or bus being periodic
            LatencyContributor samplingLatencyContributor = new LatencyContributorComponent(boundBusOrRequiredClassifier, report.isMajorFrameDelay());
            samplingLatencyContributor.setBestCaseMethod(LatencyContributorMethod.SAMPLED_PROTOCOL);
            samplingLatencyContributor.setWorstCaseMethod(LatencyContributorMethod.SAMPLED_PROTOCOL);
            samplingLatencyContributor.setSamplingPeriod(period);
            latencyContributor.addSubContributor(samplingLatencyContributor);
            // add queuing latency: always zero in this case
            LatencyContributor queuingLatencyContributor = new LatencyContributorComponent(boundBusOrRequiredClassifier, report.isMajorFrameDelay());
            queuingLatencyContributor.setBestCaseMethod(LatencyContributorMethod.QUEUED);
            queuingLatencyContributor.setWorstCaseMethod(LatencyContributorMethod.QUEUED);
            queuingLatencyContributor.setMinimum(0.0);
            queuingLatencyContributor.setMaximum(0.0);
            latencyContributor.addSubContributor(queuingLatencyContributor);
        } else {
            /*
				 * Issue 1148
				 *
				 * if "boundBus" is really a bound component instance, and not a required component classifier,
				 * then we remember the bus as asynchronous. Later in fillInQueuingTimes() we go through this list,
				 * and then find all the connection instances bound to this bus. For each connection,
				 * we compute the sum of the max transmission times of the OTHER connections bound to the bus. This
				 * we set as the worse case queuing time. (Best case is 0.)
				 *
				 * We also remember the bus--connection pair that needs the queuing latency by storing its latency contributor.
				 */
            if (bindingConnection != null) {
                final ComponentInstance boundBus = (ComponentInstance) boundBusOrRequiredClassifier;
                /* Set the bus order and then add it to the ordered set */
                if (!busOrder.containsKey(boundBus)) {
                    busOrder.put(boundBus, nextBusId++);
                    asyncBuses.add(boundBus);
                }
                connectionsToContributors.put(new Pair<>(boundBus, bindingConnection), latencyContributor);
            }
        }
    }
}

Example 38 with ComponentClassifier

use of org.osate.aadl2.ComponentClassifier in project osate2 by osate.

the class FlowLatencyAnalysisSwitch method computeTotalDataSize.

/**
 * calculate the protocol data size contributions.
 * Do so for any RequiredVirtualBusClass of each protocol recursively.
 * @param protocols
 * @return
 */
private double computeTotalDataSize(List<Classifier> protocols, double transmissionDataSize, LatencyContributor latencyContributor, final ConnectionInstance onBehalfOfConnection) {
    double total = transmissionDataSize;
    for (Classifier cc : protocols) {
        double contribution = AadlContribUtils.getDataSize((ComponentClassifier) cc, SizeUnits.BYTES);
        double wrapped = transmissionDataSize + contribution;
        processTransmissionTime(cc, wrapped, latencyContributor, onBehalfOfConnection);
        total = total + contribution;
        List<Classifier> reqprotocols = DeploymentProperties.getRequiredVirtualBusClass(cc).orElse(Collections.emptyList());
        if (!reqprotocols.isEmpty()) {
            total = total + computeTotalDataSize(reqprotocols, wrapped, latencyContributor, onBehalfOfConnection);
        }
    }
    return total;
}

Example 39 with ComponentClassifier

use of org.osate.aadl2.ComponentClassifier in project osate2 by osate.

the class FlowLatencyAnalysisSwitch method mapConnectionInstance.

private void mapConnectionInstance(final EndToEndFlowInstance etef, final FlowElementInstance flowElementInstance, LatencyReportEntry entry) {
    ConnectionInstance connectionInstance = (ConnectionInstance) flowElementInstance;
    final RealRange expected = PropertyUtils.getScaledRange(org.osate.aadl2.contrib.communication.CommunicationProperties::getLatency, flowElementInstance, TimeUnits.MS).orElse(RealRange.ZEROED);
    ComponentInstance componentInstanceSource = InstanceModelUtil.getRelatedComponentSource(connectionInstance);
    ComponentInstance componentInstanceDestination = InstanceModelUtil.getRelatedComponentDestination(connectionInstance);
    ComponentInstance srcHW = InstanceModelUtil.getHardwareComponent(componentInstanceSource);
    ComponentInstance dstHW = InstanceModelUtil.getHardwareComponent(componentInstanceDestination);
    ComponentInstance srcPartition = FlowLatencyUtil.getPartition(componentInstanceSource);
    ComponentInstance dstPartition = FlowLatencyUtil.getPartition(componentInstanceDestination);
    // if we exit a partition then we may have I/O Delay until the end of the partition window or the end of the major frame
    if (srcPartition != null && srcPartition != dstPartition) {
        double partitionLatency = FlowLatencyUtil.getPartitionPeriod(srcPartition);
        List<ScheduleWindow> schedule = FlowLatencyUtil.getModuleSchedule(srcPartition);
        double partitionDuration = FlowLatencyUtil.getPartitionDuration(srcPartition, schedule);
        if (partitionDuration > 0) {
            LatencyContributor ioLatencyContributor = new LatencyContributorComponent(srcPartition, flowElementInstance, report.isMajorFrameDelay());
            if (!FlowLatencyUtil.isInSchedule(srcPartition, schedule)) {
                ioLatencyContributor.reportWarning("Partition not found in ARINC653 schedule of processor " + FlowLatencyUtil.getModule(srcPartition).getName());
            }
            ioLatencyContributor.setWorstCaseMethod(LatencyContributorMethod.PARTITION_OUTPUT);
            ioLatencyContributor.setBestCaseMethod(LatencyContributorMethod.PARTITION_OUTPUT);
            if (partitionLatency == 0) {
                ioLatencyContributor.setSamplingPeriod(partitionDuration);
                ioLatencyContributor.reportInfo("No partition period/rate. Using partition duration");
            } else {
                ioLatencyContributor.setSamplingPeriod(partitionLatency);
            }
            double frameOffset = FlowLatencyUtil.getPartitionFrameOffset(srcPartition, schedule);
            ioLatencyContributor.setPartitionOffset(frameOffset);
            ioLatencyContributor.setPartitionDuration(partitionDuration);
            entry.addContributor(ioLatencyContributor);
        }
    }
    // now we deal with communication latency
    LatencyContributor latencyContributor = new LatencyContributorConnection(connectionInstance, report.isMajorFrameDelay());
    processActualConnectionBindingsSampling(connectionInstance, latencyContributor);
    ComponentClassifier relatedConnectionData = (ComponentClassifier) FlowLatencyUtil.getConnectionData(connectionInstance);
    processActualConnectionBindingsTransmission(connectionInstance, relatedConnectionData == null ? 0.0 : AadlContribUtils.getDataSize(relatedConnectionData, SizeUnits.BYTES), latencyContributor);
    if (expected.getMaximum() > 0) {
        latencyContributor.setWorstCaseMethod(LatencyContributorMethod.SPECIFIED);
        latencyContributor.setExpectedMaximum(expected.getMaximum());
    }
    if (expected.getMinimum() > 0) {
        latencyContributor.setBestCaseMethod(LatencyContributorMethod.SPECIFIED);
        latencyContributor.setExpectedMinimum(expected.getMinimum());
    }
    if (latencyContributor.getSubContributors().isEmpty()) {
        if (expected.getMaximum() > 0) {
            latencyContributor.setMaximum(expected.getMaximum());
        }
        if (expected.getMinimum() > 0) {
            latencyContributor.setMinimum(expected.getMinimum());
        }
    } else {
        latencyContributor.reportInfo("Adding latency subtotal from protocols and hardware - shown with ()");
    }
    // set synchronous if on same processor
    if (srcHW != null && dstHW != null) {
        // we have two hardware components. One or both could be a device
        ComponentInstance srcTime = (ComponentInstance) TimingProperties.getReferenceTime(srcHW).orElse(null);
        ComponentInstance dstTime = (ComponentInstance) TimingProperties.getReferenceTime(dstHW).orElse(null);
        if (srcHW == dstHW) {
            latencyContributor.setSynchronous();
        } else if (srcTime != null && dstTime != null) {
            if (srcTime == dstTime) {
                latencyContributor.setSynchronous();
            } else {
                latencyContributor.setAsynchronous();
            }
        } else {
            latencyContributor.setSyncUnknown();
        }
    } else {
        // set synchronous if in same partition. This may be the case if the partitions are not bound yet to a processor
        if (dstPartition != null && srcPartition != null) {
            if (srcPartition == dstPartition) {
                latencyContributor.setSynchronous();
            } else {
                // no else part: partitions are unbound so we want to have both a sync and async analysis
                latencyContributor.setSyncUnknown();
            }
        }
    }
    entry.addContributor(latencyContributor);
    if (dstPartition != null && srcPartition != dstPartition) {
        // add partition latency if the destination is a partition and it is different from the source partition (or null)
        double partitionLatency = FlowLatencyUtil.getPartitionPeriod(dstPartition);
        List<ScheduleWindow> schedule = FlowLatencyUtil.getModuleSchedule(dstPartition);
        double partitionDuration = FlowLatencyUtil.getPartitionDuration(dstPartition, schedule);
        LatencyContributorComponent platencyContributor = new LatencyContributorComponent(dstPartition, flowElementInstance, report.isMajorFrameDelay());
        if (!FlowLatencyUtil.isInSchedule(dstPartition, schedule)) {
            platencyContributor.reportWarning("Partition not found in ARINC653 schedule of processor " + FlowLatencyUtil.getModule(dstPartition).getName());
        }
        if (partitionDuration > 0) {
            double frameOffset = FlowLatencyUtil.getPartitionFrameOffset(dstPartition, schedule);
            platencyContributor.setPartitionOffset(frameOffset);
            if (partitionLatency == 0) {
                platencyContributor.setSamplingPeriod(partitionDuration);
                platencyContributor.reportInfo("No partition period. Using partition duration");
            } else {
                platencyContributor.setSamplingPeriod(partitionLatency);
            }
            platencyContributor.setPartitionDuration(partitionDuration);
            platencyContributor.setWorstCaseMethod(LatencyContributorMethod.PARTITION_SCHEDULE);
            platencyContributor.setBestCaseMethod(LatencyContributorMethod.PARTITION_SCHEDULE);
            entry.addContributor(platencyContributor);
        } else {
            platencyContributor.setSamplingPeriod(partitionLatency);
            platencyContributor.setWorstCaseMethod(LatencyContributorMethod.PARTITION_FRAME);
            platencyContributor.setBestCaseMethod(LatencyContributorMethod.PARTITION_FRAME);
            entry.addContributor(platencyContributor);
        }
    }
}

Example 40 with ComponentClassifier

use of org.osate.aadl2.ComponentClassifier in project osate2 by osate.

the class FlowLatencyAnalysisSwitch method processActualConnectionBindingsSampling.

/*
	 * connOrVB - Can be a ConnectionInstance (initial call), ComponentInstance (bus or virtual bus bound to a connection or virtual bus), or a
	 * ComponentClassifier (required by a connection or virtual bus).
	 *
	 * onBehalfOfConnection - The connection instance that is bound to this mess. When connOrVB is a connection instance then
	 * it must be that connOrVB == onBehalfOfConnection
	 */
private void processActualConnectionBindingsSampling(final NamedElement connOrVB, final LatencyContributor latencyContributor, final ConnectionInstance onBehalfOfConnection) {
    boolean willDoVirtualBuses = false;
    boolean willDoBuses = false;
    if (connOrVB instanceof InstanceObject) {
        // look for actual binding if we have a connection instance or virtual bus instance
        List<InstanceObject> bindings = DeploymentProperties.getActualConnectionBinding(connOrVB).orElse(Collections.emptyList());
        for (InstanceObject componentInstance : bindings) {
            if (((ComponentInstance) componentInstance).getCategory().equals(ComponentCategory.VIRTUAL_BUS)) {
                willDoVirtualBuses = true;
            } else {
                willDoBuses = true;
            }
        }
        /**
         * required virtual bus class indicates protocols the connection intends to use.
         * We also can have an actual connection binding to a virtual bus
         * If we have that we want to use that virtual bus overhead
         */
        if (!willDoVirtualBuses) {
            List<Classifier> protocols = DeploymentProperties.getRequiredVirtualBusClass(connOrVB).orElse(Collections.emptyList());
            // XXX: [Code Coverage] protocols cannot be null.
            if ((protocols != null) && (protocols.size() > 0)) {
                if (willDoBuses) {
                    latencyContributor.reportInfo("Adding required virtual bus contributions to bound bus");
                }
                for (Classifier cc : protocols) {
                    processSamplingAndQueuingTimes(cc, null, latencyContributor);
                    processActualConnectionBindingsSampling(cc, latencyContributor, onBehalfOfConnection);
                }
            }
        }
        for (InstanceObject componentInstance : bindings) {
            processSamplingAndQueuingTimes(componentInstance, onBehalfOfConnection, latencyContributor);
            if (((ComponentInstance) componentInstance).getCategory().equals(ComponentCategory.VIRTUAL_BUS)) {
                processActualConnectionBindingsSampling(componentInstance, latencyContributor, onBehalfOfConnection);
            }
        }
    }
}