JP4950325B2 - Efficient parallel processing method of Monte Carlo method - Google Patents

Description

  The present invention relates to a Monte Carlo parallel processing technique, and more particularly to a Monte Carlo parallel processing technique that efficiently uses a parallel computer, and an apparatus and a computer program for executing the parallel processing technique.

  The Monte Carlo method is a technique widely used for analysis of probabilistic phenomena such as natural phenomena and social phenomena, and complex numerical integration. This Monte Carlo method is particularly effective for problems that are difficult to solve analytically. Since natural phenomena and social phenomena are mostly uncertain, the scope of application of the Monte Carlo method is very wide from the academic field to practice. Furthermore, the Monte Carlo algorithm (calculation procedure) is easy to understand. This is one reason why the Monte Carlo method is widely used. For example, specific examples of industrial use of the Monte Carlo method include simulation in the field of fluid dynamics, calculation of risk amounts in financial institutions, price calculation of various financial products, etc. Patent Document 1).

  On the other hand, in order to ensure the calculation accuracy of the Monte Carlo method, it is necessary to take a sufficient number of trials. As a result, the calculation time increases. In recent years, computers equipped with a plurality of processor cores have appeared one after another, and in the past, execution was performed with a single thread. It became relatively easy to shorten. Here, the thread refers to the flow of processing within the process. For the Monte Carlo method, the computation time can be shortened by parallel processing. In particular, the algorithm of the Monte Carlo method has a very high affinity with parallel processing, and there is an increasing demand for speeding up by the parallel processing of the Monte Carlo method.

  The parallel processing of the Monte Carlo method has been conventionally performed. That is, the entire trial of the Monte Carlo method is shared by a plurality of threads, and one computer or one processor core assigns one thread to each computer, so that each computer or processor core can perform processing independently. it can. For example, when the number of trials is 10,000 and parallel processing is performed by four computers, each computer may perform 2500 trials.

  However, in practice, the following two problems must be overcome. One is a problem of reproducibility of calculation results, and the other is a problem of correlation occurring between random number sequences.

  The reproducibility of the first calculation result means that the same calculation result can be obtained when numerical calculation by the Monte Carlo method is repeated using the same random number seed, that is, the same random number sequence. This reproducibility is indispensable when performing a back test or verifying the effect of changing calculation conditions. In general, when a program is parallelized, the sequentiality of processing is lost. Therefore, in order to ensure the reproducibility of calculation results, it is necessary to devise a method for generating and using random numbers.

  The correlation generated between the second random number sequences means that a correlation which cannot be said to be significantly zero is generated between the random number sequences used for each thread in the parallel processing of the Monte Carlo method. When such a correlation occurs, the reliability of the calculation result is lowered. Therefore, when generating a different random number sequence for each computer or processor core, it is necessary to use one having a very small correlation between random number sequences. . As a solution to this problem, either parallel processing is performed using one random number sequence, or random number sequences having a very small correlation with each other are generated and the parallel processing is simply performed. There is an algorithm for the latter, but there are many problems such as the need for processing for generating a random number sequence and verification of the independence of the random number sequence before executing the Monte Carlo method. Therefore, it is practically important to perform parallel processing using a single random number sequence and maintaining the reproducibility of the calculation result.

  When performing parallel processing using a single random number sequence and maintaining reproducibility of calculation results, a random number generation method at the time of executing the Monte Carlo method is essentially important. The existing technologies related to the parallel processing of the Monte Carlo method include the following.

[Prior art 1]
FIG. 1 is a diagram showing the assignment of trial numbers for each thread when parallel processing is performed using a parallel processing system having four threads as the prior art (hereinafter also referred to as prior art 1). The horizontal axis indicates the first to fourth threads, and the vertical axis indicates time t. A symbol A indicates a process for generating a random number used in a subsequent trial. A symbol B indicates an execution process of each trial. The numbers in parentheses following the symbol B are trial numbers. Symbol C indicates random number discarding processing or state variable skip processing described later.

  As shown in FIG. 1, in the prior art 1, the number of trials is equally distributed to each thread. Specifically, assuming that 10,000 trials are executed by four threads as described above, the first thread takes charge of the first to 2500th trials. The second thread is responsible for the 2501st to 5000th trials, the third thread is responsible for the 5001st to 7500th trials, and the fourth thread is responsible for the 7501th to 10000th trials. Handle. That is, each thread executes 2500 trials.

  A random number generator is prepared for each thread, and the same random number seed (random number sequence) is given to all random number generators. Each thread discards random numbers that are unnecessary for the trial that it is in charge of, and then performs the trial that it assigned.

  For example, if 100 random numbers are used for one trial, the first thread generates 100 × 2500 = 250,000 random numbers and performs the trial.

  Similarly, the second thread requires 250,000 random numbers. However, the second thread needs to generate 500,000 random numbers, discard the 250,000 in the first half, and use 250,000 in the second half for the trial. The first half 250,000 random numbers are used by the first thread for trial, and the second thread cannot use the first half 250,000 random numbers. If the second thread uses 250,000 random numbers in the first half, both the first thread and the second thread will try using the same random number, and the reliability of the result of the Monte Carlo method will decrease. End up. This random number discarding process is indicated by a symbol C in FIG.

  This is different from physical random numbers generated by using random physical phenomena such as dice rolls, and pseudo random numbers are generated by substituting previous random numbers into arithmetic expressions to generate new random numbers. This is because of the sequential nature. Therefore, in the second thread, unless the 1st to 250,000th random numbers are generated, the 2251st and subsequent random numbers cannot be generated.

  The third thread generates 750,000 random numbers. Then, after the first 250,000 random numbers used in the first thread and the next 250,000 random numbers used in the second thread are added together, 500,000 random numbers are discarded, Starting with the 2nd random number, trial is performed using 250,000 random numbers.

  Finally, the fourth thread generates 1 million random numbers. Then, add the first 250,000 random numbers used in the first thread, the next 250,000 random numbers used in the second thread, and the next 250,000 random numbers used in the third thread. After 750,000 random numbers are discarded, trial is performed using 250,000 random numbers starting from the 7501st.

  Here, it should be noted that the first thread does not perform random number discard processing.

  This enables parallel processing that overcomes the above two problems. However, in this method, since more random numbers have to be discarded as the thread in charge of subsequent trials, the number of trials is equal, but the processing load of each thread is unequal. In the example of FIG. 1, since the first thread does not perform random number discard processing, the processing load is the smallest among the four threads. Since the number of random numbers to be generated increases in the order of the second thread, the third thread, and the fourth thread, the processing load also increases in the same order. That is, the fourth thread has the largest processing load among the four threads.

ここで、Ｎ_Ｓｉｍはモンテカルロ法の試行回数であり、Ｎ_Ｔは並列処理を行うスレッドの数であり、ｔ_Ｓｉｍは１回の試行に要する時間であり、ｔ_Ｓｋｉｐは１回の試行に用いる乱数の捨象に要する時間である。 When the fourth thread finishes the 10,000th trial, the Monte Carlo method ends. The theoretical calculation time t _p1 required for the fourth thread to finish the 10,000th trial can be expressed as follows.

Here, N _Sim is the number of trials of the Monte Carlo method, _NT is the number of threads performing parallel processing, t _Sim is the time required for one trial, and t _Skip is a random number used for one trial. This is the time it takes to discard.

  In this processing method, the greater the number of threads, the more uneven the processing load appears. Therefore, the efficiency of parallel processing deteriorates as the number of threads increases.

[Prior Art 2]
An improved version of the above method is described in Patent Document 1. According to Patent Document 1, in the Monte Carlo method in various calculations of financial engineering, instead of assigning the number of trials assigned to each thread equally, by reducing the number of trials of the thread responsible for subsequent trials, It has been improved to make the processing load of threads uniform. This is shown in FIG. As in FIG. 1, symbol A indicates a random number generation process used in the subsequent Monte Carlo method. A symbol B indicates trial execution processing. The numbers in parentheses following the symbol B are trial numbers. A symbol C indicates a random number discarding process.

  As shown in FIG. 2, for example, the first thread is responsible for the first through 3000th trials. The second thread is responsible for the 3001st through 5750th trials. The third thread is responsible for the 5751st through 8000th trials. The fourth thread is responsible for the 8001st through 10000th trials.

  That is, the first thread is responsible for 3000 trials, the second thread is responsible for 2750 trials, the third thread is responsible for 2250 trials, and the fourth thread is responsible for 2000 trials.

  As described above, in the related art 2, the load of four threads is equalized as a whole by reducing the number of trial assignments of threads that need to generate a large number of random numbers as compared with other threads.

ここで、Ｎ_Ｓｉｍはモンテカルロ法の試行回数であり、Ｎ_Ｔは並列処理を行うスレッドの数であり、ｔ_Ｓｉｍは１回の試行に要する時間であり、ｔ_Ｓｋｉｐは１回の試行に用いる乱数の捨象に要する時間である。 In this prior art, when the number of trials is assigned so that the processing load of each processor core is uniform, the theoretical calculation time t _p2 required for the trial execution can be expressed as follows.

Here, N _Sim is the number of trials of the Monte Carlo method, _NT is the number of threads performing parallel processing, t _Sim is the time required for one trial, and t _Skip is a random number used for one trial. This is the time it takes to discard.

This technology also has the following problems. _First , in order to assign the optimum number of trials to each thread so that the processing load is uniform, it is necessary to measure the values of t _Sim and t _Skip , and an additional program for that is required. It is. The other is that since it is still necessary to perform random number randomization processing in each thread, the efficiency of parallel processing decreases as the number of threads increases, although this is improved compared to the prior art 1.

In Expressions (2) and (3), if the limit of the number of threads N _T → ∞ is taken, both become N _Sim t _Skip . That is, no matter how many threads are increased, N _Sim t _Skip calculation time is required. This is because random number generation is performed sequentially and the entire Monte Carlo method cannot be completely parallelized.

Japanese Patent No. 4032339 Tatsuya Ishikawa, Yoshihiko Uchida, “Pricing by Monte Carlo method and calculation of risk amount: Consideration of appropriate implementation method using normal random numbers”, Financial Research, Bank of Japan, Institute for Financial Research, June 2002, Volume 21 , Separate volume No. 1, p. 51-90

  In the present invention, it is necessary to calculate and determine in advance the number of trials each thread is in charge of in order to equalize the processing load without discarding useless random numbers in each thread, which was performed in the prior art. An object is to provide an efficient parallel processing method without any problem.

The present invention relates to a parallel processing method in which execution of a Monte Carlo method by a computer is performed in parallel using a state variable generation storage unit and a plurality of threads, the step of storing the state variable in the state variable generation storage unit, and one thread In a state in which only the processor core of the one thread can access under the exclusive control, the state variable stored in the state variable generation storage unit is sequentially skipped and converted for a predetermined number of times. And a random number generation step for generating a random number, and a trial calculation step in which the processor core of the one thread uses the generated random number to calculate a trial assigned to the one thread, and Provide a parallel processing method in which the random number generation step and the trial calculation step are sequentially executed in parallel in other threads.

  In the present invention, the random number generation step includes a step in which a processor core determines in one thread whether or not an exclusive lock is applied to a state variable generation storage unit in which a state variable used to generate a random number is stored. When the exclusive lock is not applied to the state variable generation storage unit, the processor core of the one thread applies an exclusive lock to the state variable generation storage unit, and the processor core of the one thread includes: A processing step of sequentially performing a skip process and a conversion process for a state variable stored in the state variable generation storage unit a predetermined number of times, and a processor core of the one thread performs an exclusive lock on the state variable generation storage unit And releasing the parallel processing method.

  Furthermore, the present invention is a parallel processing method for executing parallel execution of a Monte Carlo method by a computer using a state variable generation storage unit and a plurality of threads, and storing the state variable in the state variable generation storage unit, The processor core of the thread acquires a state variable stored in the state variable generation storage unit in a state where only the processor core of the one thread is accessible under exclusive control, and the state variable A state variable skip processing step that sequentially performs skip processing over the number of times, and a step in which the processor core of the one thread performs conversion processing and skip processing on the acquired state variable a predetermined number of times to generate a random number; The processor core of the one thread is assigned to the one thread using the generated random number. And a trial calculation step of performing calculation was attempted, also provides a parallel processing method slide into sequentially executed in parallel in the other threads each step.

Here, in the state variable skip processing step, the processor core determines in one thread whether or not an exclusive lock is applied to a state variable generation storage unit in which a state variable used for generating a random number is stored. When the exclusive lock is not applied to the state variable generation storage unit, the processor core of the one thread applies an exclusive lock to the state variable generation storage unit, and the processor core of the one thread includes: Acquiring a value of the state variable from the state variable generation storage unit, and the processor core of the one thread sequentially skips the state variable stored in the state variable generation storage unit a predetermined number of times. The processing step to be performed and the processor core of the one thread have an exclusive lock on the state variable generation storage unit. The may be one comprising the step of releasing.

  These parallel processing methods measure the credit risk of a portfolio that includes multiple bonds in the field of financial engineering, calculate the price of financial products by modeling changes in the financial market, and further It can be used to perform the Monte Carlo method to measure the amount of market risk caused by fluctuations in

  The present invention also provides a program for causing a computer to execute each step of these parallel processing methods.

Furthermore, the present invention is a parallel processing system that executes a Monte Carlo method by a computer by parallel processing using a state variable generation storage unit and a plurality of threads, in order to generate a random number that is shared by the plurality of threads. A state variable generation storage unit that stores state variables to be used, and a random number generation that sequentially performs conversion processing and skip processing for a predetermined number of times on the state variables stored in the state variable generation storage unit And an exclusive lock control unit that applies an exclusive lock to the state variable generation storage unit or releases an exclusive lock for each thread, and an operation that performs a trial operation using the random number generated by the random number generation unit A parallel processing system including a processing execution unit is provided.

  The present invention is a parallel processing system that executes a Monte Carlo method by a computer by performing parallel processing using a state variable generation storage unit and a plurality of threads, and generates a random number that is shared by the plurality of threads. A state variable generation storage unit in which state variables used for storage are stored, a state variable skip processing unit that sequentially performs skip processing over a predetermined number of times for the state variables stored in the state variable generation storage unit, For a thread, an exclusive lock control unit that applies an exclusive lock to the state variable generation storage unit or releases an exclusive lock, and a state variable acquisition that acquires the value of the state variable from the state variable generation storage unit and stores it in the memory Parts and state variables stored in memory are converted and skipped a predetermined number of times to generate random numbers. A random number generator which also provides a parallel processing system comprising a processing execution unit for performing computation of the trial using the random number generated by the random number generating unit.

  According to one embodiment of the present invention, the amount of credit risk in the field of financial engineering can be measured using the Monte Carlo method. That is, the method of the present invention is used when modeling changes in the value of individual obligors (usually companies) and measuring the credit risk amount (credit VaR, conditional credit VaR, etc.) of the portfolio or bank. By executing the Monte Carlo simulation, the overall credit risk amount can be calculated.

  Similarly, the amount of market risk in the financial market can be measured using the Monte Carlo method of the present invention. Specifically, by modeling changes in stock prices in the stock market and bond prices in the bond market, and executing a Monte Carlo simulation using the method of the present invention, the amount of market risk caused by these market fluctuations can be calculated. It can be measured.

  Alternatively, the price of the financial product can be calculated using the Monte Carlo method of the present invention. That is, by modeling the change in the financial market and executing Monte Carlo simulation using the method of the present invention, it is possible to calculate the price of financial products such as various securities and derivatives.

  In the present invention, parallel processing of the Monte Carlo method that realizes almost ideal parallel efficiency is realized. Further, the present invention has a feature that mounting is easy. Since the present invention is a technique related to a general Monte Carlo method and can be applied to any field, as described above, it is considered that the field in which the present invention can enjoy the advantages of reducing the calculation load of the Monte Carlo method is very wide. In addition to each field of financial engineering, it is useful in various fields such as fluid dynamics and molecular dynamics. In addition, the above two disadvantages of the prior art, namely, the disadvantage that the efficiency of parallelization decreases as the number of threads increases due to the discarding of useless random numbers, and the disadvantage that the number of trials assigned to each thread must be calculated in advance. Both can be eliminated, and more efficient parallel processing becomes possible.

It is a schematic diagram which shows a mode that the frequency | count of trial is allocated to each thread | sled based on a prior art. It is a schematic diagram which shows a mode that the frequency | count of trial is allocated to each thread | sled based on a prior art. It is a schematic diagram which shows the flow of the process which produces | generates a random number. It is a block diagram of the parallel processing system which performs the parallel processing of a Monte Carlo method. It is a flowchart which shows the flow of the parallel processing of a Monte Carlo method. It is a schematic diagram which shows a mode that the frequency | count of trial is allocated to each thread | sled. It is a table | surface which shows the comparison of the calculation time with the prior art 1. FIG. It is a table | surface which shows the comparison of the calculation time with the prior art 2. FIG. This is an example of a program for obtaining the area of a circle with a radius of 0.5 by sequentially processing the Monte Carlo method. This is an example of a program for calculating the area of a circle with a radius of 0.5 by parallel processing of the Monte Carlo method. This is an example of a program for calculating the area of a circle with a radius of 0.5 by parallel processing of the Monte Carlo method. It is an example program of a random number generation class.

  First, random number generation processing will be described. FIG. 3 is a schematic diagram showing a flow of processing for generating a random number. In order to generate a random number, first, a value which is called a seed (random number seed) and is a source for generating a pseudo-random number is prepared. This seed is denoted by reference numeral 101. The seed 101 can be input through a keyboard or can be prepared using a dedicated program.

  In step S1, the state variable 102 is calculated from the prepared seed 101. A state variable is generally a vector whose elements are integers. Next, as step S2, a random number 103 is generated from the initial state variable 102. In step S3, a new state variable 104 is calculated from the initial state variable 102. In step S4, a random number 105 is generated from the state variable 104. In step S5, a new state variable 106 is calculated from the state variable 104. In step S6, a random number 107 is generated from the state variable 106.

  Alternatively, steps S1, S3, S5, S7,... Are executed to generate necessary random numbers of state variables. Then, steps S2, S4, S6,... Can be executed to generate random numbers.

  In this way, a plurality of random numbers can be generated by repeating the calculation of state variables and the generation of random numbers. Specific examples of the random number generation method include the Mersenne Twister method and the linear congruence method. The linear congruence method can be grasped in the framework of the random number generation process described above by considering that the state variable itself is a random number.

  A process of calculating a new state variable from a certain state variable as in steps S3, S5, and S7 is referred to as a state variable skip process. As described above, when the skip process is performed on the state variable, the value of the state variable is updated.

  As described above, the generation of random numbers can be divided into a state variable skip process and a conversion process that converts state variables into random numbers. It is also possible to generate a random number immediately after each skip process. The present invention is based on the knowledge that, by using exclusive control and sharing the value of a state variable among all threads, unnecessary random number round-off processing in the prior art becomes unnecessary.

  As one method for realizing the present invention, the following embodiment can be considered. That is, one random number generation module capable of holding state variable information is prepared and shared by all threads. By combining this module and parallel task scheduling as described below, random number assignment without wasteful separation is realized.

  For example, consider a case where the first thread enters the random number generation process in a certain trial. At this time, under exclusive control, the first thread sequentially performs conversion processing and skip processing in the module, generates a random number necessary for one trial, and stores it in the local memory in the thread. By this process, the state variable obtained by the last skip process is stored in the module. Thereafter, the exclusive control is released, and the first thread performs one trial of the Monte Carlo method based on the random number stored in the local memory. Next, the second thread performs a random number skip process and a conversion process required in one trial in the module under the same exclusive control. In this way, the processing proceeds in the same manner for other threads.

  In the above embodiment, as the number of random numbers used for one trial increases, the capacity of local memory used in each thread increases, and the number of memory accesses associated with storing and calling random numbers also increases. For this reason, when the number of random numbers used for one trial is large, the time required to access the memory cannot be ignored, and the processing time may increase. A method for avoiding the possibility of increasing the processing time described above by minimizing the memory usage will be described in the following embodiment.

As another method for realizing the present invention, the following embodiment can be considered. That is, modules having two memory holding modes are prepared according to the purposes of skip processing and conversion processing. On top of that, to prepare one module for saving the skip process state variables (hereinafter referred to as module m _0), shared by all threads. Further, a module for generating a random number by performing conversion processing and skip processing on the state variable is prepared for each thread (hereinafter referred to as m ₁ , m ₂ ,..., M _NT ).

By combining these (N _T +1) modules and parallel task scheduling as follows, random number assignment without wasteful retirement is realized. For example, consider a case where the first thread enters the random number generation process in a certain trial. At this time, under exclusive control, the first thread copies the state variable stored in the module m ₀ to the module m ₁ . Further, a skip process for a random number necessary for one trial is performed in the module m ₀ . By this process, the module m ₀ is in a state where the state variable obtained by the last skip process is stored. Thereafter, the exclusive control is released, and the first thread performs conversion processing and skip processing locally using the module m ₁ , and generates a random number necessary for executing the trial. Next, under the same exclusive control, the second thread copies the state variable information stored in the module m ₀ to the module m ₂ and then performs the skip process of the module m ₀ . In this way, the processing proceeds in the same manner for other threads.

  Even in the series of operations described above, useless random numbers are not discarded. In addition, since the same random number is assigned to each trial regardless of which thread is assigned in any order, the reproducibility of the calculation result is obtained, and it is not necessary to determine the number of trials assigned to each thread in advance.

In the above series of operations, only the state variables stored in the module m ₀ are copied onto the local memory of each thread, and access to the memory is reduced compared to the first embodiment. be able to. On the other hand, it is necessary for each thread to perform a state variable skip process at the time of random number generation performed by each thread in addition to the module m ₀ . For this reason, which embodiment has the faster processing time depends on the hardware and the object of analysis.

  As can be seen from the above two embodiments, in the present invention, it is necessary to perform exclusive control for the state variable skip processing. Various methods for realizing exclusive control are known, but the present invention is not based on a specific exclusive control method. Any exclusive control method can be used as long as the skip processing of the state variable shared by each thread can be avoided from being simultaneously performed by a plurality of threads. This exclusive control can be executed using, for example, the concept of a synchronization object and an exclusive lock. Before entering a part where exclusive control is required, that is, a certain session, a certain object is locked. While the key is locked, other threads cannot lock the same object and wait until the key is removed. The locked thread then unlocks the object after finishing that particular session. At this time, the object to be locked is called a synchronization object, and the lock operation is called an exclusive lock. This synchronization object can be regarded as a state variable generation storage unit described below, or can be regarded as other target or abstract data.

  FIG. 4 is a block diagram of a parallel processing system 400 that executes the Monte Carlo method in parallel according to one embodiment. The parallel processing system 400 includes an input device 410 including a keyboard and a mouse, and a display device 420 such as an LCD (Liquid Crystal Display) display.

  The parallel processing system 400 further includes a parallel processing control unit 430, a first thread 440, a second thread 450, a third thread 460, a fourth thread 470, and a global storage unit 480. The first to fourth threads 440, 450, 460, and 470 can be realized using a computer having four or more processor cores, or can be realized using four or more computers. In addition, the parallel processing system 400 itself can be realized by using a computer system including a multiprocessor computer having four or more processors.

  The global storage unit 480 includes a state variable generation storage unit 481 that stores state variables and a state variable skip processing unit 482. The state variable generation storage unit 481 and the state variable skip processing unit 482 can be accessed by any of the first thread to the fourth thread to acquire the value of the state variable and perform a skip process.

  Upon receiving an instruction from the input device 410, the parallel processing control unit 430 receives a state variable generation storage unit 481, a state variable skip processing unit 482, a first thread 440, a second thread 450, and a third thread 460. The fourth thread 470 is instructed to process the Monte Carlo method in parallel. Each thread can be executed by one processor core.

  At this time, the parallel processing control unit 430 generates a state variable using the seed received from the input device 410 and stores it in the state variable generation storage unit 481. Alternatively, the parallel processing control unit 430 can generate a seed using its own program, generate a state variable from the seed, and store it in the state variable generation storage unit 481.

  The first thread 440, the second thread 450, the third thread 460, and the fourth thread 470 receive control of the parallel processing control unit 430 and execute the Monte Carlo method in parallel. Although the parallel processing system 400 of this embodiment has four threads, it is not limited to this. The number of threads can be an arbitrary integer, and can be changed according to the hardware configuration.

  The first to fourth threads 440, 450, 460, 470 all have the same structure. For example, the first thread includes a trial count counting unit 441, an exclusive lock control unit 442, a state variable acquisition unit 443, a random number generation unit 445, a trial execution unit 446, and a local storage unit 447. .

  The parallel processing system 400 also has a result output unit 490. The result output unit 490 can collectively output the results obtained by the trials executed by the four threads 440, 450, 460, and 470 to the display device 420.

FIG. 5 is a flowchart of processing performed in parallel by the first to fourth threads 440, 450, 460, and 470 shown in FIG. As an example, the number of trials N _{sim is set} to 10,000 times (N _sim = 10000).

Hereinafter, the flow of processing will be described using the first thread 440 as an example. First, processing is started in step S501. In step S502, the trial number counting unit 441 determines the magnitude relationship between the variable n indicating the number of trials and the number of trials N _sim . Note that the value of the variable n is initialized to 0 at the start of processing.

In step S502, if the trial number counting unit 441 determines that n <N _sim , the process proceeds to step S503. On the other hand, if the trial number counting unit 441 does not determine that n <N _sim , the process proceeds to step S511 and the process ends.

  In step S503, the trial number counting unit 441 increments n. That is, the result obtained by calculating n + 1 is set as a new value of n. The new value of n obtained at this time is the number of trials to be executed.

  In step S504, the exclusive lock control unit 442 attempts to access the state variable generation storage unit 481. When none of the exclusive lock control units 452, 462, and 472 of the second to fourth threads has an exclusive lock on the state variable generation storage unit 481, the first thread 440 is in the state variable generation storage unit. 481 can be accessed, and then the process proceeds to step S505.

  On the other hand, at step S504, one of the exclusive lock control units 452, 462, and 472 of the second to fourth threads, for example, the exclusive lock control unit 472 in the fourth thread is in response to the state variable generation storage unit 481. When the exclusive lock is applied, the first to third threads 440, 450, and 460 cannot access the state variable generation storage unit 481. In that case, step S504 is executed again after a certain time.

  In step S505, the exclusive lock control unit 442 of the first thread 440 places an exclusive lock on the state variable generation storage unit 481. As a result, none of the second, third, and fourth threads 450, 460, and 470 can access the state variable generation storage unit 481.

  If exclusive control of access to the state variable generation storage unit 481 is not performed, a plurality of threads can access at the same time, and the plurality of threads generate random numbers using the same state variable. In this case, some random numbers used in different threads are duplicated, and the obtained Monte Carlo method results are also unreliable. In this way, the exclusive access control described above is effective to prevent a plurality of threads from using the same state variable redundantly.

  In step S506, the state variable acquisition unit 443 of the first thread accesses the state variable generation storage unit 481, acquires the value of the state variable stored in the state variable generation storage unit 481, and the local storage unit 447. Save to.

  In step S507, the state variable skip processing unit 482 executes a skip process on the state variables stored in the state variable generation storage unit 481. Specifically, the state variable skip processing unit 482 repeatedly executes steps S3, S5, S7,... Shown in FIG. At this time, the number of repetitions is the same value as the number of random numbers required to perform one simulation.

  For example, if 100 random numbers are required for one trial, in step S507, the state variable skip processing unit 482 performs the state variable skip processing (steps S3, S5, S7,...) Shown in FIG. Repeat 100 times.

  At this time, the state variable acquired in step S506 is stored in the local storage unit 447 of the first thread 440. The state variable generation storage unit 481 stores a state variable corresponding to the first random number used in the next trial.

In step S508, the exclusive lock control unit 442 of the first thread 440 releases the exclusive lock on the state variable generation storage unit 481. As a result, the second to fourth threads 450, 460, and 470 can access the state variable generation storage unit 481.

  In step S509, the state variable stored in the local storage unit 447 is called, and the value is passed to the random number generation unit 445.

  In step S510, the trial execution unit 446 executes one trial while the random number generation unit 445 generates 100 random numbers. Thereafter, the process proceeds to step S502.

  As described above, the first thread 440 can execute the Monte Carlo method that it is in charge of. The second thread 450, the third thread 460, and the fourth thread 470 can also execute the Monte Carlo method that they are responsible for by executing the processing shown in FIG. As a result, the first thread 440, the second thread 450, the third thread 460, and the fourth thread 470 can execute all trials in parallel.

  As described above, the present invention eliminates useless state variable skip processing by sharing state variable information among all threads while using exclusive control.

  FIG. 6 is a diagram illustrating an example of a trial assignment of each thread according to the embodiment. The horizontal axis indicates the first to fourth threads, and the vertical axis indicates time t. Like FIG. 1 and FIG. 2, the code | symbol A has shown the production | generation process of the random number used for the trial of the subsequent Monte Carlo method performed. A symbol B indicates trial execution processing. The numbers in parentheses following the symbol B are trial numbers. Here, unlike FIG. 1 showing the prior art 1 and FIG. 2 showing the prior art 2, in the above embodiment, the codes C representing the random number round-off process are distributed among the threads, and the processing load is made uniform. You can see that The reason why the load of each thread can be equalized in this way is that all the threads share state variable information used for trials by using the state variable generation and storage unit.

  In the example shown in FIG. 6, the first thread executes trials of n = 2, 6,..., 9998, and the second thread executes trials of n = 1, 5,. The third thread executes trials of n = 4, 8,..., 10000, and the fourth thread executes trials of n = 3, 7,. However, since the assignment of the trial number to each thread is automatically determined by the parallel task scheduling of the OS, in general, the trial number assigned to each thread is different for each execution. Further, the number of trials executed by each thread is not necessarily the same. On the other hand, in the method of the present invention, since the same random number is always assigned to trials with the same trial number, the execution result of the Monte Carlo method is reproducible.

  In a multitasking OS, even if trial execution is being performed, other tasks may be assigned to the processor core by the OS, and even if processing is assigned to each thread so that the amount of calculation is equalized, each processor core The time required to complete the process is not always uniform. According to the method of the present invention, there is an advantage that a large number of trial processes are automatically assigned to a processor core that is lightly loaded by other tasks and the load among the processor cores is automatically distributed.

ここで、Ｎ_Ｓｉｍはモンテカルロ法の試行回数であり、Ｎ_Ｔは試行を実行するスレッドの数であり、ｔ_Ｓｉｍは１回の試行に要する時間であり、ｔ_Ｓｋｉｐは１回の試行に用いる乱数のスキップ処理に要する時間である。 The parallel processing in the above embodiment ends when the 10,000th trial is completed. The theoretical calculation time t _MC required to finish the 10000th trial can be expressed as follows.

Here, N _Sim is the number of trials of the Monte Carlo method, _NT is the number of threads executing the trial, t _Sim is the time required for one trial, and t _Skip is a random number used for one trial. This is the time required for the skip process.

In the case of the number of threads N _T ≦ t _Sim / t _Skip , since the skip process of other threads is completed while the trial execution process is being performed, the processing wait time due to the exclusive lock does not occur. In this case, as can be seen from equation (4), increasing the number of threads N _T, the calculation time t _MC becomes shorter accordingly. On the other hand, when the number of threads N _T ≧ t _Sim / t _Skip , the calculation time t _MC does not change even if the number of threads N _T is increased. This is because in this case, processing wait time due to exclusive lock occurs.

Table 1 shown in FIG. 7 represents a comparison of theoretical calculation times between the embodiment of the present invention and the above-described related art 1. The horizontal axis represents the number of threads, and the vertical axis represents t _Sim / t _skip . The values in the table are (theoretical calculation time according to an embodiment of the present invention) / (theoretical calculation time of the prior art 1).

The larger the value of t _Sim / t _skip, the more complicated the trial takes for the processing other than random number generation. If t _Sim / t _skip = 1, that is, if the time t _Sim required for one trial is equal to the time t _Skip required for skipping the random number used for one trial, a random number is generated. This means that no calculation using random numbers is performed. This is meaningless in practical use, but is included for reference as a comparison of calculation time.

According to Table 1, when the number of threads is 20 and t _Sim / t _skip = 20, (theoretical calculation time according to an embodiment of the present invention) / (theoretical calculation time of prior art 1) ) = 0.54. That is, it means that the calculation time can be almost halved as compared with the prior art 1.

Table 2 shown in FIG. 8 represents a comparison of theoretical calculation time between the embodiment of the present invention and the above-described related art 2. Similar to Table 1, the horizontal axis represents the number of threads, and the vertical axis represents t _Sim / t _skip . The value in the table is (theoretical calculation time according to one embodiment of the present invention) / (theoretical calculation time of the prior art 2). In the prior art 2, it is necessary to measure t _Sim and t _skip before executing the Monte Carlo method in order to achieve a theoretical calculation time. However, in this comparison, the time required for the measurement is not considered. .

According to Table 2, when the number of threads is 20 and t _Sim / t _skip = 20, (theoretical calculation time according to an embodiment of the present invention) / (theoretical calculation time of the prior art 2) ) = 0.67. That is, it means that the calculation time can be shortened to almost two thirds compared with the conventional technique 2 which is superior to the conventional technique 1.

[Example]
Hereinafter, an embodiment in which the area of a circle having a radius of 0.5 is obtained using the Monte Carlo method will be described. First, FIG. 9 shows an example of a program that performs the Monte Carlo method sequentially rather than in parallel. Here, a C ++ language is used as a programming language. “1”, “2”,..., “20” shown on the left side of each line of the program shown in FIG. 9 represents the line number of the program and constitutes the program itself. It is not a thing.

  “AreaOfCircle” on the first line is a function for obtaining the area of a circle having a radius of 0.5 by the Monte Carlo method. The argument “NSim” of this function is a variable representing the number of trials, and the argument “seed” is a value from which a pseudo-random number is generated. The function “AreaOfCircle” is defined in the 2nd to 20th lines.

  The variables “x” and “y” on the fourth line are variables for setting the generated random number as the x coordinate value and the y coordinate value. The variable “r_sq” in the fifth row stores a value obtained by squaring the distance between the center point (0.5, 0.5) of a circle having a radius of 0.5 and a point on the XY plane obtained by random number generation. Variable. The variable “s” on the sixth line is a variable for storing the number of points included in a circle having a radius of 0.5 among a plurality of points on the XY plane obtained by random number generation.

  “RandomNumberGenerator” on the seventh line is a class that generates a uniform random number in the (0, 1) interval. Details thereof will be described later. In the 10th line, the argument “seed” of the function “AreaOfCircle” is initialized.

The 13th to 18th lines are loops for performing the Monte Carlo method. Starting with the variable SimNo = 0 indicating the trial number, N _Sim trials are sequentially performed. In the 14th and 15th lines, one random number is generated, and the respective values are set as the X coordinate value and the Y coordinate value. Thereby, points on the XY plane can be determined randomly. In the 16th line, using the Pythagorean theorem, the distance between the point on the XY plane defined in the 14th line and the 15th line and the center point (0.5, 0.5) of the circle is calculated. The square is calculated and stored in the variable r_sq. In the 17th line, the magnitude relationship between r_sq and 0.25 (= 0.5 * 0.5) is determined, and when r_sq <0.25 is satisfied, that is, on a randomly defined XY plane. If the point is contained within a circle with a radius of 0.5, the variable s is incremented. The s / N _{Sim on} the 19th line is the return value of the function AreaOfCircle, that is, the area of the obtained circle. The larger the value of the number of trial executions N _Sim, the closer the obtained circle area is to π * 0.5 * 0.5.

  FIG. 10 is a program example in which the program example of FIG. 9 is parallelized. In the program example shown in FIG. 10, parallelization is performed using OpenMP, which is a standard for performing parallel computation. OpenMP is mainly used in shared memory parallel computers.

The first line is a declaration statement of the function AreaOfCircle having the variable N _Sim and the variable seed as arguments, as in FIG.

  The fifth line declares a random number generation class RandomNumberGenerator for acquiring the value of the state variable. This random number generation class RandomNumberGenerator is a class shared by all threads. As shown in FIG. 12 later, this class includes member variables corresponding to state variables, and can play a role of the state variable generation storage unit 481. Also included are methods that perform state variable skip processing, state variable value acquisition processing, and random number generation processing.

  The variable s in the sixth row is a variable for storing the number of points included in a circle having a radius of 0.5 among a plurality of points on the XY plane obtained by random number generation, as in FIG.

The twelfth to thirty-second lines are portions where the threads execute processing in parallel. That is, starting from the variable SimNo = 0, N _Sim times of trials are shared and executed by the threads 440, 450, 460, and 470 shown in FIG.

  The 22nd and 27th lines are processes for performing exclusive lock control on the state variable generation storage unit 481. This corresponds to the processing performed by the exclusive lock control units 442, 452, 462, and 472 in FIG. With this process, when a certain thread is performing a random number generation process (lines 25 and 26), other threads cannot execute the random number generation process.

The s / N _Sim calculated in the 33rd line is the return value of the function AreaOfCircle, that is, the area of the obtained circle. This calculation corresponds to the processing of the result output unit 490 in FIG.

  The descriptions on the 12th, 19th, and 22nd lines indicate instructions for parallel processing by OpenMP.

  In the program example shown in FIG. 10, unlike the block diagram shown in FIG. 4, the random number generation unit is shared by all threads, and there is no state variable acquisition unit or random number generation unit in each thread. On the other hand, the invention has a feature that information on state variables is shared by all threads while using exclusive control. Such an example is also included in the scope of the present invention.

  In the example of the program shown in FIG. 10, the number of random numbers used for one trial is as small as two. However, in a simulation using many random numbers for one trial, the memory capacity used in each thread increases, and the memory is accessed. The number of times also increases. For this reason, depending on the hardware and the object of analysis, a program similar to that shown in FIG.

  A method of reducing the possibility of the above increase in processing time by minimizing the processing in the exclusive control unit in the program example of FIG. That is the program example shown in FIG.

The fifth line declares a random number generation class RandomNumberGenerator shared by all threads, as in FIG. This class includes a member variable corresponding to a state variable, so that information on the state variable is shared by all classes.

  The sixth line defines a variable NRand representing the number of random numbers used in one Monte Carlo method. In this example, NRand = 2. This is because, for each trial, a total of two random numbers including a random number for setting the X coordinate value and a random number for setting the Y coordinate value are required.

  The 28th line and the 34th line are processes for controlling the exclusive lock for the state variable generation storage unit 481. With this process, when a certain thread is acquiring the value of the state variable (line 31) and when performing a state variable skip process (line 33), the other threads Therefore, neither the acquisition of the value of the state variable nor the skip process can be performed.

  In the 37th line, the previously obtained state variable is set in the random number generation class of each thread. Then, random numbers are generated on the 38th and 39th lines, and set as the X coordinate value and the Y coordinate value, respectively.

  FIG. 12 shows an example of a program for declaring a random number generation class “RandomNumberGenerator” used in each of the example programs of FIGS. 9, 10, and 11. In the 10th line in FIG. 12, a member variable state_vec corresponding to the state variable is declared. By storing the value of the state variable in this variable, this class can serve as the state variable generation storage unit 481. The class RandomNumberGenerator includes a method for generating a random number (the 23rd line), a method for performing a state variable skipping process (the 26th line), and a method for performing a state variable value acquiring process (the 2nd line). (29th line) is prepared. In the block diagram of FIG. 4, these are respectively a random number generator (reference numerals 445, 455, 465, and 475), a state variable skip processing section (reference numeral 482), and a state variable acquisition section (reference numerals 443, 453, 463, and 473). ). The actual processing of this class varies depending on whether the Mersenne Twister method, linear congruential method, or other methods are used as the random number generation algorithm.

  Parallel computers can be broadly divided into shared memory type parallel computers and distributed memory type parallel computers. The shared memory type parallel computer is a type of computer in which all processor cores share memory. This memory is called a shared memory. The shared memory parallel computer has an advantage that data exchange between processor cores is easy. On the other hand, when the number of processor cores is large, writing to the shared memory competes and there is a disadvantage that the performance may be reduced. OpenMP can be used for mounting on a shared memory parallel computer.

  The distributed memory type parallel computer can execute each of the first to fourth threads 440, 450, 460, and 470 shown in FIG. 4 by several processors having separate memories. In order to exchange data between processors, it is necessary to communicate between processors. MPI (Message Passing Interface) can be used for mounting on a distributed memory parallel computer.

  The above embodiment can be implemented in either a shared memory type parallel computer or a distributed memory type parallel computer. That is, as long as all of the first to fourth threads 440, 450, 460, and 470 shown in FIG. 4 can share the state variable information, any of the shared memory type parallel computer and the distributed memory type parallel computer can be used. Can also be implemented. In addition, each thread can be configured to be handled by one processor core, or each thread itself can be processed by two or more processor cores.

  Note that the hardware configuration of the computer for implementing each embodiment of the present invention is not limited to the configuration specifically shown, and has one or more dedicated numerical arithmetic units in accordance with the numerical arithmetic format. Or a cluster configuration that is divided into a plurality of housings and connected to each other via a network. It should be noted that the functional means described separately in the present invention as well as in the present embodiment are realized by any component that substantially performs such a distinguished function. At this time, the present invention is limited by an attribute that is not limited in performing functions such as how many physical components there are, or a plurality of components and in what positional relationship with each other. There is nothing. For example, it is within the scope of the present invention that multiple distinct functions are performed at different times over time by a single component.

  The software configuration for performing numerical calculation in the computer that implements the functional processing of each embodiment of the present invention can be any configuration as long as the numerical information processing of each embodiment of the present invention is realized. The computer is equipped with software for hardware control, such as a basic input / output system (BIOS), and operates in conjunction with this to operate an operating system (in charge of file input / output and allocation of hardware resources). OS). The OS can execute an application program that operates in cooperation with the OS or hardware based on, for example, an explicit instruction from the user, an indirect instruction from the user, or an instruction from another program. The application program is appropriately programmed so as to enable such operations and to operate in association with the OS, depending on the procedure defined by the OS or not depending on the OS. When implementing each embodiment of the present invention, generally, processing such as numerical calculation and file input / output is implemented in the form of a dedicated application program, but the present invention is not limited thereto, Uses multiple dedicated or general purpose application programs, partially uses pre-made numerical libraries, is implemented by network programming techniques to be processed by other computer hardware, or any other implementation Can be realized. Therefore, software that expresses a series of instructions for implementing the calculation method of each embodiment of the present invention on a computer is simply called a program. The program can be expressed in any format that can be executed by a computer or in any format that can ultimately be converted into such a format.

  In the program according to each embodiment of the present invention, an arithmetic unit such as an MPU that is a hardware resource receives a command from a calculation program via the OS or without going through the OS, and the main memory or auxiliary memory that is the hardware resource. In cooperation with a storage means such as a storage device, it is configured to perform arithmetic processing through an appropriate bus as a hardware resource. That is, the information processing by software that realizes the calculation method of each embodiment of the present invention is implemented so as to be realized by these hardware resources. The storage means or storage unit refers to a part or all of a computer-readable information storage medium that is logically divided by an arbitrary unit, or a combination thereof. This storage means is realized by an arbitrary hardware resource such as a cache memory in the MPU, a main memory connected to the MPU, or a non-volatile storage medium such as a hard disk drive connected to the MPU by an appropriate bus. The Here, the storage means is an area in the memory defined by the MPU architecture, a file or folder on the file system managed by the OS, or a database accessible in any computer on the same computer or network. Realized in any format, such as a list or record in a management system, or a record managed by multiple lists that are related to each other by a relational database, logically separated from the others, and at least temporarily stored so that information can be identified Or anything that can be recorded.

400 Parallel processing system 410 Input device 420 Display device 430 Parallel processing control unit 440 First thread 450 Second thread 460 Third thread 470 Fourth thread 441, 451, 461, 471 Trial count unit 442, 452, 462, 472 Exclusive Lock control unit 443, 453, 463, 473 State variable acquisition unit 445, 455, 465, 475 Random number generation unit 446, 456, 466, 476 Trial execution unit 447, 457, 467, 477 Local storage unit 480 Global storage unit 481 State Variable generation storage unit 482 State variable skip processing unit 490 Result output unit

Claims (13)

A parallel processing method in which execution of a Monte Carlo method by a computer is processed in parallel using a state variable generation storage unit and a plurality of threads,
Storing the state variable in the state variable generation storage unit;
In a state where the processor core of one thread can access only the processor core of the one thread under exclusive control, the state variable stored in the state variable generation storage unit is sequentially skipped a predetermined number of times. And a random number generation step for generating a random number by performing a conversion process,
The processor core of the one thread includes a trial calculation step of performing a trial calculation assigned to the one thread using the generated random number, and the random number generation step and the trial calculation step are performed in other threads as well. A parallel processing method that executes sequentially in parallel. The random number generation step includes:
A step in which a processor core determines in one thread whether or not an exclusive lock is applied to a state variable generation storage unit in which a state variable used for generating a random number is stored;
If the state variable generation storage unit is not locked exclusively, the processor core of the one thread locks the state variable generation storage unit;
A processing step in which the processor core of the one thread sequentially performs a skip process and a conversion process over a predetermined number of times with respect to the state variables stored in the state variable generation storage unit;
The parallel processing method according to claim 1, further comprising: a processor core of the one thread releasing an exclusive lock on the state variable generation storage unit. A parallel processing method in which execution of a Monte Carlo method by a computer is processed in parallel using a state variable generation storage unit and a plurality of threads,
Storing the state variable in the state variable generation storage unit;
A processor core of one thread obtains a state variable stored in the state variable generation storage unit in a state where only the processor core of the one thread can access under exclusive control, and for the state variable A state variable skip processing step for sequentially performing skip processing for a predetermined number of times;
The processor core of the one thread generates a random number by performing conversion processing and skip processing for a predetermined number of times for the acquired state variable;
The processor core of the one thread performs a trial operation step of performing an operation of the trial assigned to the one thread using the generated random number, and sequentially executing each step in parallel in other threads Parallel processing method. The state variable skip processing step includes:
A step in which a processor core determines in one thread whether or not an exclusive lock is applied to a state variable generation storage unit in which a state variable used for generating a random number is stored;
If the state variable generation storage unit is not locked exclusively, the processor core of the one thread locks the state variable generation storage unit;
The processor core of the one thread acquires a value of a state variable from the state variable generation storage unit;
A processing step in which the processor core of the one thread sequentially performs a skip process over a predetermined number of times with respect to the state variables stored in the state variable generation storage unit;
The parallel processing method according to claim 3, wherein the processor core of the one thread releases an exclusive lock on the state variable generation storage unit.   A method for measuring a credit risk amount of a portfolio including a plurality of bonds, wherein the credit risk amount is measured by executing a Monte Carlo method using the method according to claim 1.   A method for measuring an amount of market risk caused by a change in a financial market by executing a Monte Carlo method using the method according to claim 1.   A method for calculating a price of a financial product by modeling a change in a financial market and executing a Monte Carlo method using the method according to claim 1. A parallel processing system that executes a Monte Carlo method by a computer by parallel processing using a state variable generation storage unit and a plurality of threads,
A state variable generation and storage unit in which state variables used for generating random numbers are shared by the plurality of threads;
A random number generator that generates a random number by sequentially performing a conversion process and a skip process over a predetermined number of times for the state variables stored in the state variable generation storage unit,
For each thread, an exclusive lock control unit that applies an exclusive lock to the state variable generation storage unit or releases the exclusive lock; and
A parallel processing system comprising: an arithmetic processing execution unit that performs a trial calculation using the random number generated by the random number generation unit. A parallel processing system that executes a Monte Carlo method by a computer by performing parallel processing using a state variable generation storage unit and a plurality of threads,
A state variable generation and storage unit in which state variables used for generating random numbers are shared by the plurality of threads;
A state variable skip processing unit that sequentially performs skip processing over a predetermined number of times for the state variables stored in the state variable generation storage unit,
For each thread, an exclusive lock control unit that applies an exclusive lock to the state variable generation storage unit or releases the exclusive lock; and
A state variable acquisition unit that acquires a value of the state variable from the state variable generation storage unit and stores the value in a memory;
A random number generator that performs a conversion process and a skip process on a state variable stored in the memory a predetermined number of times to generate a random number;
A parallel processing system comprising: an arithmetic processing execution unit that performs a trial calculation using the random number generated by the random number generation unit.   The parallel processing system according to claim 8 or 9, which measures a credit risk amount of a portfolio including a plurality of bonds.   The parallel processing system according to claim 8 or 9, which measures the amount of market risk caused by fluctuations in the financial market.   The parallel processing system according to claim 8 or 9, wherein in order to calculate a price of a financial product, a change in a financial market is modeled and a Monte Carlo method is executed using the parallel processing system. The program for making a computer perform each step of the method in any one of Claims 1-7.

Images