KR20140063279A - A concurrent and parallel processing system based on synchronized messages - Google Patents

A concurrent and parallel processing system based on synchronized messages Download PDF

Info

Publication number
KR20140063279A
KR20140063279A KR1020120130456A KR20120130456A KR20140063279A KR 20140063279 A KR20140063279 A KR 20140063279A KR 1020120130456 A KR1020120130456 A KR 1020120130456A KR 20120130456 A KR20120130456 A KR 20120130456A KR 20140063279 A KR20140063279 A KR 20140063279A
Authority
KR
South Korea
Prior art keywords
message
component
processing system
parallel processing
requested
Prior art date
Application number
KR1020120130456A
Other languages
Korean (ko)
Other versions
KR101448861B1 (en
Inventor
황선명
이병기
Original Assignee
한남대학교 산학협력단
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 한남대학교 산학협력단 filed Critical 한남대학교 산학협력단
Priority to KR1020120130456A priority Critical patent/KR101448861B1/en
Publication of KR20140063279A publication Critical patent/KR20140063279A/en
Application granted granted Critical
Publication of KR101448861B1 publication Critical patent/KR101448861B1/en

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38—Concurrent instruction execution, e.g. pipeline, look ahead
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F15/00—Digital computers in general; Data processing equipment in general
    • G06F15/16—Combinations of two or more digital computers each having at least an arithmetic unit, a program unit and a register, e.g. for a simultaneous processing of several programs
    • G06F15/163—Interprocessor communication

Abstract

The present invention relates to a massive parallel processing system based on a synchronized message capable of being connected to clients and processing a lot of work (requested work) requested by the clients in parallel at the same time. The present invention comprises an object which performs the requested work by dividing the same into unit work and generates a component which independently the unit work and a message queue which receives messages requested by the component and stores the messages according to a receiving order. The present invention brings the oldest message from the message queue and transmits the oldest message to a processing unit which processes a process of the component which requests the message. The massive parallel processing system is provided to divide the work to each component, thereby avoiding the degradation of a performance caused by mutual exclusion in simultaneous programming and easily distributing the work in a multicore environment.

Description

동기적 메시지 기반 대량 병렬처리 시스템 { A concurrent and parallel processing system based on synchronized messages }[0002] A concurrent and parallel processing system based on synchronized messages

본 발명은 다수의 클라이언트와 연결되어 상기 클라이언트가 요청하는 다수의 작업을 동시에 병렬적으로 처리하되, 메시지 큐를 이용하여 동시성 프로그래밍에서 상호 배제하여 처리하는 동기적 메시지 기반 대량 병렬처리 시스템에 관한 것이다.
The present invention relates to a synchronous message-based massively parallel processing system, which is connected to a plurality of clients to simultaneously process a plurality of tasks requested by the client in parallel and to exclude them from each other in concurrent programming using a message queue.

일반적으로, 병렬(parallel) 프로그래밍 또는 동시성(concurrent) 프로그래밍은 다수의 프로세스(또는 프로그램)가 동시에 수행하여 작업을 처리하는 프로그래밍을 말한다. 병렬 프로그램은 서로 다른 작업들이 동시에 수행되는 경우도 있고, 하나의 작업을 다수의 단위 작업으로 나누어 다수의 단위 작업들을 동시에 수행시키는 경우도 있다.In general, parallel programming or concurrent programming refers to programming in which a plurality of processes (or programs) execute at the same time to process a job. In parallel programs, different tasks may be executed at the same time, or a task may be divided into a plurality of unit tasks to perform a plurality of unit tasks simultaneously.

병렬 프로그래밍의 일례로서, 직렬 알고리즘을 병렬화하는 예가 도 1에 도시되고 있다. 도 1은 직렬 알고리즘을 병렬화 할 때 발생하는 극단적인 예로서, 도 1의 프로그램은 1부터 100까지의 정수들의 합을 구하는 프로그램이다. 만약 명령어가 스레드 1이 끝나기 전에 실행되어, 스레드 2가 가져가는 값은 스레드 1의 결과가 아닌 스레드 1에 입력된 값 1을 가져간다. 따라서 스레드 2는 변수 Sum의 값을 2로 변경하게 되므로, 잘못된 결과를 만들게 된다. 이를 경쟁상태라고 한다.As an example of parallel programming, an example of parallelizing a serial algorithm is shown in FIG. 1 is an example of an extreme case occurring when a serial algorithm is parallelized. The program of FIG. 1 is a program for obtaining a sum of integers from 1 to 100. If the instruction is executed before thread 1 ends, the value taken by thread 2 takes the value 1 entered in thread 1, not the result of thread 1. Therefore, thread 2 changes the value of the variable Sum to 2, which results in an incorrect result. This is called competition.

알고리즘을 병렬화하지 않는 경우, 프로그래머는 이를 막기 위해 락(Lock)을 사용하여 상호배제를 하게 되는데 상호배제된 상태에서는 다른 스레드가 사용 중인 변수에 접근하지 못하도록 막게 되며, 작업이 끝나면 락(Lock)을 풀고 다른 스레드가 접근할 수 있게 한다. When the algorithm is not parallelized, the programmer uses locks to prevent mutual exclusion. In the mutually excluded state, other threads are prevented from accessing the variables in use, and locks Unlock and allow other threads to access.

상호배제는 프로그램이 반드시 정상적으로 실행될 수 있게 하지만, 다른 스레드들이 대기하는 동안 오버헤드가 발생하여 수행 속도를 느리게 만들 수 있다. Mutual exclusion allows the program to run normally, but it can slow down the execution time due to overhead while other threads are waiting.

또한 스레드간의 의사소통, 스레드 생성 해제에 따른 자원관리의 문제로 실행시간이 늘어날 수 있는 문제점이 있다.
In addition, there is a problem that execution time is increased due to a problem of resource management due to communication between threads and release of thread creation.

또 다른 병렬 프로그래밍의 예로서, 도 2는 웹 어플리케이션 서버에서의 병렬처리 프로그래밍을 나타내고 있다. 웹 어플리케이션 서버는 웹 환경을 구현하는 것에 최적의 솔루션이 되어왔다. 전통적인 기존의 웹 환경은 여러 개의 페이지가 있고, 많은 양의 페이지 데이터를 받아와, 한 페이지를 이동할 때마다 적은 카운트, 큰 크기의 명령 및 트랜잭션을 발생시킨다.As another example of parallel programming, Figure 2 illustrates parallel programming in a web application server. Web application servers have become the optimal solution for implementing the web environment. Traditional traditional web environments have multiple pages, receive large amounts of page data, and each time a page is moved, it generates fewer counts, larger orders, and transactions.

적은 카운트의 트랜잭션을 가지므로 같은 데이터 공간을 공유하는 것이 문제가 되지 않으며, 어플리케이션 서버 상에서의 공유메모리에 대한 상호배제도 충분히 수용할 수 있다.  Since there are few count transactions, sharing the same data space is not a problem, and mutual exclusion of shared memory on the application server can be sufficiently accommodated.

하지만, 이를 SNG(Social Network Game, 쇼셜 네트워크 게임) 등에 적용시키면 문제가 달라진다. SNG는 처음 한 번에 페이지와 각종 필요한 데이터를 로드한 뒤, 적은 양의 데이터를 자주 요청한다. 이는 많은 카운트, 적은 크기의 명령 및 트랜잭션을 발생시키는 것을 의미하고, 본래 웹 어플리케이션 서버가 의도한 것과는 정 반대의 상황이 일어나게 된다. However, if you apply it to SNG (Social Network Game, social network game), the problem is different. The SNG loads the page and all the necessary data the first time, then requests a small amount of data frequently. This means generating a large number of counts, a small amount of instructions and transactions, and the opposite situation to what the web application server originally intended to be.

어플리케이션 서버는 공유된 메모리상에서 요청된 명령을 처리하면서 많은 양의 병목현상을 발생시키게 되고, 이보다 심각한 것은 데이터베이스와의 트랜잭션에서 대량의 읽기 쓰기 연산으로 인한 병목현상이다. 파일시스템은 메모리보다 수행시간이 훨씬 느리므로 많은 양의 데이터가 아님에도 접근속도로 인한 병목현상으로 시스템에 큰 부하를 가져오게 된다. The application server processes a requested command on the shared memory and causes a large amount of bottlenecks, and more serious is the bottleneck caused by a large amount of read / write operations in the transaction with the database. The file system is much slower to execute than memory, so even though it is not a large amount of data, the bottleneck caused by access speed causes a heavy load on the system.

실제로 많은 수의 SNG(쇼셜 네트워크 게임)들이 아직도 이러한 웹 서비스 형태로 구현되어있어 잘 운영이 되는 것 같은 서비스들도 사용자 수가 증가함에 따라 많은 서비스 장애를 발생시키고 있다.
In fact, a large number of SNG (social network games) are still implemented in this type of web service, and services that seem to be operating well cause many service failures as the number of users increases.

본 발명의 목적은 상술한 바와 같은 문제점을 해결하기 위한 것으로, 다수의 클라이언트와 연결되어 상기 클라이언트가 요청하는 다수의 작업을 동시에 병렬적으로 처리하되, 메시지 큐를 이용하여 동시성 프로그래밍에서 상호 배제하여 처리하는 동기적 메시지 기반 대량 병렬처리 시스템을 제공하는 것이다.The object of the present invention is to solve the above-mentioned problems, and it is an object of the present invention to provide a method and system for processing a plurality of jobs concurrently requested by a client, Based mass-parallel processing system.

특히, 본 발명의 목적은 각각의 요청된 작업을 객체 단위로 독립하게 하고, 각 객체는 요청 작업을 수행하기 위한 단위작업들을 각각 컴포넌트로 구성하고, 컴포넌트가 메시지 기반으로 상호 배제되어 처리하도록 하는 동기적 메시지 기반 대량 병렬처리 시스템을 제공하는 것이다.
In particular, it is an object of the present invention to provide a method and apparatus for making each requested task independent on an object-by-object basis, each object comprising unit operations for performing a request operation, And to provide a massively parallel processing system based on a miracle message.

상기 목적을 달성하기 위해 본 발명은 다수의 클라이언트와 연결되어 상기 클라이언트가 요청하는 다수의 작업(이하 요청 작업)을 동시에 병렬적으로 처리하는 동기적 메시지 기반 대량 병렬처리 시스템에 관한 것으로서, 상기 요청 작업을 단위 작업으로 나누어 수행하되, 상기 단위 작업을 독립적으로 수행하는 컴포넌트를 생성하여 수행시키는 다수의 객체; 및, 상기 컴포넌트에서 요청하는 메시지들을 수신하여 저장하는 적어도 2개의 저장소로 구성된 메시지 큐를 포함하고, 상기 컴포넌트는 상기 저장소 중 어느 하나(이하 제1 저장소)에 저장된 메시지를 처리하고, 새로 발생되는 메시지를 상기 제1 저장소와 다른 저장소(이하 제2 저장소)에 저장하는 것을 특징으로 한다.In order to achieve the above object, the present invention is a synchronous message-based massively parallel processing system connected to a plurality of clients and simultaneously processing a plurality of jobs requested by the clients (hereinafter referred to as a request task) in parallel, A plurality of objects to be executed by dividing the unit work into a unit work and generating and executing a component that performs the unit work independently; And a message queue configured with at least two repositories for receiving and storing messages requested by the component, the component processes a message stored in one of the repositories (hereinafter referred to as a first repository) (Hereinafter referred to as " second storage ").

또, 본 발명은 동기적 메시지 기반 대량 병렬처리 시스템에 있어서, 상기 컴포넌트는 해당 단위 작업을 수행하기 위한 데이터 및 기능을 처리하는 프로세스로 구성되는 것을 특징으로 한다.According to another aspect of the present invention, there is provided a synchronous message-based massively parallel processing system, wherein the component comprises a process for processing data and functions for performing a corresponding unit task.

또, 본 발명은 동기적 메시지 기반 대량 병렬처리 시스템에 있어서, 상기 시스템은, 컴포넌트 클래스를 저장하는 컴포넌트 클래스를 더 포함하고, 상기 컴포넌트는 상기 컴포넌트 클래스로부터 인터페이스 객체를 상속함으로써 생성되는 것을 특징으로 한다.The present invention also provides a synchronous message-based massively parallel processing system, wherein the system further comprises a component class for storing a component class, and the component is generated by inheriting an interface object from the component class .

또, 본 발명은 동기적 메시지 기반 대량 병렬처리 시스템에 있어서, 상기 제1 저장소에 저장된 메시지가 모두 처리되면, 상기 컴포넌트는 상기 제2 저장소에 저장된 메시지를 처리하고, 새로 발생하는 메시지는 상기 제1 저장소에 저장되는 것을 특징으로 한다.According to another aspect of the present invention, there is provided a synchronous message-based massively parallel processing system, wherein when a message stored in the first storage is processed, the component processes a message stored in the second storage, And is stored in a storage.

또, 본 발명은 동기적 메시지 기반 대량 병렬처리 시스템에 있어서, 상기 메시지는 사용자의 입력에 의해 발생되거나, 상기 컴포넌트에 의해 발생되는 것을 특징으로 한다.The present invention also relates to a synchronous message-based massively parallel processing system, wherein the message is generated by a user's input or generated by the component.

또, 본 발명은 동기적 메시지 기반 대량 병렬처리 시스템에 있어서, 상기 메시지는 메시지를 생성한 컴포넌트, 발생된 이벤트, 메시지를 수신할 컴포넌트를 포함하는 것을 특징으로 한다.
According to another aspect of the present invention, there is provided a synchronous message-based massively parallel processing system, wherein the message includes a component for generating a message, a generated event, and a component for receiving a message.

상술한 바와 같이, 본 발명에 따른 동기적 메시지 기반 대량 병렬처리 시스템에 의하면, 각각의 컴포넌트들로 작업을 분할하여 다른 작업 등에 영향을 받지 않도록 독립시킴으로써, 동시성 프로그래밍에서 상호배제에 의한 성능저하를 피하고, 다중 코어 환경에서 작업들을 쉽게 분배할 수 있는 효과가 얻어진다.As described above, according to the synchronous message-based massively parallel processing system according to the present invention, by dividing tasks into respective components and isolating them from being influenced by other tasks, performance degradation due to mutual exclusion in synchronous programming is avoided , It is possible to easily distribute tasks in a multi-core environment.

본 발명에 따른 동기적 메시지 기반 대량 병렬처리 시스템에 의하면, 메시지 큐에서의 원자적 연산은 현대의 멀티코어 프로세서에서는 별도의 원자적 연산을 위한 별도의 명령어를 탑재하고 있으므로, 스레드 간에 교착상태(deadlock) 방지를 해결을 위한 상호배제가 없는 프로그래밍이 가능하게 되어, 멀티코어 환경에서의 처리효율이 높아지는 효과가 얻어진다.According to the synchronous message-based massively parallel processing system according to the present invention, since the atomic operation in the message queue includes separate instructions for separate atomic operations in modern multicore processors, deadlocks ), It is possible to perform programming without mutual exclusion for solving the problem that the processing efficiency in the multicore environment is increased.

본 발명에 따른 동기적 메시지 기반 대량 병렬처리 시스템에 의하면, 각각의 작업이 객체 단위로 독립되므로 여러 대의 장비로 분산처리시스템을 구성하기에도 용이하고, 구성후 운영중 시스템에 부하가 많이 걸린다면 새로운 장비를 추가(Scale-Out)할 수 있는 효과가 얻어진다.
According to the synchronous message-based massively parallel processing system according to the present invention, since each task is independent on an object basis, it is easy to construct a distributed processing system with a plurality of equipments, It is possible to add a device (scale-out).

도 1 및 도 2는 종래 기술에 의한 병렬 처리 프로그래밍의 예들이다.
도 3은 본 발명을 실시하기 위한 전체 시스템의 구성을 도시한 도면이다.
도 4 및 도 5는 본 발명의 일실시예에 따라 동기적 메시지 기반 대량 병렬처리 시스템의 구성에 대한 블록도이다.
도 6은 본 발명의 일실시예에 따른 컴포넌트 클래스로부터 속성을 상속받아 컴포넌트를 생성하는 예시이다.
도 7은 본 발명의 일실시예에 따른 메시지의 구조이다.Figures 1 and 2 are examples of parallel processing programming according to the prior art.
3 is a diagram showing a configuration of an overall system for carrying out the present invention.
4 and 5 are block diagrams of a configuration of a synchronous message-based massively parallel processing system according to an embodiment of the present invention.
FIG. 6 is an example of generating a component by inheriting an attribute from a component class according to an embodiment of the present invention.
7 is a structure of a message according to an embodiment of the present invention.

이하, 본 발명의 실시를 위한 구체적인 내용을 도면에 따라서 설명한다.DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Hereinafter, the present invention will be described in detail with reference to the drawings.

또한, 본 발명을 설명하는데 있어서 동일 부분은 동일 부호를 붙이고, 그 반복 설명은 생략한다.
In the description of the present invention, the same parts are denoted by the same reference numerals, and repetitive description thereof will be omitted.

먼저, 본 발명의 일실시예에 따른 동기적 메시지 기반 대량 병렬처리 시스템을 실시하기 위한 전체 시스템의 구성에 대하여 도 3을 참조하여 설명한다.First, a configuration of an overall system for implementing a synchronous message-based massively parallel processing system according to an embodiment of the present invention will be described with reference to FIG.

도 3에서 보는 바와 같이, 본 발명을 실시하기 위한 전체 시스템은 클라이언트(10) 및, 서버(30)로 구성된다. 클라이언트(10) 및 서버(30)는 네트워크(20)를 통해 서로 연결되어 구성된다. 추가적으로, 문서 등 데이터를 저장하기 위한 데이터베이스(40)를 더 포함하여 구성될 수 있다.As shown in FIG. 3, the overall system for implementing the present invention comprises a client 10 and a server 30. The client 10 and the server 30 are connected to each other via the network 20 and configured. In addition, it may further comprise a database 40 for storing data such as a document.

클라이언트(10)는 사용자가 이용하는 PC, 노트북, 넷북, 태블릿PC, PDA, 모바일, 스마트폰 등 통상의 컴퓨팅 단말기이다. 클라이언트(10)는 서버(30)에 특정한 작업을 요청하고, 요청된 결과를 수신한다.The client 10 is a general computing terminal used by a user such as a PC, a notebook, a netbook, a tablet PC, a PDA, a mobile phone, and a smart phone. The client 10 requests the server 30 for a specific job, and receives the requested result.

서버(30)는 통상의 서버로서, 클라이언트(10)로부터 작업을 요청받아, 해당 작업을 처리한다. 또한, 서버(30)는 처리 결과를 클라이언트(10)에 전송한다. 이때, 서버(30)는 클라이언트(10)의 작업 처리를 위해 클라이언트(10)와 세션을 설정하여 유지한다.The server 30 is a normal server, receives a job from the client 10, and processes the job. In addition, the server 30 transmits the processing result to the client 10. At this time, the server 30 establishes and maintains a session with the client 10 for the work process of the client 10.

한편, 다수의 클라이언트(10)가 서버(30)에 동시에 접속하여 다수의 작업을 동시에 요청할 수 있고, 서버(30)는 이와 같이 요청받은 다수의 작업들을 동시에 처리한다.Meanwhile, a plurality of clients 10 simultaneously access the server 30 to request a plurality of jobs at the same time, and the server 30 simultaneously processes the plurality of jobs requested.

즉, 서버(30)는 본 발명에 따른 동기적 메시지 기반 대량 병렬처리 시스템의 기능을 수행한다. 이하에서 서버(30)를 대량 병렬처리 시스템이라 한다.
That is, the server 30 performs the function of the synchronous message-based massively parallel processing system according to the present invention. Hereinafter, the server 30 is referred to as a massively parallel processing system.

다음으로, 본 발명의 일실시예에 따른 동기적 메시지 기반 대량 병렬처리 시스템을 도 4 및 도 5를 참조하여 보다 구체적으로 설명한다.Next, a synchronous message-based massively parallel processing system according to an embodiment of the present invention will be described in more detail with reference to FIGS. 4 and 5. FIG.

도 4 및 도 5에서 보는 바와 같이, 본 발명에 따른 동기적 메시지 기반 대량 병렬처리 시스템(30)은 다수의 객체(112), 및, 메시지 큐(113)로 구성된다. 추가적으로, 클래스 저장부(18)를 더 포함하여 구성될 수 있다.4 and 5, the synchronous message-based massively parallel processing system 30 according to the present invention comprises a plurality of objects 112 and a message queue 113. In addition, it may further comprise a class storage unit 18.

앞서 본 바와 같이, 병렬처리 시스템(30)은 다수의 클라이언트(10)와 연결되어 클라이언트(10)가 요청하는 다수의 작업을 동시에 병렬적으로 처리한다. 이때, 요청하는 작업을 요청 작업이라 부르기로 한다.As described above, the parallel processing system 30 is connected to a plurality of clients 10 and simultaneously processes a plurality of jobs requested by the clients 10 in parallel. At this time, the requested operation is called a request operation.

객체(112)는 상기 요청 작업을 단위 작업으로 나누어 수행한다. 특히, 객체(112)는 상기 단위 작업을 독립적으로 수행하는 컴포넌트(110)로 생성하여 수행시킨다.The object 112 divides the request task into unit tasks. In particular, the object 112 generates and executes the unit job as a component 110 that performs the unit operation independently.

컴포넌트(110)는 어떠한 임의의 기능(또는 임의의 단위 작업)을 수행하기 위한 하나의 모듈이다. 컴포넌트(110)는 해당 기능을 수행하기 위한 데이터들과 매 처리 동작마다 각자의 기능을 처리하는 가상함수(또는 프로세스, Process)로 구성되어있다.The component 110 is a module for performing any arbitrary function (or any unit operation). The component 110 is composed of data for performing a corresponding function and a virtual function (or a process) for processing each function for each processing operation.

클래스 저장부(118)는 컴포넌트 클래스(111)를 별도로 저장해둔다. 도 6에서 보는 바와 같이, 각각의 컴포넌트(110)들은 컴포넌트 클래스 IComponent(111)의 인터페이스 객체를 상속함으로써, 본 시스템에 대한 호환성을 보장받을 수 있다.The class storage unit 118 stores the component class 111 separately. As shown in FIG. 6, each of the components 110 inherits the interface object of the component class IComponent 111, thereby ensuring compatibility with the present system.

객체(112)는 이러한 컴포넌트(110)들을 포함하여 하나의 유기적인 기능을 수행하기 위한 모듈이다. 각각의 객체(112)들은 0개 이상의 컴포넌트(110)와 해당 객체를 정의하기 위한 데이터들로 이루어진다. 컴포넌트(110)들은 시스템이 수행되는 도중에 추가되거나 제거될 수 있다.The object 112 is a module for performing one organic function including these components 110. Each object 112 consists of zero or more components 110 and data for defining the object. The components 110 may be added or removed while the system is running.

컴포넌트(110) 또는 객체(112)는 적어도 2개의 저장소를 가지고, 상기 저장소에 데이터들을 저장한다. 이때, 하나의 저장소가 표시되는 동안은 다른 하나의 저장소는 임시저장을 위한 버퍼로 사용된다.The component 110 or object 112 has at least two repositories and stores the data in the repository. At this time, while one repository is displayed, the other repository is used as a buffer for temporary storage.

메시지 큐(113)는 시스템 외/내부에서 발생하는 다양한 이벤트들에 의해 생성되는 메시지들을 매 처리동작마다 원자적 연산으로 추가한다. 메시지 큐(113)는 2개의 저장소(113a, 113b)를 가지고 있다. 하나의 저장소 113a가 처리되는 동안 다른 하나의 저장소 113b는 입력을 받게 된다. 저장소 113a의 메시지를 모두 처리가 되면, 저장소 113b에 저장된 메시지를 처리하고, 저장소 113a에는 입력을 받게 된다. The message queue 113 adds messages generated by various events occurring outside / inside the system by an atomic operation for each processing operation. The message queue 113 has two storages 113a and 113b. While one storage 113a is being processed, the other storage 113b receives input. When all the messages in the storage 113a are processed, the messages stored in the storage 113b are processed, and the storage 113a receives the input.

즉, 어느 시점에서, 현재 처리되는 메시지들은 어느 하나의 저장소에 저장된 메시지들이고, 이 메시지들이 처리될 때 새로 발생하는 메시지들은 다른 하나의 저장소에 저장된다. 이때, 처리되는 메시지를 저장하는 저장소를 "제1 저장소"라고 하고, 메시지가 입력되는 저장소를 "제2 저장소"라 부르기로 한다.That is, at some point, currently processed messages are messages stored in any one of the repositories, and when these messages are processed, newly generated messages are stored in another repository. At this time, the storage for storing the processed message is referred to as a "first storage ", and the storage for inputting a message is referred to as a" second storage ".

도 7에서 보는 바와 같이, 메시지(114)는 해당 메시지가 생성된 객체(112)의 주소, 발생된 이벤트, 해당 메시지를 수신할 객체 등으로 구성되며, 수신할 객체는 모든 객체 혹은, 특정 컴포넌트일 수 있다.7, the message 114 includes an address of the object 112 in which the message is generated, an event generated, an object to receive the message, and the like. The object to be received may be any object, .

사용자 입력(115)이나 시스템 내 컴포넌트(110)에서 특정한 이벤트가 발생되면 각각의 컴포넌트(110)나 객체(112)의 정보를 변경시키지 않고 해당 이벤트를 메시지(114) 형태로 메시지 큐(113)에 저장한다. 특히 이때 발생된 메시지는 메시지 큐(113)의 제2 저장소에 저장된다.When a specific event occurs in the user input 115 or the in-system component 110, the corresponding event is transmitted to the message queue 113 in the form of a message 114 without changing the information of the respective components 110 and the object 112 . In particular, the message generated at this time is stored in the second storage of the message queue 113.

현재의 정보가 사용자에게 보여지고 있는 동안(메시지가 처리되어 그 결과를 보여주는 동안), 객체(112)는 각 컴포넌트(110)의 프로세스(Process) 함수를 실행시켜 각각의 기능들을 수행한다. 이때 발생하는 메시지(114)는 메시지 큐(113)(또는 제2 저장소)에 전달된다. 각각의 프로세스는 변경되지 않는 상수 값들(현재 데이터)을 참조하여 수행된다. 따라서 수행 순서와 상관없이 결과 값이 보장된다.While the current information is being shown to the user (while the message is being processed and showing the result), the object 112 executes the respective functions of the respective component 110 by executing the process functions. At this time, the generated message 114 is delivered to the message queue 113 (or the second storage). Each process is performed with reference to constant values (current data) that are not changed. Therefore, the result is guaranteed regardless of the order of execution.

각 프로세스(Process)가 수행되는 동안, 메시지 큐(113)를 탐색하며 해당 컴포넌트나 객체에게 영향을 주는 메시지(110)인지 판단한다. 수신객체조건과 일치할 경우 메시지(110) 내용에 따라 각각의 임의의 처리를 수행한다.During each process, the message queue 113 is searched and it is determined whether the message 110 affects the corresponding component or object. And performs the arbitrary processing according to the contents of the message 110 when the condition of the receiving object coincides with the condition of the receiving object.

모든 컴포넌트(110) 및 객체(112)의 처리가 종료되면, 처리가 끝난 메시지 큐(113)(또는 제1 저장소)의 내용을 소거하고, 표시 데이터와 버퍼 데이터의 저장소를 교환한다. 이후 앞서의 동작을 반복적으로 수행하여 시스템 기능이 수행된다. 즉, 제2 저장소가 제1 저장소 역할을 하고, 제1 저장소가 제2 저장소 역할을 한다.When the processing of all the components 110 and the objects 112 ends, the contents of the processed message queue 113 (or the first storage) are erased and the storage of the display data and the buffer data is exchanged. Then, the above operation is repeatedly performed to perform the system function. That is, the second storage serves as a first storage, and the first storage serves as a second storage.

본원발명은 상호배제가 필요한 모듈만 메시지로 처리하는 것이 아니다. 기존의 순차적인 방식으로 프로그램 동작을 구성했을 때는 서로 공통된 부분이나 우선적으로 처리해야할 부분 때문에 임계영역이 발생할 수밖에 없다. 그래서 전체 시스템의 기능들을 다양한 컴포넌트로 나누고, 해당 기능이 필요한 객체에 각 컴포넌트를 등록해서 시스템을 구성한 것이다. 즉, 각각의 데이터를 처리하는 처리 모듈은 각각의 컴포넌트에 정의되어있고, 이러한 컴포넌트들의 기능을 실행하기 위한 인터페이스가 준비된다. 그리고 처리과정에서는 각 컴포넌트를 프로세서들끼리 나누고, 단순하게 해당 인터페이스를 호출하여 처리 프로세스가 동작하는 것이다. The present invention does not process only the modules that need mutual exclusion. When a program operation is configured in an existing sequential manner, a critical region is inevitably generated due to a common portion or a portion to be preferentially processed. Thus, the functions of the whole system are divided into various components, and the system is configured by registering each component in the object requiring the corresponding function. That is, a processing module for processing each data is defined in each component, and an interface for executing functions of these components is prepared. In the process, each component is divided into processors, and the process is called by simply calling the corresponding interface.

다만, 처리나 사용자 입력에 대해서 곧 바로 해당 객체나 컴포넌트의 데이터에 손을 대면 임계영역을 지정할 수밖에 없다. 따라서 이에 대한 처리를 뒤로 미루어서, 메시지형태로 만들어 큐에 저장하는 것이다. 즉, 추가 발생하는 메시지들을 제2 저장소에 별도로 저장하여 당장 처리하지 않고, 제1 저장소의 메시지가 모두 처리된 후 추가 발생한 메시지들이 처리된다. 즉, 큐는 현재 처리과정 중에 발생한 메시지를 저장하는 큐와 앞서 발생한 메시지를 처리중인 큐로 두 가지로 구성되어있는 것이다.
However, if you touch the data of the object or the component immediately about the processing or the user input, you have to specify the critical area. Therefore, we postpone the process for it and make it into a message form and store it in the queue. That is, additional generated messages are separately stored in the second storage and are not immediately processed, and additional generated messages are processed after all the messages in the first storage are processed. In other words, the queue consists of two queues: a queue that stores messages that occur during the current process, and a queue that processes messages that are generated earlier.

이상, 본 발명자에 의해서 이루어진 발명을 상기 실시 예에 따라 구체적으로 설명하였지만, 본 발명은 상기 실시 예에 한정되는 것은 아니고, 그 요지를 이탈하지 않는 범위에서 여러 가지로 변경 가능한 것은 물론이다.
Although the present invention has been described in detail with reference to the above embodiments, it is needless to say that the present invention is not limited to the above-described embodiments, and various modifications may be made without departing from the spirit of the present invention.

10 : 클라이언트 20 : 네트워크
30 : 병렬처리 시스템, 서버 40 : 데이터베이스
110 : 컴포넌트 112 : 객체
113 : 메시지 큐 114 : 메시지
115 : 사용자 단말 118 : 클래스 저장부10: Client 20: Network
30: parallel processing system, server 40: database
110: component 112: object
113: Message Queue 114: Message
115: user terminal 118: class storage unit

Claims (6)

다수의 클라이언트와 연결되어 상기 클라이언트가 요청하는 다수의 작업(이하 요청 작업)을 동시에 병렬적으로 처리하는 동기적 메시지 기반 대량 병렬처리 시스템에 있어서,
상기 요청 작업을 단위 작업으로 나누어 수행하되, 상기 단위 작업을 독립적으로 수행하는 컴포넌트를 생성하여 수행시키는 다수의 객체; 및,
상기 컴포넌트에서 요청하는 메시지들을 수신하여 저장하는 적어도 2개의 저장소로 구성된 메시지 큐를 포함하고,
상기 컴포넌트는 상기 저장소 중 어느 하나(이하 제1 저장소)에 저장된 메시지를 처리하고, 새로 발생되는 메시지를 상기 제1 저장소와 다른 저장소(이하 제2 저장소)에 저장하는 것을 특징으로 하는 동기적 메시지 기반 대량 병렬처리 시스템.
1. A synchronous message-based massively parallel processing system connected to a plurality of clients and concurrently processing a plurality of jobs (hereinafter referred to as requests) requested by the clients,
A plurality of objects to be executed by dividing the request task into unit tasks and generating and executing a component that performs the unit tasks independently; And
And a message queue configured by at least two repositories for receiving and storing the messages requested by the component,
Wherein the component processes a message stored in one of the repositories (hereinafter referred to as a first repository) and stores a newly generated message in a repository (hereinafter referred to as a second repository) different from the first repository Massively parallel processing system.
제1항에 있어서,
상기 컴포넌트는 해당 단위 작업을 수행하기 위한 데이터 및 기능을 처리하는 프로세스로 구성되는 것을 특징으로 하는 동기적 메시지 기반 대량 병렬처리 시스템.
The method according to claim 1,
Wherein the component comprises a process for processing data and functions for performing a corresponding unit operation.
제1항에 있어서,
상기 시스템은, 컴포넌트 클래스를 저장하는 컴포넌트 클래스를 더 포함하고,
상기 컴포넌트는 상기 컴포넌트 클래스로부터 인터페이스 객체를 상속함으로써 생성되는 것을 특징으로 하는 동기적 메시지 기반 대량 병렬처리 시스템.
The method according to claim 1,
The system further comprises a component class for storing a component class,
Wherein the component is created by inheriting an interface object from the component class.
제1항에 있어서,
상기 제1 저장소에 저장된 메시지가 모두 처리되면, 상기 컴포넌트는 상기 제2 저장소에 저장된 메시지를 처리하고, 새로 발생하는 메시지는 상기 제1 저장소에 저장되는 것을 특징으로 하는 동기적 메시지 기반 대량 병렬처리 시스템.
The method according to claim 1,
Characterized in that when a message stored in the first storage is processed, the component processes the message stored in the second storage and the newly generated message is stored in the first storage. .
제1항에 있어서,
상기 메시지는 사용자의 입력에 의해 발생되거나, 상기 컴포넌트에 의해 발생되는 것을 특징으로 하는 동기적 메시지 기반 대량 병렬처리 시스템.
The method according to claim 1,
Wherein the message is generated by a user's input or is generated by the component.
제1항에 있어서,
상기 메시지는 메시지를 생성한 컴포넌트, 발생된 이벤트, 메시지를 수신할 컴포넌트를 포함하는 것을 특징으로 하는 동기적 메시지 기반 대량 병렬처리 시스템.
The method according to claim 1,
Wherein the message comprises a component for generating a message, a generated event, and a component for receiving a message.
KR1020120130456A 2012-11-16 2012-11-16 A concurrent and parallel processing system based on synchronized messages KR101448861B1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
KR1020120130456A KR101448861B1 (en) 2012-11-16 2012-11-16 A concurrent and parallel processing system based on synchronized messages

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
KR1020120130456A KR101448861B1 (en) 2012-11-16 2012-11-16 A concurrent and parallel processing system based on synchronized messages

Publications (2)

Publication Number Publication Date
KR20140063279A true KR20140063279A (en) 2014-05-27
KR101448861B1 KR101448861B1 (en) 2014-10-13

Family

ID=50891324

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020120130456A KR101448861B1 (en) 2012-11-16 2012-11-16 A concurrent and parallel processing system based on synchronized messages

Country Status (1)

Country Link
KR (1) KR101448861B1 (en)

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN106453625A (en) * 2016-11-17 2017-02-22 东软集团股份有限公司 Information synchronization method and high-availability cluster system
KR102460845B1 (en) * 2022-02-28 2022-10-31 (주)성창 Distributed processing-based real-time data change history management system for SCADA implementation

Family Cites Families (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPH07141180A (en) * 1993-11-19 1995-06-02 Oki Electric Ind Co Ltd Parallel execution method for object
KR100378444B1 (en) * 2001-03-14 2003-04-10 지아이에스소프트 주식회사 Server system and method for managing client's demand of the server system

Cited By (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN106453625A (en) * 2016-11-17 2017-02-22 东软集团股份有限公司 Information synchronization method and high-availability cluster system
CN106453625B (en) * 2016-11-17 2019-05-17 东软集团股份有限公司 Information synchronization method and high availability cluster system
KR102460845B1 (en) * 2022-02-28 2022-10-31 (주)성창 Distributed processing-based real-time data change history management system for SCADA implementation

Also Published As

Publication number Publication date
KR101448861B1 (en) 2014-10-13

Similar Documents

Publication Publication Date Title
Tang et al. A MapReduce task scheduling algorithm for deadline constraints
Kulkarni et al. Survey on Hadoop and Introduction to YARN.
Lelli et al. An efficient and scalable implementation of global EDF in Linux
US8776077B2 (en) Method for multithreading an application using partitioning to allocate work to threads
Ma et al. The limitation of MapReduce: A probing case and a lightweight solution
US11269692B2 (en) Efficient sequencer for multiple concurrently-executing threads of execution
JP2012160014A (en) Data analysis and machine learning processing unit, method, and program
Liang et al. Accelerating iterative big data computing through MPI
Miceli et al. Programming abstractions for data intensive computing on clouds and grids
Yang et al. PK-OMLP: An OMLP based k-exclusion real-time locking protocol for multi-GPU sharing under partitioned scheduling
US20170371713A1 (en) Intelligent resource management system
US20150160973A1 (en) Domain based resource isolation in multi-core systems
KR101448861B1 (en) A concurrent and parallel processing system based on synchronized messages
Yankovitch et al. Hypersonic: A hybrid parallelization approach for scalable complex event processing
Shrivastava et al. Supporting transaction predictability in replicated DRTDBS
Tiwari et al. Modeling and analyzing key performance factors of shared memory mapreduce
Sadooghi et al. Albatross: An efficient cloud-enabled task scheduling and execution framework using distributed message queues
Liu et al. BSPCloud: A hybrid distributed-memory and shared-memory programming model
Lusk et al. Asynchronous dynamic load balancing
Son et al. Parallel Job Processing Technique for Real-time Big-Data Processing Framework
Perarnau et al. Argo
US20130166887A1 (en) Data processing apparatus and data processing method
Kovoor et al. Building a Java mapreduce framework for multi-core architectures
Shah et al. Performance analysis of scheduling algorithms in Apache Hadoop
Mühe et al. The mainframe strikes back: elastic multi-tenancy using main memory database systems on a many-core server

Legal Events

Date Code Title Description
A201 Request for examination
E902 Notification of reason for refusal
E701 Decision to grant or registration of patent right
GRNT Written decision to grant
FPAY Annual fee payment

Payment date: 20170908

Year of fee payment: 4

FPAY Annual fee payment

Payment date: 20180921

Year of fee payment: 5

FPAY Annual fee payment

Payment date: 20190906

Year of fee payment: 6