Precise Semantics of UML Composite Structures Avatar
  1. OMG Specification

Precise Semantics of UML Composite Structures — All Issues

  • Acronym: PSCS
  • Issues Count: 11
  • Description: All Issues
Open Closed All
All Issues

Issues Descriptions

Incorrect SysML term used in SysML Annex

  • Key: PSCS12-1
  • Status: closed  
  • Source: NIST ( Conrad Bock)
  • Summary:

    The term "behavior proxyport" isn't in SysML, but is used in Annex B many times. Ports can't be both behavioral and proxy. Informally, both kinds of port "stand in" for other objects, but behavior ports stand in for the owning object, while proxy ports stand in for internal parts. I think the Annex is referring to behavior ports, at least I recall Clause 11.2.2.3 (Block with Multiple Behavior ProxyPorts) is. The error seems to be causing some of the SysMLers to think the annex applies to proxy ports.

  • Reported: PSCS 1.0 — Thu, 22 Sep 2016 13:37 GMT
  • Disposition: Closed; No Change — PSCS 1.2
  • Disposition Summary:

    Annex B is correct

    Annex B does in fact apply specifically to ProxyPorts, and only to ProxyPorts. And it also only applies to ProxyPorts with isBehavior = true, that is, "behavior" ProxyPorts. Note that, in UML, a behavior Port does not actually have its own behavior, but has its behavior handled by the classifier behavior of its owning object, rather than via a delegation connector. (See the definition of Port::isBehavior and the corresponding semantics specification in subclause 9.3.12 of the UML 2.4.1 specification or subclause 11.3.3.1 of the UML 2.5.1 specification.)

    Further, SysML does in fact allow behavior ProxyPorts. According to he SysML 1.4 specification (on which the Annex is based), subclause 9.3.2.12 (emphasis added),

    Completely specified proxy ports must be connected to internal parts or be behavioral, to enable the owning block or connected internal parts to handle or initiate any interactions through the port.

    "Being behaviorial" is interpreted here as meaning isBehavior = true. This is as opposed to FullPorts, which "cannot be behavioral (isBehavior = false)" according to constraint [3] of subclause 9.3.2.8 of the SysML 1.4 specification.

    There for, the Annex is essentially correct in discussing "behavior ProxyPorts". The SysML 1.4 specification actually uses the term "behavioral port", but the more proper term according the UML specification is really "behavior port".

  • Updated: Tue, 18 Dec 2018 21:02 GMT

Problem with access to the context object in CS_SendSignalActionActivation

  • Key: PSCS11-4
  • Status: closed  
  • Source: Commissariat a l Energie Atomique-CEA ( Arnaud Cuccuru)
  • Summary:

    CS_SendSignalActionActivation has to retrieve the context object, in order to determine how to propagate the signal instance. This is done with the following statement :
    Object_ executionContext = this.group.activityExecution.context;

    This statement does not cover all possible cases. The correct statement is :
    Object_ executionContext = this.getActivityExecution().context ;

  • Reported: PSCS 1.0 — Mon, 29 Feb 2016 13:03 GMT
  • Disposition: Resolved — PSCS 1.1
  • Disposition Summary:

    Problem with acces to the context object CS_SendSignalActionActivation

    Agreed. The usage of statement this.group.activityExecution.context prevents to return the activity execution to which the group may indirectly belong.

  • Updated: Thu, 22 Jun 2017 16:46 GMT

Behavior Ports should be able to handle CallEventOccurrences

  • Key: PSCS11-7
  • Status: closed  
  • Source: Model Driven Solutions ( Ed Seidewitz)
  • Summary:

    In PSCS 1.0, when an Operation is dispatched to a behavior Port, it is ignored, because fUML 1.2 does not support CallEvents. However, PSSM allows StateMachines to have CallEvents on Triggers, and it should be possible to dispatch an Operation call through a behavior Port, as a CallEventOccurrence to be handled by a classifierBehavior that is a StateMachine.

  • Reported: PSCS 1.0 — Thu, 8 Dec 2016 20:14 GMT
  • Disposition: Resolved — PSCS 1.1
  • Disposition Summary:

    Behavior Ports should be able to handle CallEventOccurrences

    Note: The technical changes proposed to PSCS are dependent on issues resolved for fUML 1.3:

    FUML13-16: Support for synchronous call of operations on active objects.
    FUML13-1: SendSignalAction completion semantics.
    ­FUML13-60: Simplification to resolution of issue FUML13-1.

    It also relies on the resolution specified for PSCS11-6. This resolution introduces the possibility to have any event occurrence associable with an interaction point.

    Proposal: Enabling the possibility to dispatch an operation call on a behavior port requires to allow the creation of an execution when the dispatched operation arrives at a CS_InteractionPoint which is a manifestation of a behavior Port. The created execution must be a CS_CallEventExecution (a specialization of CallEventExecution – see FUML13-16). This latter is an execution that describes the production and the sending of a CS_EventOccurrence wrapping a CallEventOccurrence. The target of the sending is the owner of the interaction point which is the manifestation of the behavior port. The CS_EventOccurrence that is added to the event pool of the active object references this interaction point. This enables the classifier behavior that may accept this event occurrence to declare a trigger that identifies a Port from which the event occurrence might be accepted.

    The introduction of such changes require to update both AcceptCallActionActivation (see FUML13-16) and CS_SendSignalActionActivation. Hence, a CS_AcceptCallActionActivation must be provided in order to enable a CallEventOccurrence to be unwrapped in the case a CS_Eventoccurrence is accepted. In the case of CS_SendSignalActionActivation, only an update to the doAction operation is required. This update enables the possibility to wrap the SignalEventOccurrence to a CS_EventOccurrence, to initialize this latter with the Port and the direction to which the event occurrence shall be propagated and to make this event occurrence responsible for the effective sending to the target. The sending will occur using specific operations sendInTo and sendOutTo provided by CS_EventOccurrence.

    As CS_EventOccurrence is an active object (it specializes EventOccurrence – see FUML13-1 and FUML13-60). In order to specialize the classifier behavior inherited from EventOccurrence the doSend operation must be overridden in CS_EventOccurrence. The behavior specified for this operation enables to account for the direction and the port through which the event occurrence must be forwarded.

  • Updated: Thu, 22 Jun 2017 16:46 GMT

Any EventOccurrence should be associatable as an interaction point.

  • Key: PSCS11-6
  • Status: closed  
  • Source: Model Driven Solutions ( Ed Seidewitz)
  • Summary:

    The EventOccurrence class was introduced in fUML 1.2, with SignalEventOccurrence as a subclass. However, PSCS 1.0 only allows a SignalInstance to be associated with the InteractionPoint of the port through which it was sent. This should be changed to allow any EventOccurrence to be associated with an InteractionPoint, so that other types of EventOcurrences may be identified as sent through ports (which is necessary to properly handle them on Triggers with port references).

  • Reported: PSCS 1.0 — Thu, 8 Dec 2016 20:09 GMT
  • Disposition: Resolved — PSCS 1.1
  • Disposition Summary:

    Any EventOccurrence should be associatable as an interaction point.

    Note: The technical changes proposed to PSCS are dependent on issues resolved for fUML 1.3:

    ­FUML13-23: Enable any kind of event occurrence to be exchanged between active objects.

    ­FUML13-25: Enable EventOccurrence and its subclasses to provide operations to define trigger matching as well as data extractions semantics.

    Proposal: In order to introduce the possibility to send any EventOccurrence through ports and connectors in PSCS, four different groups of changes shall be performed:

    1. Classes CS_Object, CS_InteractionPoint and CS_Reference contribute to the event based communications propagation mechanism limited to SignalInstance. These classes must have their send(…), sendIn(…) and sendOut(…) operation signatures and specifications changed to make sure it is allowed to propagate EventOccurrence (cf. section 8.4.3.2.3 in fUML 1.2.1) instead of CS_SignalInstance. These changes directly rely on those proposed in resolution FUML13-23.
    2. In PSCS 1.0 only signal instances where intended to be propagated through ports and connectors, hence an extension to SignalInstance was provided. This extension (i.e., CS_SignalInstance) captures the port through which a signal instance was received. The problem here is that this information is not specific to signal instances but general to any kind of event occurrence that might be propagated along ports and connectors. Hence, CS_SignalInstance shall be removed and replaced by CS_EventOccurrence, which must reference an EventOccurrence (i.e., the event occurrence actually propagated) and a CS_InteractionPoint (i.e., the port instance through which the propagated event occurrence has arrived). CS_EventOccurrence must also override operations getParameterValues and match inherited from EventOccurrence.
    3. The above two groups of changes imply modifications of the specifications of both CS_AcceptEventActionActivation and CS_SendSignalActionActivation. The changes to CS_AcceptEventActionActivation consist in:
      • Removing the match operation that does not need to be overridden since its specification was changed in FUML13-25 to rely on the matchAny operation provided in EventOccurrence.
      • Overriding the accept operation in order to make sure that if a CS_eventOccurrence is received then the event occurrence that is finally accepted is the wrapped event occurrence.
        The changes to CS_SendSignalActionActivation consist in:
      • Removing the doActionDefault operation which does not need to exist since it does not change the semantics provided by SendSignalActionActivation doAction operation and CS_SignalInstance is removed from the PSCS semantic model.
      • Updating the definition of the doAction operation in order to account for the usage of EventOccurrence instead of SignalInstance or CS_SignalInstance.
    4. In FUML13-25, the implementation of ReadIsClassifiedObjectAction doAction operation has changed. Type checking semantics now relies on operations instanceOf and checkAllParents which are both provided by the Value class. This change implies that it is not anymore required for PSCS to provide an extension to ReadIsClassifiedObjectAction. Indeed operations (checkAllParents, isDescendant and realizesInterface) provided in this extension must be moved to CS_Object (which is a kind of Value) to ensure specific type checking semantics related to interfaces is preserved. Since CS_ReadIsClassifierObjectActionActivation does not add semantics to ReadIsClassifierObjectActionActivation it must be removed from the PSCS semantic model.
  • Updated: Thu, 22 Jun 2017 16:46 GMT

Incorrect SysML term used in SysML Annex

  • Key: PSCS11-5
  • Status: closed  
  • Source: NIST ( Conrad Bock)
  • Summary:

    The term "behavior proxyport" isn't in SysML, but is used in Annex B many times. Ports can't be both behavioral and proxy. Informally, both kinds of port "stand in" for other objects, but behavior ports stand in for the owning object, while proxy ports stand in for internal parts. I think the Annex is referring to behavior ports, at least I recall Clause 11.2.2.3 (Block with Multiple Behavior ProxyPorts) is. The error seems to be causing some of the SysMLers to think the annex applies to proxy ports.

  • Reported: PSCS 1.0 — Thu, 22 Sep 2016 13:37 GMT
  • Disposition: Deferred — PSCS 1.1
  • Disposition Summary:

    Incorrect SysML term used in SysML annex

    Consensus could not be reached during the RTF due to lack of time. We proposed to defer the issue for the next RTF.

  • Updated: Thu, 22 Jun 2017 16:46 GMT

RemoveStructuralFeatureValueAction should destroy constructor links

  • Key: PSCS11-3
  • Status: closed  
  • Source: Model Driven Solutions ( Ed Seidewitz)
  • Summary:

    PSCS updates the semantics for ClearStructuralFeatureValueAction, so that, "when a StructuralFeature is cleared, any links representing an instance of a Connector in which the StructuralFeature is involved are destroyed" (see 8.2.2.2.2 CS_ClearStructuralFeatureActionActivation).

    However, there is no similar update to the semantics for RemoveStructuralFeatureValueAction. So, if a single value is removed from a StructuralFeature, it is possible that this value will still have links to it that are instances of Connectors from within the composite. This violates the semantics of Connectors, whose instances are only supposed to link values within properties of the containing composite object.

    Recommendation: Add a CS_RemoveStructuralFeatureValueActionActivation to destroy relevant connector links to a value when the value is removed from a structural feature.

  • Reported: PSCS 1.0b1 — Fri, 31 Jul 2015 16:25 GMT
  • Disposition: Resolved — PSCS 1.1
  • Disposition Summary:

    RemoveStructuralFeatureValueAction should destroy constructor links

    As suggested in the issue description, PSCS is required to provide an extension to the semantics defined by fUML for RemoveStructuralFeatureValueAction (see section 8.6.3.2.12 in [fUML 1.2.1]). The defined extension will be in charge, when a value is removed from a feature value, to destroy all links (i.e., instances of connectors) in which the removed value is involved.

    In order to capture the new semantics, CS_RemoveStructuralFeatureValueActionActivation visitor is required to be included in the PSCS semantic model. This visitor class must be defined as a specialization of RemoveStructuralFeatureValueActionActivation. It overrides the doAction operation of its superclass. The doAction operation captures the exact same semantics than the one defined in fUML however it add the possibility to propagate the impact of the removed value(s) to the relevant connectors. This propagation is ensured in getLinkToDestroy and propagateDestructionToLinks which respectively find the connectors instances to destroy and perform the actual destruction.

    As a side adjustment, CS_ExecutionFactory instantiateVisitor operation is updated to enable the creation of a CS_RemoveStructuralFeatureValueActionActivation.

  • Updated: Thu, 22 Jun 2017 16:46 GMT

ad-13-11-08.xmi and ad-13-11-09.xmi have parse errors

  • Key: PSCS11-2
  • Status: closed  
  • Source: Commissariat a l Energie Atomique-CEA ( Arnaud Cuccuru)
  • Summary:

    ad-13-11-08.xmi - parse error on line 19, xsi namespace not defined (SysML Semantics)
    ad-13-11-09.xmi - parse error on line 2248, xsi namespace not defined (SysML test suites)

  • Reported: PSCS 1.0b1 — Thu, 11 Dec 2014 21:45 GMT
  • Disposition: Resolved — PSCS 1.1
  • Disposition Summary:

    Remove xsi:nil

    The indicated files have several cases in which xsi:nil=true is used to indicates empty values. These should all be removed.

    In addition, the SysML Test Suite XMI contains XMI extensions that are Ecore specific. While these can be ignored by a non-Ecore tool, they are really not appropriate for a clean XMI file (even if it is just informative) and should be removed.

  • Updated: Thu, 22 Jun 2017 16:46 GMT

Machine readable files shall be in canonical XMI format

  • Key: PSCS11-1
  • Status: closed  
  • Source: Commissariat a l Energie Atomique-CEA ( Arnaud Cuccuru)
  • Summary:

    Machine readable files are currently not in canonical XMI format. They shall be.

  • Reported: PSCS 1.0b1 — Thu, 11 Dec 2014 21:43 GMT
  • Disposition: Resolved — PSCS 1.1
  • Disposition Summary:

    Regenerate normative XMI files

    Agreed, all the normative XMI files should be in canonical XMI format. It is less important that the informative XMI files be in canonical XMI, except for the Generic Association model, which may actually be used be user models conforming to PSCS.

  • Updated: Thu, 22 Jun 2017 16:46 GMT

Section 2.2 - Editorial

  • Key: PSUCSF-7
  • Status: closed  
  • Source: Commissariat a l Energie Atomique-CEA ( Arnaud Cuccuru)
  • Summary:

    In Section 2.2, Second bullet, the text mentions « 2 new semantic variation points » but there are actually 3 semantic variation points.

  • Reported: PSCS 1.0b1 — Thu, 11 Dec 2014 21:56 GMT
  • Disposition: Resolved — PSCS 1.0
  • Disposition Summary:

    Update the text to say "three" instead of "two"

    In clause 2.2, second bullet, replace "two" by "three" in the sentence:

    "In addition, this specification introduces two new semantic variation points and corresponding default strategies for them:"

  • Updated: Tue, 14 Jul 2015 05:53 GMT

Clarify use of test suite to demonstrate conformance

  • Key: PSUCSF-5
  • Status: closed  
  • Source: Commissariat a l Energie Atomique-CEA ( Arnaud Cuccuru)
  • Summary:

    The specification shall clarrify if passing the test suite is a necessary or sufficient condition to demonstrate conformance with the specification

  • Reported: PSCS 1.0b1 — Thu, 11 Dec 2014 21:49 GMT
  • Disposition: Resolved — PSCS 1.0
  • Disposition Summary:

    Add text to clause 2 (conformance)

    In the clause 2 (conformance), add “Semantic Conformance. A conforming execution tool must provide execution semantics for a conforming model consistent with the semantics specified in clause Semantics of this document. Passing all the tests of the test suites in clause 9 are sufficient to demonstrate conformance with the semantics specified in clause 8.”

  • Updated: Tue, 14 Jul 2015 05:53 GMT

Invalid assertions in SysML test case 11.2.2.3

  • Key: PSUCSF-2
  • Status: closed  
  • Source: Commissariat a l Energie Atomique-CEA ( Arnaud Cuccuru)
  • Summary:

    In test case 11.2.2.3:
    b0.b1.p1_1.fp1 = b3 ;
    b0.b1.fp1 = b3 ;
    => Shall have the same effect at runtime, but currently don’t have

    In addition, according to SysML 1.4, assertions in test case 11.2.2.3 are wrong.
    It shall propagate in all cases.
    Currently says:
    b0.b1.p1_1.fp1 = b3 ;
    AssertTrue("Value successfully propagated to b0.b2_1.p2", b0.b2_1.p2.fp2 == b3) ;
    AssertTrue("Value NOT propagated to b0.b2_2.p2", ! (b0.b2_2.p2.fp2 == b3)) ;
    b0.b1.fp1 = b4 ;
    // Multiple matching flow properties. Shall not propagate.
    AssertTrue("Value NOT propagated to b0.b2_1.p2", !(b0.b2_1.p2.fp2 == b4)) ;
    AssertTrue("Value NOT propagated to b0.b2_2.p2", !(b0.b2_2.p2.fp2 == b4)) ;

    Should say:
    b0.b1.p1_1.fp1 = b3 ;
    AssertTrue("Value successfully propagated to b0.b2_1.p2", b0.b2_1.p2.fp2 == b3) ;
    AssertTrue("Value SUCCESSFULLY propagated to b0.b2_2.p2", b0.b2_2.p2.fp2 == b3) ;
    b0.b1.fp1 = b4 ;
    AssertTrue("Value SUCCESSFULLY propagated to b0.b2_1.p2", b0.b2_1.p2.fp2 == b4) ;
    AssertTrue("Value SUCCESSFULLY propagated to b0.b2_2.p2", b0.b2_2.p2.fp2 == b4) ;

    Also, the rule for « multiple matching flow properties » is not correctly implemented.

    => Changes are required in the extended execution model

  • Reported: PSCS 1.0b1 — Tue, 9 Dec 2014 17:24 GMT
  • Disposition: Resolved — PSCS 1.0
  • Disposition Summary:

    Changes required in the SysML test suite and the semantics

    11.2.2.3 is actually B.2.2.3.
    The extended execution model does not correctly implement SysML execution semantics.
    Indeed, a behavior proxy port is a proxy to the owning block. In terms of instances and objects in the locus, a port object (represented by a SysML_InteractionPoint) and the object owning the SysML_InteractionPoint are the same object. Modifying property values either by accessing a property by navigation from an object, or from an interaction point of thsi object, should have the same effect. This is not currently the case, as was reflected by the assertions in the test case B.2.2.3.
    The specific (and invalid) semantics were implemented in operations SysML_InteractionPoint::setFeatureValue and SysML::setFeatureValueOnInteractionPoint. These two operations can be removed. Note that SysML_InteractionPoint::setFeatureValue was the only operation of SysML_InteractionPoint, which means that this class is not really required anymore. However, other kinds of SysML ports (i.e., not behavior proxy ports) may require particular semantics. In order to ease possible future extension (that would address the other kinds of ports), the class can be kept.
    An other error in the currently implemented semantics is related to the case where there are multiple matching flow properties for propagation of a value assigned to a source flow property. The current semantics does not distinguish the case where multiple potential target flow properties belong to multiple objects or to a single objects. If there is one matching flow property per target object, there is no conflict and the propagation shall happen on each object. The body of SysML_Object::doPropagation shall be updated to reflect this.

  • Updated: Tue, 14 Jul 2015 05:53 GMT
  • Attachments: