WO2007138124A1 - Método aparato y sistema aplicado en un protocolo de coherencia de una memoria cache - Google Patents

Método aparato y sistema aplicado en un protocolo de coherencia de una memoria cache Download PDF

Info

Publication number
WO2007138124A1
WO2007138124A1 PCT/ES2006/070074 ES2006070074W WO2007138124A1 WO 2007138124 A1 WO2007138124 A1 WO 2007138124A1 ES 2006070074 W ES2006070074 W ES 2006070074W WO 2007138124 A1 WO2007138124 A1 WO 2007138124A1
Authority
WO
WIPO (PCT)
Prior art keywords
cache memory
speculative
thread
cache
message
Prior art date
Application number
PCT/ES2006/070074
Other languages
English (en)
French (fr)
Inventor
Carlos Madriles Gimeno
Carlos GARCIA QUIÑONES
Pedro Marcuello
Jesús SANCHEZ
Fernando Latorre
Antonio Gonzalez
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 CN2006800547341A priority Critical patent/CN101449250B/zh
Priority to US12/226,793 priority patent/US8185700B2/en
Priority to DE112006003917T priority patent/DE112006003917T5/de
Priority to PCT/ES2006/070074 priority patent/WO2007138124A1/es
Publication of WO2007138124A1 publication Critical patent/WO2007138124A1/es

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00—Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02—Addressing or allocation; Relocation
    • G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
    • G06F12/0806—Multiuser, multiprocessor or multiprocessing cache systems
    • G06F12/0815—Cache consistency protocols
    • G06F12/0831—Cache consistency protocols using a bus scheme, e.g. with bus monitoring or watching means
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F2212/00—Indexing scheme relating to accessing, addressing or allocation within memory systems or architectures
    • G06F2212/50—Control mechanisms for virtual memory, cache or TLB
    • G06F2212/507—Control mechanisms for virtual memory, cache or TLB using speculative control

Definitions

  • the embodiments of the present invention relate to processor-based systems, and more particularly to the implementation of a memory coherence protocol within one of such systems.
  • processors have incorporated increasing support for execution-level parallelism.
  • the parallelism at the level of execution exploited by the architectures is explicit or non-speculative.
  • the use of parallelism at the level of speculative execution has been proposed to further increase the benefits of multi-threaded / multi-core architectures.
  • the code is divided into pieces that are executed speculatively in parallel.
  • Transactional memory execution is a similar technique in which different threads are allowed to have speculative access and write to memory, ignoring possible data dependencies between threads.
  • the state of speculative memory is assigned atomic to the state of the architecture or discarded depending on the checks of the execution time (for example of the dependencies of the memory between threads).
  • physical equipment support in the memory subsystem is expanded with support to handle speculative data, detect data dependency between threads, and entrust or crush the speculative state.
  • a memory subsystem may be able to maintain a different speculative version per thread of the same memory location so that speculative threads of the same application can share the memory space and write in the same memory locations.
  • An expanded memory subsystem with speculation and multiversion support is called a multiversion cache (MVC).
  • FIG. 1 is a block diagram of a part of a system according to an embodiment of the present invention.
  • FIG. 2 is a flow chart of a method for effecting speculative execution in accordance with an embodiment of the present invention.
  • FIG. 3 is a flow chart of a method for performing additional speculative operations in accordance with an embodiment of the present invention.
  • FIG. 4 is a flow chart of a method for more speculative operations in accordance with an embodiment of the present invention.
  • FIG. 5 is a flow chart of a method for processing received bus messages according to an embodiment of the present invention.
  • FIG. 6 is a flow chart of a method for entrusting the results of a speculative operation in accordance with an embodiment of the present invention.
  • FIG. 7 is a flow chart of a method for crushing a speculative operation according to an embodiment of the present invention.
  • FIG. 8 is a state transition diagram illustrating the responses to events of the processor according to an embodiment of the present invention.
  • FIG. 9 is a state transition diagram illustrating the responses to bus messages according to an embodiment of the present invention.
  • FIG. 10 is a block diagram of a multiprocessor system according to an embodiment of the present invention. Detailed description
  • a multiversion cache memory protocol can be implemented in a system to allow multi-threaded speculative processing and / or transactions. In this way, improved performances can be obtained since the threads can be executed in parallel and a cache memory consistency protocol, in combination with software that handles the orders through the threads, can determine the validity of any given speculative thread.
  • a multiversion cache memory does not implant the communication of the values of the speculative memory between speculative threads.
  • the physical equipment is significantly simplified, since this avoids a centralized version control logic. Consequently, physical equipment can be minimized to implement speculative thread execution, and in addition there is no need for a centralized directory or other centralized cache memory structure.
  • a cache memory controller associated with local cache memories can receive bus traffic relative to speculative accesses and, on the basis of this information and the state of minimum speculative physical equipment in the cache memory, determine if there is a conflict to a place to which you have access.
  • the cache controller can send a signal to a software layer, for example, to an application manipulator to determine the nature of the conflict. By determining that one or more threads have to be crushed, the application manipulator can send a message on the bus to produce the crush. He The controller (or controllers) of the cache memory associated with the thread (threads) when canceled can consequently establish the status of one or more lines of cache memory associated with the thread.
  • a multiversion cache consistency protocol may be implemented based on a modified, shared, invalid (MSI) / modified, exclusive, shared, invalid (MESI) conventional protocol.
  • the protocol which can be referred to herein as a MU [E] SLI protocol, includes additional states (for example, a state L corresponding to a speculative loaded state, and a state U corresponding to an insecure state) and can operate in the Word granularity, dynamically detect memory dependencies between threads, and support a speculative version of a place in memory for each data cache. That is, the protocol can support a speculative version of a word given by thread and by data cache.
  • additional states for example, a state L corresponding to a speculative loaded state, and a state U corresponding to an insecure state
  • the speculative memory state can be maintained in each local data cache memory of the kernel and does not propagate to higher levels of a memory hierarchy until it is entrusted.
  • the expulsion of a speculatively modified cache memory line can cause the cancellation of a speculative thread that runs in that core.
  • the coherence activity due to non-speculative loads and storage can operate in the granularity of the line.
  • the protocol can operate on the granularity of the word to support speculative versions and reduce unnecessary cancellations due to false sharing conditions.
  • the dependencies of the memory between threads can be verified dynamically.
  • a dependency of data for example, dependency between threads of reading after writing (RAW) or writing after reading (WAR)
  • a violation manipulator can be invoked.
  • the violation manipulator can execute at application level and properly cancel the speculation activity
  • the protocol has no concept of thread order.
  • a software layer that manages the thread ratio can be implemented. For example, in the case of a violation of the data dependency between threads, the invoked software manipulator is responsible for checking whether there is a dependency on reading after writing before canceling the speculative thread that has made a reading (and all its successors).
  • expulsions of non-speculative cache memory lines can be handled according to the MESI protocol.
  • the status of the speculative memory and the status of the information is maintained locally in the data cache and does not propagate to higher levels until entrusted, any expulsion of a line of cache memory to which having speculative access (that is, access to read or write) causes a violation, similar to that of a dependency on data between threads.
  • the protocol can allow a mixture of speculative and non-speculative load / storage in the same local data cache.
  • any loading / storage performed by a speculative thread is treated as speculative.
  • special loads / storage called "secure" accesses, can be made by any thread (speculative or not) for access to shared memory and these accesses can be treated as non-speculative. Therefore, some interactions can occur when speculative and non-speculative loads / storage effected by access to the same wire to the same places.
  • the protocol can resolve this issue by raising a case of violation provided that a non-speculative load / storage has access to a place of speech that is speculatively accessed (that is, with the set of bits U or L).
  • the coherence protocol can dynamically keep track of data words in memory that have been speculatively accessed and verify data dependencies between threads in order to detect false speculations on the fly.
  • the mechanism to dynamically check the dependencies between wires can be based on several bus messages. In one embodiment, such messages may be tagged with the thread identifier (ID) of the thread generating the message, the address of the cache line that has been accessed and at least one word mask to indicate the word (words) that was accessed within the line.
  • ID thread identifier
  • bus messages that can be generated over speculative access may include a read verification message, a write verification message and a non-speculative write verification message (which are designated, respectively, as a message of ChkRd, ChkWr, and ChkNSWr).
  • a multi-cache cache can be used in a multi-processor system.
  • the system may include multiple processors, for example, cores of a multicore processor or multiple processors of a multiprocessor system.
  • Each core may include or be associated with a local cache, for example, a level 1 cache (Ll) that includes a cache controller.
  • Ll level 1 cache
  • the system 10 includes a processor 20 that is coupled to a system memory 65, in which it can use a dynamic direct access memory (DRAM), in one embodiment.
  • processor 20 can be coupled to system memory 65 through an out-of-chip interface 60, although the scope of the present invention is not limited to this aspect.
  • DRAM dynamic direct access memory
  • a processor 20 includes a core 30 and a cache memory 40.
  • the processor 20 may be a single core processor, although in other implementations the processor 20 may be a multi-core processor, in which others may be similarly configured cores with a core and an associated cache memory.
  • the cache memory 40 which can be a cache memory Ll, includes a memory array 42 and a cache controller 50.
  • the memory array 42 includes a plurality of cache memory lines 43a-43n (generically line 43 of the memory cache). Each line 43 of the cache memory can store multiple data words in a data part 49. Although the scope of the present invention is not limited to this aspect, in one embodiment the data part 49 can store eight words.
  • each cache line 43 may include an associated tag 44, which can be used to access the cache memory line.
  • each cache memory line 43 may include a first status portion 45, which may in turn include a series of bits or indicators according to a selected cache memory consistency protocol. For example, in one embodiment, this may be a MESI protocol. In other embodiments, other cache memory protocols may be used, such as an MSI protocol.
  • each line 43 of cache memory may further include a third speculative mask 46, which is also referred to as a first word mask.
  • the first speculative mask 46 may include a bit associated with each word of the part of data 49. Accordingly, in the embodiment of FIG. 1, the first speculative mask 46 may include first speculative indicators 41i-41 8 (generically first speculative indicator 41) each associated with a corresponding word in data portion 49.
  • the first speculative word mask 46 may be used to indicate that there has been a speculative reading of the associated word in data part 49.
  • a second speculative mask 48 which is also referred to herein as a second word mask, may include a bit associated with each word of data part 49.
  • the second speculative mask 48 may include second speculative indications 47i ⁇ 47 8 (generically second speculative indicator 47) each associated with a corresponding word in data portion 49.
  • the second speculative word mask 48 may be used to indicate that has produced a speculative writing of the associated word in data portion 49.
  • each second indicator 47 of the second speculative word mask 48 may be referred to as a U (Unsafe) bit, which is set when writing a storage of a speculative thread or a transaction region in the corresponding word.
  • each first indicator 41 of the first speculative word mask 46 may be referred to as an L (Speculatively Loaded) bit, which indicates that the data word has been read by the transaction or speculative thread and was not produced by that thread /transaction.
  • L Speculatively Loaded
  • cache memory controller 50 may cause appropriate indicators to be set in the first speculative mask 46 and in the second speculative mask 48.
  • the cache controller 50 can cause the generation and transmission of bus messages to notify other agents of the system, for example, other cache controllers, in relation to with the status of the various cache memory lines. In this way, speculative processing can be implanted using minimal physical equipment.
  • the cache memory controller 50 may also be configured to receive bus messages arriving, for example, from other cache controllers and determine if there is a conflict between an address indicated by the bus message and a location in cache memory 40. If so, cache memory controller 50 can send a data dependency violation message, for example, to kernel 30 to enable the execution of an appropriate manipulator to determine the ordering between accesses in conflict.
  • processor 20 may include an interface 55 on the chip, which makes communication between several cores possible within processor 20, in embodiments in which processor 20 is a multi-core processor. Although it has been illustrated with this particular implementation in the embodiment of FIG. 1, it should be understood that the scope of the present invention is not limited to this aspect.
  • FIG. 2 a flow chart of a method for performing speculative operations in accordance with an embodiment of the present invention has been represented. As illustrated in FIG. 2, method 100 can begin by speculatively executing a thread (block 110). Such speculative execution may correspond to a thread when executed, for example, on the basis of prediction based on a branch of a probable path for a program flow.
  • the speculative execution may correspond to the execution of a transaction in a transactional memory system according to an embodiment of the present invention.
  • you can determine whether a loading operation is to be carried out (rhombus 115). If not, the control passes back to block 110, previously considered. If a load operation is to be carried out, the control goes to block 120.
  • the data can be accessed in a local cache memory (block 120). For example, a kernel that executes the thread may require data that is present in a cache memory Ll.
  • a U bit and an L bit associated with the data can be checked to determine the speculative state of the data that has been accessed. If it is determined that the data has not been accessed during speculative execution, the control goes to block 130.
  • a cache controller associated with the cache memory Ll can establish a speculative load indicator for the associated data provided to the processor and can also generate a bus message (block 130). More specifically, the cache controller can send the required data to the kernel. In addition, the cache controller may establish one or more speculative load indicators associated with the data. For example, with reference again to FIG. 1, suppose that the kernel requires data from an entire cache memory line 43.
  • the cache controller will set all the first indicators 41i-41 8 of the first speculative word mask 46 to indicate that all of them have been loaded the corresponding data of a cache memory line 43.
  • the cache controller can also generate a bus message. Note that this bus message can only be generated the first time that a given data place is speculatively accessed during a speculative thread. In this way, a reduced bus traffic is carried out, while still providing the necessary information, that is, the wire Speculatively had access to a given memory location.
  • an identification message may be sent to indicate that the data in its cache memory has been speculatively loaded in one embodiment, which may correspond to a read verification bus message, that is, a ChkRd.
  • This message can be sent with the address and content of the first word mask.
  • This message may cause other cache controllers to determine that a word has not been written to that word mask.
  • the analysis of the word mask by another cache controller will be considered in the following. Note that block 130, and its operations of establishing a load indicator and generating a bus message, are not carried out if the data accessed has been read or written and stored in the local cache during the current execution speculative Consequently, block 130 is derived and method 100 concludes.
  • a flow chart of a method for performing speculative operations in accordance with an embodiment of the present invention has been represented.
  • a method 135 can begin by continuing the speculative execution of a thread (block 138).
  • it can be determined whether a storage operation is to be carried out (rhombus 140). If not, the control can go back to block 138 for another speculative execution. If, on the contrary, a storage operation is to be carried out, the control can go to block 145.
  • rhombus 150 it can be determined whether the data was produced in speculative execution. If so, method 135 can be concluded. Otherwise, the control passes from rhombus 150 to block 155. In this, the speculative data can be stored, and a speculative write indicator can be set. Further, a bus message can be generated (block 155). That is, in addition to storing the data in the data portion 49 of a cache memory line 43, one or more second indicators 47 can be set within the second speculative mask 48 to indicate this speculative data writing.
  • the associated cache memory controller can send a bus message, for example, a write check message, that is, a ChkWr, which can be received by other cache controllers which then verify that no load has read data. of a word in the second speculative mask 48 corresponding to a place to which it has been written.
  • this write verification message can only be sent the first time a data place with storage data is provided during the execution of a speculative thread. This reduces traffic even while providing the necessary information, that is, a given data place has been modified during speculative execution. Note that although it has been described with this particular implantation in the embodiment of FIG. 3, it should be understood that the scope of the present invention is not limited. Also, note that additional actions can be taken in a system to confirm whether the speculative execution was appropriate and should be entrusted or whether the speculative execution should be annulled, as described in more detail below.
  • method 200 can begin by completing speculative processing (block 210). For example, such a speculative process can be completed when a speculative thread reaches the end of its instructional stream or when a transaction in a transactional memory system completes its operation.
  • speculative execution can write speculatively determined data in a local cache memory, for example a cache memory Ll of a core in which speculative execution has occurred. It can then be determined if the speculative execution has been validated (rhombus 220). For this determination it can be taken into account if the data used by the kernel for speculative execution were valid. In different embodiments, the validation can take place in different ways and can be performed by various software in combination with physical equipment.
  • the control goes to block 230, where the state of the speculative memory can be entrusted to the state of the architecture (block 230).
  • Such entrustment of the state of the local cache memory can be carried out in accordance with an organization chart that is considered in the following with respect to FIG. 6.
  • the control goes to block 240.
  • the speculative state can be canceled.
  • such cancellation can be carried out in accordance with the flow chart of FIG. 7, which is considered in more detail in the following.
  • a cache controller may also receive bus messages, for example, from other cache controllers associated with speculative execution. These bus messages may include information regarding the speculative state of data in cache memory lines associated with the cache controller that sends such messages. Based on these messages, a receiving cache controller can determine if an impact has occurred at a location in its local cache.
  • FIG. 5 a flow chart of a method for processing received bus messages according to an embodiment of the present invention has been represented.
  • a bus message associated with speculative execution (block 310).
  • such a bus message can be received from a cache controller that is associated with a thread that is subject to speculative execution.
  • it can be determined whether the data corresponding to the bus message exists in the cache memory that receives the bus message (rhombus 320). For example, based on the tag information sent with the bus message it can be determined if there is a bit in the cache memory. If not, you can conclude method 300.
  • the cache controller can determine if there is a conflict, for example, by comparing a speculative word mask received with the message with the appropriate speculative word mask of the cache memory line reached.
  • a logical "Y" operation can be performed with bits between the received mask and the appropriate mask of the data line reached. This operation will be considered in more detail in the following. If a match occurs (that is, a logical "one" of the logical "Y” operation) results in a conflict. Consequently, the control goes to block 340.
  • the cache controller may signal a violation of the data dependency (block 340). More specifically, a violation of the data dependency between threads can be pointed out.
  • the cache memory controller that terminates the violation may send a particular violation message (Viol), for example, to its core associated with the identifiers of the conflicting threads.
  • the core can vectorize an application manipulator to perform a sort comparison between the conflicting threads.
  • the application handler can generate bus messages to indicate that one or more threads should be overridden to avoid data breaches. Although it has been illustrated with this particular implementation in the embodiment of FIG. 5, it should be understood that other forms of manipulation of incoming bus messages can be performed.
  • FIG. 6 represented in a flow chart of a method for entrusting the results of a speculative operation to a state of architecture according to an embodiment of the present invention.
  • method 400 you can start by receiving a message to entrust to a bus (block 410).
  • a message to entrust to a bus can be received by a cache controller that receives an indication that the data stored in its cache memory that was generated speculatively has been validated.
  • the cache controller can restore the speculative state of the data line that has been speculatively accessed in its local cache (block 420). That is, that both speculative word masks, the first and second, for any lines of cache memory to which you have access speculatively, can be restored.
  • any of these cache memory lines in which one or more words were modified during speculative execution may have a more updated cache memory consistency status. More specifically, any such lines can be established in a modified state (block 430). For example, in implementations using an MESI protocol, the M bit can be set.
  • the cache controller can also generate an update bus message. More specifically, the cache controller can generate such messages for shared data that has been modified (block 440).
  • a bus update message can be sent, that is, a DUpd message.
  • bus messages can cause one or more cache memories to send an invalid modified data line architecture value (block 460). Consequently, upon receiving such a value, the local cache memory can merge its speculatively written words with the value of the line architecture to eventually entrust the correct state of the line architecture to the memory (block 470).
  • An application manipulator or other agent may determine that the speculative execution of a given transaction or thread violates a data dependency rule. When this occurs, a so-called kill bus message can be sent.
  • FIG. 7 a flow chart of a method for canceling a speculative operation according to an embodiment of the present invention has been represented. Consequently, as illustrated in FIG. 7, method 500 can be started when a kill bus message has been received (block 510).
  • the message can be received from a core that implants the application manipulator.
  • the message may be generated by a cache memory controller or by another system agent.
  • the cache controller can restore the speculative state of such cache memory lines that have been speculatively accessed (block 520 ). For example, the first and second speculative word masks can both be deleted for any lines in the cache memory that have been speculatively accessed.
  • the cache controller can invalidate the state of any speculatively written cache lines (block 530). Consequently, any lines of the cache memory that have indicators established in the second speculative word masks can be invalidated. Such invalidation may correspond to an invalid bit setting of a MESI state of the associated cache memory line.
  • any of the invalidated lines were in an exclusive state (rhombus 540). That is, it can be determined whether the invalidated lines that have been speculatively accessed were the exclusive property of the local cache. If this is not the case, method 500 can be concluded. If, on the contrary, any invalidated lines were in an exclusive state, the control goes to block 550. In this case, a release bus message (that is, a RelOwner) can be sent to these previously exclusive cache memory lines (block 550). Accordingly, the cache controller can send a bus message that releases ownership of the associated cache line or lines and therefore returns ownership of the line to memory.
  • FIGS. 8 and 9 are state transition diagrams according to an embodiment of the present invention.
  • FIG. 8 represents the responses to events in the processor, while FIG. 9 represents responses to bus messages. Transitional states have not been included for clarity. The state transitions are labeled with the following nomenclature: "events or messages / actions received and / or messages generated”. The states, events, actions and messages involved in the protocol illustrated in FIGS. 8 and 9, are described in Table 1.
  • ChkRd message is generated by any speculative load that has access to a place of speech that has not previously been accessed (read or written) by the same thread.
  • the ChkWr message is generated by any speculative storage in a place of word that has not been speculatively written previously (that is, it is not insecure).
  • verification messages can only be generated on the first speculative load or stored in a word location in the cache memory.
  • ChkNSWr messages can be generated by any non-speculative storage (that is, a storage produced by a non-speculative thread or a "secure" storage produced by any thread).
  • the actual dependency check can be carried out whenever a cache memory controller receives a check message and compares (for example, by means of a "Y" bit operation) the word mask of the message with the L or U bits of the cache memory line to which you had access accordingly.
  • the ChkRd message causes the cache controller to compare the word mask of the message against the U bits, while the ChkWr and ChkNSWr messages compare it against the L bits.
  • This violation invokes an application manipulator with the IDs (identities) of the producer and consumer threads as parameters.
  • a special thread ID can be passed as a producer parameter to notify that the producer thread is non-speculative.
  • the application through the violation manipulator may be responsible for managing the cancellation of the speculation activity properly.
  • this involves checking the order between producer and consumer threads to verify that the violation is caused by a dependency on reading after writing. If so, the manipulator can send a message to cancel the consumer thread and all its successors.
  • the protocol can support multiple versions of the same place of speech (one version for each thread), and therefore the reliance on data to write after writing between threads does not cause any violation.
  • Access to sub-words can be specially manipulated.
  • a speculative storage in a sub-word place implies a violation when another thread writes to the same word because otherwise the coherence of the cache memory would not be guaranteed.
  • a speculative storage of a sub-word can cause an associated cache memory controller to set the U bit and send a ChkWr message, as is done in a speculative storage operation.
  • the cache controller can set the L bit and send a ChkRd message. This guarantees that whenever another thread carries out a storage in the same place of the word, a violation of the dependence of data between threads will be detected.
  • the memory speculative state can entrust yourself to the state of architecture.
  • a message called "BusCommit"("EncomendarBus) is sent that includes the thread ID of the speculative thread or the transactional region to be entrusted.
  • the cache memory controller receives the "BusCommit” message corresponding to the message thread ID, the process of entrusting the speculative memory begins. This process can be carried out in accordance with the organization chart set out in LA FIG. 6.
  • Table 2 the actions performed by the cache memory line in any of the given states are summarized (ie, the "BusCommit" column.
  • the entrust process resets all the L and U bits in the local cache memory lines and puts those lines that have any speculatively written word (ie, insecure) in the M state. In order to do this, a scan of the local data cache is performed. Those lines that are in the SU state or in the SUL state cause the generation of a bus grade rise (BusUpg) to invalidate other copies of the cache memory line.
  • BusUpg bus grade rise
  • a protocol according to an embodiment of the present invention may be responsible for discarding any state of speculative memory produced by the transactional region or the voided thread. This is implemented through a bus message, called "BusKill" in an embodiment that includes the thread ID of the speculative thread to be overridden.
  • the speculative memory override process begins. This process can be carried out in accordance with the flow chart set forth in FIG. 7.
  • Table 2 shows the actions performed by a line of cache memory in each of the given states (ie, the BusKill column). As described above, this override process includes resetting all the L and U bits in the local data cache. In addition, those cache memory lines that have any speculative word (that is, insecure) are invalidated. The lines that are accessed not speculatively are not changed.
  • lines in the EU or EUL state release ownership of the line to memory, through a bus message to release owner (i.e., a RelOwner), when they change to invalid status.
  • a point-to-point interconnection system 700 includes a first processor 770 and a second processor 780 coupled through a point-to-point interconnection 750.
  • each of the 770 and 780 processors can be a multi-core processor, which includes first and second processor cores (i.e., 774a and 774b processor cores and 784a and 784b processor cores).
  • the various processor cores may each include a local cache memory that implements a cache memory consistency protocol in accordance with an embodiment of the present invention. Consequently, using the 700 system, speculative multi-threaded transactions and transmissions can be made.
  • the first processor 770 further includes a memory controller center (MCH) 772 and point-to-point interfaces (PP) 776 and 778.
  • the second processor 780 includes an MCH 782 and PP interfaces 786 and 788.
  • the MCH 772 and 782 couple the processors to the respective memories, that is to a memory 732 and a memory 734, which can be parts of main memory locally linked to the respective processors.
  • the first processor 770 and the second processor 780 can be coupled to a chipset 790 through PP 752 and 754 interfaces, respectively.
  • the 790 chipset includes PP 794 and 798 interfaces.
  • the 790 chipset includes a 792 interface to couple the 790 chipset with a 738 performance graphics engine.
  • AGP Advanced Graphics Port
  • the 739 AGP bus can be adapted to the Accelerated Graphics Port Interface Spedification, Revision 2.0 (Specification Memory Accelerated Graphics Port Interface, Revision 2.0) published on May 7, 1998 by Intel Corporation, Santa Clara, California (USA)
  • a point-to-point 739 interconnection can couple these components.
  • the chip set 790 can be coupled to a first bus 716 through an interface 796.
  • the first bus 716 can be a "Peripheral Component Interconnect (PCI) bus.” as defined in the "PCI Local Bus Specification, Production Version, Revision 2.1", dated June 1995, or a bus such as the PCI Express bus or other input / output interconnect (I / O) bus third generation, although the scope of the present invention is not limited thereto.
  • PCI Peripheral Component Interconnect
  • I / O devices 714 can be coupled to the first bus 716, together with a bus bridge 718 that couples the first bus 726 to a second bus 720.
  • the second bus 720 may be an LPC bus ( Low PIN or Personal Identification Number).
  • Various devices can be coupled to the second bus 720 including, for example, a keyboard / mouse 722, communication devices 726 and the data storage unit 728 which may include code 730, in one embodiment.
  • an audio I / O 724 can be coupled to the second bus 720.
  • the embodiments can be implemented in code form and can be stored in a machine-accessible medium such as a storage medium that has instructions stored therein that can be used to program a machine. system to execute instructions.
  • the storage medium may include, but is not limited to, floppy disks or floppy disks, read-only memory compact discs (CD-ROMs), rewritable compact discs (CD-RWs), and optical magneto disks, semiconductor devices such as read-only memories (ROMs) direct access memories (RAMs) such as dynamic direct access memories (DRAMs), static direct access memories (SRAMs), programmable read only memories (EPROMs), quick memories, memories Electrically erasable programmable read-only (EEPROMs), magnetic or optical cards, or any other suitable means for storing electronic instructions.
  • ROMs read-only memories
  • RAMs random access memories
  • DRAMs dynamic direct access memories
  • SRAMs static direct access memories
  • EPROMs programmable read only memories
  • EEPROMs electrically erasable

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Memory System Of A Hierarchy Structure (AREA)

Abstract

En una realización, el presente invento incluye un método para recibir un mensaje de bus en una primera memoria cache correspondiente a un acceso especulativo a una parte de una segunda memoria cache por un segundo hilo, y determinar dinámicamente en la primera memoria cache si existe una dependencia entre hilos, entre el segundo hilo y un primer hilo asociado con la primera memoria cache con respecto a esa una parte. Se describen y se reivindican otras realizaciones.

Description

MÉTODO APARATO Y SISTEMA APLICADO EN UN PROTOCOLO DE COHERENCIA DE UNA MEMORIA CACHE
Antecedentes
Las realizaciones del presente invento se refieren a sistemas basados en procesador, y más en particular a la implantación de un protocolo de coherencia de la memoria dentro de uno de tales sistemas.
En los últimos años, los procesadores han incorporado un creciente soporte para el paralelismo a nivel de ejecución. Usualmente, el paralelismo a nivel de ejecución explotado por las arquitecturas es explícita o no especulativa. La utilización del paralelismo a nivel de ejecución especulativo ha sido propuesto para aumentar aun más los beneficios de las arquitecturas multihilo/multinúcleo. En tales soluciones, se divide el código en trozos que son ejecutados en paralelo especulativamente. La ejecución en memoria transaccional es una técnica similar en la que se permite que diferentes hilos tengan acceso especulativo y escriban en la memoria, ignorando las posibles dependencias de datos entre los hilos. En estos dos modelos de ejecución, el estado de memoria especulativa es encomendado atómicamente al estado de la arquitectura o bien desechado dependiendo de las comprobaciones del tiempo de ejecución (por ejemplo de las dependencias de la memoria entre hilos) . Para implantar eficazmente estos modelos de ejecución en procesadores actuales multihilo y multinúcleo, el soporte de equipo físico en el subsistema de la memoria se amplia con el soporte para manejar datos especulativos, detectar dependencia de datos entre hilos, y encomendar o aplastar el estado especulativo. De este modo, un subsistema de memoria puede ser capaz de mantener una versión especulativa diferente por hilo del mismo lugar de la memoria de modo que hilos especulativos de la misma aplicación puedan compartir el espacio de la memoria y escribir en los mismos lugares de la memoria. Un subsistema de memoria ampliado con soporte de especulación y multiversión se denomina una memoria cache multiversión (MVC) . Frecuentemente tales sistemas incluyen tablas centralizadas tales como una tabla para deshacer ambigüedades en la memoria para mantener la pista de los datos a los que se ha tenido acceso especulativamente. Sin embargo, tal soporte de equipo físico es costoso y requiere cantidades significativas de espacio y de energía. Tal soporte requiere además típicamente soporte de órdenes de lectura basadas en el equipo físico. Además, se requiere una comunicación significativa entre diversas memorias caches de cada sistema, incluyendo la transmisión de los propios datos especulativos, lo cual aumenta el tráfico en el bus y afecta perjudicialmente a las actuaciones y al consumo de energía. Breve Descripción de los Dibujos
La FIG. 1 es un diagrama bloque de una parte de un sistema de de acuerdo con una realización del presente invento.
La FIG. 2 es un organigrama de un método para efectuar la ejecución especulativa de acuerdo con una realización del presente invento.
La FIG. 3 es un organigrama de un método para efectuar operaciones especulativas adicionales de acuerdo con una realización del presente invento.
La FIG. 4 es un organigrama de un método para más operaciones especulativas de acuerdo con una realización del presente invento. La FIG. 5 es un organigrama de un método para procesar mensajes de bus recibidos de acuerdo con una realización del presente invento.
La FIG. 6 es un organigrama de un método para encomendar los resultados de una operación especulativa de acuerdo con una realización del presente invento.
La FIG. 7 es un organigrama de un método para aplastar una operación especulativa de acuerdo con una realización del presente invento.
La FIG. 8 es un diagrama de transición de estado que ilustra las respuestas a acontecimientos del procesador de acuerdo con una realización del presente invento. La FIG. 9 es un diagrama de transición de estado que ilustra las repuestas a mensajes de bus de acuerdo con una realización del presente invento.
La FIG. 10 es un diagrama bloque de un sistema multiprocesador de acuerdo con una realización del presente invento . Descripción Detallada
En varias realizaciones, se puede implantar un protocolo de memoria cache multiversión en un sistema para permitir procesado especulativo de múltiples hilos y/o transacciones. De este modo, se pueden obtener actuaciones mejoradas puesto que por los hilos se puede ejecutar en paralelo y un protocolo de coherencia de memoria cache, en combinación con software que maneje las órdenes por los hilos, puede determinar la validez de cualquier hilo especulativo dado.
Además, para deducir la complejidad del equipo físico, una memoria cache multiversión de acuerdo con una realización del presente invento no implanta la comunicación de los valores de la memoria especulativa entre hilos especulativos. Al no efectuar tal comunicación, se simplifica significativamente el equipo físico, dado que ello evita una lógica de control de versión centralizada. En consecuencia, se puede reducir al mínimo el equipo físico para implantar la ejecución por hilos especulativa, y además no hay necesidad de un directorio centralizado u otra estructura de memoria cache centralizada. Por el contrario, un controlador de memoria cache asociado con memorias cache locales puede recibir el tráfico del bus relativo a accesos especulativos y, sobre la base de esta información y del estado de equipo físico especulativo mínimo en la memoria cache, determinar si hay un conflicto a un lugar al que se tenga acceso. Si es asi, el controlador de la memoria cache puede enviar una señal a una capa de software, por ejemplo, a un manipulador de la aplicación para determinar la naturaleza del conflicto. Al determinar que uno o más hilos han de ser aplastados, el manipulador de la aplicación puede enviar un mensaje por el bus para producir el aplastamiento. El controlador (o controladores) de la memoria cache asociado (s) con el hilo (hilos) al ser anulados puede establecer en consecuencia el estado de una o más lineas de memoria cache asociadas con el hilo. En varias realizaciones, se puede implantar un protocolo de coherencia de memoria cache multiversión sobre la base de un protocolo convencional modificado, compartido, inválido (MSI) /modificado, exclusivo, compartido, inválido (MESI). El protocolo, al cual se puede aqui referencia como un protocolo MU[E]SLI, incluye estados adicionales (por ejemplo, un estado L correspondiente a un estado cargado especulativo, y un estado U correspondiente a un estado inseguro) y puede operar en la granularidad de la palabra, detectar dinámicamente las dependencias de la memoria entre hilos, y soportar una versión especulativa de un lugar en la memoria por cada memoria cache de datos. Es decir, que el protocolo puede soportar una versión especulativa de una palabra dada por hilo y por memoria cache de datos .
El estado de memoria especulativa puede mantenerse en cada memoria cache de datos local del núcleo y no se propaga a niveles superiores de una jerarquia de la memoria hasta ser encomendado. La expulsión de una linea de memoria cache modificada especulativamente puede originar la anulación de un hilo especulativo que discurra en ese núcleo. La actividad de coherencia debida a cargas y almacenamientos no especulativos puede operar en la granularidad de la linea. Para cargas y almacenamientos especulativos, el protocolo puede operar en la granularidad de la palabra para soportar versiones especulativas y reducir las anulaciones innecesarias debidas a falsa condición de compartir.
Las dependencias de la memoria entre hilos pueden verificarse dinámicamente. Cuando se detecta una dependencia de datos (por ejemplo, dependencia entre hilos de leer después de escribir (RAW) o escribir después de leer (WAR) , se puede invocar un manipulador de violación. El manipulador de violación puede ejecutar a nivel de aplicación y anular apropiadamente la actividad de especulación. Para reducir la complejidad del equipo físico, el protocolo no tiene concepto del orden de los hilos. En el caso de multihilo especulativo en el que existe un orden secuencial entre los hilos, se puede implantar una capa de software que gestione la relación de los hilos. Por ejemplo, en el caso de una violación de la dependencia de datos entre hilos, el manipulador de software invocado es responsable de comprobar si hay una dependencia de leer después de escribir antes de anular el hilo especulativo que haya efectuado una lectura (y todos sus sucesores) .
En varias realizaciones, se pueden manejar las expulsiones de lineas de memoria cache no especulativas de acuerdo con el protocolo MESI. Sin embargo, puesto que el estado de la memoria especulativa y el estado de la información se mantiene localmente en la memoria cache de datos y no se propaga a niveles superiores hasta que sea encomendado, cualquier expulsión de una linea de memoria cache a la que se tenga acceso especulativamente (es decir, de acceso de leer o escribir) origina una violación, similar a la de una dependencia de datos entre hilos.
Por otra parte, el protocolo puede permitir una mezcla de carga/almacenamientos especulativos y no especulativos en la misma memoria cache de datos local. Generalmente, cualquier carga/almacenamiento efectuado por un hilo especulativo se trata como especulativo. Sin embargo, las cargas/almacenamientos especiales, denominados accesos "seguros", pueden efectuarse por cualquier hilo (especulativo o no) para acceso a la memoria compartida y estos accesos pueden tratarse como no especulativos. Por consiguiente, pueden producirse algunas interacciones cuando las cargas/almacenamientos especulativos y no especulativos efectuados por acceso al mismo hilo a los mismos lugares. En ese caso, el protocolo puede resolver esta cuestión suscitando para ello un caso de violación siempre que una carga/almacenamiento no especulativo tenga acceso a un lugar de palabra a la que se tenga acceso especulativamente (es decir, con el conjunto de bits U o L) . En varias realizaciones, el protocolo de coherencia puede mantener dinámicamente la pista de las palabras de datos de la memoria a las que se ha tenido acceso especulativamente y verificar las dependencias de datos entre hilos con objeto de detectar las falsas especulaciones sobre la marcha. El mecanismo para comprobar dinámicamente las dependencias entre hilos puede estar basado en varios mensajes de bus. En una realización, tales mensajes pueden ser etiquetados con el identificador de hilo (ID) del hilo que genere el mensaje, la dirección de la linea de la memoria cache a la que se ha tenido acceso y al menos una máscara de palabra para indicar la palabra (palabras) a la que se haya tenido acceso dentro de la linea. Estos mensajes pueden adoptar diferentes formas en las diferentes realizaciones. Sin embargo, los mensajes pueden ser usados para indicar a otros controladores de la memoria cache el estado de los datos a los que se ha tenido acceso especulativamente. En respuesta, estos controladores de la memoria cache pueden tomar varias acciones como se describe con más detalle en lo que sigue. En una realización, los mensajes de bus que pueden ser generados sobre acceso especulativo pueden incluir un mensaje de verificación de lectura, un mensaje de verificación de escritura y un mensaje de verificación no especulativa de escritura (que se designan, respectivamente, como un mensaje de ChkRd, de ChkWr, y de ChkNSWr) . Aunque pueden implantarse realizaciones de diferentes sistemas, en una realización se puede usar una memoria cache multiversión en un sistema de múltiples procesadores. Por ejemplo, el sistema puede incluir múltiples procesadores, por ejemplo, núcleos de un procesador multinúcleo o múltiples procesadores de un sistema multiprocesador . Cada núcleo puede incluir o estar asociado con una memoria cache local, por ejemplo, una memoria cache de nivel 1 (Ll) que incluye un controlador de memoria cache.
Con referencia ahora a la FIG. 1, se ha representado un diagrama bloque de una parte de un sistema de acuerdo con una realización del presente invento. Como se ha ilustrado en la FIG. 1, el sistema 10 incluye un procesador 20 que está acoplado a una memoria 65 del sistema, en la cual puede usar una memoria de acceso directo dinámica (DRAM), en una realización. Como se ha ilustrado en la FIG. 1, el procesador 20 puede ser acoplado a la memoria 65 del sistema a través de una interfaz 60 fuera de chip, aunque el alcance del presente invento no queda limitado a este aspecto.
Como se ha ilustrado también en la FIG. 1, un procesador 20 incluye un núcleo 30 y una memoria cache 40. En una realización, el procesador 20 puede ser un procesador de un solo núcleo, aunque en otras implantaciones el procesador 20 puede ser un procesador multinúcleo, en el cual pueden estar otros núcleos configurados similarmente con un núcleo y una memoria cache asociada. La memoria cache 40 que puede ser una memoria cache Ll, incluye una matriz de memoria 42 y un controlador de memoria cache 50. La matriz de memoria 42 incluye una pluralidad de lineas de memoria cache 43a-43n (genéricamente la linea 43 de la memoria cache) . Cada linea 43 de la memoria cache puede almacenar múltiples palabras de datos en una parte de datos 49. Aunque el alcance del presente invento no queda limitado a este aspecto, en una realización la parte de datos 49 puede almacenar ocho palabras. Además del almacenamiento de datos, cada linea 43 de memoria cache puede incluir una etiqueta 44 asociada, la cual puede ser usada para tener acceso a la linea de memoria cache. Además, cada linea de memoria cache 43 puede incluir una primera parte de estado 45, la cual puede incluir a su vez una serie de bits o indicadores de acuerdo con un protocolo de coherencia de memoria cache seleccionado. Por ejemplo, en una realización, este puede ser un protocolo MESI. En otras realizaciones se pueden usar otros protocolos de memoria cache, tales como un protocolo MSI.
Continuando con referencia a la FIG. 1, cada linea 43 de memoria cache puede incluir además una tercera máscara especulativa 46, a la que también se hace referencia como una primera máscara de palabra. La primera máscara especulativa 46 puede incluir un bit asociado con cada palabra de la parte de datos 49. En consecuencia, en la realización de la FIG. 1, la primera máscara especulativa 46 puede incluir primeros indicadores especulativos 41i-418 (genéricamente primer indicador especulativo 41) cada uno de ellos asociado con una palabra correspondiente en la parte de datos 49. La primera máscara de palabra especulativa 46 puede usarse para indicar que se ha producido una lectura especulativa de la palabra asociada en la parte de datos 49.
Análogamente, una segunda máscara especulativa 48, a la que también se hace aqui referencia como una segunda máscara de palabra, puede incluir un bit asociado con cada palabra de la parte de datos 49. Como se ha ilustrado en la FIG. 1, la segunda máscara especulativa 48 puede incluir segundas indicaciones especulativas 47i~478 (genéricamente segundo indicador especulativo 47) cada uno asociado con una palabra correspondiente en la parte de datos 49. La segunda máscara de palabras especulativa 48 puede usarse para indicar que se ha producido una escritura especulativa de la palabra asociada en la parte de datos 49. En una realización, cada segundo indicador 47 de la segunda máscara de palabras especulativa 48 puede denominarse como un bit U (Inseguro) , que se establece cuando escribe un almacenamiento de un hilo especulativo o una región de transacción en la correspondiente palabra. Análogamente, cada primer indicador 41 de la primera máscara de palabras especulativa 46 puede denominarse como un bit L (Cargado Especulativamente) , lo cual indica que la palabra de datos ha sido leida por la transacción o hilo especulativo y que no fue producida por ese hilo/transacción. Una carga especulativa puede establecer ese bit en cualquier palabra leida que tenga el bit U despejado.
Por consiguiente, cuando se esté produciendo ejecución especulativa que proporciona acceso a datos en la memoria cache 40, el controlador de memoria cache 50 puede hacer que sean establecidos los indicadores apropiados en la primera máscara especulativa 46 y en la segunda máscara especulativa 48. Además, sobre la base del estado de una linea de memoria cache dada, el controlador de memoria cache 50 puede originar la generación y la transmisión de mensajes de bus para notificar a otros agentes del sistema, por ejemplo, a otros controladores de memoria cache, en relación con el estado de las diversas lineas de memoria cache. De este modo, el procesado especulativo puede ser implantado usando un equipo fisico añadido minimo. En varias realizaciones, el controlador de memoria cache 50 puede además estar configurado para recibir mensajes de bus que lleguen, por ejemplo, procedentes de otros controladores de memoria cache y determinar si existe un conflicto entre una dirección indicada por el mensaje de bus y un lugar en la memoria cache 40. De ser asi, el controlador de memoria cache 50 puede enviar un mensaje de violación de la dependencia de datos, por ejemplo, al núcleo 30 para hacer posible la ejecución de un manipulador apropiado para determinar el ordenamiento entre accesos en conflicto.
Como se ha ilustrado también en la FIG. 1, el procesador 20 puede incluir una interfaz 55 en el chip, la cual hace posible la comunicación entre varios núcleos dentro del procesador 20, en las realizaciones en las cuales el procesador 20 sea un procesador multinúcleo. Aunque se ha ilustrado con esta implantación particular en la realización de la FIG. 1, ha de quedar entendido que no queda limitado a este aspecto el alcance del presente invento. Con referencia ahora a la FIG. 2, se ha representado un organigrama de un método para efectuar operaciones especulativas de acuerdo con una realización del presente invento. Como se ha ilustrado en la FIG. 2, el método 100 puede empezar por ejecutar especulativamente un hilo (bloque 110) . Tal ejecución especulativa puede corresponder a un hilo al ser ejecutado, por ejemplo, sobre la base de la predicción en base de una rama de un camino probable para un flujo de programa. En otras implantaciones, la ejecución especulativa puede corresponder a la ejecución de una transacción en un sistema de memoria transaccional de acuerdo con una realización del presente invento. Durante la ejecución del hilo especulativo, puede determinarse si se ha de efectuar una operación de carga (rombo 115) . Si no es asi, el control pasa volviendo al bloque 110, antes considerado. Si se ha de efectuar una operación de carga, el control pasa al bloque 120. En este se puede tener acceso a los datos en una memoria cache local (bloque 120) . Por ejemplo, un núcleo que ejecute el hilo puede requerir datos que estén presentes en una memoria cache Ll. A continuación, puede determinarse si los datos a los que se ha tenido acceso fueron leidos o escritos durante la actual ejecución especulativa (rombo 125) . Por ejemplo, un bit U y un bit L asociados con los datos pueden verificarse para determinar el estado especulativo de los datos a que se ha tenido acceso. Si se determina que no se ha tenido acceso a los datos durante la ejecución especulativa, el control pasa al bloque 130. Para hacer posible la multiversión de los datos a los que se ha tenido acceso, un controlador de memoria cache asociado con la memoria cache Ll puede establecer un indicador de carga especulativa para los datos asociados proporcionados al procesador y además puede generar un mensaje de bus (bloque 130) . Más concretamente, el controlador de memoria cache puede enviar los datos requeridos al núcleo. Además, el controlador de memoria cache puede establecer uno o más indicadores de carga especulativa asociados con los datos. Por ejemplo, con referencia de nuevo a la FIG. 1, supongamos que el núcleo requiere datos de una linea de memoria cache entera 43. En tal hipótesis, el controlador de memoria cache establecerla todos los primeros indicadores 41i-418 de la primera máscara de palabra especulativa 46 para indicar que han sido cargados todos los datos correspondientes de una linea de memoria cache 43. Además, para mantener la coherencia entre los múltiples hilos, el controlador de memoria cache puede generar además un mensaje de bus. Obsérvese que este mensaje de bus solamente puede ser generado la primera vez que se tiene acceso especulativamente a un lugar de datos dados durante un hilo especulativo. De este modo, se realiza un tráfico de bus reducido, sin dejar por ello de proporcionar la información necesaria, es decir, que el hilo especulativo ha tenido acceso a un lugar de la memoria dado. En una realización, puede enviarse un mensaje de identificación para indicar que los datos en su memoria cache han sido cargados especulativamente en una realización, lo cual puede corresponder a un mensaje de bus de verificación de lectura, es decir, un ChkRd. Este mensaje puede ser enviado con la dirección y el contenido de la primera máscara de palabra. Este mensaje puede hacer que otros controladores de memoria cache determinan que no ha sido escrito almacenamiento de una palabra en esa máscara de palabra. El análisis de la máscara de palabra por otro controlador de memoria cache se considerará en lo que sigue. Obsérvese que el bloque 130, y sus operaciones de establecer un indicador de carga y generar un mensaje de bus, no se efectúan si los datos a los que se ha tenido acceso fueron leídos o escritos y almacenados en la memoria cache local durante la actual ejecución especulativa. En consecuencia, se deriva el bloque 130 y el método 100 concluye.
Con referencia ahora a la FIG. 3, se ha representado en ella un organigrama de un método para efectuar operaciones especulativas de acuerdo con una realización del presente invento. Como se ha ilustrado en la FIG. 3, un método 135 puede empezar por continuar la ejecución especulativa de un hilo (bloque 138) . A continuación, puede determinarse si se ha de efectuar una operación de almacenar (rombo 140) . Si no es asi, el control puede pasar de nuevo al bloque 138 para otra ejecución especulativa. Si por el contrario se ha de efectuar una operación de almacenar, el control puede pasar al bloque 145.
En este se puede tener acceso a los datos en la memoria cache local durante la ejecución especulativa (bloque 145) . A continuación, puede determinarse si los datos fueron producidos en la ejecución especulativa (rombo 150) . Si es asi, puede concluir el método 135. De no ser asi, el control pasa del rombo 150 al bloque 155. En este, se pueden almacenar los datos especulativos, y se puede establecer un indicador de escritura especulativa. Además, se puede generar un mensaje de bus (bloque 155) . Es decir, que además de almacenar los datos en la parte de datos 49 de una linea de memoria cache 43, se pueden establecer uno o más segundos indicadores 47 dentro de la segunda máscara especulativa 48 para indicar esta escritura de datos especulativos. Además, el controlador de memoria cache asociado puede enviar un mensaje de bus, por ejemplo, un mensaje de verificar escritura, es decir, un ChkWr, que puede ser recibido por otros controladores de memoria cache los cuales verifican entonces que ninguna carga ha leido datos de una palabra en la segunda máscara especulativa 48 correspondiente a un lugar a que se ha escrito. Al igual que con el mensaje de verificación de lectura descrito en lo que antecede, este mensaje de verificación de escritura puede únicamente ser enviado la primera vez que se proporciona un lugar de datos con datos de almacenamiento durante la ejecución de un hilo especulativo. Esto reduce el tráfico aun sin dejar de proporcionar la información necesaria, es decir, que ha sido modificado un lugar de datos dado durante la ejecución especulativa. Obsérvese que aunque se ha descrito con esta implantación particular en la realización de la FIG. 3, ha de quedar entendido que no queda por eso limitado el alcance del presente invento. Además, obsérvese que se pueden emprender acciones adicionales en un sistema para confirmar si la ejecución especulativa fue la apropiada y deberá ser encomendada o bien si la ejecución especulativa deberá ser anulada, como se describe con más detalle en lo que sigue.
Con referencia ahora a la FIG. 4, se ha representado en ella un organigrama de un método para todavia más operaciones especulativas de acuerdo con una realización del presente invento. Como se ha ilustrado en la FIG. 4, el método 200 puede empezar por completar el procesado especulativo (bloque 210) . Por ejemplo, tal proceso especulativo puede completarse cuando un hilo especulativo llega al final de su corriente de instrucción o bien cuando una transacción en un sistema de memoria transaccional complete su operación. En uno u otro caso, la ejecución especulativa puede escribir datos determinados especulativamente en una memoria cache local, por ejemplo una memoria cache Ll de un núcleo en el cual se haya producido la ejecución especulativa. Puede entonces determinarse si se ha validado la ejecución especulativa (rombo 220) . Para esta determinación se puede tener en cuenta si los datos usados por el núcleo para ejecución especulativa eran válidos. En diferentes realizaciones, la validación puede tener lugar de diferentes maneras y puede ser efectuada por diversos software en combinación con equipo físico.
Todavía con referencia a la FIG. 4, si se valida la ejecución especulativa, el control pasa al bloque 230, donde se puede encomendar el estado de la memoria especulativa al estado de la arquitectura (bloque 230) . Tal encomienda del estado del memoria cache local puede efectuarse de acuerdo con un organigrama que se considera en lo que sigue con respecto a la FIG. 6. Como alternativa, si no se ha validado la ejecución, el control pasa al bloque 240. En este se puede anular el estado especulativo. En una realización, tal anulación puede efectuarse de acuerdo con el organigrama de la FIG. 7, que se considera con más detalle en lo que sigue.
Como se ha descrito en lo que antecede, además de establecer indicadores y generar mensajes de bus durante la ejecución especulativa, un controlador de memoria cache puede también recibir mensajes de bus, por ejemplo, de otros controladores de memoria cache asociados con la ejecución especulativa. Estos mensajes de bus pueden incluir información relativa al estado especulativo de datos en lineas de memoria cache asociadas con el controlador de memoria cache que envia tales mensajes. Sobre la base de estos mensajes, un controlador de memoria cache de recepción puede determinar si se ha producido un impacto en un lugar en su memoria cache local.
Con referencia ahora a la FIG. 5, se ha representado un organigrama de un método para procesar mensajes de bus recibidos de acuerdo con una realización del presente invento. Como se ha ilustrado en la FIG. 5, por el método 300 se puede empezar por recibir un mensaje de bus asociado con la ejecución especulativa (bloque 310) . Como ejemplo, tal mensaje de bus puede ser recibido desde un controlador de memoria cache que esté asociado con un hilo que esté sometido a ejecución especulativa. Sobre la base del mensaje de bus recibido, puede determinarse si los datos correspondientes al mensaje de bus existen en la memoria cache que recibe el mensaje de bus (rombo 320) . Por ejemplo, sobre la base de la información de etiqueta enviada con el mensaje de bus puede determinarse si hay un bit en la memoria cache. Si no es asi, puede concluir el método 300.
Si por el contrario se produce un impacto, el control pasa al bloque 330. En este se puede determinar si existe un conflicto entre los datos del acceso especulativo y los datos en la memoria cache local. En varias realizaciones, el controlador de memoria cache puede determinar si existe un conflicto, por ejemplo, comparando para ello una máscara de palabra especulativa recibida con el mensaje con la máscara de palabra especulativa apropiada de la linea de memoria cache alcanzada. Como ejemplo, se puede efectuar una operación "Y" lógica con bits entre la máscara recibida y la máscara apropiada de la linea de datos alcanzada. Esta operación se considerará con más detalle en lo que sigue. Si se produce una coincidencia (es decir, que resulta un "uno" lógico de la operación "Y" lógica) ello indica un conflicto. En consecuencia, el control pasa al bloque 340. Si por el contrario no se producen impactos (es decir, que de una operación "Y" lógica resultan todos "ceros" lógicos) , no existe conflicto alguno y puede concluir el método 300. Todavía con referencia a la FIG. 5, si existe un conflicto, el controlador de memoria cache puede señalar una violación de la dependencia de datos (bloque 340) . Más concretamente, puede señalarse una violación de la dependencia de datos entre hilos. En una realización, el controlador de memoria cache que termina la violación puede enviar un mensaje determinado de violación (Viol) , por ejemplo, a su núcleo asociado juntamente con los identificadores de los hilos en conflicto. A su vez, el núcleo puede vectorizar a un manipulador de aplicación de efectúe una comparación de ordenación entre los hilos en conflicto. Sobre la base de la determinación de la dependencia de la ordenación, el manipulador de la aplicación puede generar mensajes de bus para indicar que uno o más hilos deberán ser anulados para evitar violaciones de datos. Aunque se ha ilustrado con esta implantación particular en la realización de la FIG. 5, ha de quedar entendido que pueden realizarse otras formas de manipulación de los mensajes de bus que llegan.
Con referencia ahora a la FIG. 6, representada en un organigrama de un método para encomendar los resultados de una operación especulativa a un estado de la arquitectura de acuerdo con una realización del presente invento. Como se ha ilustrado en la FIG. 6, por el método 400 se puede empezar por recibir un mensaje de encomendar a un bus (bloque 410) . Tal mensaje de encomendar a un bus puede ser recibido por un controlador de la memoria cache que reciba una indicación de que los datos almacenados en su memoria cache que fueron generados especulativamente han sido validados.
En consecuencia, el controlador de memoria cache puede restablecer el estado especulativo de la linea de datos a que se ha tenido acceso especulativamente en su memoria cache local (bloque 420) . Es decir, que ambas máscaras de palabras especulativas, la primera y la segunda, para cualesquiera lineas de memoria cache a las que tenga acceso especulativamente, pueden ser restablecidas. Además, cualquiera de estas lineas de memoria cache en las cuales fueran modificadas una o más palabras durante la ejecución especulativa, puede tener un estado de coherencia de memoria cache más actualizado. Más concretamente, se pueden establecer cualesquiera de tales lineas en un estado modificado (bloque 430) . Por ejemplo, en las implantaciones usando un protocolo MESI, se puede establecer el bit M. En consecuencia, tales acciones pueden actualizar efectivamente las correspondientes lineas de memoria cache a las que se ha tenido acceso especulativamente en la memoria cache local para reflejar su propio estado de arquitectura a la luz de la validación de la ejecución especulativa. Además, para efectuar un estado correcto de la arquitectura a través del sistema, el controlador de la memoria cache puede generar además un mensaje de bus de actualización. Más concretamente, el controlador de la memoria cache puede generar tales mensajes para datos compartidos que hayan sido modificados (bloque 440) . En una realización, se puede enviar un mensaje de actualización de bus, es decir, un mensaje DUpd.
En los implantes en los que hayan tenido lugar modificaciones a nivel de palabra, tales mensajes de bus pueden hacer que una o más memorias caches envíen un valor de la arquitectura de la linea de datos modificada inválida (bloque 460) . En consecuencia, al recibirse tal valor, la memoria cache local puede fundir sus palabras escritas especulativamente con el valor de la arquitectura de la linea para encomendar eventualmente el estado correcto de la arquitectura de la linea a la memoria (bloque 470) . Aunque se describe con este implante particular en la realización de la FIG. 6, ha de quedar entendido que el alcance del presente invento no queda limitado a este aspecto.
Un manipulador de la aplicación u otro agente puede determinar que la ejecución especulativa de una transacción o hilo dado viole una regla de dependencia de datos. Cuando ocurra esto, se puede enviar un denominado mensaje de bus de matar. Con referencia ahora a la FIG. 7, se ha representado un organigrama de un método para anular una operación especulativa de acuerdo con una realización del presente invento. En consecuencia, como se ha ilustrado en la FIG. 7, se puede empezar con el método 500 cuando se haya recibido un mensaje de bus de matar (bloque 510) . Por ejemplo, en una realización el mensaje puede ser recibido desde un núcleo que implante el manipulador de la aplicación. Sin embargo, en otras realizaciones el mensaje puede ser generado por un controlador de la memoria cache o por otro agente del sistema. Al recibir tal mensaje un controlador de una memoria cache que incluya los datos a que se ha tenido acceso especulativamente, el controlador de la memoria cache puede restablecer el estado especulativo de tales lineas de memoria cache a las que se ha tenido acceso especulativamente (bloque 520) . Por ejemplo, las máscaras de palabras especulativas primera y segunda pueden ser ambas borradas para cualesquiera lineas de la memoria cache a las que se haya tenido acceso especulativamente . A continuación, el controlador de la memoria cache puede invalidar el estado de cualesquiera lineas de memoria cache escritas especulativamente (bloque 530) . En consecuencia, pueden ser invalidadas cualesquiera lineas de la memoria cache que tengan indicadores establecidos en las segundas máscaras de palabra especulativas. Tal invalidación puede corresponder a un establecimiento del bit de inválido de un estado MESI de la linea de memoria cache asociada.
Siguiendo con referencia a la FIG. 7, a continuación puede determinarse si cualquiera de las lineas invalidadas estuviera en un estado exclusivo (rombo 540) . Es decir, que puede determinarse si las lineas invalidadas a las que se ha tenido acceso especulativamente eran de la propiedad exclusiva de la memoria cache local. Si no es asi, puede concluir el método 500. Si por el contrario cualesquiera lineas invalidadas estuvieran en un estado exclusivo, el control pasa al bloque 550. En este se puede enviar un mensaje de bus de liberar (es decir, un RelOwner) para estas lineas de memoria cache previamente exclusivas (bloque 550) . En consecuencia, el controlador de la memoria cache puede enviar un mensaje de bus que libere la propiedad de la linea o lineas de la memoria cache asociadas y por consiguiente devuelve la propiedad de la linea a la memoria. Aunque se describe con esta implantación particular en la realización de la FIG. 7, ha de quedar entendido que el alcance del presente invento no queda por eso limitado, y que en otras realizaciones se pueden realizar otras formas de desenvolver o anular transacciones o ejecuciones especulativas inválidas. Las FIGS. 8 y 9 son diagramas de transición de estado de acuerdo con una realización del presente invento. La FIG. 8 representa las respuestas a acontecimientos en el procesador, mientras que la FIG. 9 representa respuestas a mensajes de bus. No se han incluido los estados transitorios para mayor claridad. Las transiciones de estado se etiquetan con la siguiente nomenclatura: "acontecimientos o mensajes/acciones recibidas y/o mensajes generados". Los estados, acontecimientos, acciones y mensajes implicados en el protocolo que se ha ilustrado en las FIGS. 8 y 9, se describen en la Tabla 1.
Tabla 1
Figure imgf000020_0001
Figure imgf000021_0001
Como varios ejemplos de las transiciones representadas en las FIGS. 8 y 9, se genera un mensaje ChkRd mediante cualquier carga especulativa que tenga acceso a un lugar de palabra al que no se haya tenido previamente acceso (leida o escrita) por el mismo hilo. Por otra parte, el mensaje ChkWr es generado por cualquier almacenamiento especulativo en un lugar de palabra al que no se haya escrito anteriormente especulativamente (es decir, que no es inseguro) . Como se ha descrito en lo que antecede, los mensajes de verificación solamente pueden ser generados en la primera carga especulativa o almacenamiento en un lugar de palabra de la memoria cache. Los mensajes ChkNSWr pueden ser generados por cualquier almacenamiento no especulativo (es decir, un almacenamiento producido por un hilo no especulativo o bien un almacenamiento "seguro" producido por cualquier hilo) .
La verificación de dependencia real puede efectuarse siempre que un controlador de la memoria cache reciba un mensaje de comprobación y compare (por ejemplo, por medio de una operación "Y" de bits) la máscara de palabra del mensaje con los bits L o U de la linea de memoria cache a la que haya tenido acceso en consecuencia. En general, el mensaje ChkRd hace que el controlador de la memoria cache compare la máscara de palabra del mensaje frente a los bits U, mientras que los mensajes ChkWr y ChkNSWr la comparan frente a los bits L. En caso de que haya conflicto, es decir, de que la operación en "Y" de bits no dé como resultado cero, se detecta una dependencia de datos entre hilos y se puede suscitar un caso de violación. Esta violación invoca un manipulador de aplicación con las IDs (identidades) de los hilos del productor y del consumidor como parámetros. Cuando se genera la violación debido a un mensaje ChkNSWr, se puede hacer pasar una ID de hilo especial como parámetro del productor para notificar que el hilo del productor es no especulativo.
En varias formas de implantación, la aplicación a través del manipulador de la violación puede ser la responsable de gestionar la anulación de la actividad de especulación apropiadamente. En un modelo de ejecución multihilo especulativo, esto implica comprobar el orden entre los hilos de productor y de consumidor para verificar que la violación es causada por una dependencia de leer después de escribir. Si es asi, el manipulador puede enviar un mensaje para anular el hilo de consumidor y todos sus sucesores. En un sistema de memoria transaccional, puesto que no hay orden entre los hilos, solamente se anula el hilo de consumidor. Obsérvese que el protocolo puede soportar múltiples versiones del mismo lugar de palabra (una versión por cada hilo) , y por lo tanto la dependencia de datos de escribir después de escribir entre hilos no origina violación alguna.
Los accesos a las sub-palabras pueden ser manipulados especialmente. Un almacenamiento especulativo en un lugar de sub-palabra implica una violación cuando otro hilo escribe a la misma palabra debido a que de lo contrario no seria garantizada la coherencia de la memoria cache. Con objeto de conseguir esto, un almacenamiento especulativo de una sub-palabra puede hacer que un controlador de la memoria cache asociado establezca el bit U y envié un mensaje ChkWr, como se hace en una operación de almacenamiento especulativo. Además, el controlador de la memoria cache puede establecer el bit L y enviar un mensaje de ChkRd. Esto garantiza que siempre que otro hilo efectúe un almacenamiento en el mismo lugar de la palabra, será detectada una violación de la dependencia de datos entre hilos . Cuando se valide la actividad especulativa y no se detecte fallo alguno, el estado de especulativo de la memoria puede encomendarse al estado de la arquitectura. Para situar un proceso de encomendar, se envia un mensaje denominado de "BusCommit" ("Encomendar Bus") que incluye la ID de hilo del hilo especulativo o bien la región transaccional a ser encomendada. Cuando el controlador de la memoria cache recibe el mensaje de "BusCommit" correspondiente a la ID de hilo del mensaje, se inicia el proceso de encomendar la memoria especulativa. Este proceso puede efectuarse de acuerdo con el organigrama que se expone en LA FIG. 6. Además, como se ha ilustrado en Tabla 2 que sigue, se resumen las acciones efectuadas por la linea de memoria cache en cualquiera de los estados dados (es decir, la columna de "BusCommit".
Tabla 2
Figure imgf000023_0001
Obsérvese que el proceso de encomendar restablece todos los bits L y U en las lineas de la memoria cache local y pone en el estado M a aquellas lineas que tengan cualquier palabra escrita especulativamente (es decir, insegura) . Con objeto de hacer esto, se efectúa una exploración de la memoria cache de datos local. Aquellas lineas que estén en el estado SU o en el estado SUL producen la generación de una elevación del grado del bus (BusUpg) para invalidar otras copias de la linea de la memoria cache. De un modo similar, aquellas lineas que estén en el estado IU o IUL producen la generación de un mensaje exclusivo de leer bus (BusRdX) para solicitar el valor de la arquitectura de la linea y efectuar localmente una fusión con las palabras escritas especulativamente. Por otra parte, las lineas en los estados EU o EUL se cambian al estado M sin generar mensaje de bus alguno, dado que la linea está únicamente presente en esa memoria cache. En el caso de un fallo de especulación, se ha de anular la actividad especulativa. Un protocolo de acuerdo con una realización del presente invento puede ser el responsable de desechar todo estado de memoria especulativa producido por la región transaccional o el hilo anulado. Esto se implanta a través de un mensaje de bus, denominado "BusKill" en una realización que incluye la ID de hilo del hilo especulativo a ser anulada. Cuando se recibe el mensaje de BusKill por el controlador de memoria cache con la ID de hilo igual a la ID de hilo del mensaje, se inicia el proceso de anulación de la memoria especulativa. Este proceso puede llevarse a cabo de acuerdo con el organigrama que se expone en la FIG. 7. Además, en la Tabla 2 se han representado las acciones efectuadas por una linea de memoria cache en cada uno de los estados dados (es decir, la columna de BusKill) . Como se ha descrito en lo que antecede, este proceso de anulación incluye restablecer todos los bits L y U en la memoria cache de datos local. Además, aquellas lineas de memoria cache que tengan cualquier palabra especulativa (es decir, insegura) son invalidadas. Las lineas a las que se tiene acceso no especulativamente no se cambian. Por consiguiente, aquellas lineas que estén en cualquiera de los estados EU, EUL, SU, SUL, IU, o IUL cambian al estado I, y aquellas lineas que estén en uno cualquiera de los estados ML, EL, SL, o IL, cambian a M, E, S, e I, respectivamente. Obsérvese que las lineas en el estado EU o EUL liberan la propiedad de la linea a la memoria, a través de un mensaje de bus de liberar propietario (es decir, un RelOwner) , cuando cambian al estado de inválidas.
En consecuencia, en varias realizaciones, el ordenamiento de los hilos se manipula mediante software (por ejemplo, código generado por compilador) que es el responsable de filtrar las dependencias de la memoria entre hilos tal como en las operaciones de leer después de escribir. Un protocolo de acuerdo con una realización del presente invento puede también soportar la ejecución de la memoria transaccional, cuando el orden de los hilos sea irrelevante. Las realizaciones pueden implantarse en muchos tipos de sistemas diferentes. Con referencia ahora a la FIG. 10, se ha representado un diagrama bloque de un sistema de acuerdo con una realización del presente invento. Como se ha ilustrado en la FIG. 10, un sistema de interconexión de punto a punto 700 incluye un primer procesador 770 y un segundo procesador 780 acoplados a través de una interconexión de punto a punto 750. Aunque en la FIG. 10 se ha ilustrado como un sistema de interconexión punto a punto, ha de entenderse que el alcance del presente invento no queda limitado a este aspecto y que en otras realizaciones el sistema 700 puede ser de una arquitectura de bus de múltiples caldas u otro de tales tipos de sistema. Como se ha ilustrado en la FIG. 10, cada uno de los procesadores 770 y 780 puede ser un procesador multinúcleo, que incluya núcleos de procesador primero y segundo (es decir, núcleos de procesador 774a y 774b y núcleos de procesador 784a y 784b) . Los varios núcleos de procesador puede cada uno incluir una memoria cache local que implante un protocolo de coherencia de memoria cache de acuerdo con una realización del presente invento. En consecuencia, usando el sistema 700 se pueden efectuar transacciones y transmisiones multihilo especulativas.
El primer procesador 770 incluye además un centro controlador de la memoria (MCH) 772 e interfaces de punto a punto (P-P) 776 y 778. Análogamente, el segundo procesador 780 incluye un MCH 782 e interfaces P-P 786 y 788. Como se ha ilustrado en la FIG. 10, los MCH 772 y 782 acoplan los procesadores a las respectivas memorias, es decir a una memoria 732 y a una memoria 734, las cuales pueden ser partes de memoria principal unida localmente a los procesadores respectivos.
El primer procesador 770 y el segundo procesador 780 pueden ser acoplados a un juego de chips 790 a través de interfaces de P-P 752 y 754, respectivamente. Como se ha representado en la FIG. 10, el juego de chips 790 incluye interfaces de P-P 794 y 798. Además, el juego de chips 790 incluye una interfaz 792 para acoplar el juego de chips 790 con un motor de gráficos de actuaciones 738. En una realización, se puede usar un bus 739 de "Advanced Graphics Port (AGP) (Puerto de Gráficos Avanzado) para acoplar el motor de gráficos 738 al juego de chips 790. El bus 739 AGP puede adaptarse a la Accelerated Graphics Port Interface Spedification, Revisión 2.0 (Memoria de Especificación de Interfaz de Puerto de Gráficos Acelerados, Revisión 2.0) publicada con fecha 7 de mayo de 1998 por la Intel Corporation, Santa Clara, California (EE.UU.). Como alternativa, una interconexión de punto a punto 739 puede acoplar estos componentes .
A su vez, el juego de chips 790 puede ser acoplado a un primer bus 716 a través de una interfaz 796. En una realización, el primer bus 716 puede ser un bus de "Peripheral Component Interconnect (PCI) (Interconexión de Componentes Periféricos) tal como se define en la "PCI Local Bus Specification, Production Versión, Revisión 2.1", de fecha de junio de 1995, o bien un bus tal como el bus PCI Express u otro bus de interconexión de entrada/salida (I/O) de tercera generación, aunque el alcance del presente invento no queda limitado a eso.
Como se ha ilustrado en la FIG. 10, se pueden acoplar varios dispositivos 714 de I/O al primer bus 716, juntamente con un puente 718 de bus que acopla el primer bus 726 a un segundo bus 720. En una realización, el segundo bus 720 puede ser un bus LPC (de bajo PIN o Número de Identificación Personal) . Al segundo bus 720 pueden ser acoplados varios dispositivos incluyendo, por ejemplo, un teclado/ratón 722, dispositivos de comunicación 726 y la unidad de almacenamiento de datos 728 la cual puede incluir el código 730, en una realización. Además, se puede acoplar una I/O 724 de audio al segundo bus 720.
Las realizaciones pueden ser implantadas en forma de código y pueden ser almacenadas en un medio accesible para la máquina tal como en un medio de almacenamiento que tenga instrucciones almacenadas en el mismo que puedan ser usadas para programar un sistema para ejecutar las instrucciones. El medio de almacenamiento puede incluir, aunque sin quedar limitado a ellos, discos flexibles o disquetes, discos compactos de memoria de solo lectura (CD-ROMs) , discos compactos regrabables (CD- RWs) , y discos magneto ópticos, dispositivos semiconductores tales como memorias de solo lectura (ROMs) memorias de acceso directo (RAMs) tales como memorias de acceso directo dinámicas (DRAMs) , memorias de acceso directo estáticas (SRAMs) , memorias de solo lectura programables que pueden borrarse (EPROMs), memorias rápidas, memorias de solo lectura programables borrables eléctricamente (EEPROMs), tarjetas magnéticas u ópticas, o cualquier otro tipo de medios adecuados para almacenar instrucciones electrónicas.
Aunque se ha descrito el presente invento con respecto a un número limitado de realizaciones, quienes sean expertos en la técnica apreciarán numerosas modificaciones y variaciones del mismo. Se ha pretendido que las reivindicaciones que se acompañan abarquen todas esas modificaciones y variaciones en cuanto quedan comprendidas dentro del verdadero espíritu y del alcance de este presente invento.

Claims

Reivindicaciones
1. Un método que comprende : recibir un mensaje de bus en una primera memoria cache, correspondiendo el mensaje de bus a un acceso especulativo a una parte de una segunda memoria cache por un segundo hilo; y determinar dinámicamente en la memoria cache final si existe una dependencia entre hilos entre el segundo hilo y un primer hilo asociado con la primer memoria cache con respecto a esa una parte.
2. El método según la reivindicación 1, que comprende además señalar una violación de la dependencia a un manipulador de la aplicación asociada con una aplicación que incluye el primer hilo y el segundo hilo.
3. El método según la reivindicación 2, que comprende además: recibir en el manipulador de la aplicación el señalamiento de la violación de la dependencia y un identificador para el primer hilo y el segundo hilo; y determinar cual del primer hilo y del segundo hilo se ha de anular sobre la base de ordenar la información del primer hilo y del segundo hilo.
4. El método según la reivindicación 1, en el que la recepción del mensaje de bus comprende recibir una parte del mensaje, una parte de dirección y un identificador de hilo del segundo hilo, y no recibir la parte a la que se ha tenido acceso especulativamente .
5. El método según la reivindicación 1, que comprende además : establecer un primer indicador de estado especulativo para la parte a la que se ha tenido acceso especulativamente por el segundo hilo, y establecer un segundo indicador de estado especulativo para la parte a la que se ha tenido acceso especulativamente por el segundo hilo si la parte es escrita especulativamente por el segundo hilo.
6. El método según la reivindicación 1, en el que la determinación dinámicamente comprende: comparar una primera máscara del mensaje de bus con una primera máscara de una linea de memoria cache de la primera memoria cache que incluye la parte; y determinar la dependencia entre hilos sobre la base de la comparación .
7. Un aparato que comprende : una memoria cache que incluye una matriz de memoria y un controlador de memoria cache, en que la matriz de memoria ha de incluir una pluralidad de lineas que cada una tiene: una parte de estado para almacenar una primera máscara que tiene primeros indicadores especulativos cada uno para indicar un acceso especulativo a una palabra correspondiente de la linea, la parte de estado para almacenar además una segunda máscara que tiene segundos indicadores especulativos cada uno para indicar una escritura especulativa de una palabra correspondiente de la linea; y una parte de datos para almacenar una pluralidad de palabras; y el controlador de la memoria cache para transmitir y procesar los mensajes de bus asociados con los accesos a la memoria cache especulativos .
8. El aparato según la reivindicación 7, en el que la parte de estado y la parte de datos no incluyen información de ordenamiento.
9. El aparato según la reivindicación 7, en el que la parte de estado es para almacenar además un primer conjunto de indicadores correspondientes a un protocolo de coherencia modificada, exclusiva, compartida, e inválida.
10. El aparato según la reivindicación 9, en el que el primer conjunto de indicadores han de ser mantenidos sobre una base de linea y las máscaras primera y segunda han de ser mantenidas sobre una base de palabra.
11. El aparato según la reivindicación 7, en el que el controlador de la memoria cache es para afirmar una violación de la dependencia entre hilos a un manipulador de la aplicación.
12. El aparato según la reivindicación 11, en el que el controlador de la memoria cache es para afirmar la violación de la dependencia entre hilos si una u otra de una máscara primera o segunda que llegue enviada con un mensaje de bus de llegada está en conflicto con una máscara primera o segunda con la que coincida en la matriz de la memoria.
13. El aparato según la reivindicación 7, en el que el controlador de la memoria cache es para recibir un mensaje de bus para indicar la encomienda de un hilo especulativo si se ha validado el hilo especulativo.
14. El aparato según la reivindicación 13, en el que el controlador de la memoria cache es para dejar libre la primera máscara y la segunda máscara de lineas asociadas con el hilo especulativo si se ha validado el hilo especulativo.
15. El aparato según la reivindicación 7, en el que el controlador de la memoria cache es para verificar dinámicamente una dependencia de datos entre hilos sobre la base de un mensaje de bus que llega.
16. El aparato según la reivindicación 7, en el que el controlador de la memoria cache es para transmitir un primer mensaje de bus para indicar un acceso especulativo a una palabra de una linea, y para transmitir un segundo mensaje de bus para indicar una escritura especulativa a la palabra, en el que los mensajes de bus primero y segundo han de ser transmitidos sin la palabra.
17. El aparato según la reivindicación 16, en el que el primer mensaje de bus incluye la primera máscara y el segundo mensaje de bus incluye la segunda máscara.
18. Un articulo que comprende un medio de almacenamiento legible por máquina que incluye instrucciones que si son ejecutadas por una máquina capacitan a la máquina para poner en práctica un método que comprende: recibir un mensaje de bus en una primera memoria cache desde una segunda memoria cache para indicar una modificación de un valor de datos en la segunda memoria cache mediante una transacción de un sistema de memoria transaccional; y determinar en la primera memoria cache si la transacción está en conflicto con un primer hilo que ejecuta sobre un procesador asociado con la primera memoria cache sobre la base, al menos en parte, del mensaje de bus.
19. El articulo según la reivindicación 18, en el que el método comprende además enviar un mensaje de violación desde la primera memoria cache a un manipulador de la aplicación del procesador para determinar el ordenamiento entre la transacción y el primer hilo si se determina el conflicto.
20. El articulo según reivindicación 19, en el que el método comprende además recibir un mensaje desde el manipulador de la aplicación para anular la transacción basada en la determinación del ordenamiento.
21. El articulo según la reivindicación 20, en el que el método comprende además : restablecer indicadores especulativos en la segunda memoria cache asociados con el valor de datos; y enviar un mensaje de bus desde una segunda memoria cache para liberar la propiedad de una linea de memoria cache incluyendo el valor de datos si la segunda memoria cache poseía a la linea de memoria cache.
22. Un sistema que comprende: un primer procesador que tiene un primer núcleo y una primera memoria cache; un segundo procesador que tiene un segundo núcleo y una segunda memoria cache, en el que una determinación dinámica de una dependencia de datos entre memorias caches de un valor de datos presente tanto en la primera memoria cache como en la segunda memoria cache está basada en un mensaje de bus enviado entre la primera memoria cache y la segunda memoria cache; y una memoria de acceso directo dinámica (DRAM) acoplada al primer procesador y al segundo procesador.
23. El sistema según la reivindicación 22, en el que la primera memoria cache incluye un primer controlador de memoria cache para determinar dinámicamente la dependencia de datos entre memorias caches.
24. El sistema según la reivindicación 23, en el que el primer controlador de memoria cache es para generar un mensaje de violación para indicar una violación de la dependencia de datos entre memorias caches basada en el mensaje de bus.
25. Un sistema según la reivindicación 24, que comprende además un manipulador para recibir el mensaje de violación y para determinar el ordenamiento entre un hilo de productor y un hilo de consumidor.
26. El sistema según la reivindicación 25, que comprende además un programa de aplicación que incluye el hilo del productor y el hilo del consumidor, incluyendo además el programa de la aplicación el manipulador.
27. El sistema según la reivindicación 23, en el que el controlador de la primera memoria cache es para señalar una violación de la dependencia de datos entre memorias caches si tiene lugar un acceso especulativo a un lugar de acceso especulativamente en la primera memoria cache, en el que el acceso especulativo comprende una operación segura.
PCT/ES2006/070074 2006-05-30 2006-05-30 Método aparato y sistema aplicado en un protocolo de coherencia de una memoria cache WO2007138124A1 (es)

Priority Applications (4)

Application Number Priority Date Filing Date Title
CN2006800547341A CN101449250B (zh) 2006-05-30 2006-05-30 用于高速缓存一致性协议的方法、装置及系统
US12/226,793 US8185700B2 (en) 2006-05-30 2006-05-30 Enabling speculative state information in a cache coherency protocol
DE112006003917T DE112006003917T5 (de) 2006-05-30 2006-05-30 Verfahren, Gerät und System angewendet in einem Cachespeicher-Kohärenzprotokoll
PCT/ES2006/070074 WO2007138124A1 (es) 2006-05-30 2006-05-30 Método aparato y sistema aplicado en un protocolo de coherencia de una memoria cache

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
PCT/ES2006/070074 WO2007138124A1 (es) 2006-05-30 2006-05-30 Método aparato y sistema aplicado en un protocolo de coherencia de una memoria cache

Publications (1)

Publication Number Publication Date
WO2007138124A1 true WO2007138124A1 (es) 2007-12-06

Family

ID=38778149

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/ES2006/070074 WO2007138124A1 (es) 2006-05-30 2006-05-30 Método aparato y sistema aplicado en un protocolo de coherencia de una memoria cache

Country Status (4)

Country Link
US (1) US8185700B2 (es)
CN (1) CN101449250B (es)
DE (1) DE112006003917T5 (es)
WO (1) WO2007138124A1 (es)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101853188A (zh) * 2009-05-21 2010-10-06 威盛电子股份有限公司 检测载入-储存冲突的方法及其装置

Families Citing this family (39)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9128750B1 (en) * 2008-03-03 2015-09-08 Parakinetics Inc. System and method for supporting multi-threaded transactions
US8316366B2 (en) * 2008-04-02 2012-11-20 Oracle America, Inc. Facilitating transactional execution in a processor that supports simultaneous speculative threading
US7934180B2 (en) * 2008-05-27 2011-04-26 International Business Machines Corporation Incremental speculative merging
US8806145B2 (en) * 2008-11-07 2014-08-12 Oracle America, Inc. Methods and apparatuses for improving speculation success in processors
US8898401B2 (en) * 2008-11-07 2014-11-25 Oracle America, Inc. Methods and apparatuses for improving speculation success in processors
US8392666B2 (en) * 2009-05-21 2013-03-05 Via Technologies, Inc. Low power high speed load-store collision detector
US8468539B2 (en) * 2009-09-03 2013-06-18 International Business Machines Corporation Tracking and detecting thread dependencies using speculative versioning cache
US8751748B2 (en) * 2010-01-15 2014-06-10 International Business Machines Corporation Reader set encoding for directory of shared cache memory in multiprocessor system
US8832415B2 (en) * 2010-01-08 2014-09-09 International Business Machines Corporation Mapping virtual addresses to different physical addresses for value disambiguation for thread memory access requests
US8533399B2 (en) * 2010-01-15 2013-09-10 International Business Machines Corporation Cache directory look-up re-use as conflict check mechanism for speculative memory requests
EP2581834A4 (en) 2010-06-14 2014-12-31 Fujitsu Ltd MULTICULTURAL PROCESSOR SYSTEM, INTERMEDIATE COHERENCE CONTROL PROCEDURE, AND INTERMEDIATE COHERENCE CONTROL PROGRAM
US20110320781A1 (en) * 2010-06-29 2011-12-29 Wei Liu Dynamic data synchronization in thread-level speculation
US8751714B2 (en) * 2010-09-24 2014-06-10 Intel Corporation Implementing quickpath interconnect protocol over a PCIe interface
CN101966102A (zh) * 2010-10-23 2011-02-09 浙江晶皓光电科技有限公司 一种牙具
US20130132962A1 (en) * 2011-11-22 2013-05-23 Microsoft Corporation Scheduler combinators
KR101745640B1 (ko) * 2012-06-15 2017-06-09 인텔 코포레이션 공유 메모리 자원들을 사용하는 메모리 일관성 모델에서 비순차 load들에 대한 로크 기반 및 동기화 기반 방법
KR101996351B1 (ko) 2012-06-15 2019-07-05 인텔 코포레이션 통합된 구조를 갖는 동적 디스패치 윈도우를 가지는 가상 load store 큐
EP2862084A4 (en) 2012-06-15 2016-11-30 Soft Machines Inc METHOD AND SYSTEM FOR IMPLEMENTING RECOVERY FROM A SPECULATIVE TRANSMISSION OF FAULT FORECASTS / ERRORS DUE TO THE CHANGE AND OPTIMIZATION OF MEMORY LOADS
WO2013188754A1 (en) 2012-06-15 2013-12-19 Soft Machines, Inc. A disambiguation-free out of order load store queue
CN104583957B (zh) 2012-06-15 2018-08-10 英特尔公司 具有无消歧乱序加载存储队列的重新排序的推测性指令序列
KR101826399B1 (ko) 2012-06-15 2018-02-06 인텔 코포레이션 Load store 재정렬 및 최적화를 구현하는 명령어 정의
KR101832574B1 (ko) * 2012-06-15 2018-02-26 인텔 코포레이션 모든 store들이 캐시의 모든 워드들에 대한 검사를 스누핑해야만 하는 것을 방지하기 위해 store들을 필터링하는 방법 및 시스템
CN104583943B (zh) 2012-06-15 2018-06-08 英特尔公司 拥有具有分布式结构的动态分派窗口的虚拟加载存储队列
KR101695845B1 (ko) 2012-09-20 2017-01-12 한국전자통신연구원 캐시 일관성 유지 장치 및 방법, 이를 이용하는 멀티프로세서 장치
US9311241B2 (en) * 2012-12-29 2016-04-12 Intel Corporation Method and apparatus to write modified cache data to a backing store while retaining write permissions
WO2014107148A1 (en) 2013-01-03 2014-07-10 Intel Corporation Adaptive data prefetching
US9417974B2 (en) 2013-03-28 2016-08-16 Microsoft Technology Licensing, Llc. Transaction processing for database in persistent system
US20150205721A1 (en) * 2014-01-22 2015-07-23 Advanced Micro Devices, Inc. Handling Reads Following Transactional Writes during Transactions in a Computing Device
US10169103B2 (en) 2014-02-27 2019-01-01 International Business Machines Corporation Managing speculative memory access requests in the presence of transactional storage accesses
GB2533415B (en) * 2014-12-19 2022-01-19 Advanced Risc Mach Ltd Apparatus with at least one resource having thread mode and transaction mode, and method
CN106126451B (zh) * 2016-06-20 2019-01-25 中国航天科技集团公司第九研究院第七七一研究所 基于包含式Cache体系的多核处理器低功耗设计结构
CN106126450B (zh) * 2016-06-20 2018-10-30 中国航天科技集团公司第九研究院第七七一研究所 一种应对多核处理器监听访问冲突的Cache设计结构及方法
US10417129B2 (en) * 2017-05-08 2019-09-17 International Business Machines Corporation Transactional memory operation success rate
US10303603B2 (en) 2017-06-13 2019-05-28 Microsoft Technology Licensing, Llc Low power multi-core coherency
US10282298B2 (en) 2017-06-13 2019-05-07 Microsoft Technology Licensing, Llc Store buffer supporting direct stores to a coherence point
US11169805B2 (en) 2018-04-30 2021-11-09 Hewlett Packard Enterprise Development Lp Dynamic processor cache to avoid speculative vulnerability
US11055221B2 (en) * 2019-03-22 2021-07-06 Samsung Electronics Co., Ltd. Speculative DRAM read, in parallel with cache level search, leveraging interconnect directory
US11550716B2 (en) * 2021-04-05 2023-01-10 Apple Inc. I/O agent
US11803471B2 (en) 2021-08-23 2023-10-31 Apple Inc. Scalable system on a chip

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6122712A (en) * 1996-10-11 2000-09-19 Nec Corporation Cache coherency controller of cache memory for maintaining data anti-dependence when threads are executed in parallel
US6389446B1 (en) * 1996-07-12 2002-05-14 Nec Corporation Multi-processor system executing a plurality of threads simultaneously and an execution method therefor
US20030014602A1 (en) * 2001-07-12 2003-01-16 Nec Corporation Cache memory control method and multi-processor system
WO2004075046A2 (en) * 2003-02-13 2004-09-02 Sun Microsystems Inc. Selectively unmarking of load-marked cache lines during t speculative thread execution

Family Cites Families (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20040123081A1 (en) * 2002-12-20 2004-06-24 Allan Knies Mechanism to increase performance of control speculation
US20040154010A1 (en) * 2003-01-31 2004-08-05 Pedro Marcuello Control-quasi-independent-points guided speculative multithreading
US7657880B2 (en) * 2003-01-31 2010-02-02 Intel Corporation Safe store for speculative helper threads
US20080134196A1 (en) * 2005-05-19 2008-06-05 Intel Corporation Apparatus, System, and Method of a Memory Arrangement for Speculative Multithreading
US7404041B2 (en) * 2006-02-10 2008-07-22 International Business Machines Corporation Low complexity speculative multithreading system based on unmodified microprocessor core

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6389446B1 (en) * 1996-07-12 2002-05-14 Nec Corporation Multi-processor system executing a plurality of threads simultaneously and an execution method therefor
US6122712A (en) * 1996-10-11 2000-09-19 Nec Corporation Cache coherency controller of cache memory for maintaining data anti-dependence when threads are executed in parallel
US20030014602A1 (en) * 2001-07-12 2003-01-16 Nec Corporation Cache memory control method and multi-processor system
WO2004075046A2 (en) * 2003-02-13 2004-09-02 Sun Microsystems Inc. Selectively unmarking of load-marked cache lines during t speculative thread execution

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101853188A (zh) * 2009-05-21 2010-10-06 威盛电子股份有限公司 检测载入-储存冲突的方法及其装置

Also Published As

Publication number Publication date
DE112006003917T5 (de) 2009-06-04
US8185700B2 (en) 2012-05-22
US20090083488A1 (en) 2009-03-26
CN101449250A (zh) 2009-06-03
CN101449250B (zh) 2011-11-16

Similar Documents

Publication Publication Date Title
WO2007138124A1 (es) Método aparato y sistema aplicado en un protocolo de coherencia de una memoria cache
KR101461378B1 (ko) 동기화 ｓｉｍｄ 벡터
US9513904B2 (en) Computer processor employing cache memory with per-byte valid bits
US7552290B2 (en) Method for maintaining atomicity of instruction sequence to access a number of cache lines during proactive synchronization within a computer system
US9513905B2 (en) Vector instructions to enable efficient synchronization and parallel reduction operations
KR100954623B1 (ko) 무한 트랜잭션 메모리 시스템
US6141734A (en) Method and apparatus for optimizing the performance of LDxL and STxC interlock instructions in the context of a write invalidate protocol
US7073026B2 (en) Microprocessor including cache memory supporting multiple accesses per cycle
KR20110050724A (ko) 사용자 핸들러 등록 장치, 프로세서, 시스템 및 방법
US8930636B2 (en) Relaxed coherency between different caches
US9015436B2 (en) Performing an atomic operation without quiescing an interconnect structure
CN104025027B (zh) 结构访问处理器、方法、系统和指令
CN106293894B (zh) 执行事务性功率管理的硬件设备和方法
EP3131018B1 (en) Transaction abort method in a multi-core cpu.
US11620133B2 (en) Reduction of data cache access in a processing system
JP2024502279A (ja) オフロードされた命令とオフロードされていない命令との間のメモリ順序付けの保持
US8601242B2 (en) Adaptive optimized compare-exchange operation
JP2011081662A (ja) 演算処理装置及び制御方法
CN115577402A (zh) 设备之间的安全直接对等存储器访问请求
CN103984671A (zh) 共享的运算对称的、更新敏感的变量
KR101587362B1 (ko) 비교-및-스와핑 기반 방식을 사용하여서 데이터를 조건적으로 저장하는 방법 및 장치
US7975129B2 (en) Selective hardware lock disabling
BRPI0805218B1 (pt) “Aparelho, sistema e método para esquema de omissão de trava por hardware híbrida de retirada prévia-posterior”.
JPH07104834B2 (ja) 処理装置間ロック制御システム
JP2005327086A (ja) 半導体集積回路装置

Legal Events

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

Ref document number: 200680054734.1

Country of ref document: CN

121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 06755387

Country of ref document: EP

Kind code of ref document: A1

WWE Wipo information: entry into national phase

Ref document number: 12226793

Country of ref document: US

WWE Wipo information: entry into national phase

Ref document number: 1120060039172

Country of ref document: DE

RET De translation (de og part 6b)

Ref document number: 112006003917

Country of ref document: DE

Date of ref document: 20090604

Kind code of ref document: P

122 Ep: pct application non-entry in european phase

Ref document number: 06755387

Country of ref document: EP

Kind code of ref document: A1

REG Reference to national code

Ref country code: DE

Ref legal event code: 8607