KR102509751B1 - Method and Apparatus for Rapidly Designing all Valid Primers that Simultaneously Satisfy Primer Restriction Condition and Specificity Condition in Large DNA Sequence Database using GPU - Google Patents

Abstract

A method and apparatus for rapidly designing all effective primers that simultaneously satisfy primer restriction conditions and specificity conditions in a large-scale DNA sequence database using a GPU are provided. An apparatus for rapidly designing all valid primers that simultaneously satisfy primer restriction conditions and specificity conditions in a large-scale DNA sequence database by utilizing GPU according to an embodiment is a GPU primer to determine primer restriction conditions and specificity conditions in a DNA sequence database. The entire operation is performed to design effective primers that satisfy the same requirements, the data structure including the hash map generated during the operation is stored in the main memory, and the DNA sequence database and candidate primers used as initial input are recorded. In the case of a file in the middle process to be stored in the form of a file on a separate hard disk, the CPU reads and uses it if necessary; And when a large-scale operation is required, it is driven by receiving commands for some operations of the GPU primer through the CPU, and the GPU memory receives data necessary for operation from the main memory, performs kernel operation, and then performs kernel operation as a result. It can be made by including a GPU to copy back to the main memory for.

Description

Method and Apparatus for Rapidly Designing all Valid Primers that Simultaneously Satisfy Primer Restriction Condition and Specificity Condition in Large DNA Sequence Database using GPU}

The following examples relate to a method and apparatus for designing primers, and more particularly, by satisfying various filtering constraints given by a user for a given large-scale sequence database and performing a homology test on its own. It relates to a method and apparatus for rapidly and efficiently designing all valid primer pairs whose specificity has been verified using a GPU.

Polymerase Chain Reaction (PCR) is a method that can amplify a portion of target DNA in large quantities in vitro, and is widely used in hospitals, research institutes, universities, etc. that perform related biological experiments. In particular, quantitative PCR (qPCR), also known as real-time PCR (RCR), is a basic technique widely used to simultaneously detect the amplification and quantity of DNA molecules by monitoring the product of a specific DNA molecule in real time during the PCR process. It is used in many areas, such as virus detection, genetically modified organism (GMO) detection, and forensic analysis through genetic fingerprinting and paternity confirmation. In addition, in order to obtain good results in such experiments related to qPCR, it is very important to design primers suitable for the target sequence. A primer is a short gene sequence that serves as a starting point for DNA synthesis, and is essential for DNA sequencing or PCR experiments.

1 is a view showing a state in which a general forward primer and a reverse primer are bound to a DNA target sequence. More specifically, FIG. 1 shows that a Forward Primer 205 and a Reverse Primer 203 are respectively applied to the separated DNA strand 202 to form a forward template 201 and a reverse template of each target. (207) shows an example in which DNA polymerase is formed by complementary binding.

As shown in FIG. 1, new forward strands 206 and reverse strands 204 on both sides are synthesized in the 5' to 3' direction, and as shown in the figure, in order to synthesize a specific sequence, forward primers 205 and reverse A pair of primers 203 are required.

In general, high-quality primers used in the synthesis process not only have to satisfy the Single/Pair Primer Filtering condition for the primer or primer pair, but also a homology test to prevent amplification of off-target sequences. (Homology Test) must also be performed to verify specificity. Constraints in designing primers include single primer filtering conditions and pair primer filtering conditions. The single primer filtering conditions include primer length, temperature (℃), GC There are content (%), Self-Complementarity, 3' End Self-Complementary, consecutive bases, and end stability (G value). Pair Primer Filtering conditions include length difference, temperature difference, product length, pair -Complementary, 3' End Pair-Complementary.

Since designing primers by hand while considering the above-mentioned Single Primer Filtering conditions and Pair Primer Filtering conditions is time-consuming and may cause incorrect results, the above-mentioned conditions are not considered. A number of automated methods have been devised to take into account and design appropriate primers.

However, conventional techniques for designing primers generally fail to simultaneously verify specificity necessary for high-quality primer design in addition to the above-mentioned primer design constraints. Therefore, conventional methods have a limitation in that an additional homology check process using a tool such as BLAST is additionally required to verify this specificity. In particular, it is more difficult to simultaneously design a plurality of primers that satisfy strict constraints on a large-scale DNA sequence database and pass specificity verification, rather than primers for one target DNA sequence.

MRPrimer, developed in this regard, is based on Hadoop's MapReduce framework to design optimal primers by searching for primers that satisfy the above-mentioned primer constraints in the DNA sequence database and at the same time performing specificity verification. It is a pipeline that can Since the specificity of the primers output through these MRPrimers has also been experimentally verified, they are used as a base algorithm for websites that help primer design, such as MRPrimerW and MRPrimerV.

However, the MRPrimer pipeline has a weakness in that it is computationally slow to process large DNA sequence databases. In fact, MRPrimer took more than two weeks for 101,684 human gene sequence data, despite using 40 supercomputers at the time. At present, when the size of sequence databases is rapidly increasing with the development of sequencing technology, the limitation of computational speed is bound to become a bigger weakness in the long term. Therefore, the speed required for primer design as well as the quality of primers is a very important factor.

Korean Patent Registration No. 10-1666506 describes a method for designing all effective primers satisfying specificity conditions for such a large-scale DNA sequence database.

Korean Patent Registration No. 10-1666506

The present embodiments are intended to solve the problems according to the prior art, and satisfy various filtering constraints given by the user for a given large-scale sequence database and perform a homology test on its own to determine its specificity. It is to provide a fast and efficient way to design all of these validated valid primer pairs using GPUs.

Looking at the specific solution to the problems mentioned in the prior art, first, the problem of specificity verification through homology inspection while examining the constraints on the primer, which is a problem in the prior art, can be solved through MRPrimer.

However, MRPrimer uses a distribution-based pipeline, which can cause unnecessary overhead for data sharing between machines, and MRPrimer also uses large-scale DNA sequence data to perform specificity tests on all possible primers. The problem is that it takes too much time.

In order to reduce overhead, which is the first problem, the present embodiments may perform calculations using only one machine rather than a distributed system.

In addition, in order to solve the second problem in the prior art, the speed limit for primer design, the present embodiments utilize the characteristics of parallel operation and fast operation speed of GPUs to design primers more quickly and efficiently, and increase the operation speed. Several techniques are available for acceleration. However, since using the GPU also involves data copy overhead between the main memory and the GPU memory, the GPU is not used for all the processes of the present embodiments, and the GPU is used only for the steps that take the most time, For other steps, the CPU's multi-thread operation can be utilized.

An apparatus for rapidly designing all valid primers that simultaneously satisfy primer restriction conditions and specificity conditions in a large-scale DNA sequence database by utilizing GPU according to an embodiment is a GPU primer to determine primer restriction conditions and specificity conditions in a DNA sequence database. The entire operation is performed to design effective primers that satisfy the same requirements, the data structure including the hash map generated during the operation is stored in the main memory, and the DNA sequence database and candidate primers used as initial input are recorded. In the case of a file in the middle process to be stored in the form of a file on a separate hard disk, the CPU reads and uses it if necessary; And when a large-scale operation is required, it is driven by receiving commands for some operations of the GPU primer through the CPU, and the GPU memory receives data necessary for operation from the main memory, performs kernel operation, and then performs kernel operation as a result. It can be made by including a GPU to copy back to the main memory for.

Design effective primers that simultaneously satisfy primer restriction conditions and specificity conditions in the DNA sequence database through the CPU and the GPU, and single primer filtering conditions and pair primer filtering with the DNA sequence database given by the CPU ( A first step of generating and outputting candidate primers by extracting subsequences between a minimum length and a maximum length by receiving conditions of Pair Primer Filtering; a second step of applying the single primer filtering condition received to the output candidate primers and generating a hash map, which is a data structure to be used for calculation, using primers satisfying the condition; Pair-joining is performed based on the C1' file recording the extracted subsequences and the primers stored in the hash map through the second step, and when the remaining parts of the primers are the same except for the 5' end, the A third step of updating a valid value in the hash map of the primer; A data structure to be used in GPU operation is created using the C1' file recording the extracted subsequences and a set of candidate primers that have passed the Single Primer Filtering and 5' Cross-Hybridization Filtering, and paired in the GPU. a fourth step of performing a join and updating valid values of the primers in the hash map when the primers in each candidate primer set are identical except for the given mismatch number (#mismatch); and dividing the remaining primers from the result of the fourth step into a forward primer and a reverse primer set, respectively, to create a data structure for each, and performing a self-join operation in the GPU to determine the Pair Primer Filtering condition. A fifth step of applying , calculating and outputting penalty scores for primer pairs satisfying the condition, and sequentially sorting according to the penalty scores within the same sidset group can be performed.

The CPU, in the first step, receives the sequence number sid and the sequence data S in the form of a pair of sid + S from the DNA database, and receives the filtering conditions to be used later, and inputs the filtering conditions between all possible minimum lengths and maximum lengths. Candidate primers are generated by extracting the subsequence, reverse complementary primers are created for the output candidate primers, and reverse primers are extracted when displayed, and sidset, which is a set of sids in which the same primers appear, can be generated.

The CPU may apply a plurality of single primer filtering conditions in the second step to generate and store the hash map only for the primers satisfying the condition.

, GC content(%), Self-Complementarity, 3' End Self-Complementary, 연속된 염기 및 end stability(G value)일 수 있다. The plurality of single primer filtering conditions are length, temperature (

, GC content (%), Self-Complementarity, 3' End Self-Complementary, consecutive bases, and end stability (G value).

The GPU copies the data structure to be used in the GPU operation generated in the fourth step and performs a pair join of arraysC1 and arraysC3, and the primers in each set are the same except for the number of mismatches (#mismatch) given, It can be updated to indicate 'not valid' for the primers in arraysC3.

The GPU divides each of the forward primer and reverse primer sets generated in the fifth step, copies the data structure for each, and performs a pair-join operation between the forward primer and the reverse primer within the same sid in the GPU, The penalty score is calculated and stored only for primers that satisfy the condition by applying the Pair Primer Filtering condition, and the data structure in which the penalty score is stored is copied to the main memory to output the result. .

A method for designing effective primers that simultaneously satisfy primer restriction conditions and specificity conditions in a DNA sequence database using a GPU implemented through a computer device according to another embodiment is a given DNA sequence database and single primer filtering (Single Primer Filtering) A first step of generating and outputting candidate primers by extracting subsequences between a minimum length and a maximum length by receiving input conditions and pair primer filtering conditions; a second step of applying the single primer filtering condition received to the output candidate primers and generating a hash map, which is a data structure to be used for calculation, using primers satisfying the condition; Pair-joining is performed based on the C1' file recording the extracted subsequences and the primers stored in the hash map through the second step, and when the remaining parts of the primers are the same except for the 5' end, the A third step of updating a valid value in the hash map of the primer; A data structure to be used in GPU operation is created using the C1' file recording the extracted subsequences and a set of candidate primers that have passed the Single Primer Filtering and 5' Cross-Hybridization Filtering, and pair-joined in the GPU. A fourth step of updating the valid value of the primers in the hash map when the primers in each candidate primer set are the same except for the given number of mismatches (#mismatch) by performing; and dividing the remaining primers from the result of the fourth step into a forward primer and a reverse primer set, respectively, to create a data structure for each, and performing a self-join operation in the GPU to determine the Pair Primer Filtering condition. A fifth step of applying , calculating and outputting penalty scores for primer pairs satisfying the condition, and sequentially sorting according to the penalty scores within the same sidset group.

In the first step, the DNA database receives the sequence number sid and the sequence data S in the form of a pair of sid + S, receives the filtering conditions to be used later, and receives all possible minimum and maximum lengths of the subsequence Extracting and generating candidate primers; and making reverse complementary primers for the output candidate primers, and extracting the reverse primers if indicated, and generating a sidset, which is a set of sids in which the same primers appear.

In the second step, a plurality of single primer filtering conditions may be applied to generate and store the hash map only for the primers satisfying the condition.

, GC content(%), Self-Complementarity, 3' End Self-Complementary, 연속된 염기 및 end stability(G value)일 수 있다. The plurality of single primer filtering conditions are length, temperature (

, GC content (%), Self-Complementarity, 3' End Self-Complementary, consecutive bases, and end stability (G value).

In the third step, a pair join is performed from the C1' file in which all possible subsequences extracted from a given DNA sequence database are stored and the hash map in which candidate primers that have passed the single primer filtering are stored, If the primers of each set are identical except for the 5' end, the primers stored in the hash map may be updated to indicate 'not valid'.

In the fourth step, generating another hash map by dividing the primers into several seeds from the hash map in which the primers that have passed both Single Primer Filtering and 5' Cross-Hybridization Filtering are stored; Data structure arraysC3 having information on primers that have passed both the Single Primer Filtering and 5' Cross-Hybridization Filtering from the another hash map and information on all possible subsequences extracted from a given DNA sequence database Creating a data structure arraysC1 having; And copying the generated data structure to the GPU to perform a pair join of arraysC1 and arraysC3, and when the primers in each set are the same except for the given number of mismatches (#mismatch), 'not valid' for the primers in arraysC3 It may include updating to indicate.

The fifth step may include grouping candidate primers having the same sid and arranging them in descending order of the number of primers; Receives the sorted file as an input and separates the candidate primers into two sets of forward and reverse primers according to the presence or absence of the mark performed when extracting the candidate primers from the DNA sequence database, creates a data structure to be used for GPU operation for each set, and stores penalty scores. Creating a data structure that can be; Copy the generated data structure to the GPU, perform a pair-join operation between forward primers and reverse primers within the same sid in the GPU, and apply a plurality of the pair primer filtering conditions to satisfy the condition calculating and storing the penalty score only for the primer; and copying the data structure in which the penalty score is stored to a main memory, outputting the result, grouping based on the same sidset, and assigning an order to primer pairs using the penalty score in each sidset.

The plurality of pair primer filtering conditions may include length difference, temperature difference, product length, Pair-Complementary, and 3' End Pair-Complementary.

According to the embodiments, it is possible to quickly design primer pairs of all valid coverages that satisfy various filtering constraints given by the user for a given large-scale DNA sequence database and whose specificity has been verified using a GPU.

In addition, according to the embodiments, the primer design is checked for Single / Pair Primer Filtering conditions and the homology test in one integrated method, so that the user does not have to use additional tools. Therefore, mistakes do not occur in the validation process and primers can be designed efficiently.

1 is a view showing a state in which a general forward primer and a reverse primer are bound to a DNA target sequence.
2 is a diagram showing a system configuration diagram according to an embodiment.
3 is a flowchart illustrating a method of designing effective primers that simultaneously satisfy primer restriction conditions and specificity conditions in a DNA sequence database using a GPU according to an embodiment.
4 is a flowchart illustrating a method of extracting candidate primers according to an embodiment.
5 is a diagram illustrating examples of a C1 file and a C1' file according to an embodiment.
6 is a flowchart illustrating a method for generating a hash map for primers satisfying a single primer filtering condition according to an embodiment.
7 is a flowchart illustrating a 5' Cross-Hybridization Filtering method according to an embodiment.
8 is a flowchart illustrating a method of generating {seedH, arraysC1, arraysC3} and general cross-hybridization filtering according to an embodiment.
9 is a diagram illustrating an example of generating {seedH, arraysC1, arraysC3} and general cross-hybridization filtering according to an embodiment.
10 is a diagram illustrating an example of a data flow and a timeline in a method of generating {seedH, arraysC1, arraysC3} and general cross-hybridization filtering according to an embodiment.
11 is a flowchart illustrating a pair filtering and scoring method according to an embodiment.
12 is a diagram illustrating an example of a primer sequence alignment method according to an embodiment.

Hereinafter, embodiments will be described with reference to the accompanying drawings. However, the described embodiments may be modified in many different forms, and the scope of the present invention is not limited by the embodiments described below. In addition, several embodiments are provided to more completely explain the present invention to those skilled in the art. The shapes and sizes of elements in the drawings may be exaggerated for clarity.

The following examples satisfy various filtering constraints given by the user for a given large-scale DNA sequence database and perform a homology test on its own to find all valid primer pairs whose specificity has been verified by GPU. Provides a method and device for designing quickly and efficiently using

As a result of the experiments of these examples, a total of 816,034,287 primer pairs were designed through experiments on 138,375 total mRNA RefSeq (NCBI Reference Sequence) data from six species, including humans and mice.

To describe the above results in more detail, 278,147,461 primer pairs were designed for 51,979 human mRNA sequence data, and 234,410,464 primer pairs were designed for 35,349 mouse mRNA sequence data.

In terms of efficiency of GPU utilization, the present examples show that it is possible to design all possible primer pairs in a human RefSeq sequence database in 2 hours when using a single machine with 4 NVIDIA GTX 1080ti GPUs to design all possible primer pairs. Very effective. In addition, when the same machine is used to design all possible primer pairs for the above-mentioned 138,375 entire databases, it is possible to design within 4 to 5 hours.

Since penalty scores are calculated for the primer pairs designed in these examples and sequentially aligned based on these penalty scores within each sidset, one optimal primer pair for a sidset containing a specific target sequence, or a desired rank Primer pairs up to can be easily found, so it is efficient to actually use them in experiments.

Since the present examples design complete primer pairs, a database based on the results of all primer pairs for a given input sequence can be constructed and used repeatedly in PCR experiments, provided that the filtering conditions remain the same. In general, since the filtering conditions used in laboratories rarely change, an optimal primer database suitable for the laboratory is constructed by executing the program only once for the sequence database for the desired species or for a specific sequence database and building the database based on the results. can do.

In addition, the present embodiments perform pair join to find all possible combinations, so that the amount of computation can increase exponentially as the size of data increases. Since primer design is possible, results can be obtained quickly even if the input sequence database is updated later and calculations must be performed on a larger database.

Hereinafter, a method and apparatus for quickly designing all effective primers that simultaneously satisfy primer restriction conditions and specificity conditions in a large-scale DNA sequence database by utilizing the GPU according to the present embodiments will be described in detail.

2 is a diagram showing a system configuration diagram according to an embodiment.

Referring to FIG. 2, a system configuration diagram for implementing the present embodiments is shown, and a GPU Primer (G-Primer) 101 may include a CPU 102 and a GPU 103, Accordingly, the CPU 102 and GPU 103 may include memories 104 and 105 .

More specifically, the GPU primer 101 program operates by utilizing both the CPU 102 and the GPU 103, the CPU 102 and the GPU 103 for driving the GPU primer 101, and the main memory 104 ) and a hard disk 106. In addition, each of the GPUs 103 may include a memory 105 .

Through the CPU 102 and the GPU 103, it is possible to design effective primers that simultaneously satisfy primer restriction conditions and specificity conditions in the DNA sequence database. A specific execution sequence of the GPU primer 101 program can be described as an example with reference to FIG. 3 .

The overall operation in FIG. 3 is performed by utilizing the CPU 102 shown in FIG. 2, and data structures such as hash maps generated in the operation process are stored in the main memory 104 and used, and other initial inputs In the case of files in the intermediate process for recording the DNA sequence database and candidate primers used as a file, they can be stored in the hard disk 106 in the form of files and read and used if necessary. Here, the GPU 105 may be used only in some steps (S306 and S310) requiring large-scale calculations.

The GPU 103 is basically driven by receiving commands for some operations of the GPU primer 101 through the CPU 102, and the GPU memory 105 receives data necessary for operation from the main memory 104 and is copied to the GPU. After performing a kernel operation in the internal memory 104, the result may be copied back to the main memory 104.

For example, in the first step, the CPU 102 receives the sequence number sid and the sequence data S in the form of a pair of sid + S from the DNA database, and inputs the filtering conditions to be used thereafter to obtain all possible minimum and maximum lengths. Candidate primers can be generated by extracting subsequences between the lengths, reverse complementary primers are created for the output candidate primers, and reverse primers are extracted when displayed, and sidset, which is a set of sids in which the same primers appear, can be generated.

In addition, the CPU 102 may apply a plurality of single primer filtering conditions in the second step to generate and store a hash map only for primers that satisfy the conditions.

The GPU 103 copies the data structure to be used in the GPU operation generated in the fourth step and performs a pair join of arraysC1 and arraysC3, and when the primers in each set are the same except for the number of mismatches (#mismatch) given, arraysC3 can be updated to indicate 'not valid' for the primers in

In addition, the GPU 103 divides each of the forward primer and reverse primer sets generated in the fifth step, copies the data structure for each, and performs a pair-join operation between the forward primer and the reverse primer within the same sid in the GPU 103 , apply a plurality of pair primer filtering conditions, calculate and store penalty scores only for primers that satisfy the conditions, and copy the data structure in which the penalty scores are stored to the main memory to output the result. .

A method for designing effective primers that simultaneously satisfy primer restriction conditions and specificity conditions in a DNA sequence database by utilizing the GPU 103 implemented through a computer device according to an embodiment is a given DNA sequence database and single primer filtering (Single Primer Filtering). The first step of generating and outputting candidate primers by extracting subsequences between the minimum and maximum lengths by receiving Primer Filtering conditions and Pair Primer Filtering conditions. A second step of generating a hash map, which is a data structure to be used for calculation, by applying a Single Primer Filtering condition and using primers that satisfy the condition, and a C1' file recording the extracted subsequences and the second step Pass through and perform pair-join based on the primers stored in the hash map, and if the remaining parts of the primers are the same except for the 5' end, the third step of updating the valid value in the hash map of the primers, the extracted subsequences Using the recorded C1' file and a set of candidate primers that have passed Single Primer Filtering and 5' Cross-Hybridization Filtering, a data structure to be used in GPU (103) operation is created, and pair join is performed in GPU (103). When the primers in each candidate primer set are the same except for the given number of mismatches (#mismatch), the fourth step of updating the valid value in the hash map of the primer, and the remaining primers from the result of the fourth step Divided into forward and reverse primer sets, a data structure for each is created, a self-join operation is performed in the GPU 103 to apply pair primer filtering conditions, and primer pairs that satisfy the conditions are applied. Calculate and output penalty points for the same sidset A fifth step of sequentially sorting according to penalty points within the group may be included.

의 형태로 C1 파일을 생성하고, 이후에 같은 프라이머가 나타나는 sid의 집합으로 sidset를 생성하고

형태로 추출하여 C1' 파일을 생성할 수 있다.In the first step, the CPU 102 receives the sequence number sid and the sequence data S in the form of a pair of sid + S from the CPU 102, receives filtering conditions to be used later, generating candidate primers by extracting subsequences, and generating reverse complementary primers for the output candidate primers, and extracting the reverse primers when indicated, and generating sidset, which is a set of sids in which the same primers appear. can For example, the CPU 102 receives a DNA database as a sequence number sid and sequence data S in the form of a file, extracts subsequences of all candidate primers between all possible minimum lengths and maximum lengths, and

Create a C1 file in the form of , then create a sidset as a set of sids in which the same primer appears,

You can create a C1' file by extracting it in the form.

, GC content(%), Self-Complementarity, 3' End Self-Complementary, 연속된 염기 및 end stability(G value)일 수 있다. In the second step, a hash map may be generated and stored only for primers satisfying the condition by applying a plurality of single primer filtering conditions in the CPU 102 . For example, the CPU 102 applies a plurality of single primer filtering conditions while reading the C1 file, generates primerH and suffixH hash maps only for primers that satisfy the conditions, and single primer filtering (Single Primer Filtering) A C2 file can be created by outputting only the primers that satisfy the filtering conditions. Here, the plurality of single primer filtering conditions are the length, temperature (

, GC content (%), Self-Complementarity, 3' End Self-Complementary, consecutive bases, and end stability (G value).

In the third step, the CPU 102 performs a pair join from the C1' file in which all possible subsequences extracted from the given DNA sequence database are stored and the hash map in which candidate primers that have passed Single Primer Filtering are stored. , If the primers of each set are identical except for the 5' end, the primers stored in the hash map can be updated to indicate 'not valid'. For example, the CPU 102 is based on two C1' files including all possible candidate primers extracted from a given DNA database and suffixH generated based on primers that have passed Single Primer Filtering. When pair-joining is performed between primers having the same suffix, and the C1' primer and the primer in suffixH have different sidsets except for the 5' end, valid at primerH for the corresponding primer ' It can be set to '0', which means 'not valid'. Although the C1' primer and the fry in suffixH have the same very high similarity except for the 5' end, having different sidsets means that the corresponding primer can also amplify off-target sequences, so this should be removed.

The fourth step is to generate another hash map by dividing the primers into several sids from the hash map in which the primers that have passed both Single Primer Filtering and 5' Cross-Hybridization Filtering are stored, and another hash map. A data structure arraysC3 having information on primers that have passed both Single Primer Filtering and 5' Cross-Hybridization Filtering from and data structure arraysC1 having information on all possible subsequences extracted from a given DNA sequence database generating step, and copying the generated data structure to the GPU 103 to perform pair-joining of arraysC1 and arraysC3, and when the primers in each set are the same except for the given mismatch number (#mismatch), the primers of arraysC3 It may include updating to indicate 'not valid' for

형태의 C4 파일을 생성할 수 있다.On the other hand, the fourth step is the first step of performing an operation using the GPU 103, preparing a data structure so that the operation can be efficiently processed using the GPU 103, and based on the created array. Utilizing the GPU 103, the rest is the same except for the number of mismatches (#mismatch) given between the C1' primer and the primers that have passed both Single Primer Filtering and 5' Cross-Hybridization Filtering. At the same time, another sidset Display 'not valid' in the output array having the result for the primer if you have it, and copy the output array storing the result from the GPU (103) to the host to apply to the primer removed from General Cross-Hybridization Filtering. For primerH, set valid to '0', which means 'not valid', and then use Single Primer Filtering, 5' Cross-Hybridization Filtering, and General Cross-Hybridization Filtering for use in the fifth step. Save and align primers that have all passed

A C4 file of the form can be created.

In the fifth step, candidate primers having the same sid are grouped and sorted in descending order of the number of primers. Forward primers are selected according to the presence or absence of marking performed when extracting candidate primers from the DNA sequence database by receiving the sorted file as an input. and two sets of reverse primers to create a data structure to be used for GPU 103 operation for each and create a data structure capable of storing a penalty score, copying the generated data structure to the GPU 103 to the GPU ( 103) performs a pair-join operation between forward and reverse primers within the same sid, applies a plurality of pair primer filtering conditions, and calculates and stores penalty scores only for primers that satisfy the conditions; and copying the data structure in which the penalty score is stored to the main memory 104, outputting the result, grouping based on the same sidset, and assigning an order to primer pairs using the penalty score in each sidset to align.

Here, the fifth step is the second step of performing an operation using the GPU 103. While reading the C4 generated in the fourth step, a data structure required for the GPU 103 operation is prepared, and the GPU 103 Pair primer penalty scores are calculated for pair primers that satisfy the pair primer filtering conditions given through operation, and pair primers that satisfy the pair primer filtering conditions are output to obtain pairs with the same sidset. The final result can be output by sorting the primers based on the penalty score. Here, the plurality of pair primer filtering conditions may include length difference, temperature difference, product length, Pair-Complementary, and 3' End Pair-Complementary. This will be described in more detail with reference to FIG. 3 below.

3 is a flowchart illustrating a method of designing effective primers that simultaneously satisfy primer restriction conditions and specificity conditions in a DNA sequence database using a GPU according to an embodiment.

As shown in FIG. 3, given a DNA sequence database and filtering conditions, candidate primers of subsequences having all possible minimum lengths (minLen) and maximum lengths (maxLen) can be extracted (S301, S302). .

Subsequently, for the candidate primers extracted in step S302, the C1 file is received as an input, primerH and suffixH are generated for primers satisfying the single primer filtering condition input in step S301, and the C2 file is output. It can (S303).

In addition, the C1' file containing all possible subsequences obtained in step S302 is received as an input, and while performing Pair Join with the primers in suffixH generated in step S303, if the primers in the C1' file and suffixH If the rest of the primers are the same except for the 5' end, the valid value (valid value) can be updated to 'not valid' by referring to primerH for the primers in suffixH (S304).

In addition, seedH hash map may be generated based on primerH updated in step S304, and arraysC3, which is a data structure for performing efficient operation in the GPU, may be generated based on seedH. In addition, arraysC1 may be generated by receiving the C1' file including all possible subsequences obtained in step S302 as an input. arraysC1 and arraysC3 are copied to the GPU and paired in the GPU. If the primers in the two arrays (arraysC1 and arraysC3) are the same except for the number of mismatches (#mismatch) given, the result is displayed in the output array, and in the GPU After all the calculations are finished, the output array can be copied back to the host, and the valid value can be updated to 'not valid' by referring to primerH for the primers in arraysC3 (S306, S307, S308).

In addition, when the C2 file is read, only primers having a valid valid value are output, and when grouped based on sid, the C4 file, which is an output file, can be generated by sequentially sorting in descending order of the number of forward primers (S309).

In the C4 file generated as a result of step S309, a forward primer set and a reverse primer set are divided into two sets, arraysFP and arraysRP arrays are generated, respectively, and penalty scores for combinations of all paired primers of forward and reverse primers can be stored. You can create an array of scoreoffset and score. The generated arrays are copied to the GPU, and self-join calculations are performed between primers having the same sid for arraysFP and arraysRP in the GPU, and filtering conditions for primer pairs are applied to calculate penalty scores only for primers that satisfy the conditions. You can store the results in a score array. Thereafter, the score array is copied back to the main memory, and a common sidset of the forward and reverse primers can be found by referring to primerH and output together with a penalty score (S310).

Then, the primer pairs output through step S310 are sequentially aligned according to a penalty within the group having a common sidset, and the result of sequentially aligned primer pairs is obtained (S311, S312).

4 is a flowchart illustrating a method of extracting candidate primers according to an embodiment. More specifically, FIG. 4 is a detailed flowchart of the candidate primer extraction operation of step S302 shown in FIG. 3 .

As shown in FIG. 4, in step S401, the DNA database is input in the form of sid + S, which is a pair of sequence number sid and sequence data S, and the length between all possible minimum lengths (minLen) and maximum lengths (maxLen) A partial sequence for a candidate primer having the same may be extracted using a window sliding method (S402).

That is, subsequences may be sequentially extracted from a sequence having a |S| length from 0 to |S|-minLen as a starting point and increasing from a length of minLen to maxLen. At this time, pos is the starting point and P is a partial sequence corresponding to the length between minLen and maxLen at the starting point pos and becomes a candidate primer. The length minLen and maxLen values are input from the user as one of the Single Primer Filtering conditions.

Then, in step S403, reverse complementary primers can also be extracted by attaching a '*' mark.

In step S404, sidset, which is a set of sids for each primer, may be extracted.

의 형식으로 출력되고, C1' 파일은

의 형식으로 출력될 수 있다. 여기서 P는 프라이머 후보, sid는 P가 나온 하나의 특정 서열의 번호, pos은 sid 서열 내에 P의 위치를 뜻하며, sidset은 P가 나온 sid의 집합을 뜻한다. In step S405, the two files C1 and C1' can be output. At this time, the C1 file is

, and the C1' file is

can be output in the form of Here, P is a primer candidate, sid is the number of one specific sequence from which P is derived, pos is the position of P within the sid sequence, and sidset is the set of sids from which P is derived.

5 is a diagram illustrating examples of a C1 file and a C1' file according to an embodiment. More specifically, (a) of FIG. 5 shows an example of the output C1 file and C1' file of step S302 of FIG. 3, and (b) shows hash maps used in steps S303, S304, S306, and S310 of FIG. shows an example for

6 is a flowchart illustrating a method for generating a hash map for primers satisfying a single primer filtering condition according to an embodiment. More specifically, FIG. 6 is a detailed flowchart of single primer filtering and {primerH, suffix} generation operations in step S303 shown in FIG. 3, and step S303 in FIG. Among them, seven single primer filtering conditions may be applied to confirm the suitability of the candidate primers extracted in step S302.

As shown in FIG. 6, while receiving and sequentially reading the C1 file in step S601, as in steps S602 to S608, temperature (℃), GC content (%), Self-Complementarity, 3' End Self- Complementary, consecutive bases, and end stability (G value) can be sequentially checked (S602 ~ S608).

Values of all of the conditions may be defined by the user. In particular, the same formula applied in the above-mentioned MRPrimer was applied to calculate temperature or end stability.

PrimerH and suffixH hash maps can be generated based on primers that satisfy all Single Primer Filtering conditions. primerH has primer P as a key, and has sidset and valid as values. sidset is a set of sids in which the corresponding P appears, valid is a value indicating whether the primer is valid or not, and is initially initialized to '1' indicating 'true'. suffixH is a hash map generated for the operation of step S304 shown in FIG. 3, and the key is suffix denoting a partial sequence of a specific length of the 3' end of the primer. In addition, it has Pset, which is a set of primers having the corresponding suffix, as a value (S609, S610). Meanwhile, an example of primerH and suffix hash map generated in steps S609 and S610 is shown in (b) of FIG.

형식으로 출력하여 출력 파일인 C2 파일을 생성할 수 있다(S611). In addition, primers that satisfy all Single Primer Filtering conditions are identical to the input file.

A C2 file, which is an output file, can be generated by outputting in the format (S611).

7 is a flowchart illustrating a 5' Cross-Hybridization Filtering method according to an embodiment. More specifically, FIG. 7 shows a detailed flowchart of the 5' Cross-Hybridization Filtering operation of step S304 shown in FIG. 3 .

Referring to FIG. 7, in step S304 of FIG. 3, a C1' file containing all possible subsequences extracted from a given DNA sequence database is received as an input and sequentially read to separate suffixes from each primer P1 (S701 ).

And, if the corresponding suffix exists in the suffixH generated in step S303 of FIG. 3, pair-joining of the primer P1 and the primer P2 in the Pset can be performed by looking up the Pset having the corresponding suffix in the suffixH (S702, S703).

The valid value of primer P2 of the Pset having a specific suffix is checked in primerH, and if the value is 'true', the sidset of P1 and the sidset of P2 can be compared. In the case of the sidset of P1, it was received through the C1' file, and in the case of the sidset of P2, it can be obtained by referring to primerH. If there is a sid in the sidset of P1 that is not included in the sidset of P2, P2 should be removed because there is a possibility that P2 can also amplify the sequence of the corresponding sid, which is an off-target. Therefore, in the case of such primer P2, the valid value in primerH can be updated to 'false' (S704, S705, S706).

An example of applying the 5' Cross-Hybridization Filtering operation as described above can be described with reference to (a) and (b) of FIG. 5 .

The GCT appearing in the third row of the C1' file in (a) of FIG. 5 does not satisfy the single primer filtering condition in step S303 shown in FIG. 3, and corresponds to primerH and suffixH in (b) of FIG. 5 It is assumed that there is no information about the primers. In the case of 'GCT+3' in the 'C1' file, since it has a suffix CT, the {*TCT} set is found by looking up the Pset having the suffix in suffixH. If this *TCT is found in primerH, it can be seen that the primer has {4-5} as the sidset, and the sidset of GCT, {3}, is not included in the corresponding {4-5}. In this case, since primer *TCT can also amplify sid 3, which is an off-target sequence, due to high similarity, primer *TCT is updated to 'false'.

In terms of implementation, the C1' file is divided into the same number of files as the number of CPU threads, and several CPU threads update primerH while reading each file. In the case of lookup, because it is an atomic operation, it is possible to perform a fast operation without race conditions between threads.

8 is a flowchart illustrating a method of generating {seedH, arraysC1, arraysC3} and general cross-hybridization filtering according to an embodiment. More specifically, FIG. 8 is a detailed flowchart of {seedH, arraysC1, arraysC3} generation and general cross-hybridization filtering operations in step S306 shown in FIG. 3 .

In step S306 of FIG. 3, data structures (seedH, arraysC1, arraysC3) are prepared to efficiently process operations using the GPU, and primers and single primer filtering of the C1' file are performed based on the generated data structures. ) and the primers that passed 5' Cross-Hybridization Filtering, except for the given number of mismatches (#mismatch), if they have different sidsets at the same time, valid in primerH for that primer is 'not valid'. Can be set to 0'.

In order to effectively carry out this process, step S306 divides the primers into several seeds and performs the operation. The length of the seed that can be generated from one primer is at least exactly matched in m-length sequences with k mismatches. It can be set to include m/(k+1) bases.

이고 값은 Pset이다. 키에서의 seed는 프라이머의 시드를 뜻하고 index는 시드가 시작하는 위치, |P|는 프라이머의 길이를 나타내며, seedH의 값인 Pset은 해당 키를 가지고 있는 프라이머의 집합을 뜻한다. 하나의 프라이머에서 여러 개의 시드가 추출되기 때문에 하나의 프라이머로부터 여러 개의 키가 생성된다(S801, S802, S803).Referring to FIG. 8, only for candidate primers that have passed both the Single Primer Filtering and the 5' Cross-Hybridizatiopn Filtering, primerH whose valid value is marked as 'true' is sequentially looked up, , seedH can be updated by extracting a seed from the primer for the case where the corresponding primer is valid. At this time, the key of seedH is

and the value is Pset. The seed in the key means the seed of the primer, index is the starting position of the seed, |P| indicates the length of the primer, and Pset, the value of seedH, means the set of primers with the corresponding key. Since several seeds are extracted from one primer, several keys are generated from one primer (S801, S802, S803).

When the creation of seedH is complete, arraysC3 and output arrays can be created from seedH and copied to the GPU. arraysC3 consists of four arrays: P3offset, P3, sidset3offset, and sidset3 (S804).

An application example of the operation of step S804 can be confirmed through examples of FIG. 5(b) and FIG. 9(a).

9 is a diagram illustrating an example of generating {seedH, arraysC1, arraysC3} and general cross-hybridization filtering according to an embodiment.

To create arraysC3, first, the keys of seedH can be sorted in ascending order of the size of Pset (the number of primers for each key). The order of keys is used to handle workload balancing of GPU operations, and this order is called workload order. Then you can create P3 and sidset3 arrays in order of workload.

In the case of seedH in (b) of FIG. 5, the number of primers having keys of 'A+0+3' and 'G+2+3' is 2, and the number of primers having keys of 'T+1+3' is 1 am. Therefore, array P3 having primer information is first created as Pset {ATG} for the key of 'T+1+3' with the smallest Pset size, and then Pset {AAC of 'A+0+3' , ATG} can update P3. Similarly, array sidset3 having sidset information starts with sidset {1-2} of ATG of 'T+1+3' with reference to primerH in (b) of FIG. 5, followed by 'A+0+3' It is created in the order of sidset {2-3-4} of AAC and sidset {1,2} of ATG. P3offset and sidset1offset in (a) of FIG. 9 may simply operate as a pointer array of P3 and sidset3.

The output array in (a) of FIG. 9 is an array for storing the results of General Cross-Hybridization Filtering, and has the same size as P3 because it represents the filtering results for each primer. This output array is initialized to '1', which means 'true', and is updated while performing General Cross-Hybridization Filtering.

At this time, arraysC3 and the output array are generated for candidate primers that have passed both the Single Primer Filtering and the 5' Cross-Hybridization Filtering, so they are generally of a size that can be copied to the GPU at once. Therefore, they are copied to the GPU at once, and this copying is called Chunk-Copy.

)를 생성할 수 있다. seedH 내에 해당 키가 존재하는 경우에 대해서만 arraysC1을 업데이트 할 수 있다(S805, S806, S807, S808).Next, the C1' file containing all possible subsequences extracted from the DNA sequence database is received as an input and the seed is extracted from each primer P1 while sequentially reading it as a key (

) can be created. arraysC1 can be updated only when the corresponding key exists in seedH (S805, S806, S807, S808).

In the case of arraysC1 updated in step S808, it is composed of four arrays: P1offset, P1, sidset1offset, and sidset1, and an example can be seen in (b) of FIG. It is created based on the same workload order as when arraysC3 was created. P1 is an array containing information about primers, sidset1 is an array containing sidset information about each primer, and P1offset and sidset1offset are arrays of pointers to P1 and sidset1, respectively. used

In the case of the C1' file, since it has all subsequences to the DNA sequence database as candidate primers, in most cases the GPU memory is insufficient to create arraysC1 for them at once and copy them to the GPU. Therefore, in the case of the C1' file, arraysC1 is read only as much as the size that can be copied to the GPU at a time, arraysC1 is created, copied to the GPU, and the operation is performed. Then, the same process can be repeated by reading the next part of the previously read part. At this time, in order to reduce the overhead of creating arraysC1 and copying to the GPU, arraysC1 created for the previous C1' file piece performs an operation in the GPU and arraysC1 for the next C1' file piece is created and processed. The process of copying to the GPU is done simultaneously. For these asynchronous operations and data copying, copying of arraysC1 is called streaming-copy because the copying of arraysC1 is performed using a GPU stream (S809, S810).

In the GPU, a pair-join operation can be performed on each primer having the same key using arraysC3 chunk-copied in step S804 and arraysC1 stream-copied in step S810. First, sidset1 and sidset3 are compared, and if the sidset (sidset1) of P1 is not included in the sidset (sidset3) of P3 and the number of mismatches between primers P1 and P3 is smaller than #Mismatch set, the two primers (P1 and P3) are very Since the similarity is high, P3 can amplify the off-target sequence, and accordingly, the output value of the corresponding primer is updated to '0' indicating 'not valid' (S811, S812, S813, S814).

An application example of the operation of steps S811, S812, S813, and S814 can be confirmed through examples of (a) and (b) of FIG. 9 .

P3 with key 'T+1+3' is {ATG}, and P1 is {ATG, CTT, CTA}. Comparing sidset {1,2} of ATG, P3, and sidset {4,5} of CTT, P1, sidset1({4,5}) is not included in sidset3({1,2}). In this case, the number of mismatches is checked. Assuming that the number of mismatches of ATG and CTT is 2 and #mismatch is 1, the output is not updated because the number of mismatches is higher than this.

By streaming copy, arraysC1 is initialized in steps S811 to S814 and steps S805, which are operations in the GPU for arraysC1 and arraysC3 currently possessed by the GPU, and arraysC1 is generated while reading the C1' file of the part that has not yet been read. Operations up to step S810 of copying are performed simultaneously, and these processes are repeated until all C1' files are processed (S805, S815, S816).

Basically, operations within the GPU using arraysC1 and arraysC3 are independently performed on a key-by-key basis. Since the distribution of the number of primers for a key varies greatly, when one GPU thread processes only one key, a specific GPU thread is very small. It can lead to an uneven workload, such as processing only the amount of primers and a specific GPU thread processing a lot of primers, which can lead to a decrease in GPU computational performance. Therefore, if a specific threshold is set for Workload Balancing and the index of a specific key is smaller than this threshold, one GPU thread processes all primers within one key. Each-thread mode If the index of a specific key is greater than the threshold, block-threads mode can be applied so that all GPU threads within one thread block process within one key. Since P3 is sorted according to the order of workload as described above, and P1 can be considered to be almost sorted according to the same order of workload, just setting a specific index as a threshold and processing each differently Workload balancing is possible. This threshold value was set through experimentation, and when the #ITERATION value in step S305 of FIG. 3 is 1, it is set at 85% of the total, and when the #ITERATION value is 2, it is set at 20%.

After the operation of all C1' files is completed, copy the final output array to the host, and refer to primerH for primers with '0', which means 'not valid' in the output, and set the valid value to the same 'not valid' (false )' (S816, S817, S818).

의 포맷으로 출력할 수 있다(S819).Then, while receiving the C2 file generated in step S303 of FIG.

It can be output in the format of (S819).

10 is a diagram illustrating an example of a data flow and a timeline in a method of generating {seedH, arraysC1, arraysC3} and general cross-hybridization filtering according to an embodiment.

에 따라 독립적이기 때문에 한 키에 대한 모든 데이터가 하나의 GPU에 복사되어야 한다. 도 10의 (a)에서는 GPU가 두 개일 때의 예시이기 때문에 arraysC3와 output이 2 개로 나뉘어졌다. 청크 복사 끝나고 나면 N 개의 조각으로 나뉘어진 C1' 파일을 읽으면서 arraysC1을 생성할 수 있다. arraysC1 또한 각 GPU가 가지고 있는 키에 대해서만 각 GPU에게 복사된다. 이 때, 도 10의 (b)를 보면 arraysC1의 스트리밍 복사와 GPU 내의 커널 연산이 스트림을 이용하여 비동기적으로 수행됨을 알 수 있다. C1' 파일에 대한 모든 연산이 끝나면 output 배열은 다시 호스트에게 복사되어 primerH를 업데이트 하는데 사용된다.(a) and (b) of FIG. 10 are examples showing the data flow and timeline for the detailed flowchart of FIG. 4 when two GPUs are used. First, based on seedH generated from primerH, arraysC3 and output arrays are created in the main memory, and chunks can be copied to each GPU by dividing them by the number of GPUs. At this time, the operation using arraysC3 and arraysC1 is used as a key.

is independent, so all data for one key must be copied to one GPU. In (a) of FIG. 10, since it is an example when there are two GPUs, arraysC3 and output are divided into two. After copying the chunks, arraysC1 can be created by reading the C1' file divided into N pieces. arraysC1 is also copied to each GPU only for the keys each GPU has. At this time, in (b) of FIG. 10 , it can be seen that the streaming copy of arraysC1 and the kernel operation in the GPU are performed asynchronously using the stream. After all operations on the C1' file are finished, the output array is copied back to the host and used to update primerH.

11 is a flowchart illustrating a pair filtering and scoring method according to an embodiment. More specifically, FIG. 11 shows a detailed flowchart of Pair Filtering and Scoring operations in step S310 shown in FIG. 3 .

In the Pair Filtering and Scoring step of step S311, when the output file generated in step S306 of FIG. 3 is grouped based on sid in step S309, the C4 file, which is an output file obtained by sequentially sorting in descending order of the number of forward primers, is used as an input file. receive At this time, sequential sorting is for later workload balancing.

While receiving and reading the C4 file sequentially, the primers in the C4 file are separated into forward primers (f.p) and reverse primers (r.p) to generate arraysFP and arraysRP, which are arrays required for GPU operation. arraysFP consists of a total of three arrays: FP with forward primer information, Fpos and FP with forward primer pos information, and FPoffset serving as a pointer array to Fpos. arraysRP consists of three sequences, RPoffset, RP, and Rpos related to the reverse primer, and the meaning of each is the same as that of arraysFP (S1102, S1103).

Application examples of the operation of step S1103 can be confirmed through (a), (b) and (c) of FIG. 12 .

12 is a diagram showing an example of a primer sequence alignment method according to an embodiment. More specifically, (a) of FIG. 12 is an example of a C4 file used as an input file. In the C4 file, {CGT} is one forward primer with sid of 7, and {ATG, AAC} is two forward primers with sid of 2, so they are arranged in this order. 12 (b) and (c) are examples of arraysFP and arryasRP, respectively. While sequentially reading the C4 file of FIG. 12 (a), primer and pos information are read, respectively, and FP and Fpos can be updated if the primer is a forward primer, and RP and Rpos can be updated if the primer is a reverse primer. Also, whenever sid changes, FPoffset and RPoffset can be updated.

Since pair filtering and scoring steps must perform calculations on all possible pairs of forward and reverse primers, a score array capable of storing penalty scores for all possible pairs can be generated. An example of this score array is shown in FIG. 12(d). The scoreoffset in (d) of FIG. 12 is used as a pointer array for scores, and can be generated by scanning FPoffset in (b) and RPoffset in (c) once. In the case of the score array, its size is very large, so it usually cannot be copied to the GPU at once. Therefore, a scoreoffset and a score array can be generated only as large as the size that can be copied at one time, and the matching primer pair can be initialized to '-1.0', which means 'not valid'. At this time, since operations performed in the GPU are independent for each sid, all forward and reverse primers within one sid must be copied to the same GPU at once (S1104).

By copying the generated score and scoreoffset and arraysFP and arraysRP for the corresponding score to the GPU, a join calculation can be performed on the forward and reverse primers having the same sid in the GPU (S1105, S1106).

At this time, as in the General Cross-Hybridization Filtering shown in FIG. 8, the join operation for the data structure currently in the GPU and the step of preparing and copying an array of scores to be performed in the next operation are performed asynchronously. Copying of the data structure to the GPU in step S1105 may also be performed by streaming copying.

In the join operation, 5 pair primer filtering conditions can be applied. Conditions can be sequentially inspected for temperature difference, length difference, Pair-Complementary, 3' End Pair-Complementary, and product length difference as in steps S1107 to S1111. All of these values can be defined by the user when the program is running.

And, for primer pairs that satisfy all the Pair Primer Filtering conditions, a penalty score (Single Primer Penalty) is calculated for each of the forward and reverse primers, and based on the sum of the two penalty scores, the pair primer penalty score ( Pair Primer Penalty) can be calculated and the penalty score can be recorded at the location of the matching score (S1112).

In the case of the penalty score for the forward and reverse primers (Single Primer Penalty), the penalty was calculated for the single primer filtering conditions mentioned above, length, temperature (℃), GC content (%), Self-Complementarity, 3' End Self-Complementary, consecutive bases, and end stability (G value) are applicable.

The Pair Primer Penalty is calculated using the sum of the penalty scores for the forward and reverse primers and the Pair Primer Filtering conditions mentioned above.

After the join between the forward and reverse primers copied to the GPU is finished, the final scoreoffset and score array can be copied to the host (S1113).

While reading the copied score array, a common sidset for a primer pair having a positive pair primer penalty score other than '-1.0' can be obtained and the final result can be output. The format of the final result is 'common sidsetÅf.PÅr.P sidÅf.posÅr.pos'. Here, f.P denotes a forward primer, r.P denotes a reverse primer, and f.pos and r.pos denote the pos of the forward and reverse primers, respectively (S1114).

If there are arraysFP and srraysrP that have not yet been calculated, return to step S1104 to regenerate and initialize the scoreoffset array and score, and then repeat steps S1105 to S1114 until pair calculations for all sids are completed. Although the data preparation and copying of the score array and the operation in the GPU are performed asynchronously, in this step, unlike the General Cross-Hybridization Filtering shown in FIG. 8, the score result must be copied to the host every time to output the result. Therefore, the performance improvement that can be obtained when using streaming copy is relatively small.

In addition, since the distribution of the number of primers for one key (sid) is much more skewed than the distribution in General Cross-Hybridization Filtering shown in FIG. and largeThreshold, two are set, each-thread mode is applied when the index is less than smallThreshold, block-threads mode is applied when the index is between smallThreshold and largeThreshold, and all GPU threads are applied when the index is greater than largeThreshold. Workload balancing can be handled by applying the all-threads mode that processes one key.

Subsequently, in step S311 of FIG. 3, based on the results output in step S310, sort by sidset group using Linux Sort, order the primer pairs according to the penalty within each group, and then the final result get it

A method for quickly designing all effective primers satisfying specificity conditions for a large-scale DNA sequence database using GPU according to the present embodiments has been described according to the examples, but the scope of the present invention is not limited to the specific examples. , Various alternatives, modifications and changes can be made and implemented within the scope obvious to those skilled in the art in relation to the present invention.

The devices described above may be implemented as hardware components, software components, and/or a combination of hardware components and software components. For example, devices and components described in the embodiments may include, for example, a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable array (FPA), It may be implemented using one or more general purpose or special purpose computers, such as a programmable logic unit (PLU), microprocessor, or any other device capable of executing and responding to instructions. A processing device may run an operating system (OS) and one or more software applications running on the operating system. A processing device may also access, store, manipulate, process, and generate data in response to execution of software. For convenience of understanding, there are cases in which one processing device is used, but those skilled in the art will understand that the processing device includes a plurality of processing elements and/or a plurality of types of processing elements. It can be seen that it can include. For example, a processing device may include a plurality of processors or a processor and a controller. Other processing configurations are also possible, such as parallel processors.

Software may include a computer program, code, instructions, or a combination of one or more of the foregoing, which configures a processing device to operate as desired or processes independently or collectively. The device can be commanded. Software and/or data may be any tangible machine, component, physical device, virtual equipment, computer storage medium or device, intended to be interpreted by or provide instructions or data to a processing device. can be embodied in Software may be distributed on networked computer systems and stored or executed in a distributed manner. Software and data may be stored on one or more computer readable media.

The method according to the embodiment may be implemented in the form of program instructions that can be executed through various computer means and recorded on a computer readable medium. The computer readable medium may include program instructions, data files, data structures, etc. alone or in combination. Program commands recorded on the medium may be specially designed and configured for the embodiment or may be known and usable to those skilled in computer software. Examples of computer-readable recording media include magnetic media such as hard disks, floppy disks and magnetic tapes, optical media such as CD-ROMs and DVDs, and magnetic media such as floptical disks. - includes hardware devices specially configured to store and execute program instructions, such as magneto-optical media, and ROM, RAM, flash memory, and the like. Examples of program instructions include high-level language codes that can be executed by a computer using an interpreter, as well as machine language codes such as those produced by a compiler.

As described above, although the embodiments have been described with limited examples and drawings, those skilled in the art can make various modifications and variations from the above description. For example, the described techniques may be performed in an order different from the method described, and/or components of the described system, structure, device, circuit, etc. may be combined or combined in a different form than the method described, or other components may be used. Or even if it is replaced or substituted by equivalents, appropriate results can be achieved.

Therefore, other implementations, other embodiments, and equivalents of the claims are within the scope of the following claims.

Claims (15)

Using GPU primers, overall calculations are performed to design effective primers that satisfy both primer restriction and specificity conditions in the DNA sequence database, and the data structure including the hash map generated during the calculation process is stored in the main memory for use. and, in the case of intermediate process files for recording the DNA sequence database and candidate primers used as initial inputs, stored in the form of files on a separate hard disk and read and used if necessary; and
When a large-scale operation is required, it is driven by receiving commands for some operations of the GPU primer through the CPU, and the GPU memory copies data necessary for operation from the main memory, performs kernel operation, and then displays the result. GPU to copy back to the main memory for
including,
Design effective primers that simultaneously satisfy primer restriction conditions and specificity conditions in the DNA sequence database through the CPU and the GPU,
Receiving the DNA sequence database given by the CPU and the Single Primer Filtering conditions and Pair Primer Filtering conditions, extracting subsequences between the minimum length and the maximum length to generate and output candidate primers first step;
a second step of applying the single primer filtering condition received to the output candidate primers and generating a hash map, which is a data structure to be used for calculation, using primers satisfying the condition;
Pair-joining is performed based on the C1' file recording the extracted subsequences and the primers stored in the hash map that have passed the Single Primer Filtering condition in the second step, so that the primers are located at the 5' end A third step of applying 5' Cross-Hybridization Filtering to update a valid value in the hash map of the primer when the remaining parts are the same except for the part;
GPU calculation using the C1' file recording the extracted subsequences and the candidate primer set that passed the Single Primer Filtering in the second step and the 5' Cross-Hybridization Filtering in the third step. Creates a data structure to be used in the GPU, and performs pair join in the GPU, and when the primers in each candidate primer set are the same except for the given mismatch number (#mismatch), the valid value of the primer in the hash map A fourth step of updating; and
The primers remaining in the result of the fourth step are divided into a forward primer and a reverse primer set, respectively, to create a data structure for each, and to perform a self-join operation in the GPU to determine the pair primer filtering condition. A fifth step of applying, calculating and outputting penalty scores for primer pairs that satisfy the condition, and sequentially sorting according to penalty scores within the same sidset group
to perform,
The fourth step,
From the hash map in which the primers that have passed both Single Primer Filtering and 5' Cross-Hybridization Filtering are stored, another hash map is created by dividing the primers into several seeds, and from the other hash map Create data structure arraysC3, which contains information on primers that have passed both Single Primer Filtering and 5' Cross-Hybridization Filtering, and data structure arraysC1, which contains information on all possible subsequences extracted from a given DNA sequence database and copying the generated data structure to the GPU to perform pair-joining of arraysC1 and arraysC3, and if the primers in each set are the same except for the given number of mismatches (#mismatch), the primers in arraysC3 are not valid. to update to indicate '
Characterized by a device. delete According to claim 1,
The CPU,
In the first step, the DNA database receives the sequence number sid and the sequence data S in the form of a pair of sid + S, inputs the filtering conditions to be used later, and calculates the subsequence between all possible minimum lengths and maximum lengths Extracting to generate candidate primers, making reverse complementary primers for the output candidate primers, extracting when reverse primers are displayed, and generating a sidset, which is a set of sids in which the same primers appear
Characterized by a device. According to claim 1,
The CPU,
In the second step, a plurality of single primer filtering conditions are applied to generate and store the hash map only for the primers that satisfy the condition.
Characterized by a device. According to claim 4,
The plurality of single primer filtering conditions,
length, temperature (

, GC content (%), Self-Complementarity, 3' End Self-Complementary, contiguous bases and end stability (G value)
Characterized by a device. delete According to claim 1,
The GPU,
Divide into forward and reverse primer sets generated in the fifth step, copy the data structure for each, and perform a pair-join operation between the forward and reverse primers in the same sid in the GPU, and a plurality of the paired primers Applying filtering (Pair Primer Filtering) conditions to calculate and store the penalty score only for primers that satisfy the condition, and copy the data structure in which the penalty score is stored to the main memory to output the result
Characterized by a device. A method for designing effective primers that simultaneously satisfy primer restriction conditions and specificity conditions in a DNA sequence database using a GPU implemented through a computer device,
A first step of generating and outputting candidate primers by extracting subsequences between a minimum length and a maximum length by receiving a given DNA sequence database and Single Primer Filtering conditions and Pair Primer Filtering conditions as inputs. ;
a second step of applying the single primer filtering condition received to the output candidate primers and generating a hash map, which is a data structure to be used for calculation, using primers satisfying the condition;
Pair-joining is performed based on the C1' file recording the extracted subsequences and the primers stored in the hash map that have passed the Single Primer Filtering condition in the second step, so that the primers are located at the 5' end A third step of applying 5' Cross-Hybridization Filtering to update a valid value in the hash map of the primer when the remaining parts are the same except for the part;
GPU calculation using the C1' file recording the extracted subsequences and the candidate primer set that passed the Single Primer Filtering in the second step and the 5' Cross-Hybridization Filtering in the third step. Create a data structure to be used in the GPU, and perform pair-joining in the GPU, and if the primers in each candidate primer set are the same except for the given mismatch number (#mismatch), the valid value in the hash map of the primer The fourth step of updating; and
The primers remaining in the result of the fourth step are divided into a forward primer and a reverse primer set, respectively, to create a data structure for each, and to perform a self-join operation in the GPU to determine the pair primer filtering condition. A fifth step of applying, calculating and outputting penalty scores for primer pairs that satisfy the condition, and sequentially sorting according to penalty scores within the same sidset group
including,
In the fourth step,
Generating another hash map by dividing the primers into several seeds from the hash map in which the primers that have passed both single primer filtering and 5' cross-hybridization filtering are stored;
Data structure arraysC3 having information on primers that have passed both the Single Primer Filtering and 5' Cross-Hybridization Filtering from the another hash map and information on all possible subsequences extracted from a given DNA sequence database Creating a data structure arraysC1 having; and
Copying the generated data structure to the GPU and performing pair-joining of arraysC1 and arraysC3, and when the primers in each set are the same except for the given number of mismatches (#mismatch), 'not valid' for the primers in arraysC3 Steps to update to indicate
Including, method. According to claim 8,
The first step is
The DNA database receives sequence number sid and sequence data S in the form of a pair of sid + S, inputs filtering conditions to be used later, extracts the subsequence between all possible minimum and maximum lengths, and selects candidate primers. generating; and
Making reverse complementary primers for the output candidate primers and extracting the reverse primers when indicated.
including,
A method characterized by generating a sidset, which is a set of sids in which the same primer appears. According to claim 8,
The second step,
Applying a plurality of single primer filtering conditions to generate and store the hash map only for the primers that satisfy the condition
Characterized by, method. According to claim 10,
The plurality of single primer filtering conditions,
length, temperature (

, GC content (%), Self-Complementarity, 3' End Self-Complementary, contiguous bases and end stability (G value)
Characterized by, method. According to claim 8,
The third step,
Pair-joining is performed from the C1' file in which all possible subsequences extracted from a given DNA sequence database are stored and the hash map in which candidate primers that have passed the Single Primer Filtering are stored, so that the primers of each set are 5 ' Updating the primer stored in the hash map to indicate 'invalid' if the rest of the parts are the same except for the end.
Including, method. delete According to claim 8,
The fifth step,
grouping candidate primers having the same sid and arranging them in descending order of the number of primers;
Receives the sorted file as an input and separates the candidate primers into two sets of forward and reverse primers according to the presence or absence of the mark performed when extracting the candidate primers from the DNA sequence database, creates a data structure to be used for GPU operation for each set, and stores penalty scores. Creating a data structure that can be;
Copy the generated data structure to the GPU, perform a pair-join operation between forward primers and reverse primers within the same sid in the GPU, and apply a plurality of the pair primer filtering conditions to satisfy the condition calculating and storing the penalty score only for the primer; and
Copying the data structure in which the penalty score is stored to the main memory, outputting the result, grouping based on the same sidset, and assigning an order to primer pairs using the penalty score in each sidset and sorting step
Including, method. According to claim 14,
The plurality of pair primer filtering conditions are,
Including Length Difference, Temperature Difference, Product Length, Pair-Complementary and 3' End Pair-Complementary
Characterized by, method.

Images