Abstract:
A method of verifying a performance model of an integrated circuit is provided. The method comprises the following steps: obtaining statistical request numbers and corresponding latency values of memory access requests; developing functions of latency value based on the statistical request numbers and the corresponding latency values; bringing a random value to one of the functions to retrieve a latency value; and verifying the logic of the performance model using the latency value retrieved in the step above.

Description:
CROSS-REFERENCES TO RELATED APPLICATIONS 
     This Application claims priority to Chinese Patent Application 200910131892.8, filed Apr. 9, 2009. 
     FIELD OF INVENTION 
     The present invention generally relates to a computer-aided design of integrated circuits and, more specifically, to the verification of the performance model of an integrated circuit in a memory latency simulation environment. 
     BACKGROUND OF THE INVENTION 
     When a processor submits a request to a memory device, e.g., a Dynamic Random Access Memory (DRAM), the response from the memory device can be read by the processor after a delay of time, referred to as a “latency.” For example, a processor may issue a read request to a cache memory system; after a period of time, the cache memory system responds by placing the requested data on the bus. The processor can then receive the data from the bus after the latency expires. If the processor attempts to receive the data from the bus before the latency expires, the processor is likely to receive inaccurate and invalid data. Therefore when designing processors, it is crucial to take the memory latency into consideration. 
     In conventional computer-aided designs of processor or other integrated circuits, a lot of man and machine hours are needed to verify that the model of the integrated circuit is correct. For example, an architectural model, typically written by an engineering team, of the integrated circuit is used to define the functional requirements. Then a Register Transfer Level (RTL) model of the integrated circuit is then produced, typically by another engineering team, and the logic or the functionality of the RTL model is verified against the architectural model. Conventionally, the verification is performed with a “fixed latency” model (or so-called simulation environment), in which the memory latency values are set fixed. Actually, the amount of latency can vary depending on several factors, for example, the types of request. The amount of latency can also vary among the same types of request. Therefore, “fixed latency” is not accurate enough for the verification. 
     Based on the foregoing, there is a need for a more accurate and dynamic latency model to perform the verification of an integrated circuit. 
     SUMMARY OF THE INVENTION 
     The present invention is to provide a method of verifying a performance latency model of an integrated circuit and a method of designing an integrated circuit. 
     One aspect of the present invention is to adopt “dynamic latency” in the verification of an integrated circuit. Another aspect of the present invention is to create a new memory latency model for the verification of an integrated circuit. Still another aspect of the present invention is to assign the latency value(s) randomly for the verification of an integrated circuit. Yet another aspect of the present invention is to assign the latency value(s) in a manner related to statistical latency data. 
     In one embodiment, the method of verifying a performance model of an integrated circuit comprises the following steps: obtaining statistical request numbers and corresponding latency values of memory access; developing functions of latency value based on the statistical request numbers and the corresponding latency values; bringing a random value to one of the functions to retrieve a latency value; and verifying the logic of the performance model using the latency value retrieved in the step above. 
     In another embodiment, the method of designing an integrated circuit comprises: writing source code of the integrated circuit, and verifying a performance model, e.g., an RTL model, of the integrated circuit. The later step may further include obtaining statistical request numbers and corresponding latency values of memory access; developing functions of latency value based on the statistical request numbers and the corresponding latency values; bringing a random value to one of the functions to retrieve a latency value; and verifying the logic of the performance model using the latency value retrieved in the step above. 
     In yet another embodiment, the method of dynamically verifying memory latency in an integrated circuit comprises: writing source code of the integrated circuit, and verifying a performance model of the integrated circuit. The later step may further include obtaining statistical request numbers and corresponding latency values of memory access; developing functions of latency value based on the statistical request numbers and the corresponding latency values; bringing a random value to one of the functions to retrieve a latency value; bringing another random value to one of the functions to retrieve another latency value and verifying the logic of the performance model using the latency values retrieved in the steps above. 
     The foregoing and other features of the invention will be apparent from the following more particular description of embodiment of the invention. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       So that the manner in which the above recited features of the present invention can be understood in detail, a more particular description of the invention, briefly summarized above, may be had by reference to embodiments, some of which are illustrated in the appended drawings. It is to be noted, however, that the appended drawings illustrate only typical embodiments of this invention and are therefore not to be considered limiting of its scope, for the invention may admit to other equally effective embodiments. 
         FIG. 1  illustrates a flow diagram of an exemplary method of designing an integrated circuit in accordance with one or more aspects of the present invention; 
         FIG. 2  is a graph showing statistical data according to an embodiment of the present invention; and 
         FIGS. 3   a ,  3   b ,  3   c  and  3   d  illustrate exemplary piecewise linear functions according to one or more embodiments of the present invention. 
     
    
    
     DETAILED DESCRIPTION 
     In the following descriptions, numerous specific details are set forth to provide a more thorough understanding of the present invention. However, it will be apparent to one of skill in the art that the present invention may be practiced without one or more of these specific details. In other instances, well-known features have not been described in order to avoid obscuring the present invention. 
       FIG. 1  illustrates a flow diagram of an exemplary method of designing an integrated circuit, e.g., graphic processor unit (GPU) chip, in accordance with one or more aspects of the present invention. In step  100 , source code for the integrated circuit is written, using a programming language, such as “C++”, and a performance model of the chip in RTL, for example, is created. In the integrated circuit design, RTL description is a way of describing the operation of a synchronous digital circuit. In the RTL design, a circuit&#39;s behavior is defined in terms of the flow of signals (or transfer of data) between the hardware registers, and the logical operations performed on those signals. 
     In step  102 , statistical data such as request numbers and corresponding latency values of memory access are collected to create a memory latency distribution model.  FIG. 2 . illustrates an example of the memory latency distribution model, where the X-axis represents the latency values in terms of clock cycle (Clk) and the Y-axis represents the request numbers. Note that the statistical request numbers and latency values in the present invention could be collected from the historical data of a real system or could be generated from a computer simulation as illustrated in the example shown in  FIG. 2 . Also note that the statistical request numbers may be directed to only one type of request, e.g., read request or write request, or in some embodiments the statistical request numbers could be collected regardless of the type of request. 
     From the statistical data in the example of  FIG. 2 , there are 2,000 requests in total and the latency values of the requests range from 600 Clks to 900 Clks. The whole range of the latency value (e.g., 600-900 Clks) may be further divided into three ranges of 600-700 Clks, 700-800 Clks, and 800-900 Clks. It could be found that there are 300 requests, 15% of the total requests, resulting in a latency value in the first range of 600 Clks to 700 Clks; another 700 requests, 35% of the total requests, causing a latency value in the second range of 700 Clks to 800 Clks; and finally 1000 requests, 50% of the total requests, generating a latency value in the third range of 800 Clks to 900 Clks. Note that in other embodiments, the whole range of latency value may be further divided into any number of equal or unequal “sub-ranges” for different application purposes, and the requests accumulated in a “sub-range” of the latency value and its ratio to the total requests may change accordingly. 
     In step  104 , a predetermined function for each divided range (or sub-range) is developed based on the requests accumulated in the divided range, e.g., one of the ranges of 600-700 Clks, 700-800 Clks, or 800-900 Clks. It is preferable that the predetermined functions are piecewise linear functions, but other continuous or discontinuous, linear or nonlinear, functions which are able to describe the latency distribution could be also adopted in the present invention. 
     In this example, the ratios of the requests in each divided range to the total requests are furthered used to define the segment of the piecewise linear function. For example, while the requests in the first range of 600-700 Clks are 15% of the total requests, the piecewise linear function for the first range of 600-700 Clks is established between the points 0 and 0.15. Next, the piecewise linear function for the second range of 700-800 Clks is established between 0.15 and 0.5, and the piecewise linear function for the third range of 800-900 Clks is established between 0.5 and 1. The exemplary piecewise linear functions are listed as below and illustrated in  FIG. 3   a , wherein the X-axis represents the accumulated ratio of the requests to the total, and the Y-axis represents the latency values in terms of clock cycle (Clk).
 
 Y=X *(700−600)/(0.15−0.0)+600, where  X  is between 0 and 0.15;
 
 Y =( X− 0.15)*(800−700)/(0.5−0.15)+700, where  X  is between 0.15 and 0.5;
 
 Y =( X− 0.5)*(900−800)/(1.0−0.5)+800, where  X  is between 0.5 and 1.
 
     In step  106 , a random value or more random values are selected from a range of 0 to 1 and are brought into the piecewise linear functions listed above as the ratio in X-axis to retrieve the latency value(s) in Y-axis. For example, if the random value is 0.1, which is in the range of 0 to 0.15, then the random value of 0.1 is brought into the first piecewise linear function and a latency value of 666.67 Clks is obtained; if the random value is 0.75, which is in the range of 0.5 to 1, then the random value of 0.75 is brought into the third piecewise linear function and a latency value of 850 Clks is obtained. In this manner, the memory latency for an access could be simulated in a dynamic manner which could be more similar to the real case. In step  108 , one or more retrieved latency values are used in the verification of the logic of the performance model. 
     Note that in step  104  mentioned above, it is not necessary to have the ratio of the requests to the total for the present invention. In some embodiments, the segment of the piecewise linear function could be defined directly by the statistical request numbers, and accordingly the random value is selected from the range of entire statistical request numbers in the step  106 . 
     Also note that the steps  102  to  106  described above may be embodied in a software product, which could be written in a common programming language such as “C++”, and could be executed on a personal computer or a workstation. The software product for performing the steps  102  to  106  could be a standalone product or a functional module to be combined with other module(s) for analyzing the queuing behavior, e.g., in an integrated software product for verification. 
     In another example the statistical data discussed with respect to  FIG. 2 , assume there are 2,000 requests in total and the latency values of the requests range from 600 Clks to 900 Clks. The whole range (e.g., 600-900 Clks) may be divided into two ranges of 600-750 Clks, and 750-900 Clks. It could be found that there are 650 requests, 32.5% of the total requests, resulting in a latency value in the first range of 600 Clks to 750 Clks; there are 1350 requests, 67.5% of the total requests, generating a latency value in the second range of 750 Clks to 900 Clks. 
     In step  104 , two piecewise linear functions are developed based on the requests accumulated in the ranges of 600-750 Clks and 750-900 Clks. Similar to what has been described above, the ratio of the requests in each divided range to the total requests is used to define the segment of the piecewise linear function. For example, while the requests in the first range of 600 Clks to 750 Clks account for 32.5% of the total request numbers, the piecewise linear function for the first range of 600 Clks to 750 Clks is established between points 0 and 0.325. Accordingly, the piecewise linear function for the second range of 750 Clks to 900 Clks is established between 0.325 and 1. The exemplary piecewise linear functions are listed as below and illustrated in  FIG. 3   b.  
 
 Y=X *(750−600)/(0.325−0.0)+600, where  X  is between 0 and 0.325; and
 
 Y =( X− 0.325)*(900−750)/(1−0.325)+750, where  X  is between 0.325 and 1.
 
     In step  106 , if the random value is 0.1, which is in the range of 0 to 0.325, then the random value of 0.1 is brought into the first piecewise linear function and a latency value of 646.15 Clks is obtained; if the random value is 0.75, which is in the range of 0.325 to 1, then the random value of 0.75 is brought into the second piecewise linear function and a latency value of 844.44 Clks is obtained. 
     In still another example of  FIG. 2 , assume there are 2,000 requests in total and the latency values of the requests range from 600 Clks to 700 Clks and from 700 Clks to 900 Clks respectively. It could be found that there are 300 requests, 15% of the total requests, resulting in a latency value in the first range of 600 Clks to 700 Clks; and there are 1700 requests, 85% of the total requests, generating a latency value in the second range of 700 Clks to 900 Clks. 
     In step  104 , two piecewise linear functions are developed based on the requests accumulated in the ranges of 600-700 Clks and 700-900 Clks. Likewise, the ratio of the requests in each divided range to the total requests is used to define the segment of the piecewise linear function. For example, while the requests in the first range of 600 Clks to 700 Clks are 15% of the total requests, the piecewise linear function for the first range of 600 Clks to 700 Clks is established between points 0 and 0.15. Accordingly, the piecewise linear function for the second range of 700 Clks to 900 Clks is established between 0.15 and 1. The exemplary piecewise linear functions are listed as below and illustrated in  FIG. 3   c.  
 
 Y=X *(700−600)/(0.15−0.0)+600, where  X  is between 0 and 0.15; and
 
 Y =( X− 0.15)*(900−700)/(1−0.15)+700, where  X  is between 0.15 and 1.
 
     In step  106 , if the random value is 0.1, which is in the range of 0 to 0.15, then the random value of 0.1 is brought into the first piecewise linear function and a latency value of 666.67 Clks is obtained; if the random value is 0.75, which is in the range of 0.15 to 1, then the random value of 0.75 is brought into the second piecewise linear function and a latency value of 841.18 Clks is obtained. 
     In yet another example of  FIG. 2 , the requests having the latency values in the range of 700 Clks to 800 Clks may be disregarded, so there are 1,300 requests in total and the latency values of the requests range only from 600 Clks to 700 Clks and from 800 Clks to 900 Clks. It could be found that there are 300 requests, 23.1% of the total requests, resulting in a latency value in the first range of 600 Clks to 700 Clks; and there are 1,000 requests, 76.9% of the total requests, generating a latency value in the second range of 800 Clks to 900 Clks. 
     In step  104 , two piecewise linear functions are developed based on the request accumulated in the ranges of 600-700 Clks and 800-900 Clks. Likewise, the ratio of the requests in each divided range to the total requests is used to define the segment of the piecewise linear function. For example, while the request numbers in the first range of 600 Clks to 700 Clks account for 23.1% of the total requests, the piecewise linear function for the first range of 600 Clks to 700 Clks is established between points 0 and 0.231. Accordingly, the piecewise linear function for the second range of 800 Clks to 900 Clks is established between 0.231 and 1. Then the piecewise linear functions are listed as below and illustrated in  FIG. 3   d.  
 
 Y=X *(700−600)/(0.231−0)+600, where  X  is between 0 and 0.231; and
 
 Y =( X− 0.231)*(900−800)/(1−0.231)+800, where  X  is between 0.231 and 1.
 
     Note that these two piecewise linear functions are discontinuous, and the first piecewise linear function may be predetermined inclusive at point 0.231. 
     In step  106 , if the random value is 0.1, which is in the range of 0 to 0.231, then the random value of 0.1 is brought into the first piecewise linear function and a latency value of 643.29 Clks is obtained; if the random value is 0.75, which is in the range of 0.231 to 1, then the random value of 0.75 is brought into the second piecewise linear function and a latency value of 867.49 Clks is obtained. 
     While this invention has been described with reference to the illustrative embodiments, these descriptions should not be construed in a limiting sense. Various modifications of the illustrative embodiments, as well as other embodiments of the invention, will be apparent upon reference to these descriptions. It is therefore contemplated that the appended claims will cover any such modifications or embodiments as falling within the true scope of the invention and its legal equivalents.