KR20110069259A - Parallel collision detection method based on inter conllision detection and computer readable media thereof - Google Patents

Abstract

PURPOSE: A parallel collision detection method based on inter collision detection and a computer readable media thereof are provided to minimize the locking by distributing the task efficiently when the collision detection of an object is executed using a plurality of threads. CONSTITUTION: The bounding volume hierarchy(BVH) for objects is created based on the geometric information of objects(S110). The main BVH is created based on the BVHs of the objects (S120). The subtrees in which the reciprocity irrelevant nodes are the root are extracted from the main BVH(S130). The nodes composed in the subtrees are distributed to each of threads(S140). An inter collision test pair set(ICTPS), which is a set of the node pairs composed in the subtrees, are created for performing the collision detection between the objects for the parent node of the nodes(S150).

Description

PARALLEL COLLISION DETECTION METHOD BASED ON INTER CONLLISION DETECTION AND COMPUTER READABLE MEDIA THEREOF}

The present invention relates to image processing, and more particularly, to collision detection of an object in an image.

Collision detection of objects refers to collisions between two objects represented as geometric data (inter-collision) or collisions of two parts of an object (magnetic collision, intra-collision or self-collision) in a virtual world of geometric data. ) Means detecting. In general, it uses hierarchical data structures such as bounding volume hierarchies (BVH) and KD-Tree for efficient collision detection, and mathematical methods to check for collisions between elementary polygons constituting an object. Use Collision checking methods can be divided into discrete and continuous detection methods. Accurate collision checking requires continuous collision checking, but has a disadvantage of requiring a large amount of computation.

 Many methods have been proposed to overcome the shortcomings of such continuous collision checking, and parallel processing algorithms using a multicore CPU or a graphics processor are also presented. However, the existing parallel processing algorithms use only one of a multicore CPU or a GPU, and are not sufficient in terms of performance (speed) for use in a field requiring real time processing.

 When collision checking is performed using multiple cores simultaneously in an environment using hierarchical data structures such as BVH, two or more threads may access the same data while updating and searching data structures. Locking mechanisms are used to prevent such invalid data access and update. The locking mechanism means that when one thread accesses data, the other thread blocks access. In this case, the blocked thread waits without processing another task until the access is released.

 Existing multi-core collision detection methods use this locking mechanism and thus do not use the available cores to the maximum. This problem is exacerbated by the locality of the collision, which means that the collision tends to be concentrated in one part, and with the use of multicore.

An object of the present invention is to provide a collision checking method that can ensure high scalability of the collision checking method when the speed is improved and the number of threads of the CPU is increased.

Another object of the present invention is to provide a collision checking method in which the speed of collision checking is improved as the number of CPU threads increases.

In addition, an object of the present invention is to provide a collision inspection method that can minimize locking through an efficient work distribution method in performing an object collision inspection using a plurality of threads.

The invention of claim 1 is a method for detecting a collision between objects included in a scene performed in a computer system, comprising: bounding volume hierarchies for each of the objects based on geometrical information of the objects; Generating a main BVH based on the BVHs of the respective objects, extracting a plurality of subtrees rooted at nodes having mutual independence in the main BVH, the plurality of subs Distributing nodes configured in the tree to a plurality of threads, and performing object-to-object collision checking on a parent node having nodes configured in the plurality of subtrees as child nodes. Generating an inter collision test pair set (ICTPS) that is a set of configured node pairs.

The invention of claim 2 is characterized in that the elementary polygon included in the main BVH is a triangle.

The present invention of claim 3, wherein the requesting thread of the plurality of threads makes a task redistribution request to a distributing thread, and the distributing thread gives the requesting thread information on the collision checking target polygon allocated to itself by the task redistribution request. The request thread means a thread that finishes its task among the plurality of threads and no longer has a task, and the distribution thread means a thread having a task among the plurality of threads.

The invention of claim 4 is a computer readable medium carrying a program executable by a computer, wherein the program is a method of detecting a collision between objects included in a scene executed in a computer system. A program for executing a collision detection method according to any one of the inventions.

According to the present invention, the speed of the collision checking operation can be improved, and the high scalability of the collision checking method can be ensured when the number of threads of the CPU increases.

In addition, according to the present invention, as the number of threads of the CPU increases, the speed of collision checking is improved.

In addition, when performing object collision check using a CPU having a plurality of threads, it is possible to avoid locking in a core loop and to effectively distribute tasks.

The present invention includes a new task distribution method that efficiently distributes hierarchical data structure update and search operations to CPU threads.

In the present invention, the following method can be used to solve the problems of the existing technology.

1) Multicore CPUs can be used to create, update, and search hierarchical data structures.

2) Tasks can be divided and allocated to each thread so that hierarchical data structures can be updated and searched by multiple CPU threads without a locking mechanism.

3) In order to maximize the utilization of multiple CPU cores, a task can be able to send and receive tasks at low cost between many threads and fewer threads.

Hereinafter, with reference to the accompanying drawings will be described in detail the present invention. In the description of the present invention, if the known technology is a part of the configuration of the present invention, a detailed description thereof will be omitted. Even so, those skilled in the art will be able to correctly understand and easily reproduce the present invention.

[Example]

1 is a flow chart of a collision detection method according to an embodiment of the present invention. A collision detection method according to an embodiment of the present invention relates to a method for detecting a collision between two objects included in a scene or a collision between two parts in an object, which is performed in a computer system, and more specifically, an object. Task distribution method for collision detection between. Wherein the computer system may comprise a CPU.

First, in a first step S110, bounding volume hierarchies (hereinafter referred to as BVH) of each object are generated from the geometric information of the objects included in the scene. BVH is a technique used for acceleration in continuous collision checking, which is a data structure representing a bounding volume (BV) hierarchically (for example, in a tree structure). Bounding volume refers to an area surrounding some or all of the volume of an object. Several types of bounding volumes are known, and the following description assumes the use of the most widely used axis-aligned bounding boxes (AABBs). Although not AABB, the present invention may also be implemented using BVs such as spheres, oriented bounding boxes (OBBs), etc. In summary, BVH divides objects contained in the scene into bounding volumes, Repeated division of the bounding volume into multiple (e.g., two) bounding volumes, resulting in a hierarchical data structure that finally breaks the bounding volume into underlying polygons, based on the end node if BVH is a tree structure. Polygons will exist.

In step S120, one main BVH is generated from the BVH of each object. One main BVH may be created by adding upper nodes that bind root nodes of respective BVHs. By doing so, it is possible to treat collisions between objects in the same way as collisions inside objects while treating several objects as one object.

Although not shown, the BVH may be updated when the object model is being deformed. As a method of updating the BVH, a selective reconstruction method of regenerating only a portion that needs to be regenerated and updating only a portion that is not necessary may be used. The specific method is described in [YCM07] YOON S., CURTIS S., MANOCHA D .: Ray tracing dynamic scenes using selective restructuring. Eurographics Symp. on Rendering (2007), 73-84. The method disclosed in 3 can be used. The whole or part of the BVH may be updated from time to time, and the BVH may be selectively reconfigured as needed.

Then, in step S130, a plurality of subtrees having mutual independence at one main BVH are extracted. To do this, first replace the collision detection within the object with the collision detection between objects. To represent this, as shown in FIG. 2, assuming that there is no one parent node N in the hierarchical data structure representing an object, child nodes A and B that are immediately below the parent node N are each object. The collision between the child nodes A and B becomes the same as the collision inspection between objects. As such, the child nodes A and B assumed for collision checking between objects become one subtree, and have mutually independent relations.

Mutual independence is that if the objects that make up the two collision tests have no parent-child relationship on the hierarchical data structure, the nodes visited during the collision check are not overlapped. For example, as shown in FIG. 3, the objects C, D, E, and F do not have parent-child relationships with each other, and thus, a subtree having (C, D) as the root node and (E, F) as the root node. During collision checking between objects between subtrees, the nodes approaching each other are completely independent. As another example, nodes n4, n5, n6, and n7 shown in FIG. 4 have mutual independence. If mutually independent properties are established between allocated nodes, BVH can be searched using Lazy BVH reconstruction without using a locking mechanism. Lazy BV reconstruction means that updating a node's state to the current state is performed when the node is first visited during a hierarchy search. Locking is necessary because the update operation of a node requires a write operation. However, according to the task distribution method using mutual independence proposed by the present invention, a locking mechanism needs to be used because multiple threads do not visit a node. There is no.

To ensure that there is no correlation between the nodes that are initially allocated, breadth-first searches can be performed to extract the number of available threads for nodes that satisfy this property. For example, as shown in FIG. 4, when the number of available threads is four, it is possible to select nodes whose number of nodes having the same depth is four at the root of the BVH. The selected nodes n4, n5, n6, and n7 and their child nodes are called low-level nodes, and the rest are called high-level nodes. That is, in the example of FIG. 4, n1, n2, n3 are high-level nodes and the rest are low-level nodes.

Then, in step S140, task distribution is performed to process the object-to-object collision check for each parent node having nodes configured in the plurality of subtrees as child nodes. At this time, the nodes configured in the plurality of subtrees are allocated to the plurality of CPU threads, respectively. For example, referring to FIG. 4, when the extracted subtrees are composed of n4, n5, n6, and n7 root nodes, each node is allocated to CPU threads (Thread 1, Thread 2, Thread 3, Thread 4), respectively. Can be. That is, n4 may be assigned to Thread 1, n5 to Thread 2, n6 to Thread 3, and n7 to Thread 4. This process corresponds to the initial distribution process of the collision detection task, after which the dynamic task redistribution may be additionally performed. The dynamic task redistribution will be described later.

Next, in step S150, to perform collision checking between the parent nodes, an inter collision test pair set (ICTPS), which is a set composed of pairs of child nodes, is generated. Referring to FIG. 4, in the case of processing ICTPS for a parent node n2 (ICTPS (n2)) (S151), since ICTPS (n2) is a collision check between a child node n4 of n2 and a subtree having n5 as a root, In operation S152, a set of node pairs composed of n4 or n5 nodes may be generated. In addition, in the case of ICTPS n3 (S151), a set of node pairs composed of the child nodes n6 or n7 of n3 may be generated (S152). These ICTPS can be processed simultaneously by multiple CPU threads.

The above steps can be processed in the CPU.

Thereafter, collision checking may be performed based on TCTPS through the GPU.

As described above, by processing a plurality of subtrees that are independent of each other using a plurality of CPU threads, the speed of collision checking may be improved as the number of CPU threads increases.

Dynamic task reassignment

When using multiple threads, dynamic task redistribution can be used to most efficiently use CPU resources.

The task is to quickly finish its task among multiple threads, call a thread that no longer has a task, and call a thread that has enough tasks. Select a thread with a large number of tasks among the nodes in the front of the task unit queue (here, a subtree of nodes with mutual independence) referred to as the front node. do. Accordingly, the request thread makes a task redistribution request.

Next, when the distribution thread is selected, the distribution thread is dynamic task redistribution by giving the front thread to the requesting thread by the task redistribution request of the requesting thread. The theoretical basis of this dynamic task distribution method is that all nodes in the task unit queue satisfy mutual independence. The reason for giving the front node of the task unit queue to the request thread is that there are the most tasks in the front tree's subtree. Using this dynamic task redistribution, up to seven times better performance can be achieved using eight CPU cores.

The request thread enters a task request message into the scheduling queue of the distribution thread. The locking of the distribution thread is required to access the scheduling queue of the distribution thread. However, since multiple threads rarely access the scheduling queue of the same thread, it does not affect performance. After entering the request message into the scheduling thread of the distribution thread, the request thread goes to sleep.

Each thread checks its own scheduling queue after one collision check. If there is a task distribution request, the front node of the task unit queue is provided to the requesting node. It then sends a wake-up message to the requesting thread that is sleeping, and when the requesting thread receives the wake-up message, it can resume collision checking.

According to the present invention, it is possible to improve the speed of the collision checking operation and ensure high scalability of the collision checking method when the number of threads of the CPU increases.

In addition, as the number of threads of the CPU increases, the speed of collision checking may be improved.

In addition, when performing object collision check using a CPU having a plurality of threads, it is possible to avoid locking in a core loop and to effectively distribute tasks.

The collision detection method described above can be implemented as a computer readable medium on which a program capable of executing the method by a computer is mounted. Therefore, it is understood that a program storage device such as a floppy disk, a CD-ROM, a RAM, an EEPROM, a microprocessor, a magneto-optical disk, a hard disk, and the like, including a program capable of executing the above-described collision detection method, also belongs to the scope of the present invention. Should be.

As described above, those skilled in the art will understand that the present invention can be implemented in other specific forms without changing the technical spirit or essential features.

Therefore, the above-described embodiments are to be understood as illustrative and not restrictive in all respects, and the scope of the present invention is indicated by the appended claims rather than the foregoing description, and the meaning and scope of the claims and All changes or modifications derived from the equivalent concept should be interpreted as being included in the scope of the present invention.

1 is a flow chart of a collision detection method according to an embodiment of the present invention.

2 conceptually illustrates a method of replacing an intra-object collision test with an inter-object collision test;

3 is a diagram for explaining mutual independence between nodes;

4 is a diagram for explaining a method of distributing a BVH tree structure and an initial task.

5 is a block diagram of a computer system in which a collision detection method according to the present invention is performed and a diagram illustrating a data transmission path between the components thereof.

Claims (4)

A method for detecting a collision between objects included in a scene, performed in a computer system, Generating bounding volume hierarchies (BVH) for each of the objects based on the geometric information of the objects; Generating a main BVH based on BVHs of the respective objects; Extracting a plurality of subtrees rooted at nodes having mutual independence in the main BVH; Distributing nodes configured in the plurality of subtrees to a plurality of threads, respectively; And Generating an inter-collision test pair set (ICTPS), which is a set of node pairs configured in the plurality of subtrees, in order to perform an object-to-object collision test for a parent node having nodes configured in the plurality of subtrees as child nodes; Collision detection method comprising a. The method of claim 1, And wherein the elementary polygon contained in the main BVH is a triangle. The method of claim 1, The requesting thread of the plurality of threads makes a task redistribution request to the distribution thread, The distribution thread, by the task redistribution request, gives the request thread the information of the collision checking target polygon allocated to itself, The request thread, Means a thread that finishes its own task of the plurality of threads and no more tasks, The distribution thread, A collision checking method, meaning a thread having a task among a plurality of threads. A computer readable medium carrying a program executable by a computer, The program, A computer-readable medium in a computer system, a program for executing a method of detecting a collision according to any one of claims 1 to 3 as a method for detecting a collision between objects included in a scene.

Images