Multi-person real-time cooperation method of SysML modeling tool based on session

Abstract

The invention provides a multi-person real-time cooperation method of a session-based SysML modeling tool, and relates to the technical field of SysML modeling, and the method comprises the following steps: establishing a data layer in which a plurality of SysML models are stored, and the SysML models in the data layer are unique trusted data sources; a view layer is established for each client, the view layer is a view showing the data layer, and data change is carried out on the SysML model through the view layer; and a server side is established, the server side is used for monitoring data changes in the data layer in real time, pushing and updating the data to all the associated view layers through a broadcast mechanism when the data changes, and communication between the server side and the client side is established through a session. The method has the advantages that more efficient, low-resource-competition and more reliable multi-person cooperative operation is achieved.

Description

Technical Field

[0001] This invention relates to the field of SysML modeling technology, and more specifically, to a multi-user real-time collaboration method for a session-based SysML modeling tool. Background Art

[0002] With the widespread adoption and practical application of engineering and modular concepts in modern industrial systems, and the continuous refinement and specialization of technical divisions in various professional fields, the parallel collaborative editing and dynamic modification by multi-disciplinary technical teams has become a routine requirement in systems engineering workflows during the modeling and development of complex systems.

[0003] Traditional systems engineering tools primarily employ lock-based concurrency control algorithms to achieve multi-user collaborative operations. While this approach offers advantages in ensuring data consistency, it inevitably leads to problems such as increased operational complexity, increased response latency, and heavier cognitive load on users. Locking mechanisms require users to acquire exclusive access before editing specific modules, which not only disrupts the natural workflow but can also cause systemic bottlenecks such as resource contention, deadlock risks, and decreased collaboration efficiency. This significantly contradicts the demands of modern engineering practices that emphasize agile collaboration and real-time synchronization.

[0004] Therefore, it is necessary to improve multi-person collaborative operations and optimize resource coordination in collaborative operations, so as to achieve more efficient, less resource-competitive, and more reliable multi-person collaborative operations. Summary of the Invention

[0005] The purpose of this invention is to provide a real-time multi-user collaboration method based on a session-based SysML modeling tool, which achieves more efficient, less resource-contention-driven, and more reliable multi-user collaborative operation.

[0006] This invention is achieved through the following technical solution:

[0007] A multi-user real-time collaboration method for a session-based SysML modeling tool includes the following steps:

[0008] A data layer is established, which stores multiple SysML models, and the SysML models in the data layer are the only trusted data sources.

[0009] A separate view layer is established for each client. The view layer is used to display the data layer and to modify the data in the SysML model.

[0010] A server is established to monitor data changes in the data layer in real time and push updates to all associated view layers through a broadcast mechanism when data changes. Communication between the server and the client is established through a session.

[0011] Preferably, the communication protocol between the server and the client adopts the WebSocket protocol, which provides a full-duplex communication channel.

[0012] Preferably, an extended session is established to create a session object for each client, and the session object stores the view relationship and context relationship between the client and the data layer.

[0013] Preferably, the method for performing the data modification on the data layer is as follows:

[0014] The centralized transaction processing engine receives instructions from the view layer of different clients and performs unified data change processing on the data layer according to the instructions.

[0015] Preferably, the state consistency between the view layers of different clients is coordinated through a centralized transaction processing engine, and the processing mechanism is: to implement data distribution by adopting a selective synchronization strategy.

[0016] Preferably, the selective synchronization strategy includes:

[0017] Perform change impact analysis on the data layer and establish a model element dependency graph;

[0018] When the data change occurs, the affected data and the associated clients are identified through the model element dependency graph, and updates are pushed to them.

[0019] Preferably, the selective synchronization strategy further includes:

[0020] During the broadcast phase, updates are pushed only to the clients that hold the outdated version data.

[0021] Preferably, the view layer includes a graphical canvas and a model tree.

[0022] Preferably, when broadcasting, the set of all clients involved in the current data change object is obtained, and the client currently making the data change is removed from the set of clients;

[0023] If the client set becomes empty, no operation is performed; otherwise, a broadcast is made to all online clients in the client set.

[0024] Preferably, the data change is a change to at least one model element, which includes the model's class, interface, and association relationships.

[0025] The technical solution of the present invention has at least the following advantages and beneficial effects:

[0026] This invention avoids model bifurcation and conflict caused by inconsistent local states when editing on multiple clients by setting the SysML model in the data layer as the only trusted data source, thereby improving the correctness and stability of the modeling results.

[0027] The communication architecture built on the session mechanism in this invention enables multiple clients to load and operate the same SysML model simultaneously, improving collaboration efficiency and work concurrency without interfering with each other's operations.

[0028] This invention achieves lock-free message synchronization between different clients by uniformly scheduling and executing various clients and data, and synchronizing changes to all active sessions in real time via broadcast. Compared with traditional lock-based concurrency control strategies, it avoids explicit resource locking requirements. Clients can submit modifications directly without waiting for locks to be released, significantly reducing operation latency and collaboration complexity.

[0029] Through centralized transaction management and global state synchronization, this invention enables the system to maintain high concurrent response efficiency while ensuring data consistency. It can also effectively avoid resource waste and communication delays caused by polling, thus better adapting to the needs of multi-disciplinary parallel collaboration in modern systems engineering.

[0030] This invention establishes a persistent connection between the client and the server based on a session, such as based on the WebSocket protocol, which supports low-latency, high-frequency data interaction and meets the communication requirements for real-time modeling collaboration.

[0031] This invention is rationally designed and suitable for large-scale system modeling scenarios that require high consistency and high concurrency editing, and has broad engineering application value. Attached Figure Description

[0032] Figure 1 This is a schematic diagram illustrating the principle of the real-time multi-user collaboration method of the session-based SysML modeling tool provided in Embodiment 1 of the present invention.

[0033] Figure 2 A schematic diagram illustrating the principle of an extended session example provided in Embodiment 1 of the present invention;

[0034] Figure 3 A schematic diagram illustrating the principle of a unified data change processing example provided in Embodiment 1 of the present invention;

[0035] Figure 4 This is a schematic diagram illustrating the principle of a broadcasting case based on change impact analysis provided in Embodiment 1 of the present invention;

[0036] Figure 5 This is a schematic diagram illustrating the principle of a broadcasting example provided in Embodiment 1 of the present invention. Detailed Implementation

[0037] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations.

[0038] Example 1

[0039] This embodiment provides a multi-user real-time collaboration method for a session-based SysML modeling tool, including the following steps:

[0040] A data layer is established, which stores multiple SysML models, and the SysML models in the data layer are the only trusted data sources.

[0041] A separate view layer is established for each client. The view layer is used to display the data layer and to modify the data in the SysML model.

[0042] A server is established to monitor data changes in the data layer in real time and push updates to all associated view layers through a broadcast mechanism when data changes. Communication between the server and the client is established through a session.

[0043] Existing technologies generally rely on the EMF Compare component for collaborative operations, but EMF Compare exhibits significant platform limitations. While it employs a metamodel-based architecture, its implementation is strictly confined to the Eclipse platform ecosystem. This deep integration necessitates model management using Eclipse core services and prevents independent deployment outside the Eclipse environment, posing significant obstacles to integration with other modern IDEs or toolchains. Furthermore, its technology stack requires the use of the EMF modeling framework, resulting in insufficient compatibility with non-EMF models. Regarding collaborative modeling implementation, although it integrates version control systems such as CVS, SVN, and Git, this traditional version control-based approach involves complex workflows requiring multiple commit / update steps and fails to achieve true real-time collaborative editing. These technical constraints make EMF Compare extremely demanding in terms of tool compatibility and technical environment requirements, posing applicability challenges in modern systems engineering practices, particularly in collaborative modeling scenarios demanding lightweight, high-performance, and cross-platform support.

[0044] The working principle of each module in the technical solution of this embodiment is described in the following reference. Figure 1 Its core architecture adopts a data-view separation design pattern. In this mechanism, the system uses the SysML model ontology as a trusted data source, while the view layer, which serves as the user interface, acts as the view of the data. This architecture design does not limit the source of the data view, ensures the independence of the view state, avoids conflicts at the view layer, and uses a centralized transaction processing engine to ensure data consistency. The essence of this architecture design is to efficiently and conveniently support multiple users to concurrently edit and modify the same model while ensuring data consistency.

[0045] As the core abstraction of the view layer, the session mechanism in this embodiment preferably uses the WebSocket protocol for communication between the server and the client, which provides a full-duplex communication channel. Compared to the traditional HTTP protocol, the WebSocket protocol provides a full-duplex communication channel. Based on this feature, the server can monitor data change events in real time and actively push updates to all related views through a broadcast mechanism, ensuring the consistency and synchronization of states across multiple clients.

[0046] The mechanism in this embodiment effectively solves the latency and resource consumption problems caused by traditional polling methods, providing underlying communication guarantees for real-time collaboration. As a further preferred solution, an extended session is established to create a session object for each client. This session object stores the view relationship and context relationship between the client and the data layer. An example of an extended session can be found in [reference needed]. Figure 2 , Figure 2 In this context, ClientSession represents the client participating in the session, SessionObject represents the session object created one-to-one for the client, DiagramObject is the model diagram representing the SysML model that the client edits through the view layer. A model diagram can be connected to multiple session objects to indicate that it is being edited by multiple clients at the same time. ProjectObject represents an entire SysML modeling project, and the connected model diagrams are part of it. Map can be used as a graph module to manage various mapping relationships.

[0047] To ensure data consistency, the preferred method for modifying the data layer in this embodiment is as follows:

[0048] A centralized transaction processing engine receives instructions from the view layer of different clients and performs unified data change processing on the data layer according to these instructions. An example of unified data change processing can be found in [reference needed]. Figure 3When editing the model diagram, `IModelState` represents the internal data state interface of the SysML model, and the objects being edited ultimately reside here. `CommandStack` is the command stack, primarily used to store various editing commands from different clients. `CommandHandler` represents the executor of the editing operation and is the core component for processing and executing commands. In simple terms, the processing flow is as follows: an editing operation is triggered by the client's view layer, such as dragging a primitive to modify a certain attribute. This operation is encapsulated as a command, which is stored in `CommandStack`. The `execute()` function in `CommandStack` is called to execute the specific command, and `flush()` can be used to refresh and clean up the stack when necessary. Based on the commands coordinated by `CommandStack`, `CommandHandler` is used to execute and process commands to modify the data in `IModelState`.

[0049] Based on this solution, in multi-user collaborative scenarios, instead of each client handling model modifications themselves, all commands can be processed centrally by a unified transaction engine on the server side. This enables controllable modification order, improves coordination, avoids conflicts, and facilitates unified broadcasting of all data changes.

[0050] Furthermore, the centralized transaction processing engine coordinates the state consistency between the view layers of different clients, and the processing mechanism is to use a selective synchronization strategy to achieve data distribution.

[0051] In other words, this mechanism optimizes communication efficiency by changing the dependency graph of model elements established in the impact analysis. During the targeted broadcast phase, updates are only pushed to clients holding expired version data. Specific selective synchronization strategies include:

[0052] For the data layer, a change impact analysis is performed, and a model element dependency graph is established. The implementation code for this step can be found below:

[0053]

[0054] When the data change occurs, the affected data and the associated clients are identified through the model element dependency graph, and updates are pushed accordingly.

[0055] And during the broadcast phase, updates are pushed only to the clients that hold the outdated version data.

[0056] A case study on broadcasting based on change impact analysis can be found here. Figure 4The system consists of three parts: CommandEngine, the command engine responsible for executing editing commands for the model; DependencyAnalyser, the dependency analyzer responsible for determining the validity of commands and which other sessions need to be synchronized; and Synchronouser, the synchronizer responsible for pushing updated data to other clients. CommandEngine sends a request to DependencyAnalyser to execute a command, with the following branches: `noEffect` indicates no impact, and DependencyAnalyser directly returns `noEffect` to CommandEngine, requiring no synchronization and ending the process; if the command has an impact, DependencyAnalyser performs model dependency analysis, analyzing which other clients are affected by the model change based on the model element dependency graph. After analysis, DependencyAnalyser returns all impact results (al lEffect) to CommandEngine. Based on the returned results, Synchronouser is responsible for pushing these changes to other relevant clients via broadcast to complete synchronization.

[0057] In addition, when broadcasting, the set of all clients involved in the current data change object is obtained, and the client currently making the data change is removed from the set of clients;

[0058] If the client set becomes empty, no operation is performed; otherwise, a broadcast is made to all online clients in the client set.

[0059] The following code snippet can be used as a reference for the above broadcasting method:

[0060]

[0061] For a specific example of broadcasting, please refer to [link / reference]. Figure 5 IActionDispatcher is the dispatch component. After the preceding CommandEngine receives all the affected results, it notifies the IActionDispatcher of the objects that need to be sent, and IActionDispatcher broadcasts accordingly.

[0062] Finally, it should be noted that in editing the model, the view layer includes a graphical canvas and a model tree, and the data change is a change to at least one model element, which includes the model's class, interface, and association.

[0063] The above are merely preferred embodiments of the present invention and are not intended to limit the present invention. Various modifications and variations can be made to the present invention by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A multi-user real-time collaboration method for a conversation-based SysML modeling tool, characterized in that, Includes the following steps: A data layer is established, which stores multiple SysML models, and the SysML models in the data layer are the only trusted data sources. A separate view layer is established for each client. The view layer is used to display the data layer and to modify the data in the SysML model. A server is established to monitor data changes in the data layer in real time and push updates to all associated view layers through a broadcast mechanism when data changes. Communication between the server and the client is established through a session.

2. The method for real-time multi-user collaboration using a session-based SysML modeling tool according to claim 1, characterized in that, The communication protocol between the server and the client uses the WebSocket protocol, which provides a full-duplex communication channel.

3. The method for real-time multi-user collaboration using a session-based SysML modeling tool according to claim 1, characterized in that, An extended session is established to create a session object for each client, and the session object stores the view relationship and context relationship between the client and the data layer.

4. The method for real-time multi-user collaboration using a session-based SysML modeling tool according to claim 1, characterized in that, The method for performing the data modification on the data layer is as follows: The centralized transaction processing engine receives instructions from the view layer of different clients and performs unified data change processing on the data layer according to the instructions.

5. A multi-user real-time collaboration method for a session-based SysML modeling tool according to claim 1, characterized in that, The centralized transaction processing engine coordinates the state consistency between the view layers of different clients. The processing mechanism is to use a selective synchronization strategy to distribute data.

6. A multi-user real-time collaboration method for a session-based SysML modeling tool according to claim 5, characterized in that, The selective synchronization strategy includes: Perform change impact analysis on the data layer and establish a model element dependency graph; When the data change occurs, the affected data and the associated clients are identified through the model element dependency graph, and updates are pushed to them.

7. A multi-user real-time collaboration method for a session-based SysML modeling tool according to claim 6, characterized in that, The selective synchronization strategy also includes: During the broadcast phase, updates are pushed only to the clients that hold the outdated version data.

8. A multi-user real-time collaboration method for a session-based SysML modeling tool according to claim 1, characterized in that, The view layer includes a graphical canvas and a model tree.

9. A multi-user real-time collaboration method for a session-based SysML modeling tool according to claim 1, characterized in that, When broadcasting, obtain the set of all clients involved in the current data change object, and remove the client currently making the data change from the client set; If the client set becomes empty, no operation is performed; otherwise, a broadcast is made to all online clients in the client set.

10. A multi-user real-time collaboration method for a session-based SysML modeling tool according to claim 1, characterized in that, The data change refers to a change to at least one model element, which includes the model's class, interface, and association relationships.

Images