WO2006059444A1 - マルチプロセッサシステムとそのシステムにおけるプログラム実行方法 - Google Patents
マルチプロセッサシステムとそのシステムにおけるプログラム実行方法 Download PDFInfo
- Publication number
- WO2006059444A1 WO2006059444A1 PCT/JP2005/020000 JP2005020000W WO2006059444A1 WO 2006059444 A1 WO2006059444 A1 WO 2006059444A1 JP 2005020000 W JP2005020000 W JP 2005020000W WO 2006059444 A1 WO2006059444 A1 WO 2006059444A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- address
- processor
- instruction
- interrupt
- return
- Prior art date
Links
- 238000000034 method Methods 0.000 title claims description 52
- 230000015654 memory Effects 0.000 claims abstract description 37
- 238000012545 processing Methods 0.000 claims abstract description 28
- 238000000605 extraction Methods 0.000 claims description 11
- 238000012546 transfer Methods 0.000 claims description 9
- 230000007704 transition Effects 0.000 claims description 6
- MHABMANUFPZXEB-UHFFFAOYSA-N O-demethyl-aloesaponarin I Natural products O=C1C2=CC=CC(O)=C2C(=O)C2=C1C=C(O)C(C(O)=O)=C2C MHABMANUFPZXEB-UHFFFAOYSA-N 0.000 claims 3
- 230000008569 process Effects 0.000 description 29
- 230000006870 function Effects 0.000 description 8
- 239000000284 extract Substances 0.000 description 6
- 238000010586 diagram Methods 0.000 description 5
- 230000004044 response Effects 0.000 description 3
- 230000014509 gene expression Effects 0.000 description 2
- 230000005012 migration Effects 0.000 description 2
- 238000013508 migration Methods 0.000 description 2
- 238000004364 calculation method Methods 0.000 description 1
- 238000004590 computer program Methods 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000008571 general function Effects 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- PWPJGUXAGUPAHP-UHFFFAOYSA-N lufenuron Chemical compound C1=C(Cl)C(OC(F)(F)C(C(F)(F)F)F)=CC(Cl)=C1NC(=O)NC(=O)C1=C(F)C=CC=C1F PWPJGUXAGUPAHP-UHFFFAOYSA-N 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 229920001690 polydopamine Polymers 0.000 description 1
- 238000009877 rendering Methods 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4812—Task transfer initiation or dispatching by interrupt, e.g. masked
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/32—Address formation of the next instruction, e.g. by incrementing the instruction counter
- G06F9/322—Address formation of the next instruction, e.g. by incrementing the instruction counter for non-sequential address
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
- G06F9/3877—Concurrent instruction execution, e.g. pipeline or look ahead using a slave processor, e.g. coprocessor
- G06F9/3879—Concurrent instruction execution, e.g. pipeline or look ahead using a slave processor, e.g. coprocessor for non-native instruction execution, e.g. executing a command; for Java instruction set
Definitions
- the present invention relates to a system in which a processor of a computer uses a multiprocessor configuration, and a method of executing a program in the system.
- control circuit As the control circuit is reduced in area and highly integrated, the area for mounting hardware resources such as a register mounted for smooth execution of a program is also reduced. If such hardware resources are reduced, some commands may be difficult to execute smoothly.
- the present invention has been made in view of such a situation, and its object is to provide a multiprocessor system capable of flexibly executing processing in a small-scale circuit and a program execution method in the system. To provide.
- one aspect of the present invention is a program execution method in a multiprocessor system. This method is called by the call instruction when the first processor executes the call instruction in the main routine. When the routine processing is completed, save the return address to return to the main routine to the second processor.
- Yet another aspect of the present invention is also a program execution method in a multiprocessor system. According to this method, when the first processor executes a call instruction or a jump instruction, the second processor gets the acquisition of the full address of the call destination address or the jump destination address.
- processing can be flexibly performed on a small-scale circuit.
- FIG. 1 is a view showing the configuration of a multiprocessor system according to an embodiment of the present invention.
- FIG. 2 is a view showing an example of a display list in the present embodiment.
- FIG. 3 is a diagram showing a format of a first command example in which the GPU instructs the CPU to perform address extraction in the present embodiment.
- FIG. 4 is a diagram showing a format of a second command example in which the GPU instructs the CPU to perform address extraction in the present embodiment.
- FIG. 5 is a flow chart when a call instruction in the present embodiment is executed.
- FIG. 6 is a flowchart of executing a jump instruction in the present embodiment.
- the first processor includes an interrupt generation unit that generates an interrupt to the second processor when a predetermined call instruction is executed in the main routine being executed.
- An address save unit that saves a return address for returning to the main routine to a predetermined memory area when processing of a subroutine called by a call instruction is completed when the second processor receives an interrupt from the interrupt generation unit.
- main routine and "subroutine” are descriptive expressions showing the relationship between the calling routine and the called routine, and for example, when the specific routine is related to the calling routine The relation between the "subroutine" and the called routine may be expressed as "main routine".
- the interrupt generation unit generates an interrupt again to the second processor when a predetermined return instruction is executed in the subroutine, and the second processor receives the interrupt generated again.
- And may further include an address notification unit that notifies the first processor of the return address.
- the first processor may include a fetcher that fetches an instruction, and the return address may be set as the target address for access by this fetcher.
- the first processor includes an interrupt generation unit that generates an interrupt to the second processor when executing a predetermined call instruction or jump instruction.
- the second processor splits and stores the call destination address or jump destination stored in the format of the call instruction or jump instruction and the execution stop instruction placed after that, when the first processor power is also interrupted.
- An address extraction unit that extracts an address, and an address notification unit that notifies the first processor of the acquired call destination address or jump address.
- the “jump instruction” may be either a conditional jump instruction or an unconditional jump instruction.
- the first processor may include a fetcher for fetching an instruction, and a call destination address or a jump destination address may be set as a target address for access by this fetcher.
- the graphics processor sequentially reads out instructions described as a display list from a memory, a DMAC (Direct Memory Access Controller), a decoder that sequentially decodes the read instructions, and a solution.
- a display list from a memory
- DMAC Direct Memory Access Controller
- decoder that sequentially decodes the read instructions
- a solution When the read instruction is a predetermined call instruction included in the main routine of the display list, a transition interrupt is generated to the main processor, and the decoded instruction is included in a subroutine called by the call instruction. It has an interrupt generation unit that generates a return interrupt to the main processor when it is a return instruction.
- the main processor receives from the interrupt generation unit an address save unit that saves a return address for returning to the main routine when the processing of the subroutine is completed when receiving the transition interrupt from the interrupt generation unit, and from the interrupt generation unit. And an address notification unit for reading a return address from a predetermined memory and notifying a graphics processor when a return interrupt is received.
- the return address notified to the graphic processor is set as the DMAC access target address.
- Another aspect also includes a graphic processor and a main processor.
- the graphic processor sequentially reads the instructions described as the display list from the memory, the DMAC sequentially decodes the read instructions, and the predetermined call instruction or jump instruction in which the decoded instruction is included in the display list.
- an interrupt generation unit that generates an interrupt to the main processor.
- the main processor receives an interrupt from the interrupt generation unit, the main processor obtains a call destination address or a jump destination address which is divided and stored in the format of a call instruction or a jump instruction and an execution stop instruction placed after that.
- an address notification unit for notifying the graphic processor.
- the call destination address or jump destination address notified to the graphic processor is set as the DMAC access target address.
- the first processor may return to the stack area and save the address on its own.
- the second processor may return to entrust the saving of the address.
- the call instruction is an instruction that does not specify that the second processor should be assigned the save of the return address
- the first processor may save the return address to the stack area that it incorporates.
- the first processor may consign the return address to the second processor.
- FIG. 1 is a diagram showing the configuration of a multiprocessor system 100 according to an embodiment of the present invention.
- the multiprocessor system 100 in this embodiment has a configuration in which a CPU 12, a CPU 14 and a main memory 16 are connected on the same bus 32.
- the functions and data structures of the GPU 12, the CPU 14 and the main memory 16 are described to the extent necessary for the description of the present embodiment, and their general functions and data structures are described. Is omitted.
- the GPU 12 is a graphic processing processor that mainly performs calculations and rendering necessary for three-dimensional graphic display, and may be configured by a one-chip integrated semiconductor integrated circuit.
- the GPU 12 includes a DMAC 20, a decoder 22, and an interrupt generation unit 24.
- the DMA C 20 performs direct data transfer with the main memory 16. In this embodiment, it functions as a fetcher that fetches commands from the main memory 16.
- the DMAC 20 includes an address stack 26, an address counter 28, and a memory control unit 30.
- the address stack 26 temporarily suspends the drawing process currently being executed by the GPU 12 due to the occurrence of an interrupt, and when executing a callback function or the like, ends the subroutine related to the callback function and resumes the above-mentioned drawing process.
- the address counter 28 holds the address of the access destination, that is, the address of the main memory 16 in the present embodiment, and increments the force ⁇ at which the data is read and the address.
- the memory control unit 30 communicates data with the main memory 16. Control data transfer, specifically, the address power indicated by the address counter 28 also reads data.
- the decoder 22 sequentially decodes the commands fetched by the DMAC 20. According to the decipherment, an execution unit provided with an adder (not shown) executes a command and writes the operation result to a frame memory (not shown) or the like.
- the decoder 22 reads the interrupt handler 52 if the decoded command generates an interrupt and is a call instruction of the display list 50 described later.
- the decoder 22 suspends the currently executing drawing process and stores the return address for returning to the process in the address stack 26. If the drawing process is not interrupted temporarily, the return address may not be stored. Further, when there is no free space in the address stack 26, the interrupt generation unit 24 is instructed to return to the CPU 14 to request storage of the address.
- the decoder 22 reads the call knock function hooked by initialization. For example, the callback function is called using an argument set in the lower 16 bits of the decoded command format.
- the currently executing drawing process may be suspended temporarily, or the currently executing drawing process may be continued.
- the interrupted process may be resumed, or when another command instructing restart of the drawing process is decoded, Processing may be resumed.
- These can be set in advance as a command type in the command format. Also, it may be set depending on the presence or absence of execution stop instruction such as Holt instruction.
- the decoder 22 generates an interrupt by the decoded command to generate a call instruction or a jump instruction of the display list 50 described later, and a part of the target address to be accessed. If the type is set, the decoder 22 instructs the interrupt generation unit 24 to request the CPU 14 to extract the target address of the display list 50. If the instruction is a call instruction, the return address is stored as described above. In this embodiment, when the target address can not be set in one command format, it is set across a plurality of commands.
- a call instruction or a jump instruction command for generating an interrupt to the display list 50 and then a halt instruction or an endmer
- a command system in which a force is set and a command are described in a set it can be divided into those two commands and set.
- the target address is to be specified by 32 bits and the area where the address can be set to one command is 24 bits or less, the target address is divided into 16 bits and two command formats are defined. It may be set inside.
- the decoder 22 When the address has a data length that can be set in one command and is set in one command, the decoder 22 does not request the CPU 14 to extract an address. As usual, the decoder 22 may set the address in the address counter 28. Whether or not the target address is divided into multiple commands and set may be set in advance as the command type in the command format, and it may be determined by decoding it, or the execution may be performed. You may judge by the presence or absence of the stop command.
- the decoder 22 generates an interrupt by the decoded command and generates a return instruction corresponding to the call instruction, and the return address corresponding to the call instruction is stored in the address stack 26. Alternatively, it is read from the auxiliary stack area 54 of the main memory 16 described later. If the return address is stored in the auxiliary stack area 54, it instructs the interrupt generation unit 24 to request the CPU 14 to read the return address.
- the CPU 14 when the following events occur, the CPU 14 generates an interrupt signal. That is when the CPU 14 is requested to store the return address. Further, in this case, the CPU 14 is requested to extract an address set by dividing into a plurality of commands. Furthermore, in the subroutine, when a return instruction for returning to the caller is executed, if the return address is stored in the auxiliary stack area 54 of the main memory 16, the CPU 14 is requested to transfer the return address. .
- an interrupt signal generated in the CPU 14 when a predetermined call instruction included in the main routine of the display list 50 is decoded and executed will be called a transition interrupt.
- an interrupt signal generated in the CPU 14 is called a return interrupt. It should be noted that there are various forces, such as input from the keyboard, in the event that generates an interrupt.
- call instructions and jump instructions are decoded and The explanation is limited to the interruption that occurs when the line is executed.
- the CPU 14 includes an interrupt control unit 40, an address extraction unit 42, an address save unit 44, an address read unit 46, and an address notification unit 48. These show functional blocks for realizing the functions of the interrupt handler 52 described later.
- the interrupt control unit 40 receives a migration interrupt and a return interrupt from the interrupt generation unit 24 of the GPU 12.
- the address extraction unit 42 extracts a part of the address from each command when the transfer interrupt is requested to extract target addresses across a plurality of commands. For example, it extracts addresses separately set in the format of a command such as a call instruction or a jump instruction and a command such as a halt instruction placed after that.
- the target address indicates a call destination address or a jump destination address in the main memory 16 or the like.
- the CPU 14 is provided with a large number of register groups (not shown) than the GPU 12. It may have a shift register. For example, if one command format is a 32-bit specification and the number of address bits that can be set is specified to 24 bits, the lower 16 bits of each of the two commands are used to specify an address specified by 32 bits. Divide into 16 bits and set to 2 commands. Then, the upper 16 bits of the address are set to the first command, and the lower 16 bits are set to the next command.
- the address extraction unit 42 also extracts the upper 16 bits of the address of the previous command force and puts it in the shift register. The shift register is shifted to the MSB (Most Significant Bit) side by 16 digits, and the lower 16 bits of the address are extracted from the later command, and combined with the data in the shift register, the address before division is obtained. It can be restored.
- MSB Most Significant Bit
- the address notification unit 48 transfers the target address generated by the address extraction unit 42 to the GPU 12 and sets it in the address counter 28.
- the address counter 28 updates the held data by this processing, and thereafter increments from the set address.
- the address save unit 44 stores the return address in the auxiliary stack area 54 in the main memory 16 described later.
- the address save unit 44 stores them in the auxiliary stack area 54 using the Last-In First-Out (LIFO) method.
- LIFO Last-In First-Out
- the address read unit 46 When the address read unit 46 is requested to transfer the return address by the return interrupt, The return address is read from the auxiliary stack area 54 in the in-memory 16. The address reading unit 46 reads the return address stored last when the auxiliary stack area 54 is controlled by the LIFO method. This reading order also matches the request order of the return address transfer from the GPU 12.
- the address notification unit 48 transfers the return address read by the address reading unit 46 to the GPU 12 and sets it in the address counter 28.
- the address counter 28 updates the held data by this process, and thereafter increments from the set address.
- the main memory 16 stores various commands and data.
- the device playlist 50 and the interrupt handler 52 are mainly stored. Besides, texture data etc. may be stored.
- an auxiliary stack area 54 is secured in the main memory 16.
- the playlist 50 is a list of drawing commands that can be processed efficiently at the time of drawing execution. In this embodiment, it is fetched and executed by the GPU 12.
- the interrupt handler 52 is a program waiting to process and control the interrupt. In the present embodiment, the operation of the GPU 12 and the CPU 14 is mainly controlled when a call instruction or a jump instruction is executed while the display list 50 is being executed.
- the auxiliary stack area 54 is an area reserved for storing the return address in the present embodiment.
- the transferred return address is sequentially stored in the direction in which the final area strength of the main memory 16 also returns to the top address.
- the auxiliary stack area 54 may be secured corresponding to the number of stages of the subroutine executed by the call instruction.
- FIG. 2 is a diagram showing an example of the display list 50. As shown in FIG. The DMAC 20 fetches sequentially from the top address of the display list 50 in the main memory.
- the command "cmd" is a generic term for drawing commands, and corresponds to a command for specifying a frame, a polygon, or a color for specifying a primitive.
- the decoder 22 decodes the command "call id" stored at the address # 1
- the GPU 12 calls a callbacks function hooked in advance using the argument iD (process s).
- the # sign indicates hexadecimal notation.
- the call back to address # 1000 is The number is set.
- the process shifts to return address # 2 and returns to the main routine of the caller (process t).
- the return address is stored in the address stack 26 or the auxiliary stack area 54 in the main memory 16. It was stored when the above subroutine was called.
- GPU 22 decodes the command "cpu call # 20" stored at address # 100, it splits the command and the command "halt #FF" stored at the next address # 101.
- the CPU 14 extracts the address # 20FF that has been set, and calls a subroutine starting from the address # 20FF (process u). Then, the subroutine which starts the address # 20F F is executed, and when the decoder 22 decodes the command "re turn” indicating the end and the command "halt” with it, it shifts to the return address # 102, and the main routine Return to (process V).
- the GPU 12 jumps to address # 220 (w).
- the return address need not be stored because it is a jump due to a branch within the same routine, and it is not a process of calling a subroutine and returning to the caller after the subroutine is finished.
- the address can be defined within 24 bits, it is possible to set the address with one command which need not be divided into multiple commands. This process is similar to the process of general jump instruction.
- FIG. 3 shows a format of a first command example in which the GPU 12 instructs the CPU 14 to perform address extraction in the present embodiment.
- This command is used in conjunction with the command “cpu cal,” “halt” and executes the call instruction of the playlist 50.
- each command is defined by 32 bits, and the command code power of the above 8 bits, ie 31 to 24 digits,
- the upper or lower 16 bits of the callee address are described as a data field in the lower 16 bits of the command type, lower 15 bits, ie, 15 to 0, in 8 bits, that is, 23 to 16 in the order.
- the command code is an encoding of each command.
- the command type may interrupt the process being executed when an interrupt is generated, whether or not it is necessary to save the return address, whether it is the process of the GPU 12 alone or not, in other words, the CPU 14 and It specifies incidental information on the execution of a command, such as cooperative processing or negative power.
- these formats are only an example, and if the decoder 22 can correctly decode a command, a field can be arbitrarily set to describe an instruction or data. For example, if the instruction part of a command can be described in the upper 8 bits, the remaining 24 bits may be used as a data field, and addresses and arguments may be described there.
- FIG. 4 shows the format of a second command example in which the GPU 12 instructs the CPU 14 to perform address extraction in the present embodiment.
- the command "cpu jmp" is used in conjunction with "halt” to execute the jump instruction of the playlist 50.
- the jump instruction includes a branch jump instruction and an unconditional jump instruction.
- FIG. 4 as well as FIG. 3 the upper 16 bits or lower 16 bits of the jump address are described in the lower 16 bit fields of each command.
- FIG. 5 is a flowchart when executing a call instruction in the present embodiment.
- the decoder 22 decodes the command "cpu call”
- the GPU 12 executes the command (S10).
- the decoder 22 decodes the next command “halt” and temporarily suspends the process currently being executed (S12).
- the GPU 12 generates a migration interrupt for the CPU 14 (S14).
- the CPU 14 saves the return address for returning to the main routine of the caller that the GPU 12 was executing to the auxiliary stack area 54 in the main memory 16 (S 16). .
- the callee address stored in the command "cpu call” and the command "halt” is extracted (S18). Then, the call destination address is notified to the GPU 12 (S20).
- the GPU 12 shifts to a subroutine starting from the call destination address (S22).
- the subroutine 22 executes the subroutine and the decoder 22 decodes the command "return”, the command (S24).
- the decoder 22 decodes the next command "halt” and ends the process currently being executed (S26). Parallel to this, the GPU 12 generates a return interrupt to the CPU 14 (S28).
- the CPU 14 In response to the return interrupt, the CPU 14 reads the return address saved in the auxiliary stack area 54 from the auxiliary stack area 54 in the main memory 16 (S30). Then, the return address is notified to the GPU 12 (S32). From the return address, the GPU 12 returns to the main routine of the caller and continues the processing (S34).
- the processing described above is processing on the premise that there is no free space in the address stack 26 of the GPU 12. In this respect, if there is free space in the address stack 26, the return address may be saved there.
- a flag register or the like may be provided in the GPU 12 and a flag indicating whether or not there is a vacant area in the address stack 26 may be set in the register. In this case, the decoder 22 can refer to the flag to determine whether to request the CPU 14 to save the address.
- the processing in steps S16 and S28 to S32 in FIG. 5 is unnecessary, and the processing in the GPU 12 is performed.
- FIG. 6 is a flow chart when executing a jump instruction in the present embodiment.
- the decoder 22 decodes the command "cpu jmp"
- the GPU 12 executes the command (S50).
- the decoder 22 decodes the next command “halt” and ends the processing currently being executed (S52).
- the GPU 12 generates an interrupt to the CPU 14 (S54).
- the CPU 14 divides the command “cpu jmp” and the command “halt” and extracts the jump destination address stored therein (S 56), and the jump destination address is extracted.
- the GPU 12 is notified (S58)
- the GPU 12 shifts to the jump destination address (S60) and resumes the reading of the address power as well.
- a return address for returning to the main routine of the call source which has generated the interrupt is stored in the main memory 16 outside the GPU 12. Since the data can be saved, the area for storing the return address in the GPU 12 can be reduced. That is, when the process of further generating a call instruction in the called routine is executed a plurality of times, and a multi-step subroutine is constructed. You need to keep multiple return addresses to return to the calling routine
- the return address can be saved in the main memory 16, and both the small scale processing of the GPU 12 and the processing flexibility can be achieved. Specifically, even a GPU 12 which is simple in terms of hardware resources can process call instructions of many stages.
- the CPU 14 entrusts the CPU 14 to extract the addresses.
- the registers of the GPU 12 can be reduced. That is, in order to extract addresses that span multiple commands, it is necessary to extract a part of the addresses contained in each command, and to register for shifting or combining them.
- the registers are larger in size than the registers needed to extract the arguments or addresses set in one command.
- the main CPU 14 consigns decoding of a command that requires a logical operation such as shift or addition, such as extracting an address set by dividing into a plurality of commands.
- the GPU 12 only needs to have the registers necessary to process a command that can be decoded in units of one command, so that the circuit area can be reduced and the scale can be reduced. Also, commands that are difficult to decipher with hardware resources of the GPU 12 can be deciphered by the CPU 14 to correspond to commands of various description systems. Therefore, it is possible to balance the small scale of GPU 12 and the processing flexibility. If the GPU 12 is scaled down, the entire multiprocessor system can be scaled down.
- the present invention has been described above based on the embodiments.
- the present invention is not limited to these embodiments, and various modifications thereof are also effective as aspects of the present invention.
- the configuration in which the GPU 12 has the address stack 26 has been described.
- all return addresses may be stored in the stack area of the main memory 16 without providing the address stack 26 in the GPU 12.
- further small-scale GPU12 can be Can.
- the call destination address and the jump destination address are divided into two commands and set.
- the data field of one command is small, or when the data length of the set address is further long, etc., it may be divided into three or more commands. According to this, it is possible to flexibly define the command description system.
- one command format is shortened, it is possible to further reduce the hardware resources of the GPU 12 on a small scale.
- the present invention is applicable to a system using a multiprocessor configuration in a computer processor and a technique for executing a program in the system.
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Executing Machine-Instructions (AREA)
- Image Processing (AREA)
- Advance Control (AREA)
- Multi Processors (AREA)
- Hardware Redundancy (AREA)
- Stored Programmes (AREA)
- Exchange Systems With Centralized Control (AREA)
Description
Claims
Priority Applications (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
EP05805443A EP1840736B1 (en) | 2004-12-03 | 2005-10-31 | Multi-processor system and program execution method in the system |
AT05805443T ATE461482T1 (de) | 2004-12-03 | 2005-10-31 | Mehrprozessorsystem und programmausführungsverfahren in dem system |
US10/587,553 US7805596B2 (en) | 2004-12-03 | 2005-10-31 | Highly integrated multiprocessor system |
DE602005020063T DE602005020063D1 (de) | 2004-12-03 | 2005-10-31 | Mehrprozessorsystem und programmausführungsverfahren in dem system |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
JP2004350702A JP3768516B1 (ja) | 2004-12-03 | 2004-12-03 | マルチプロセッサシステムとそのシステムにおけるプログラム実行方法 |
JP2004-350702 | 2004-12-03 |
Publications (1)
Publication Number | Publication Date |
---|---|
WO2006059444A1 true WO2006059444A1 (ja) | 2006-06-08 |
Family
ID=36383717
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/JP2005/020000 WO2006059444A1 (ja) | 2004-12-03 | 2005-10-31 | マルチプロセッサシステムとそのシステムにおけるプログラム実行方法 |
Country Status (6)
Country | Link |
---|---|
US (1) | US7805596B2 (ja) |
EP (2) | EP2124147B1 (ja) |
JP (1) | JP3768516B1 (ja) |
AT (2) | ATE522863T1 (ja) |
DE (1) | DE602005020063D1 (ja) |
WO (1) | WO2006059444A1 (ja) |
Families Citing this family (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8510596B1 (en) * | 2006-02-09 | 2013-08-13 | Virsec Systems, Inc. | System and methods for run time detection and correction of memory corruption |
US8269782B2 (en) * | 2006-11-10 | 2012-09-18 | Sony Computer Entertainment Inc. | Graphics processing apparatus |
JP2008228969A (ja) * | 2007-03-20 | 2008-10-02 | Seiko Epson Corp | 画像表示装置及び遊技機 |
JP2009110455A (ja) * | 2007-10-31 | 2009-05-21 | Hakko Denki Kk | プログラマブル操作表示器、そのプログラム |
US8480398B1 (en) * | 2007-12-17 | 2013-07-09 | Tamer Yunten | Yunten model computer system and lab kit for education |
KR20090103070A (ko) * | 2008-03-27 | 2009-10-01 | 삼성전자주식회사 | 멀티 링크 아키텍쳐에서 저장 상태정보의 다이렉트전송기능을 갖는 멀티 프로세서 시스템 |
AU2017285429B2 (en) | 2016-06-16 | 2022-03-31 | Virsec Systems, Inc. | Systems and methods for remediating memory corruption in a computer application |
Citations (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JPS57143642A (en) * | 1981-02-04 | 1982-09-04 | Burroughs Corp | Circuit for and method of controlling subroutine |
JP2002202964A (ja) * | 2000-11-02 | 2002-07-19 | Sony Computer Entertainment Inc | 並列演算装置、エンタテインメント装置、演算処理方法、コンピュータプログラム、半導体デバイス |
JP2003036169A (ja) * | 2001-07-25 | 2003-02-07 | Nec Software Tohoku Ltd | 複数の小規模プロセッサによって並列処理を行なうシングルチップマイクロプロセッサ |
US20030120897A1 (en) * | 2001-12-21 | 2003-06-26 | Schlansker Michael Steven | Multiple function unit processor using distributed variable length instruction words |
Family Cites Families (8)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5706478A (en) * | 1994-05-23 | 1998-01-06 | Cirrus Logic, Inc. | Display list processor for operating in processor and coprocessor modes |
US5784638A (en) * | 1996-02-22 | 1998-07-21 | International Business Machines Corporation | Computer system supporting control transfers between two architectures |
US6505290B1 (en) | 1997-09-05 | 2003-01-07 | Motorola, Inc. | Method and apparatus for interfacing a processor to a coprocessor |
US6167504A (en) * | 1998-07-24 | 2000-12-26 | Sun Microsystems, Inc. | Method, apparatus and computer program product for processing stack related exception traps |
US6807620B1 (en) * | 2000-02-11 | 2004-10-19 | Sony Computer Entertainment Inc. | Game system with graphics processor |
US6671196B2 (en) * | 2002-02-28 | 2003-12-30 | Sun Microsystems, Inc. | Register stack in cache memory |
US6996677B2 (en) * | 2002-11-25 | 2006-02-07 | Nortel Networks Limited | Method and apparatus for protecting memory stacks |
US8042179B2 (en) * | 2003-09-04 | 2011-10-18 | Science Park Corporation | False code execution prevention method, program for the method, and recording medium for recording the program |
-
2004
- 2004-12-03 JP JP2004350702A patent/JP3768516B1/ja active Active
-
2005
- 2005-10-31 AT AT09011692T patent/ATE522863T1/de not_active IP Right Cessation
- 2005-10-31 WO PCT/JP2005/020000 patent/WO2006059444A1/ja active Application Filing
- 2005-10-31 US US10/587,553 patent/US7805596B2/en active Active
- 2005-10-31 EP EP09011692A patent/EP2124147B1/en active Active
- 2005-10-31 EP EP05805443A patent/EP1840736B1/en active Active
- 2005-10-31 AT AT05805443T patent/ATE461482T1/de not_active IP Right Cessation
- 2005-10-31 DE DE602005020063T patent/DE602005020063D1/de active Active
Patent Citations (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JPS57143642A (en) * | 1981-02-04 | 1982-09-04 | Burroughs Corp | Circuit for and method of controlling subroutine |
JP2002202964A (ja) * | 2000-11-02 | 2002-07-19 | Sony Computer Entertainment Inc | 並列演算装置、エンタテインメント装置、演算処理方法、コンピュータプログラム、半導体デバイス |
JP2003036169A (ja) * | 2001-07-25 | 2003-02-07 | Nec Software Tohoku Ltd | 複数の小規模プロセッサによって並列処理を行なうシングルチップマイクロプロセッサ |
US20030120897A1 (en) * | 2001-12-21 | 2003-06-26 | Schlansker Michael Steven | Multiple function unit processor using distributed variable length instruction words |
Also Published As
Publication number | Publication date |
---|---|
EP2124147B1 (en) | 2011-08-31 |
DE602005020063D1 (de) | 2010-04-29 |
US20070283135A1 (en) | 2007-12-06 |
EP1840736B1 (en) | 2010-03-17 |
EP1840736A1 (en) | 2007-10-03 |
ATE522863T1 (de) | 2011-09-15 |
EP1840736A4 (en) | 2009-04-08 |
ATE461482T1 (de) | 2010-04-15 |
EP2124147A1 (en) | 2009-11-25 |
US7805596B2 (en) | 2010-09-28 |
JP2006163552A (ja) | 2006-06-22 |
JP3768516B1 (ja) | 2006-04-19 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
JP4934356B2 (ja) | 映像処理エンジンおよびそれを含む映像処理システム | |
US6289434B1 (en) | Apparatus and method of implementing systems on silicon using dynamic-adaptive run-time reconfigurable circuits for processing multiple, independent data and control streams of varying rates | |
EP1686474A2 (en) | Processor and information processing method | |
US20060200826A1 (en) | Processor and information processing method | |
WO2007140428A2 (en) | Multi-threaded processor with deferred thread output control | |
JPH09212358A (ja) | データ処理装置及びマイクロプロセッサ | |
WO2006059444A1 (ja) | マルチプロセッサシステムとそのシステムにおけるプログラム実行方法 | |
JP2007133456A (ja) | 半導体装置 | |
JP2002073330A (ja) | データ処理装置 | |
JP3837289B2 (ja) | 同じ論理的空間を占有する複数のレジスタファイルを含むマイクロプロセッサ | |
JPH10505444A (ja) | 処理システム、プロセッサ、命令ストリーム格納用メモリ及びコンパイラ | |
US8082429B2 (en) | Information processing apparatus and exception control circuit | |
US6675290B1 (en) | Processor for improving instruction utilization using multiple parallel processors and computer system equipped with the processor | |
US7246220B1 (en) | Architecture for hardware-assisted context switching between register groups dedicated to time-critical or non-time critical tasks without saving state | |
GB2380282A (en) | A data processing arrangement with a special and a general processing unit wherein the general unit may receive instructions from the special unit | |
US20070143579A1 (en) | Integrated data processor | |
US20210089305A1 (en) | Instruction executing method and apparatus | |
US8694697B1 (en) | Rescindable instruction dispatcher | |
JP4389797B2 (ja) | プロセッサおよび情報処理方法 | |
CN108022281B (zh) | 渲染三维图形的方法及装置 | |
JP2876791B2 (ja) | 例外処理装置および例外処理方法 | |
JP3102399B2 (ja) | データ処理装置及び方法 | |
JP3729250B2 (ja) | 情報処理装置及び電子機器 | |
CN114579264A (zh) | 处理装置、处理***和处理方法 | |
JP2001092792A (ja) | データ処理装置 |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AK | Designated states |
Kind code of ref document: A1 Designated state(s): AE AG AL AM AT AU AZ BA BB BG BR BW BY BZ CA CH CN CO CR CU CZ DE DK DM DZ EC EE EG ES FI GB GD GE GH GM HR HU ID IL IN IS KE KG KM KN KP KR KZ LC LK LR LS LT LU LV LY MA MD MG MK MN MW MX MZ NA NG NI NO NZ OM PG PH PL PT RO RU SC SD SE SG SK SL SM SY TJ TM TN TR TT TZ UA UG US UZ VC VN YU ZA ZM ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A1 Designated state(s): GM KE LS MW MZ NA SD SL SZ TZ UG ZM ZW AM AZ BY KG KZ MD RU TJ TM AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HU IE IS IT LT LU LV MC NL PL PT RO SE SI SK TR BF BJ CF CG CI CM GA GN GQ GW ML MR NE SN TD TG |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
NENP | Non-entry into the national phase |
Ref country code: DE |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2005805443 Country of ref document: EP |
|
WWE | Wipo information: entry into national phase |
Ref document number: 10587553 Country of ref document: US |
|
WWP | Wipo information: published in national office |
Ref document number: 2005805443 Country of ref document: EP |
|
WWP | Wipo information: published in national office |
Ref document number: 10587553 Country of ref document: US |