WO2010047174A1 - ソース・コード処理方法、システム、及びプログラム - Google Patents
ソース・コード処理方法、システム、及びプログラム Download PDFInfo
- Publication number
- WO2010047174A1 WO2010047174A1 PCT/JP2009/064698 JP2009064698W WO2010047174A1 WO 2010047174 A1 WO2010047174 A1 WO 2010047174A1 JP 2009064698 W JP2009064698 W JP 2009064698W WO 2010047174 A1 WO2010047174 A1 WO 2010047174A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- source code
- processing time
- processing
- divided
- processors
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Ceased
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/45—Exploiting coarse grain parallelism in compilation, i.e. parallelism between groups of instructions
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/45—Exploiting coarse grain parallelism in compilation, i.e. parallelism between groups of instructions
- G06F8/456—Parallelism detection
Definitions
- the present invention relates to a technique for speeding up program execution in a multiprocessor system.
- multiprocessor systems having a plurality of processors have been used in fields such as scientific and technical calculations and simulations.
- an application program creates multiple processes and assigns the processes to individual processors. For example, these processors proceed with processing while communicating with each other using a shared memory space.
- simulation software that has been especially actively developed includes simulation software for mechatronics plants such as robots, automobiles, and airplanes. Thanks to the development of electronic components and software technology, most of the control is electronically performed in robots, automobiles, airplanes, etc. using wire connection or wireless LAN that is stretched like nerves.
- HILS Hard In-the-Loop Simulation
- ECU electronice control unit
- full vehicle HILS the environment for testing the electronic control unit (ECU) of the entire automobile is called full vehicle HILS.
- ECU electronice control unit
- a real ECU is connected to a dedicated hardware device that emulates an engine, a transmission mechanism, and the like in a laboratory, and a test is performed according to a predetermined scenario.
- the output from the ECU is input to a monitoring computer and further displayed on a display, and a tester checks whether there is an abnormal operation while looking at the display.
- HILS requires a dedicated hardware device, and it must be physically wired between it and the real ECU, so preparation is difficult.
- the test after replacing with another ECU also takes time since it must be physically reconnected.
- real time is required for the test. Therefore, testing many scenarios takes a huge amount of time.
- a hardware device for HILS emulation is generally very expensive.
- SILS Software In the Loop Simulation
- MATLAB (R) / Simulink (R) which is a simulation modeling system available from CYBERNET SYSTEMS CO., LTD.
- R MATLAB
- Simulink (R) a simulation modeling system available from CYBERNET SYSTEMS CO., LTD.
- function blocks A, B, ..., J are arranged on the screen by a graphical interface as shown in Fig. 1, and the processing is performed as indicated by arrows.
- a simulation program can be created by specifying the flow.
- CP here refers to a critical path.
- the block diagram shown in FIG. 1 is converted into a task graph shown in FIG.
- the task graph of FIG. 2 has four vertical columns, and the processing of each column is assigned to four individual CPUs in parallel, and is substantially compared to when processing by one CPU. Double speed processing can be achieved.
- the path B ⁇ D ⁇ F ⁇ H ⁇ J is a critical path, and the entire processing time cannot be shortened beyond the CPU time for processing this critical path.
- Japanese Patent Laid-Open No. 6-83608 discloses that a critical path analysis unit finds a part that is a bottleneck of program execution in a parallel computer.
- Japanese Patent Laid-Open No. 7-21240 relates to a logic circuit layout design, a critical path extracting device for extracting a critical path in order to shorten the critical path and minimize the number of nets crossing the cut line; Merges blocks from the merge partner of each block determined by the merge partner selection device and the merge partner selection device that determine the merge partner of each block from the cut line creation device that creates the cut line, the degree of connection of each block, and critical path information And a pair-wise device that performs pair exchange so that the number of nets crossing the cut line is minimized.
- JP-A-8-180100 discloses that an efficient solution is obtained at high speed by generating an efficient neighborhood and combining it with an approximate solution method for a job shop scheduling problem involving machine assignment.
- JP-A-6-83608 and JP-A-8-180100 merely disclose an outline of task scheduling.
- Japanese Patent Laid-Open No. 7-21240 describes a technique for shortening a critical path in the layout design of a logical circuit. This is a critical path in a physical layout, and a logical critical path of software. It is not applicable to the processing.
- JP-A-6-83608 Japanese Patent Laid-Open No. 7-21240 JP-A-8-180100
- an object of the present invention is to provide a technique for speeding up program execution by parallelization in a multiprocessor system.
- the above object is achieved by appropriately cutting the critical path of the program to be accelerated, dividing it as a separate process, and assigning it to individual processors. This makes it possible to output an optimum code for speculative execution of simulation.
- the processing program of the present invention reads the source code of a program that is made up of a plurality of processing blocks and wants to increase the speed, tests all possible cuts of the critical path, and determines the results of the processing blocks that have been cut. Find the cut with the shortest processing time for the flow.
- a phase in which the processing program is compiled and the execution time and other values of each processing block are measured in advance is performed.
- the value measured at this time includes the cost of messaging when processing crosses over different processors, the processing required for speculative execution, the cost of rollback when speculation fails, and further to each block Measurement data such as the degree of input prediction (ie, speculation success probability) is also included.
- the processing of cuts that can be performed on critical paths is applied recursively to the path resulting from the cut. Then, even if further cuts are made, the cut is stopped at a stage where the overall processing time becomes longer if the communication time between processors is taken into consideration. Thereby, a group of a plurality of processing blocks is obtained.
- a group of processing blocks is referred to as a block chunk.
- the individual block chunks generated in this way is equal to or less than the number of processors in the multiprocessor system, the individual block chunks are compiled as they are and each is assigned to an individual processor in the execution environment. Assigned.
- the processing program of the present invention attempts to combine block chunks so that the number of block chunks is equal to the number of processors. At this time, it is preferable to select a combination that minimizes the maximum processing time for the critical path among the resulting combined block chunks.
- the resulting block chunk is compiled and assigned to each individual processor in the execution environment. In this way, one processor is assigned to every block chunk, so that optimum parallel processing is performed.
- a plurality of CPU1 304a, CPU2 304b, CPU3 304c,... CPUn 304n are connected to the host bus 302. Further connected to the host bus 502 is a main memory 306 for arithmetic processing of CPU1, 304a, CPU2, 304b, CPU3, 304c,.
- a keyboard 310, a mouse 312, a display 314 and a hard disk drive 316 are connected to the I / O bus 308.
- the I / O bus 308 is connected to the host bus 302 via the I / O bridge 318.
- the keyboard 310 and the mouse 312 are used by an operator to input commands and click menus.
- the display 314 is used to display a menu for operating a program according to the present invention, which will be described later, using a GUI as necessary.
- CPU1 304a, CPU2 304b, CPU3 304c,..., CPUn 304n are, for example, Intel (R) Xeon (R), and the operating system is Windows (trademark) Server 2003.
- the operating system is stored on the hard disk drive 316 and is read from the hard disk drive 316 into the main memory 306 when the computer system is started.
- the hardware of the computer system that can be used for carrying out the present invention is not limited to IBM (R) System X, and any hardware can be used as long as it can run the simulation program of the present invention.
- a computer system can be used.
- the operating system is not limited to Windows (R), and any operating system such as Linux (R) or Mac OS (R) can be used.
- a computer system such as IBM (R) System P whose operating system is AIX (trademark) based on POWER (trademark) 6 may be used.
- the hard disk drive 316 further includes a MATLAB® / Simulink®, C compiler or C ++ compiler, a module for cutting a critical path according to the present invention, a code generation module for CPU allocation, and a processing block.
- a MATLAB® / Simulink® C compiler or C ++ compiler
- a module for cutting a critical path according to the present invention a code generation module for CPU allocation, and a processing block.
- a processing block are stored in the main memory 306 in response to an operator's keyboard or mouse operation.
- the usable simulation modeling tools are not limited to MATLAB (R) / Simulink (R), and any simulation modeling tools such as open source Scilab / Scicos can be used.
- FIG. 4 is a functional block diagram according to the embodiment of the present invention. Each block basically corresponds to a module stored in the hard disk drive 316.
- the simulation modeling tool 402 may be any existing tool such as MATLAB® / Simulink®, Scilab / Scicos.
- the simulation modeling tool 402 basically, an operator arranges function blocks in a GUI on the display 314, describes necessary attributes such as mathematical formulas, and blocks the function blocks in association with each other as necessary. It has a function that makes it possible to describe a diagram.
- the simulation modeling tool 402 further has a function of outputting C source code describing a function equivalent to the described block diagram. In addition to C, C ++, Fortran, etc. can be used.
- the simulation modeling tool can be installed in another personal computer, and the generated source code can be downloaded to the hard disk drive 316 via a network or the like. .
- Source code 404 thus output is stored in the hard disk drive 316.
- Source code 404 is compiled by compiler 406 and the resulting executable program is passed to test module 408.
- the test module 408 has a function for performing an execution test and a function for performing a speculative test.
- the execution test the average processing time, inter-processor communication time, and speculation success probability of each block as shown in FIG. 1 are measured according to a predetermined scenario. In order to measure the average time, preferably the same scenario is executed multiple times.
- the measurement result 410 is stored in the hard disk drive 316 for later use.
- Speculation test speculatively executes the resulting executable program according to another predetermined scenario.
- the processing time for speculation preparation that is, the time for processing to save the predicted input value and the processing time for confirming speculation success / failure in case the speculation fails and rolls back
- the processing time to check whether it matches the expected data and the rollback processing time that is, the speculation failed, that is, the predicted input and the actual value are different
- the time required for post-processing such as stopping the processing performed based on an incorrect input or erasing data is measured.
- Such a value is also stored in the hard disk drive 316 as the measurement result 410 for later use.
- the speculation success probability can actually be calculated without actually executing speculation.
- the process is executed before the input that should come originally, so the input is predicted and the process is executed. Therefore, the probability that the speculation is successful is equal to the probability that the prediction for the input is correct.
- the prediction algorithm can be predicted from only the actual input data without actually performing speculative execution (that is, without executing block processing based on the predicted input data).
- Success probability can be calculated. That is, simply by recording the input for each block in the “execution test” and calculating the prediction success rate of the input prediction algorithm from the input data series, the speculation success probability can be obtained.
- the “Critical Path Cut” module 412 has a function of processing the source code 404 in units of blocks, finding a critical path, putting a cut, and finding a cut that has an optimal execution time. At this time, information of the measurement result 410 is used. Module 412 also recursively applies the critical path cut function to obtain sub-block chunks as shown in FIG. The block chunk information 414 thus generated is stored on the hard disk drive 316 for later use.
- the critical path cut function will be described in detail later with reference to a flowchart.
- the “CPU allocation code generation” module 416 uses the block chunk information 414 and the measurement result 410 to generate codes 418a, 418b,. If the number of block chunks is less than or equal to the number of CPU1 to CPUn, the code of each block chunk is assigned to CPU1 to CPUn as it is.
- the block chunks are arranged so that the number of block chunks is equal to the number of CPUs 1 to CPUn.
- the coupling at this time is preferably chosen optimally so that the expected execution time of the resulting critical path is minimized.
- codes 418a, 418b,..., 418m to be assigned to CPU1 to CPUn and dependency information 420 are generated.
- the reason why the dependency relationship information 420 is necessary is as follows. That is, as shown in FIG. 10, when the original processing flow is divided by the critical path cut function, the dependency between the original blocks may be broken. In order to compensate for this, the module 416, for example, which code among the codes 418a, 418b,... 418m assigned to the CPU1 to CPUn returns a variable used in which other code, etc.
- the dependency relationship information 420 is also provided. In practice, the dependency relationship information 420 is created by the “Critical Path Cut” module 412 at the time of the cut, so that the “CPU allocation code generation” module 416 uses it.
- the codes 418a, 418b,..., 418m generated in this way are individually compiled as executable programs by the compiler 422, and are individually assigned to be executed in parallel on the corresponding CPU1 to CPUn in the execution environment 424. It is done.
- the dependency relationship information 420 is arranged in a common memory area of the main memory 306 so that it can be commonly referred to by the CPUs 1 to CPUn, and when the CPUs 1 to CPUn execute the codes 418a, 418b,. If necessary, it is used to refer to information on a code being executed on another CPU.
- FIG. 5 shows the overall processing flow of this embodiment. It should be understood that this is a flow showing a work procedure and does not necessarily correspond to a computer processing flow.
- step 502 a developer or worker uses a simulation modeling tool 402 such as MATLAB® / Simulink®, and a block diagram of a specific simulation target is shown in FIG. Create on the system or on another computer.
- a simulation modeling tool 402 such as MATLAB® / Simulink®
- step 504 the developer or worker generates source code 404 corresponding to the created block diagram using the function of the simulation modeling tool 402 and stores it in the hard disk drive 316.
- step 506 the developer or worker compiles the source code 404 using the compiler 406.
- the compiled executable program is temporarily stored in the hard disk drive 316 (not shown).
- step 508 the developer or the worker performs an execution test using the test module 408 using the compiled execution program.
- the measurement data of the average processing time of the block, the communication time between processors, and the execution time of the speculative success probability obtained as a result are stored in the hard disk drive 316 as the measurement result 410 in step 510.
- step 512 the developer or worker performs a speculative test in the test module 408 using the compiled execution program.
- the measurement data of the speculative preparation processing time, speculative success / failure confirmation processing time, and rollback processing time obtained as a result is stored in the hard disk drive 316 as the measurement result 410 in step 514.
- step 516 the processing of the computer is started in response to the operation of the developer or worker. That is, basically, steps 516 to 524 automatically proceed by computer processing.
- step 516 the source code 404 is processed by the “cut critical path” module 412.
- a critical path in the entire processing flow described in the source code 404 is found by an algorithm, and is optimally cut in processing time.
- the process of cutting the critical path is performed recursively. At this time, the measurement result 410 is used.
- the data structure stored at this time may be any data structure that is computer readable and can express both the contents of the source code and the connection relationship (link), such as XML.
- the “CPU allocation code generation” module 416 uses the information of the block chunk 414, the “CPU allocation code generation” module 416 generates a code to be individually allocated to the CPU1 to CPUn. That is, if the number of block chunks is smaller than the number of CPUs 1 to CPUn, they are assigned to CPU1 to CPUn one by one as they are. On the other hand, if the number of block chunks is larger than the number of CPU1 to CPUn, the block chunks are combined so as to be the shortest in terms of execution time so as to be equal to the number of CPU1 to CPUn. At this time, the measurement result 410 is used.
- step 522 the code generated by the module 416 is compiled by the compiler 422.
- step 524 the code is individually assigned to the corresponding processors CPU1 to CPUn and executed.
- step 602 a process of finding the optimum cut of the critical path is performed.
- the optimum cut is, reference is made to FIG.
- FIG. 8 shows a processing flow composed of blocks A to I.
- the B-C-D-E-F is identified as a critical path by the algorithm that finds the critical path, in step 602, a possible path along B-C-D-E-F is possible.
- the cuts c1, c2, c3, and c4 are tried sequentially by the “cut critical path” module 412. For example, to try the cut c3, the critical path is cut at c3, and the cut flow is logically moved to the side as shown in FIG. Then, two flows will be juxtaposed. Therefore, cut c3 is evaluated.
- Evaluating the cut c3 is to evaluate the longer value T c by comparing the expected execution times of the two juxtaposed flows, assuming that the speculative success probability is 100%. However, generally, since the speculative success probability is lower than 100%, Tc is evaluated in consideration of the speculative success probability as will be described with reference to FIG. Such a cut with the shortest Tc is called an optimum cut.
- the expected execution time of each block is measured in advance by an execution test shown in step 508 of FIG. 5 and stored in the hard disk drive 316 as a measurement result 410. Note that such measurement results 410 are used in calculating the expected execution time for a given flow.
- MSCxy Message transmission cost from block X to block Y when block X and block Y are cut.
- MRCxy Message reception cost from block X to block Y when block X and block Y are cut.
- SCxy speculative cost from block X to block Y.
- SCCxy Speculation check cost from block X to block Y.
- RBCxy Rollback cost when speculation from block X to block Y fails.
- the cost between these blocks is also measured in advance by the execution test shown in step 508 and the speculative test shown in step 512 in FIG. 5 and stored in the hard disk drive 316 as the measurement result 410.
- T cs
- represents the execution time of block D.
- the “cut critical path” module 412 determines whether or not an optimum cut exists.
- the existence of the optimum cut means that the entire expected processing time is shortened as a result of the cut. Cutting in any case does not necessarily reduce processing time. That is, in view of the transmission cost, the reception cost, and the speculative cost described above, the processing time may not be shortened even if it is cut. In such a case, it is determined in step 604 that there is no optimum cut, and in step 606, information on the block chunk currently being evaluated is preferably stored in the hard disk drive 316.
- step 604 if it is determined in step 604 that the optimum cut exists, the “cut critical path” module 412 moves the cut block in step 608. This is a process as shown in FIG.
- step 610 the process of the flowchart of FIG. 6 is recursively called for the entire set of paths that have been cut.
- the blocks A, B, C, D, E, F, G, H, and I the blocks A, B, C, D, and E are applied.
- F and blocks G, H, and I where the processing of the flowchart of FIG. 6 is recursively called.
- step 702 processing for finding a critical path is performed.
- the process itself for finding the critical path for the process flow is well known in the art, For example, the PERT method described in http://www.kogures.com/hitoshi/webtext/pt-pert/index.html can be used.
- step 706 it is determined whether or not C is empty. If not, the process proceeds to step 708, and cut c is extracted from C.
- step 710 the expected execution time of cut c is calculated and substituted for t c .
- the calculation of the execution time here includes the case of speculative execution described with reference to FIG.
- steps 708, 710, 712 and 714 are executed, the result of c min is returned to step 602 in FIG.
- the determination at step 604 in FIG. 6 becomes negative.
- FIG. 10 schematically shows the result of such processing.
- the processing flow of the block shown on the left side of FIG. 10 is cut at a plurality of locations by the recursive procedure of the processing shown in the flowchart of FIG. 6, and a plurality of subdivided block chunks are converted as shown on the right side of FIG. can get.
- step 1104 If it is determined in step 1104 that p ⁇ b, this means that the number of processors is insufficient to individually allocate block chunks as they are, so in step 1108, the two block chunks are combined, Processing is performed to reduce the number of block chunks by one.
- Joining two block chunks may result in a longer critical path and longer expected processing time at the joined block chunk.
- an optimal combination is found that minimizes the expected processing time of the result of combining the two block chunks.
- FIG. 14 schematically shows such processing.
- step 1104 becomes negative. Now, there are as many processors as there are individual block chunks assigned, so in step 1106, the resulting individual block chunks stored at that time are assigned to individual processors, and the process End.
- FIG. 12 is a flowchart showing the process of step 1108 of FIG. 11 in more detail.
- S 1 current set of block chunks
- t min ⁇
- u min ⁇
- ⁇ means an appropriate constant sufficiently larger than the number actually assumed in this situation.
- step 1204 it is determined whether S 1 is empty. If so, the process is completed, and the process returns to step 1108 in the flowchart of FIG. If S 1 is not empty, at step 1206, one block chunk s 1 is retrieved from S 1 .
- S 2 is determined is whether empty or not, and if so, returns to step 1204. If S 2 is not empty, at step 1212 one block chunk s 2 is retrieved from S 2 .
- step 1214 the execution time when s 2 is combined under s 1 is calculated using the measurement result 410 of each block shown in FIG. 4 and substituted into T s1s2 .
- the case where s 2 s 1 is omitted.
- the original upstream / downstream relationship can be determined, the original upstream / downstream relationship may be combined.
- step 1216 it is determined whether T s1s2 is equal to T min . If so, at step 1218, the expected cost when s 2 is combined under s 1 is calculated and assigned to u s1s2 .
- the cost refers to the execution time of each block, the cost of sending and receiving messages between blocks across different processors, the speculative cost, the speculative check cost, and the rollback cost in the event of speculative failure. This is an expected value of the total CPU consumption time calculated by weighting with probability.
- step 1216 the process proceeds to step 1224, where it is determined whether T s1s2 ⁇ T min . If so, step 1222 is executed before returning to step 1210. Otherwise, the process returns from step 1224 to step 1210.
- FIG. 13 shows an example of combining block chunks.
- t bc2 bc3
- + MRCac + MRCif u bc2 bc3
- t bc1 bc4 p 1 p 2 (
- u bc1 bc4
- FIG. 14 shows that when there are six block chunks bc1, bc2, bc3, bc4, bc5, bc6, and there are only five CPUs, in order to reduce the block chunk by one, “CPU allocation code”
- FIG. 10 illustrates the process when the “Generate” module 416 attempts to combine two block chunks.
- the “CPU allocation code generation” module 416 calculates the longest execution time t s1s2 for all possible block chunk combinations, and consequently selects the block chunk combination that exhibits the shortest t s1s2 .
- the code for each CPU generated in this way is stored in the hard disk drive 316 once it is compiled by the compiler 422 and converted into executable code.
- FIG. 15 is a schematic diagram for explaining such a dependency relationship.
- the code consisting of block A and block C is Code 1
- the code consisting of block B and block D is Code 2
- the code consisting of block F, block H and block J is Code 3
- the code consisting of I is Code IV4.
- Such information is generated together with the “CPU allocation code generation” module 416 when each CPU allocation code is generated.
- Dependency information can be included in individual CPU allocation code and notified to the compiler 422, but is preferably allocated by the CPU1 to CPUn by placing it directly on the shared memory of the execution environment 424. Dependency information can be referenced when executing the specified code.
- the compiled executable program for each CPU is sequentially read into the main memory 306 by the execution environment 424, and the execution environment 424 Allocate processes created for possible programs to individual processors.
- the simulation program divided into a plurality of executable programs is executed in parallel by the individual processors.
- the process of assigning and parallelizing to a plurality of CPUs based on the program source code generated using the simulation modeling tool has been described.
- the present invention is not limited to such a simulation program.
- the present invention is not limited to source code, and can be applied to any source code as long as a processing block unit can be identified and its flow is described.
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
- Devices For Executing Special Programs (AREA)
- Management, Administration, Business Operations System, And Electronic Commerce (AREA)
Abstract
Description
MSCxy : ブロックXとブロックYがカットされているときの、ブロックXからブロックYについてのメッセージ送信コスト。
MRCxy : ブロックXとブロックYがカットされているときの、ブロックXからブロックYについてのメッセージ受信コスト。
SCxy : ブロックXからブロックYについての投機コスト。
SCCxy : ブロックXからブロックYについての投機チェックコスト。
RBCxy : ブロックXからブロックYについての投機が失敗した場合のロールバック・コスト。
Tcs = |D|+|E|+|F|+SCcd+MRCif+MRCcd+SCCcd
ここで、例えば|D|は、ブロックDの実行時間をあらわす。
Tcf = |B|+|C|+|D|+|E|+|F|+MRCac+MSCcd+MRCcd+RBCcd+MRCif
Tc = pcTcs + (1-pc)Tcfと計算される。
例えば、http://www.kogures.com/hitoshi/webtext/pt-pert/index.htmlに記述されているPERTの方法などを使用することができる。
cmin = null、C = クリティカル・パスの可能なカットの集合とセットされる。
Tmin = Ts1s2、b1 = s1、b2 = s2、uminには、s2がs1の下に結合されたときの期待されるコストが代入される。ステップ1222からは、ステップ1210の判断に戻る。
tbc2 bc3 = |B|+|C|+|D|+|E|+|F|+MRCac+MRCif
ubc2 bc3 = |A|+|B|+|C|+|D|+|E|+|F|+|G|+|H|+|I|
+MRCac+MRCif+MSCac+MSCif
tbc1 bc4 = p1p2(|D|+|E|+|F|+ SCcd + SCif + MRcd + SCCcd + MRCif + SCCif)+ p1(1-p2)(|A|+|G|+|H|+|I|+|F|+MSAac+MSCif+MRCif+SCCif+RBCif)+
(1-p1)(|B|+|C|+|D|+|E|+|F| + MRCac +
MSCcd + MRCcd + SCCcd + RBCcd + MRCif)
ubc1 bc4 = |A|+|B|+|C|+|D|+|E|+|F|+|G|+|H|+|I|+
p1p2(SCcd + SCif + MRcd + SCCcd + MRCif + SCCif)+
p1(1-p2)(MSAac+MSCif+MRCif+SCCif+RBCif)+
(1-p1)(MRCac + MSCcd + MRCcd + SCCcd + RBCcd + MRCif)
ここで、p1及びp2は、図示されている経路での投機の成功確率である。
1st output of Code 1 -> 1st argument of Code 3
1st output of Code 2 -> 2nd argument of Code 3
1st output of Code 3 -> 3rd argument of Code 3
406、422・・・コンパイラ
412・・・「クリティカル・パスのカット」モジュール
416・・・「CPU割当て用コード生成」モジュール
418・・・CPU用コード
420・・・依存関係情報
Claims (27)
- コンピュータの処理によって、マルチプロセッサ・システムで並列実行可能とするためのソース・コードを生成する方法であって、
プログラムのソース・コードを入力するステップと、
前記コンピュータの処理によって、前記プログラムのソース・コードの処理のクリティカル・パスを見つけるステップと、
前記クリティカル・パスをカットして、前記マルチプロセッサ・システムの個々のプロセッサ毎に対応して前記ソース・コードを分割するステップを有する、
ソース・コード処理方法。 - 前記ソース・コードをコンパイルして実行し、前記ソース・コードの処理ブロック単位の処理時間を計測して記録するステップをさらに有し、
前記ソース・コードを分割するステップは、前記記録された処理時間を用いて、分割されたソース・コードのうちの期待される処理時間が最大のものの期待される処理時間が、少なくとも元のソース・コードの処理時間より短くなるように分割を行う、請求項1の方法。 - 処理が異なるプロセッサにまたがった際のメッセージングのコスト、投機実行のために必要な処理、、投機が失敗した際のロールバックのコスト、及び各ブロックへの入力の予測がどの程度当たるのかという投機成功確率のデータを更に計測して記録するステップを有する、請求項2の方法。
- 前記ソース・コードを分割するステップは、前記記録された処理時間を用いて、分割されたソース・コードのうちの期待される処理時間が最大のものの期待される処理時間が最小になるように分割を行う、請求項2の方法。
- 前記分割されたソース・コードの間の変数及び引数の依存関係の情報を含む情報を出力するステップをさらに有する、請求項1の方法。
- 前記マルチプロセッサ・システムのプロセッサの個数と、前記分割されたソース・コードの個数を比較し、前記分割されたソース・コードの個数がプロセッサの個数よりも多いことに応答して、前記分割されたソース・コードの個数がプロセッサの個数と等しいかそれ以下になるように、前記分割されたソース・コードを結合するステップをさらに有する、請求項2の方法。
- 前記分割されたソース・コードを結合するステップは、前記記録された処理時間を用いて、結合されたソース・コードのうちの期待される処理時間が最大のものの期待される処理時間が最小になるように結合を行う、請求項6の方法。
- 前記ソース・コードは、シミュレーション・モデリング・ツールの機能により生成されたものであり、前記ソース・コードの処理ブロック単位は、シミュレーション・モデリング・ツール上のブロック線図のブロックに対応する、請求項1の方法。
- コンピュータの処理によって、マルチプロセッサ・システムで並列実行可能とするための複数のソース・コードを生成するシステムであって、
プログラムのソース・コードを保存する記録手段と、
前記コンピュータの処理によって、前記プログラムのソース・コードを読み取って、該ソース・コードの処理のクリティカル・パスを見つける手段と、
前記クリティカル・パスをカットして、前記マルチプロセッサ・システムの個々のプロセッサ毎に対応して前記ソース・コードを分割する手段を有する、
ソース・コード処理システム。 - 前記ソース・コードをコンパイルして実行し、前記ソース・コードの処理ブロック単位の処理時間を計測して記録する手段をさらに有し、
前記ソース・コードを分割する手段は、前記記録された処理時間を用いて、分割されたソース・コードのうちの期待される処理時間が最大のものの期待される処理時間が、少なくとも元のソース・コードの処理時間より短くなるように分割を行う、請求項9のシステム。 - 前記処理時間を計測して記録する手段は、処理が異なるプロセッサにまたがった際のメッセージングのコスト、投機実行のために必要な処理、投機が失敗した際のロールバックのコスト、及び各ブロックへの入力の予測がどの程度当たるのかという投機成功確率のデータを更に計測して記録する、請求項10のシステム。
- 前記ソース・コードを分割するシステムは、前記記録された処理時間を用いて、分割されたソース・コードのうちの期待される処理時間が最大のものの期待される処理時間が最小になるように分割を行う、請求項10のシステム。
- 前記分割されたソース・コードの間の変数及び引数の依存関係の情報を含む情報を出力する手段をさらに有する、請求項9のシステム。
- 前記マルチプロセッサ・システムのプロセッサの個数と、前記分割されたソース・コードの個数を比較し、前記分割されたソース・コードの個数がプロセッサの個数よりも多いことに応答して、前記分割されたソース・コードの個数がプロセッサの個数と等しいかそれ以下になるように、前記分割されたソース・コードを結合する手段をさらに有する、請求項10のシステム。
- 前記分割されたソース・コードを結合する手段は、前記記録された処理時間を用いて、結合されたソース・コードのうちの期待される処理時間が最大のものの期待される処理時間が最小になるように結合を行う、請求項14のシステム。
- 前記ソース・コードは、シミュレーション・モデリング・ツールの機能により生成されたものであり、前記ソース・コードの処理ブロック単位は、シミュレーション・モデリング・ツール上のブロック線図のブロックに対応する、請求項9のシステム。
- マルチプロセッサ・システムにより並列実行可能な複数のプログラムを実行するコンピュータ・システムであって、
プログラムのソース・コードを保存する記録手段と、
前記コンピュータの処理によって、前記プログラムのソース・コードを読み取って、該ソース・コードの処理のクリティカル・パスを見つける手段と、
前記クリティカル・パスをカットして、前記マルチプロセッサ・システムの個々のプロセッサ毎に対応して前記ソース・コードを分割する手段と、
前記分割されたソース・コードをコンパイルする手段と、
前記コンパイルされた実行可能プログラムを、前記マルチプロセッサ・システムの個別のプロセッサに割り当てる手段を有する、
コンピュータ・システム。 - 前記ソース・コードをコンパイルして実行し、前記ソース・コードの処理ブロック単位の処理時間を計測して記録する手段をさらに有し、
前記ソース・コードを分割する手段は、前記記録された処理時間を用いて、分割されたソース・コードのうちの期待される処理時間が最大のものの期待される処理時間が、少なくとも元のソース・コードの処理時間より短くなるように分割を行う、請求項17のコンピュータ・システム。 - 前記処理時間を計測して記録する手段は、処理が異なるプロセッサにまたがった際のメッセージングのコスト、投機実行のために必要な処理、投機が失敗した際のロールバックのコスト、及び各ブロックへの入力の予測がどの程度当たるのかという投機成功確率のデータを更に計測して記録する、請求項18のコンピュータ・システム。
- 前記ソース・コードを分割するシステムは、前記記録された処理時間を用いて、分割されたソース・コードのうちの期待される処理時間が最大のものの期待される処理時間が最小になるように分割を行う、請求項18のコンピュータ・システム。
- 前記分割されたソース・コードの間の変数及び引数の依存関係の情報を含む情報を出力する手段と、
該依存関係の情報を、前記マルチプロセッサ・システムの個別のプロセッサが参照可能となるようにロードする手段、
をさらに有する、請求項17のコンピュータ・システム。 - 前記マルチプロセッサ・システムのプロセッサの個数と、前記分割されたソース・コードの個数を比較し、前記分割されたソース・コードの個数がプロセッサの個数よりも多いことに応答して、前記分割されたソース・コードの個数がプロセッサの個数と等しいかそれ以下になるように、前記分割されたソース・コードを結合する手段をさらに有する、請求項17のコンピュータ・システム。
- コンピュータの処理によって、マルチプロセッサ・システムで並列実行可能とするためのソース・コードを生成するプログラムであって、
前記コンピュータに、
プログラムのソース・コードを入力するステップと、
前記コンピュータの処理によって、前記プログラムのソース・コードの処理のクリティカル・パスを見つけるステップと、
前記クリティカル・パスをカットして、前記マルチプロセッサ・システムの個々のプロセッサ毎に対応して前記ソース・コードを分割するステップを実行させる、
プログラム。 - 前記ソース・コードをコンパイルして実行し、前記ソース・コードの処理ブロック単位の処理時間を計測して記録するステップをさらに有し、
前記ソース・コードを分割するステップは、前記記録された処理時間を用いて、分割されたソース・コードのうちの期待される処理時間が最大のものの期待される処理時間が、少なくとも元のソース・コードの処理時間より短くなるように分割を行う、請求項23のプログラム。 - 処理が異なるプロセッサにまたがった際のメッセージングのコスト、投機実行のために必要な処理、、投機が失敗した際のロールバックのコスト、及び各ブロックへの入力の予測がどの程度当たるのかという投機成功確率のデータを更に計測して記録するステップを有する、請求項24のプログラム。
- 前記ソース・コードを分割するステップは、前記記録された処理時間を用いて、分割されたソース・コードのうちの期待される処理時間が最大のものの期待される処理時間が最小になるように分割を行う、請求項24のプログラム。
- 前記マルチプロセッサ・システムのプロセッサの個数と、前記分割されたソース・コードの個数を比較し、前記分割されたソース・コードの個数がプロセッサの個数よりも多いことに応答して、前記分割されたソース・コードの個数がプロセッサの個数と等しいかそれ以下になるように、前記分割されたソース・コードを結合するステップをさらに有する、請求項24のプログラム。
Priority Applications (4)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| KR1020117009462A KR101522444B1 (ko) | 2008-10-24 | 2009-08-24 | 소스 코드 처리 방법, 시스템, 및 프로그램 |
| EP09821874A EP2352087A4 (en) | 2008-10-24 | 2009-08-24 | PROCESS, SYSTEM AND PROGRAM FOR SOURCE COD PROCESSING |
| CN200980142515.2A CN102197376B (zh) | 2008-10-24 | 2009-08-24 | 源代码处理方法、系统及程序 |
| JP2010534746A JP5209059B2 (ja) | 2008-10-24 | 2009-08-24 | ソース・コード処理方法、システム、及びプログラム |
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| JP2008274686 | 2008-10-24 | ||
| JP2008-274686 | 2008-10-24 |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| WO2010047174A1 true WO2010047174A1 (ja) | 2010-04-29 |
Family
ID=42118628
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| PCT/JP2009/064698 Ceased WO2010047174A1 (ja) | 2008-10-24 | 2009-08-24 | ソース・コード処理方法、システム、及びプログラム |
Country Status (6)
| Country | Link |
|---|---|
| US (2) | US8407679B2 (ja) |
| EP (1) | EP2352087A4 (ja) |
| JP (1) | JP5209059B2 (ja) |
| KR (1) | KR101522444B1 (ja) |
| CN (1) | CN102197376B (ja) |
| WO (1) | WO2010047174A1 (ja) |
Cited By (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP2013020580A (ja) * | 2011-07-14 | 2013-01-31 | Internatl Business Mach Corp <Ibm> | 並列化方法、システム、及びプログラム |
| JP2013164657A (ja) * | 2012-02-09 | 2013-08-22 | Internatl Business Mach Corp <Ibm> | 並列化方法、システム、及びプログラム |
| WO2014115613A1 (ja) * | 2013-01-23 | 2014-07-31 | 学校法人 早稲田大学 | 並列性の抽出方法及びプログラムの作成方法 |
| JP2016192153A (ja) * | 2015-03-31 | 2016-11-10 | 株式会社デンソー | 並列化コンパイル方法、並列化コンパイラ、及び車載装置 |
Families Citing this family (22)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US9053239B2 (en) * | 2003-08-07 | 2015-06-09 | International Business Machines Corporation | Systems and methods for synchronizing software execution across data processing systems and platforms |
| JP4988789B2 (ja) * | 2009-05-19 | 2012-08-01 | インターナショナル・ビジネス・マシーンズ・コーポレーション | シミュレーション・システム、方法及びプログラム |
| US8863128B2 (en) * | 2010-09-30 | 2014-10-14 | Autodesk, Inc | System and method for optimizing the evaluation of task dependency graphs |
| US9256401B2 (en) | 2011-05-31 | 2016-02-09 | Microsoft Technology Licensing, Llc | Editor visualization of symbolic relationships |
| US8789018B2 (en) | 2011-05-31 | 2014-07-22 | Microsoft Corporation | Statically derived symbolic references for dynamic languages |
| US8752035B2 (en) * | 2011-05-31 | 2014-06-10 | Microsoft Corporation | Transforming dynamic source code based on semantic analysis |
| US9477585B2 (en) * | 2012-11-09 | 2016-10-25 | Coherent Logix, Incorporated | Real time analysis and control for a multiprocessor system |
| US8954939B2 (en) | 2012-12-31 | 2015-02-10 | Microsoft Corporation | Extending a development environment |
| KR101883475B1 (ko) | 2013-02-28 | 2018-07-31 | 한화지상방산 주식회사 | 소형통합제어장치 |
| US9552195B2 (en) * | 2013-03-08 | 2017-01-24 | Facebook, Inc. | Enlarging control regions to optimize script code compilation |
| US10592278B2 (en) | 2013-03-15 | 2020-03-17 | Facebook, Inc. | Defer heavy operations while scrolling |
| US10326448B2 (en) | 2013-11-15 | 2019-06-18 | Scientific Concepts International Corporation | Code partitioning for the array of devices |
| US9294097B1 (en) | 2013-11-15 | 2016-03-22 | Scientific Concepts International Corporation | Device array topology configuration and source code partitioning for device arrays |
| US9698791B2 (en) | 2013-11-15 | 2017-07-04 | Scientific Concepts International Corporation | Programmable forwarding plane |
| CN104678775A (zh) * | 2013-11-27 | 2015-06-03 | 联创汽车电子有限公司 | Hils系统及其同步纠偏方法 |
| JP6803173B2 (ja) * | 2015-08-24 | 2020-12-23 | エスエーエス アイピー, インコーポレーテッドSAS IP, Inc. | 時間ドメイン分解過渡シミュレーションのためのプロセッサ実行システム及び方法 |
| US10289469B2 (en) * | 2016-10-28 | 2019-05-14 | Nvidia Corporation | Reliability enhancement utilizing speculative execution systems and methods |
| JP2018124605A (ja) * | 2017-01-30 | 2018-08-09 | オムロン株式会社 | 画像処理システム、情報処理装置、情報処理方法、および、情報処理プログラム |
| CN112400162B (zh) * | 2018-07-19 | 2024-06-21 | 日立安斯泰莫株式会社 | 模拟装置及其方法、以及ecu装置 |
| KR102763162B1 (ko) | 2018-11-08 | 2025-02-07 | 삼성전자주식회사 | 인공 신경망의 연산 처리 그래프를 관리하는 시스템 및 이를 이용한 연산 처리 그래프를 관리하는 방법 |
| JP6890738B2 (ja) * | 2019-02-26 | 2021-06-18 | 三菱電機株式会社 | 情報処理装置、情報処理方法及び情報処理プログラム |
| US11645219B2 (en) * | 2021-02-02 | 2023-05-09 | American Megatrends International, Llc | Method for generating a hybrid BMC system and hybrid BMC system |
Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JPH0380337A (ja) * | 1989-04-28 | 1991-04-05 | Hitachi Ltd | 並列化装置 |
| JPH0683608A (ja) | 1992-09-04 | 1994-03-25 | Fujitsu Ltd | プログラム解析支援装置 |
| JPH0721240A (ja) | 1993-06-23 | 1995-01-24 | Nec Corp | タイミング考慮配置装置 |
| JPH08180100A (ja) | 1994-12-27 | 1996-07-12 | Fujitsu Ltd | スケジューリング方法および装置 |
| JP2002149416A (ja) * | 2000-10-30 | 2002-05-24 | Internatl Business Mach Corp <Ibm> | プログラムの最適化方法及びこれを用いたコンパイラ |
| JP2007048052A (ja) * | 2005-08-10 | 2007-02-22 | Internatl Business Mach Corp <Ibm> | コンパイラ、制御方法、およびコンパイラ・プログラム |
| JP2008515051A (ja) * | 2004-09-28 | 2008-05-08 | インテル コーポレイション | 依存性チェーン処理のためのシステム、方法及び装置 |
| JP2009129179A (ja) * | 2007-11-22 | 2009-06-11 | Toshiba Corp | プログラム並列化支援装置およびプログラム並列化支援方法 |
Family Cites Families (11)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5325525A (en) * | 1991-04-04 | 1994-06-28 | Hewlett-Packard Company | Method of automatically controlling the allocation of resources of a parallel processor computer system by calculating a minimum execution time of a task and scheduling subtasks against resources to execute the task in the minimum time |
| US5774728A (en) * | 1995-12-27 | 1998-06-30 | International Business Machines Corporation | Method and system for compiling sections of a computer program for multiple execution environments |
| JP2000207223A (ja) * | 1999-01-12 | 2000-07-28 | Matsushita Electric Ind Co Ltd | 並列処理向けのプログラム処理方法および装置、並びに並列処理向けのプログラム処理を実行するプログラムを記録した記録媒体および並列処理向けの命令列を記録した記録媒体 |
| JP3870112B2 (ja) * | 2002-03-13 | 2007-01-17 | インターナショナル・ビジネス・マシーンズ・コーポレーション | コンパイル方法、コンパイル装置、及びコンパイル用プログラム |
| US20050144602A1 (en) * | 2003-12-12 | 2005-06-30 | Tin-Fook Ngai | Methods and apparatus to compile programs to use speculative parallel threads |
| US20060123401A1 (en) * | 2004-12-02 | 2006-06-08 | International Business Machines Corporation | Method and system for exploiting parallelism on a heterogeneous multiprocessor computer system |
| US7627864B2 (en) * | 2005-06-27 | 2009-12-01 | Intel Corporation | Mechanism to optimize speculative parallel threading |
| JP2008059304A (ja) * | 2006-08-31 | 2008-03-13 | Sony Corp | 通信装置および方法、並びにプログラム |
| WO2008072334A1 (ja) * | 2006-12-14 | 2008-06-19 | Fujitsu Limited | コンパイル方法及びコンパイラ |
| CN101611380A (zh) * | 2007-01-30 | 2009-12-23 | 尼玛实验室公司 | 推测性吞吐量计算 |
| JP5148674B2 (ja) * | 2010-09-27 | 2013-02-20 | 株式会社東芝 | プログラム並列化装置およびプログラム |
-
2009
- 2009-08-24 WO PCT/JP2009/064698 patent/WO2010047174A1/ja not_active Ceased
- 2009-08-24 CN CN200980142515.2A patent/CN102197376B/zh active Active
- 2009-08-24 EP EP09821874A patent/EP2352087A4/en not_active Withdrawn
- 2009-08-24 KR KR1020117009462A patent/KR101522444B1/ko active Active
- 2009-08-24 JP JP2010534746A patent/JP5209059B2/ja active Active
- 2009-10-22 US US12/603,598 patent/US8407679B2/en active Active
-
2013
- 2013-01-25 US US13/750,112 patent/US8595712B2/en not_active Expired - Fee Related
Patent Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JPH0380337A (ja) * | 1989-04-28 | 1991-04-05 | Hitachi Ltd | 並列化装置 |
| JPH0683608A (ja) | 1992-09-04 | 1994-03-25 | Fujitsu Ltd | プログラム解析支援装置 |
| JPH0721240A (ja) | 1993-06-23 | 1995-01-24 | Nec Corp | タイミング考慮配置装置 |
| JPH08180100A (ja) | 1994-12-27 | 1996-07-12 | Fujitsu Ltd | スケジューリング方法および装置 |
| JP2002149416A (ja) * | 2000-10-30 | 2002-05-24 | Internatl Business Mach Corp <Ibm> | プログラムの最適化方法及びこれを用いたコンパイラ |
| JP2008515051A (ja) * | 2004-09-28 | 2008-05-08 | インテル コーポレイション | 依存性チェーン処理のためのシステム、方法及び装置 |
| JP2007048052A (ja) * | 2005-08-10 | 2007-02-22 | Internatl Business Mach Corp <Ibm> | コンパイラ、制御方法、およびコンパイラ・プログラム |
| JP2009129179A (ja) * | 2007-11-22 | 2009-06-11 | Toshiba Corp | プログラム並列化支援装置およびプログラム並列化支援方法 |
Non-Patent Citations (1)
| Title |
|---|
| See also references of EP2352087A4 |
Cited By (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| JP2013020580A (ja) * | 2011-07-14 | 2013-01-31 | Internatl Business Mach Corp <Ibm> | 並列化方法、システム、及びプログラム |
| JP2013164657A (ja) * | 2012-02-09 | 2013-08-22 | Internatl Business Mach Corp <Ibm> | 並列化方法、システム、及びプログラム |
| WO2014115613A1 (ja) * | 2013-01-23 | 2014-07-31 | 学校法人 早稲田大学 | 並列性の抽出方法及びプログラムの作成方法 |
| JP2014160453A (ja) * | 2013-01-23 | 2014-09-04 | Waseda Univ | 並列性の抽出方法及びプログラムの作成方法 |
| JP2016192153A (ja) * | 2015-03-31 | 2016-11-10 | 株式会社デンソー | 並列化コンパイル方法、並列化コンパイラ、及び車載装置 |
Also Published As
| Publication number | Publication date |
|---|---|
| KR20110071097A (ko) | 2011-06-28 |
| JPWO2010047174A1 (ja) | 2012-03-22 |
| US8407679B2 (en) | 2013-03-26 |
| KR101522444B1 (ko) | 2015-05-21 |
| EP2352087A1 (en) | 2011-08-03 |
| CN102197376A (zh) | 2011-09-21 |
| US20100106949A1 (en) | 2010-04-29 |
| US8595712B2 (en) | 2013-11-26 |
| US20130139131A1 (en) | 2013-05-30 |
| EP2352087A4 (en) | 2012-08-08 |
| JP5209059B2 (ja) | 2013-06-12 |
| CN102197376B (zh) | 2014-01-15 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| JP5209059B2 (ja) | ソース・コード処理方法、システム、及びプログラム | |
| JP4629768B2 (ja) | 並列化処理方法、システム、及びプログラム | |
| JP4931978B2 (ja) | 並列化処理方法、システム、及びプログラム | |
| US8677334B2 (en) | Parallelization method, system and program | |
| Burtscher et al. | Perfexpert: An easy-to-use performance diagnosis tool for hpc applications | |
| JP4988789B2 (ja) | シミュレーション・システム、方法及びプログラム | |
| JP5651251B2 (ja) | シミュレーション実行方法、プログラム及びシステム | |
| US8990767B2 (en) | Parallelization method, system and program | |
| JP5479942B2 (ja) | 並列化方法、システム、及びプログラム | |
| US8868381B2 (en) | Control system design simulation using switched linearization | |
| US9218317B2 (en) | Parallelization method, system, and program | |
| Cheng et al. | PipeThreader: Software-Defined Pipelining for Efficient DNN Execution | |
| WO2006022204A1 (ja) | ソースプログラムの分析装置および方法 | |
| KR102512704B1 (ko) | 매트릭스 연산 방법 및 그 장치 | |
| Tang et al. | Pipe-DBT: enhancing dynamic binary translation simulators to support pipeline-level simulation | |
| Swaminathan | An Experimental Study of Parallelism in Different Python Frameworks | |
| JP4997144B2 (ja) | マルチタスク処理装置およびその方法 | |
| Bakhtin | Automation of Debugging Parallel Programs in the DVM System | |
| Stoyenko et al. | Predictability and Techniques for Schedulability Analysis | |
| JP2022011264A (ja) | ソフトウェア開発支援装置及びソフトウェア開発支援方法 |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| WWE | Wipo information: entry into national phase |
Ref document number: 200980142515.2 Country of ref document: CN |
|
| 121 | Ep: the epo has been informed by wipo that ep was designated in this application |
Ref document number: 09821874 Country of ref document: EP Kind code of ref document: A1 |
|
| ENP | Entry into the national phase |
Ref document number: 2010534746 Country of ref document: JP Kind code of ref document: A |
|
| ENP | Entry into the national phase |
Ref document number: 20117009462 Country of ref document: KR Kind code of ref document: A |
|
| NENP | Non-entry into the national phase |
Ref country code: DE |
|
| WWE | Wipo information: entry into national phase |
Ref document number: 2009821874 Country of ref document: EP |