KR101068645B1 - Master-Slave based Tile Display System and Synchronization Method between Master-Slaves - Google Patents

Abstract

The master-slave based tile display system includes a first display device, a second display device installed in a multi-array manner with the first display device to form a tile display, a master personal computer (PC) connected to the first display device, And a slave PC connected with the master PC via a network and connected with the second display device, wherein each of the master PC and the slave PC stores attributes of a dynamic object that is a dynamic scene component that requires continuous synchronization. Comprising a shared object block that can reference the object, and a shared object list that is an array of the shared object block. In the synchronization process of the master-slave based tile display system, the complexity of the synchronization program can be reduced and the synchronization process can be modularized, thereby ensuring the expandability and portability of the synchronization module.

Description

Tiled display system based master-slave and method of synchronizing between master and slave for the same}

The present invention relates to a master-slave-based tile display system, and more particularly, to a master-slave-based tile display system for performing synchronization of state change information between master-slaves using a shared object or a shared function. .

Recently, high-resolution large displays such as liquid crystal displays (LCDs), plasma display panels (PDPs), and organic electroluminescence displays (OLEDs) have been developed. The high resolution large display provides users with a wide viewing angle and high precision to increase the realism and immersion of the information visualized on the screen, and the actual ratio of digital mock-up (DMU) reviews, large engineering / geographic data It can be applied to a variety of industries such as detailed verification of information, increased visual immersion on virtual reality, rapid decision making in the aviation / traffic control room, and increased advertisement display / publicity effect.

In implementing a large display, there is an increasing trend to use a tile display system capable of realizing a screen having various layouts without being limited by a screen size than a single display system. In particular, with the recent rapid development of flat panel display technologies such as PDP / LCD, the application of flat panel-based tile displays with excellent resolution and brightness, easy installation and maintenance, and low cost is increasing.

The tile display system needs to apply various hardware and software technologies according to the content and purpose of the provided content. In particular, distributed visualization technology using PC clusters is essential for digital mock-up image evaluation, engineering simulation visualization, and virtual reality applications that must provide high-resolution 3D computer graphics on a large screen.

Distributed visualization technology is a technology that distributes rendering work by applying a plurality of resources existing on the network and applies space-time synchronization to them. Distributed visualization technology is divided into a client-server model and a master-slave model based on the type of data distributed and the role of each cluster node.

In the client-server model, a single virtual reality application is executed on a client, and a scene is generated based on user input, and a distributed rendering is performed by transmitting a set of generated graphic commands to a rendering server through a network. to be. Also known as centralized because it manages all graphics data in key applications, it is easy to separate application modules and distributed rendering modules and to develop programs, but has a wide bandwidth and low latency for sending large amounts of graphics instructions. There is a disadvantage that this is necessary.

In the master-slave model, the same virtual reality application is executed in all clusters at the same time.The master performs simulation based on user input and transfers the state change information of each scene to each slave to synchronize the scene. This is how rendering is done. Only the state change information of the scene is transmitted through the network, so it is a suitable model when large data visualization is required. However, since the application and all the graphics data must be copied to each cluster node, the maintenance of the system is difficult and the separation of the graphics engine and the distributed rendering module is difficult, so that program development is not easy.

The technical problem to be solved by the present invention is a master-slave based master-slave-based tile display system to simplify the program and enable modularization to increase the maintainability of the system and to secure the expandability and portability of the synchronization module The present invention provides a tile display system.

A master-slave based tile display system according to an embodiment of the present invention is provided with a first display device, a second display device installed in a multi-array manner with the first display device to form a tile display, and connected with the first display device. And a slave PC connected to the master PC via a network and to the second display device, wherein each of the master PC and the slave PC is a dynamic scene component requiring continuous synchronization. Construct a shared object block that can store the properties of a dynamic object and refer to a real object, and a shared object list that is an array of the shared object block.

The shared object block may include an object pointer that may refer to the real object. The shared object block may include an attribute value indicating whether the dynamic scene component is activated or the number of synchronization.

A data packet including an object identifier (identifier) referring to the shared object list and an integer value or a real value representing state information of the shared object may be transmitted through the network.

The data packet may include a short packet for transmitting a shared object requiring simple parameter information and a long packet for transmitting a shared object having a plurality of attributes.

The master PC and the slave PC may configure a shared function block including a shared function for an instruction requiring intermittent synchronization and a function pointer for executing the shared function. The master PC and the slave PC may configure a shared function map indicating the shared function block.

The network may use a user datagram protocol (UDP).

The data transmission from the master PC to the slave PC may be a broadcasting or multicasting transmission scheme.

In the master-slave-based tile display system in which a master node and a slave node constitute a shared object block and a shared object block list corresponding to each other for dynamic scene components requiring continuous synchronization, the master and slave nodes according to another embodiment of the present invention. The synchronization method may be performed by: a simulation update step of executing simulation logic in the master node according to an input signal received from an input device, configuring a scene in which the simulation update result according to the simulation update process is reflected in the master node, and updated scene configuration A scene update step of reflecting an element to the shared object block of the master node, and the attribute value defined according to the format of each shared object block while traversing the shared object block included in its shared object list in the master node; And a synchronization step of transmitting to the Eve node.

The master node and the slave node configure a shared function block and a shared function map corresponding to each other for a command requiring intermittent synchronization, and the synchronizing step includes the shared function when a function for processing a specific event is called in the master node. The method may include transmitting a function name for processing the specific event included in the block to the slave node.

The synchronizing step may include updating, by the slave node, an attribute value of its own shared object block corresponding to the shared object block of the master node.

The slave node may further include a slave scene update step of updating a scene component by checking a shared object list of the slave node.

The method may further include a rendering step of converting state change information of the scene component updated in the master node and the slave node into a rendering command.

The method may further include a swap buffer step of synchronously outputting a display signal according to a swap buffer command in the master node and the slave node.

In the synchronization process of the master-slave based tile display system, the complexity of the synchronization program can be reduced and the synchronization process can be modularized, thereby ensuring the expandability and portability of the synchronization module.

1 is a block diagram illustrating an example of a master-slave based tile display system.
2 is a flowchart illustrating an example of a method of performing rendering for distributed visualization of a master-slave scheme.
3 is a block diagram illustrating synchronization of scene components using a shared object list according to an embodiment of the present invention.
4 is a block diagram illustrating a configuration of a shared object list according to an embodiment of the present invention.
5 is a block diagram illustrating synchronization of scene components using a shared function map according to an embodiment of the present invention.
6 is a block diagram illustrating a packet structure for communication between a master and a slave according to an embodiment of the present invention.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings so that those skilled in the art may easily implement the present invention. As those skilled in the art would realize, the described embodiments may be modified in various different ways, all without departing from the spirit or scope of the present invention.

In addition, in the various embodiments, components having the same configuration are represented by the same reference symbols in the first embodiment. In the other embodiments, only components different from those in the first embodiment will be described .

In order to clearly describe the present invention, parts irrelevant to the description are omitted, and like reference numerals designate like elements throughout the specification.

Throughout the specification, when a part is "connected" to another part, this includes not only "directly connected" but also "electrically connected" with another element in between. . In addition, when a part is said to "include" a certain component, which means that it may further include other components, except to exclude other components unless otherwise stated.

1 is a block diagram illustrating an example of a master-slave based tile display system.

Referring to FIG. 1, a master-slave based tile display system includes one master node and a plurality of slave nodes. Here we use a personal computer (PC) for each node. That is, the tile display system includes a master PC 10 and a plurality of slave PCs 20-1,..., 20-K. The master PC 10 and the plurality of slave PCs 20-1,..., 20-K are connected through a network. This is called a PC cluster.

The master PC 10 receives an input signal from the input device 30 and performs processing such as simulation update, scene update, synchronization, etc. for distributed visualization. The input device 30 may be a user input device such as a keyboard, a mouse, a joystick, or a multimedia providing device. The master PC 10 provides the plurality of slave PCs 20-1,..., 20-K with state change information according to scene update reflecting the input signal and the simulation result.

The plurality of slave PCs 20-1,..., 20-K perform a scene update process based on the state change information provided from the master PC 10.

The display device 15 (25-1, ..., 25-K) is connected to each of the master PC 10 and the plurality of slave PCs 20-1, ..., 20-K. The display device 15 of the master PC 10 and the display devices 25-1, ..., 25-K of the plurality of slave PCs 20-1, ..., 20-K are connected in a multi-array manner. Installed to form a tile display. For example, the display device 15 of the master PC 10 and the display devices 25-1,..., 25-K of the plurality of slave PCs 20-1,. It may be an element device such as a beam projector, a digital light processing (DLP) cube, a PDP / LCD, or the like, and a tile display may be implemented by an array type installation of such element devices.

Here, the PC and the display device are shown as being connected 1: 1 to implement a tile display. However, the PC and the display device are connected in a 1: n format using a video splitter, or various input signals and output signals It can be connected in m: n format using a mapable wall controller (m is any number of sources, n is the number of displays).

2 is a flowchart illustrating an example of a method of performing rendering for distributed visualization of a master-slave scheme.

Referring to FIG. 2, distributed visualization of a master-slave method is aimed at detecting and transmitting a state change. First, after constructing the scene components in the initialization process, the components that need synchronization and the rendering space region are defined, and each application is executed at the same time.

<Master loop>

The master PC 10 processes the input signal received from the input device 30 (S110), and performs a simulation update process according to the input signal (S120). The simulation update process consists of accumulation of simulation time and execution of simulation logic corresponding to the accumulated simulation time.

A scene update process constituting a scene reflecting the input signal and the simulation update result is performed (S130). The scene components constituting the scene include a camera, a scene node, an object, a light, and the like, and a periodic or intermittent state change of the scene component occurs during the scene update process.

The master PC 10 transmits the state change of the scene component to the slave PC 20 to perform synchronization (S140). In the synchronization process, the state change information of the scene component may be delivered in a streaming method or a command method. In the streaming method, the state change value of the scene component is continuously transmitted and synchronized every frame. The command method is a method in which a command for controlling a state change value of a component or a specific logic is intermittently transmitted and synchronized only when a specific event occurs.

In the proposed synchronization scheme, shared object lists and shared function maps are defined for reusability of distributed rendering modules and for module separation from the graphics engine. The shared object list is defined as an array of data blocks that store the properties of dynamic scene components that require constant synchronization that must be delivered in a streaming fashion, and that can refer to real objects. The shared function map is defined as an array of function blocks consisting of a function name and a function pointer to reference it for commands that require intermittent synchronization that must be delivered command-wise. A detailed description of the shared object list and the shared function map will be given later.

The master PC 10 performs a rendering process of converting state change information of a scene component into a rendering command (S150). The rendering command is transmitted to the graphics card to complete the hardware rendering of the master PC 10.

Thereafter, when a swap buffer command is transmitted, the frame buffer of the graphics card is activated and a display signal is transmitted to the display device 15 (S160). The swap buffer command activates the frame buffer.

<Slave loop>

The slave PC 20 receives the state change information of the scene component and performs synchronization (S210). The slave PC 20 may obtain the state change information of the scene component by checking the shared object list or the shared function map.

The slave PC 20 performs a scene update process based on the state change information of the scene element (S220), and performs a rendering process of converting the state change information of the scene element into a render command (S230). The rendering command is transmitted to the graphics card to complete the hardware rendering of the slave PC 20.

Thereafter, when a swap buffer command is transmitted, the frame buffer of the graphics card is activated and a display signal is transmitted to the display device 25 (S240). The transmission timing of the swap buffer command of the master PC 10 and the slave PC 20 may be controlled to control output synchronization of the display signal. In general, when the master PC 10 and the slave PC 20 have a constant frame refresh rate (frame per second, FPS) of 60 Hz or more, output synchronization of a display signal using a swap buffer command is not required. If you are concerned about a decrease in the refresh rate of some clusters, output synchronization can minimize shape distortion or delay.

3 is a block diagram illustrating synchronization of scene components using a shared object list according to an embodiment of the present invention. 4 is a block diagram illustrating a configuration of a shared object list according to an embodiment of the present invention.

3 and 4, a dynamic scene component requiring continuous synchronization is called a shared object, and a data block capable of storing the attributes of the dynamic scene component and referencing an actual object is a shared object block (shared object). object block, and an array of shared object blocks is called a shared object list. The shared object list may be recorded in a storage area, a storage medium, or the like provided in the execution memory of the master PC 10 and the slave PC 20 as a data structure in the form of a linked dimension or a linked list of shared object blocks.

In the initialization process, a shared object block is configured and arranged in the shared object list, which is configured to correspond to each other in the master PC 10 and each slave PC 20. That is, the shared object list 220 of the slave PC 20 includes the shared object block 230 in the same arrangement as the shared object list 120 of the master PC 10, and the shared object block of the slave PC 20. 230 is configured in the same structure as the shared object block 130 of the master PC (10).

The master PC 10 constructs a shared object list 120 including a plurality of shared object blocks 130 corresponding to the plurality of shared objects 110. The slave PC 20 constructs a shared object list 220 including a plurality of shared object blocks 230 corresponding to the master PC 10, and each shared object block 230 is a plurality of slave PCs 20. Corresponds to the shared object 210 of.

The shared object of the master PC 10 may include a camera 110-1, a scene node 110-2, an animation 110-3, a light 110-4, a parameter 110-5, and the like. Properties of the camera 110-1 include position, orientation, scale, and the like, which are stored in the shared object block 1 130-1. Attributes of the scene node 110-2 include a position, an orientation, and the like, which are stored in the shared object block 2 130-2. The property of the animation 110-3 is animation time, which is stored in shared object block 3 130-3. Properties of lighting 110-4 include location, direction, power, and the like, which are stored in shared object block 4 130-4. Attributes of parameters 110-5 include application specific parameters such as simulation time, weather time, etc., which are stored in shared object block 5 130-5. That is, the shared object block 130 corresponding to each shared object 110 is configured, and each shared object block 130 represents the attributes of the corresponding shared object 110.

The shared object block 130 of the master PC 10 includes a block ID, whether a dynamic scene component or a specific parameter is activated, the number of synchronizations, and an object pointer that can refer to these attribute values and the shared object.

In the scene update process (S130) of the master loop, the attributes of the shared object 110 are updated according to the state change of the dynamic scene component, which is reflected in the corresponding shared object block 130. In the process of synchronizing the master loop (S140), the master PC 10 traverses the shared object blocks 130 included in its shared object list 120 and defines attributes according to the format of each shared object block 130. The value is transmitted to the slave PC 20 through the network.

The slave PC 20 updates the attribute value of its own shared object block 230 corresponding to the shared object block 130 of the master PC 10. The slave PC 20 updates the state of the corresponding shared object 210 according to the attribute value of the shared object block 230 with reference to the object pointer.

5 is a block diagram illustrating synchronization of scene components using a shared function map according to an embodiment of the present invention.

Referring to FIG. 5, a function for an instruction requiring intermittent synchronization is called a shared function, and a function block composed of a shared function and a function pointer that can refer to the function is called a shared function block. In other words, an array of shared function blocks is called a shared function map. The shared function map may be recorded in a storage area, a storage medium, and the like provided in the execution memory of the master PC 10 and the slave PC 20 as a map structure indicating the shared function block. That is, each of the master PC 10 and the slave PC 20 may configure a shared function block and a shared function map.

Shared functions include command functions such as changing navigation, simulation control, animation control, and particle system control. Shared functions also include command functions for aperiodic object properties, such as visibility, color values, and material values.

When a function for processing a specific event is called on the master PC 10, the same function must be called on the master PC 10 and the slave PC 20. Since the master PC 10 needs additional logic to be transferred to the slave PC 20, there is a difficulty in consistent program writing and function call. By concatenating the name of a predefined function with the function pointer, you can use an interface that is replaced by the passing of the function name.

The shared function block includes a name of a predefined shared function and a function pointer capable of executing the corresponding shared function. The shared function name is called a key and the function pointer is called a key value.

The master PC 10 constructs a shared function map 170 indicating the plurality of shared function blocks 160, and the slave PC 20 generates a plurality of shared function blocks 260 corresponding to the master PC 10. A shared function map 270 is constructed.

When the shared function for processing a specific event is called, the master PC 10 finds a key of the shared function in the shared function map 170 and transmits it through the network. The slave PC 10 calls a shared function that processes a specific event by referring to a kit value corresponding to the key of the shared function received from the shared function map 270. That is, the master PC 10 and the slave PC 20 may perform synchronization by transmitting a key of a shared function for a command requiring intermittent synchronization. In addition, the function command may be managed consistently using the shared function maps 170 and 270 provided in the master PC 10 and the slave PC 20.

6 is a block diagram illustrating a packet structure for communication between a master and a slave according to an embodiment of the present invention.

Referring to FIG. 6, the state change information of the master PC 10 is configured as an appropriate data packet according to a streaming method or a command method and transmitted to the slave PC 20.

In a streaming scheme, that is, synchronization using a shared object list, a data packet may be configured in the form of a short packet or a long packet. Short packets are applied to shared objects that require simple parameter information transfer. Long packets are applied to shared objects that require multiple data transfers, including three-dimensional positions and orientations. For example, a shared object having a single property, such as an animation having a time property and a parameter having an application specific property, may be transmitted using a short packet. In addition, a shared object having a plurality of attributes such as a camera, a scene node, and a light may be transmitted using a long packet.

The short packet includes an object ID capable of referring to the shared object list and an integer value or one or more float values representing state information of the shared object. In a short packet, it may consist of a 2-bit object ID, a 4-bit integer value, and a 4-bit real value. The long packet may include a plurality of real values representing the object ID and the state information of the shared object. The long packet may consist of a 2-bit object ID and eight 4-bit integer values. The number of bits of the object ID, integer value, and real number included in the short packet and the long packet is only an example, and may be determined by various bits depending on the property of the shared object of the graphics program used in the tile display system.

In the command method, that is, synchronization using a shared function map, a data packet may be configured in the form of a string packet. The string packet contains a string representing a function name and an integer value and a real value representing a function parameter. The string packet may consist of a 32-bit function name, a 4-bit integer value, and a 4-bit real value. The number of bits of a function name, an integer value, and a real value included in a string packet is merely an example, and may be determined by various bits according to a graphics program used in a tile display system.

In the case of designing the data structure transmitted from the master PC 10 to the slave PC 20 as a single packet of the maximum size in consideration of the transfer mode of all state changes and the shape of the object, unnecessary data is continuously transmitted to waste network resources. May result. In addition, designing individual data structures for all objects can increase the complexity of the program.

Like the proposed method, using short packet and long packet in streaming method and string packet in command method can reduce program complexity and unnecessary waste of network resources.

Meanwhile, data transmission from the master PC 10 to the slave PC 20 may use a user datagram protocol (UDP). In general, a PC cluster performs communication using an IP (internet protocol) based socket. A TCP (transmission control protocol) can perform reliable communication by controlling an IP based flow, but wastes resources by unnecessary flow control. Can cause. However, UDP is a one-sided communication protocol that is more efficient in synchronizing scene components and synchronization of swap buffer commands in a master-slave based tile display system. In addition, the data transfer from the master PC 10 to the slave PC 20 is hardware packet copy through the router than the data transfer from the master PC 10 to each slave PC 20 by using socket communication. Possible broadcasting or multicasting transmission schemes are efficient.

It is to be understood that both the foregoing general description and the following detailed description of the present invention are illustrative and explanatory only and are intended to be illustrative of the invention and are not to be construed as limiting the scope of the invention as defined by the appended claims. It is not. Therefore, those skilled in the art will understand that various modifications and equivalent other embodiments are possible. Therefore, the true technical protection scope of the present invention will be defined by the technical spirit of the appended claims.

Claims (15)

A first display device;
A second display device installed in a multiple array manner with the first display device to form a tile display;
A master PC connected to the first display device; And
A slave PC connected with the master PC through a network and connected with the second display device;
Each of the master PC and the slave PC constitutes a shared object block capable of storing a property of a dynamic object that is a dynamic scene component requiring continuous synchronization and referencing an actual dynamic object, and a shared object list that is an array of the shared object blocks. Master-slave based tile display system. The method according to claim 1,
And the shared object block comprises an object pointer capable of referring to the actual dynamic object. The method of claim 2,
The shared object block is a master-slave-based tile display system including an attribute value indicating whether the dynamic scene component is activated, the number of synchronization. The method according to claim 1,
And a data packet including an object identifier (identifier) referring to the shared object list and an integer value or a real value representing state information of the shared object through the network. The method of claim 4, wherein
The data packet is a master-slave-based tile display system comprising a short packet for the transmission of a shared object requiring the transmission of simple parameter information and a long packet for the transmission of a shared object having a plurality of attributes. The method according to claim 1,
And the master PC and the slave PC correspond to each other to form a shared function block including a shared function for an instruction requiring intermittent synchronization and a function pointer for executing the shared function. The method of claim 6,
And the master PC and the slave PC configure a shared function map indicating the shared function block in correspondence with each other. The method according to claim 1,
The network is a master-slave based tile display system using a user datagram protocol (UDP). The method according to claim 1,
The master-slave-based tile display system in which data transmission from the master PC to the slave PC is a broadcasting or multicasting transmission method. A method for synchronizing between a master and a slave in a master-slave based tile display system in which a master node and a slave node form a list of shared object blocks and shared object blocks corresponding to each other for dynamic scene components requiring continuous synchronization,
A simulation updating step of executing simulation logic in the master node according to an input signal received from an input device;
A scene update step of constructing a scene in which the simulation update result according to the simulation update process is reflected in the master node, and reflecting the updated scene component in the shared object block of the master node; And
A synchronization step of traversing the shared object block included in its shared object list in the master node and transmitting an attribute value defined according to the format of each shared object block to the slave node;
Synchronization method between the master and slave in the master-slave-based tile display system comprising a. The method of claim 10,
The master node and the slave node configure a shared function block and a shared function map corresponding to each other for a command requiring intermittent synchronization,
The synchronizing step includes transmitting a name of a function for processing a specific event included in the shared function block to the slave node when a function for processing a specific event is called in the master node. How to synchronize between master and slave in tile display system. The method of claim 10,
The synchronizing step includes updating, by the slave node, an attribute value of its own shared object block corresponding to the shared object block of the master node in a master-slave-based tile display system. The method of claim 10,
And a slave scene updating step of updating a scene component by checking a list of shared objects of the slave node in the slave node. The method of claim 13,
And a rendering step of converting the state change information of the scene component updated in the master node and the slave node into a rendering command. The method of claim 14,
And a swap buffer step of synchronously outputting a display signal according to a swap buffer command in the master node and the slave node.

Images