Distributed data processing method, apparatus, system, device, and medium

Abstract

A distributed data processing method, apparatus, system, device and medium. The method comprises: in response to receiving a modification instruction for a first object and a first version number corresponding to the first object in a first client from a first client among a plurality of clients, comparing a second version number stored in a log server for the first object with the first version number; and in response to determining that the first version number is not lower than the second version number, assigning a third version number to the modification instruction, wherein the third version number is higher than the first version number; sending the modification instruction and the third version number to other clients among the plurality of clients except the first client; sending the third version number to the first client for updating the first version number corresponding to the first object in the first client based on the third version number; and in response to determining that the modification instruction does not include an addition or deletion operation for the first object, retaining the second version number of the first object stored in the log server.

Description

Technical Field

[0001] This disclosure relates to the field of computers, and in particular to a distributed data processing method, apparatus, system, electronic device, non-transitory computer-readable storage medium, and computer program product. Background Technology

[0002] 3D editors are tools for designing and creating 3D digital assets, improving production efficiency. They integrate various asset resources to generate 3D digital assets that support functions such as object combination, rotation, movement, and scaling. Compared to general 2D design tools, 3D editors have more complex interactive operations. Editing 3D scenes using traditional workflows can involve many stages, each requiring different processing software, creating a long and cumbersome toolchain. To address this need, multi-user collaboration has emerged. Multiple users simultaneously editing the same object online can break down upstream and downstream dependencies, shorten the 3D digital asset production cycle, and simplify the entire production process. Therefore, implementing synchronization mechanisms for multi-device operations in multi-user collaboration and resolving potential conflicts caused by multiple users are particularly important.

[0003] The methods described in this section are not necessarily methods that had been previously conceived or adopted. Unless otherwise specified, no method described in this section should be assumed to be prior art simply because it is included in this section. Similarly, unless otherwise specified, the issues mentioned in this section should not be considered to be accepted in any prior art. Summary of the Invention

[0004] This disclosure provides a distributed data processing method, apparatus, system, electronic device, non-transitory computer-readable storage medium, and computer program product.

[0005] According to one aspect of this disclosure, a distributed data processing method is provided, the method being executed on a server side, the method comprising: in response to receiving a modification instruction for a first object and a first version number corresponding to the first object in the first client from a first client among a plurality of clients, comparing a second version number for the first object stored in a log server with the first version number; and in response to determining that the first version number is not lower than the second version number, assigning a third version number to the modification instruction, wherein the third version number is higher than the first version number; sending the modification instruction and the third version number to other clients among the plurality of clients besides the first client; sending the third version number to the first client for updating the first version number corresponding to the first object in the first client based on the third version number; and in response to determining that the modification instruction does not include an add or delete operation for the first object, retaining the second version number for the first object stored in the log server.

[0006] According to another aspect of this disclosure, a distributed data processing method is provided, the method being executed on a client, the method comprising: in response to generating a modification instruction for a first object, sending the modification instruction and a first version number corresponding to the first object in the client to a log server; and in response to receiving a second version number for the first object from the log server, updating the first version number based on the second version number, wherein the second version number is higher than the first version number.

[0007] According to another aspect of this disclosure, a distributed data processing apparatus is provided, the apparatus including a log server configured to perform the following operations: in response to receiving a modification instruction for a first object and a first version number corresponding to the first object in the first client from a plurality of clients, comparing a stored second version number for the first object with the first version number; and in response to determining that the first version number is not lower than the second version number, assigning a third version number to the modification instruction, wherein the third version number is higher than the first version number; sending the modification instruction and the third version number to other clients among the plurality of clients besides the first client; sending the third version number to the first client for updating the first version number corresponding to the first object in the first client based on the third version number; and in response to determining that the modification instruction does not include an add or delete operation for the first object, retaining the stored second version number for the first object.

[0008] According to another aspect of this disclosure, a distributed data processing apparatus is provided, the apparatus including a client configured to perform the following operations: in response to generating a modification instruction for a first object, sending the modification instruction and a first version number corresponding to the first object in the client to a log server; in response to receiving a second version number for the first object from the log server, updating the first version number based on the second version number, wherein the second version number is higher than the first version number.

[0009] According to another aspect of this disclosure, a distributed data processing system is provided, comprising: a client cluster including multiple clients; and a log server; wherein the distributed data processing system is configured to perform the following operations: in response to a first client among the multiple clients generating a modification instruction for a first object, the first client sends the modification instruction and a first version number corresponding to the first object in the first client to the log server; in response to receiving the modification instruction, the log server compares the first version number with a second version number for the first object stored in the log server; in response to determining that the first version number is not lower than the second version number, the log server assigns a third version number to the modification instruction, wherein the third version number is higher than the first version number; the log server sends the modification instruction and the third version number to other clients in the client cluster besides the first client; the log server sends the third version number to the first client for updating the first version number corresponding to the first object in the first client based on the third version number; and in response to determining that the modification instruction does not include an add or delete operation for the first object, the log server retains the second version number for the first object stored in the log server.

[0010] According to another aspect of this disclosure, an electronic device is provided, comprising: at least one processor, wherein each of the at least one processor includes: a processor cache; and a memory communicatively connected to the at least one processor, wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the distributed data processing method described above.

[0011] According to another aspect of this disclosure, a non-transitory computer-readable storage medium is provided storing computer instructions, wherein the computer instructions are used to cause a computer to perform the above-described distributed data processing method.

[0012] According to another aspect of this disclosure, a computer program product is provided, including a computer program, wherein the computer program implements a distributed data processing method when executed by a processor.

[0013] These and other aspects of this disclosure will be apparent from the embodiments described below, and will be elucidated with reference to the embodiments described below. Attached Figure Description

[0014] Further details, features, and advantages of this disclosure are disclosed in the following description of exemplary embodiments taken in conjunction with the accompanying drawings. The illustrated embodiments are for illustrative purposes only and do not limit the scope of the claims. Throughout the drawings, the same reference numerals refer to similar but not necessarily identical elements.

[0015] Figure 1 This is a schematic diagram illustrating an exemplary system in which the various methods described herein may be implemented according to exemplary embodiments;

[0016] Figure 2 This is a flowchart illustrating a distributed data processing method according to an exemplary embodiment;

[0017] Figure 3 This is a flowchart illustrating a distributed data processing method according to an exemplary embodiment;

[0018] Figure 4 This is a structural block diagram illustrating a distributed data processing apparatus according to an exemplary embodiment;

[0019] Figure 5 This is a structural block diagram illustrating a distributed data processing apparatus according to an exemplary embodiment;

[0020] Figure 6 This is a block diagram illustrating the structure of a distributed data processing system according to an exemplary embodiment;

[0021] Figure 7 This is a schematic diagram illustrating a distributed data processing system according to an exemplary embodiment; and

[0022] Figure 8 This is a block diagram illustrating an exemplary computer device that can be applied to an exemplary embodiment. Detailed Implementation

[0023] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding, and should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0024] In this disclosure, unless otherwise stated, the use of terms such as "first," "second," etc., to describe various elements is not intended to limit the positional, temporal, or importance relationships of these elements; such terms are merely used to distinguish one element from another. In some examples, the first element and the second element may refer to the same instance of that element, while in other cases, based on the context, they may refer to different instances.

[0025] The terminology used in the description of the various examples described in this disclosure is for the purpose of describing particular examples only and is not intended to be limiting. Unless the context explicitly indicates otherwise, an element may be one or more unless the number of elements is specifically limited. As used herein, the term "multiple" means two or more, and the term "based on" should be interpreted as "at least partially based on". Furthermore, the terms "and / or" and "at least one of..." cover any one of the listed items and all possible combinations thereof.

[0026] In related technologies, synchronization in multi-user collaborative operations relies on distributed synchronization algorithms and data structures, including Conflict-free Replicated Data Type (CRDT) and Operational Transformation (OT). The problem with relying on these two methods is the high complexity of the data structures, making them difficult to design and implement. Furthermore, they require the application's business data to perfectly match the data structures required by both algorithms, resulting in poor adaptability.

[0027] To address the aforementioned issues, this disclosure implements synchronized collaborative editing and handles potential conflicts by setting up a centralized server. Specifically, the centralized server determines whether to receive incremental changes from multiple clients by setting a reference version number, and pushes the received incremental changes to other clients to achieve synchronization. Furthermore, the server determines whether to update the reference version number based on the type of incremental changes from the clients to resolve conflicts between concurrent requests in different scenarios. The distributed data processing method provided by this disclosure allows multiple users to edit the same object online simultaneously without adapting instruction data, supports instruction data of different data types, and has strong applicability.

[0028] Exemplary embodiments of this disclosure will now be described in detail with reference to the accompanying drawings.

[0029] Figure 1 A schematic diagram of an exemplary system 100 in which the various methods and apparatus described herein can be implemented according to embodiments of this disclosure is shown. Reference Figure 1 The system 100 includes one or more client devices 101, 102, 103, and 104, a server 120, and one or more communication networks 110 coupling the one or more client devices to the server 120. The client devices 101, 102, 103, and 104 can be configured to execute one or more applications.

[0030] In embodiments of this disclosure, server 120 may run one or more services or software applications that enable the execution of distributed data processing methods.

[0031] In some embodiments, server 120 may also provide other services or software applications that may include non-virtual and virtual environments. In some embodiments, these services may be provided as web-based services or cloud services, such as to users of client devices 101, 102, 103, and 104 under a Software as a Service (SaaS) model.

[0032] exist Figure 1 In the configuration shown, server 120 may include one or more components that implement the functions performed by server 120. These components may include software components, hardware components, or combinations thereof that can be executed by one or more processors. Users operating client devices 101, 102, 103, and 104 can sequentially interact with server 120 using one or more client applications to utilize the services provided by these components. It should be understood that various different system configurations are possible and may differ from system 100. Therefore, Figure 1 This is an example of a system used to implement the various methods described herein, and is not intended to be limiting.

[0033] Users can use client devices 101, 102, 103, and 104 to execute distributed data processing methods for the client. The client devices can provide interfaces that allow users to interact with them. The client devices can also output information to the user through these interfaces. Although... Figure 1 Only four client devices are depicted, but those skilled in the art will understand that this disclosure can support any number of client devices.

[0034] Client devices 101, 102, 103, and 104 can include various types of computer devices, such as portable handheld devices, general-purpose computers (such as personal computers and laptops), workstation computers, wearable devices, smart screen devices, self-service terminal devices, service robots, gaming systems, thin clients, various messaging devices, sensors, or other sensing devices. These computer devices can run various types and versions of software applications and operating systems, such as Microsoft Windows, Apple iOS, UNIX-like operating systems, Linux or Linux-like operating systems (such as Google Chrome OS); or include various mobile operating systems, such as Microsoft Windows Mobile OS, iOS, Windows Phone, and Android. Portable handheld devices can include cellular phones, smartphones, tablets, personal digital assistants (PDAs), etc. Wearable devices can include head-mounted displays (such as smart glasses) and other devices. Gaming systems can include various handheld gaming devices, internet-enabled gaming devices, etc. Client devices are capable of executing various applications, such as various internet-related applications, communication applications (such as email applications), short message service (SMS) applications, and can use various communication protocols.

[0035] Network 110 can be any type of network well known to those skilled in the art, and can use any of a variety of available protocols (including but not limited to TCP / IP, SNA, IPX, etc.) to support data communication. By way of example only, one or more networks 110 can be a local area network (LAN), an Ethernet-based network, a token ring network, a wide area network (WAN), the Internet, a virtual network, a virtual private network (VPN), an intranet, an extranet, a public switched telephone network (PSTN), an infrared network, a wireless network (e.g., Bluetooth, WIFI), and / or any combination of these and / or other networks.

[0036] Server 120 may include one or more general-purpose computers, special-purpose server computers (e.g., PC (personal computer) servers, UNIX servers, mid-range servers), blade servers, mainframe computers, server clusters, or any other suitable arrangement and / or combination. Server 120 may include one or more virtual machines running a virtual operating system, or other computing architectures involving virtualization (e.g., one or more flexible pools of logical storage devices that can be virtualized to maintain virtual storage devices for servers). In various embodiments, server 120 may run one or more services or software applications that provide the functionality described below.

[0037] The computing unit in server 120 can run one or more operating systems, including any of the aforementioned operating systems and any commercially available server operating system. Server 120 can also run any of a variety of additional server applications and / or middleware applications, including HTTP servers, FTP servers, CGI servers, JAVA servers, database servers, etc.

[0038] In some implementations, server 120 may include one or more applications to analyze and merge data feeds and / or event updates received from users of client devices 101, 102, 103, and 104. Server 120 may also include one or more applications to display data feeds and / or real-time events via one or more display devices of client devices 101, 102, 103, and 104.

[0039] In some implementations, server 120 can be a server for a distributed system or a server integrated with blockchain. Server 120 can also be a cloud server, or an intelligent cloud computing server or intelligent cloud host with artificial intelligence technology. A cloud server is a host product in the cloud computing service system, designed to address the shortcomings of traditional physical hosts and Virtual Private Server (VPS) services, such as high management difficulty and weak business scalability.

[0040] System 100 may also include one or more databases 130. In some embodiments, these databases may be used to store data and other information. For example, one or more of the databases 130 may be used to store information such as audio files and video files. Databases 130 may reside in various locations. For example, a database used by server 120 may be local to server 120, or it may be located away from server 120 and may communicate with server 120 via a network-based or dedicated connection. Databases 130 may be of different types. In some embodiments, the database used by server 120 may be, for example, a relational database. One or more of these databases may store, update, and retrieve data from and from the databases in response to commands.

[0041] In some embodiments, one or more of the databases 130 may also be used by an application to store application data. The databases used by the application may be of different types, such as key-value stores, object stores, or regular stores supported by a file system.

[0042] Figure 1 The system 100 can be configured and operated in various ways to enable the application of the various methods and apparatus described in this disclosure.

[0043] Figure 2 This is a flowchart illustrating a distributed data processing method according to an exemplary embodiment, the method being executed on the server side. Figure 2 As shown, the distributed data processing method 200 includes: step S201, in response to receiving a modification instruction for a first object and a first version number corresponding to the first object in the first client from a first client among a plurality of clients, comparing a second version number for the first object stored in a log server with the first version number; and step S202, in response to determining that the first version number is not lower than the second version number, assigning a third version number to the modification instruction, wherein the third version number is higher than the first version number; step S203, sending the modification instruction and the third version number to other clients among the plurality of clients besides the first client; step S204, sending the third version number to the first client for updating the first version number corresponding to the first object in the first client based on the third version number; and step S205, in response to determining that the modification instruction does not include an add or delete operation for the first object, retaining the second version number for the first object stored in the log server.

[0044] The log server stores a reference version number for each object. When it receives a modification instruction for a first object and its corresponding first version number from the first client, the log server queries the reference version number (second version number) for the first object and compares it with the first version number to determine whether to accept the modification. If the first version number is not lower than the second version number, it indicates that the first object in the first client is updated, and the log server can accept the modification. Otherwise, the log server will reject the modification. For example, when the log server rejects the modification instruction from the first client, it can send a corresponding prompt message to the first client, indicating that the current version number of the first object in the first client is too low and that the modification operation should continue after updating.

[0045] In step S202, after receiving the modification instruction from the first client, the log server assigns a third version number higher than the first version number to the modification instruction to indicate an update to the first object. In step S203, the modification instruction corresponding to this update and the third version number are sent to other clients so that they can synchronize their updates. Simultaneously, in step S204, the third version number is sent to the first client to update the version number of the first object in the first client.

[0046] According to some embodiments, the method further includes: updating the second version number based on the third version number in response to determining that the modification instruction includes an add or delete operation for the first object. The log server updates the second version number only for add or delete operations for the first object, and does not update the second version number for other modification instructions. This update control for the second version number can automatically resolve conflicts between multiple modification instructions, facilitating collaboration between multiple clients.

[0047] The following two examples illustrate how update control for the second version number resolves conflicts between multiple modification commands.

[0048] In one example, when two clients send a modification command to the log server at the same time to change the location of an object, the order of the two modifications will not affect the final consistency, thus improving compatibility during collaborative editing.

[0049] In one example, one client sends a modification instruction A to the log server to change the location of an object, while another client sends a modification instruction B to delete that object. In this example, if the log server receives A first and then B, the deletion instruction B will not affect the result of modification instruction A. However, if the log server receives B first and then A, assuming B is accepted by the log server, it will update the version number to the second version. Simultaneously, the log server must reject any subsequent operations on that object. If the version number in modification instruction A is lower than the second version number, it means the client sending instruction A has not yet received the message that the object has been deleted; in this case, modification instruction A will be rejected. Conversely, if the client already knows the object has been deleted, it will not issue any modification instructions to modify the object except for adding it back. This achieves conflict resolution between multiple modification instructions.

[0050] Meanwhile, the distributed data processing method provided in this disclosure achieves synchronized collaborative editing and handles potential conflicts by setting up a centralized log server, enabling multiple users to edit the same object online simultaneously without needing to adapt the instruction data. It can support instruction data of different data types and has strong applicability.

[0051] According to some embodiments, the log server can generate a global sequence from multiple modification instructions received from multiple clients, where the third version number corresponding to each modification instruction determines the position of the modification instruction in the global sequence. This global sequence will be pushed to the clients to be updated in sequence for synchronous updates, so that each client can obtain the first object of the latest version updated by other clients through the log server.

[0052] In some implementations, log servers can consist of multiple instances that perform data commits, backups, and master server elections through the ETCD service, thus forming a highly available cluster. At any given time, only the master log server within the cluster can accept modification commands from clients. Once a modification is accepted, the log server performs data commits and multiple replica backups through ETCD to meet high availability requirements.

[0053] According to some embodiments, the method further includes: in response to the first version number being not lower than the second version number, storing the modification instruction and the third version number in the log server. Thus, the entire accepted modification history corresponding to the first object and its corresponding version number can be obtained through the log server.

[0054] According to some embodiments, the method further includes: comparing the third version number with the fourth version number corresponding to the first object in the storage server; and in response to the third version number being higher than the fourth version number, storing the modification instruction in the storage server and updating the fourth version number based on the third version number. Thus, the storage server performs persistent storage for each object by subscribing to logs from a log server. Specifically, it stores modification instructions from the log server that are higher than its current version, thereby performing version control and permanent storage for the first object to avoid data loss.

[0055] According to some embodiments, the method further includes: in response to receiving a request from the first client including a number corresponding to the first object, determining the first object based on the number; and sending a modification instruction in the log server corresponding to the first object with a version number higher than the fourth version number and / or the first object in the storage server corresponding to the fourth version number to the first client.

[0056] Understandably, a storage server can provide objects to multiple clients. During the startup phase of the first client, when the first client needs to load the first object, it first sends a request to the storage server to retrieve the first object. The storage server identifies the requested first object based on the number attached to this request and sends the fourth version number corresponding to the first object in the storage server back to the first client. The first client then requests modification instructions for the first object's version number higher than the fourth version from the log server based on the fourth version number. Thus, the first client can obtain the first object up to the fourth version number from the storage server and the modification instructions from the log server up to the latest version. Based on these two sets of data, the first client can perform rendering operations to reconstruct the current latest version of the first object.

[0057] According to some embodiments, the method further includes: creating a snapshot of the first object in the storage server at preset time intervals, based on the modification instructions stored in the storage server and the first object corresponding to the fourth version number. It is understood that periodically instantiating multiple discrete modification instructions into a full snapshot of the first object allows the first client to directly obtain the snapshot corresponding to the first object when requesting it from the storage server. Compared to obtaining multiple discrete modification instructions and then having the client integrate them locally to reconstruct the first object, creating snapshots in the storage server at preset time intervals allows the first client to directly obtain the integrated snapshot, accelerating the process of the first client reconstructing the first object.

[0058] According to some embodiments, the storage server can also provide a service to generate object thumbnails, making each object visible to the client before it is requested by the client, so that the user can select different objects to meet different needs.

[0059] According to some embodiments, the log server, the storage server, and the plurality of clients transmit data via streaming Remote Procedure Calls (RPCs). For example, the plurality of clients and the storage server request to subscribe to messages from the log server. Upon receiving this request, the log server establishes a streaming RPC connection with each of the plurality of clients and the storage server, and subsequently sends the accepted modification instructions sequentially through these connections to the subscribers, i.e., each of the plurality of clients and the storage server. Thus, the use of remote procedure calls simplifies and makes communication between multiple ends more transparent, and improves interoperability between the ends.

[0060] According to another aspect of this disclosure, a distributed data processing method is provided, which is executed on a client side. For example... Figure 3 As shown, the distributed data processing method 300 includes: step S301, in response to generating a modification instruction for a first object, sending the modification instruction and a first version number corresponding to the first object in the client to a log server; step S302, in response to receiving a second version number for the first object from the log server, updating the first version number based on the second version number, wherein the second version number is higher than the first version number.

[0061] In step S301, when the first user corresponding to the client modifies the first object, the client sends a modification instruction to the log server, along with the first version number of the first object currently in the client, for the log server to confirm whether the modification will be accepted. In step S302, when a second version number for the first object is received from the log server, it indicates that the modification instruction has been accepted by the log server, and the first version number of the local first object is updated according to the second version number returned by the log server. In response to an update to the first object in the client, the client only needs to send a modification instruction for the first object to the log server, without sending the modified first object itself. This significantly reduces the amount of data transmitted, lowers communication latency, improves communication efficiency, and simplifies the update process.

[0062] According to some embodiments, the method further includes: in response to generating the modification instruction, performing a rendering operation based on the modification instruction to generate a first video stream for display. It is understood that, to ensure smoothness and low latency on the client side, the modification instruction is first rendered by a 3D scene editing module and a renderer, and the rendered result is directly presented to the user in the client's user interface. For example, the editing and rendering operations of the modification instruction can be implemented via a server corresponding to the client, or they can be executed locally on the client. The execution location of the editing and rendering operations can be determined based on specific needs and application scenarios, and this disclosure does not limit this.

[0063] According to some embodiments, the method further includes: in response to generating the modification instruction for the first object, generating an inverse instruction of the modification instruction and storing the inverse instruction in the undo stack of the client, wherein the inverse instruction corresponds to the inverse operation of the operation corresponding to the modification instruction; in response to the undo operation of the modification instruction, determining whether a second version number is received from the log server; and in response to receiving the second version number from the log server, executing the inverse instruction and sending the inverse instruction to the log server.

[0064] According to some embodiments, the method further includes: in response to the undo operation, generating an inverse instruction of the inverse instruction, and storing the generated inverse instruction of the inverse instruction in the redo stack of the client for use in restoring the undo operation.

[0065] Therefore, a corresponding undo operation can be implemented for each modification, and a redo option can be provided for each undo operation, offering users an intuitive way to undo and redo in collaborative editing scenarios. For example, after an undo operation, in response to a new operation, the redo stack in the client is cleared.

[0066] According to some embodiments, the method further includes: sending a request to a storage server to obtain the first object, the request including a number corresponding to the first object; receiving a third version number corresponding to the first object in the storage server; sending the third version number to the log server; receiving the first object corresponding to the third version number from the storage server and / or receiving a modification instruction for the first object whose corresponding version number is higher than the third version number from the log server; and rendering based on the received first object corresponding to the third version number and / or the modification instruction for the first object whose corresponding version number is higher than the third version number to display the current latest version of the first object.

[0067] Understandably, a storage server can provide objects to multiple clients. During the client's startup phase, when a client needs to load the first object, it first sends a request to the storage server to retrieve the first object. The storage server identifies the requested first object based on the number attached to this request and sends the corresponding fourth version number of the first object back to the client. The client then requests modification instructions for the first object's version number higher than the fourth version from the log server based on the fourth version number. Thus, the client can obtain the first object up to the fourth version number from the storage server and the modification instructions from the log server up to the latest version. Based on these two sets of data, the client can then perform rendering operations to reconstruct the latest version of the first object.

[0068] According to some embodiments, the method further includes: in response to receiving an instruction from the log server regarding a modification operation on the first object, performing a rendering operation based on the instruction to generate a second video stream for display. Thus, a client can use the log server to monitor modification operations on the first object generated by other clients and sequentially apply the received modification operations to its own currently maintained first object, ensuring that each client obtains the latest version of the first object.

[0069] According to another aspect of this disclosure, a distributed data processing apparatus is provided, such as... Figure 4As shown, the distributed data processing device 400 includes a log server 401, which is configured to perform the following operations: in response to receiving a modification instruction for a first object and a first version number corresponding to the first object in the first client from a first client among a plurality of clients, compares a stored second version number for the first object with the first version number; and in response to determining that the first version number is not lower than the second version number, assigns a third version number to the modification instruction, wherein the third version number is higher than the first version number; sends the modification instruction and the third version number to other clients among the plurality of clients besides the first client; sends the third version number to the first client for updating the first version number corresponding to the first object in the first client based on the third version number; and in response to determining that the modification instruction does not include an add or delete operation for the first object, retains the stored second version number for the first object.

[0070] Log server 401 stores a corresponding reference version number set for each object. When it receives a modification instruction for the first object and the first version number corresponding to the first object in the first client, log server 401 queries the reference version number corresponding to the first object, i.e., the second version number, and compares it with the first version number to determine whether to accept the modification made by the first client to the first object. If the first version number is not lower than the second version number, it indicates that the first object in the first client is updated, and log server 401 can accept the modification for the first object; otherwise, log server 401 will reject the modification. For example, when log server 401 rejects the modification instruction from the first client, it can send a corresponding prompt message to the first client, indicating that the current version number of the first object in the first client is too low and that the modification operation on the first object needs to be continued after updating.

[0071] Upon receiving a modification instruction from the first client, the log server 401 assigns a third version number, higher than the first version number, to the modification instruction to indicate an update to the first object. It then sends the corresponding modification instruction and the third version number to other clients so they can synchronize their updates. Simultaneously, the log server 401 sends the third version number to the first client to update the version number of the first object within that client.

[0072] According to some embodiments, the log server 401 is further configured to update the second version number based on the third version number in response to determining that the modification instruction includes an add or delete operation for the first object. The log server 401 updates the second version number only for add or delete operations for the first object, and does not update the second version number for other modification instructions. This control over the update of the second version number can automatically resolve conflicts between multiple modification instructions, facilitating collaboration between multiple clients.

[0073] The following two examples illustrate how the Log Server 401 update control for the second version number resolves conflicts between multiple modification commands.

[0074] In one example, when two clients send a modification command to the log server at the same time to change the location of an object, the order of the two modifications will not affect the final consistency, thus improving compatibility during collaborative editing.

[0075] In one example, one client sends a modification instruction A to the log server to change the location of an object, while another client sends a modification instruction B to delete that object. In this example, if the log server receives A first and then B, the deletion instruction B will not affect the result of modification instruction A. However, if the log server receives B first and then A, assuming B is accepted by the log server, it will update the version number to the second version. Simultaneously, the log server must reject any subsequent operations on that object. If the version number in modification instruction A is lower than the second version number, it means the client sending instruction A has not yet received the message that the object has been deleted; in this case, modification instruction A will be rejected. Conversely, if the client already knows the object has been deleted, it will not issue any modification instructions to modify the object except for adding it back. This achieves conflict resolution between multiple modification instructions.

[0076] Meanwhile, the distributed data processing device 400 achieves synchronized collaborative editing and handles potential conflicts by setting up a centralized log server 401, allowing multiple users to edit the same object online simultaneously without needing to adapt the instruction data. It can support instruction data of different data types and has strong applicability.

[0077] According to some embodiments, the log server 401 can generate a global sequence from multiple modification instructions received from multiple clients, wherein the third version number corresponding to each modification instruction will determine the position of the modification instruction in the global sequence. This global sequence will be pushed to the clients to be updated in sequence for synchronous updates, so that each client can obtain the first object of the latest version updated by other clients through the log server.

[0078] According to some embodiments, the log server 401 can consist of multiple instances, which perform data commit, backup, and master server election through the ETCD service, thereby forming a highly available cluster. At any given time, only the master log server in the cluster can accept modification commands from clients. After a modification is accepted, the log server will perform data commit and multiple replica backups through ETCD to meet the high availability requirements.

[0079] According to some embodiments, the distributed data processing device 400 further includes a storage server, wherein the storage server stores the first object corresponding to a fourth version number, and wherein the storage server is configured to perform the following operations: comparing the third version number with the fourth version number; and in response to the third version number being higher than the fourth version number, storing the modification instruction and updating the fourth version number based on the third version number. Thus, the storage server performs persistent storage for each object by subscribing to logs from a log server; specifically, it stores modification instructions from the log server that are higher than its current version, to perform version control and persistent storage for the first object, thereby preventing data loss.

[0080] According to some embodiments, the log server 401 is further configured to: in response to the first version number being not lower than the second version number, store the modification instruction and the third version number. Thus, the log server 401 can retrieve all accepted modification history corresponding to the first object and its corresponding version number.

[0081] According to some embodiments, the storage server is further configured to: in response to receiving a request from the first client including a number corresponding to the first object, determine the first object based on the number; send the first object corresponding to the fourth version number to the first client; and wherein the log server 401 is further configured to: send a modification instruction for the first object whose corresponding version number is higher than the fourth version number to the first client.

[0082] Understandably, the storage server can provide objects to multiple clients. During the startup phase of the first client, when the first client needs to load the first object, it first sends a request to the storage server to retrieve the first object. The storage server determines the first object requested by the first client based on the number attached to this request and sends the fourth version number corresponding to the first object in the storage server back to the first client. The first client then requests modification instructions for the first object's version number higher than the fourth version from the log server 401 based on the fourth version number. Thus, the first client can obtain the first object up to the fourth version number from the storage server and the modification instructions from the log server 401 up to the latest version number. Therefore, the first client can perform rendering operations based on these two sets of data to reconstruct the current latest version of the first object.

[0083] According to some embodiments, the storage server is further configured to: create a snapshot of the first object at preset time intervals, based on the stored modification instructions and the first object corresponding to the fourth version number.

[0084] Understandably, the storage server periodically instantiates multiple discrete modification instructions into a full snapshot of the first object, allowing the first client to directly obtain the snapshot corresponding to the first object when requesting it from the storage server. Compared to obtaining multiple discrete modification instructions and then having the client integrate them locally to reconstruct the first object, the snapshots created by the storage server at preset time intervals allow the first client to directly obtain the integrated snapshot, accelerating the process of the first client reconstructing the first object.

[0085] According to some embodiments, the log server, the storage server, and the plurality of clients transmit data via streaming remote procedure calls. For example, the plurality of clients and the storage server request to subscribe to messages from the log server 401. Upon receiving this request, the log server establishes a streaming RPC connection with each of the plurality of clients and the storage server, and subsequently sends the accepted modification instructions sequentially through this connection to the subscribers, i.e., each of the plurality of clients and the storage server. Thus, the use of remote procedure calls simplifies and makes communication between multiple ends more transparent, and improves interoperability between the ends.

[0086] According to another aspect of this disclosure, a distributed data processing apparatus is provided, such as... Figure 5As shown, the distributed data processing device 500 includes a client 501, which is configured to perform the following operations: in response to generating a modification instruction for a first object, sending the modification instruction and a first version number corresponding to the first object in the client to a log server; and in response to receiving a second version number for the first object from the log server, updating the first version number based on the second version number, wherein the second version number is higher than the first version number.

[0087] When the first user corresponding to client 501 modifies the first object, client 501 sends a modification instruction to the log server, along with the first version number of the first object in client 501, for the log server to confirm whether the modification will be accepted. Upon receiving a second version number for the first object from the log server, it indicates that the modification instruction has been accepted, and the client updates the first version number of the local first object based on the second version number returned by the log server. In response to an update to the first object in client 501, client 501 only needs to send a modification instruction for the first object to the log server, without needing to send the modified first object itself. This significantly reduces the amount of data transmitted, lowers communication latency, improves communication efficiency, and simplifies the update process.

[0088] According to some embodiments, the client 501 is further configured to: in response to generating the modification instruction, perform a rendering operation based on the modification instruction to generate a first video stream for display. It is understood that, to ensure client smoothness and low latency, the modification instruction is first rendered by the 3D scene editing module and renderer, and the rendered result is directly presented to the user in the client's user interface. For example, the editing and rendering operations of the modification instruction can be implemented via a server corresponding to the client, or they can be executed locally on the client. The execution location of the editing and rendering operations can be determined based on specific needs and application scenarios, and this disclosure does not limit this.

[0089] According to some embodiments, the client 501 is further configured to perform the following operations: in response to generating the modification instruction for the first object, generating an inverse instruction of the modification instruction and storing the inverse instruction in the client's undo stack, wherein the inverse instruction corresponds to the inverse operation of the operation corresponding to the modification instruction; in response to the undo operation of the modification instruction, determining whether the second version number is received from the log server; and in response to receiving the second version number from the log server, executing the inverse instruction and sending the inverse instruction to the log server.

[0090] According to some embodiments, the client 501 is further configured to: generate a reverse instruction of the reverse instruction in response to the undo operation, and store the generated reverse instruction of the reverse instruction in the client's redo stack for use in restoring the undo operation.

[0091] Therefore, a corresponding undo operation can be implemented for each modification operation, and a redo option can be provided for each undo operation, so as to provide users with intuitive undo and redo operations in the context of collaborative editing. For example, after an undo operation, in response to a new operation, the redo stack in the client's 501 is cleared.

[0092] According to some embodiments, the client 501 is further configured to perform the following operations: send a request to a storage server to obtain the first object, the request including a number corresponding to the first object; receive from the storage server a third version number corresponding to the first object in the storage server; send a message containing the third version number to the log server; receive from the storage server the first object corresponding to the third version number and / or receive from the log server a modification instruction for the first object whose corresponding version number is higher than the third version number; and render based on the received first object corresponding to the third version number and / or the modification instruction for the first object whose corresponding version number is higher than the third version number to display the current latest version of the first object.

[0093] Understandably, the storage server can provide objects to multiple clients. During the client startup phase, when client 501 needs to load the first object, it first sends a request to the storage server to retrieve the first object. The storage server determines the first object requested by the first client based on the number attached to this request and sends the fourth version number corresponding to the first object in the storage server back to client 501. Client 501 then requests modification instructions for the first object's version number higher than the fourth version from the log server based on the fourth version number. Thus, client 501 can obtain the first object up to the fourth version number from the storage server and the modification instructions from the fourth version number to the latest version from the log server. Therefore, client 501 can perform rendering operations based on these two sets of data to reconstruct the current latest version of the first object.

[0094] According to some embodiments, the client 501 is further configured to: in response to receiving an instruction from the log server regarding a modification operation on the first object, perform a rendering operation based on the instruction to generate a second video stream for display. Thus, the client can listen to modification operations on the first object generated by other clients through the log server, and sequentially apply the received modification operations to its own currently maintained first object, ensuring that each client obtains the latest version of the first object.

[0095] According to another aspect of this disclosure, a distributed data processing system is provided, such as Figure 6 As shown, the distributed data processing system 600 includes: a client cluster 601, which includes multiple clients; and a log server 602; wherein the distributed data processing system is configured to perform the following operations: in response to a first client among the multiple clients generating a modification instruction for a first object, the first client sends the modification instruction and a first version number corresponding to the first object in the first client to the log server; in response to receiving the modification instruction, the log server compares the first version number with a second version number for the first object stored in the log server; in response to determining that the first version number is not lower than the second version number, the log server assigns a third version number to the modification instruction, wherein the third version number is higher than the first version number; the log server sends the modification instruction and the third version number to other clients in the client cluster besides the first client; the log server sends the third version number to the first client for updating the first version number corresponding to the first object in the first client based on the third version number; and in response to determining that the modification instruction does not include an add or delete operation for the first object, the log server retains the second version number for the first object stored in the log server.

[0096] Log server 602 stores a corresponding reference version number set for each object. When a modification instruction for a first object and its corresponding first version number in the first client's database are received from the first client in client cluster 601, log server 602 queries the reference version number (second version number) of the first object and compares it with the first version number to determine whether to accept the modification made by the first client. If the first version number is not lower than the second version number, it indicates that the first object in the first client is updated, and log server 602 can accept the modification; otherwise, the log server will reject the modification. For example, when log server 602 rejects the modification instruction from the first client, it can send a corresponding prompt message to the first client, indicating that the current version number of the first object in the first client is too low and that the modification operation should continue after updating.

[0097] Upon receiving a modification instruction from the first client, log server 602 assigns a third version number, higher than the first version number, to the modification instruction to indicate an update to the first object. It then sends the corresponding modification instruction and the third version number to other clients to enable them to synchronize their updates. Simultaneously, the third version number is sent to the first client to update the version number of the first object within that client.

[0098] Log server 602 updates the second version number only for add or delete operations on the first object, and does not update the second version number for other modification commands. Update control for the second version number can automatically resolve conflicts between multiple modification commands, which helps to facilitate collaboration between multiple clients.

[0099] The distributed data processing system 600 achieves synchronized collaborative editing and handles potential conflicts by setting up a centralized log server 602, allowing multiple users to edit the same object online simultaneously without needing to adapt the instruction data. It can support instruction data of different data types and has strong applicability.

[0100] According to some embodiments, the log server 602 can generate a global sequence from multiple modification instructions received from multiple clients in the client cluster 601. The third version number corresponding to each modification instruction will determine the position of the modification instruction in the global sequence. This global sequence will be pushed to the clients to be updated in sequence for synchronous updates, so that each client can obtain the first object of the latest version updated by other clients through the log server.

[0101] According to some embodiments, the log server 602 can consist of multiple instances, which perform data commit, backup, and master server election through the ETCD service, thereby forming a highly available cluster. At any given time, only the master log server in the cluster can accept modification commands from clients. After a modification is accepted, the log server will perform data commit and multiple replica backups through ETCD to meet the high availability requirements.

[0102] According to some embodiments, the distributed data processing system further includes: a storage server storing the first object corresponding to a fourth version number; wherein the distributed data processing system is further configured to perform the following operations: the log server sends the modification instruction and the third version number to the storage server; in response to receiving the modification instruction and the third version number, the storage server compares the third version number and the fourth version number; and in response to the third version number being higher than the fourth version number, the storage server stores the modification instruction and updates the fourth version number based on the third version number. Thus, the storage server performs persistent storage for each object by subscribing to the logs of the log server. Specifically, it stores modification instructions from the log server that are higher than its current version, thereby performing version control and permanent storage for the first object to avoid data loss.

[0103] Figure 7 This is a schematic diagram illustrating a distributed data processing system according to an exemplary embodiment. Figure 7As shown, the distributed data processing system 700 includes one or more client devices 701, 702, and 703, engine servers 721, 722, and 723 corresponding to the one or more client devices, a log server 724, a storage server 730, and one or more communication networks 711, 712, and 713 that couple the one or more client devices to their respective engine servers. Multiple users can edit and modify the same object using multiple client devices. The log server 724 determines whether to accept modification instructions from the clients and pushes accepted instructions to other clients to achieve synchronization between the clients. After receiving an update instruction from the log server 724, the client can render the received instruction via the corresponding engine server to obtain a video stream for display on the client's page. Furthermore, when a user performs a modification operation on an object in the client, the client can render the corresponding modification operation via the corresponding engine server to display the user's modification operation on the client's page in real time. It is understood that rendering of object editing or modification operations can be implemented through the engine server corresponding to the client, or it can be rendered locally on the client; this disclosure does not limit this. Meanwhile, over 730 objects are stored on the storage server, which receives modification instructions from the log server, corresponding to object updates, to completely record the modification history of each object and permanently store the objects.

[0104] While specific functions have been discussed above with reference to specific modules, it should be noted that the functions of the modules discussed herein can be divided into multiple modules, and / or at least some functions of multiple modules can be combined into a single module. The specific module performing an action discussed herein includes the specific module itself performing the action, or alternatively, the specific module calling or otherwise accessing another component or module that performs the action (or performs the action in conjunction with the specific module). Therefore, a specific module performing an action can include the specific module performing the action itself and / or another module that the specific module calls or otherwise accesses to perform the action. As used herein, the phrase "entity A initiates action B" can mean that entity A issues an instruction to perform action B, but entity A itself does not necessarily perform action B.

[0105] It should also be understood that this article can describe various technologies in the general context of software and hardware components or program modules. The above regarding... Figure 4 , Figure 5 and Figure 6The described modules can be implemented in hardware or in hardware in combination with software and / or firmware. For example, these modules can be implemented as computer program code / instructions configured to execute in one or more processors and stored in a computer-readable storage medium. Alternatively, these modules can be implemented as hardware logic / circuit.

[0106] According to one aspect of this disclosure, an electronic device is provided, comprising at least one processor and a memory communicatively connected to the at least one processor. Each of the at least one processor includes a processor cache. The memory stores instructions executable by the at least one processor, which, when executed by the at least one processor, enable the at least one processor to perform the steps of any of the method embodiments described above.

[0107] According to one aspect of this disclosure, a non-transitory computer-readable storage medium is provided, on which a computer program is stored, which, when executed by a processor, implements the steps of any of the method embodiments described above.

[0108] According to one aspect of this disclosure, a computer program product storing computer instructions is provided, comprising a computer program that, when executed by a processor, implements the steps of any of the method embodiments described above.

[0109] In the following text, combined with Figure 8 Illustrative examples describing such computer devices, non-transitory computer-readable storage media, and computer program products.

[0110] Figure 8 An example configuration of a computer device 800 that can be used to implement the methods described herein is shown. Each of the above-described devices 400 and 500 can also be implemented wholly or at least partially by computer device 1200 or similar devices or systems.

[0111] Computer device 800 can be a variety of different types of devices. Examples of computer device 800 include, but are not limited to: desktop computers, server computers, laptop or netbook computers, mobile devices (e.g., tablet computers, cellular or other wireless phones (e.g., smartphones), notebook computers, mobile stations), wearable devices (e.g., glasses, watches), entertainment devices (e.g., entertainment appliances, set-top boxes communicatively coupled to a display device, game consoles), televisions or other display devices, automotive computers, and so on.

[0112] Computer device 800 may include at least one processor 802, memory 804, multiple communication interfaces 806, display device 808, other input / output (I / O) devices 810, and one or more mass storage devices 812 capable of communicating with each other, such as via system bus 814 or other suitable connections.

[0113] Processor 802 may be a single processing unit or multiple processing units, and all processing units may include single or multiple computing units or multiple cores. Processor 802 may be implemented as one or more microprocessors, microcomputers, microcontrollers, digital signal processors, central processing units, state machines, logic circuits, and / or any device that manipulates signals based on operating instructions. Among other capabilities, processor 802 may be configured to acquire and execute computer-readable instructions stored in memory 804, mass storage device 812, or other computer-readable media, such as program code of operating system 816, program code of application program 818, program code of other program 820, etc.

[0114] Memory 804 and mass storage device 812 are examples of computer-readable storage media for storing instructions executed by processor 802 to perform the various functions described above. For example, memory 804 may generally include both volatile and non-volatile memory (e.g., RAM, ROM, etc.). Furthermore, mass storage device 812 may generally include hard disk drives, solid-state drives, removable media, including external and removable drives, memory cards, flash memory, floppy disks, optical disks (e.g., CDs, DVDs), storage arrays, network-attached storage, storage area networks, etc. Both memory 804 and mass storage device 812 may be collectively referred to herein as memory or computer-readable storage media, and may be non-transitory media capable of storing computer-readable, processor-executable program instructions as computer program code, which may be executed by processor 802 as a specific machine configured to perform the operations and functions described in the examples herein.

[0115] Multiple programs may be stored on mass storage device 812. These programs include operating system 816, one or more application programs 818, other programs 820, and program data 822, and they may be loaded into memory 804 for execution. Examples of such application programs or program modules may include, for example, computer program logic (e.g., computer program code or instructions) for implementing the following components / functions: method 200 and / or method 300 (including any suitable steps of method 200 and / or method 300), and / or other embodiments described herein.

[0116] Although Figure 8The modules 816, 818, 820, and 822, or portions thereof, are illustrated as being stored in memory 804 of computer device 800; however, modules 816, 818, 820, and 822 may be implemented using any form of computer-readable medium accessible by computer device 800. As used herein, “computer-readable medium” includes at least two types of computer-readable media: computer-readable storage media and communication media.

[0117] Computer-readable storage media include volatile and non-volatile, removable and non-removable media implemented by any method or technology for storing information such as computer-readable instructions, data structures, program modules, or other data. Computer-readable storage media include, but are not limited to, RAM, ROM, EEPROM, flash memory or other memory technologies, CD-ROM, DVD, or other optical storage devices, magnetic cassettes, magnetic tapes, disk storage devices or other magnetic storage devices, or any other non-transmission medium that can be used to store information for access by a computer device. In contrast, communication media can embody computer-readable instructions, data structures, program modules, or other data in modulated data signals such as carrier waves or other transmission mechanisms. Computer-readable storage media as defined herein do not include communication media.

[0118] One or more communication interfaces 806 are used for exchanging data with other devices, such as via a network, direct connection, etc. Such communication interfaces can be one or more of the following: any type of network interface (e.g., a network interface card (NIC)), wired or wireless (such as IEEE 802.11 Wireless LAN (WLAN)) wireless interface, Wi-MAX interface, Ethernet interface, Universal Serial Bus (USB) interface, cellular network interface, Bluetooth. TM Interfaces include near-field communication (NFC) interfaces, etc. Communication interface 806 facilitates communication across various network and protocol types, including wired networks (e.g., LAN, cable, etc.) and wireless networks (e.g., WLAN, cellular, satellite, etc.), the Internet, etc. Communication interface 806 can also provide communication with external storage devices (not shown) such as storage arrays, network-attached storage, storage area networks, etc.

[0119] In some examples, a display device 808, such as a monitor, may be included for displaying information and images to the user. Other I / O devices 810 may be devices that receive various inputs from the user and provide various outputs to the user, and may include touch input devices, gesture input devices, cameras, keyboards, remote controls, mice, printers, audio input / output devices, and so on.

[0120] The techniques described herein can be supported by these various configurations of computer device 800, and are not limited to specific examples of the techniques described herein. For example, the functionality can also be implemented wholly or partially on a “cloud” using a distributed system. A cloud includes and / or represents a platform for resources. The platform abstracts the underlying functionality of the cloud’s hardware (e.g., servers) and software resources. Resources may include applications and / or data that can be used when performing computational processing on a server remote from computer device 800. Resources may also include services provided via the Internet and / or via subscriber networks such as cellular or Wi-Fi networks. The platform can abstract resources and functionality to connect computer device 800 to other computer devices. Therefore, the implementation of the functionality described herein can be distributed throughout the cloud. For example, the functionality may be implemented partly on computer device 800 and partly through a platform that abstracts the functionality of the cloud.

[0121] Although this disclosure has been described and illustrated in detail in the accompanying drawings and the foregoing description, such description and illustration should be considered illustrative and suggestive, not restrictive; this disclosure is not limited to the disclosed embodiments. By studying the drawings, the disclosure, and the appended claims, those skilled in the art will be able to understand and implement variations of the disclosed embodiments in practice with respect to the claimed subject matter. In the claims, the word "comprising" does not exclude other elements or steps not listed, the indefinite article "a" or "an" does not exclude a plurality, the term "a plurality" means two or more, and the term "based on" should be interpreted as "at least partially based on". The mere fact that certain measures are recited in mutually different dependent claims does not indicate that a combination of these measures cannot be beneficial.

Claims

1. A distributed data processing method, the method being performed at a server side, the method comprising: in response to receiving a modification instruction for a first object and a first version number corresponding to the first object at a first client from a plurality of clients, comparing a second version number stored in a log server for the first object with the first version number, wherein the first object is an editable object capable of being moved in a three-dimensional editor at the first client, and wherein the first object is rendered and displayed in the three-dimensional editor based on the modification instruction; and in response to determining that the first version number is not lower than the second version number, assigning a third version number for the modification instruction, wherein the third version number is higher than the first version number; sending the modification instruction and the third version number to clients other than the first client from the plurality of clients; sending the third version number to the first client for updating the first version number corresponding to the first object at the first client based on the third version number; in response to determining that the modification instruction does not include an adding or deleting operation for the first object, preserving the second version number stored in the log server for the first object; and in response to determining that the modification instruction includes an adding or deleting operation for the first object, updating the second version number based on the third version number. 2.The method of claim 1, further comprising: in response to the first version number not being lower than the second version number, storing the modification instruction and the third version number in the log server. 3.The method of claim 1 or 2, further comprising: comparing the third version number with a fourth version number corresponding to the first object at a storage server; and in response to the third version number being higher than the fourth version number, storing the modification instruction in the storage server and updating the fourth version number based on the third version number. 4.The method of claim 3, further comprising: in response to receiving a request including a number corresponding to the first object from the first client, determining the first object based on the number; and sending a modification instruction corresponding to the first object in the log server with a version number higher than the fourth version number and / or the first object corresponding to the fourth version number in the storage server to the first client. Data transmission between the log server, the storage server and the plurality of clients is performed through streaming remote procedure calls. 6.The method of any one of claims 4-5, further comprising: creating a snapshot corresponding to the first object based on the modification instruction stored in the storage server and the first object corresponding to the fourth version number at the storage server at a preset time interval in the storage server. 7.A distributed data processing method, the method being performed at a client side, the method comprising: ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ 5. The method of claim 3, wherein, ​ ​ ​ ​ in response to generating the modification instruction for the first object, performing a rendering operation based on the modification instruction to generate a first video stream for displaying the first object in a three-dimensional editor of the client, wherein the first object is an editable object that can be moved in position in the three-dimensional editor; sending the modification instruction and a first version number corresponding to the first object in the client to a log server; and in response to receiving a second version number for the first object from the log server, updating the first version number based on the second version number, wherein the second version number is higher than the first version number, the second version number is sent in response to determining that the first version number is not lower than a third version number for the first object stored by the log server, and wherein in response to determining that the modification instruction does not include an add or delete operation for the first object, the third version number is preserved, and in response to determining that the modification instruction includes an add or delete operation for the first object, the third version number is updated based on the second version number.

8. The method of claim 7, further comprising: in response to generating the modification instruction for the first object, generating an inverse instruction of the modification instruction and storing the inverse instruction in an undo stack of the client, wherein the inverse instruction corresponds to an inverse operation of an operation corresponding to the modification instruction; in response to an undo operation of the modification instruction, determining whether the second version number is received from the log server; and in response to receiving the second version number from the log server, executing the inverse instruction and sending the inverse instruction to the log server.

9. The method of claim 8, further comprising: in response to the undo operation, generating an inverse instruction of the inverse instruction and storing the generated inverse instruction of the inverse instruction in a redo stack of the client for recovering the undo operation.

10. The method of any one of claims 7-9, further comprising: sending a request to a storage server for obtaining the first object, the request including a number corresponding to the first object; receiving a third version number corresponding to the first object in the storage server from the storage server; sending the third version number to the log server; receiving the first object corresponding to the third version number from the storage server and / or receiving a modification instruction for the first object from the log server that a corresponding version number for the first object is higher than the third version number; and performing rendering based on the received first object corresponding to the third version number and / or the modification instruction for the first object that a corresponding version number for the first object is higher than the third version number to display a current latest version of the first object.

11. The method of any one of claims 7-9, further comprising: in response to receiving an instruction of a modification operation for the first object from the log server, performing a rendering operation based on the instruction to generate a second video stream for displaying.

12. A distributed data processing apparatus, the apparatus comprising a log server, the log server configured to perform the following operations: in response to receiving a modification instruction for a first object and a first version number corresponding to the first object in a first client from a first client among a plurality of clients, comparing a second version number stored for the first object with the first version number, wherein, the first object is rendered and displayed in a three-dimensional editor of the first client based on the modification instruction, and wherein the first object is an editable object capable of moving position in the three-dimensional editor; and in response to determining that the first version number is not lower than the second version number, assigning a third version number to the modification instruction, wherein the third version number is higher than the first version number; sending the modification instruction and the third version number to clients of the plurality of clients other than the first client; sending the third version number to the first client for updating the first object in the first client based on the third version number; in response to determining that the modification instruction does not comprise an adding or deleting operation for the first object, retaining the stored second version number for the first object; and in response to determining that the modification instruction comprises an adding or deleting operation for the first object, updating the second version number based on the third version number.

13. The apparatus of claim 12, wherein, the log server is further configured to: in response to the first version number not being lower than the second version number, store the modification instruction and the third version number.

14. The apparatus of claim 12 or 13, further comprising a storage server, wherein, the storage server has stored therein the first object corresponding to a fourth version number, and wherein the storage server is configured to perform the following operations: comparing the third version number with the fourth version number; and in response to the third version number being higher than the fourth version number, storing the modification instruction and updating the fourth version number based on the third version number.

15. The apparatus of claim 14, wherein, the storage server is further configured to: in response to receiving a request from the first client comprising a number corresponding to the first object, determining the first object based on the number; sending the first object corresponding to the fourth version number to the first client; and wherein the log server is further configured to send to the first client a modification instruction for the first object corresponding to a version number higher than the fourth version number.

16. The apparatus of claim 14, wherein, transmission of data between the log server, the storage server and the plurality of clients is through streaming remote procedure calls.

17. The apparatus of any of claims 15-16, wherein, the storage server is further configured to: at a preset time interval, creating a snapshot of the first object based on the stored modification instruction and the first object corresponding to the fourth version number.

18. A distributed data processing apparatus, the apparatus comprising a client, the client configured to perform the following operations: in response to generating the modification instruction for the first object, performing a rendering operation based on the modification instruction to generate a first video stream for displaying the first object in the three-dimensional editor of the client, wherein, the first object is an editable object capable of moving position in the three-dimensional editor; sending the modification instruction and a first version number corresponding to the first object in the client to a log server; and in response to receiving a second version number for the first object from the log server, updating the first version number based on the second version number, wherein the second version number is higher than the first version number, the second version number is sent in response to determining that the first version number is not lower than a third version number for the first object stored by the log server, and wherein, in response to determining that the modification instruction does not include an add or delete operation for the first object, the third version number is retained; and in response to determining that the modification instruction includes an add or delete operation for the first object, the third version number is updated based on the second version number.

19. The apparatus of claim 18, wherein, The client is further configured to perform the following operations: in response to generating the modification instruction for the first object, generating an inverse instruction of the modification instruction and storing the inverse instruction in a undo stack of the client, wherein the inverse instruction corresponds to an inverse operation of an operation corresponding to the modification instruction; in response to the undo operation on the modification instruction, determining whether the second version number is received from the log server; and in response to receiving the second version number from the log server, executing the inverse instruction and sending the inverse instruction to the log server.

20. The apparatus of claim 19, wherein, The client is further configured to: in response to the undo operation, generating an inverse instruction of the inverse instruction and storing the generated inverse instruction of the inverse instruction in a redo stack of the client for recovering the undo operation.

21. The apparatus of any one of claims 18-20, wherein, The client is further configured to perform the following operations: sending a request for obtaining the first object to a storage server, the request including a number corresponding to the first object; receiving a third version number corresponding to the first object in the storage server from the storage server; sending the third version number to the log server; receiving the first object corresponding to the third version number from the storage server and / or receiving a modification instruction for the first object from the log server, the corresponding version number for the first object being higher than the third version number; and rendering based on the received first object corresponding to the third version number and / or the modification instruction for the first object, the corresponding version number being higher than the third version number, to display the first object of the current latest version.

22. The apparatus of any one of claims 18-20, wherein, The client is further configured to: in response to receiving an instruction of a modification operation for the first object from the log server, performing a rendering operation based on the instruction to generate a second video stream for display.

23. A distributed data processing system, comprising: a client cluster, the client cluster including a plurality of clients; and a log server; wherein the distributed data processing system is configured to perform the following operations: in response to the first client in the plurality of clients generating a modification instruction for a first object, performing, by the first client, a rendering operation based on the modification instruction to generate a first video stream for displaying the first object in a three-dimensional editor of the first client, and sending the modification instruction and a first version number corresponding to the first object in the first client to the log server, wherein the first object is an editable object that is movable in position in the three-dimensional editor; in response to receiving the modification instruction, comparing, by the log server, the first version number and a second version number corresponding to the first object stored in the log server; in response to determining that the first version number is not lower than the second version number, assigning, by the log server, a third version number to the modification instruction, wherein the third version number is higher than the first version number; sending, by the log server, the modification instruction and the third version number to clients in the client cluster other than the first client; sending, by the log server, the third version number to the first client for updating the first version number corresponding to the first object in the first client based on the third version number; in response to determining that the modification instruction does not include an addition or deletion operation for the first object, retaining, by the log server, the second version number corresponding to the first object stored in the log server; and in response to determining that the modification instruction includes an addition or deletion operation for the first object, updating the second version number based on the third version number.

24. The distributed data processing system of claim 23, the distributed data processing system further comprising: a storage server storing the first object corresponding to a fourth version number; wherein the distributed data processing system is further configured to perform the following operations: sending, by the log server, the modification instruction and the third version number to the storage server; in response to receiving the modification instruction and the third version number, comparing, by the storage server, the third version number and the fourth version number; and in response to the third version number being higher than the fourth version number, storing, by the storage server, the modification instruction and updating the fourth version number based on the third version number.

25. An electronic device, comprising: at least one processor, wherein each of the at least one processor comprises: a processor cache; and a memory communicatively connected with the at least one processor, wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-11.

26. A non-transitory computer readable storage medium having stored thereon computer instructions, wherein, the computer instructions cause the computer to perform the method of any one of claims 1-11.

27. A computer program product comprising a computer program, wherein, the computer program, when executed by a processor, implements the method of any one of claims 1-11.

Images