Graph processing system including different kind memory device and an operation method thereof
The graph processing system combines non-volatile and volatile memory devices to optimize data storage and computational efficiency, addressing performance degradation and checkpoint latency issues in GPGPU systems.
Patent Information
- Application Number
- KR1020190104278
- Authority / Receiving Office
- KR · KR
- Patent Type
- Patents
- Current Assignee / Owner
- Filing Date
- 2019-08-26
- Publication Date
- 2026-11-11
- Estimated Expiration
- 2039-08-26
AI Technical Summary
Existing graph processing systems using GPGPU face performance degradation due to frequent page swaps and data copying between volatile memory devices, and checkpoint operations to disk or flash-based storage are time-consuming, leading to inefficient computational performance.
A graph processing system utilizing a combination of a non-volatile memory device for storing graph data and a volatile memory device for dynamic vertex values, enabling efficient iterative operations and rapid checkpointing through overlapping storage and operation steps.
This approach enables effective storage and rapid execution of repetitive graph operations by leveraging memory devices with different characteristics, reducing data transfer overhead and improving computational efficiency.
Smart Images

Figure R1020190104278_ABST
Abstract
Description
Technology Field
[0001] The present invention relates to a graph processing system, and more specifically, to a graph processing system including a heterogeneous memory device and a method of operating the graph processing system. Background Technology
[0002] With the advent of the Big Data era, graph-based data structures designed to efficiently represent and analyze relationships between data are playing a crucial role in machine learning and various data analyses. Consequently, various graph algorithms are being used as key applications in the data centers of companies such as Google and Facebook.
[0003] For example, Google's PageRank (Reference 1: Rogers, Ian. "The Google Pagerank algorithm and how it works.", 2002.) and Twitter's connected components algorithm [Reference 2: Ediger, David, Karl Jiang, Jason Riedy, David A. Bader, and Courtney Corley. "Massive social network analysis: Mining twitter for social good" In ICPP, 2010.] are representative graph-based data analysis applications.
[0004] In order to satisfy the high computational load required by graph applications, systems utilizing GPGPU (General Purpose Graphing Processing Unit) are used in many computational domains. However, since GPGPU systems generally only include volatile memory devices with a relatively small capacity, they cause frequent page swaps and data copying between the host and the device for the volatile memory devices as shown in Figure 1, which leads to a problem of application performance degradation.
[0005] Furthermore, since the primary termination condition of graph algorithms is saturation, a checkpoint operation is required to save the calculation results to a separate storage device connected to the GPGPU system for efficient failure recovery after performing numerous iterative calculations. However, because separate storage devices connected to the GPGPU system typically use disk or flash-based storage, there is a problem in that the time required for the checkpoint to save the results to the storage device takes longer than the time required to perform the calculations on the GPGPU system.
[0006] For example, in the case of the aforementioned Google PageRank algorithm, the calculation time is 30 seconds, while the checkpoint requires 60 seconds (Reference 3: Shen, Yanyan, Gang Chen, HV Jagadish, Wei Lu, Beng Chin Ooi, and Bogdan Marious Tudor. "Fast failure recovery in distributed graph processing systems." In VLDB, 2014). The problem to be solved
[0007] An embodiment of the present invention provides a graph processing system and a method of operation of the graph processing system that includes two types of memory devices having different characteristics, which can rapidly perform iterative graph operations on graph data while effectively checking the results of the graph operations. means of solving the problem
[0008] A method of operation of a graph processing system according to an embodiment of the present invention comprises: a method of operation of a graph processing system including a first memory device and a second memory device, wherein among graph data input from a host, a starting vertex index, an ending vertex index, and an edge value between a starting vertex and an ending vertex are stored in the first memory device, and a starting vertex value is stored in the second memory device; a rearrangement step of rearranging the starting vertex value as an intermediate vertex value within the second memory device by referencing the starting vertex index of the first memory device; an operation step of performing a graph operation on the intermediate vertex value of the second memory device by referencing the ending vertex index and the edge value of the first memory device, and storing the ending vertex value determined as the operation result in the second memory device; and a determination step of determining whether the graph processing operation is completed by comparing the ending vertex value and the starting vertex value within the second memory device. If the graph processing operation is not completed in the judgment step, the method may include a setting step of setting the destination vertex value in the second memory device to a new start vertex value; and a repetition step of repeatedly performing the setting step, the rearrangement step, the operation step, and the judgment step until the graph processing operation is completed in the judgment step.
[0009] In addition, if the graph processing operation is completed in the above judgment step, it may further include a final storage step of storing the destination vertex value stored in the second memory device in the first memory device as the final result of the graph processing operation.
[0010] Additionally, it may further include a counting step for counting the number of times the above judgment step is performed; and an intermediate storage step for checking the value counted in the counting step if the graph processing operation is not completed in the above judgment step, and storing the destination vertex value stored in the second memory device in the first memory device as an intermediate result of the graph processing operation according to the result of the check.
[0011] In addition, the section where the intermediate storage step is performed may overlap with the section where the setting step, the rearrangement step, the operation step, and the judgment step are performed through the repetition step.
[0012] In addition, when the above intermediate storage step is performed at least twice, the storage area of the first memory device used in the preceding intermediate storage step and the storage area of the first memory device used in the subsequent intermediate storage step are different from each other, and the storage area of the first memory device used in the preceding intermediate storage step can be released at the time when the subsequent intermediate storage step is completed.
[0013] In addition, the storage area of the first memory device used in the intermediate storage step and the storage area of the first memory device used in the final storage step are different from each other, and the storage area of the first memory device used in the intermediate storage step can be released at the time when the final storage step is completed.
[0014] In addition, the method may further include a step of storing a message generated during the graph operation process of the above operation step in the second memory device by corresponding it to the destination vertex value.
[0015] Additionally, the first memory device may be a non-volatile memory device that inputs and outputs data in page units, and the second memory device may be a volatile memory device that inputs and outputs data in bit units.
[0016] Additionally, the storage step may include: a step of, after a plurality of graph data is input from the host, grouping a plurality of start vertex indices included in each of the plurality of graph data into at least one page, grouping a plurality of end vertex indices into at least one page, and grouping a plurality of edge values into at least one page, and then storing each of the grouped plurality pages in the first memory device; and a step of, when the graph data is input from the host, storing the start vertex values included in the graph data in the second memory device.
[0017] Additionally, the first memory device may be any one of flash memory, phase change random access memory (PCRAM), resistive random access memory (RRAM), ferroelectric random access memory (FRAM), and spin transfer torque random access memory (STT-MRAM), and the second memory device may be any one of static random access memory (SRAM) and dynamic random access memory (DRAM).
[0018] A graph processing system according to another embodiment of the present invention comprises: a first memory device; a second memory device; The graph processing device includes a graph processing device that stores a starting vertex index, an ending vertex index, and an edge value between the starting vertex and the ending vertex among graph data input from a host in the first memory device, stores a starting vertex value in the second memory device, and then performs a rearrangement operation to generate an intermediate vertex value by rearranging the starting vertex value within the second memory device through the starting vertex index of the first memory device, and performs an operation to store in the second memory device an ending vertex value determined as a result of performing a graph operation on the intermediate vertex value of the second memory device by referencing the ending vertex index and the edge value of the first memory device. The graph processing device performs a judgment operation to determine whether the graph processing operation is completed by comparing the ending vertex value and the starting vertex value within the second memory device, and a setting operation to set the ending vertex value as a new starting vertex value within the second memory device if it is determined in the judgment operation that the graph processing operation is not completed. In the judgment operation, the graph A repetitive operation can be performed by repeating the above setting operation, the above rearrangement operation, the above calculation operation, and the above judgment operation until it is determined that the processing operation is completed.
[0019] Additionally, the graph processing device may perform a counting operation that counts the number of times the judgment operation is executed whenever it is determined that the graph processing operation is not completed in the judgment operation; an intermediate storage operation that stores the destination vertex value stored in the second memory device as an intermediate result of the graph processing operation in the first memory device according to the number of times the judgment operation is executed counted through the counting operation up to that point in time when it is determined that the graph processing operation is not completed in the judgment operation; and a final storage operation that stores the destination vertex value stored in the second memory device as a final result of the graph processing operation in the first memory device when it is determined that the graph processing operation is completed in the judgment operation.
[0020] In addition, the graph processing device can control the section where the intermediate storage operation is performed to overlap with the section where the setting operation, the rearrangement operation, the calculation operation, and the judgment operation are performed through the repetition operation.
[0021] Additionally, when the graph processing device performs the intermediate storage operation at least twice, it sets the storage area of the first memory device allocated for the preceding intermediate storage operation and the storage area of the first memory device allocated for the subsequent intermediate storage operation differently from each other, and can release the storage area of the first memory device allocated for the preceding intermediate storage operation at the time when the subsequent intermediate storage operation is completed.
[0022] In addition, the graph processing device sets the storage area of the first memory device allocated for the intermediate storage operation and the storage area of the first memory device allocated for the final storage operation differently from each other, and can release the area of the first memory device allocated for the intermediate storage operation at the time when the final storage operation is completed.
[0023] In addition, the graph processing device can store a message generated during the graph operation process of the operation operation in the second memory device by corresponding it to the destination vertex value.
[0024] Additionally, the first memory device may be a non-volatile memory device that inputs and outputs data in page units, and the second memory device may be a volatile memory device that inputs and outputs data in bit units.
[0025] Additionally, the graph processing device may, after receiving a plurality of graph data from the host, group a plurality of start vertex indices included in each of the plurality of graph data into at least one page, group a plurality of end vertex indices into at least one page, and group a plurality of edge values into at least one page, and then store each of the grouped pages in the first memory device.
[0026] Additionally, the first memory device may be any one of flash memory, phase change random access memory (PCRAM), resistive random access memory (RRAM), ferroelectric random access memory (FRAM), and spin transfer torque random access memory (STT-MRAM), and the second memory device may be any one of static random access memory (SRAM) and dynamic random access memory (DRAM). Effects of the invention
[0027] This technology enables effective storage of graph data and rapid execution of repetitive graph operations performed on graph data by distributing and storing graph data input from a host in two types of memory devices having different characteristics. Brief explanation of the drawing
[0028] FIG. 1 is a diagram showing the data swap overhead ratio of graph operations in a graph processing system according to the prior art. FIG. 2 is a drawing illustrating an example of a graph processing system according to an embodiment of the present invention. Figure 3 is a diagram illustrating an example of a graph data structure used in a G-shard. FIG. 4 is a diagram illustrating a Bulk Synchronous Parallel (BSP) based graph processing platform. FIG. 5 is a diagram illustrating a graph processing operation according to an embodiment of the present invention. Specific details for implementing the invention
[0029] Hereinafter, preferred embodiments of the present invention will be described with reference to the attached drawings. However, the present invention is not limited to the embodiments disclosed below and may be configured in various different forms; the embodiments provided are merely intended to ensure that the disclosure of the present invention is complete and to fully inform those skilled in the art of the scope of the present invention.
[0030] FIG. 2 is a drawing illustrating an example of a graph processing system according to an embodiment of the present invention.
[0031] Figure 3 is a diagram illustrating an example of a graph data structure used in a G-shard.
[0032] FIG. 4 is a diagram illustrating a Bulk Synchronous Parallel (BSP) based graph processing platform.
[0033] FIG. 5 is a diagram illustrating a graph processing operation according to an embodiment of the present invention.
[0034] Referring to FIG. 2, a graph processing system (22) according to an embodiment of the present invention may include a first memory device (221), a second memory device (222), and a graph processing device (223).
[0035] First, the host (21) can transmit graph data (GRAPH_DATA) to the graph processing system (22). The graph processing system (22) can store the graph data (GRAPH_DATA) input from the host (21) in an internal memory device, namely, a first memory device (221) and a second memory device (222). Then, the graph processing device (223) included in the graph processing system (22) can perform graph operations on the graph data (GRAPH_DATA) stored in the first memory device (221) and the second memory device (222) and output the result to the host (21).
[0036] Although not directly illustrated in the drawing, the interior of the graph processing unit (223) included in the graph processing system (22) can be subdivided, from a hardware perspective, into a streaming multiprocessor, a streaming processor, and a Warp, which is a group of threads. This distinction from a hardware perspective can be subdivided from a software perspective into a Grid, a Block, and a Thread.
[0037] Meanwhile, among parallel computing models, Bulk Synchronous Parallel (BSP) is a model actively researched for graph processing. A representative example is Pregel (Reference 4: Malewicz, Grzegorz, Matthew H. Austern, Aart JC Bik, James C. Dehnert, Illan Horn, Naty Leiser, and Grzegorz Czajkowski. "Pregel: a system for large-scale graph processing." In SIGMOD, 2010.), a graph-specialized platform created by Google to replace Hadoop, and it can be used primarily for vertex-centric graph operations. For reference, vertex-centric graph processing in Google's PageRank can be represented by the following algorithm example.
[0038] Pregel_PageRank (DestIdx,messages): / / receive all the messagestotal=0foreach (msg in messages): total=total+msg / / update the rank of this vertex / / rank is saved as vertex valueR[i]=0.15+total / / send new messages to vertex i's neighbors (out-edges) / / weight is saved as edge value between vertex i and vertex jforeach (j in out_neighbors[i]): sendmsg(R[i]*w_ij ) to vertex
[0039] In addition, a Compressed Sparse Row (CSR) is a representative method for representing data when loading graph data (GRAPH_DATA) into memory for graph operations (Reference 5: Williams, Samuel, Leonied Oilker, Richard Vuduc, John Shalf, Katherine Yelick, and James Demmel. "Optimization of sparse matrix-vector multiplication on emerging multicore platforms." In SC, 2007). Compressed Sparse Rows (CSR) can be efficient in terms of the memory capacity for loading graph data (GRAPH_DATA). However, during the process of performing graph operations, sequential access to the neighboring vertex indices of each of the multiple vertices included in the graph data (GRAPH_DATA)—that is, accessing vertex values through indices—can cause frequent random reads and random writes to the memory storing the graph data (GRAPH_DATA).
[0040] Accordingly, a shard (Reference 6: Kyrola, A., Blelloch, GE, & Guestrin, C. "GraphChi: Large-scale graph computation on just a pc." In USENIX, 2012.) has been proposed that can improve the I / O performance of the memory where the graph data (GRAPH_DATA) is stored by arranging the information included in the graph data (GRAPH_DATA) so that a specific number of sequential vertices are designated as destination vertices as shown in FIG. 3. Furthermore, in a G-shard modified to be suitable for processing graph data (GRAPH_DATA), the starting vertex index (S_INDEX), starting vertex value (S_VALUE), edge value between the starting vertex and the destination vertex (ST_EDGE), and destination vertex index (T_INDEX) included in the graph data (GRAPH_DATA) are each separated into a single row (Rx), thereby allowing multiple rows (R1, R2, R3, R4, Parallel processing can be performed by allocating R5, R6, and R7 respectively and processing them sequentially. For reference, Figure 3 illustrates an example where four destination vertex indices (T_INDEX: 0~3) are specified as the size of the shard.
[0041] Referring to Fig. 4, in the conventional massively synchronous parallel (BSP), assuming that a total of M vertices in graph data (GRAPH_DATA) are divided and assigned to N blocks (BLOCK<0, 1, ..., N>) for parallel computation, M / N vertex values (M / N*VERTEX) can be assigned to each of the N blocks (BLOCK<0, 1, ..., N>) as starting vertex values (S_VALUE). In this way, graph computation can be performed through vertex computation (VERTEX COMPUTATION) on the M / N vertex values (M / N*VERTEX) assigned to each of the N blocks (BLOCK<0, 1, ..., N>) to determine the destination vertex values corresponding to each of the N blocks (BLOCK<0, 1, ..., N>). In this case, for graph operations on each of the N blocks (BLOCK<0, 1, ..., N>), the edge value (ST_EDGE) between the starting vertex and the destination vertex included in the graph data (GRAPH_DATA) and the destination vertex index (T_INDEX) may be referenced. Additionally, since edges may exist between vertices in different blocks during the process of performing graph operations on each of the N blocks (BLOCK<0, 1, ..., N>), message passing may be used for data sharing. For reference, M / N, which is the number of vertices (VERTEX) allocated to a single block, may be the size of the shard.
[0042] Thus, a Super Step can be defined as performing a single graph operation on all M vertices included in the graph data (GRAPH_DATA) by executing graph operations for each of the N blocks (BLOCK<0, 1, ..., N>), that is, performing N graph operations. Once a Super Step is completed for the M starting vertex values and the M destination vertex values are determined, the determined M destination vertex values are set as the M starting vertex values (S_VALUE), and a new Super Step can begin. Such Super Steps can be repeated until the graph operations reach saturation. Here, graph operations reaching saturation means that the difference between the starting vertex values and the destination vertex values is within a set range. In other words, if the M destination vertex values determined by performing graph operations on M destination vertex values differ from the M destination vertex values prior to the operations within a set range, it may be meaningless to continue performing graph operations. Therefore, the case where the difference between the destination vertex values and the destination vertex values is within a set range can be described as a state where the graph operations are saturated.
[0043] In addition, the drawing illustrates the operation of checking the graph operation result after two super steps are repeated; however, this is merely one example, and in reality, the graph operation result can be checked after more or fewer super steps are repeated. For example, the graph operation result can be checked at a cycle of 5 to 10 super steps. For reference, checking the graph operation result may mean dumping all graph data determined up to the point where the check point is performed into a non-volatile storage device and storing it permanently. By checking the graph operation result in this way, if the graph operation cannot be performed normally due to an unexpected error, the graph data can be recovered using the graph operation result stored at the previous check point, and the graph operation can be performed normally again. In other words, failure recovery for graph data can be performed through checkpoints.
[0044] Referring again to FIG. 2, in order for countless threads within the graph processing unit (223) to perform efficient graph operations on graph data (GRAPH_DATA) input from the host (21), a memory device having a relatively large capacity and a fast operating speed is required. However, the faster the operating speed of the memory device, the more difficult it is to increase the storage capacity, and even if the storage capacity can be increased, it may require a high cost. Conversely, the slower the operating speed of the memory device having a relatively large capacity.
[0045] Accordingly, a graph processing system (22) according to an embodiment of the present invention may include two memory devices (221, 222) having different characteristics. That is, a graph processing system (22) according to an embodiment of the present invention may include a first memory device (221) having a relatively large capacity and a second memory device (222) having a relatively fast operating speed. Of course, the operating speed of the second memory device (222) may be faster than the operating speed of the first memory device (221).
[0046] Additionally, the first memory device (221) may be a non-volatile memory device that inputs and outputs data in page units. For example, the first memory device (221) may be any one of a flash memory, a phase change random access memory (PCRAM), a resistive random access memory (RRAM), a ferroelectric random access memory (FRAM), and a spin transfer torque random access memory (STT-MRAM).
[0047] Additionally, the second memory device (222) may be a volatile memory device that inputs and outputs data in bit units. For example, the second memory device (222) may be a memory of either static random access memory (SRAM) or dynamic random access memory (DRAM).
[0048] And, the graph data (GRAPH_DATA) transmitted from the host (21) to the graph processing system (22) may include a starting vertex index (S_INDEX), a starting vertex value (S_VALUE), an edge value (ST_EDGE) between the starting vertex and the destination vertex, and a destination vertex index (T_INDEX).
[0049] Specifically, among the graph data (GRAPH_DATA), the starting vertex index (S_INDEX), the edge value (ST_EDGE) between the starting and ending vertices, and the ending vertex index (T_INDEX) may be read-only data used without updates during the execution of graph operations. On the other hand, the starting vertex value (S_VALUE) among the graph data (GRAPH_DATA) may be data that is referenced during the execution of graph operations but is updated whenever the superstep of the graph operation is repeated. In other words, the starting vertex value (S_VALUE) among the graph data (GRAPH_DATA) may be data for which both read and write operations are performed.
[0050] Furthermore, the combined size of the starting vertex index (S_INDEX), edge value (ST_EDGE), and destination vertex index (T_INDEX) in the graph data (GRAPH_DATA) can be significantly larger than the data size of the starting vertex value (S_VALUE). For example, assuming the graph data (GRAPH_DATA) contains 4.8M vertices and 69M edges, the combined size of the starting vertex index (S_INDEX), edge value (ST_EDGE), and destination vertex index (T_INDEX) is approximately 1.1 GByte, whereas the data size of the starting vertex value (S_VALUE) can be 19.2 MByte (Reference 7: J. Leskovec, KJ Lang, A. Dasgupta, and MW Mahoney. "Community structure in large networks: Natural cluster sizes and the absence of large well-defined clusters" In Internet Mathematics, 2009.).
[0051] For reference, it is common for all existing memory devices to have a read speed faster than a write speed, and this may also be the case for the first memory device (221) and the second memory device (222). For example, assuming the first memory device (221) is a phase-conversion memory (PCRAM), the read speed may be 185ns while the write speed may be 20us. Also, assuming the second memory device (222) is a dynamic RAM (DRAM), the read speed may be 100ns while the write speed may be 125ns.
[0052] Accordingly, in the graph processing system (22) according to an embodiment of the present invention, the starting vertex index (S_INDEX), the edge value (ST_EDGE) between the starting vertex and the destination vertex, and the destination vertex index (T_INDEX) among the graph data (GRAPH_DATA) can be stored in a first memory device (221) having a relatively large capacity but a relatively slow operating speed. Additionally, the starting vertex value (S_VALUE) among the graph data (GRAPH_DATA) can be stored in a second memory device (222) having a relatively small capacity but a relatively fast operating speed.
[0053] Meanwhile, as described in FIG. 3 above, one graph data (GRAPH_DATA) input from the host (21) may correspond to one row (Rx). Therefore, assuming that two graph data (GRAPH_DATA) are input from the host (21), '0, V0, 5, 1', which is the value of the starting vertex index (S_INDEX), starting vertex value (S_VALUE), edge value (ST_EDGE), and destination vertex index (T_INDEX) corresponding to the first row (R1), may be input, and then '1, V1, 1, 2', which is the value of the starting vertex index (S_INDEX), starting vertex value (S_VALUE), edge value (ST_EDGE), and destination vertex index (T_INDEX) corresponding to the second row (R2), may be input. In this way, if the remaining values (S_INDEX, ST_EDGE, T_INDEX) excluding the starting vertex value (S_VALUE) from the graph data (GRAPH_DATA) input in a form corresponding to the row (Rx) are stored as is in the first memory device (221) that inputs / outputs data in page units, access to the first memory device (221) may occur too frequently.
[0054] Accordingly, a graph processing system (22) according to an embodiment of the present invention may, after receiving a plurality of graph data (GRAPH_DATA) from a host (21), group a plurality of starting vertex indices (S_INDEX) included in each of the plurality of graph data (GRAPH_DATA) into at least one page, and then store the grouped at least one page in a first memory device (221). Additionally, the graph processing system (22) may, after grouping a plurality of destination vertex indices (T_INDEX) included in each of the plurality of graph data (GRAPH_DATA) into at least one page, and then store the grouped at least one page in a first memory device (221). Additionally, the graph processing system (22) may, after grouping a plurality of edge values (ST_EDGE) included in each of the plurality of graph data (GRAPH_DATA) into at least one page, and then store the grouped at least one page in a first memory device (221).
[0055] In summary, the graph processing system (22) according to an embodiment of the present invention, when a graph data (GRAPH_DATA) input from a host (21) as described in FIG. 3 above corresponds to a row (Rx), does not store the data in the form corresponding to the row (Rx) as is in the first memory device (221), but classifies the data into a form corresponding to a column and then stores it in the first memory device (221). For example, '0, 1, 5, 5, 6, 7, 7', which is the value of the column corresponding to the starting vertex index (S_INDEX) in the graph data (GRAPH_DATA), can be grouped into at least one page and stored in the first memory device (221). In addition, '5, 1, 6, 4, 4, 3, 9', which is the value of the column corresponding to the edge value (ST_EDGE) in the graph data (GRAPH_DATA), can be grouped into at least one page and stored in the first memory device (221). Additionally, the value of the column corresponding to the destination vertex index (T_INDEX) in the graph data (GRAPH_DATA), '1, 2, 1, 3, 0, 0, 2', can be grouped into at least one page and stored in the first memory device (221).
[0056] In addition, the operation of storing the starting vertex value (S_VALUE) among the graph data (GRAPH_DATA) in the second memory device (222) that inputs / outputs data in bit units can be controlled differently from the storage operation of the first memory device (221) described above. That is, whenever graph data (GRAPH_DATA) is input from the host (21), the graph processing system (22) can select only the starting vertex value (S_VALUE) among the graph data (GRAPH_DATA) and store it in the second memory device (222).
[0057] Meanwhile, the graph processing system (22) according to an embodiment of the present invention can store graph data (GRAPH_DATA) input from a host (21) in a distributed manner between a first memory device (221) and a second memory device (222), and then perform massive synchronous parallel (BSP) in the order described in FIG. 5.
[0058] Referring to FIGS. 2, FIGS. 4, and FIGS. 5, a graph processing system (22) according to an embodiment of the present invention can perform a rearrangement operation (A) of rearranging a starting vertex value (S_VALUE) into an intermediate vertex value (M_VALUE) within a second memory device (222) by referring to a starting vertex index (S_INDEX) of a first memory device (221).
[0059] Specifically, a graph processing device (223) included in a graph processing system (22) can perform a rearrangement operation (A) in which, after reading at least one page in which a start vertex index (S_INDEX) is stored in a first memory device (221), the start vertex value (S_VALUE) stored in a second memory device (222) is rearranged as an intermediate vertex value (M_VALUE) by referencing the read start vertex index (S_INDEX).
[0060] Meanwhile, the second memory device (222) may include a storage area (2221) and a processing area (2222). At this time, M starting vertex values (S_VALUE) input from the host (21) may be stored in the storage area (2221) of the second memory device (222). Additionally, the graph processing device (223) may perform graph operations by dividing the M starting vertex values (S_VALUE) into N blocks (BLOCK<0, 1, ..., N>), that is, by grouping them into M / N starting vertex values (S_VALUE). Accordingly, the graph processing device (223) may perform a rearrangement operation (A) of rearranging the M / N starting vertex values (S_VALUE) into M / N intermediate vertex values (M_VALUE) by referencing the starting vertex index (S_INDEX) read from the first memory device (221). For reference, the rearrangement operation (A) may be performed by a graph processing device (223) as shown in the drawing, but it may also be performed through separate hardware logic as shown in the drawing.
[0061] According to an embodiment, M / N starting vertex values (S_VALUE) may be moved from the storage area (2221) of the second memory device (222) to the processing area (2222), and then rearranged into M / N intermediate vertex values (M_VALUE) by referencing the starting vertex index (S_INDEX) of the first memory device (221). According to another embodiment, M / N starting vertex values (S_VALUE) may be rearranged from the storage area (2221) of the second memory device (222) into M / N intermediate vertex values (M_VALUE) by referencing the starting vertex index (S_INDEX) of the first memory device (221), and then only M / N intermediate vertex values (M_VALUE) may be moved from the storage area (2221) of the second memory device (222) to the processing area (2222).
[0062] Next, the graph processing system (22) can perform a graph operation (B) on the intermediate vertex value (M_VALUE) of the second memory device (222) by referencing the destination vertex index (T_INDEX) and edge value (ST_EDGE) of the first memory device (221), and store the destination vertex value (T_VALUE) determined as a result of the graph operation in the second memory device (222).
[0063] Specifically, a graph processing device (223) included in a graph processing system (22) can read at least one page in which a destination vertex index (T_INDEX) is stored in a first memory device (221) and read at least one page in which an edge value (ST_EDGE) is stored, and then perform graph operations on M / N intermediate vertex values (M_VALUE) stored in a processing area (2222) of a second memory device (222) by referencing the read destination vertex index (T_INDEX) and edge value (ST_EDGE). After performing graph operations on the M / N intermediate vertex values (M_VALUE), the graph processing device (223) can determine M / N destination vertex values (T_VALUE) as the result of the operation. The graph processing device (223) can determine M / N destination vertex values (T_VALUE) through graph operations and then store the determined M / N destination vertex values (T_VALUE) in the storage area (2221) of the second memory device (222).
[0064] At this time, since the graph processing device (223) uses a message passing method for data sharing, it can generate messages during the process of determining the destination vertex value (T_VALUE) by performing graph operations on the intermediate vertex value (M_VALUE). The graph processing device (223) can store the generated messages in the second memory device (222) by corresponding them to the destination vertex value (T_VALUE). That is, the graph processing device (223) can generate multiple messages corresponding to each of the M / N destination vertex values (T_VALUE) during the process of determining the M / N destination vertex values (T_VALUE) by performing graph operations on M / N intermediate vertex values (M_VALUE). The graph processing device (223) can store the generated messages in the storage area (2221) of the second memory device (222) in a form corresponding to each of the M / N destination vertex values (T_VALUE).
[0065] As described above, the graph processing system (22) can determine M / N destination vertex values (T_VALUE) by performing a rearrangement operation (A) to rearrange M / N destination vertex values (S_VALUE) into M / N intermediate vertex values (M_VALUE), and then performing a graph operation on the M / N intermediate vertex values (M_VALUE) through an operation operation (B). By performing graph operations in this manner N times, M destination vertex values (S_VALUE) can be rearranged into M intermediate vertex values (M_VALUE), and then M destination vertex values (T_VALUE) can be determined by performing graph operations on the M intermediate vertex values (M_VALUE). In this way, the state in which M destination vertex values (T_VALUE) are determined by performing a graph operation once for each of the M destination vertex values (S_VALUE) can be described as a state in which one super step is completed.
[0066] After one super step is completed, the graph processing system (22) can perform a judgment operation (C) to determine whether the graph processing operation is completed by comparing the starting vertex value (S_VALUE) and the destination vertex value (T_VALUE).
[0067] Specifically, the graph processing device (223) included in the graph processing system (22) may determine that the graph processing operation is completed when the difference between M starting vertex values (S_VALUE) and M destination vertex values (T_VALUE) is within a set range. Conversely, the graph processing device (223) may determine that the graph processing operation is not completed when the difference between M starting vertex values (S_VALUE) and M destination vertex values (T_VALUE) exceeds a set range.
[0068] If the graph processing device (223) determines in the judgment operation (C) that the graph processing operation is not completed, it may perform a setting operation (D) to set the destination vertex value (T_VALUE) to a new start vertex value (S_VALUE) within the second memory device (222). Thus, the start vertex value (S_VALUE) that was already stored in the second memory device (222) before the destination vertex value (T_VALUE) is set to a previously used vertex value may remain stored in the second memory device (222) as such, depending on the embodiment. According to another embodiment, the start vertex value (S_VALUE) that was stored in the second memory device (222) before the setting operation (D) is performed can be deleted to generate a new start vertex value (S_VALUE).
[0069] Specifically, if the graph processing device (223) determines in the judgment operation (C) that the graph processing operation is not completed, it can set M destination vertex values (T_VALUE) within the second memory device (222) to new M start vertex values (S_VALUE) through the setting operation (D). Therefore, after the setting operation (D) is performed, the second memory device (222) may no longer contain M destination vertex values (T_VALUE).
[0070] If it is determined that the graph processing operation is not completed in the judgment operation (C), the graph processing device (223) may perform another super step following the previously performed super step. That is, after the rearrangement operation (A), operation (B), and judgment operation (C) are performed through the previously performed super step, if it is determined that the graph processing operation is not completed in the judgment operation (C), the graph processing device (223) may perform another super step including the setting operation (D), the rearrangement operation (A), the operation (B), and the judgment operation (C).
[0071] In this way, multiple super steps may be repeated, and since the starting vertex value (S_VALUE) input from the host (21) is directly assigned only in the first super step, the setting operation (D) may not be included in the super step, and from the second super step to the last super step, the setting operation (D) that sets the destination vertex value (T_VALUE) determined in the preceding super step as the starting vertex value (S_VALUE) may be included in the super step.
[0072] Meanwhile, for failure recovery of graph data, it may be necessary to checkpoint the graph calculation result whenever a set number of super steps among multiple super steps are repeated.
[0073] To this end, the graph processing system (22) according to an embodiment of the present invention can count the number of times a judgment operation (C) included in each of a plurality of super steps is performed. That is, the graph processing device (223) included in the graph processing system (22) can perform a counting operation that increases one counting value each time a super step is performed.
[0074] Additionally, if it is determined that the graph processing operation is not completed as a result of performing a judgment operation (C) in any one of the multiple super steps, the super step containing the judgment operation (C) may not be the last super step. Therefore, the graph processing system (22) can perform a checkpoint operation (F) in which, in the case of an intermediate super step that is not the last super step among the multiple super steps, that is, when the graph processing operation is not completed as a result of the judgment operation (C), it checks the value of the counting operation and stores the destination vertex value (T_VALUE) stored in the second memory device (222) in the first memory device (221) as an intermediate result of the graph processing operation (F). For example, if the graph processing device (223) has not completed the graph processing operation as a result of the judgment operation (C), it can check the value of the counting operation, and if the checked counting value is a multiple of 5 (5, 10, 15, 20, ...), it can perform an intermediate storage operation (F) of storing the destination vertex value (T_VALUE) stored in the second memory device (222) in the first memory device (221) as an intermediate result of the graph processing operation. If the checked counting value is not a multiple of 5, it will not perform the intermediate storage operation (F) and will start the execution of the next super step, that is, the setting operation (D), the rearrangement operation (A), the operation (B), and the judgment operation (C).
[0075] At this time, the graph processing system (22) can control the intermediate storage operation (F) of the preceding superstep among the plurality of supersteps to overlap with the section where the setting operation (D), rearrangement operation (A), operation (B), and judgment operation (C) of the subsequent superstep are performed. For example, the section where the intermediate storage operation (F) of the fifth superstep among the plurality of supersteps is performed may overlap with the section where the setting operation (D), rearrangement operation (A), operation (B), and judgment step (C) of the sixth superstep are performed.
[0076] Meanwhile, in the judgment operation (C) included in the last super step among the multiple super steps, it may be in a state where it is determined that the graph operation is completed. In this way, when it is determined that the graph operation is completed in the judgment operation (C), the graph processing device (223) may perform a final storage operation (G) of storing the destination vertex value (T_VALUE) stored in the second memory device (222) in the first memory device (221) as the final result of the graph processing operation.
[0077] Meanwhile, the graph processing system (22) may perform an intermediate storage operation (F) at least twice during the process of performing a number of super steps. In such cases, the graph processing system (22) may make the storage area of the first memory device (221) used in the preceding intermediate storage operation (F) and the storage area of the first memory device (221) used in the subsequent intermediate storage operation (F) different from each other among the at least two intermediate storage operations (F). To this end, the graph processing system (22) may release the storage area of the first memory device (221) used in the preceding intermediate storage operation (F) at the time when the subsequent intermediate storage operation (F) is completed (H). For example, the graph processing device (223) may use the first storage area of the first memory device (221) when performing the first intermediate storage operation (F). Subsequently, when the graph processing device (223) performs a second intermediate storage operation (F) following the first intermediate storage operation (F), it may use a second storage area that is distinct from the first storage area of the first memory device (221). At this time, the graph processing device (223) may release the first storage area of the first memory device (221) in which the destination vertex value (T_VALUE) corresponding to the first intermediate storage operation (F) is stored, at the time when the operation of storing the destination vertex value (T_VALUE) corresponding to the second intermediate storage operation (F) in the second storage area of the first memory device (221) is completed.
[0078] Meanwhile, the graph processing system (22) may perform at least one intermediate storage operation (F) and then perform a final storage operation (G) during the process of performing a plurality of super steps. In such a case, the graph processing system (22) may have the storage area of the first memory device (221) used in the intermediate storage operation (F) and the storage area of the first memory device (221) used in the final storage operation (G) different from each other. To this end, the graph processing system (22) may release the storage area of the first memory device (221) used in the preceding intermediate storage operation (F) at the time when the final storage operation (G) is completed (H). For example, the graph processing device (223) may use the third storage area of the first memory device (221) when performing the intermediate storage operation (F). Subsequently, when performing the final storage operation (G), the graph processing device (223) may use a fourth storage area that is distinct from the third storage area of the first memory device (221). At this time, the graph processing device (223) may release the third storage area of the first memory device (221) in which the destination vertex value (T_VALUE) corresponding to the intermediate storage operation (F) is stored, at the point when the operation of storing the destination vertex value (T_VALUE) corresponding to the final storage operation (G) in the fourth storage area of the first memory device (221) is completed.
[0079] It will be obvious to those skilled in the art that the invention described above is not limited by the aforementioned embodiments and attached drawings, and that various substitutions, modifications, and changes are possible within the scope of the technical concept of the invention.
Claims
Claim 1 A method of operation of a graph processing system comprising a first memory device, a second memory device, and a graph processing device, wherein the graph processing device stores, among graph data input from a host, a start vertex index, an end vertex index, and an edge value between a start vertex and an end vertex in the first memory device, and stores a start vertex value in the second memory device; a rearrangement step wherein the graph processing device rearranges the start vertex value as an intermediate vertex value within the second memory device by referencing the start vertex index of the first memory device; an operation step wherein the graph processing device performs a graph operation on the intermediate vertex value of the second memory device by referencing the end vertex index and the edge value of the first memory device, and stores the end vertex value determined as the operation result in the second memory device; a determination step wherein the graph processing device determines whether the graph processing operation is completed by comparing the end vertex value and the start vertex value within the second memory device; wherein, in the determination step, the graph processing operation A method of operation of a graph processing system comprising: a setting step in which, if not completed, the graph processing device sets the destination vertex value in the second memory device to a new start vertex value; and a repetition step in which the graph processing device repeatedly performs the setting step, the rearrangement step, the operation step, and the judgment step until the graph processing operation in the judgment step is completed. Claim 2 A method of operation of a graph processing system according to claim 1, further comprising a final storage step in which, when the graph processing operation is completed in the judgment step, the destination vertex value stored in the second memory device is stored in the first memory device as the final result of the graph processing operation by the graph processing device. Claim 3 A method of operation of a graph processing system according to claim 2, further comprising: a counting step for counting the number of times the judgment step is performed by the graph processing device; and an intermediate storage step for, if the graph processing operation is not completed in the judgment step, checking the value counted in the counting step by the graph processing device and storing the destination vertex value stored in the second memory device in the first memory device as an intermediate result of the graph processing operation according to the result of the check. Claim 4 A method of operation of a graph processing system according to paragraph 3, wherein the section in which the intermediate storage step is performed by the graph processing device is controlled to overlap with the section in which the setting step, the rearrangement step, the operation step, and the judgment step are performed through the repetition step. Claim 5 A method of operation of a graph processing system according to claim 3, wherein when the intermediate storage step is performed at least twice by the graph processing device, the storage area of the first memory device used in the preceding intermediate storage step and the storage area of the first memory device used in the subsequent intermediate storage step are set differently from each other, and the storage area of the first memory device used in the preceding intermediate storage step is released at the time when the subsequent intermediate storage step is completed. Claim 6 A method of operation of a graph processing system according to claim 3, wherein the storage area of the first memory device used in the intermediate storage step and the storage area of the first memory device used in the final storage step are set differently by the graph processing device, and the storage area of the first memory device used in the intermediate storage step is released at the time when the final storage step is completed. Claim 7 A method of operation of a graph processing system according to claim 1, further comprising the step of storing a message generated during the graph operation process of the operation step by the graph processing device in the second memory device by corresponding it to the destination vertex value. Claim 8 A method of operation of a graph processing system, wherein, in claim 1, the first memory device is a non-volatile memory device that inputs / outputs data in page units, and the second memory device is a volatile memory device that inputs / outputs data in bit units. Claim 9 In claim 8, the storage step comprises: a step of, after a plurality of graph data is input from the host by the graph processing device, grouping a plurality of start vertex indices included in each of the plurality of graph data into at least one page, grouping a plurality of end vertex indices into at least one page, and grouping a plurality of edge values into at least one page, and then storing each of the grouped plurality pages in the first memory device; and a step of, when the graph data is input from the host by the graph processing device, storing the start vertex values included in the graph data in the second memory device. Claim 10 First memory device; second memory device; The graph processing device includes a graph processing device that stores a starting vertex index, an ending vertex index, and an edge value between the starting vertex and the ending vertex among graph data input from a host in the first memory device, stores a starting vertex value in the second memory device, and then performs a rearrangement operation to generate an intermediate vertex value by rearranging the starting vertex value within the second memory device through the starting vertex index of the first memory device, and performs an operation to store in the second memory device an ending vertex value determined as a result of performing a graph operation on the intermediate vertex value of the second memory device by referencing the ending vertex index and the edge value of the first memory device. The graph processing device performs a judgment operation to determine whether the graph processing operation is completed by comparing the ending vertex value and the starting vertex value within the second memory device, and a setting operation to set the ending vertex value as a new starting vertex value within the second memory device if it is determined in the judgment operation that the graph processing operation is not completed. In the judgment operation, the graph A graph processing system that performs a repetitive operation of repeating the above setting operation, the above rearrangement operation, the above operation and the above judgment operation until it is determined that the processing operation is completed. Claim 11 In claim 10, the graph processing device comprises a graph processing system that performs a counting operation for counting the number of times the judgment operation is performed whenever it is determined that the graph processing operation is not completed in the judgment operation, an intermediate storage operation for storing the destination vertex value stored in the second memory device as an intermediate result of the graph processing operation in the first memory device according to the number of times the judgment operation is performed counted through the counting operation up to that point in time when it is determined that the graph processing operation is not completed in the judgment operation, and a final storage operation for storing the destination vertex value stored in the second memory device as a final result of the graph processing operation in the first memory device when it is determined that the graph processing operation is completed in the judgment operation. Claim 12 In claim 11, the graph processing device is a graph processing system that controls the section performing the intermediate storage operation to overlap with the section where the setting operation, the rearrangement operation, the operation operation, and the judgment operation are performed through the repetition operation. Claim 13 A graph processing system according to claim 11, wherein the graph processing device sets the storage area of the first memory device allocated for the preceding intermediate storage operation and the storage area of the first memory device allocated for the subsequent intermediate storage operation differently when performing the intermediate storage operation at least twice, and releases the storage area of the first memory device allocated for the preceding intermediate storage operation at the time of completing the subsequent intermediate storage operation. Claim 14 In claim 11, the graph processing device sets the storage area of the first memory device allocated for the intermediate storage operation and the storage area of the first memory device allocated for the final storage operation differently from each other, and the graph processing system releases the area of the first memory device allocated for the intermediate storage operation at the time when the final storage operation is completed. Claim 15 In claim 10, the graph processing device is a graph processing system that stores a message generated during the graph operation process of the above operation in the second memory device by corresponding it to the destination vertex value. Claim 16 A graph processing system in which, in paragraph 10, the first memory device is a non-volatile memory device that inputs and outputs data in page units, and the second memory device is a volatile memory device that inputs and outputs data in bit units. Claim 17 In claim 16, the graph processing device is a graph processing system that, after a plurality of graph data are input from the host, groups a plurality of start vertex indices included in each of the plurality of graph data into at least one page, groups a plurality of end vertex indices into at least one page, groups a plurality of edge values into at least one page, and then stores each of the grouped pages in the first memory device. Claim 18 A first memory device that stores read-only values including a start vertex index, an end vertex index, and an edge value between the start vertex and the end vertex among graph data input from a host; a second memory device that stores read and write values including a start vertex value among the graph data, has a relatively smaller capacity than the first memory device, and operates at a relatively faster speed than the first memory device; A graph processing system comprising a graph processing device that repeatedly performs a super step operation based on graph data distributed and stored in the first and second memory devices, and performs a checkpoint operation that stores the result of the super step operation performed the set number of times in the first memory device whenever the super step operation is repeated a set number of times; wherein the graph processing device, after a plurality of graph data is input from the host, groups a plurality of start vertex indices included in each of the plurality of graph data into a first group, groups a plurality of end vertex indices into a second group, groups a plurality of edge values into a third group, and stores each of the first to third groups in the first memory device, and each of the first to third groups has a size corresponding to a multiple of the data input / output unit of the first memory device. Claim 19 delete Claim 20 delete
Citation Information
Patent Citations
Link analysis computing method, devices and link analysis computing system
CN104572729A
Maximal matching method for graph
KR1020150111482A
Graph processing system and method of operation of graph processing system
KR1020190095489A
