KR101068669B1 - Method and apparatus of visualizing accesses in OpenMP program on scalable 3D cone, and recording medium storing the method thereon - Google Patents

Abstract

A method, apparatus, and storage medium for visualizing access to shared variables in a parallel program on a three-dimensional cone are disclosed. The visualization method includes the steps of receiving a contention detection result for the program, analyzing the contention detection results to obtain the nesting depth of the program, visualizing the three-dimensional cone, and then coniculating the height of the three-dimensional cone to equal the nesting depth. Step, a thread visualization step of visualizing a thread of the same nesting level among a plurality of parallel threads generated during execution of the program on a circumference located at the same height of the cone, and analyzing the contention detection result to analyze the access events of the shared variables among the threads. And classifying the generated threads according to whether or not the read and write access events are generated and their probabilities, and visualizing the classified threads to distinguish them from each other.

OpenMP parallel program, contention validation, 3D scalable visualization, parallelism

Description

Method and apparatus of visualizing accesses in OpenMP program on scalable 3D cone, and recording medium storing the method thereon}

The present invention relates to a debugging technique of a parallel program having nested parallelism. In particular, by visualizing the access to a shared variable in a parallel program on a three-dimensional cone, to facilitate debugging and to efficiently perform program development. A method, apparatus, and storage medium for doing so.

While a shared memory parallel program is running, one or more parallel threads use the same shared variable. Therefore, if multiple concurrent threads access a shared variable at the same time, an access error called data race will occur if proper synchronization is not performed. Conflicts in parallel programs can produce results that differ from those designed by the programmer. These results are called nondeterministic output.

The parallelism between threads when executing a parallel program can be represented by using a Partial Order Execution Graph (POEG). Vertices in POEG represent the creation / join instructions of parallel threads and access events to any shared variables, and arcs represent threads. r and w represent the read and write events on that thread, respectively. If there is no path between any two events e _i and e _j then e _i and e _j are said to be concurrent. If one of the two events for the same shared variable is a write event, the two events are said to be in conflict. If e _i and e _j are conflicting cases and parallel, the two events are said to be in conflict.

By the way, OpenMP (Open Multi-Processing), a parallel program model for industrial standardization, is a set of directives and libraries that use shared memory and extend standard C / C ++ and Fortran 77/90. OpenMP makes it easy to parallelize sequential programs using directives and provides the concept of orphan directives to implement coarse-grain parallelism, which increases the scalability of parallel programs. The directives provided by OpenMP include parallelization directives and synchronization directives. Parallelization directives include "#pragma omp parallel for" and "#pragma omp parallel sections" that create and join new threads. Synchronization directives control "#pragma omp atomic" and "#pragma", which control the execution order between threads. omp barrier "and" #pragma omp critical ". OpenMP also provides libraries and environment variables that control the runtime execution environment.

1A is source code for explaining contention of threads in a parallel program. In line 11 of FIG. 1A, a thread is created by the "#pragma omp parallel" directive. This assumes that two threads are created. The created threads are assigned the work specified in the loop body from the for statement on line 13 to the "}" on line 19 by the "#pragma omp for private (i, y, z)" directive on line 12. In the loop, the subscript variables i, y, and z are private variables used by each thread, and the integer variable x is a shared variable shared by both threads. The initial values of the x, y, and z variables are 0.

Of the two threads created, sentence 15 executed by the first thread and sentence 18 performed by the second thread have x because the threads are in concurrency, but the critical section is set by the "#pragrma omp critical (L1)" directive. There should be no contention for. However, as shown in FIG. 1B, when the first thread executes a read event on the shared variable x in sentence 14 and the second thread performs a write access event on the shared variable x in sentence 18, Contention occurs. This is because the critical variable for the shared variable x in sentence 14 is not protected. The parallel execution of the two threads may change the order in which access events occur. Therefore, in the 20th sentence, a random value of x is output from 100, 104, and 204. Of these values, a value of 104 occurs because the shared variable x is not protected by the critical zone. Therefore, the value may not be intended by the programmer. This is because parallel threads access the shared variable x with at least one write access event without proper synchronization between the two threads. Therefore, contention on shared variable x may result in nondeterministic output. The occurrence of nondeterministic results indicates that the program does not run reliably and must be resolved.

기호와

기호로 지정된 영역은 록 변수인 L1의 임계구역을 의미한다. 도 1b에서 T1 스레드에 r1과 T2 스레드에 w4는 병행관계에 있고 r1이 임계구역으로 보호되어 있지 않기 때문에 w4와 경합이라는 것을 알 수 있다. 그런데, 병렬 프로그램이 복잡해질수록 동시에 수행되는 스레드의 개수도 증가하고, 모든 접근 사건들의 경합을 일목요연하게 판단하기 곤란하다. FIG. 1B is a diagram illustrating a POEG when the pseudo code shown in FIG. 1A is executed. Here, the Partial Order Execution Graph (POEG) is a graph showing the logical ordering relationship of parallel programs. In FIG. 1B

Symbols and

The area designated by the symbol means the critical area of the lock variable L1. It can be seen from FIG. 1B that w1 is in parallel with the thread T1 and w4 in the thread T2, and because w1 is not protected by the critical section, it is contended with w4. However, as the parallel program becomes more complex, the number of threads executed simultaneously increases, and it is difficult to judge the contention of all access events at a glance.

Therefore, by showing the parallel program approach at a glance, there is an urgent need for a user to easily debug the parallel program, thereby reducing the program development time and improving the operational stability of the program.

SUMMARY OF THE INVENTION An object of the present invention is to provide a method capable of showing the contention detection results of a parallel program at a glance.

Another object of the present invention is to provide a visualization apparatus capable of logically understanding the execution structure of a parallel program so that not only the cause of detected contentions can be easily identified, but also intuitive information can be provided for debugging.

One aspect of the present invention for achieving the above object, relates to a method for visualizing the access of an OpenMP program on an extended three-dimensional cone, receiving a contention detection result for the program, by analyzing the contention detection results A cone visualization step of acquiring the nesting depth of the program, visualizing the three-dimensional cones, and then dividing the height of the three-dimensional cones to correspond to the nesting depths. Analyze the thread visualization step and contention detection result to visualize on the circumference located at the same height of, and classify the threads where the access event to the shared variable among the threads occur according to whether or not the read and write access event occurs and after Event visualization to visualize partitioned threads from one another Steps. In particular, the cone visualization step includes determining whether a multi-way loop exists within each nesting level and indicating whether there is a multi-loop present at the nesting level. In addition, the thread visualization step includes determining a thread including a critical section of the threads, and marking the thread including the critical section to be distinguished in different colors according to the lock variable. Further, the thread visualization step determines the distance between the threads based on the concurrency between the parallel threads, marks each of the threads on the cone spaced apart by the determined distance, and displays the parent thread including the child thread among the threads. It further includes a vertical abstraction step to distinguish it from. In addition, the thread visualization step further includes a horizontal abstraction step of representing a predetermined number of threads as one thread among the threads located on the same cone on the cone. Preferably, the access event visualization step is to classify the threads into a thread that does not have an access event, a thread in which a read access event occurs before a write access event, and a thread in which a write access event occurs before a read access event, respectively. Marking the threads to be distinct from one another. Furthermore, the access event visualization step is to classify the threads into a thread that does not have an access event, a thread in which a read access event occurs before a write access event, and a thread in which a write access event occurs before a read access event, respectively. Marking the threads to be distinct from one another.

Another aspect of the present invention for achieving the above objects relates to a recording medium for recording a computer program comprising instructions for implementing the method according to one aspect of the present invention.

Another aspect of the present invention for achieving the above object is an apparatus for visualizing the access of the OpenMP program on an extended three-dimensional cone, a user interface for receiving a contention detection result for the program, contention detection results A cone visualization module that analyzes to obtain the nesting depth of the program, visualizes the three-dimensional cones, and then divides the height of the three-dimensional cones to correspond to the nesting depths. Is a thread visualization module for visualizing the circumference on the same circumference of the cone, and analyzes the contention detection result to classify the occurrences of read and write access events and whether or not they occur after the occurrence of access events to shared variables among the threads. And visualize classified threads to distinguish them from each other An apparatus comprising a visualization module is provided. The cone visualization module may determine whether a multi-way loop exists within each nesting level, and further indicate whether the multi-loop exists. In addition, the thread visualization module determines which thread includes a critical section of the threads and further displays the thread comprising the critical section to be distinguished in different colors according to the lock variable. Further, the thread visualization module determines the distance between the threads based on the concurrency between the parallel threads, marks each of the threads on the cone apart by the determined distance, and displays the parent thread including the child thread among the threads. It further includes a vertical abstraction module that marks the thread as distinct. Alternatively, the thread visualization module further includes a horizontal abstraction module that indicates, as one thread, a predetermined number of threads located on the same cone on the cone. In addition, the access event visualization module classifies the threads into threads that do not have an access event, threads where a read access event occurs before a write access event, and threads where a write access event occurs before a read access event. It is characterized in that further display to distinguish them from each other.

According to the present invention, since the contention detection result of the parallel program can be illustrated at a glance, the development time of the program can be shortened.

In addition, according to the present invention, since the programmer can intuitively and logically understand the execution structure of the parallel program, it is possible to easily identify the cause of the detected contention, thereby ensuring the stability of the result of the program execution.

In order to fully understand the present invention, the operational advantages of the present invention, and the objects achieved by the practice of the present invention, reference should be made to the accompanying drawings which illustrate preferred embodiments of the present invention and the contents described in the accompanying drawings.

Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings. As those skilled in the art would realize, the described embodiments may be modified in various different ways, all without departing from the spirit or scope of the present invention. In addition, in order to clearly describe the present invention, parts irrelevant to the description are omitted, and the same reference numerals in the drawings indicate the same members.

Throughout the specification, when a part is said to "include" a certain component, this means that it may further include other components, without excluding other components unless otherwise stated. The terms "part", "unit", "module", "block", and the like described in the specification mean units for processing at least one function or operation, And a combination of software.

2 is a flowchart conceptually illustrating a method for visualizing an approach of an OpenMP program on an extended three-dimensional cone according to one aspect of the present invention.

Referring to FIG. 2, first, the visualization method according to the present invention receives a contention detection result that is an analysis result of an approach of an OpenMP program (S210). The contention detection result shows the result of the contention detection operation during the execution of the OpenMP program. That is, the contention detection result classifies access events for a plurality of parallel threads based on whether a synchronization instruction is included and accesses that are in parallel with previous access events stored in the access history among each access event for shared variables. Can be written by detecting an event as contention.

The contention detection result may include information about nesting levels, information about threads, and information about access events. In particular, the information on the nesting level may include a join symbol and nesting depth, and the thread information and the access event information may include a source code line number and an event type. ), An English-Hebrew label (EH-Label), a loop index, a nesting level, and lock variables.

When the contention detection result is received (S220), the height of the 3D cone is equally divided according to the analyzed nesting depth (S230). That is, after the three-dimensional cone is shown, the nesting depth information is read out and the height of the three-dimensional cone is equally divided accordingly.

FIG. 3 is a diagram illustrating a result of performing a cone visualization step included in the method illustrated in FIG. 2. 3 shows a parallel program with a nesting level of three. Since the nesting level is 3, the height of the cone shown is divided into three. At this time, if there are multi-way loops within each nesting level, a combo box indicates that multiple loops exist. As explained in the legend, in the case of multiple loops it is indicated by the down arrow, in the case of one-way loops it is indicated by bold dots. As such, the multiple loop and the one-way loop are illustrated using different symbols, so that the user can intuitively determine the existence of the multiple loop.

When the cone abstraction step is performed, the threads belonging to the same nesting level are visualized on the circumference located at the same height (S240).

4 is a diagram illustrating a result of performing a thread visualization step included in the method illustrated in FIG. 2. At this time, the threads are shown using different symbols, respectively, depending on whether they are scalable threads, non-access threads, and critical sections as shown in the legend. Therefore, the user can easily grasp the attributes of each symbol by easily reporting only the symbol of the thread shown.

However, the number of threads included in the same nesting level may be very large, in which case it may be impossible to show all the threads on a limited circumference. Alternatively, although it is possible to show all threads on a finite circumference, in this case it may be too complicated to grasp the attributes of each thread. Therefore, the visualization method according to the present invention determines whether vertical / horizontal abstraction is necessary to reduce the visual / spatial complexity of the illustrated POEG (S250). As a result of the determination, if the abstraction is necessary, vertical and horizontal abstraction steps S260 may be performed to fold and unfold one or more threads in the vertical and horizontal directions, respectively.

FIG. 5 is a diagram illustrating a result of performing a vertical abstraction step included in the thread visualization step illustrated in FIG. 2, and FIG. 6 is a diagram illustrating a result of performing a horizontal abstraction step.

모양으로 하고 부모 스레드가 단말 스레드이거나 부모 스레드가 포함하고 있는 자식 스레드들을 표현하고 있다면 추상화 된 부모 스레드의 원형 심벌 내에 -를 추가하여

모양으로 추상화한다. 전술된 바와 같이 원형 심벌의 둘레가 굵은 선이며 색이 입혀진 심벌은 추상화 된 스레드 내에 임계구역(critical section)을 포함하고 있다는 의미한다. In the vertical abstraction technique, a thread abstracts a thread into a circular symbol on a three-dimensional cone using an angle between threads. In this case, if the parent thread contains a child thread but does not indicate that the child thread is included to include whether it is an abstracted thread, add a + in the circle symbol of the abstracted parent thread.

If the parent thread is a terminal thread or represents a child thread that the parent thread contains, add a-to the circle symbol of the abstracted parent thread.

Abstract into shapes. As described above, the circular symbol is surrounded by a thick line and the colored symbol means that it includes a critical section in the abstracted thread.

The horizontal abstraction technique is intended to reduce the visual spatial complexity of threads represented on the same cone. Even though the threads are abstracted vertically on the cone, it is still possible to reduce the complexity of the thread by using a horizontal abstraction technique to represent multiple threads as a single thread because of the large visual space complexity. In other words, by adjusting the ratio of complexity, horizontally abstracted threads are displayed on the cone, not the entire thread. Referring to FIG. 5, the nesting level 2 is abstracted at 4: 1 ratio and the nesting level 3 is abstracted at 2: 1.

As can be seen from Figures 5 and 6, the present invention provides an environment that can intuitively detect contention by extensively visualizing the execution structure of the OpenMP program on a three-dimensional cone. The visualization of three-dimensional abstraction uses the concept of Partial Order Execution Graph (POEG) that can effectively express the parallelism between threads for the limitation of visualization. Extensive visualization uses abstraction techniques to reduce visual complexity. This technique solves visual complexity by replacing symbols with symbolic meanings for threads, access events, and synchronization that cause complexity.

When a thread is visualized, the threads in which access events for shared variables among the threads are generated are classified according to whether or not read and write access events occur and after the occurrence. Then, an access event visualization step of differentially visualizing each thread using different symbols according to the classified threads is performed (S270).

FIG. 7 is a diagram illustrating a result of performing an approach event visualization step included in the method illustrated in FIG. 2.

The access event visualization process is similar to the thread visualization process, except that the objects to be visualized are access events for shared variables. The types of access events are: non-access thread, which is a thread symbol where no read or write access occurred, read-first thread, which is the thread symbol in which a read access occurred first, and write-first thread, which is the thread symbol in which a write access occurred first. Etc. In the approach event visualization technique, the vertical abstraction technique and the horizontal abstraction technique may be applied in the same manner as in the thread visualization process. The vertical abstraction technique uses the + and-symbols as well as the functionality provided by thread abstraction.

The symbols used in the access event abstraction technique are illustrated in FIG. 8.

심벌은 스레드에 공유변수에 대한 접근사건이 발생하지 않은 스레드이며 자식 스레드들을 포함하고 있다. 내포수준 2에서 앞쪽에 있는

심벌은 스레드에서 공유변수에 대해서 쓰기접근사건이 먼저 발생한 것이고 둘레가 굵은 선이고 색이 입혀져 있기 때문에 임계구역 내에 추상화 된 쓰기 접근사건임을 알 수 있다. 그리고 색은 록 변수마다 다르다. 그리고 수평적 추상화 기법은 Thread 추상화에서 지원하는 수평적 추상화 기법과 동작원리는 동일하다. Referring to FIG. 7 with reference to the symbols illustrated in FIG. 8, the right-hand side at nesting level 1 of FIG. 7 is described.

A symbol is a thread that has never had access to a shared variable and contains child threads. Forward at nesting level 2

The symbol is a write access event that occurs first on the shared variable in the thread and is an abstract write access event within the critical area because of the thick line and the colored line. And the color is different for each lock variable. And the horizontal abstraction technique is the same as the horizontal abstraction technique supported by Thread abstraction.

9 is a block diagram conceptually illustrating a 3D visualization apparatus according to another aspect of the present invention.

As shown in FIG. 9, the 3D visualization apparatus 900 according to the present invention includes a cone visualization module 910, a thread visualization module 920, and an approach event visualization module 930.

Cone visualization module 910 shows a three-dimensional cone in the ratio of (1 / nesting depth * each level number) according to the nesting depth value obtained by analyzing the contention detection results. The pseudo code of the operation performed in the cone visualization module 910 is as follows.

for (a = 0; a <levelstore; a ++) {// each level number

:

glLightModelfv (GL_LIGHT_MODEL_AMBIENT, ambient); // light source function

glRotatef (90.0, 1.0, 0.0, 0.0); // position function

gluCylinder (Pencil Obj, 0.0, 1.0- (1.0 / levelstore * a), 1.0-1.0 / levelstore * a, 20, 2);

// draw cone-diameter 0, radius / height 1.0- (1.0 / levelstore * a), side 20 angle

}

※ nesting depth = levelstore, each level number = a

When the cone is shown, the thread visualization module 920 visualizes threads of the same nesting level among the plurality of parallel threads created during execution of the program on the circumference located at the same height of the cone. Here, the height is calculated using high [level] = (1.0 / levelmax) * (each level number) * (main cone high), and the angle is degree [level] = (360 / (each level thread total number)) Can be calculated using. Then, the position coordinate of each symbol shown is X: high [level] * cos (degree [level] * thread number), Y: high [level] * sin (degree [level] * thread number), and Z: high can be calculated as [level].

The pseudo code of the operation performed in the thread visualization module 920 is as follows.

if (lev [1] [0]! = 0) {

degree [1] = (3.141592) / 180 * (360 / lev [1] [0]); // angle (Level 1)

high [1] = (1.0 / levelstore); // height (Level 1)

:

glBegin (GL_LINES); // start thread figure

glVertex3f (0,0,0); // thread entry point

glVertex3f (high [1] * cos (degree [1] * b) +0.01, high [1] * sin (degree [1] * b) +0.01, high [1] -0.01);

glEnd (); // finish the thread endpoint and figure

:

glutSolidSphere (0.043,20,20); // representation of sphere as non-access symbol

Once the threads are visualized, the access event visualization module 930 classifies and differentially shows each thread. Here, the position coordinates of the symbol shown are the same as the value calculated by the thread visualization module 920, but the access event visualization module 930 divides the illustrated thread into read-first, write-first symbols, and the like. .

Pseudo code representing an action performed in the access event visualization module 930 is as follows.

if (lev [1] [0]! = 0) {

degree [1] = (3.141592) / 180 * (360 / lev [1] [0]); // angle (Level 1)

high [1] = (1.0 / levelstore); } // height (Level 1)

:

glBegin (GL_LINES); // start thread figure

glVertex3f (0,0,0); // thread entry point

glVertex3f (high [1] * cos (degree [1] * b) +0.01, high [1] * sin (degree [1] * b) +0.01, high [1] -0.01);

glEnd (); // finish the thread endpoint and figure

:

redraw (); // Read-first, Write-first symbol instead of Non-Access

As described above, the present invention is a tool that can visualize data contention generated in an OpenMP program in three dimensions with optimal function and performance.

According to the present invention, it is possible to logically understand the execution structure of a parallel program by using an extended visualization tool using an abstract concept. Also, if you look at the recent development of the CPU, the trend is moving from Pentium 4 with single core to Pentium D with dual core. This could be interpreted to mean that parallel computing is desperately needed. Errors occurring in such parallel computing are harder to detect than errors occurring in sequential programs, and even when errors are detected, debugging will be difficult. This will require a lot of time and effort to detect and debug errors that occur in parallel programs. In this regard, the tools proposed in this study will have a significant impact in the development of these tools. First, the theoretical part of the tool can be used in fields that improve performance in a parallel computing environment or require visual results. And the technical part can actively support industry standardization of debugging tools for standardized OpenMP programs.

Although the present invention has been described with reference to the embodiments shown in the drawings, this is merely exemplary, and it will be understood by those skilled in the art that various modifications and equivalent other embodiments are possible.

Therefore, the true technical protection scope of the present invention will be defined by the technical spirit of the appended claims.

The present invention can be applied to the field of debugging of parallel programs.

1A is pseudo code for explaining contention of threads in a parallel program.

FIG. 1B is a diagram illustrating a POEG when the pseudo code shown in FIG. 1A is executed.

2 is a flowchart conceptually illustrating a method for visualizing an approach of an OpenMP program on an extended three-dimensional cone according to one aspect of the present invention.

FIG. 3 is a diagram illustrating a result of performing a cone visualization step included in the method illustrated in FIG. 2.

4 is a diagram illustrating a result of performing a thread visualization step included in the method illustrated in FIG. 2.

FIG. 5 is a diagram illustrating a result of performing a vertical abstraction step included in the thread visualization step illustrated in FIG. 2.

FIG. 6 is a diagram illustrating a result of performing a horizontal abstraction step included in the thread visualization step shown in FIG. 2.

FIG. 7 is a diagram illustrating a result of performing an approach event visualization step included in the method illustrated in FIG. 2.

8 is a diagram illustrating symbols used in an access event abstraction technique.

9 is a block diagram conceptually illustrating a 3D visualization apparatus according to another aspect of the present invention.

Claims (14)

In a method for visualizing an OpenMP program's approach on an extended three-dimensional cone, Receiving a contention detection result for the program; A cone visualization step of analyzing the contention detection result to obtain a nesting depth of the program, visualizing a three-dimensional cone, and then dividing the height of the three-dimensional cone to correspond to the nesting depth; A thread visualization step of visualizing a thread of the same nesting level among a plurality of parallel threads generated during execution of the program on a circumference located at the same height of the cone; And Analyzing the contention detection result, classifying the occurrence of access events to the shared variable among the threads according to whether or not the read and write access event occurs and the occurrence of the occurrence, and visualize the classified threads to distinguish from each other Method comprising a. The method of claim 1, wherein the cone visualization step, Determining whether a multi-way loop exists within each nesting level; And And indicating at the nesting level whether the multiple loops are present. The method of claim 1, wherein the thread visualization step, Determining a thread comprising a critical section of the threads, and marking the thread including the critical section to be distinguished in different colors according to a lock variable. The method of claim 3, wherein the thread visualization step, Determine the distance between the threads based on the concurrency between the parallel threads, respectively mark the threads spaced apart by the determined distance on the cone, and distinguish a parent thread, including a child thread, of the threads from a child thread. And further comprising a vertical abstraction step of displaying. The method of claim 3, wherein the thread visualization step, And a horizontal abstraction step of representing a predetermined number of threads of the threads located on the same cone on the cone as one thread. The method of claim 1, wherein the approach event visualization step, Classifying the threads into threads for which no access event has occurred, threads for which a read access event occurs before a write access event, and threads for which a write access event occurs before a read access event, respectively; And Displaying the sorted threads so as to be distinguished from each other. The method of claim 1, wherein the approach event visualization step, Classifying the threads into threads for which no access event has occurred, threads for which a read access event occurs before a write access event, and threads for which a write access event occurs before a read access event, respectively; And Displaying the sorted threads so as to be distinguished from each other. A recording medium for recording a computer program comprising instructions for implementing the method according to any one of claims 1 to 7. Apparatus for visualizing an approach of an OpenMP program on an extended three-dimensional cone, A user interface for receiving a contention detection result for the program; A cone visualization module for analyzing the contention detection result to obtain a nesting depth of the program, visualizing a three-dimensional cone, and then dividing the height of the three-dimensional cone to correspond to the nesting depth; A thread visualization module for visualizing a thread of the same nesting level among a plurality of parallel threads generated during execution of the program on a circumference located at the same height of the cone; And Access event visualization module that analyzes the contention detection result and classifies threads in which access events to a shared variable among the threads occur according to whether or not read and write access events occur, and visualizes the classified threads to be distinguished from each other. Apparatus comprising a. The method of claim 9, wherein the cone visualization module, And determining whether a multi-way loop exists within each nesting level, and indicating whether the multi-loop exists. The method of claim 9, wherein the thread visualization module, Determine a thread comprising a critical section of the threads, and further display the thread including the critical section to be distinguished in different colors according to a lock variable. The method of claim 11, wherein the thread visualization module, Determine the distance between the threads based on the concurrency between the parallel threads, respectively mark the threads spaced apart by the determined distance on the cone, and distinguish a parent thread, including a child thread, of the threads from a child thread. And a vertical abstraction module for displaying. The method of claim 11, wherein the thread visualization module, And a horizontal abstraction module for displaying a predetermined number of threads of the threads located on the same cone on the cone as one thread. The method of claim 9, wherein the approach event visualization module, The threads are classified into a thread in which an access event does not occur, a thread in which a read access event occurs before a write access event, and a thread in which a write access event occurs before a read access event, respectively, and further display the classified threads to be distinguished from each other. Device characterized in that.

Images