WO2006122990A2 - Aparato, sistema y método de dispositivo de memoria para conjuntos múltiples de instrucciones de tipo especulativo - Google Patents

Aparato, sistema y método de dispositivo de memoria para conjuntos múltiples de instrucciones de tipo especulativo Download PDF

Info

Publication number
WO2006122990A2
WO2006122990A2 PCT/ES2005/000279 ES2005000279W WO2006122990A2 WO 2006122990 A2 WO2006122990 A2 WO 2006122990A2 ES 2005000279 W ES2005000279 W ES 2005000279W WO 2006122990 A2 WO2006122990 A2 WO 2006122990A2
Authority
WO
WIPO (PCT)
Prior art keywords
instructions
values
segment
task
precalculation
Prior art date
Application number
PCT/ES2005/000279
Other languages
English (en)
French (fr)
Other versions
WO2006122990A3 (es
Inventor
Carlos Madriles
Peter Rundberg
Jesus Sanchez
Carlos Garcia
Pedro Marcuello
Antonio González
Original Assignee
Intel Corporation
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by Intel Corporation filed Critical Intel Corporation
Priority to PCT/ES2005/000279 priority Critical patent/WO2006122990A2/es
Priority to US10/544,874 priority patent/US20080134196A1/en
Publication of WO2006122990A2 publication Critical patent/WO2006122990A2/es
Publication of WO2006122990A3 publication Critical patent/WO2006122990A3/es

Links

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/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • G06F9/3824—Operand accessing
    • 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/3824—Operand accessing
    • G06F9/3834—Maintaining memory consistency
    • 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/3836—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • G06F9/3842—Speculative instruction execution
    • 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/3836—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • G06F9/3851—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution from multiple instruction streams, e.g. multistreaming

Definitions

  • a set of speculative instructions or tasks in an architecture of multiple sets of speculative type tasks may include a body of said set of instructions or tasks and a precalculation sector.
  • the term "task” (“thread”), as used in this description, can refer to a set of one or more instructions.
  • speculative task can refer to a set of one or more instructions.
  • speculative thread can refer to a task that is executed based on input conditions or initial speculative conditions.
  • a speculative task can become committed (“commited") after validation of its initial conditions.
  • the precalculation or precomputing segment of a speculative task may include a subset of instructions of a dynamic generation task that has dynamically generated the speculative task.
  • the data dependencies between the dynamic generation task and the dynamically generated task can be handled by the precalculation segment of the dynamically generated task.
  • the precalculation segment can be executed to produce one or more initial "live" values that are consumed by the task body of the speculative task.
  • the precalculation segment of a speculative task may require access to certain "old" memory values, for example, values of the moment at which the task was dynamically generated, rather than the values produced more Recent for this task.
  • other parts of the speculative task for example, its body, may require access to memory values that have been updated very recently. Therefore, a speculative multitasking architecture with live precalculation may require a memory configuration or memory arrangement that is capable of supporting both the precalculation segment and the task body of a speculative task.
  • Figure 1 is a block diagram showing an apparatus adapted for executing a computer program code by speculative multitasking with live pre-calculation according to at least one embodiment of the invention
  • FIG. 2 is a block diagram of a task unit having memory configuration adapted to support multiple versions and a process unit that executes a speculative task according to illustrative embodiments of the invention
  • Figure 3 is a schematic flow diagram of a method of dynamic generation of a task according to illustrative embodiments of the invention
  • Figure 4 is a schematic flow chart of a method of realizing the precalculation segment of a speculative task according to illustrative embodiments of the invention
  • Figure 5 is a schematic flow chart of a method of performing the task body of a speculative task according to illustrative embodiments of the invention
  • Figure 6 is a schematic flow chart of a method of executing a load instruction in a precalculation segment according to illustrative embodiments of the invention
  • Figure 7 is a schematic flow chart of a method of carrying out a storage instruction in a precalculation segment according to illustrative embodiments of the invention
  • Figure 8 is a schematic flow chart of
  • Some embodiments of the invention may be implemented, for example, using a machine-readable medium or an article that can store an instruction or set of instructions that, if executed by the machine, causes it to carry out a method and / or operations in accordance with embodiments of the invention.
  • This machine may include, for example, any suitable process platform, computer process platform, computer process device, process device, computer process system, process system, computer, processor or the like, and can be implemented making any suitable combination of hardware and / or software.
  • the medium or article that is machine-readable may include, for example, any suitable type of memory unit, memory structure, memory article, memory medium, storage device, storage article, storage medium and / or unit storage, for example, memory, removable or non-removable media, media that can be erased or not, media that can be written or rewritten, digital or analog media, hard drives, soft drives, compact discs of read memory only (CD -ROM), recordable compact discs (CD-R), compact discs that can be rewritten
  • any suitable type of memory unit for example, any suitable type of memory unit, memory structure, memory article, memory medium, storage device, storage article, storage medium and / or unit storage, for example, memory, removable or non-removable media, media that can be erased or not, media that can be written or rewritten, digital or analog media, hard drives, soft drives, compact discs of read memory only (CD -ROM), recordable compact discs (CD-R), compact discs that can be rewritten
  • CD-RW compact discs
  • magnetic media various types of versatile digital discs (DVD), magnetic tape, cassette or the like.
  • DVD versatile digital discs
  • the instructions may comprise any suitable type of code, for example, source code, summary code, interpreted code, executable code, static code, dynamic code or the like, and can be implemented using any suitable high level, low level, language oriented language.
  • object, visual, programming language summarized and / or interpreted for example, C, C ++, Java, BASIC, Pascal, Fortran, Cobol, assembly language, machine code or the like.
  • Embodiments of the invention may include apparatus for carrying out the indicated operations. These devices may be specifically constructed for the desired purposes, or may include a general type computer selectively activated or reconfigured by a computer program stored in the computer.
  • This computer program can be stored in a storage medium readable by the computer, for example, without limitation, any type of disk including soft discs, optical discs, CD-ROM, magnetic magnetic discs, read memory only (ROM), random access memories (RAM), electrically programmable read only memories (EPROM), electrically erasable and only programmable read memories (EEPROM), magnetic or optical cards, or any other type of support suitable for storing instructions electronic, and capable of being coupled to the bus of a computer system.
  • inventions of the present invention disclose a multi-version memory configuration that is capable of preserving multiple values per task or group of instructions ("thread") speculative for the same memory location, to thereby support both precalculations or "live-in” precomputing and realization of a block of a task or set of speculative instructions.
  • embodiments of the invention provide validation of input values that can be processed by computer and used in the execution of task or speculative instruction set.
  • Figure 1 is an illustrative block diagram of an apparatus (100) adapted to execute a code of Multiconj computer program with speculative instructions with live precalculation, according to illustrative embodiments of the invention.
  • the device 100 adapted to execute a code of Multiconj computer program with speculative instructions with live precalculation, according to illustrative embodiments of the invention.
  • (100) can comprise, for example, a processor (104) that can be implemented in a semiconductor device, operatively connected to a memory configuration, for example, an "off-chip” memory hierarchy (106), with intermediate an interconnection bus (108).
  • the processor 1014 that can be implemented in a semiconductor device, operatively connected to a memory configuration, for example, an "off-chip" memory hierarchy (106), with intermediate an interconnection bus (108).
  • the (104) may comprise one or more task units or instruction sets, for example, N units including instruction set units (112) and (114) for performing one or more tasks.
  • a task unit or instruction set may include on-chip memories, for example, in the form of caches and / or buffers, and other desirable hardware.
  • the units (112) and (114) can be operatively connected to a version control logic unit (VCL) (120) through an interconnect bus (110).
  • VCL unit (120) can control the reading and writing interaction between task units, for example, units (112) and (114).
  • a non-exhaustive list of examples for the apparatus (100) may comprise a desktop personal computer, a workstation, a server computer, a laptop computer, a calendar computer, a manual computer, a personal digital assistant computer ( PDA), mobile phone, game console and similar.
  • PDA personal digital assistant computer
  • processor (104) may comprise a central processing unit (CPU), a digital signal processor (DSP), a computer with reduced instruction set (RISC), a computer with complex instruction set (CISC) and the like.
  • the processor (104) may also be part of an application-specific integrated circuit (ASIC), or it may be part of an application-specific standard product (ASSP).
  • ASIC application-specific integrated circuit
  • ASSP application-specific standard product
  • the processor (104) may incorporate hardware and technologies, such as technologies of "hyper threading” (Intel ®), and can support “thread level parallelism” in the simultaneous processing of multiple instruction sets.
  • Each thread unit for example, the unit
  • each of the units (112) and (114 ) can process instruction sets
  • off-chip memory (106) may include semiconductor devices of the following type or any combination thereof, such as synchronous random dynamic access memory devices (SDRAM), access memory devices Random dynamic type RAMBUS (RDRAM), double data memory structures (DDR), static type random access memory devices (SRAM), flash memory structures, read-only memory devices electrically readable programmable type (EEPROM), non-volatile random access memory device
  • SDRAM synchronous random dynamic access memory devices
  • RDRAM Random dynamic type RAMBUS
  • DDR double data memory structures
  • SRAM static type random access memory devices
  • flash memory structures such as synchronous random dynamic access memory devices (SDRAM), access memory devices Random dynamic type RAMBUS (RDRAM), double data memory structures (DDR), static type random access memory devices (SRAM), flash memory structures, read-only memory devices electrically readable programmable type (EEPROM), non-volatile random access memory device
  • NVRAM non-volatile memory
  • USB removable universal serial bus
  • CD-ROM compact disc read only
  • CD-ROM compact disc read only
  • magnetic devices such as hard drives, soft drives, magnetic tape and the like.
  • off-chip memory (106) can be fixedly arranged inside the apparatus (100) or detachable.
  • Figure 2 is a block diagram showing a task handling unit or instruction sets (200) having a memory configuration (201) and a process unit (202).
  • Figure 2 shows that the process unit (202) of the instruction set processing unit
  • FIG. 200 may include an instruction cache (240), which can execute a set of instructions (241).
  • Figure 2 also shows a task handling unit or instruction sets (250) for performing an instruction set (251). For the purposes of explaining the specific example in Figure 2, it is assumed that the instruction set (251) has been dynamically generated by the instruction set (241).
  • Figure 2 also shows a traditional unit
  • Figure 2 shows an example that assumes that the instruction set (261) has dynamically generated the instruction set (241) according to at least one embodiment of the invention.
  • the memory configuration (201) may be a memory device capable of supporting multiple versions, and may include a series of memory structures, for example, a memory structure (210) that includes one or more "old buffers", for example, old buffers (212) and (214).
  • the memory configuration (201) may also include a "segment buffer” (220) and a "level 1" data cache Ll.
  • the terms and details of "old buffer”, "segment buffer” and "LI data cache” are described in the following sections.
  • Figure 2 shows three units of tasks, it will be appreciated by those skilled in the art that the embodiments of the invention can be implemented with more than three units of tasks or less than three units of tasks, according to the requirements of the system specific. Furthermore, it will be appreciated that the task unit according to the embodiments of the invention can execute speculative tasks as well as non-speculative tasks.
  • a memory structure for example, the segment buffer (220) or the data cache L-I (230), can have multiple entries or lines.
  • the term "line” or “entry” in this description may refer to the granularity of the memory unit controlled by a processor or task unit, and may comprise various memory locations and data values.
  • the task or instruction set (251) may have the precalculation segment (252) and a body (254) of the task.
  • Task (261) can have a precalculation segment
  • Task (241) and (260), which perform tasks (251) and (261), may have memory configurations similar to the Task unit (200) and therefore its details have not been shown in order to make the illustration simpler.
  • the (202) of the task unit (200), may have a precalculation segment (242) and a body (244) of the task.
  • Homework may have a precalculation segment (242) and a body (244) of the task.
  • (241) can be designated as a local task with respect to the task unit (200).
  • the task (241) can dynamically generate the task (251), and therefore the task (241) can be a "matrix task” of the task (251), and the task (251) can be a
  • the precalculation segment (252) of the speculative task (251) can read memory values generated by its dynamically generated task (241) at the time when the speculative task (251) has been dynamically generated. These memory values can be read by the task (251) from, for example, the data cache (230) Ll of the task unit (200).
  • the "storage" operations carried out by the parent task (241) to reserve updated values of the data cache Ll, after the creation of the filial task (251 ), can be made "invisible" for the precalculation segment (252) of the filial task (251) by the memory configuration (201). In other words, memory values at the time that the filial task (251) was dynamically generated can be preserved by the memory configuration (201).
  • the storage operations carried out by the parent task (241) can be made available to the body.
  • old buffer in this description, can refer to a memory structure adapted to store values of other memories, for example, the data cache Ll of a memory unit when a task executed by the task unit generates dynamically one or more speculative tasks. For example, when the speculative task (251) is dynamically generated, the old buffer (212) can be assigned to the generated task (251) in the task unit (200) of the dynamic generation task (241).
  • the values stored in the old buffer (212) of the task unit (200) can be provided to the precalculation segment (252) of the task (251) for the calculation of live initial values towards the body (254) of the task.
  • the task unit (200) can have as many old buffers as the number of filial tasks dynamically generated by the task unit (200).
  • a task unit can carry out storage operations in its memories, for example, cache of Ll data, during the execution of a task. For example, before writing new values in the location of the data cache Ll (230), the task unit (200) can store existing values in the location of the data cache Ll (230) to the memory structure
  • segment buffer in the present invention, can refer to a memory structure adapted for storing live initial values calculated by p ⁇ -calculation of a speculative task.
  • the dynamically generated task can be assigned, in a task unit that executes the dynamically generated speculative task, with an empty segment buffer.
  • the task (241) can be a speculative task and when it is dynamically generated by the task (261), the task unit (200) executing the task (241) may have assigned the segment buffer
  • the segment buffer (220) can include multiple entries.
  • An entry may include, for example, a validation bit "V”, for example, the "V” bit (222), and a vector of read bits “Rmask”, for example, bits “Rmask” (224).
  • the "Rmask” bits (224) can contain as many bits as the number of task units exists in a processor, for example, the processor (104) (figure 1). The functions of the "V" bit and the "Rmask” bits are described below.
  • the precalculation can write values in segments of the segment buffer of a task unit.
  • the "V" bit (222) may be set to indicate that the line It is valid.
  • values of the memory entries of the segment buffer (220) can be read. If the reading is carried out by the task (241), local with respect to the task unit (200), the "V" bit (222) can be replaced to invalidate the line that has been read that can then be copied into the data cache Ll (230).
  • the "V" bit (222) may not be replaced, that is, it can be kept in its initial disposition, and the line remains valid. In both cases, the corresponding bit read in the "Rmask” bits (224) is used to indicate which task the line has read.
  • the entries in the buffer of Task segment can be validated by checking if the task body has been executed with correct input values or if a speculation failure may have occurred during execution. This validation can be performed as follows.
  • the entries of the segment buffer that have some of their "Rmask" bits arranged can be sent to the previous non-speculative tasks to validate their values.
  • subsequent speculative tasks which may have referenced the entries of the task segment buffer and all its successors, may be canceled.
  • the values stored in the segment buffer can be canceled since they are potentially erroneous. All local Ll data cache lines are recorded.
  • the data cache Ll (230) may include multiple "lines" of memory. "A data cache line Ll (230) may include a set of status bits that includes an" old bit "(232).
  • the task (241) that is performed on the task unit (200) can carry out a load on a line of the data cache Ll (230) during the precalculation, when the loaded value comes from an old buffer of the parent task (261) assigned for the task (241) or of the data cache Ll or segment buffers of other remote tasks that are less speculative than the parent task (261), a bit old line, for example, old bit (232), can be arranged to indicate that the line may potentially contain old values and that it can be discarded at the exit of the precalculation segment.
  • the old bits for example, the old bit (232)
  • the old bit (232) can be used to prevent a more speculative task from reading old values of less speculative tasks during the execution of a precalculation segment of The most speculative task.
  • all cache entries Ll with the old bit are invalidated to prevent values in the cache lines, which are potentially old, from being read by this task and other more speculative tasks, as described in detail later.
  • a non-speculative task ends its execution, it may be possible that some of the derived or dynamically generated tasks generated by the non-speculative task are still performing their respective precalculation segments. Therefore, according to illustrative embodiments of the invention, old buffers of the non-speculative task cannot be released until these derivative or subsidiary tasks complete their precalculation segments.
  • a speculative task becomes a non-speculative task, it can send a request to its parent task to cancel the assignment of its corresponding old buffer, as described in detail below.
  • the unit of task that executes the taxed task can go to rest and can be assigned to perform a new task. While the invention is not limited in this respect, the number of task units in a processor, for example, the processor (104) of Figure 1, can be fixed.
  • FIG. 3 is a schematic flow chart of a method of dynamic generation of a task according to an illustrative embodiment of the present invention.
  • a task unit can divide the task it is executing or can dynamically generate one or more speculative tasks for parallel processing.
  • a task unit starts dynamic generation, it can determine, first, in block (312), if there is a free old buffer available for the task to be generated dynamically. If there are no free old tampons available, dynamic generation can be aborted, ending the process. If one or more free old buffers are available, one of the old buffers can be assigned in block (314). Then a task, that is, a derived or filial task, can be dynamically generated in block (316) and attributed to the assigned old buffer. The dynamic generation process can then be finished.
  • Figure 4 is a schematic flow diagram of a method of realizing the precalculation segment of a speculative task, in accordance with illustrative embodiments of the invention.
  • segments of task precalculation can be performed in different task units simultaneously for the live calculation of input or initial values to their respective task bodies.
  • a task unit begins to execute the precalculation segment of a speculative task, it can read an instruction, in block (412), from a local instruction cache or some external memory hierarchy.
  • the task unit can execute the load of the segment or store the instruction, in block (416 ), in a process that is defined in Figure 6 (for loading instructions) or in Figure 7 (for storage instruction) as indicated below. If the instruction is not a memory access instruction, it can be executed regularly in block (417). In block (418), it can be determined whether the speculative task in execution has received, for example, instructions for its removal by an instruction received. If the task has to be maintained, the task unit can determine, in block (420), if the end of the precalculation segment has been reached. If there are more precalculation instructions to execute, the task unit may return the execution process back to block (412) to read the next instruction, and the process described above may be repeated. If this is the _ or ⁇ -
  • the task unit can go to block (422) to override lines of the local data cache LI, whose old bits have been set during the execution of the segment load or can store instructions ( Figure 6 or 7).
  • the task unit can send a request to a task unit that has dynamically generated the speculative task under execution to deallocate the old buffer assigned to the speculative task, which has just completed its precalculation segment.
  • the unit of task that executes the speculative task may go to block (424) to override lines of the local data cache L-I that are not committed.
  • the task unit may then go to the block (426) to empty, for example, delete, the buffer of the task unit segment, and the block
  • FIG. 5 is a schematic flow diagram of a method of executing the body of the instruction set of a set of speculative instructions, in accordance with the illustrative embodiments of the present invention. After the "live-in" precalculation of a set of speculative instructions, a task unit may begin executing instructions from the body of said instruction set. The task unit may read an instruction, in block (512), of a local instruction cache or some kind of external memory hierarchy.
  • said task unit may execute said instruction set load or storage instruction, in the block (516), in a procedure that is defined in Figure 8 (for the load instruction) or Figure 9 (for the storage instruction) below. If the instruction is not a memory access instruction, it can be executed regularly in block (517).
  • block (518) it is checked whether the speculative instruction set should be removed or silenced. If the instruction set must not be eliminated, the task unit can proceed to determine, in block (520), if the end of the instruction set body has been reached. If there are more instructions to execute in the body of the instruction set, the task unit can continue reading the next instruction by returning the process to block (512), and the procedure described above can be repeated. If the end of the instruction set body has been reached, the task unit can proceed to block (522) to validate the read inputs, in the buffer of the segment of the instruction set, whose reading bits have been determined during the execution of the load of the instruction set or of the storage instructions (figure 8 or 9).
  • the execution of the body of the instruction set is considered as valid and therefore carried out, or as invalid and therefore eliminated in block (524).
  • the task unit can then proceed to block (532) to eliminate, for example, clean the entries in the buffer of the task unit segment.
  • An instruction set can be suppressed or silenced when a suppression signal is sent by the VCL unit (120) in situations where a faulty speculation is detected, or sent by a less speculative instruction set for other reasons. If in block (518) it is determined that the instruction set must be deleted, the unit of tasks that is executing said instruction set can proceed, in block (526), to invalidate lines not executed in the local data cache Ll, in block (528), to deallocate old buffers from the task unit, and then, in block (530), delete the instruction set and finish the execution. The task unit can then proceed to block (532) to clean the entries in the segment buffer.
  • FIG. 6 is a schematic flow chart of a method of executing a load instruction in a precalculation segment in accordance with the illustrative embodiments of the present invention.
  • a task unit When a task unit carries out a load instruction in a precalculation segment, it can access the local data cache Ll and the buffer of the task unit segment in the block (612).
  • the load instruction is terminated. Otherwise, the task unit may proceed to block (616).
  • the task unit can issue a bus read request within the segment to access a task unit of the parent task set via an "on-chip" interconnect bus (110) ( Figure 1 ).
  • the order within the segment may be accompanied by a signal indicating that the instruction set that placed the order, a subsidiary instruction set, is in the precalculation segment mode and therefore said matrix instruction set may return a line of an old buffer assigned for said subsidiary instruction set and not from its data cache Ll.
  • the old buffer assigned to the parent task unit can be accessed in block (618).
  • the task unit of the matrix instruction set can provide a line of your old buffer assigned in block (620). Said line can be copied to the data cache Ll of the task unit of the subsidiary instruction set in block (621). The old bit of the line in the local data cache Ll can be determined, in block (630), to indicate that the values could be old since they are copied from the task unit of the matrix instruction set.
  • unit VCL (120) (figure 1) can access other data cache Ll and buffers of the remote instruction set segment, in block (622), which are less speculative that the matrix instruction set, by means of an "on-chip" interconnection bus (110)
  • the VCL unit (120) can treat the load instructions as an ordinary load, and consider the filial instruction set that the line requests as having the same logical order as its matrix instruction set.
  • the VCL unit (120) may proceed to copy the line to the data cache Ll of the task unit in block (625).
  • the task unit You can then proceed to determine, in block (628), if the line that has been copied is an assigned line. If the line is an assigned or committed line, the load instruction is executed and terminated. If it is not a compromised line, the old bit in the line copied from the local data cache Ll can be determined, in block (630), to indicate that the data in it could be potentially old.
  • the task unit can access an "off-chip” memory hierarchy (106) (figure 1), in the block (626), by means of an "off-chip” interconnection bus (108) (figure 1).
  • the line obtained from the "off-chip” memory (106) can be copied to the local data cache Ll.
  • Figure 7 is a schematic flow chart of a method of executing a storage instruction in a precalculation segment according to the illustrative embodiments of the present invention.
  • a task unit executes a precalculation segment and performs a storage instruction
  • the data can be stored in the buffer of the task unit segment.
  • the line to be stored may be placed first in the segment buffer and then updated with the stored data.
  • a method similar to that described in relation to the performance of a load instruction can be carried out ( Figure 6).
  • a task unit carries out a storage instruction in a precalculation segment, it can access the local data cache Ll and the segment buffer of said task unit in the block (712).
  • block (714) if it is determined that the requested memory line is available in the local data cache Ll, then that line in the data cache Ll may be invalidated in the block (730). The line is copied to the buffer of the task unit segment and is updated with the storage data in the block (728). Such data is invisible to the other task units as long as the precalculation segment is still running. In block (714), if it is determined that the line is not available in the local data cache Ll or the segment buffer, that is, the line is not found locally, the task unit may proceed to the block ( 716).
  • the task unit can issue a bus write request "within the segment” to access the task unit of the matrix instruction set via the "on-chip” interconnect bus (110)
  • the order "within the segment” may be accompanied by a signal indicating that the instruction set that made the order, a subsidiary instruction set, is in the precalculation segment mode and therefore the matrix instruction set may return a line from an old buffer assigned to the subsidiary instruction set and not from its data cache Ll.
  • the old buffer assigned to the matrix task unit can be accessed in block (718).
  • the task unit of the matrix instruction set can provide a line, from its old buffer assigned in block (720).
  • the line can be copied to the segment buffer of the task unit of the subsidiary instruction set and updated with the storage data in the block (728). This data is invisible to other task units as long as the precalculation segment is still running.
  • the VCL unit (120) can access other data cache Ll and buffers of the remote instruction set segment, in block (722), which are less speculative than the matrix instruction set, via the "on-chip" interconnection bus (110) (figure 1).
  • the VCL unit (120) can treat the storage instruction as an ordinary memory, and considering that the subsidiary instruction set requesting said line has the same logical order as its parent instruction set.
  • Figure 8 is a schematic flow diagram of a method of executing a load instruction in the body of the instruction set of a speculative task in accordance with the illustrative embodiments of the present invention.
  • a task unit that executes the instruction set body of a speculative task When a task unit that executes the instruction set body of a speculative task performs a load instruction, it can first access the memory positions of the segment buffer and the data cache Ll of the task unit in the block
  • the task unit can proceed to determine, in block (826), if the line is available in the segment buffer. If the line is available from the segment buffer, then it is copied to the data cache Ll of the task unit in block (828). The line that supplies the data in the segment buffer is marked as read by the corresponding reading bit in the "Rmask” and as invalid by restoring the validity bit "V" (figure 2). All lines in the segment buffer with a certain read bit are then validated before the instruction set becomes non-speculative. In block (826), if it is determined that the line is available in the local data cache Ll, then the load instruction is terminated.
  • the task unit can Issue a bus read request, in block (816), to the VCL unit (120) via the "on-chip" interconnect bus (110) (figure 1).
  • the VCL unit (120) can access other data cache Ll and the buffers of the task segment or remote instruction set and less speculative in the block (818).
  • the VCL unit (120) can set the old bit in the lines of the data cache Ll of the instruction sets that are more speculative than the current instruction set and are still executing precalculation segments, in block (820), to indicate that the data could be old.
  • the VCL unit (120) can assign the correct version of the requested line from the instruction sets that are less speculative than the instruction set being executed, it could copy the line to the cache of Ll data of the instruction set unit in block (823).
  • the instruction set unit can proceed to determine, in block (830), if a buffer of the remote segment has provided said line. If so, then the line in the buffer of the remote segment is marked as read and indicates which unit of tasks has read that line, in block (832), using a "Rmask" reading bit of the segment buffer. All lines in the segment buffer with a certain read bit are validated before the set of instructions in execution becomes non-speculative.
  • the task unit can access a memory or off-chip hierarchy "(106), in block (824), by an interconnect bus (108) "off-chip” (figure 1) . Then, the line obtained from the "off-chip” memory (106) is copied, in block (824), to the data cache local Ll of the task unit.
  • Fig. 9 is a schematic flow chart of a method of executing a storage instruction in the body of the instruction set of a speculative instruction set according to the illustrative embodiments of the present invention.
  • the task unit can first access the memory positions of the segment buffer and the data cache Ll of said task unit in the block (912). In block (914), if it has been determined that the requested line is available, the task unit can proceed to determine, in block
  • the task unit You can send a bus write request, in block (916), to the VCL unit (120) via the "on-chip" interconnect bus (110) (figure 1).
  • the unit (120) can access other data cache Ll and buffers of the remote and less speculative instruction set segment in the block (918).
  • the VCL unit (120) can also determine the old bit of the data cache lines Ll of instruction sets that are more speculative than the present instruction set and that are still executing precalculation segments, in block (920), to indicate that the data could be old.
  • the VCL unit (120) if it is able to assign the correct version of the requested line, it can proceed to determine, in block (930), if a buffer of the remote segment has provided said line. If so, then the line in the buffer of the remote segment is marked as read and it is indicated which unit of tasks has read that line, in block (932), using a "Rmask” reading bit of the buffer of the remote segment . All lines in the segment buffer with Some given reading bit are validated before the set of instructions in execution becomes non-speculative.
  • the task unit can access an "off-chip” memory hierarchy (106), in block (924), by an "off-chip” interconnect bus (108) (figure 1).
  • the line is copied to old buffers, in block (934), which are allocated in the task unit to save old memory values for sets of filial instructions that are activated by the task unit and They are running precalculus buffers. Then the line is copied to the local data anteface of the task unit and updated with the storage data in the block (936).

Landscapes

  • Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Multimedia (AREA)
  • Advance Control (AREA)
  • Memory System Of A Hierarchy Structure (AREA)

Abstract

Las realizaciones de la presente invención dan a conocer una configuración de memoria multiversión que tiene la capacidad para mantener múltiples valores por conjunto de instrucciones especulativo para la misma posición de memoria para soportar precálculo y ejecución vivos del cuerpo del conjunto de instrucciones de un conjunto de instrucciones especulativo. Además, las realizaciones de la presente invención dan a conocer la validación de los valores de entrada que pueden ser calculados y utilizados en la ejecución del conjunto de instrucciones especulativo. Las realizaciones de la presente invención dan a conocer además un método para el funcionamiento de la misma.

Description

Aparato, sistema y método de dispositivo de memoria para conjuntos múltiples de instrucciones de tipo especulativo
Antecedentes de la invención Un conjunto de instrucciones o tareas especulativas en una arquitectura de múltiples conjuntos de tareas de tipo especulativo puede incluir un cuerpo de dicho conjunto de instrucciones o tareas y un sector de precálculo. El término "tarea" ("thread"), tal como se utiliza en esta descripción, puede hacer referencia a un conjunto de una o varias instrucciones . El término "tarea especulativa"
( "speculative thread" ) , tal como es bien conocido en esta técnica, puede hacer referencia a una tarea que es ejecutada basándose en condiciones de entrada o condiciones iniciales especulativas. Una tarea especulativa puede pasar a ser comprometida ("commited") después de validación de sus condiciones iniciales. El segmento de precálculo o precomputación de una tarea especulativa puede incluir un subconjunto de instrucciones de una tarea de generación dinámica que ha generado dinámicamente la tarea especulativa. Las dependencias de datos entre la tarea de generación dinámica y la tarea generada dinámicamente pueden ser manejadas por el segnerrco de precálculo de la tarea generada dinámicamente. Durante la ejecución de la tarea especulativa, el segmento de precálculo se puede ejecutar para producir uno o varios valores iniciales "vivos" que son consumidos por el cuerpo de tarea de la tarea especulativa. Para producir valores iniciales vivos, el segmento de precálculo de una tarea especulativa puede requerir acceso a ciertos valores de memoria "antiguos", por ejemplo, valores del momento en el que la tarea fue generada dinámicamente, en vez de los valores producidos de manera más reciente para dicha tarea. No obstante, otras partes de la tarea especulativa, por ejemplo, el cuerpo de la misma, pueden requerir acceso a valores de memoria que se han actualizado de manera muy reciente. Por lo tanto, una arquitectura multitarea especulativa con precálculo vivo puede requerir una configuración de memoria o disposición de memoria que sea capaz de soportar tanto el segmento de precálculo como el cuerpo de la tarea de una tarea especulativa . Breve descripción de los dibujos
La invención se comprenderá y se apreciará de manera más completa en base a la siguiente descripción detallada de diferentes realizaciones de la misma, en relación con los dibujos adjuntos, en los cuales: la figura 1 es un diagrama de bloques que muestra un aparato adaptado para ejecutar un código de programa de ordenador por multitareas especulativas con precálculo vivo de acuerdo, como mínimo, con una realización de la invención; la figura 2 es un diagrama de bloques de una unidad de tarea que tiene configuración de memoria adaptada para soportar múltiples versiones y una unidad de proceso que ejecuta una tarea especulativa de acuerdo con realizaciones ilustrativas de la invención; la figura 3 es un diagrama de flujo esquemático de un método de generación dinámica de una tarea de acuerdo con realizaciones ilustrativas de la invención; la figura 4 es un diagrama de flujo esquemático de un método de realización del segmento de precálculo de una tarea especulativa según realizaciones ilustrativas de la invención; la figura 5 es un diagrama de flujo esquemático de un método de realización del cuerpo de la tarea de una tarea especulativa según realizaciones ilustrativas de la invención; la figura 6 es un diagrama de flujo esquemático de un método de ejecución de una instrucción de carga en un segmento de precálculo según realizaciones ilustrativas de la invención; la figura 7 es un diagrama de flujo esquemático de un método de realización de una instrucción de almacenamiento en un segmento de precálculo según realizaciones ilustrativas de la invención; la figura 8 es un diagrama de flujo esquemático de un método de ejecución de una instrucción de carga en el cuerpo de la tarea de una tarea especulativa de acuerdo con realizaciones ilustrativas de la presente invención; y la figura 9 es un diagrama de flujo esquemático de un método de realización de una instrucción de almacenamiento en el cuerpo de la tarea de una tarea especulativa, de acuerdo con realizaciones ilustrativas de la invención.
Se observará que, a efectos de simplicidad y claridad de ilustración, los elementos mostrados en las figuras no se han dibujado necesariamente a escala. Por ejemplo, las dimensiones de algunos de estos elementos se pueden haber exagerado con respecto a otros elementos para mayor claridad . Descripción detallada de realizaciones de la invención
En la siguiente descripción detallada, se indicarán numerosos detalles específicos a efectos de proporcionar una comprensión completa de las realizaciones de la invención. No obstante, se comprenderá por los técnicos en la materia que se pueden llevar a cabo realizaciones de la invención sin estos detalles específicos. En otros casos, no se han descrito de manera detallada métodos y procesos que son conocidos a efectos de no dificultar la comprensión de las realizaciones de la invención. Algunas partes de la descripción detallada siguiente se presentan en términos de algoritmos y representaciones simbólicas de operaciones en bits de datos o señales digitales binarias dentro de una memoria de ordenador. Estas descripciones de algoritmos y representaciones pueden ser técnicas utilizadas por los expertos en el proceso de datos para trasladar las bases de su trabajo a otros técnicos en la materia.
Un algoritmo se considerará en esta descripción, y de modo general, una secuencia autónoma de actos o de operaciones que conducen a un resultado deseado. Éstas incluyen manipulaciones físicas de cantidades físicas. Habitualmente, si bien no de modo necesario, estas cantidades adoptan la forma de señales eléctricas o magnéticas capaces de ser almacenadas, transferidas, combinadas, comparadas y manipuladas de otras formas. Se ha observado como conveniente en ciertos casos, principalmente por razones de utilización común, hacer referencia a estas señales como bits, valores, elementos, símbolos, caracteres, términos, números o similares. Se debe comprender, no obstante, que todos estos términos y otros similares se tienen que asociar con las cantidades físicas apropiadas y son meramente etiquetas de conveniencia aplicadas a estas cantidades. Si no se indica de otro modo, tal como queda evidente de las explicaciones que siguen, se apreciará que en todas las explicaciones los términos tales como "proceso" , "cálculo" , "proceso de ordenador" , "determinación" o similares se refieren a la acción y/o proceso de un ordenador o de un sistema de ordenador, o dispositivo de cálculo electrónico similar, que manipula y/o transforma datos representados en forma de cantidades físicas, tales como datos electrónicos, dentro de los registros del sistema del ordenador y/o de sus memorias en otros datos representados de manera similar y cantidades físicas dentro de las memorias del sistema del ordenador, registros u otros dispositivos de almacenamiento de información, de transmisión o de visualización.
Algunas realizaciones de la invención pueden ser implementadas , por ejemplo, utilizando un medio legible a máquina o un artículo que pueda almacenar una instrucción o un juego de instrucciones que, si se ejecutan por la máquina, provocan que ésta lleve a cabo un método y/o operaciones de acuerdo con realizaciones de la invención. Esta máquina puede incluir, por ejemplo, cualquier plataforma de proceso adecuada, plataforma de proceso por ordenador, dispositivo de proceso por ordenador, dispositivo de proceso, sistema de proceso por ordenador, sistema de proceso, ordenador, procesador o similar, y se puede implementar realizando cualquier combinación adecuada de hardware y/o de software .
El medio o artículo que es legible a máquina puede incluir, por ejemplo, cualquier tipo adecuado de unidad de memoria, estructura de memoria, artículo de memoria, medio de memoria, dispositivo de almacenamiento, artículo de almacenamiento, medio de almacenamiento y/o unidad de almacenamiento, por ejemplo, memoria, medios extraíbles o no extraíbles, medios que pueden ser borrados o no, medios que se pueden escribir o reescribir, medios digitales o analógicos, discos duros, discos blandos, discos compactos de memoria de lectura solamente (CD-ROM) , discos compactos gravables (CD-R) , discos compactos que se pueden reescribir
(CD-RW), discos ópticos, soportes magnéticos, varios tipos de discos digitales versátiles (DVD), cinta magnéticas, cásete o similares.
Las instrucciones pueden comprender cualquier tipo adecuado de código, por ejemplo, código fuente, código resumido, código interpretado, código ejecutable, código estático, código dinámico o similares, y se pueden implementar utilizando cualquier lenguaje adecuado de alto nivel, bajo nivel, orientado al objeto, visual, lenguaje de programación resumido y/o interpretado, por ejemplo, C, C++, Java, BASIC, Pascal, Fortran, Cobol, lenguaje de ensamblado, código de máquina o similares.
Las realizaciones de la invención pueden incluir aparatos para llevar a cabo las operaciones indicadas . Estos aparatos pueden estar específicamente construidos para los objetivos deseados, o pueden incluir un ordenador de tipo general activado selectivamente o reconfigurado por un programa de ordenador almacenado en el ordenador. Este programa de ordenador puede ser almacenado en un medio de almacenamiento legible por el ordenador, por ejemplo, sin que ello sirva de limitación, cualquier tipo de disco incluyendo discos blandos, discos ópticos, CD-ROM, discos magnético ópticos, memoria de lectura solamente (ROM), memorias de acceso al azar (RAM) , memorias de lectura solamente programables eléctricamente (EPROM) , memorias de lectura solamente borrables y programables eléctricamente (EEPROM), tarjetas magnéticas u ópticas, o cualquier otro tipo de soporte adecuado para almacenar instrucciones electrónicas, y capaz de ser acoplado al bus de un sistema de ordenador.
Los procesos y visualizaciones que se presentan en esta descripción no están relacionados de manera intrínseca a ningún ordenador específico u otro aparato. Se pueden utilizar otros varios sistemas de utilización general con programas de acuerdo con lo que se da a conocer en esta descripción, o se puede considerar conveniente construir un aparato más especializado para llevar a cabo el método deseado. La estructura deseada para una serie de estos sistemas quedará evidente de la descripción siguiente. Además, no se describen realizaciones de la invención haciendo referencia a ningún lenguaje de programación específico. Se observará que se puede utilizar una amplia variedad de lenguajes de programación para implementar la materia que se da a conocer en la invención de acuerdo con su descripción.
En la siguiente descripción, se presentan diferentes figuras, esquemas, diagramas de flujo, modelos y descripciones como medios distintos para trasladar de manera efectiva las bases de la invención y para ilustrar diferentes realizaciones de la misma que se proponen en la presente solicitud de patente. Se comprenderá por los técnicos en la materia que todo ello tiene carácter ilustrativo, y que no se debe considerar como limitativo de la invención.
Las realizaciones de la presente invención dan a conocer una configuración de memoria de múltiples versiones que es capaz de conservar valores múltiples por tarea o grupo de instrucciones ("thread") especulativo para la misma localización de memoria, para soportar de esta manera tanto precálculos o precomputación "viva" ("live-in") y realización de un bloque de una tarea o conjunto de instrucciones especulativas. Además, realizaciones de la invención proporcionan la validación de valores de entrada que pueden ser procesados por ordenador y utilizados en la ejecución de tarea o conjunto de instrucciones especulativo .
La figura 1 es un diagrama de bloques ilustrativo de un aparato (100) adaptado para ejecutar un código de programa de ordenador por multiconj untos de instrucciones de tipo especulativo con precálculo vivo, de acuerdo con realizaciones ilustrativas de la invención. El aparato
(100) puede comprender, por ejemplo, un procesador (104) que puede ser impletnentado en un dispositivo semiconductor, conectado operativamente a una configuración de memoria, por ejemplo, una jerarquía de memoria "off-chip" (106), con intermedio de un bus de interconexión (108) . El procesador
(104) puede comprender una o varias unidades de tareas o conjuntos de instrucciones, por ejemplo, N unidades incluyendo las unidades de conjuntos de instrucciones (112) y (114) para realizar una o varias tareas. Una unidad de tarea o conjunto de instrucciones puede incluir memorias on-chip, por ejemplo, en forma de antememorias ("caches") y/o tampones, y otro hardware deseable. Las unidades (112) y (114) pueden ser conectadas operativamente a una unidad lógica de control de versión (VCL) (120) con intermedio de un bus de interconexión (110) . La unidad VCL (120) puede controlar la interacción de lectura y escritura entre unidades de tarea, por ejemplo, las unidades (112) y (114) .
Una lista no exhaustiva de ejemplos para el aparato (100) puede comprender un ordenador personal de sobremesa, una estación de trabajo, un ordenador servidor, un ordenador "laptop" , un ordenador de agenda, un ordenador manual, un ordenador asistente digital personal (PDA) , teléfono móvil, consola de juegos y oimilares.
Una lista no exhaustiva de ejemplos para el procesador (104) puede comprender una unidad central de proceso (CPU) , un procesador de señales digitales (DSP) , un ordenador con juego de instrucciones reducido (RISC), un ordenador con juego de instrucciones complejo (CISC) y similares. El procesador (104) puede formar parte también de un circuito integrado específico de una aplicación (ASIC) , o puede formar parte de un producto estándar específico de una aplicación (ASSP) .
El procesador (104) puede llevar incorporado hardware y tecnologías, por ejemplo, tecnologías de "hyper- threading" (Intel®), y puede soportar "paralelismo a nivel de thread" en el proceso simultáneo de varios conjuntos de instrucciones. Cada unidad thread, por ejemplo, la unidad
(112) o (114), del procesador (104), puede ser considerada por lo tanto como un "procesador virtual" , o núcleo, tal como es conocido en la técnica, y cada una de las unidades (112) y (114) puede procesar conjuntos de instrucciones
("threads") separadamente.
Una lista no exhaustiva de ejemplos de memoria off- chip (106) puede incluir dispositivos semiconductores del tipo siguiente o cualquier combinación de los mismos, tal como dispositivos de memoria de acceso al azar síncrona de tipo dinámico (SDRAM) , dispositivos de memoria de acceso al azar de tipo dinámico RAMBUS (RDRAM) , estructuras de memoria de datos dobles (DDR) , dispositivos de memoria de acceso al azar de tipo estático (SRAM) , estructuras de memoria flash, dispositivos de memoria de lectura solamente de tipo programable legible eléctricamente (EEPROM) , dispositivo de memoria de acceso al azar no volátil
(NVRAM) , memoria extraíble de bus serie universal (USB) y similares; dispositivos ópticos, tales como memorias de disco compacto de lectura solamente (CD-ROM) y similares; así como dispositivos magnéticos, tales como discos duros, discos blandos, cinta magnética y similares. La memoria off-chip (106) puede estar dispuesta de modo fijo dentro del aparato (100) o de forma desmontable.
La figura 2 es un diagrama de bloques que muestra una unidad de tratamiento de tareas o conjuntos de instrucciones (200) que tiene una configuración de memoria (201) y una unidad de proceso (202) . Para los objetivos del ejemplo, la figura 2 muestra que la unidad de proceso (202) de la unidad de tratamiento de conjunto de instrucciones
(200) puede incluir una antememoria de instrucciones (240), que puede ejecutar un conjunto de instrucciones (241) . La figura 2 muestra además una unidad de tratamiento de tareas o conjuntos de instrucciones (250) para realizar un conjunto de instrucciones (251) . A los efectos de la explicación del ejemplo específico en la figura 2, se supone que el conjunto de instrucciones (251) ha sido generado dinámicamente por el conjunto de instrucciones (241) . La figura 2 muestra también una unidad tradicional
(260) para el proceso de conjuntos de instrucciones para ejecutar una tarea o conjunto de instrucciones (261) .
También en este caso, a efectos de la explicación, la figura 2 muestra un ejemplo que supone que el conjunto de instrucciones (261) ha generado dinámicamente el conjunto de instrucciones (241) de acuerdo, como mínimo, con una realización de la invención. La configuración de memoria
(201) puede ser un dispositivo de memoria capaz de soportar versiones múltiples, y puede incluir una serie de estructuras de memoria, por ejemplo, una estructura de memoria (210) que incluye uno o más "tampones antiguos", por ejemplo, los tampones antiguos (212) y (214) . La configuración de memoria (201) puede incluir además un "tampón de segmento" (220) y una antememoria de datos "nivel 1" Ll. Los términos y detalles de "tampón antiguo", "tampón del segmento" y "antememoria de datos L-I" se describen en las secciones siguientes. Si bien la figura 2 muestra tres unidades de tareas, se apreciará por los técnicos en la materia que las realizaciones de la invención se pueden implementar con más de tres unidades de tareas o menos de tres unidades de tareas, de acuerdo con las exigencias del sistema específico. Además, se apreciará que la unidad de tarea según las realizaciones de la invención puede ejecutar tareas especulativas así como tareas no especulativas.
Una estructura de memoria, por ejemplo, el tampón de segmento (220) o la antememoria de datos L-I (230), pueden tener múltiples entradas o líneas. El término "línea" o "entrada" en esta descripción puede hacer referencia a la granularidad de la unidad de memoria controlada por un procesador o unidad de tarea, y puede comprender varias localizaciones de memoria y valores de datos.
La tarea o conjunto de instrucciones (251) puede tener el segmento de precálculo (252) y un cuerpo (254) de la tarea. La tarea (261) puede tener un segmento de precálculo
(262) y un cuerpo (264) de la tarea. Las unidades de tarea
(250) y (260) , que ejecutan las tareas (251) y (261) , pueden tener configuraciones de memoria similares a la unidad de tarea (200) y por lo tanto sus detalles no se han mostrado con el objetivo de que la ilustración sea más simple. La tarea (241), ejecutada por la unidad de proceso
(202) de la unidad de tarea (200), puede tener un segmento de precálculo (242) y un cuerpo (244) de la tarea. La tarea
(241) puede ser designada como tarea local con respecto a la unidad de tarea (200) .
La tarea (241) puede generar dinámicamente la tarea (251) , y por lo tanto la tarea (241) puede ser una "tarea matriz" de la tarea (251) , y la tarea (251) puede ser una
"tarea filial" de la tarea (241) . Por otra parte, la tarea
(241) puede ser generada dinámicamente por la tarea (261) y por lo tanto la tarea (261) puede 3er una tarea matriz de la tarea (241) , y dicha tarea (241) puede ser una tarea filial de la tarea (261) . El segmento de precálculo (252) de la tarea especulativa (251) puede leer valores de memoria generados por su tarea generada dinámicamente (241) en el momento en el que la tarea especulativa (251) ha sido generada dinámicamente. Estos valores de memoria pueden ser leídos por la tarea (251) a partir, por ejemplo, de la antememoria (230) de datos Ll de la unidad de tarea (200) . De acuerdo, como mínimo, con una realización de la invención, las operaciones de "almacenamiento" llevadas a cabo por la tarea matriz (241) para reservar valores actualizados de la antememoria de datos Ll, después de la creación de la tarea filial (251) , se pueden hacer "invisibles" para el segmento de precálculo (252) de la tarea filial (251) por la configuración de memoria (201) . En otras palabras, los valores de memoria en el momento en el que la tarea filial (251) fue generada dinámicamente se pueden conservar por la configuración de memoria (201) . De acuerdo, como mínimo, con una realización de la invención, las operaciones de almacenamiento llevadas a cabo por la tarea matriz (241) se pueden poner a disposición del cuerpo
(254) de la tarea de la tarea filial (251) de manera que los valores actualizados de la antememoria de datos Ll
(230) pueden ser utilizados en la ejecución del cuerpo de tarea (254) de la tarea filial (251) . El término "tampón antiguo" , en esta descripción, se puede referir a una estructura de memoria adaptada para almacenar valores de otras memorias, por ejemplo, la antememoria de datos Ll de una unidad de memoria cuando una tarea ejecutada por la unidad de tarea genere dinámicamente una o varias tareas especulativas. Por ejemplo, cuando la tarea especulativa (251) es generada dinámicamente, el tampón antiguo (212) puede ser destinado a la tarea generada (251) en la unidad de tarea (200) de la tarea de generación dinámica (241) . De acuerdo con realizaciones ilustrativas de la invención, los valores almacenados en el tampón antiguo (212) de la unidad de tareas (200) pueden ser facilitados al segmento de precálculo (252) de la tarea (251) para el cálculo de valores iniciales vivos hacia el cuerpo (254) de la tarea. La unidad de tarea (200) puede tener tantos tampones antiguos como número de tareas filiales generadas dinámicamente por la unidad de tarea (200) .
Una unidad de tarea puede llevar a cabo operaciones de almacenamiento en sus memorias, por ejemplo, antememoria de datos Ll, durante la ejecución de una tarea. Por ejemplo, antes de escribir valores nuevos en la localización de la antememoria de datos Ll (230), la unidad de tarea (200) puede almacenar valores existentes en la localización de la antememoria de datos Ll (230) a la estructura de memoria
(210) de tampones antiguos que han sido asignados a la tarea filial generada dinámicamente (251) y otras tareas filiales. Si ya se han almacenado valores de la localización de la antememoria de datos Ll (230) en la estructura de memoria (210) de tampones antiguos, no se necesita entonces soporte duplicado y los valores de esta antememoria Ll pueden ser descartados. En este caso, se pueden sobrescribir nuevos valores en la misma localización. El término "tampón de segmento" , en la presente invención, puede hacer referencia a una estructura de memoria adaptada para el almacenamiento de valores iniciales vivos calculados por pχ-ecálculo de una tarea especulativa. Cuando una tarea especulativa es generada dinámicamente, la tarea generada dinámicamente puede ser asignada, en una unidad de tarea que ejecuta la tarea especulativa generada dinámicamente, con un tampón de segmento vacío. Por ejemplo, la tarea (241) puede ser una tarea especulativa y cuando es generada dinámicamente por la tarea (261) , la unidad de tarea (200) que ejecuta la tarea (241) puede haber asignado el tampón de segmento
(220) a la tarea (241) . El tampón de segmento (220) puede incluir múltiples entradas. Una entrada puede incluir, por ejemplo, un bit de validación "V", por ejemplo, el bit "V" (222), y un vector de bits de lectura "Rmask" , por ejemplo, los bits "Rmask" (224) . Los bits "Rmask" (224) pueden contener tantos bits como número de unidades de tarea existen en un procesador, por ejemplo, el procesador (104) (figura 1) . Las funciones del bit "V" y de los bits "Rmask" se describen a continuación.
De acuerdo con realizaciones ilustrativas de la invención, el precálculo puede escribir valores en líneas del tampón de segmento de una unidad de tarea. Por ejemplo, cuando se escribe una nueva línea en el tampón de segmento (220) durante la ejecución del segmento de precálculo (242) de la tarea (241) , el bit "V" (222) puede ser dispuesto para indicar que la línea es válida. Durante la ejecución del cuerpo (244) de la tarea correspondiente a la tarea (241) u otras tareas más especulativas, se pueden leer valores de las entradas de memoria del tampón de segmento (220) . Si la lectura es realizada por la tarea (241) , local con respecto a la unidad de tarea (200), el bit "V" (222) puede ser repuesto para invalidar la línea que ha sido leída que puede ser entonces copiada en la antememoria de datos Ll (230) . Si la lectura realizada por una tarea posterior, distinta y más especulativa, el bit "V" (222) puede no ser repuesto, es decir, se puede mantener en su disposición inicial, y la línea se mantiene válida. En ambos casos, el bit correspondiente leído en los bits "Rmask" (224) es utilizado para indicar cuál es la tarea que ha leído la línea.
Antes de que una tarea especulativa pase a ser una tarea no especulativa, las entradas en el tampón de segmento de la tarea se pueden validar verificando si el cuerpo de la tarea ha sido ejecutado con valores correctos de entrada o si puede haber ocurrido un fallo de especulación durante la ejecución. Esta validación puede ser realizada del modo siguiente. Las entradas del tampón de segmento que tienen dispuestos alguno de sus bits "Rmask" pueden ser enviadas a las tareas no especulativas previas para validar sus valores. En situaciones en las que ha tenido lugar un fallo de especulación, las tareas especulativas posteriores, que pueden haber referenciado las entradas del tampón de segmento de la tarea y todos sus sucesores, se pueden anular. Después de que la tarea especulativa pasa a ser no especulativa, es decir, comprometida, los valores almacenados en el tampón de segmento se pueden anular puesto que son potencialmente erróneos. Todas las líneas de antememorias de datos Ll local son grabadas .
La antememoria de datos Ll (230) puede incluir múltiples "líneas" de memoria" . Una línea de antememoria de datos Ll (230) puede incluir un conjunto de bits de situación que incluye un "bit antiguo" (232) . De acuerdo con realizaciones ilustrativas de la invención, la tarea (241) que se realiza en la unidad de tarea (200) puede llevar a cabo una carga en una línea de la antememoria de datos Ll (230) durante el precálculo. Cuando el valor cargado procede de un tampón antiguo de la tarea matriz (261) asignada para la tarea (241) o de las antememorias de datos Ll o tampones de segmento de otras tareas remotas que son menos especulativas que la tarea matriz (261) , un bit antiguo de la línea, por ejemplo, bit antiguo (232), puede ser dispuesto para indicar que la línea puede contener potencialmente valores antiguos y que se puede descartar a la salida del segmento de precálculo. De acuerdo con las realizaciones ilustrativas de la invención, los bits antiguos, por ejemplo, el bit antiguo (232), puede ser utilizado para impedir que una tarea más especulativa lea valores antiguos de tareas menos especulativas durante la ejecución de un segmento de precálculo de la tarea más especulativa. Cuando termina el segmento de precálculo, todas las entradas de antememoria Ll con el bit antiguo se invalidan para impedir que valores en las líneas de antememoria, que son potencialmente antiguos, sean leídos por esta tarea y otras tareas más especulativas, tal como se describe en detalle más adelante .
Cuando una tarea no especulativa termina su ejecución, puede ser posible que alguna de las tareas derivadas o filiales generadas dinámicamente por la tarea no especulativa estén todavía realizando sus respectivos segmentos de precálculo. Por lo tanto, de acuerdo con realizaciones ilustrativas de la invención, los tampones antiguos de la tarea no especulativa no pueden ser liberados hasta que estas tareas derivadas o filiales terminan sus segmentos de precálculo. Cuando una tarea especulativa pasa a ser una tarea no especulativa, ésta puede enviar una solicitud a su tarea matriz para anular la asignación de su correspondiente tampón antiguo, tal como se describe en detalle más adelante. Cuando se ha completado la ejecución de la tarea y ésta se ha agravado, la unidad de tarea que ejecuta la tarea gravada puede pasar a reposo y se puede asignar para realizar una nueva tarea. Si bien la invención no queda limitada en este respecto, el número de unidades de tarea en un procesador, por ejemplo, el procesador (104) de la figura 1, puede ser fijo.
La figura 3 es un diagrama de flujo esquemático de un método de generación dinámica de una tarea de acuerdo con una realización ilustrativa de la presente invención. Durante la ejecución de la tarea, una unidad de tarea puede dividir la tarea que está ejecutando o puede generar dinámicamente una o más tareas especulativas para proceso en paralelo. Cuando una unidad de tarea inicia la generación dinámica, puede determinar, en primer lugar, en el bloque (312) , si existe un tampón antiguo libre a disposición para la tarea a generar dinámicamente. Si no hay tampones antiguos libres a disposición, la generación dinámica puede ser abortada, terminando el proceso. Si se encuentran a disposición uno o varios tampones antiguos libres, uno de los tampones antiguos puede ser asignado en el bloque (314) . Entonces una tarea, es decir, una tarea derivada o filial, puede ser generada dinámicamente en el bloque (316) y atribuida al tampón antiguo asignado. El proceso de generación dinámica puede quedar entonces terminado.
La figura 4 es un diagrama esquemático de flujo de un método de realización del segmento de precálculo de una tarea especulativa, de acuerdo con realizaciones ilustrativas de la invención. Cuando se generan dinámicamente una o varias tareas especulativas, se pueden realizar segmentos de precálculo de las tareas en diferentes unidades de tarea simultáneamente para el cálculo vivo de valores de entrada o iniciales a sus respectivos cuerpos de tareas. Cuando una unidad de tarea empieza a ejecutar el segmento de precálculo de una tarea especulativa, puede leer una instrucción, en el bloque (412), desde una antememoria de instrucción local o alguna jerarquía de memoria externa. En el bloque (414) , si la instrucción es una instrucción de acceso a memoria, tal como una carga de un segmento o instrucción de almacenamiento, la unidad de tarea puede ejecutar la carga del segmento o almacenar la instrucción, en el bloque (416) , en un proceso que es definido en la figura 6 (para instrucciones de carga) o bien en la figura 7 (para instrucción de almacenamiento) tal como se indica más adelante. Si la instrucción no es una instrucción de acceso a memoria, se puede ejecutar de manera regular en el bloque (417) . En el bloque (418), se puede determinar si la tarea especulativa en ejecución ha recibido, por ejemplo, instrucciones para su eliminación por una instrucción recibida. Si la tarea se tiene que mantener, la unidad de tarea puede pasar a determinar, en el bloque (420), si se ha alcanzado el final del segmento de precálculo. Si hay- más instrucciones de precálculo a ejecutar, la unidad de tarea puede volver el proceso de ejecución nuevamente al bloque (412) para leer la instrucción siguiente, y se puede repetir el proceso descrito anteriormente. Si éste es el _ o í -
final del segmento de precálculo, la unidad de tarea puede pasar al bloque (422) para invalidar líneas de la antememoria de datos local L-I, cuyos bits antiguos han sido dispuestos durante la ejecución de la carga de segmento o puede almacenar instrucciones (figura 6 ó 7) . En el bloque (430) , la unidad de tarea puede enviar una petición a una unidad de tarea que ha generado dinámicamente la tarea especulativa bajo ejecución para desasignar el tampón antiguo asignado a la tarea especulativa, que acaba de terminar su segmento de precálculo .
En el bloque (418) , si la tarea especulativa se ha determinado que sea eliminada, la unidad de tarea que ejecuta la tarea especulativa puede pasa al bloque (424) a invalidar líneas de la antememoria de datos local L-I que no están comprometidas. La unidad de tarea puede pasar entonces al bloque (426) para vaciar, por ejemplo, borrar, el tampón del segmento de la unidad de tarea, y al bloque
(428) para eliminar, por ejemplo, borrar, la tarea. La unidad de tarea puede proceder además al bloque (430) para enviar una petición a la unidad de tarea que ha generado dinámicamente la tarea especulativa para desasignar el tampón antiguo asignado a la tarea especulativa, que acaba de ser eliminada. La figura 5 es un diagrama esquemático de flujo de un método de ejecución del cuerpo del conjunto de instrucciones de un conjunto de instrucciones especulativas, de acuerdo con las realizaciones ilustrativas de la presente invención. Después del precálculo "vivo" ("live-in") de un conjunto de instrucciones especulativas, una unidad de tareas puede comenzar la ejecución de instrucciones del cuerpo de dicho conjunto de instrucciones. La unidad de tareas puede leer una instrucción, en el bloque (512), de una antememoria de instrucción local o algún tipo de jerarquía de memoria externa. En el bloque (514), si la instrucción es una instrucción de acceso a memoria, tal como una carga de conjunto de instrucciones o instrucción de almacenamiento, dicha unidad de tareas puede ejecutar dicha carga del conjunto de instrucciones o instrucción de almacenamiento, en el bloque (516) , en un procedimiento que queda definido en la figura 8 (para la instrucción de carga) o la figura 9 (para la instrucción de almacenamiento) más adelante. Si la instrucción no es una instrucción de acceso a memoria, puede ser ejecutada de manera regular en el bloque (517) .
En el bloque (518), se comprueba si el conjunto de instrucciones especulativas debe ser eliminado o silenciado. Si el conjunto de instrucciones no debe ser eliminado, la unidad de tareas puede proceder a determinar, en el bloque (520) , si se ha alcanzado el final del cuerpo del conjunto de instrucciones. Si hay más instrucciones para ejecutar en el cuerpo del conjunto de instrucciones, la unidad de tareas puede continuar la lectura de la siguiente instrucción devolviendo el proceso al bloque (512) , y el procedimiento descrito anteriormente puede ser repetido. Si se ha alcanzado el final del cuerpo del conjunto de instrucciones, la unidad de tareas puede proceder al bloque (522) para validar las entradas de lectura, en el tampón del segmento del conjunto de instrucciones, cuyos bits de lectura han sido determinados durante la ejecución de la carga del conjunto de instrucciones o de las instrucciones de almacenamiento (figura 8 ó 9) . Basándose en la validación de las entradas de lectura, la ejecución del cuerpo del conjunto de instrucciones es considerada como válida y por lo tanto llevada a cabo, o como inválida y por lo tanto eliminada en el bloque (524) . La unidad de tareas puede proceder entonces al bloque (532) para eliminar, por ejemplo limpiar, las entradas en el tampón del segmento de la unidad de tareas .
Un conjunto de instrucciones puede ser suprimido o silenciado cuando una señal de supresión es enviada por la unidad VCL (120) en situaciones en las que se detecta una especulación defectuosa, o enviada por un conjunto de instrucciones menos especulativas por otras razones. Si en el bloque (518) se determina que el conjunto de instrucciones debe ser suprimido, la unidad de tareas que está ejecutando dicho conjunto de instrucciones puede proceder, en el bloque (526) , a invalidar líneas no ejecutadas en la antememoria de datos local Ll, en el bloque (528) , a desasignar tampones antiguos de la unidad de tareas, y entonces, en el bloque (530) , suprimir el conjunto de instrucciones y terminar la ejecución. La unidad de tareas puede entonces proceder al bloque (532) para limpiar las entradas en el tampón del segmento. La figura 6 es un diagrama esquemático de flujo de un método de ejecución de una instrucción de carga en un segmento de precálculo de acuerdo con las realizaciones ilustrativas de la presente invención. Cuando una unidad de tareas lleva a cabo una instrucción de carga en un segmento de precálculo, puede acceder a la antememoria de datos local Ll y al tampón del segmento de la unidad de tareas en el bloque (612) . En el bloque (614) , si se determina que la línea de memoria solicitada está disponible en la antememoria de datos local Ll o en el tampón del segmento, es decir, la línea es encontrada de forma local, la instrucción de carga está terminada. De otro modo, la unidad de tareas puede proceder al bloque (616) . En el bloque (616), la unidad de tareas puede emitir un pedido de lectura de bus dentro del segmento para acceder a una unidad de tareas del conjunto de tarea matriz mediante un bus de interconexión "on-chip" (110) (figura 1) . El pedido dentro del segmento puede estar acompañado por una señal que indica que el conjunto de instrucciones que realizó el pedido, un conjunto de instrucciones filial, está en el modo de segmento de precálculo y por lo tanto dicho conjunto de instrucciones matriz puede devolver una línea de un tampón antiguo asignado para dicho conjunto de instrucciones filial y no desde su antememoria de datos Ll. El tampón antiguo asignado a la unidad de tareas matriz puede ser accedido en el bloque (618) .
La unidad de tareas del conjunto de instrucciones matriz puede proporcionar una línea de su tampón antiguo asignado en el bloque (620) . Dicha línea puede ser copiada a la antememoria de datos Ll de la unidad de tareas del conjunto de instrucciones filial en el bloque (621) . El bit antiguo de la línea en la antememoria de datos local Ll puede ser determinado, en el bloque (630) , para indicar que los valores podrían ser antiguos dado que son copiados de la unidad de tareas del conjunto de instrucciones matriz. Si en el bloque (620) la unidad de tareas del conjunto de instrucciones matriz no proporciona una línea desde el tampón antiguo asignado para el conjunto de instrucciones filial, por ejemplo, en una situación en la que dicho conjunto de instrucciones matriz no ha escrito la línea desde su antememoria de datos Ll al tampón antiguo, la unidad VCL (120) (figura 1) puede acceder a otras antememorias de datos Ll y tampones del segmento de conjuntos de instrucciones remotos, en el bloque (622), que son menos especulativos que el conjunto de instrucciones matriz, mediante un bus de interconexión "on-chip" (110)
(Figura 1) . La unidad VCL (120) puede tratar las instrucciones de carga como una carga ordinaria, y considerar el conjunto de instrucciones filial que solicita la línea como teniendo el miεmo orden lógico que su conjunto de instrucciones matriz.
En el bloque (624) , si se determina que la unidad VCL (120) es capaz de asignar la línea solicitada desde un conjunto de instrucciones remoto menos especulativo que el conjunto de instrucciones matriz, puede proceder a realizar la copia de la línea a la antememoria de datos Ll de la unidad de tareas en el bloque (625) . La unidad de tareas puede entonces proceder a determinar, en el bloque (628) , si la línea que ha sido copiada es una línea asignada. Si la línea es una línea asignada o comprometida, la instrucción de carga es ejecutada y terminada. Si no es una línea comprometida, el bit antiguo en la línea copiada de la antememoria de datos local Ll puede ser determinado, en el bloque (630) , para indicar que los datos en la misma podrían ser potencialmente antiguos. En el bloque (624), si se ha determinado que la unidad VCL (120) es incapaz de asignar la línea solicitada, la unidad de tareas puede acceder a una jerarquía de memoria "off-chip" (106) (figura 1) , en el bloque (626) , mediante un bus de interconexión "off-chip" (108) (figura 1) . La línea obtenida a partir de la memoria "off-chip" (106) puede ser copiada a la antememoria de datos local Ll .
La figura 7 es un diagrama esquemático de flujo de un método de ejecución de una instrucción de almacenamiento en un segmento de precálculo de acuerdo con las realizaciones ilustrativas de la presente invención. Cuando una unidad de tareas ejecuta un segmento de precálculo y lleva a cabo una instrucción de almacenamiento, los datos pueden ser almacenados en el tampón del segmento de la unidad de tareas. De acuerdo con las realizaciones ilustrativas de la presente invención, la línea que será almacenada puede ser colocada primero en el tampón del segmento y luego actualizada con los datos almacenados. Para acceder a la línea solicitada, puede llevarse a cabo un método similar al descrito con relación a la realización de una instrucción de carga (figura 6) . Cuando una unidad de tareas lleva a cabo una instrucción de almacenamiento en un segmento de precálculo, puede acceder a la antememoria de datos local Ll y al tampón del segmento de dicha unidad de tareas en el bloque (712) . En el bloque (714) , si se determina que la línea de memoria solicitada está disponible en la antememoria de datos local Ll, entonces dicha línea en la antememoría de datos Ll puede ser invalidada en el bloque (730) . La línea es copiada al tampón del segmento de la unidad de tareas y es actualizada con los datos de almacenamiento en el bloque (728) . Dichos datos son invisibles para las otras unidades de tareas siempre que el segmento de precálculo se encuentre aún en ejecución. En el bloque (714), si se determina que la línea no está disponible en la antememoria de datos local Ll o el tampón del segmento, es decir, la línea no es encontrada de forma local, la unidad de tareas puede proceder al bloque (716) .
En el bloque (716) , la unidad de tareas puede emitir un pedido de escritura de bus "dentro del segmento" para acceder a la unidad de tareas del conjunto de instrucciones matriz mediante el bus de interconexión "on-chip" (110)
(figura 1) . El pedido "dentro del segmento" puede estar acompañado por una señal que indica que el conjunto de instrucciones que ha realizado el pedido, un conjunto de instrucciones filial, está en el modo de segmento de precálculo y por lo tanto el conjunto de instrucciones matriz puede devolver una línea desde un tampón antiguo asignado al conjunto de instrucciones filial y no desde su antememoria de datos Ll. El tampón antiguo asignado a la unidad de tareas matriz puede ser accedido en el bloque (718) .
La unidad de tareas del conjunto de instrucciones matriz puede proporcionar una linee, a partir de su tampón antiguo asignado en el bloque (720) . La línea puede ser copiada al tampón del segmento de la unidad de tareas del conjunto de instrucciones filial y actualizada con los datos de almacenamiento en el bloque (728) . Estos datos son invisibles para otras unidades de tarea siempre que el segmento de precálculo aún esté en ejecución. Si en el bloque (720) la unidad de tareas del conjunto de instrucciones matriz no proporciona una línea desde el tampón antiguo asignado para el conjunto de instrucciones filial, por ejemplo, en una situación en la que el conjunto de instrucciones matriz no ha escrito la línea desde su antememoria de datos Ll en el tampón antiguo, la unidad VCL (120) (figura 1) puede acceder a otras antememorias de datos Ll y tampones del segmento de conjuntos de instrucciones remotos, en el bloque (722), que son menos especulativos que el conjunto de instrucciones matriz, mediante el bus de interconexión "on-chip" (110) (figura 1) . La unidad VCL (120) puede tratar la instrucción de almacenamiento como una memoria ordinaria, y considerando que el conjunto de instrucciones filial que solicita dicha línea tiene el mismo orden lógico que su conjunto de instrucciones matriz.
En el bloque (724) , si se determina que la unidad VCL (120) es capaz de asignar la línea solicitada desde un conjunto de instrucciones remoto menos especulativo que el conjunto de instrucciones matriz, puede proceder a copiar la línea al tampón del segmento de la unidad de tareas y actualizarla con los datos de almacenamiento en el bloque
(728) . Estos datos son invisibles para otras unidades de tareas siempre que el segmento de precálculo aún esté en ejecución. En el bloque (724), si se determina que la unidad VCL (120) es incapaz de asignar la línea solicitada, la unidad de tareas puede acceder a una jerarquía de memoria "off-chip" (106) (figura 1) , en el bloque (726) , mediante el bus de interconexión "off-chip" (108) (figura 1) . La línea obtenida a partir de la memoria "off-chip" (106) puede ser copiada al tampón del segmento del conjunto de instrucciones filial y actualizada con los datos de almacenamiento en el bloque (728) . Estos datos con invisibles para otras unidades de tarea siempre que el segmento de precálculo se encuentre aún en ejecución.
La figura 8 es un diagrama esquemático de flujo de un método de ejecución de una instrucción de carga en el cuerpo del conjunto de instrucciones de una tarea especulativa de acuerdo con las realizaciones ilustrativas de la presente invención.
Cuando una unidad de tareas que ejecuta el cuerpo del conjunto de instrucciones de una tarea especulativa lleva a cabo una instrucción de carga, puede acceder primero a las posiciones de memoria del tampón del segmento y la antememoria de datos Ll de la unidad de tareas en el bloque
(812) . En el bloque (814) , si se determina que la línea solicitada está disponible, la unidad de tareas puede proceder a determinar, en el bloque (826) , si la línea está disponible en el tampón del segmento. Si la línea está disponible a partir del tampón del segmento, entonces es copiada a la antememoria de datos Ll de la unidad de tareas en el bloque (828) . La línea que suministra los datos en el tampón del segmento es marcada como leída por el bit de lectura correspondiente en el "Rmask" y como inválida restaurando el bit de validez "V" (figura 2) . Todas las líneas en el tampón del segmento con algún bit de lectura determinado son luego validadas antes de que el conjunto de instrucciones se vuelva no especulativo. En el bloque (826), si se determina que la línea está disponible en la antememoria de datos local Ll, entonces la instrucción de carga es terminada.
En el bloque (814) , si se determina que la línea no está disponible en el tampón del segmento o la antememoria de datos Ll de la unidad de tareas, es decir, la línea no es encontrada de forma local, la unidad de tareas puede emitir un pedido de lectura de bus, en el bloque (816), a la unidad VCL (120) mediante el bus de interconexión "on- chip" (110) (figura 1) . La unidad VCL (120) puede acceder a otras antememorias de datos Ll y a los tampones del segmento de tareas o conjunto de instrucciones remoto y menos especulativo en el bloque (818) . La unidad VCL (120) puede fijar el bit antiguo en las líneas de la antememoria de datos Ll de los conjuntos de instrucciones que son más especulativos que el conjunto de instrucciones actual y aún están ejecutando segmentos de precálculo, en el bloque (820), para indicar que los datos podrían ser antiguos. En el bloque (822) , si la unidad VCL (120) puede asignar la versión correcta de la línea solicitada desde los conjuntos de instrucciones que son menos especulativos que el conjunto de instrucciones que está siendo ejecutado, podría copiar la línea a la antememoria de datos Ll de la unidad de conjunto de instrucciones en el bloque (823) . La unidad de conjunto de instrucciones puede proceder a determinar, en el bloque (830), si un tampón del segmento remoto ha proporcionado dicha línea. En caso afirmativo, entonces la línea en el tampón del segmento remoto es marcada como leída e indica qué unidad de tareas ha leído dicha línea, en el bloque (832), utilizando un bit de lectura de "Rmask" del tampón del segmento. Todas las líneas en el tampón del segmento con algún bit de lectura determinado son validadas antes de que el conjunto de instrucciones en ejecución se vuelva no especulativo. En el bloque (822) , si la unidad VCL (120) es incapaz de asignar la línea, entonces la unidad de tareas puede acceder a una jerarquía de memoria uoff-chip" (106) , en el bloque (824) , mediante un bus de interconexión (108) "off-chip" (figura 1) . Entonces, la línea obtenida s partir de la memoria "off-chip" (106) es copiada, en el bloque (824) , a la antememoria de datos local Ll de la unidad de tareas.
La figura 9 es un diagrama esquemático de flujo de un método de ejecución de una instrucción de almacenamiento en el cuerpo del conjunto de instrucciones de un conjunto de instrucciones especulativo de acuerdo con las realizaciones ilustrativas de la presente invención. Cuando una unidad de tareas que ejecuta el cuerpo de un conjunto de instrucciones de un conjunto de instrucciones especulativas lleva a cabo una instrucción de almacenamiento, una línea de memoria es solicitada puede ser colocada primero en la antememoria de datos local Ll de la unidad de tareas y luego actualizada con los datos de almacenamiento. Para acceder a la línea solicitada, puede llevarse a cabo un método similar al de una instrucción de carga (figura 8) de acuerdo con las realizaciones ilustrativas de la presente invención.
La unidad de tareas puede acceder primero a las posiciones de memoria del tampón del segmento y de la antememoria de datos Ll de dicha unidad de tareas en el bloque (912) . En el bloque (914) , en caso que se haya determinado que la línea solicitada está disponible, la unidad de tareas puede proceder a determinar, en el bloque
(926) , si la línea está disponible en el tampón del segmento. Si se encuentra disponible en el tampón del segmento, la línea que suministra los datos en el tampón del segmento es marcada como leída mediante un bit de lectura de "Rmask" y como no válido restaurando el bit de validez en el bloque (928) . En el bloque (926) , si se ha determinado que la línea no está disponible desde el tampón del segmento, entonces está disponible a partir de la antememoria de datos local Ll. En los dos casos, la línea es copiada a los tampones antiguos, en el bloque (934), que están asignadas en la unidad de tareas para salvar valores de memoria antigua para conjuntos de instrucciones filiales que son activados por la unidad de tareas y que están ejecutando tampones de precálculo. Entonces, la línea es copiada a la antememoria de datos local Ll de la unidad de tareas y actualizada con los datos de almacenamiento en el bloque (936) . En el bloque (914) , si se determina que la línea no está disponible a partir del tampón del segmento o la antememoria de datos Ll de la unidad de tareas, es decir, la línea no es encontrada de forma local, la unidad de tareas puede enviar un pedido de escritura de bus, en el bloque (916) , a la unidad VCL (120) mediante el bus de interconexión "on-chip" (110) (figura 1) . La unidad (120) puede acceder a otras antememorias de datos Ll y tampones del segmento de conjuntos de instrucciones remotos y menos especulativos en el bloque (918) . La unidad VCL (120) puede determinar además el bit antiguo de las líneas de antememoria de datos Ll de conjuntos de instrucciones que son más especulativos que el presente conjunto de instrucciones y que aún está ejecutando segmentos de precálculo, en el bloque (920), para indicar que los datos podrían ser antiguos.
En el bloque (922) , si la unidad VCL (120) es capaz de asignar la versión correcta de la línea solicitada, puede proceder a determinar, en el bloque (930) , si un tampón del segmento remoto ha proporcionado dicha línea. En caso afirmativo, entonces la línea en el tampón del segmento remoto es marcada como leída y se indica qué unidad de tareas ha leído dicha línea, en el bloque (932), utilizando un bit de lectura de "Rmask" del tampón del segmento remoto. Todas las líneas en el tampón del segmento con algún bit de lectura determinado son validadas antes de que el conjunto de instrucciones en ejecución se vuelva no especulativo. En el bloque (922), si la unidad VCL (120) es incapaz de asignar la línea, entonces la unidad de tareas puede acceder a una jerarquía de memoria "off-chip" (106) , en el bloque (924), mediante un bus de interconexión "off- chip" (108) (figura 1) . En los dos casos mencionados anteriormente, la línea es copiaαa a tampones antiguos, en el bloque (934) , que son asignados en la unidad de tareas para salvar valores de memoria antiguos para conjuntos de instrucciones filiales que son activados por la unidad de tareas y que están ejecutando tampones de precálculo. Entonces la línea es copiada a la antememoπa de datos local Ll de la unidad de tareas y actualizada con los datos de almacenamiento en el bloque (936) .
Si bien ciertas características de la presente invención han sido ilustradas y descritas en el presente documento, las personas especializadas en la técnica podrán idear numerosas modificaciones, substituciones, cambios, y equivalencias. Debe entenderse, por lo tanto, que las reivindicaciones adjuntas tienen la intención de cubrir todas dichas modificaciones y cambios que quedan dentro del espíritu de la presente invención.

Claims

a- 35 -REIVINDICACIONES
1. Aparato, que comprende: un procesador que incluye como mínimo una unidad de tareas para ejecutar un primer conjunto de instrucciones, teniendo dicha unidad de tareas un tampón antiguo asignado para almacenar valores para la ejecución de un segundo conjunto de instrucciones que ha sido activado por dicho primer conjunto de instrucciones, en el que dichos valores para la ejecución del segundo conjunto de instrucciones corresponden a los valores del primer conjunto de instrucciones en el momento de activación del segundo conjunto de instrucciones.
2. Aparato, según la reivindicación 1, en el que dicha unidad de tareas comprende de forma adicional : un tampón del segmento para almacenar valores de entrada "vivos" calculados mediante la ejecución de un segmento de precálculo de dicho primer conjunto de instrucciones basado en valores de un tercer conjunto de instrucciones que fue iniciado por el primer conjunto de instrucciones.
3. Aparato, según la reivindicación 2, en el que dichos valores del tercer conjunto de instrucciones corresponden a valores del momento en que dicho tercer conjunto de instrucciones surgió de dicho primer conjunto de instrucciones.
4. Aparato, según la reivindicación 2, en el que dicha unidad de tareas comprende de manera adicional : una antememoria de datos de nivel 1 para cargar valores de dichos primer y tercer conjuntos de instrucciones durante la ejecución de dicho segmento de precálculo del primer conjunto de instrucciones.
5. Aparato, según la reivindicación 4, en el que dicha antememoria de datos de nivel 1 incluye como mínimo un bit antiguo para identificar valores cargados desde dicho tercer conjunto de instrucciones como potencialmente antiguos durante dicha ejecución de dicho segmento de precálculo para los mencionados valores de entrada vivos, y en el que dicha unidad de tareas es capaz de eliminar dichos valores marcados después de que dicha unidad de tareas ejecuta dicho segmento de precálculo.
6. Aparato, según la reivindicación 2, en el que dicho tampón del segmento tiene como mínimo un bit de lectura para grabar una lectura de valores de dicho tampón del segmento por cualquiera de dichos primer o segundo conjuntos de instrucciones, y como mínimo un bit de validez para identificar valores válidos del tampón del segmento.
7. Aparato, según la reivindicación 2, en el que dicha unidad de tareas tiene la capacidad de: determinar si los valores de entrada vivos son válidos mediante la comparación de dichos valores de entrada vivos con valores actualizados de dicho tercer conjunto de instrucciones ; comprometer dicho primer conjunto de instrucciones, en caso que dichos valores de entrada vivos sean válidos; y eliminar dicho primer conjunto de instrucciones si dichos valores de entrada vivos resultan inválidos.
8. Aparato de la reivindicación 1, en el que dicha unidad de tareas comprende como mínimo una primera y una segunda unidad de tareas, y en el que dicha primera unidad de tareas tiene la capacidad de desasignar dicho tampón antiguo asignado para dicho segundo conjunto de instrucciones después de que dicha segunda unidad de tareas ejecute un segmento de precálculo de dicho segundo conjunto de instrucciones .
9. Aparato, según la reivindicación 1, que comprende de manera adicional : una unidad lógica de control de versión asociada de forma operativa con dichos primer y segundo conjuntos de instrucciones, y que tiene la capacidad para controlar la interacción de lectura y escritura entre dichas primera y segunda unidades de tareas .
10. Método, que comprende: ejecutar un primer conjunto de instrucciones; y almacenar valores para la ejecución de un segundo conjunto de instrucciones iniciado por dicho primer conjunto de instrucciones, cuyos valores corresponden a los valores del primer conjunto de instrucciones en el momento de inicio del segundo conjunto de instrucciones .
11. Método, según la reivindicación 10, que comprende de manera adicional : almacenar valores de entrada vivos calculados mediante la ejecución de un segmento de precálculo de dicho primer conjunto de instrucciones basado en valores de un tercer conjunto de instrucciones iniciado por el primer conjunto de instrucciones .
12. Método, según la reivindicación 11, en el que dichos valores del tercer conjunto de instrucciones corresponden a valores del momento en que el tercer conjunto de instrucciones fue iniciado por el segundo conjunto de instrucciones.
13. Método, según la reivindicación 11, que comprende: carga de valores desde dichos primer y segundo conjuntos de instrucciones durante la ejecución de dicho segmento de precálculo y dicho primer conjunto de instrucciones .
14. Método, según la reivindicación 13, que comprende: marcado o identificación de valores cargados desde dicho tercer conjunto de instrucciones como potencialmente antiguos durante dicha ejecución de dicho segmento de precálculo para dichos valores de entrada vivos; y eliminación de dichos valores marcados después de la ejecución de dicho segmento de precálculo.
15. Método, de acuerdo con la reivindicación 11, que comprende : grabación de una lectura de dichos valores de entrada vivos mediante cualquiera de dichos primer o segundo conjuntos de instrucciones; y marcado o identificación de dichos valores de entrada vivos que son válidos.
16. Método, de la reivindicación 11, que comprende: determinar la validez de dichos valores de entrada vivos mediante la comparación de dichos valores de entrada vivos con valores actualizados de dicho tercer conjunto de instrucciones ; asignar dicho primer conjunto de instrucciones en el caso que dichos valores de entrada vivos sean válidos; y eliminar dicho primer conjunto de instrucciones en caso que dichos valores de entrada vivos sean inválidos.
17. Método, según la reivindicación 10, que comprende de manera adicional : desasignar una memoria asignada para dicho segundo conjunto de instrucciones después de la ejecución de un segmento de precálculo de dicho segundo conjunto de instrucciones .
18. Sistema, que comprende: un procesador que tiene como mínimo una unidad de tareas y una unidad lógica de control de versión para controlar la interacción de lectura y escritura entre dichas unidades de tareas; y una memoria uoff-chip" conectada de manera operativa con dicho procesador, en el que como mínimo una de dichas unidades de tareas de dicho procesador tiene la capacidad para ejecutar un primer conjunto de instrucciones, teniendo dicha unidad de tareas un tampón antiguo asignado para almacenar valores para la ejecución de un segundo conjunto de instrucciones que ha sido iniciado por el mencionado primer conjunto de instrucciones, en el que dichos valores para ejecución del segundo conjunto de instrucciones corresponden a los valores del primer conjunto de instrucciones en el momento de iniciación del segundo conjunto de instrucciones.
19. Sistema, según la reivindicación 18, en el que dicha unidad de tareas comprende de forma adicional : un tampón del segmento para el almacenamiento de valores de entrada vivos calculados mediante la ejecución de un segmento de precálculo de dicho primer conjunto de instrucciones basado en valores de un tercer conjunto de instrucciones iniciado por el primer conjunto de instrucciones .
20. Sistema, según la reivindicación 19, en el que dichos valores del tercer conjunto de instrucciones corresponden a los valores en el momento que el tercer conjunto de instrucciones fue iniciado por el primer conjunto de instrucciones.
21. Sistema, según la reivindicación 19, en el que dicha unidad de tareas comprende de manera adicional : una antememoria de datos de nivel 1 para cargar valores de dichos primer y tercer conjuntos de instrucciones durante la ejecución de dicho segmento de precálculo del primer conjunto de instrucciones.
22. Sistema, según la reivindicación 21, en el que dicha antememoria de datos de nivel 1 incluye como mínimo un bit antiguo para marcar los valores cargados desde dicho tercer conjunto de instrucciones como potencialmente antiguos durante dicha ejecución de dicho segmento de precálculo para dichos valores de entrada vivos, y en el que dicha unidad de tareas tiene la capacidad para eliminar dichos valores marcados después de que dicha unidad de tareas ejecuta dicho segmento de precálculo.
23. Sistema, según la reivindicación 19, en el que dicho tampón del segmento tiene como mínimo un bit de lectura para grabar una lectura de valores de dicho tampón del segmento por alguno de dichos primer o segundo conjuntos de instrucciones, y como mínimo un bit de validez para identificar valores válidos del tampón del segmento.
24. Sistema, según la reivindicación 19, en el que dicha unidad de tareas tiene la capacidad para: determinar la validez de dichos valores de entrada vivos mediante la comparación de dichos valores de entrada vivos con valores actualizados de dicho tercer conjunto de instrucciones ; comprometer a dicho primer conjunto de instrucciones si los mencionados valores de entrada vivos son válidos; y eliminar dicho primer conjunto de instrucciones si los valores de entrada vivos son inválidos.
25. Medio legible por una máquina que tiene almacenado un conjunto de instrucciones que, cuando son ejecutadas por una máquina, resultan en: ejecución de un primer conjunto de instrucciones; y almacenamiento de valores para la ejecución de un segundo conjunto de instrucciones que fue iniciado por dicho primer conjunto de instrucciones, cuyos valores corresponden a los valores de dicho primer conjunto de instrucciones en el momento del inicio del segundo conjunto de instrucciones .
26. Medio legible por una máquina, según la reivindicación 25, en el que las instrucciones resultan en: almacenamiento de valores de entrada vivos calculados por la ejecución de un segmento de precálculo de dicho primer conjunto de instrucciones basado en valores de un tercer conjunto de instrucciones originado por el primer conjunto de instrucciones.
27. Medio legible por una máquina, según la reivindicación 25, en el que dichos valores del tercer conjunto de instrucciones corresponden a los valores en el momento en que el tercer conjunto de instrucciones fue originado por el segundo conjunto de instrucciones.
28. Medio legible por una máquina, según la reivindicación 25, en el que las instrucciones resultan en: carga de valores desde dicho primer y tercer conjuntos de instrucciones durante la ejecución de dicho segmento de precálculo de dicho primer conjunto de instrucciones.
29. Medio legible por una máquina, según la reivindicación 25, en el que las instrucciones resultan en: marcado o identificación de valores cargados desde dicho tercer conjunto de instrucciones como potencialmente antiguos durante dicha ejecución de dicho segmento de precálculo para dichos valores de entrada vivos; y eliminación de dichos valores marcados después de la ejecución de dicho segmento de precálculo.
30. Medio legible por una máquina, según la reivindicación 25, en el que las instrucciones resultan en: grabación de una lectura de dichos valores de entrada vivos por alguno de dichos primer y segundo conjuntos de instrucciones; y marcado de los valores de dichos valores de entrada vivos que son válidos.
PCT/ES2005/000279 2005-05-19 2005-05-19 Aparato, sistema y método de dispositivo de memoria para conjuntos múltiples de instrucciones de tipo especulativo WO2006122990A2 (es)

Priority Applications (2)

Application Number Priority Date Filing Date Title
PCT/ES2005/000279 WO2006122990A2 (es) 2005-05-19 2005-05-19 Aparato, sistema y método de dispositivo de memoria para conjuntos múltiples de instrucciones de tipo especulativo
US10/544,874 US20080134196A1 (en) 2005-05-19 2005-05-19 Apparatus, System, and Method of a Memory Arrangement for Speculative Multithreading

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
PCT/ES2005/000279 WO2006122990A2 (es) 2005-05-19 2005-05-19 Aparato, sistema y método de dispositivo de memoria para conjuntos múltiples de instrucciones de tipo especulativo

Publications (2)

Publication Number Publication Date
WO2006122990A2 true WO2006122990A2 (es) 2006-11-23
WO2006122990A3 WO2006122990A3 (es) 2008-07-03

Family

ID=37431615

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/ES2005/000279 WO2006122990A2 (es) 2005-05-19 2005-05-19 Aparato, sistema y método de dispositivo de memoria para conjuntos múltiples de instrucciones de tipo especulativo

Country Status (2)

Country Link
US (1) US20080134196A1 (es)
WO (1) WO2006122990A2 (es)

Families Citing this family (13)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
DE112006003917T5 (de) * 2006-05-30 2009-06-04 Intel Corporation, Santa Clara Verfahren, Gerät und System angewendet in einem Cachespeicher-Kohärenzprotokoll
US7953878B1 (en) * 2007-10-09 2011-05-31 Netapp, Inc. Multi-threaded internet small computer system interface (iSCSI) socket layer
US8838817B1 (en) 2007-11-07 2014-09-16 Netapp, Inc. Application-controlled network packet classification
US8566833B1 (en) 2008-03-11 2013-10-22 Netapp, Inc. Combined network and application processing in a multiprocessing environment
US8707005B2 (en) * 2011-02-25 2014-04-22 Quantum Corporation Data control systems for virtual environments
KR102031606B1 (ko) 2013-07-31 2019-10-14 휴렛 팩커드 엔터프라이즈 디벨롭먼트 엘피 버저닝된 메모리 구현
US9207967B2 (en) * 2014-01-07 2015-12-08 Red Hat, Inc. Using nonspeculative operations for lock elision
US9348595B1 (en) 2014-12-22 2016-05-24 Centipede Semi Ltd. Run-time code parallelization with continuous monitoring of repetitive instruction sequences
US9135015B1 (en) 2014-12-25 2015-09-15 Centipede Semi Ltd. Run-time code parallelization with monitoring of repetitive instruction sequences during branch mis-prediction
US9208066B1 (en) 2015-03-04 2015-12-08 Centipede Semi Ltd. Run-time code parallelization with approximate monitoring of instruction sequences
US10296346B2 (en) 2015-03-31 2019-05-21 Centipede Semi Ltd. Parallelized execution of instruction sequences based on pre-monitoring
US10296350B2 (en) 2015-03-31 2019-05-21 Centipede Semi Ltd. Parallelized execution of instruction sequences
US9715390B2 (en) 2015-04-19 2017-07-25 Centipede Semi Ltd. Run-time parallelization of code execution based on an approximate register-access specification

Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20020144083A1 (en) * 2001-03-30 2002-10-03 Hong Wang Software-based speculative pre-computation and multithreading
US6574725B1 (en) * 1999-11-01 2003-06-03 Advanced Micro Devices, Inc. Method and mechanism for speculatively executing threads of instructions
US20040073906A1 (en) * 2002-10-15 2004-04-15 Sun Microsystems, Inc. Processor with speculative multithreading and hardware to support multithreading software {including global registers and busy bit memory elements}
US20040133767A1 (en) * 2002-12-24 2004-07-08 Shailender Chaudhry Performing hardware scout threading in a system that supports simultaneous multithreading
US20040154010A1 (en) * 2003-01-31 2004-08-05 Pedro Marcuello Control-quasi-independent-points guided speculative multithreading

Family Cites Families (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6507862B1 (en) * 1999-05-11 2003-01-14 Sun Microsystems, Inc. Switching method in a multi-threaded processor
US8095920B2 (en) * 2002-09-17 2012-01-10 Intel Corporation Post-pass binary adaptation for software-based speculative precomputation

Patent Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6574725B1 (en) * 1999-11-01 2003-06-03 Advanced Micro Devices, Inc. Method and mechanism for speculatively executing threads of instructions
US20020144083A1 (en) * 2001-03-30 2002-10-03 Hong Wang Software-based speculative pre-computation and multithreading
US20040073906A1 (en) * 2002-10-15 2004-04-15 Sun Microsystems, Inc. Processor with speculative multithreading and hardware to support multithreading software {including global registers and busy bit memory elements}
US20040133767A1 (en) * 2002-12-24 2004-07-08 Shailender Chaudhry Performing hardware scout threading in a system that supports simultaneous multithreading
US20040154010A1 (en) * 2003-01-31 2004-08-05 Pedro Marcuello Control-quasi-independent-points guided speculative multithreading

Also Published As

Publication number Publication date
WO2006122990A3 (es) 2008-07-03
US20080134196A1 (en) 2008-06-05

Similar Documents

Publication Publication Date Title
WO2006122990A2 (es) Aparato, sistema y método de dispositivo de memoria para conjuntos múltiples de instrucciones de tipo especulativo
JP6342970B2 (ja) トランザクショナルメモリ（ｔｍ）システムにおける読み出し及び書き込み監視属性
US20180011748A1 (en) Post-retire scheme for tracking tentative accesses during transactional execution
US8838906B2 (en) Evict on write, a management strategy for a prefetch unit and/or first level cache in a multiprocessor system with speculative execution
JP3661614B2 (ja) キャッシュメモリ制御方法及びマルチプロセッサシステム
US7809903B2 (en) Coordinating access to memory locations for hardware transactional memory transactions and software transactional memory transactions
TWI526829B (zh) 電腦系統、用於存取儲存裝置之方法及電腦可讀儲存媒體
JP4856646B2 (ja) 連続フロープロセッサパイプライン
US8255626B2 (en) Atomic commit predicated on consistency of watches
JP7007371B2 (ja) ベクトル命令のための要素間アドレス・ハザードの取扱い
US10331568B2 (en) Locking a cache line for write operations on a bus
KR20090025295A (ko) 가상 트랜잭션 메모리를 위한 글로벌 오버플로우 방법
US8954681B1 (en) Multi-stage command processing pipeline and method for shared cache access
CN109952567B (zh) 用于旁通高级dram存储器控制器的内部高速缓存的方法和装置
US8954680B2 (en) Modifying data prefetching operation based on a past prefetching attempt
US20100058344A1 (en) Accelerating a quiescence process of transactional memory
US10430186B2 (en) Speeding up transactions in non-volatile memory using hardware transactional memory
US9378148B2 (en) Adaptive hierarchical cache policy in a microprocessor
TWI670648B (zh) 使用原子序列支援寬操作的方法和裝置
KR101587362B1 (ko) 비교-및-스와핑 기반 방식을 사용하여서 데이터를 조건적으로 저장하는 방법 및 장치
US9146870B2 (en) Performance of accesses from multiple processors to a same memory location
US7640419B2 (en) Method for and a trailing store buffer for use in memory renaming
US11586462B2 (en) Memory access request for a memory protocol
US20090164729A1 (en) Sync-id for multiple concurrent sync dependencies in an out-of-order store queue
CN111522600B (zh) 一种在dsp上的异构计算框架构建方法及系统

Legal Events

Date Code Title Description
WWE Wipo information: entry into national phase

Ref document number: 10544874

Country of ref document: US

NENP Non-entry into the national phase

Ref country code: DE

WWW Wipo information: withdrawn in national office

Country of ref document: DE

NENP Non-entry into the national phase

Ref country code: RU

WWW Wipo information: withdrawn in national office

Country of ref document: RU

WWP Wipo information: published in national office

Ref document number: 10544874

Country of ref document: US

122 Ep: pct application non-entry in european phase

Ref document number: 05750630

Country of ref document: EP

Kind code of ref document: A2