KR20150137369A - Data processing apparatus and data check method stored in a memory of the data processing apparatus - Google Patents

Data processing apparatus and data check method stored in a memory of the data processing apparatus Download PDF

Info

Publication number
KR20150137369A
KR20150137369A KR1020140065111A KR20140065111A KR20150137369A KR 20150137369 A KR20150137369 A KR 20150137369A KR 1020140065111 A KR1020140065111 A KR 1020140065111A KR 20140065111 A KR20140065111 A KR 20140065111A KR 20150137369 A KR20150137369 A KR 20150137369A
Authority
KR
South Korea
Prior art keywords
message
memory
data
memory read
engine
Prior art date
Application number
KR1020140065111A
Other languages
Korean (ko)
Other versions
KR101968501B1 (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 KR1020140065111A priority Critical patent/KR101968501B1/en
Priority to PCT/KR2015/005368 priority patent/WO2015183016A1/en
Publication of KR20150137369A publication Critical patent/KR20150137369A/en
Application granted granted Critical
Publication of KR101968501B1 publication Critical patent/KR101968501B1/en

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00—Accessing, addressing or allocating within memory systems or architectures

Abstract

Provided is a method for processing requests of real-time confirmation on data of a memory in a data processing apparatus by using conventional systems for accepting and processing an engine application program interface (API) message. The data confirmation method according to an embodiment of the present invention comprises the following steps: receiving a memory read message; inserting the memory read message into a message queue into which the engine API message is inserted; performing logic corresponding to the engine API message when the engine API message is extracted from the message queue, and applying the result to data objects recorded in the memory; and reading at least a part of the data objects in the memory when the memory read message is extracted from the message queue, and providing the read data.

Description

BACKGROUND OF THE INVENTION 1. Field of the Invention [0001] The present invention relates to a data processing apparatus and a data processing apparatus,

The present invention relates to a data processing apparatus and a method for confirming data recorded in a memory of a data processing apparatus. More particularly, the present invention relates to a data processing apparatus for loading a data object into a memory and updating the data object in the memory, the method comprising: a method for verifying data contained in a data object on a memory; .

In a data processing apparatus in which a software engine for performing a specific function and managing the result as a data object is provided, the data object can be stored in the form of a database. However, if the software engine loads the data object from the database each time it performs a specific logic, and then updates the value and reflects the updated value in the database, the software engine is difficult to process a large number of requests.

In accordance with this technical need, a memory-based software engine is provided that places data objects on a fast I / O memory and manages the data objects on the memory. The memory based software engine can be provided with a large number of inquiry requests or logic execution requests in a short time, and the memory based software engine provides the processing results at a high speed for the provided requests.

However, in such a memory-based software engine, there is not provided a method for checking what data is set in a data object in a memory and whether the integrity of the data is maintained. Even if the data written in the memory is accessed by directly accessing the data object on the memory, it is not possible to exclude the possibility that the memory-based software engine has performed the data update according to the logic execution request. For example, when it is desired to check data on a specific subject of a data object at the current time, some value of the data to be checked can be updated by the software engine at the moment of reading the data to be checked, The integrity of the data will be destroyed.

Korean Patent Publication No. 2009-0045528 Korean Patent Publication No. 2007-0003454

According to an aspect of the present invention, there is provided a system and method for configuring a data object on a memory, receiving an engine API (Application Program Interface) message, performing software logic corresponding to the provided engine API message, There is provided a data processing apparatus for managing a data object on a memory, the data processing apparatus including a method for processing a real-time confirmation request for data on a memory and a data processing apparatus to which the method is applied.

Another object of the present invention is to provide a method of processing a request for real-time confirmation of data on a memory using a reception and processing scheme of an existing engine API message in a data processing apparatus and a data processing method Device.

The technical objects of the present invention are not limited to the above-mentioned technical problems, and other technical subjects not mentioned can be clearly understood by those skilled in the art from the following description.

According to another aspect of the present invention, there is provided a data checking method including receiving a memory read message, inserting the memory read message into a message queue in which an engine API (Application Program Interface) Performing logic corresponding to the engine API message when the engine API message is extracted from the message queue and applying the result to the data object recorded in the memory; Reading at least some of the data objects in the memory and providing the read data when the data is extracted.

According to some embodiments, the memory read message and the engine API message may be composed of text by the same expression method.

According to some embodiments, the data checking method may further include extracting a next message from the message queue after processing of the message extracted from the queue is completed.

According to some embodiments, the method may further include loading the data object from the database into the memory prior to performing the logic corresponding to the engine API message.

According to some embodiments, the data object may be managed by a planning engine operating in conjunction with an ERP (Enterprise Resource Planning) system. The planning engine may be, for example, an order promising engine, an allocation engine, a master planning, or a factory planning engine.

According to another aspect of the present invention, there is provided a data processing apparatus including a memory and a memory read message, a message queue manager for inserting the received memory read message into a message queue inserted with an engine API message, An engine function executing unit for executing logic corresponding to the engine API message when the engine API message is extracted from the message queue and applying the result of execution of the logic to the data object recorded in the memory, And a memory lead function performing unit for reading at least some of the data objects in the memory and providing the read data when the read message is extracted.

According to the present invention, before the order information is provided to the delivery schedule appointment apparatus, the information (ATP, Allocation) for making the delivery appointment can be adjusted and confirmed in a systemized manner.

Further, in adjusting the information (ATP, Allocation) for the delivery time commitment, various adjustment rules can be supported.

BRIEF DESCRIPTION OF DRAWINGS FIG. 1 is a conceptual diagram for explaining embodiments of the present invention; FIG.
2 is a flowchart of a data checking method according to an embodiment of the present invention.
3 is a flowchart of a data checking method according to another embodiment of the present invention.
4 is a detailed flowchart of some operations of the data checking method shown in FIG.
5A and 5B are diagrams showing virtual memory lead messages and engine API messages converted from objects, which are provided from an external device or an input device according to embodiments of the present invention.
5C is a diagram illustrating a virtual response message for a virtual memory read message according to embodiments of the present invention.
6 is a flowchart of a data checking method according to another embodiment of the present invention.
7 is a flowchart of a data checking method according to another embodiment of the present invention.
8 is a block diagram of a data processing apparatus according to another embodiment of the present invention.
9 is a hardware configuration diagram of a data processing apparatus according to another embodiment of the present invention.
10 is a configuration diagram of a data processing system according to another embodiment of the present invention.
11 is a configuration diagram of a data processing system according to another embodiment of the present invention.

Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings. BRIEF DESCRIPTION OF THE DRAWINGS The advantages and features of the present invention and the manner of achieving them will become apparent with reference to the embodiments described in detail below with reference to the accompanying drawings. The present invention may, however, be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the invention to those skilled in the art. Is provided to fully convey the scope of the invention to those skilled in the art, and the invention is only defined by the scope of the claims. Like reference numerals refer to like elements throughout the specification.

Unless defined otherwise, all terms (including technical and scientific terms) used herein may be used in a sense commonly understood by one of ordinary skill in the art to which this invention belongs. Also, commonly used predefined terms are not ideally or excessively interpreted unless explicitly defined otherwise. The terminology used herein is for the purpose of illustrating embodiments and is not intended to be limiting of the present invention. In the present specification, the singular form includes plural forms unless otherwise specified in the specification. It is noted that the terms "comprises" and / or "comprising" used in the specification are intended to be inclusive in a manner similar to the components, steps, operations, and / Or additions.

In this specification, a logic or a routine refers to a series of instructions that can be executed by a processor, and is not limited to being written by a specific programming language.

First, embodiments of the present invention will be described with reference to FIG.

According to embodiments of the present invention, a message queue (10) is provided in which an engine API message provided from an external device via a network or provided from an input device is inserted. As is widely known, a queue is a data structure in which input and output are performed in a FIFO (First In First Out) manner. Therefore, the messages inserted into the message queue 10 are processed on a first-come-first-served basis. The message queue 10 may be configured in various ways such as an array, a linked list, and a circular queue.

When the engine API message is extracted from the message queue 10, the logic 30 corresponding to the engine API message is performed. At this time, a message parser (not shown) may be further provided to parse the engine API message to determine the logic 30 corresponding to the engine API message. The API correspondence logic 30 queries some data from the data object 22 written to the memory 20 or updates some data of the data object 22 written to the memory 20 to achieve a predetermined purpose can do. After the API correspondence logic 30 completes its operation, the next message is extracted from the message queue 10 and processed.

The memory 20 is connected to a processor (not shown) to provide instructions to the processor, and temporarily stores data output from the processor. The memory 20 may be composed of, for example, RAM (Random Access Memory), but the memory referred to in the present invention is not limited to the RAM.

According to one embodiment, not only the engine API message but also a memory lead message provided from the external device via the network or provided from the input device is also inserted into the message queue 10.

According to one embodiment, the memory read message may be composed of text in the same manner as the engine API message. Accordingly, the memory read message can be parsed using a message parser that parses an existing engine API message.

According to one embodiment, both the memory read message and the engine API message may include a type item indicating a type of a message. For example, in the memory read message, a data designation ID indicating data in a data object to be confirmed in the type item may be set in the type item. In addition, a logic ID indicating the corresponding logic to be performed in the engine API message may be set in the type field. It is preferable that the logic ID and the data designation ID are DEFINE so that they have different values in different ranges of values. For example, you can DEFINE as follows:

Figure pat00001

Table 1 is an example of a symbol DEFINE code that can be used in a data checking method according to embodiments of the present invention and a data processing apparatus to which the method is applied. As shown in Table 1, it is preferable that the data designation ID is designated in a different range so as not to overlap with the existing logic IDs (API_A to API_F).

When a message is extracted from the message queue 10, it can be confirmed whether the message is a memory read message or an engine API message using the value of the type item included in the message. If the extracted message is an engine API message, the corresponding API logic 30 will be executed, and if the extracted message is a memory read message, the corresponding memory lead logic 40 will be executed.

In the message queue 10, only when the execution of the logic corresponding to the previously extracted message is completed, the following message is extracted. For example, when the API_D, API_E, API_F, MEMORY_CHECK_B, and API_A shown in Table 1 are sequentially input to the message queue 10, the MEMORY_CHECK_B message is stored in the memory 20 after API_D, API_E, Thereby causing some of the data of the data object 22 to be output. The data output by the MEMORY_CHECK_B message allows the status of the data object 22 to be confirmed after the execution of API_D, API_E, and API_F is completed. The data output by the MEMORY_CHECK_B message is data that is not affected by the execution of API_A. That is, according to the embodiments of the present invention, when the engine API message is executed according to a series of steps, there is an effect that the state of the data object 22 at a specific time point can be accurately confirmed in a state in which the data consistency is maintained.

On the other hand, when the memory 20 is constituted by a RAM, data stored at the same time as the power supply-OFF is deleted. Accordingly, the data object 22 recorded and configured in the memory 20 can be LOADed from the database 50 and EXPORTed to the database 50. The data object 22 recorded in the memory 20 may be periodically exported to the database 50 or may be performed upon occurrence of a specific event.

A data checking method according to an embodiment of the present invention will be described with reference to FIG. The data checking method according to the present embodiment can be executed by a data processing apparatus in which a planning engine connected to, for example, an ERP (Enterprise Resource Planning) system is executed, but the subject of execution is not limited. The planning engine may include an order promising engine that accepts orders and provides delivery information for the orders, for example, an ATP quantity of a root node in a hierarchically structured seller network, A master planning for establishing an overall production plan for each bucket which is a time management unit by using an allocation number allocation engine for distributing the nodes to the nodes, order information and resource holding information, It can be one of the factory planning engines that establish the star production plan.

Receives the engine API message (S100), and inserts the provided engine API message into the message queue (S102). The memory read message is received (S104), and the received memory reload message is inserted into the message queue (S106). 2, the order in which the engine API message and the memory read message are provided may be mutually exchanged. However, note that the message queue in which the memory read message is inserted and the message queue in which the engine API message is inserted are the same.

Meanwhile, when the memory read message is received from the terminal, the memory read message can be inserted into the message queue only when the terminal that transmitted the memory read message is registered with the terminal having the memory read right. That is, a terminal capable of real-time confirmation of data recorded in a memory through a memory read message can be limited to terminals registered in advance.

One message is extracted from the message queue (S108). Extracting a message from a message queue means outputting a message recorded in an extraction position slot of a message queue, deleting the output message from the extraction position slot, and moving a pointer indicating the extraction position slot.

The extracted message can be parsed by the message parser. As described above, according to the embodiment, since the engine API message and the memory read message are composed of texts according to the same expression method, even if the extracted message is a memory read message, the engine API message message parser can be used as it is . In addition, since the memory read message and the engine API message include a type item indicating the type of the message, a message extracted based on the data set in the type item of the extracted message is included in the engine API message and the memory lead message (S110).

When the extracted message is a memory read message, determines the data to be identified in the data object indicated by the data designation ID written in the type item and the additional information included in the memory read message, reads the verification target data from the memory , And formats the read data as output data (S112). In order to prevent a data object written to the memory from being damaged due to the memory read message, it is preferable that the logic performed by the memory read message does not perform any write (WRITE) command to the memory.

If the extracted message is an engine API message, logic corresponding to the logic ID described in the type item is performed (S116). At this time, at least a part of the additional information included in the engine API message may be used as an input parameter for the logic.

The next message is extracted from the message queue after the processing for the previously extracted message is completed (S114, S118).

A data checking method according to another embodiment of the present invention will be described with reference to FIG. According to the present embodiment, as shown in FIG. 3, an operation of receiving a message (S200) and inserting it into a message queue (S202) and an operation of extracting a message from a message queue and performing a corresponding process are executed in different threads thread. According to the present embodiment, message reception and insertion into a message queue, and message extraction and processing in a message queue can be simultaneously performed in parallel.

The present embodiment can be modified such that an operation of receiving a message and inserting it into a message queue and extracting a message from a message queue to perform corresponding processing are performed by different processes.

If the message queue is not empty (S300), the thread for extracting and processing the message in the message queue extracts one message (S302), and the type of the message is checked through parsing of the extracted message (S304) . As described above, if the extracted message is a memory read message (S206), the data to be checked is read from the memory, the read data is formatted as output data, and the output data is provided (S310). If the extracted message is an engine API message, the logic corresponding to the logic ID described in the type item is performed, and the logic execution result is applied to the data object of the memory (S308).

Hereinafter, the operation of checking the message type (S304) through parsing of the extracted message will be described in detail with reference to FIG. As already mentioned, the engine API message and the memory read message may be text represented by the same representation.

For example, the engine API message and the memory read message may all be text represented by a JavaScript Object Notation (JSON) expression. For JSON expressions, see the web site "http://www.json.org/". The text based on JSON can be converted into an object using the EVAL () function of JavaScript (S304a). FIG. 5A is a representation (60) after the JSON format text of the engine API message is converted into an object, and FIG. 5B is a representation (70) after the JSON format text of the memory read message is converted into an object.

As mentioned above, both the engine API message and the memory read message can have a type entry. In FIGS. 5A and 5B, the expression "API_type" is a string indicating a type item. Once objectized, API_type can be easily accessed through JavaScript code (for example, "obj_name.API_type"). By checking the API_type of the objectized message, it can be determined whether the message is an engine API message or a memory read message (S304b).

According to another embodiment, both the engine API message and the memory read message may be text represented by XML (eXtensible Markup Language) expression.

On the other hand, when the memory read message converted into the object is processed as shown in FIG. 5B, the verification target data of the data object recorded in the memory is read in real time, and the read data is processed into the output format.

5C is an example of an output format. For example, during the operation of the planning engine, a request is received that the data output from the planning engine is abnormal, or a plurality of engine API messages are virtually input during the stabilization of the planning engine, If an error is found in the data, the output format as shown in FIG. 5C may be useful in order to determine whether there is a problem with the planning engine itself. The data included in the output format shown in FIG. 5C shows the data recorded in the memory at the time when the memory read message is performed (the time extracted from the message queue).

A data checking method according to another embodiment of the present invention will be described with reference to FIG. The data checking method according to the present embodiment can be utilized in performing an initial stabilization operation before starting a formal service using a data processing system in which a software engine performing a predetermined function is performed.

When the test for the software engine is started (S400), the test person inputs a plurality of engine API messages to the software engine in order to test whether the engine is operating normally (S402). The test manager checks whether the response of the software engine based on the plurality of engine API messages is normal (S404).

If it is confirmed that there is an error in the response, the test person can input the memory read message together with the plurality of engine API messages (S404). For example, if it is determined that the final response of the software is abnormal when the API_D, API_E, API_F, and API_A are successively executed, the change of the data object recorded in the memory after the execution of each engine API is checked by the STEP BY STEP The test person can sequentially input the API_D, the memory read message, the API_E, the memory read message, the API_F, the memory read message, the API_A, and the memory read message.

On the other hand, the logic for processing the memory read message will be unnecessary during actual service. Accordingly, the logic for processing the memory read message may be deactivated in various ways (S406) to avoid unnecessary slowdowns in the performance at the end of the test. For example, in a series of codes that perform matching routines based on the type of message extracted from the message queue, if the type of the message corresponds to a memory read message, a series of code that performs the matched routine is commented Lt; / RTI > After the engine test is finished, the formal service will be started (S408).

A data checking method according to another embodiment of the present invention will be described with reference to FIG.

First, data is loaded into the memory from the database (S500), and a data object is constructed on the memory (S502). For example, when this embodiment is performed by a delivery-by-delivery appointment software engine, data on order receipt and delivery appointment status for each merchant node recorded in the database may be loaded into the memory from the database.

When the engine API message is input (S504), a routine corresponding to the input engine API message is executed (S506). In this case, the routine performs a predetermined purpose using only the data object in the memory, without I / O to the database, and applies the result directly to the data object in operation S508. Thus, the data object on the memory is always updated with the latest value.

When the memory read message is input (S510), the verification target data corresponding to the input memory read message is determined, and then the verification target data is read from the memory (S512). The read data is provided by processing into an output format (S514). For example, when the memory read message is received from a terminal connected to a network through a data processing apparatus performing a data checking method according to the present embodiment, the read data is processed into an output format and provided to the terminal. When the memory read message is directly input to the data processing apparatus in which the data checking method according to the present embodiment is performed, the read data is processed into an output format and displayed on an output device (for example, a monitor device).

The data object recorded and configured in the memory may be EXPORTed to the database again (S516). The EXPORT may be performed periodically, or may be performed upon occurrence of a specific event.

The configuration and operation of the data processing apparatus according to another embodiment of the present invention will be described with reference to FIG. The data processing apparatus 600 according to the present embodiment may be a computing device. For example, the data processing apparatus 600 may be a computing device that executes a software engine that performs certain functions. 8, the data processing apparatus 600 may include a memory 602, a message queue management unit 604, an engine function execution unit 610, and a memory lead function execution unit 612.

The memory 602 is connected to a processor (not shown) and provides a command to the processor. The memory 602 may be a RAM, for example. In the memory 602, a data object 622 is recorded, and a message queue 620 is also recorded.

The message queue management unit 604 receives the memory read message and the engine API message, and inserts the memory read message into the message queue into which the engine API message is inserted. That is, the message queue management unit 604 inserts both the engine API message and the memory read message into the message queue 620. The message queue manager 604 extracts the messages one by one from the message queue 620 and provides them to the message parser 608. [ The time at which the message queue management unit 604 extracts the message from the message queue 620 is a time point at which the processing of the engine function performing unit 610 or the message read function executing unit 612 for the immediately extracted message ends .

The message parser 608 extracts a message from the message queue 620 and determines whether the extracted message is an engine API message or a memory read message based on the data set in the type item of the extracted message. The message parser 608 delivers the extracted message to one of the engine function execution unit 610 and the memory lead function execution unit 612 according to the determination result. If the message written to the message queue is composed of text by JSON representation, the message parser 608 may convert the JSON text into an object and then determine whether the extracted message is an engine API message or a memory read message have.

When the engine API message is extracted from the message queue 620, the engine function execution unit 610 performs logic corresponding to the engine API message and outputs the execution result of the logic to the data object 622 ).

The memory read function execution unit 612 reads at least a part of the data object 622 in the memory 602 and outputs the read data to the interface unit 606 when a memory read message is extracted from the message queue 620 to provide. As already mentioned, the memory lead function executing section 612 can be activated only when the data processing apparatus 600 operates in the debugging mode or the test mode. For example, if the type of a message corresponds to a memory read message in a series of codes that perform a matching routine according to a type of a message extracted from a message queue, the memory read function performing unit 612 performs a matching Can be deactivated by annotating a series of code that performs the routine.

The interface unit 606 receives the memory read message and the engine API message from the network or the input device, and provides the memory read message and the engine API message to the message queue management unit 604. [ The interface unit 606 receives the data processed in the output format from the message read function execution unit 612 and transmits the processed data to the external device through the network or outputs the same output as the display device through the system bus Device.

Each component in FIG. 8 may refer to software or hardware such as a field-programmable gate array (FPGA) or an application-specific integrated circuit (ASIC). However, the components are not limited to software or hardware, and may be configured to be in an addressable storage medium and configured to execute one or more processors. The functions provided in the components may be implemented by a more detailed component or may be implemented by a single component that performs a specific function by combining a plurality of components.

9 is a hardware configuration diagram of a data processing apparatus according to another embodiment of the present invention. 9, the data processing apparatus according to the present embodiment includes a system bus 706, a processor 702, a RAM (Random Access Memory) 704, a storage 708 and communication with an external device or an input / And an interface unit 710 for connection of the interface unit 710. Computer program code for implementing the data validation method in accordance with the present invention may be stored in storage 708, loaded into RAM 704, and executed by processor 702. [ As a result of executing the computer program code, a data object may be recorded in the RAM 704, and a message queue may be recorded.

10 is a configuration diagram of a data processing system according to another embodiment of the present invention. The data processing system according to the present embodiment may include the data processing apparatus 600, the input apparatus 630, and the output apparatus 640 described with reference to FIG. For example, the input device 630 may be a touch screen, a keyboard, a mouse, or a stylus pen, and the output device 640 may be any one of a monitor, a TV, a projector, and a hologram output device.

The input device 630 generates an input signal according to the input of the user and provides the input signal to the data processing device 600. The input signal may be converted into either the engine API message or the memory read message by the data processing device 600. The output device 640 may display a response output to the memory read message.

11 is a configuration diagram of a data processing system according to another embodiment of the present invention. The data processing system according to the present embodiment may include the data processing apparatus 600 and the terminal 650 described with reference to FIG. The terminal 650 may be a computing device having a network connection function, for example, a notebook PC, a desktop PC, a tablet PC, a smart phone, or a set-top box.

The terminal 650 transmits the engine API message and the memory read message to the data processing apparatus 600 via the network. In response to the input of the memory read message, the terminal 650 may receive the output data including the data to be checked on the memory corresponding to the memory read message from the data processing apparatus 600. [

The terminal 650 can perform the registration procedure for the data processing apparatus 600 so that the terminal 650 can confirm the data recorded in the memory in real time through the memory read message.

The concepts of the present invention described above with reference to Figures 1-11 can be implemented in computer readable code on a computer readable medium. The computer readable recording medium may be, for example, a removable recording medium (CD, DVD, Blu-ray disk, USB storage device, removable hard disk) . The computer program recorded on the computer-readable recording medium may be transmitted to another computing device via a network such as the Internet and installed in the other computing device, thereby being used in the other computing device.

While the present invention has been described in connection with what is presently considered to be practical exemplary embodiments, it is to be understood that the invention is not limited to the disclosed embodiments, but, on the contrary, You will understand. It is therefore to be understood that the above-described embodiments are illustrative in all aspects and not restrictive.

Claims (12)

Receiving a memory read message;
Inserting the memory read message into a message queue into which an engine API (Application Program Interface) message is inserted;
When the engine API message is extracted from the message queue, performing logic corresponding to the engine API message and applying the result to a data object recorded in the memory; And
Reading at least a portion of the data objects in the memory and providing the read data when a memory read message is extracted from the message queue.
How to check data. The method according to claim 1,
Wherein the memory read message and the engine API message are composed of texts according to the same expression,
How to check data. 3. The method of claim 2,
Wherein the memory read message and the engine API message include a type item indicating a type of a message,
Further comprising: extracting a message from the message queue and determining whether the extracted message is an engine API message or a memory read message based on data set in the type item of the extracted message.
How to check data. 3. The method of claim 2,
Wherein the memory read message and the engine API message are composed of text by a JavaScript Object Notation (JSON)
How to check data. The method according to claim 1,
Further comprising extracting a next message from the message queue after processing for the message extracted from the queue is completed.
How to check data. The method according to claim 1,
Further comprising loading the data object from the database into the memory prior to performing logic corresponding to the engine API message.
How to check data. The method according to claim 1,
Wherein the step of receiving the memory read message comprises:
And receiving the memory read message from the terminal,
Wherein the step of inserting into the message queue comprises:
And inserting the memory read message into the message queue only when the terminal transmitting the memory read message is registered as a memory readable terminal.
How to check data. The method according to claim 1,
Wherein the data object is managed by an order promising engine.
How to check data. A computer-readable recording medium storing a computer program for performing the method of any one of claims 1 to 8. Memory;
A message queue manager for receiving a memory read message and inserting the provided memory read message into a message queue into which an engine API message is inserted;
An engine function execution unit that executes logic corresponding to the engine API message when the engine API message is extracted from the message queue and applies the result of execution of the logic to a data object recorded in the memory; And
And a memory lead function performing unit for reading at least a part of the data objects from the memory and providing the read data when a memory read message is extracted from the message queue.
Data processing device. 11. The method of claim 10,
Wherein the memory lead function performing unit is activated only when the data processing apparatus is operated in the debugging mode,
Data processing device. 11. The method of claim 10,
Wherein the memory read message and the engine API message are composed of the same message format including a type item indicating a message type,
Extracting a message from the message queue, determining whether the extracted message is an engine API message or a memory read message based on the data set in the type item of the extracted message, Further comprising a message parser for delivering the extracted message to one of the memory lead function performing units,
Data processing device.
KR1020140065111A 2014-05-29 2014-05-29 Data processing apparatus and data check method stored in a memory of the data processing apparatus KR101968501B1 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
KR1020140065111A KR101968501B1 (en) 2014-05-29 2014-05-29 Data processing apparatus and data check method stored in a memory of the data processing apparatus
PCT/KR2015/005368 WO2015183016A1 (en) 2014-05-29 2015-05-28 Data processing device and method for checking data recorded on memory of data processing device

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
KR1020140065111A KR101968501B1 (en) 2014-05-29 2014-05-29 Data processing apparatus and data check method stored in a memory of the data processing apparatus

Publications (2)

Publication Number Publication Date
KR20150137369A true KR20150137369A (en) 2015-12-09
KR101968501B1 KR101968501B1 (en) 2019-04-15

Family

ID=54699278

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020140065111A KR101968501B1 (en) 2014-05-29 2014-05-29 Data processing apparatus and data check method stored in a memory of the data processing apparatus

Country Status (2)

Country Link
KR (1) KR101968501B1 (en)
WO (1) WO2015183016A1 (en)

Families Citing this family (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN108279988B (en) * 2018-01-25 2021-07-23 微梦创科网络科技（中国）有限公司 Message processing method and system based on Lua script language
CN112348713A (en) * 2020-09-25 2021-02-09 贝壳技术有限公司 QLRunner-based data processing method, device, electronic equipment and medium

Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2003071435A1 (en) * 2002-02-15 2003-08-28 Proquent Systems Corporation Management of message queues
US20050055701A1 (en) * 2000-10-30 2005-03-10 Microsoft Corporation Method and apparatus for providing and integrating high-performance message queues in a user interface environment
KR20070003454A (en) 2005-07-02 2007-01-05 엘지전자 주식회사 Method and system for dumping flash memory of embedded system
US20070083569A1 (en) * 2005-10-07 2007-04-12 Lik Wong Commit-time ordered message queue supporting arbitrary read and dequeue patterns from multiple subscribers
US20090024808A1 (en) * 2004-10-21 2009-01-22 International Business Machines Corporation Memory controller and method for optimized read/modify/write performance
KR20090045528A (en) 2007-11-02 2009-05-08 경북대학교 산학협력단 Debugging terminal with a real-time debugging function for a large scale real-time monitoring system, and debugging system with the same

Family Cites Families (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5900020A (en) * 1996-06-27 1999-05-04 Sequent Computer Systems, Inc. Method and apparatus for maintaining an order of write operations by processors in a multiprocessor computer to maintain memory consistency
US6614709B2 (en) * 2001-03-09 2003-09-02 Intel Corporation Method and apparatus for processing commands in a queue coupled to a system or memory
US7549021B2 (en) * 2006-02-22 2009-06-16 Seagate Technology Llc Enhanced data integrity using parallel volatile and non-volatile transfer buffers
GB2469299B (en) * 2009-04-07 2011-02-16 Imagination Tech Ltd Ensuring consistency between a data cache and a main memory

Patent Citations (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20050055701A1 (en) * 2000-10-30 2005-03-10 Microsoft Corporation Method and apparatus for providing and integrating high-performance message queues in a user interface environment
WO2003071435A1 (en) * 2002-02-15 2003-08-28 Proquent Systems Corporation Management of message queues
US20090024808A1 (en) * 2004-10-21 2009-01-22 International Business Machines Corporation Memory controller and method for optimized read/modify/write performance
KR20070003454A (en) 2005-07-02 2007-01-05 엘지전자 주식회사 Method and system for dumping flash memory of embedded system
US20070083569A1 (en) * 2005-10-07 2007-04-12 Lik Wong Commit-time ordered message queue supporting arbitrary read and dequeue patterns from multiple subscribers
KR20090045528A (en) 2007-11-02 2009-05-08 경북대학교 산학협력단 Debugging terminal with a real-time debugging function for a large scale real-time monitoring system, and debugging system with the same

Also Published As

Publication number Publication date
WO2015183016A1 (en) 2015-12-03
KR101968501B1 (en) 2019-04-15

Similar Documents

Publication Publication Date Title
CN108897691B (en) Data processing method, device, server and medium based on interface simulation service
US10942842B2 (en) Model integration tool
US8745641B1 (en) Automatic verification and anomaly detection in a representational state transfer (REST) application programming interface
US8676627B2 (en) Vertical process merging by reconstruction of equivalent models and hierarchical process merging
CN108958959B (en) Method and device for detecting hive data table
US8560543B2 (en) Configuration item reconciliation
WO2023088469A1 (en) Device management method and apparatus, and electronic device, storage medium and program product
KR101968501B1 (en) Data processing apparatus and data check method stored in a memory of the data processing apparatus
US20180123899A1 (en) Technology agnostic network simulation
US20180123900A1 (en) Scenario driven, technology agnostic network simulation
CN111107133A (en) Generation method of difference packet, data updating method, device and storage medium
US20190220549A1 (en) Analysis model preparing system, programming apparatus, and analysis model preparing method
CN112559525B (en) Data checking system, method, device and server
US9064042B2 (en) Instrumenting computer program code by merging template and target code methods
US9104573B1 (en) Providing relevant diagnostic information using ontology rules
US20230086564A1 (en) System and method for automatic discovery of candidate application programming interfaces and dependencies to be published
EP3999917B1 (en) Method and system for generating a digital representation of asset information in a cloud computing environment
CN114218313A (en) Data management method, device, electronic equipment, storage medium and product
CN113094041A (en) Component management method and device of application program and computer equipment
CN112800194A (en) Interface change identification method, device, equipment and storage medium
CN113626409B (en) Test data processing method, device, equipment and storage medium
CN112579428A (en) Interface testing method and device, electronic equipment and storage medium
CN116755684B (en) OAS Schema generation method, device, equipment and medium
CN116028138B (en) Application publishing method and device
US20220237021A1 (en) Systems and methods of telemetry diagnostics

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