Interleaved topological sort for low cache miss rate in EMU waveform recovery

Abstract

An apparatus for performing emulation waveform recovery, the apparatus comprising one or more processors being configured to:receive an initial netlist comprising a list of nodes; generate a first node list, representing a first topological order of the initial netlist, by sorting the initial netlist using a first sorting strategy and generate a second node list, representing a first topological order of the initial netlist, by sorting the initial netlist using a second sorting strategy; iteratively propagate signals through the initial netlist based on the first node list and the second node list; wherein the one or more processors are configured to alternate between the first node list and the second node list for each new iteration.

Description

INTERLEAVED TOPOLOGICAL SORT FOR LOW CACHE MISS RATE IN EMU WAVEFORM RECOVERYFIELD OF THE INVENTION

[0001] This invention relates to an apparatus and method for performing emulation waveform recovery by traversing a raw netlist.BACKGROUND

[0002] At the early stage of chip design, the desired behaviour of the chip is defined at register-transfer-level (RTL) . It is important to check that the behaviour described in the register-transfer-level matches the expected behaviour of the chip designer, as this high-level representation will be used to derive lower-level representations leading to the final product.

[0003] Emulation (EMU) for waveform recovery is a widely used technique for debugging and verification, and allows to ensure that the functionalities of the design specified as register-transfer-level has the desired behaviour. To perform emulation, the design or netlist is flattened and implemented on a hardware such that the propagation of the input signals through relevant ports can be simulated and tracked and the waveform observed.

[0004] Emulating can be slow for large designs, as it involves the sequential computation of traversing the same graph repetitively. When going through the logic graph, data needs to be retrieved (state of the signal, list of fanins, …) , and that data is either stored in the cache memory (which should be understood as a cache hit and the data transfer is fast between cache and the CPU) or the data to retrieve is stored in the main memory (in that case it is a cache miss and the transfer is slow between the main memory and the CPU) . The cache misses induce a transfer time that is a bottleneck in the emulation process, and the technique of this disclosure aims to reduce the cache miss rate defined as the ratio between the number of cache misses and the total number of data retrieval to improve emulation efficiency.

[0005] Some attempts at solving the shortfalls of this approach have been proposed in the art including US 9, 418, 020 B2, which is directed to systems and method for efficient cache utility curve construction. This document discloses an approach that enables determination of reuse-distance to construct accurate cache utility curves using only modest computational resources. In a similar approach, document US 9.405, 686 B2 discloses a novel hash-based spatial sampling method that is used to construct a Cache Utility Curve (CUC) that requires no prior knowledge of the system or its input workload. These approaches however are not applicable to the management of cache misses for EMU waveform computing. US 9, 864, 703 B2 discloses a further approach to computer memory and specifically, to a cache memory having enhanced performance and security features. This is different from a new topological sort strategy for low cache miss rate in EMU waveform recovery of the present disclosure. This approach is not applicable to the management of cache misses for EMU waveform computing.

[0006] A further approach is disclosed in US 8.266, 383 B1, which discloses a technique for providing an L1 cache -a central storage resource for multiple clients with diverse latency and bandwidth requirements. This approach generally relates to data storage itself rather than a specific strategy managing computed values in the EMU waveform recovery process. US 7996622B1 presents a method or system that can avoid the write-before-read hazard without a second FIFO between main memory and cache. Suggested method applicable only for a strategy when a second FIFO is incorporated between main memory and cache. In addition, US10558583B1 discloses a system for managing cache replacements. When the system needs room for a new item, it can evict a page using one of two standard policies: least frequently used (LFU) or least recently used (LRU) . The decision on which one to use on any given eviction is dictated by their weights. These weights reflect what is known about the  best policy to use at any given time and are constantly being adapted as the learning progresses. This is different approach from a topological sort strategy for low cache miss rate in EMU waveform recovery.

[0007] A further approach is disclosed in US 20090210626A1, which includes a method for cache coherency protocol with built in avoidance for conflicting responses in a multi-node system including a plurality of nodes interconnected with each other, each node having a plurality of processors, a cache, a plurality of I / O adapters, a plurality of controllers to perform cache coherent operations, and a main memory. However, this approach is concerned with conflict avoidance rather than cache misses.

[0008] One approach for reducing cache miss rate using prediction caches is presented by J.E. Bennet, M.J. Flynn. Their paper suggests predicting future misses based on the history of recent cache misses, and, therefore its performance specific to a processing task. This paper focuses on linear algebra routines, FFT implementation and it does not graph traversal procedures relevant to EMU computation. A prediction strategy such as this will be problematic due to the size and topological diversity of involved Directed Acyclic Graphs (DAGs) . S. Hu and J. Huang provide an alternate approach in their paper “Exploring Adaptive Cache for Reconfigurable VLIW Processor” . This paper proposes a reconfigurable d-cache framework that can dynamically adapt its least recently used replacement policy without much hardware overhead. However, this approach is not adapted to DAG traversing routines used in EMU waveform computation.

[0009] A further paper “Cache Misses and the Recovery of the Full AES 256 Key” by S. Briongos, P. Malagon, J. M. Moya discloses an approach to exploit the information gained from cache attacks. This paper focuses on cache misses to retrieve the secret AES encryption key. However, such an approach is not an Emulation waveform computation. Alternatively, “Reducing Load Latency with Cache Level Prediction” by M. Jalili, M. Erez proposes a method that predicts which memory hierarchy level will be accessed by a load. This allows the memory loads to start earlier, and leading to speed up in processing. However, this suggested prediction method is not scalable to the sizes of DAGs associated with EMU waveform recovery problem.

[0010] Finally, the paper “Minimizing Cache Misses in Scientific Computing Using Isoperimetric Bodies” by M. Frumkin, R.F. Van der Wijngaart, presents two methods for partitioning structured grid iteration spaces with minimum-surface cache fitting sets. These methods operate on grid structures and heavily exploits the regularity pattern of these grids. DAGs in EMU waveform computing are typically very irregular in their topology and therefore this approach is not suitable for such an application. It is desirable to develop an approach that can overcome at least some of the above issues.SUMMARY OF THE INVENTION

[0011] According to one aspect of this disclosure there is provided an apparatus for performing emulation waveform recovery, the apparatus comprising one or more processors being configured to: receive an initial netlist comprising a list of nodes; generate a first node list, representing a first topological order of the initial netlist, by sorting the initial netlist using a first sorting strategy and generate a second node list, representing a second topological order of the initial netlist, by sorting the initial netlist using a second sorting strategy; iteratively propagate signals through the initial netlist based on the first node list and the second node list; wherein the one or more processors are configured to alternate between the first node list and the second node list for each new iteration. This allows the execution time of programs to be reduced by reducing the likelihood of cache misses.

[0012] The apparatus as described above, wherein the first sorting strategy is a Kahn sorting strategy and the second sorting strategy is a depth first search strategy. This allows for the number of cache misses to be reduced by alternating between sorting strategies.

[0013] The apparatus as described above, wherein the one or more processors are configured to: populate a cache based on a selected node list from the first node list or second node list for each iteration. This generates a cache list as the nodes are traversed.

[0014] The apparatus as described above, wherein the one or more processors are configured to: update the cache at each iteration based on the propagation of signals through the initial netlist based on the node list of that iteration. This provides a means by which the cache may be updated based on the traversal of each iteration.

[0015] The apparatus as described above, wherein the one or more processors are configured to update the cache using a least recently used method or a first in first out method. This allows the updating of the cache to be performed in a logical and efficient manner.

[0016] The apparatus as described above, wherein the one or more processors are configured to: stop the iterative propagation of signals based on a number of timesteps, each timestep representing one iteration. This allows the iterative process to be concluded after a predetermined number of iterations represented by timesteps.

[0017] The apparatus as described above, wherein the one or more processors are configured to, in propagating signals through the initial netlist comprises for each node, receive one or more input signals for each node; process the one or more input signals for each node in the order defined by the selected node list; and generate one or more outputs for each node. This allows for the fanins to be determined during propagation of the signals through the nodes.

[0018] According to a further aspect of this disclosure there is provided a method for performing emulation waveform recovery, the method comprising: receiving an initial netlist; generating a first node list, representing a first topological order of the initial netlist, by sorting the initial netlist using a first sorting strategy and generate a second node list, representing a first topological order of the initial netlist, by sorting the initial netlist using a second sorting strategy; iteratively propagating signals through the initial netlist based on the first node list and the second node list; wherein, in each new iteration, the method comprises propagating signals through the initial netlist based on a different one of the first node list or the second node list that was used in the previous iteration. This allows the execution time of programs to be reduced by reducing the likelihood of cache misses. The method as described above, wherein the first sorting strategy is a Kahn sorting strategy and the second sorting strategy is a depth first search strategy. This allows for the number of cache misses to be reduced by alternating between sorting strategies. The method as described above, further comprising populating a cache based on a selected node list from the first node list or second node list for each iteration. This generates a cache list as the nodes are traversed.

[0019] The method as described above, further comprising updating the cache at each iteration based on the propagation of signals through the initial netlist based on the node list of that iteration. This provides a means by which the cache may be updated based on the traversal of each iteration.

[0020] The method as described above, wherein the method may comprise updating the cache using a least recently used method or a first in first out method. This allows the updating of the cache to be performed in a logical and efficient manner.

[0021] The method as described above, further comprising: stopping the iterative propagation of signals based on a number of timesteps, each timestep representing one iteration. This allows the iterative process to be concluded after a predetermined number of iterations represented by timesteps.

[0022] The method as described above, wherein propagating signals through the initial netlist comprises, for each node, receiving one or more input signals for each node; processing the one or more input signals for each node in the order defined by the selected node list; and generating one or more outputs for each node. This allows for the fanins to be determined during propagation of the signals through the nodes.

[0023] According to a further aspect of this disclosure there is provided a non-transitory computer readable medium having stored thereon a program that when executed by a processor, performs the method as described above. This allows for the method to be implemented by a program.

[0024] BRIEF DESCRIPTION OF THE FIGURES

[0025] The present invention will now be described by way of example with reference to the accompanying drawings.

[0026] In the drawings:

[0027] Figure 1 illustrates an example of a flattened raw netlist at several timesteps;

[0028] Figure 2 illustrates an example of waveforms recovered from the emulation of the raw netlist ‘G’ ;

[0029] Figure 3 illustrates an example algorithm representing the method according to this disclosure;

[0030] Figure 4 illustrates an example algorithm representing a method for measuring the virtual cache miss rate according to the method of this disclosure;

[0031] Figure 5 illustrates an example of cache misses and cache hits when executing a program;

[0032] Figure 6 illustrates an example of inferring the program code used for node traversal when the program code is unknown.DETAILED DESCRIPTION

[0033] An example of emulation for waveform recovery is illustrated in Figures 1 and 2. Figure 1 illustrates an example flattened raw netlist ‘G’ . During emulation, several timesteps (t) are simulated. At each timestep, the signals at P1, P2, …, P5 are propagated through the logic gates a, b, c, d, e, f. The logic gates 101 may be considered nodes. The potential traversal routes through the netlist as well as the topological dependencies of each of the nodes 101 a to f at a first timestep t=1 and how such propagation of signals will impact on the timestep t=2. The two timesteps are separated by the dashed line. As can be seen, the order in which signals may traverse the nodes of the second timestep will be impacted by the speed at which they traverse the nodes of the first timestep. This speed can be reduced by if a cache miss occurs and can lead to a suboptimal traversal of the nodes at the second timestep based on cache misses in the first timestep. Figure 2 illustrates an example of waveforms recovered from the emulation of the raw netlist ‘G’ shown in Figure 1. The states (0 or 1) of the signals at P1, P2 and ‘a’ are shown for the successive timesteps.

[0034] The topological order used for traversing the raw netlist impacts the overall cache-miss rate and, therefore, it effects the overall execution time in waveform recovery.

[0035] The present disclosure seeks to optimise node transversal by alternating between at least two node lists describing topological traversal of the nodes of the system. This may be achieved by switching between two traversal orders when performing emulation instead of fixing the topological order in which the signals are propagated through the raw netlist. The correctness of the method is based on graph theory, as long as topological sorting is applied valid computation of the waveforms can be guaranteed.

[0036] Embodiments of the present disclosure relate to an apparatus and method for performing emulation waveform recovery, the apparatus comprising one or more processors being configured to: receive an initial netlist comprising a list of nodes; generate a first node list, representing a first topological order of the initial netlist, by sorting the initial netlist using a first sorting strategy and generate a second node list, representing a second topological order of the initial netlist, by sorting the initial netlist using a second sorting strategy; iteratively propagate signals through the initial netlist based on the first node list and the second node list; wherein the one or more processors are configured to alternate between the first node list and the second node list for each new iteration.

[0037] The apparatus and method of this disclosure focuses on the order in which the nodes of the raw netlist may be traversed, from one timestep to the other in order to reduce cache misses. At each timestep, the signals at the input nodes may be propagated through the logic graph, which has to be done by traversing each node in a topological order. Nevertheless, the specific topological order in which the nodes are traversed at timestep ‘i’ and at timestep ‘i+1’ does not need to be kept the same. Besides, at the end of timestep ‘i’ , part of the nodes data are still in the cache (the rest is only in the main memory) so when a new traversal begins at node ‘i+1’ , there will be more cache hits if the nodes that are already in the cache are visited (scheduled for traversal) first. Based on this, technique disclosed herein includes interleaving the traversal orders (first and second node lists) to allow starting a new graph traversal “close to where” the previous traversal ended. In other words, the traversal order of the nodes in the next timestep can be adapted based on cache misses from the previous timestep. This disclosure proposes switching between an order coming from Kahn sort and a depth-first-search order at every other step.

[0038] The method implemented by the apparatus of this disclosure can be seen illustrated as algorithm 1 in Figure 3 representing the pseudocode for the method of this disclosure. This algorithm may be implemented in C++ using first sorting strategy ‘sortStrat1’ which may be a Kahn sorting strategy, and using a second sorting strategy ‘sortStrat2’ which may be a Depth First Search. It should be understood however that other sorting strategies could be used in place of one or both of a Kahn sorting strategy and a Depth First Search sorting strategy. It is important to note that the sorting strategies should be different from one another and thus can be alternated achieving a different topological traversal at each timestep. It should also be understood that more than two sorting strategies can be used as part of the method of this disclosure. In such a case in which more than two sorting strategies are employed, the method may cycle through the sorting strategies in a uniform and ordered manner at each timestep ensuring the that the same sorting strategy is not employed in two neighbouring timesteps. Alternatively, where there are more than two sorting strategies, the strategies may be employed in a random order that may change with each timestep so long as the same strategy is not employed two timesteps in a row.

[0039] As illustrated in Figure 3 the method of the present disclosure may comprise receiving an initial netlist, which may be thought of as a raw netlist. The method may also comprise receiving the sorting strategies to be used. Once the sorting strategies have been received each strategy is used to sort the nodes of the initial netlist to generate a node list for each sorting strategy. In the case of two sorting strategies the method may comprise the step of generating a first node list, representing a first topological order of the initial netlist, by sorting the initial netlist using a first sorting strategy and generate a second node list, representing a first topological order of the initial netlist, by sorting the initial netlist using a second sorting strategy. This is described in lines 3 and 4 of algorithm 1 shown in Figure 3.

[0040] Once the first and second netlists have been generated, they can be used to propagate signals through the initial netlist. In other words, the method may comprise iteratively propagating signals through the initial netlist based on the first node list and the second node list. In this step the algorithm shown in Figure 3 decides which of the first node list or the second node list are used for the traversal in each iteration, each iteration representing a timestep as illustrated by line 5 of the algorithm 1. As can be seen in Figure 3 it can be seen that the signals are propagated based on the chosen netlist and the fanin signals may also be  propagated. Once the signals have been propagated through the logic gates (nodes) of in the topological order defined by the generated netlist of that iteration, a further iteration will then begin. At the new iteration, the method comprises propagating signals through the initial netlist based on a different one of the first node list or the second node list that was used in the previous iteration.

[0041] It should be understood that propagating signals through the initial netlist may comprise, for each node, receiving one or more input signals for each node; processing the one or more input signals for each node in the order defined by the selected node list; and generating one or more outputs for each node. This is described in lines 10 to 12 of Algorithm 1 shown in figure 3.

[0042] The iterations from 1 to T in algorithm 1 shown in Figure 3 may continue until such a point that the maximum number of timesteps has been reached. In other words, the method may further comprise stopping the iterative propagation of signals based on a number of timesteps, each timestep representing one iteration. In this way the Algorithm 1 can set stopping criterion for stopping the iterative process. Other stopping criterion may be utilised as would be understood where appropriate.

[0043] In other words, the method of this disclosure may utilise, given a raw netlist, two topological sortings that are initially applied to determine two traversal orders. Then each traversal order may be followed alternately, as part of an iterative process, to propagate the signals through the logic gates of the netlist.

[0044] In addition, to the example method disclosed in Algorithm 1, this disclosure also provides Algorithm 2 which illustrates a way to measure the virtual cache miss rate that is obtained when our method is applied. Note that the virtual cache miss rate of current method which may involve applying the same order of node lists may also be obtained using the same method by setting ‘sortStrat1’ equal to ‘sortStart2’ . Algorithm 2 provides pseudocode for cache miss rate evaluation. Given (e.g. First-in-first-out (FIFO) , or Least-recently-used (LRU) updating methods of the cache, Algorithm 2 demonstrates, in relation to the method of Algorithm 1, where data retrieval may take place during in signal propagation and how the cache may be updated accordingly.

[0045] As signals are propagated through the netlist as part of the method, the method may further comprise populating a cache based on a selected node list from the first node list or second node list for each iteration. An example of the population of the cache can be seen in Figure 5, described later. As can be seen in Algorithm 2 the cache code can be seen as the nodes are traversed in topological order and the fanins of the current node are acquired. The cache may be populated automatically as part of the method when running a program based on which data is read. Algorithm 1 shows the cache being updated in line 13. In some cases, the method may comprise updating the cache using a least recently used method or a first in first out method.

[0046] It should be understood that this is performed as the nodes of the netlist are traversed. As such, the method of this disclosure relates to waveform recovery by propagating the logic signals following different topological sortings, and the acts of caching or updating the cache should be understood as optional features that may be handled by a memory management unit. The memory management unit may form a part of the apparatus of this disclosure or may be provided separately.

[0047] The cache hit and cache miss mechanism according to this disclosure and associated to the execution of a program will now be described in relation to Figure 5. This disclosure aims at increasing the probability that a node queried at the beginning of new traversal will already be in the cache due to the chosen traversal orders.

[0048] Figure 5 provides an example illustration of cache miss and cache hit when executing a program 501. On each of the stages in Figure 5 show on the left the list of nodes to access when executing an example program 501. In the middle of each stage is the list of nodes whose data are already stored in the cache 502, and on the right of each stage is the list of nodes whose data  is stored in the main memory 503. Executing the program 501 would involve sequential retrieval of the data of each of the nodes in the order in which the nodes are traversed based on the topology of the node lists. This would lead to a number of cache hits and cache misses. From stages 1. to 5., the process of accessing the data of node 67 is shown. As node 67 is not in the cache 502 yet, the data of node 67 is first transferred from the main memory 503 to the cache 502. This can be seen in that the program first checks the cache for the data of node 67 in stage 2 and when it finds that it is not there, the program checks the memory 503 of the device in stage 3. In stage 4 the program 501 returns the data of node 67 to the cache 502 from the main memory 503 and reads the data. In doing this data relating to node 450 is removed from the cache 502 to accommodate the data of node 67. This is an example of a cache miss. It is then read from the cache 502 and the program 501 moves on with requiring access to node 45 (steps 6. to 8. ) . As node 45 is already in the cache 502, it is a cache hit, and the time-consuming transfer from main memory 503 to cache is avoided.

[0049] It should be understood that the method of this disclosure may be performed by an apparatus for performing emulation waveform recovery. The apparatus may be comprised of one or more processors that are configured to perform the method steps described herein. Of course, the apparatus described herein for performing the method may be a single apparatus or a distributed apparatus across a network.

[0050] Figure 6 illustrates an example in which the code of the program that is executed is unknown (e.g. competitor program) . In this case it is necessary to infer in which order the data is retrieved by tracking the data transfers happening at cache level. This requires being able to identify which cache elements and transfers are related to the execution of the emulation program, and which are related to other programs running on the machine at the same time. With access to the state of the memory, depending on implementation details, it may be possible to track the order in which raw netlist is traversed in a concurrent method. If when running the competitor emulation program on a set of circuits it is observed that the traversal order alternates at each clock change, then with high probability it can be said that approach utilizes the strategy of this disclosure. The difficulty resides in detecting this pattern as extra cache behaviour can be altered by more than one factor (the order of the traversal) which could blur the pattern that would be necessary to detect.

[0051] As such, the solution implemented by the method and apparatus of this disclosure can be easily deployed as, in some cases, it only requires the application of two topological sorts instead of one at the beginning of the emulation process and to add a new pointer in each node data (in order to know which node should be visited next when the netlist is traversed every other time) . Adopting this technique during set of synthetic experiments it was observed that the cache miss rate can decrease from 30%to 15%leading to significant execution time reduction.

[0052] The applicant hereby discloses in isolation each individual feature described herein and any combination of two or more such features, to the extent that such features or combinations are capable of being carried out based on the present specification as a whole in the light of the common general knowledge of a person skilled in the art, irrespective of whether such features or combinations of features solve any problems disclosed herein, and without limitation to the scope of the claims. The applicant indicates that aspects of the present invention may consist of any such individual feature or combination of features. In view of the foregoing description it will be evident to a person skilled in the art that various modifications may be made within the scope of the invention.

Claims

1.An apparatus for performing emulation waveform recovery, the apparatus comprising one or more processors being configured to:receive an initial netlist comprising a list of nodes;generate a first node list, representing a first topological order of the initial netlist, by sorting the initial netlist using a first sorting strategy and generate a second node list, representing a second topological order of the initial netlist, by sorting the initial netlist using a second sorting strategy;iteratively propagate signals through the initial netlist based on the first node list and the second node list;wherein the one or more processors are configured to alternate between the first node list and the second node list for each new iteration.2.The apparatus according to claim 1, wherein the first sorting strategy is a Kahn sorting strategy and the second sorting strategy is a depth first search strategy.3.The apparatus according to any one of claims 1 to 2, wherein the one or more processors are configured to:populate a cache based on a selected node list from the first node list or second node list for each iteration.4.The apparatus according to claim 3, wherein the one or more processors are configured to:update the cache at each iteration based on the propagation of signals through the initial netlist based on the node list of that iteration.5.The apparatus according to claim 4, wherein the one or more processors are configured to update the cache using a least recently used method or a first in first out method.6.The apparatus according to any one of claims 1 to 5, wherein the one or more processors are configured to:stop the iterative propagation of signals based on a number of timesteps, each timestep representing one iteration.7.The apparatus according to any one of claims 1 to 6, wherein the one or more processors are configured to, in propagating signals through the initial netlist comprises for each node,receive one or more input signals for each node;process the one or more input signals for each node in the order defined by the selected node list; andgenerate one or more outputs for each node.8.A method for performing emulation waveform recovery, the method comprising:receiving an initial netlist;generating a first node list, representing a first topological order of the initial netlist, by sorting the initial netlist using a first sorting strategy and generate a second node list, representing a first topological order of the initial netlist, by sorting the initial netlist using a second sorting strategy;iteratively propagating signals through the initial netlist based on the first node list and the second node list;wherein, in each new iteration, the method comprises propagating signals through the initial netlist based on a different one of the first node list or the second node list that was used in the previous iteration.9.The method according to claim 8, wherein the first sorting strategy is a Kahn sorting strategy and the second sorting strategy is a depth first search strategy.10.The method according to any one of claims 8 to 10, further comprising populating a cache based on a selected node list from the first node list or second node list for each iteration.11.The method according to claim 10, further comprising updating the cache at each iteration based on the propagation of signals through the initial netlist based on the node list of that iteration.12.The method according to claim 11, wherein the method may comprise updating the cache using a least recently used method or a first in first out method.13.The method according to any one of claims 8 to 12, further comprising:stopping the iterative propagation of signals based on a number of timesteps, each timestep representing one iteration.14.The method according to any one of claims 8 to 13, wherein propagating signals through the initial netlist comprises, for each node,receiving one or more input signals for each node;processing the one or more input signals for each node in the order defined by the selected node list; andgenerating one or more outputs for each node.15.A non-transitory computer readable medium having stored thereon a program that when executed by a processor, performs the method of any one of claims 8 to 14.

Images