Examples with LatencyContributorComponent org.osate.analysis.flows.model.LatencyContributorComponent used on opensource projects

Example 1 with LatencyContributorComponent

use of org.osate.analysis.flows.model.LatencyContributorComponent in project osate2 by osate.

the class FlowLatencyAnalysisSwitch method mapComponentInstance.

private void mapComponentInstance(final EndToEndFlowInstance etef, final FlowElementInstance flowElementInstance, LatencyReportEntry entry) {
    ComponentInstance componentInstance;
    final boolean hasLatency = flowElementInstance instanceof FlowSpecificationInstance || flowElementInstance instanceof ConnectionInstance || flowElementInstance instanceof EndToEndFlowInstance || latencyCats.contains(((ComponentInstance) flowElementInstance).getCategory());
    final RealRange expected = hasLatency ? PropertyUtils.getScaledRange(org.osate.aadl2.contrib.communication.CommunicationProperties::getLatency, flowElementInstance, TimeUnits.MS).orElse(RealRange.ZEROED) : RealRange.ZEROED;
    if (flowElementInstance instanceof FlowSpecificationInstance) {
        componentInstance = flowElementInstance.getComponentInstance();
    } else {
        componentInstance = (ComponentInstance) flowElementInstance;
    }
    FeatureInstance incomingConnectionFI = FlowLatencyUtil.getIncomingConnectionFeatureInstance(etef, flowElementInstance);
    /**
     * Get all the relevant properties.
     */
    double period = periodCats.contains(componentInstance.getCategory()) ? PropertyUtils.getScaled(TimingProperties::getPeriod, componentInstance, TimeUnits.MS).orElse(0.0) : 0.0;
    double deadline = deadlineCats.contains(componentInstance.getCategory()) ? PropertyUtils.getScaled(TimingProperties::getDeadline, componentInstance, TimeUnits.MS).orElse(0.0) : 0.0;
    boolean isAssignedDeadline = isAssignedDeadline(componentInstance);
    final boolean isThreadOrDevice = InstanceModelUtil.isThread(componentInstance) || InstanceModelUtil.isDevice(componentInstance) || InstanceModelUtil.isAbstract(componentInstance);
    final boolean isPeriodic = period > 0 && (isThreadOrDevice ? (!InstanceModelUtil.isSporadicComponent(componentInstance) && !InstanceModelUtil.isTimedComponent(componentInstance) && !InstanceModelUtil.isAperiodicComponent(componentInstance)) : true);
    final RealRange responseTime = getResponseTimeInMilliSec(flowElementInstance, componentInstance, isPeriodic);
    final RealRange executionTime = getExecutionTimeInMilliSec(flowElementInstance, componentInstance, isPeriodic);
    /**
     * The component is periodic. Therefore it will sample its input unless we have an immediate connection or delayed connection
     */
    boolean checkLastImmediate = false;
    if (isPeriodic) {
        // we have a periodic component that samples
        if (incomingConnectionFI != null) {
            // it is not the first component in the ETEF. We need to add sampling latency
            if (incomingConnectionFI.getCategory() == FeatureCategory.DATA_PORT || incomingConnectionFI.getCategory() == FeatureCategory.ABSTRACT_FEATURE) {
                // sampling incoming data
                // period is set, and if thread, abstract, or device needs to be dispatched as periodic
                // We sample only data ports. Event and event data ports have queuing latency
                LatencyContributorComponent samplingLatencyContributor = new LatencyContributorComponent(componentInstance, flowElementInstance, report.isMajorFrameDelay());
                samplingLatencyContributor.setSamplingPeriod(period);
                if ((InstanceModelUtil.isThread(componentInstance) || InstanceModelUtil.isDevice(componentInstance)) && !hasAssignedPropertyValue(componentInstance, "Dispatch_Protocol")) {
                    samplingLatencyContributor.reportInfo("Assume Periodic dispatch because period is set");
                }
                if (FlowLatencyUtil.isPreviousConnectionDelayed(etef, flowElementInstance)) {
                    samplingLatencyContributor.setBestCaseMethod(LatencyContributorMethod.DELAYED);
                    samplingLatencyContributor.setWorstCaseMethod(LatencyContributorMethod.DELAYED);
                } else if (FlowLatencyUtil.isPreviousConnectionImmediate(etef, flowElementInstance)) {
                    // the cumulative does not exceed the deadline of the last.
                    if (!FlowLatencyUtil.isNextConnectionImmediate(etef, flowElementInstance)) {
                        checkLastImmediate = true;
                    }
                } else {
                    // sampled. We may under sample
                    ComponentInstance prevComp = FlowLatencyUtil.getPreviousComponent(etef, flowElementInstance);
                    double prevPeriod = prevComp != null ? PropertyUtils.getScaled(TimingProperties::getPeriod, prevComp, TimeUnits.MS).orElse(0.0) : 0;
                    if (period > 0 && prevPeriod > 0 && period % prevPeriod == 0.0) {
                        samplingLatencyContributor.setSamplingPeriod(prevPeriod);
                    } else {
                        samplingLatencyContributor.setSamplingPeriod(period);
                    }
                    samplingLatencyContributor.setBestCaseMethod(LatencyContributorMethod.SAMPLED);
                    samplingLatencyContributor.setWorstCaseMethod(LatencyContributorMethod.SAMPLED);
                }
                entry.addContributor(samplingLatencyContributor);
            } else {
            // queuing latency handled later
            // do nothing here
            }
        } else {
            // The periodic component is the first component in the ETEF
            // record fact that first element is periodic so we can process synchronous behavior correctly
            LatencyContributorComponent samplingLatencyContributor = new LatencyContributorComponent(componentInstance, flowElementInstance, report.isMajorFrameDelay());
            samplingLatencyContributor.setBestCaseMethod(LatencyContributorMethod.FIRST_PERIODIC);
            samplingLatencyContributor.setWorstCaseMethod(LatencyContributorMethod.FIRST_PERIODIC);
            entry.addContributor(samplingLatencyContributor);
        }
    } else {
        // the component is not executing periodically
        if (entry.getContributors().isEmpty()) {
            // insert first partition sampling for the aperiodic case. For other partitions it is inserted by connection processing
            ComponentInstance firstPartition = FlowLatencyUtil.getPartition(componentInstance);
            if (firstPartition != null) {
                double partitionLatency = FlowLatencyUtil.getPartitionPeriod(firstPartition);
                List<ScheduleWindow> schedule = FlowLatencyUtil.getModuleSchedule(firstPartition);
                double partitionDuration = FlowLatencyUtil.getPartitionDuration(firstPartition, schedule);
                LatencyContributorComponent platencyContributor = new LatencyContributorComponent(firstPartition, flowElementInstance, report.isMajorFrameDelay());
                if (!FlowLatencyUtil.isInSchedule(firstPartition, schedule)) {
                    platencyContributor.reportWarning("Partition not found in ARINC653 schedule of processor " + FlowLatencyUtil.getModule(firstPartition).getName());
                }
                if (partitionDuration > 0) {
                    platencyContributor.setSamplingPeriod(partitionLatency);
                    double frameOffset = FlowLatencyUtil.getPartitionFrameOffset(firstPartition, schedule);
                    platencyContributor.setPartitionOffset(frameOffset);
                    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);
                }
            }
        }
    }
    /**
     * Selection of the worst case value, generic case.
     */
    LatencyContributorMethod bestmethod;
    LatencyContributorMethod worstmethod;
    double worstCaseValue = 0.0;
    double bestCaseValue = 0.0;
    worstmethod = LatencyContributorMethod.UNKNOWN;
    LatencyContributorComponent processingLatencyContributor = new LatencyContributorComponent(componentInstance, flowElementInstance, report.isMajorFrameDelay());
    if (responseTime.getMaximum() != 0.0) {
        worstCaseValue = responseTime.getMaximum();
        worstmethod = LatencyContributorMethod.RESPONSE_TIME;
    } else if (executionTime.getMaximum() != 0.0) {
        if (!report.isWorstCaseDeadline()) {
            // Use execution time for worst-case if preferences specify not deadline or no deadline is specified
            worstCaseValue = executionTime.getMaximum();
            worstmethod = LatencyContributorMethod.PROCESSING_TIME;
        } else if (!isAssignedDeadline) {
            worstCaseValue = executionTime.getMaximum();
            worstmethod = LatencyContributorMethod.PROCESSING_TIME;
            processingLatencyContributor.reportInfo("Using execution time as deadline was not set");
        }
    }
    if ((worstCaseValue == 0.0) && isAssignedDeadline && report.isWorstCaseDeadline()) {
        // use deadline if no execution time and deadline was explicitly assigned
        worstCaseValue = deadline;
        worstmethod = LatencyContributorMethod.DEADLINE;
    }
    if ((worstCaseValue == 0.0) && (expected.getMaximum() != 0.0)) {
        // use flow latency if neither deadline nor execution time
        worstCaseValue = expected.getMaximum();
        worstmethod = LatencyContributorMethod.SPECIFIED;
    } else if (worstCaseValue == 0.0 && deadline != 0.0) {
        // if no flow spec value then use default deadline == period
        worstCaseValue = deadline;
        worstmethod = LatencyContributorMethod.DEADLINE;
        processingLatencyContributor.reportInfo("Using deadline as execution time was not set");
    }
    /**
     * Selection of the best case value, generic cases.
     */
    bestmethod = LatencyContributorMethod.UNKNOWN;
    if (responseTime.getMinimum() != 0.0) {
        bestCaseValue = responseTime.getMinimum();
        bestmethod = LatencyContributorMethod.RESPONSE_TIME;
    } else if (executionTime.getMinimum() != 0.0) {
        bestCaseValue = executionTime.getMinimum();
        bestmethod = LatencyContributorMethod.PROCESSING_TIME;
    }
    if ((bestCaseValue == 0.0) && (expected.getMinimum() != 0.0)) {
        bestCaseValue = expected.getMinimum();
        bestmethod = LatencyContributorMethod.SPECIFIED;
    }
    // take into account queuing delay
    if (incomingConnectionFI != null) {
        double qs = 0;
        LatencyContributorComponent ql = new LatencyContributorComponent(componentInstance, flowElementInstance, report.isMajorFrameDelay());
        if (hasAssignedPropertyValue(incomingConnectionFI, org.osate.xtext.aadl2.properties.util.CommunicationProperties.QUEUE_SIZE)) {
            qs = CommunicationProperties.getQueueSize(incomingConnectionFI).orElse(0);
        } else if (incomingConnectionFI.getCategory() == FeatureCategory.DATA_PORT && isThreadOrDevice && (InstanceModelUtil.isSporadicComponent(componentInstance) || InstanceModelUtil.isTimedComponent(componentInstance) || InstanceModelUtil.isAperiodicComponent(componentInstance))) {
            // treat data port as a port of queue size 1 when not a sampling thread
            qs = 1;
            ql.reportInfo("Data port as queue size 1 for sporadic, aperiodic, timed dispatch");
        }
        if (qs != 0) {
            // take into account queuing delay on event and event data ports.
            double dl = 0.0;
            if (InstanceModelUtil.isSporadicComponent(componentInstance) || InstanceModelUtil.isPeriodicComponent(componentInstance)) {
                dl = period;
                ql.reportInfo("Sporadic or periodic has period delay per queue element");
            } else {
                dl = worstCaseValue;
            }
            double queuingDelay = qs * dl;
            ql.setMaximum(queuingDelay);
            if (report.isBestcaseEmptyQueue()) {
                ql.setMinimum(0.0);
                ql.reportInfo("Assume best case empty queue");
            } else {
                double mindl = (InstanceModelUtil.isSporadicComponent(componentInstance) || InstanceModelUtil.isPeriodicComponent(componentInstance) ? period : bestCaseValue);
                ql.setMinimum(qs * mindl);
                ql.reportInfo("Assume best case full queue");
            }
            ql.setWorstCaseMethod(LatencyContributorMethod.QUEUED);
            ql.setBestCaseMethod(LatencyContributorMethod.QUEUED);
            entry.addContributor(ql);
        }
    }
    processingLatencyContributor.setWorstCaseMethod(worstmethod);
    processingLatencyContributor.setBestCaseMethod(bestmethod);
    processingLatencyContributor.setMaximum(worstCaseValue);
    processingLatencyContributor.setMinimum(bestCaseValue);
    processingLatencyContributor.setExpectedMaximum(expected.getMaximum());
    processingLatencyContributor.setExpectedMinimum(expected.getMinimum());
    if (checkLastImmediate && deadline > 0.0) {
        processingLatencyContributor.setImmediateDeadline(deadline);
    }
    processingLatencyContributor.checkConsistency();
    entry.addContributor(processingLatencyContributor);
}

Example 2 with LatencyContributorComponent

use of org.osate.analysis.flows.model.LatencyContributorComponent in project osate2 by osate.

the class FlowLatencyAnalysisSwitch method processTransmissionTime.

/**
 * add latency sub-contribution due to transmission by bus (or virtual bus)
 * works for an instance object and for a classifier.
 * We determine the transmission latency from the data size and transmission time property.
 * If not present we get it from the latency property.
 * If neither is present and we are a connection or virtual bus we do not add a latency.
 * If we are HW component, we add unknown latency.
 * targetMedium: a connection instance, or the binding target (virtual bus or bus)
 * transmissionDataSize: the size of data to be transmitted.
 * latencyContributor: the place where we add a subcontributor.
 */
private void processTransmissionTime(NamedElement targetMedium, double datasizeinbyte, LatencyContributor latencyContributor, final ConnectionInstance onBehalfOfConnection) {
    // XXX: [Code Coverage] targetMedium cannot be null.
    if (targetMedium != null) {
        final RealRange busLatency = PropertyUtils.getScaledRange(org.osate.aadl2.contrib.communication.CommunicationProperties::getLatency, targetMedium, TimeUnits.MS).orElse(RealRange.ZEROED);
        final RealRange busTransferTime = getTimeToTransferData(targetMedium, datasizeinbyte);
        if (busLatency.getMaximum() == 0 && busTransferTime.getMaximum() == 0) {
            // connection or protocol has nothing to contribute
            return;
        }
        LatencyContributor subContributor = new LatencyContributorComponent(targetMedium, report.isMajorFrameDelay());
        subContributor.setExpectedMaximum(busLatency.getMaximum());
        subContributor.setExpectedMinimum(busLatency.getMinimum());
        if (busTransferTime.getMaximum() > 0) {
            subContributor.setMaximum(busTransferTime.getMaximum());
            subContributor.reportInfo("Using data transfer time");
            if (datasizeinbyte == 0.0) {
                subContributor.reportInfo("Data size = 0. Possibly data type on port missing");
            }
            subContributor.setWorstCaseMethod(LatencyContributorMethod.TRANSMISSION_TIME);
            // Record the latency for use by asynchronous bus waiting times
            if (targetMedium instanceof ComponentInstance) {
                computedMaxTransmissionLatencies.put(new Pair<>((ComponentInstance) targetMedium, onBehalfOfConnection), busTransferTime.getMaximum());
            }
        } else if (busLatency.getMaximum() > 0) {
            subContributor.setMaximum(busLatency.getMaximum());
            subContributor.setWorstCaseMethod(LatencyContributorMethod.SPECIFIED);
            subContributor.reportInfo("Using specified bus latency");
            // Record the latency for use by asynchronous bus waiting times
            if (targetMedium instanceof ComponentInstance) {
                computedMaxTransmissionLatencies.put(new Pair<>((ComponentInstance) targetMedium, onBehalfOfConnection), busTransferTime.getMaximum());
            }
        } else {
            // XXX: [Code Coverage] Only executable if maxBusTransferTime or maxBusLatency is negative.
            subContributor.setWorstCaseMethod(LatencyContributorMethod.UNKNOWN);
        }
        if (busTransferTime.getMinimum() > 0) {
            subContributor.setMinimum(busTransferTime.getMinimum());
            subContributor.setBestCaseMethod(LatencyContributorMethod.TRANSMISSION_TIME);
        } else if (busLatency.getMinimum() > 0) {
            subContributor.setMinimum(busLatency.getMinimum());
            subContributor.setBestCaseMethod(LatencyContributorMethod.SPECIFIED);
        } else {
            // XXX: [Code Coverage] Only executable if minBusTransferTime or minBusLatency is negative.
            subContributor.setBestCaseMethod(LatencyContributorMethod.UNKNOWN);
        }
        latencyContributor.addSubContributor(subContributor);
    }
}

Example 3 with LatencyContributorComponent

use of org.osate.analysis.flows.model.LatencyContributorComponent in project osate2 by osate.

the class FlowLatencyAnalysisSwitch method fillInQueuingTimes.

private void fillInQueuingTimes(final SystemInstance system) {
    // Nothing to do if there are no asynchronous buses
    if (!asyncBuses.isEmpty()) {
        // Get all the connections bound to a bus and group them together by the bus they are bound to
        final Map<ComponentInstance, Set<ConnectionInstance>> sortedConnections = sortBoundConnections(system);
        /*
			 * Go through the list of all the asynchronous buses
			 */
        for (final NamedElement ne : asyncBuses) {
            // only proceed if it is a bus instance and not a classifier (from Required_Virtual_Bus_Class)
            if (ne instanceof ComponentInstance) {
                final ComponentInstance bus = (ComponentInstance) ne;
                // Get all the connections bound to that bus
                final Set<ConnectionInstance> boundConnections = sortedConnections.getOrDefault(bus, Collections.emptySet());
                // Get all the transmission times and compute the total
                double totalTime = 0.0;
                final Map<ConnectionInstance, Double> transmissionTimes = new HashMap<>();
                for (final ConnectionInstance ci : boundConnections) {
                    final Double time = computedMaxTransmissionLatencies.getOrDefault(new Pair<ComponentInstance, ConnectionInstance>(bus, ci), 0.0);
                    transmissionTimes.put(ci, time);
                    totalTime += time;
                }
                /*
					 * Go through the list of connections again, and subtract the time associated
					 * with the current connection to find the max waiting time for each connection.
					 * (That each for each connection ci, we will have the sum of all the times
					 * for the _other_ connections bound to same bus. This gives us the max
					 * time that connection ci may have to wait to use the bus.)
					 */
                for (final ConnectionInstance ci : boundConnections) {
                    final Double ciTime = transmissionTimes.get(ci);
                    final double maxWaitingTime = totalTime - ciTime;
                    // Finally we can stick this into the latency contributor
                    final LatencyContributor latencyContributor = connectionsToContributors.get(new Pair<>(bus, ci));
                    final LatencyContributor queuingLatencyContributor = new LatencyContributorComponent(bus, report.isMajorFrameDelay());
                    queuingLatencyContributor.setBestCaseMethod(LatencyContributorMethod.QUEUED);
                    queuingLatencyContributor.setWorstCaseMethod(LatencyContributorMethod.QUEUED);
                    queuingLatencyContributor.setMinimum(0.0);
                    if (report.isDisableQueuingLatency()) {
                        // Hide the queuing time
                        queuingLatencyContributor.setMaximum(0.0);
                        queuingLatencyContributor.reportInfo("Ignoring queuing time of " + maxWaitingTime + "ms");
                    } else {
                        // Report the queuing time
                        queuingLatencyContributor.setMaximum(maxWaitingTime);
                    }
                    latencyContributor.addSubContributor(queuingLatencyContributor);
                    // add the sampling latency
                    LatencyContributor samplingLatencyContributor = new LatencyContributorComponent(bus, report.isMajorFrameDelay());
                    samplingLatencyContributor.setBestCaseMethod(LatencyContributorMethod.SAMPLED_PROTOCOL);
                    samplingLatencyContributor.setWorstCaseMethod(LatencyContributorMethod.SAMPLED_PROTOCOL);
                    samplingLatencyContributor.setSamplingPeriod(0.0);
                    latencyContributor.addSubContributor(samplingLatencyContributor);
                }
            }
        }
    }
}

Example 4 with LatencyContributorComponent

use of org.osate.analysis.flows.model.LatencyContributorComponent 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 5 with LatencyContributorComponent

use of org.osate.analysis.flows.model.LatencyContributorComponent 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);
        }
    }
}