Patent Application
20220269508
This invention pertains generally to the field of high-performance computing and in particular, to methods and systems for reducing the overhead of prefetch operations for nested loops.
Array-based memory accesses are common in the loops of many benchmarks. However, many benchmarks further include indirect memory accesses which can, in the case of hot loops, can cause misses and memory access latencies. These can significantly impact a central processing unit's (CPU) benchmark performance.
As an illustrative example, an indirect memory access can be illustrated with the following code excerpt:
The above code excerpt contains an outer loop incremented by variable i at lines 001 to 005, and an inner loop, i.e. a nested loop, incremented by variable j, at lines 002 to 004. The x[col_idx[j]] instruction is an indirect memory access, because the x[. . . ] refers directly to col_idx[. . . ], but indirectly to j. If the values of the col_idx[j] array are not sequential, the memory accesses can be difficult to handle for a hardware prefetcher and this is a limitation of the prior art.
A stream, in this patent application, is an array in a loop that is indexed, directly or indirectly, by an induction variable of that loop. Such an array constitutes a stream in that loop, and it can respectively be referred to as a “direct stream” or an “indirect stream”.
Indirect-stream prefetching using a software-hardware co-design, also referred to as “co-designed prefetching” for short, is a technique that can be used to address this issue. The relationship among the arrays and the induction variable of a loop can be passed on to a stream-prefetching unit in the hardware, that can prefetch the col_idx[j] values in time, and then prefetch the x[ col_idx[j] ] values, before the CPU gets to consume it.
The following pseudo-code illustrates how co-designed prefetching can work. It contains an outer loop from lines 010 to 100, and an inner loop, i.e. a nested loop, from lines 060 to 080. With conventional prefetching techniques, stream-handling instructions, used for passing streams information to hardware, can only be placed at the same level as an inner loop. In other words, the inner loop is “wrapped” with the stream-handling instructions. Such stream-handling instructions are represented at lines 020, 030, 040, 050, and 090.
There are many cases where the trip-count of an inner loop is small, but the trip-count of an associated outer loop is comparatively larger. Consequently, the stream-handling instructions, such as streamOpen and streamClose in the preceding example, can cause an overhead so high that the potential gain by prefetching is significantly reduced, and in some cases, it can even be lost altogether. The amount of overhead depends on each specific case, but measurements on a cycle-accurate model of a modern out-of-order processor core, for running the symmetric Gauss-Seidel (SymGS) benchmark on a real-world dataset, has shown that such an overhead can include as much as 10% more instructions, and a 52% greater cycle-count.
Therefore, there is a need for methods and/or systems that can obviate or mitigate one or more limitations of the prior art, such as the overhead caused by misses and memory access latencies that can result from frequent indirect memory accesses.
This background information is provided to reveal information believed by the applicant to be of possible relevance to the present invention. No admission is necessarily intended, nor should be construed, that any of the preceding information constitutes prior art against the present invention.
Methods and systems are provided to reduce the overhead of code execution by having stream handling instructions removed from unnecessary iterations. Using a compiler analysis according to embodiments, information linking streams in inner loops with streams of outer loops can be identified, and transferred to hardware units of a prefetcher according to embodiments, using a transfer mechanism. Once the stream linking information has been transferred, the hardware units can prefetch inner stream data and a stream handling instructions can be performed outside an inner loop.
An aspect of the disclosure provides a method of prefetching data called by a stream in an inner loop, the inner loop nested in an outer loop of executable code, that includes: identifying, with a compiler analysis, stream linking information defining how the stream in the inner loop is linked to a stream in the outer loop; transferring the stream linking information from the executable code to hardware units of a prefetcher; and prefetching the data using the stream linking information and the hardware units of a prefetcher. According to some embodiments, an inner loop stream can be a subordinate stream to the outer loop stream, an outer loop stream can be a master stream to an inner loop stream, and stream linking information defining how a stream in an inner loop is linked to a stream in an outer loop can include: a subordinate stream identification; a master stream identification, providing an initial value for the subordinate stream's induction variable: an initial value for the subordinate stream identification's, coming from the master stream's identification; a master stream identification, providing an end value for the subordinate stream's induction variable; and an end value for the subordinate stream identification, coming from the master stream's identification; a subordinate stream being a stream in an inner loop that is changed at each iteration of the outer loop, and a master stream being a stream in an outer loop that can change one of: the initial value of the subordinate stream's induction variable; and the end value of the subordinate stream's induction variable; the base address of the subordinate stream. According to some embodiments, an inner loop stream can be a subordinate stream to an outer loop stream, an outer loop stream can be a master stream to an inner loop stream, and stream linking information defining how a stream in an inner loop is linked to a stream in an outer loop can include: an identification for the subordinate stream, and an identification for the master stream, the identification for the master stream providing a base address for the identification of the subordinate stream. According to some embodiments, a compiler analysis of an executable code can include: identifying an inner stream candidate, being a stream in an inner loop, the inner loop nested in an outer loop; determining whether the inner stream candidate corresponds to a qualified nested loop scenario; identifying the outer stream candidate, being a stream in the outer loop nesting the inner loop; using information from the candidate streams to create a stream dependency tree; identifying stream linking information defining how the inner stream is linked to the outer stream; generating stream handling instructions for an intermediate representation code; inserting the stream handling instructions in the intermediate representation code; where a qualified nested loop scenario is a scenario for which applying a method of an embodiment can reduce the number of times a stream handling instruction is executed. According to some embodiments, the properties of a qualified nested loop scenario can include: an outer loop containing only innermost loops; an outer loop having not previously been selected for a corresponding stream handling instruction to be inserted according to a prefetcher's instruction set architecture; and an inner loop stream being potentially linked to the outer loop stream with information including at least one of: an initial value for an induction variable, a final value for an induction variable, and a base address. According to some embodiments, a compiler analysis of an executable code can further include eliminating a stream in an outer loop, that is not linked to a stream in an inner loop. According to some embodiments, a compiler analysis of an executable code can further include eliminating a stream that is missing required stream linking information. According to some embodiments, a compiler analysis of an executable code can further include compiling the intermediate representation code into code executable by the instruction set architecture of a selected prefetcher. According to some embodiments, a compiler analysis of an executable code can further include eliminating a stream candidate not meeting certain criteria, criteria being: for a stream candidate having an induction variable, containing a loop-invariant start value, a loop-invariant end value, and a loop-invariant increment value; for a stream candidate that is a direct stream, containing a loop-invariant base address; for a stream candidate that is an indirect stream, containing a loop-invariant base address; and having an index, the calculation of which performs types of arithmetic operations that are supported by a prefetcher's implemented arithmetic units. According to some embodiments, transferring stream linking information from an executable code to hardware units of a prefetcher can include: receiving with the prefetcher, executable code containing stream linking information, the executable code having been compiled for the instruction set architecture of the prefetcher; executing the code with the prefetcher; recording the stream linking information from the executable code in a stream configuration table (SCT); reading the stream linking information from the SCT, with a stream prefetch manager. According to some embodiments, transferring stream linking information from an executable code to hardware units of a prefetcher can include, for each stream having stream linking information in the SCT, while an outer loop is being iterated: producing prefetches to bring data to a cache; fetching data from a cache and storing it in buffers; producing a prefetch for each iteration of the loop. According to some embodiments, transferring stream linking information from an executable code to hardware units of a prefetcher can include, for each stream having stream linking information in the SCT, while an inner loop is being iterated: reconfiguring an inner loop stream prefetcher using the stream linking information; prefetching for arrays in the inner loop until all iterations are completed. According to some embodiments, transferring stream linking information from an executable code to hardware units of a prefetcher can be performed through a mechanism available with the instruction set architecture (ISA) of the processor incorporating the prefetcher.
An aspect of the disclosure provides a hardware system that can include: a co-designed prefetcher frontend operative to: receive an executable code containing stream linking information, the executable code having been compiled for the instruction set architecture of the co-designed prefetcher; execute the code; record the stream linking information from the executable code in a stream configuration table (SCT); and a stream engine unit containing: a stream configuration table (SCT) in which to record stream linking information from the executable code, and having a field for inner loop streams to stay pending for values from an outer loop stream; and a stream prefetch manager containing: buffers for storing data of an outer stream, and a nested streams control unit operative for: reconfiguring an inner loop stream, and prefetching for arrays in the inner loop until all iterations are completed.
Methods and systems according to embodiments can allow stream-handling instructions to be added at the level of an outer loop, instead of an inner loop, such that the stream-handling instructions are not unnecessarily iterated in a loop. As such, embodiments can completely remove the overhead associated with co-designed prefetching techniques of the prior art.
Using embodiments, prefetching can be performed for short inner loops that are costly for software prefetchers, as well as for inner loops that are too short for hardware prefetchers to capture.
Further, embodiments can allow a prefetching engine, also referred to as a stream-engine unit, to run ahead of a processor core, and start the prefetching of inner loop arrays corresponding to future iterations of an outer loop. This goes beyond the capabilities of conventional hardware prefetchers because by design, conventional hardware prefetchers can only learn and repeat memory accesses after having observed them, and this inherently renders them unable to adapt to future sequences of an inner loop.
An array of an inner loop, an induction variable of an inner loop, or both, can be reconfigured at each iteration of an outer loop. This can occur for example while an embodiment is executing the symmetric Gauss-Seidel (SymGS) benchmark, or the PENNANT benchmark, PENNANT being an application operating on unstructured, finite element meshes with arbitrary polygons. But such reconfiguration can also be performed with many other applications. Using an embodiment, the relationship between the arrays in an inner loop and the arrays outside the inner loop, but inside an outer loop, can be identified during a compiler's code analysis, which is performed as part of the process of translating a source code into the machine code of a selected system. This part of a compiling process can generally be referred to as a compiler analysis. An instruction, or another mechanism, for passing inner loop-outer-loop relationship information to hardware can then be introduced, and using an appropriate extension of the processor's micro-architecture, that additional information can be used when generating prefetches. Following these steps, stream-handling instructions can be executed at the outer loop level, instead of the inner loop level, while prefetching can still be covered for both the outer and the inner loops. As a result, not only can the overhead be removed altogether, but a prefetching unit can be enabled to prefetch for future executions of the inner loop. These capabilities are beyond the reach of currently existing hardware prefetchers.
A software part of an embodiment can be illustrated with the following pseudo-code, which would apply to the previous example code discussed. Line 180, which is a stream-handling instruction, is written at the level of an outer loop (i.e. lines 190-230), instead of an inner loop (lines 200 to 220), and this is allowed by a method of an embodiment.
The following is an example of source code from the SymGS benchmark, for which an embodiment can be implemented. Lines 220, 230 and 240 are code in the outer loop (lines 210 to 330), that can reconfigure streams in the inner loop (lines 270 to 300).
In an embodiment, a master stream is a stream in an outer loop that can change one of the following items in an inner loop.
In an embodiment, a subordinate stream is a stream in an inner loop that is changed at each iteration of the outer loop. As with a master stream, an induction variable and any direct or indirect stream in an inner loop, can be a subordinate stream.
A master-subordinate relationship between an outer loop stream and an inner loop stream can be referred to as “stream-linking information” and the act of passing stream-linking information from software to hardware can be referred to as a “linking of streams”. Embodiments can address the following points:
For removing the overhead caused by unnecessary reiterations of stream-handling instructions, embodiments can insert the stream-handling instructions at the outer loop level, without inserting it at the inner loop level. Thus, embodiments include a system that can mimic the execution of an inner loop, and when the execution of the inner loop is complete, the system can automatically renew the subordinate streams for prefetching.
In embodiments, such execution and renewal can be performed by an additional run-ahead prefetcher in a hardware unit, rather than by software execution with the CPU.
An embodiment can include any number of the following elements:
In an embodiment of co-designed stream prefetching, the lifecycle of each stream can be composed of three parts: opening the stream, stepping the stream, and closing the stream.
For a master stream and a subordinate stream, a stream lifecycle can be as follows.
For a master stream, the data elements are quickly needed for reconfiguring subordinate streams. Therefore, the data elements are kept in in-hardware buffers of an embodiment, that can be called headVal[]. A lifecycle can correspondingly change as follows:
For a subordinate stream, configuration data can come from one or more master streams. This data can include an initial value and an end value for a subordinate stream's induction variable, as well as base addresses for subordinate direct streams or subordinate indirect streams.
The above concepts of “opening”, “stepping” and “closing”, when referring to a “master stream” or a “subordinate stream”, can allow a high-level description of a system's mechanics and operation according to embodiments, as well as the benefits these can provide.
In an embodiment, a mechanism can allow stream linking information to be transferred to hardware. Different instruction set architecture (ISA) make available different mechanisms to choose from, but whether a separate new instruction is added to the ISA 180, or another mechanism is used, the mechanism transferring the stream linking information from the executable code to hardware units of a prefetcher can be performed through a mechanism available with the instruction set architecture (ISA) of the processor incorporating the prefetcher, and can be referred to as a “streamLink” mechanism, which refers to instructions for a stream-linking information transfer mechanism.
In an embodiment, a streamLink mechanism can allow the configuration data of the streams in a subordinate, inner stream tree to get updated, from streams in a master, outer stream tree. The renewal time, also referred to as the reconfiguration time, can be when the base stream of a subordinate stream tree finishes its current iteration. Consequently, the subordinate stream tree can be renewed, and start over without additional software instructions.
In an embodiment, hardware 175 can be instructed as to which master stream is linked to which subordinate stream, so that when a subordinate stream is being opened or renewed, the hardware 175 can know from which stream it should get the new configuration data.
In an embodiment, the list of information to be passed from software to hardware can be summarized as follows:
An embodiment can include an interface between software and hardware 180. The choice of an actual mechanism to realize such interface is dependent on the architecture to which an embodiment is to be applied, and even with a given architecture, different design choices are possible, and each possibility has its own distinct overheads and benefits.
An embodiment can include various configurations of choices for mechanisms, including mechanisms having a low runtime overhead, a clear save/restore possibility during context-switches, and/or support for special cases arising upon function calls and thread-switching.
In an embodiment, a mechanism is operative with a Aarch64 processor architecture and the data format in a streamLink mechanism can use model-specific register (MSR) instructions for an AArch64 architecture. The AArch64 architecture is a 64-bit extension for version 8 of the well-known Advanced RISC Machine architecture (ARM V8). The instructions employed can be MSR instructions, which can move an architecture register to a system register. In an embodiment, the architecture register can be “xl” and the system register can be “STRM_CR_EL0”. A command can be as follows:
Embodiments can include a compiler pass 150 as described hereunder. Further, a compiler containing a compiler pass as described hereunder can be an embodiment, and a compiler pass can be an embodiment by itself. A task of a compiler pass can be to identify streams and then insert specific stream-handling instructions for transferring information about the streams to a stream engine unit (SEU), as well as instructions for configuring an automated prefetching.
In embodiments, a compiler pass can identify master and subordinate streams, and the stream linking information that relates them. A compiler pass can also hoist base addresses from an inner loop to an outer loop. A compiler can also generate streamLink instructions.
Once a stream candidate of the innermost loop is identified, the compiler can determine whether the inner stream candidate is corresponds to a qualified nested loop scenario 310. In an embodiment, a nested loop scenario can be qualified 310 if the following conditions are true:
If the nested loop scenario is not qualified, a work flow can proceed to construct a stream dependency tree 315 from only the stream candidates of an innermost loop.
In the case where a nested loop nested loop is qualified, the outer loop nesting the inner loop can be identified and analyzed for further stream candidates 320. Information from the candidate streams can then be used to create a stream dependency tree 325.
During the construction of a stream dependency tree, whether the scenario is for a nested loop or not 310, a tree structure can be created, based on the identified stream candidates. At this stage, if certain criteria are not met, some candidates can be removed. Such criteria can include:
When a stream candidate is removed due to criteria being unmet, a sub-tree, whose root is this stream itself, can also be removed. The potential distinction between the cases of a nested loop being qualified or not 310, is the number of induction variable streams, because if a nested loop is indeed qualified, the outer loops and inner loops all have induction variables of their own.
In the case of a qualified nested loop 310, once a stream tree is formed 325, a compiler pass can identify stream linking information defining how an inner stream is linked to an outer stream 330. This can create internal data structures for recording the dependency information between the output values of outer streams to:
Once stream links are identified 330 and stream linking information defining how a stream in the inner loop is linked to a stream in the outer loop, any direct stream in the outer loop that is not linked to an inner stream, can be eliminated 335 from the stream tree, because from experiments, these streams tend not to bring any benefit to computing performance.
In another step, a stream dependency tree can be stripped down further. Because instructions specific to an ISA must be inserted at the beginning of an outer loop, stream linking information, such as initial values, end values, base addresses, etc., is required at the insert point. Therefore, if such required stream linking information is missing, or if it cannot be made available by inserting additional instructions in an intermediate representation (IR), then the stream and the sub-tree starting from the stream can be eliminated 340.
As final steps, a compiler pass according to an embodiment can generate ISA-specific stream handling instructions through an IR code 345, based on a stream tree, and insert those instructions into the IR code. In a nested loop scenario 310, the insert point is the preheader of an outer loop. Otherwise 310, the insert point is the preheader of an inner loop. The IR code can finally be compiled into code executable by the instruction set architecture of a selected prefetcher
A compiler pass according to an embodiment can provide a systematic and reliable method for identifying streams, their dependency relations, and the links between them. It can also provide the flexibility of being applicable to stream-handling instructions specific to different ISAs, and at different scopes: innermost loops versus outer loops in nested loop scenarios. By doing so, a compiler pass can ensure an optimal utilization of the cache-miss reduction capability a stream engine can offer.
The work flow of a compiler pass according to an embodiment can be based on the results of actual experiments. More specifically, the elimination of unused outer streams 335 can be implemented to further eliminate streams with low or negative returns. As a result, when a compiler pass is selecting for which streams to prefetch, it can be responsive to a rate of return.
Embodiments can include a hardware design for a co-designed prefetching scheme, to which further units can be added, and the further additional units can be an embodiment in itself.
Embodiments of a co-designed prefetcher operative to receive stream linking information from executable code and prefetch stream data using the stream linking information can include the use of at least one of the following units and functionalities:
In an embodiment, a co-designed prefetcher frontend 501 can decode and execute stream-handling instructions (i.e. streamLink instructions including streamOpen and streamClose) 502, and similar mechanisms.
In an embodiment, a stream prefetch manager 525 can store the current values of a master stream's elements, in a buffer for storing data of an outer stream. Therefore, a stream prefetch manager 525 of an embodiment can include a “headValue Buffers” table 535. The length of such a table can be the number of streams supported in a specific implementation. The depth of a buffer can be another implementation choice.
In an embodiment, a subordinate stream can stay pending for values from its master stream. Therefore, an SCT 520 of an embodiment can include a field “pending2init” 540, for inner loop streams to stay pending for values from an outer loop stream.
A stream prefetch manager 525 of an embodiment can include a nested streams control unit 545, which can perform the following operations:
In an embodiment, additional hardware units, as shown in
In
In
Embodiments can include a software-hardware co-design mechanism for supporting prefetching for nested-streams.
Embodiments can include a mechanism for executing stream-handling instructions (streamOpen, streamClose, streamLink) at the outer loop level of a nested-loop structure, instead of executing them at the inner loop level, and can thus prevent some overheads of conventional methods.
Embodiments can include a software-hardware interface mechanism to allow the transfer of passing stream-linking information to hardware units, and such a software-hardware interface can be referred to as a streamLink mechanism.
Embodiments can include a compiler pass for identifying, in an executable code, opportunities for it to be modified as allowed by additional hardware units, and a stream-linking information mechanism, provided by other aspects of embodiments. A compiler including such compiler pass can also be an embodiment by itself.
Embodiments can include a hardware design that includes additional hardware units for supporting a transfer mechanism of stream-linking information, which transfer mechanism can in turn can support other aspects of embodiments and achieve the benefits of reducing overheads.
Embodiments are not bound to a specific ISA and they can be applied to various processor ISAs, including AArch64, RISC V, and others that can be used in high performance processors, or that might be introduced in the future.
Embodiments can reduce power consumption in a mobile CPU in which power-hungry hardware-prefetching mechanisms are expensive to use. An embodiment can be effectively used to improve performance at low monetary and energy cost.
Embodiments have been described above in conjunctions with aspects of the present invention upon which they can be implemented. Those skilled in the art will appreciate that embodiments may be implemented in conjunction with the aspect with which they are described, but may also be implemented with other embodiments of that aspect. When embodiments are mutually exclusive, or are otherwise incompatible with each other, it will be apparent to those skilled in the art. Some embodiments may be described in relation to one aspect, but may also be applicable to other aspects, as will be apparent to those of skill in the art.
Although the present invention has been described with reference to specific features and embodiments thereof, it is evident that various modifications and combinations can be made thereto without departing from the invention. The specification and drawings are, accordingly, to be regarded simply as an illustration of the invention as defined by the appended claims, and are contemplated to cover any and all modifications, variations, combinations or equivalents that fall within the scope of the present invention.
An aspect of the disclosure provides a method of prefetching data called by a stream in an inner loop, the inner loop nested in an outer loop of executable code, that includes: identifying, with a compiler analysis, stream linking information defining how the stream in the inner loop is linked to a stream in the outer loop; transferring the stream linking information from the executable code to hardware units of a prefetcher; and prefetching the data using the stream linking information and the hardware units of a prefetcher. According to some embodiments, an inner loop stream can be a subordinate stream to the outer loop stream, an outer loop stream can be a master stream to an inner loop stream, and stream linking information defining how a stream in an inner loop is linked to a stream in an outer loop can include: a subordinate stream identification; a master stream identification, providing an initial value for the subordinate stream's induction variable: an initial value for the subordinate stream identification's, coming from the master stream's identification; a master stream identification, providing an end value for the subordinate stream's induction variable; and an end value for the subordinate stream identification, coming from the master stream's identification; a subordinate stream being a stream in an inner loop that is changed at each iteration of the outer loop, and a master stream being a stream in an outer loop that can change one of: the initial value of the subordinate stream's induction variable; and the end value of the subordinate stream's induction variable; the base address of the subordinate stream. According to some embodiments, an inner loop stream can be a subordinate stream to an outer loop stream, an outer loop stream can be a master stream to an inner loop stream, and stream linking information defining how a stream in an inner loop is linked to a stream in an outer loop can include: an identification for the subordinate stream, and an identification for the master stream, the identification for the master stream providing a base address for the identification of the subordinate stream. According to some embodiments, a compiler analysis of an executable code can include: identifying an inner stream candidate, being a stream in an inner loop, the inner loop nested in an outer loop; determining whether the inner stream candidate corresponds to a qualified nested loop scenario; identifying the outer stream candidate, being a stream in the outer loop nesting the inner loop; using information from the candidate streams to create a stream dependency tree; identifying stream linking information defining how the inner stream is linked to the outer stream; generating stream handling instructions for an intermediate representation code; inserting the stream handling instructions in the intermediate representation code; where a qualified nested loop scenario is a scenario for which applying a method of an embodiment can reduce the number of times a stream handling instruction is executed. According to some embodiments, the properties of a qualified nested loop scenario can include: an outer loop containing only innermost loops; an outer loop having not previously been selected for a corresponding stream handling instruction to be inserted according to a prefetcher's instruction set architecture; and an inner loop stream being potentially linked to the outer loop stream with information including at least one of: an initial value for an induction variable, a final value for an induction variable, and a base address. According to some embodiments, a compiler analysis of an executable code can further include eliminating a stream in an outer loop, that is not linked to a stream in an inner loop. According to some embodiments, a compiler analysis of an executable code can further include eliminating a stream that is missing required stream linking information. According to some embodiments, a compiler analysis of an executable code can further include compiling the intermediate representation code into code executable by the instruction set architecture of a selected prefetcher. According to some embodiments, a compiler analysis of an executable code can further include eliminating a stream candidate not meeting certain criteria, criteria being: for a stream candidate having an induction variable, containing a loop-invariant start value, a loop-invariant end value, and a loop-invariant increment value; for a stream candidate that is a direct stream, containing a loop-invariant base address; for a stream candidate that is an indirect stream, containing a loop-invariant base address; and having an index, the calculation of which performs types of arithmetic operations that are supported by a prefetcher's implemented arithmetic units. According to some embodiments, transferring stream linking information from an executable code to hardware units of a prefetcher can include: receiving with the prefetcher, executable code containing stream linking information, the executable code having been compiled for the instruction set architecture of the prefetcher; executing the code with the prefetcher; recording the stream linking information from the executable code in a stream configuration table (SCT); reading the stream linking information from the SCT, with a stream prefetch manager. According to some embodiments, transferring stream linking information from an executable code to hardware units of a prefetcher can include, for each stream having stream linking information in the SCT, while an outer loop is being iterated: producing prefetches to bring data to a cache; fetching data from a cache and storing it in buffers; producing a prefetch for each iteration of the loop. According to some embodiments, transferring stream linking information from an executable code to hardware units of a prefetcher can include, for each stream having stream linking information in the SCT, while an inner loop is being iterated: reconfiguring an inner loop stream prefetcher using the stream linking information; prefetching for arrays in the inner loop until all iterations are completed. According to some embodiments, transferring stream linking information from an executable code to hardware units of a prefetcher can be performed through a mechanism available with the instruction set architecture (ISA) of the processor incorporating the prefetcher.
An aspect of the disclosure provides a hardware system that can include: a co-designed prefetcher frontend operative to: receive an executable code containing stream linking information, the executable code having been compiled for the instruction set architecture of the co-designed prefetcher; execute the code; record the stream linking information from the executable code in a stream configuration table (SCT); and a stream engine unit containing: a stream configuration table (SCT) in which to record stream linking information from the executable code, and having a field for inner loop streams to stay pending for values from an outer loop stream; and a stream prefetch manager containing: buffers for storing data of an outer stream, and a nested streams control unit operative for: reconfiguring an inner loop stream, and prefetching for arrays in the inner loop until all iterations are completed.
This application claims the benefit of and priority to U.S. Provisional application Ser. No. 63/153,640 filed Feb. 25, 2021, the entire contents of which are hereby incorporated by reference.
| Number | Date | Country | |
|---|---|---|---|
| 63153640 | Feb 2021 | US |
