TWI356321B - Systems and methods for graphics hardware design d - Google Patents

Description

1356321 " 发明发明: [Technical field to which the invention pertains] The present invention relates to a graphics hardware, and more particularly to a software model used in a graphics hardware design instead of a hardware design for debugging and verification. Method and system. [Prior Art] I In general, the integrated circuit design consists of several stages, using different tools at each stage. Integral circuit designers usually choose one of several programming languages - to write code. Synchronized with the process of writing the code is analog-to-make. During the simulation, the designer executes a simulation tool that tests the design with the code as input. Because the simulation exposes the problem, the designer can edit the code to resolve the problem and then simulate it again. After the simulation phase, the code is translated by the synthesizer into a logical representation of the integrated circuit. The logic representation is then translated by other tools into a physical Φ integrated circuit, for example, it can be translated into a field programmable logic gate array (FPGA), an application specific integrated circuit (ASIC) or a conventional silicon 1C. And other formats. " Integrated circuit designers can choose several types of programming languages. One type can be called hardware design language (HDL), also known as register transfer language (RTLs). The public understands that RTLs languages including Verilog and VHDL^RTLs are considered to be underlying languages because they describe the characteristics of special hardware such as timing and parallel processing. Another type of choice for integrated circuit design languages is high-level languages, including C and C++ (and other phases).

Client's Docket N〇.:S3U06-0029-TW TT’s Docket No:0608D-A41514-TW/Final/Joanne 5 1356321 " Off Language), these languages are usually used to develop software rather than hardware. These software languages allow designers to write higher-level code, which increases the efficiency of the programmer. - However, many of today's popular simulation tools and compositing tools use the HDL language instead of the C or C++ language as input. Therefore, it is necessary for the integrated circuit designer to write the code in C or C++ and then translate it into HDL. Language. This translation process can be done manually or automatically, or manually and automatically. In addition, _ simulation tools and compositing tools that use the HDL language usually do not provide the ability to debug the . . . to enable the hardware designer to easily and efficiently set up the hardware for debugging. For example, these simulation and synthesis tools typically only allow hardware designers or testers to detect data that is populated and extracted from simulation tools and synthesis tools, but they generally do not allow for more specific or detailed debugging and testing of graphic hardware designs. . SUMMARY OF THE INVENTION • One of the embodiments of the present invention describes a tuning and verification system for graphical hardware design. The system includes a scripting engine that translates scripts representing graphics functions into commands that can be processed by the software graphics driver. This soft v-body graphics driver processes this command in the graphics processing unit model. This graphics processing unit model can correspond to the graphics processing unit hardware design to generate at least one graphics box corresponding to the graphics functions in the script. The debug and verification system of the present invention may also include a scripting engine interface for executing commands in the software graphics driver and in the graphics processing unit model.

Client’s Docket No.: S3U06-0029-TW TT's Docket N〇: 0608D-A41 514-TW/Final/Joanne 6 1356321=The script engine can also be used to execute the software graphics driver. This script (4) outlines the debugging resources generated by the wide-frame and the graphics processing unit model. The line of the invention may also include a debugger that provides the ability to debug the graph early. Another embodiment of the invention describes a method of graphical hardware design. This method involves translating a script that represents a hardware design into a command that the software graphics driver can handle. The method of financing may also include processing commands in a software graphics driver and in a graphics processing unit model that represents a graphics hardware design. The method of the present invention may further comprise: generating at least one graphics processing unit frame corresponding to the graphics function in the script. The above and other objects, features and advantages of the present invention will become more <RTIgt; And systems and methods for verifying graphical hardware design. A graphics hardware designer or tester can use the system and method of the present invention to perform an application that includes graphics operations step by step to analyze and locate potential errors in the graphics hardware design. In addition, the user can also use the system and method of the present invention to set a break point in a script representing a graphical component of the software application to further analyze the graphics hardware design user using the system and method of the present invention, and can also utilize at least three execution paths. To generate and analyze graphic boxes or video frames to further test and test graphic hardware design: reference running time and reference grid; ^ test =

Client's Docket N〇.:S3U06-0029-TW D's Docket No:〇608D-A41514-TW/Final/Joanne 7 1356321 Line time, rely on IT device driver and system _ lion gift; or

Please refer to Fig. 1 for the video or graphic frame generated by the user support of the debugging and verification device in the graphic hardware design of the present invention. In the example, the graphical hardware design is an embodiment of an optional system of the system of the present invention. In the present embodiment, the debug and verification system includes an editor 1〇2, which is used to generate a script 1G6 for verifying the B) hardware design. For example, if one wants to verify or analyze a graphical hardware design, the user of the present invention can manually generate a script containing commands 1〇6, the commands being defined in a scripting language, representing graphical operations. The script 106 can also be generated by the script generator 1〇4. Script generator 104 can write or obtain graphics operations from a software application having graphical elements. For example, a software application that uses the Direct3D® or 〇penGL® graphics application software programming interface will include calls to the graphics runtime or graphics application programming interface, which can be written or retrieved, and converted into commands defined by the scripting language. In this case, the script 106 representing the graphics operation of the software application 210 can be converted into the script 1〇6 which can be used in the script engine 108. The software application 210 can be a game software or other software having graphical components. The script 106 generated by the script generator 104 can be edited by the editor so that the user of the system can add, move or change the representative graphics operation.

Client's Docket No.: S3U06-0029-TW TT*s Docket No: 0608D-A41514-TW/Final/Joanne 丄J J厶丄 Threat: The script command. For example, if the evaluation is done with the correctness of =, the user can move == the script 1〇6 generated by the generator 104. 21〇二=:Γ Software application with graphical interface 2〇8 components H), for example. The body application 21. Other elements are also included. However, it should be understood that the various elements are illustrated only as an understanding of the present invention.

The production ' is not intended to limit the invention. In order to display or produce graphics, the software application can include a graphical interface, a graphical interface 214 or a graphical application interface communication to execute an I command to output the ride to a screen or display. The operating system graphics surface 214 is in communication with the software graphics driver 216, which is equivalent to the device driver. In a preferred embodiment, the software graphics = driver 216 is used to interact with the graphics processing hardware 218. Submit to the target

The command of the reliance interface is _ the command specific to the lychee graphics processing hardware. The secondary graphics processing hardware 218 receives commands from the software graphics driver 216, generates data, generates a picture or a video frame 220 to display on a screen or other similar output device, and the graphics processing hardware design differs greatly. But typically: it is associated with the software graphics driver 216' capable of executing commands defined by the standard software application interface, such as the Direct3D® application interface or the penGL8 application interface. The script generator 222 can be from the software application 21 or from the software

^iienf's Docket No.:S3U06-0029-TW s Docket No:〇608D-A41514-TW/Final/Joanne 9 1356321

The graphical component of application 210 acquires or records the command ' to produce graphical content. The script generator 222 can convert these commands into commands in the script 224 that are defined by the scripting language. In one non-limiting embodiment, the script commands of the script δ a can be combined into the following types of at least four command groups: common commands (c〇mmon commands), two-dimensional commands (2D commands) (3D commands) and video commands (video commands). In this non-limiting embodiment, the 'command group' has functions corresponding to the API functions of the software graphics application interface (API). For example, a 'normal command can contain commands that define the version and type of the graphics API used for graphics operations. It can also contain display modes or decisions for graphics operations. It can also contain color quality or density and other properties corresponding to graphics or video frames. It will be understood by one of ordinary skill in the art. In addition, normal commands can also contain commands that define one or more breakpoints in the script or commands that point to script engine 1〇8 to stack debug information to a file, display, or other output device. The debug information can contain information corresponding to the debugging of the graphical hardware design. Normal commands can also contain additional additional commands that are useful for debugging purposes. For example, a command to jump to another point in the script might be useful for user analysis hardware design. In one of the embodiments of the present invention, the normal command provides a jump capability between the maintain state or the abandon state of the renderer. Another exemplary debug command may include commands to display or store debug information into a file. This is useful for the user evaluation graphics hardware. It is useful to show the user the specific information he wants to see during the execution of the script, or just to alert the user to a certain part of the book.

Client's Docket N〇.:S3U06-0029-TW TT’s Docket No:0608D-A41514-TW/Final/Joanne 1356321 points have arrived. In addition, normal commands can also contain commands to clear D, z, s buffers. In addition, commands that display rendered graphics, video frames, or flip boxes can also be included in the scripting language. One of ordinary skill in the art will appreciate that D-buffering is a buffer that contains information pertaining to color data rendering objects, and is also considered a destination &gt; buffer in the art. Those skilled in the art should understand that z-buffer refers to a "depth" buffer, which stores depth information for each primitive. In addition, it should also be understood that the S-slow φ rush refers to the "template" buffer, which stores the template values of each primitive. These buffers are the main storage areas for the 3D rendering results. In addition, the script commands make the graphics processing list Programming of low-level hardware registers in 兀 can provide control of detailed functions in a graphics processing unit (GPU) or GPU replacement model. Two-dimensional commands 'command in three-dimensional commands and video commands and special graphics application programming interfaces The commands are similar, such as special graphics applications, flat-range applications; Direct3D® API or 〇penGL® API. • The skilled person should understand that the above commands vary widely from system to system and depend on the software application. Special graphics APIs or graphical hardware designs used by scripting engines. However, those skilled in the art having graphics A; pi knowledge should be able to know that there are many other unrelated transformations that are within the scope of the present invention. Now, please return to Figure 1, referring to the principle block diagram. As described above, the script 106 used by the system of the present invention can be 1〇2 or editor 104 generates the script generation. 1〇6 script command comprising the corresponding operation pattern defined scripting language, a script may be executed 1〇8 engine. The system provides

Client's Docket No.: S3U06-0029-TW TT's Docket N〇: 0608D-A415 14-TW/Final/Joanne ^56321 Users of this system have a variety of alternative execution paths to verify and analyze the graphical hardware design. These multiple execution paths allow the user to use the graphical hardware design that the user is testing, and also allow the user to use the reference system to generate graphics or video frames for comparison purposes. The script engine 1〇8 translates the scripts 1〇6 representing the graphics operations defined by the scripting language into commands executed by the scripting engine '1〇8' to generate a graphical box, and also allows the system user to analyze and debug the frames used to generate the frames. Graphic hardware design. _ Scripting Engine 1 8 may also include a user interface, allowing the user to visually interact with script engine 108 and/or control scripts through a keyboard, mouse or other input device, or through a display or other output device. Engine 108. User interface 110 also allows scripting engine 1 8 to display the results of at least one of the execution paths to the user. The user interface 110 can also allow the user to compare the results of at least two execution paths to analyze the graphical hardware design. The system of the present invention may also include a scripting engine interface 114 that allows the scripting engine 108 to execute scripts 1 through 6 through the graphics device driver 118, which is in the form of a scripting language, representing graphical hardware design. In other words, the script ^ interface Π 4 can translate the script (10) into a (four) device-driven format 'because it may be necessary to include the command that is defined by the script language s as the graphics processing unit : The device driver call in the model of the open = unit and the subsequent call = 114 can be implemented in a variety of ways, depending on this

The device driver 118 used is different from the graphics processing unit model i22 because the system can be used by the Chenrs Docket N〇.:S3U06-0029-TW s 〇cket No:0608D-A41514-TW /FinaJ/J〇anne 12 1356321 Set to perform different device drivers and models. The system of the present invention can include a graphics processing unit model 122. The graphics processing unit model 122 may be a software model representing the hardware design of the graphics processing unit, allowing the designer or tester to analyze and verify a particular hardware design without having to create a physical graphics processing unit specifically for testing purposes. . As mentioned above, hardware designers can create graphical hardware designs using the Hard Description Language (HDL). Those skilled in the art will appreciate that a hardware design expressed in a hardware description language can be translated into a model of this design, which can be designed in a programmable language, such as the C language or other similar language, allowing the designer to be hard. The body is designed to create a working software model. Using these models in the architecture of the system of the present invention, a working graphics system can be created that can generate graphics or video frames for testing and verification purposes. For example, it is well known that logic gates described in hardware design languages can be translated into higher-order languages such as C to create hardware-designed models that can be modeled and tested. Such a model is referred to in the art as a "C-model," indicating that the programming language used to create the model of the graphical hardware design is C. It is also known that the device driver 118 is typically a software component that facilitates the operating system. Communication between the graphics subsystem and the graphics hardware. In the system of the present invention, the device driver can also be analyzed and debugged through the interaction of the scripting engine interface 114 and the graphics processing unit model 122. The graphics processing unit model 122 is simulated The hardware graphics handle the single function, so it can produce graphics, video frames or GPU images 128,

Client s Docket No TT’ — ·

r» υ . χτ 1N〇 :b3U06-0029-TW

Docket N〇:〇6〇8D.A415147wWinai/j〇anne 13 1356321 They can be displayed to the user through the user interface 110. In other words, graphics processing unit model 122 can generate GPU image 128 representing commands executed in script 106 by script engine 108 in script processing unit model 122 via script engine interface 114 and device driver 118. The GPU image 128 can be analyzed by the user of the system of the present invention through the user interface 110 or other tools. Additionally, the user interface 110 can be used to scale the generated image for more detailed analysis. A user of the system of the present invention can analyze the generated GPU image 128 to test or verify the graphical hardware design represented by the graphics processing unit model 122, which is translated from the HDL design. Additionally, because the graphics processing unit model 122 is described in a programmable language, such as the C language, those of ordinary skill in the art will appreciate that tracking information or other debug data will be generated and retrieved for analysis during execution of the script. In particular, in the process of testing and validating the design, information that uses data from some hardware design components will be acquired and analyzed, which is useful for debugging. In addition, users of the system may choose to display certain tracking information through the user interface 110. The system of the present invention includes a reference runtime 112 that communicates with the script engine 108 and receives commands from the script engine 108 to process the script commands. The user of the system selects to use the reference runtime 112 to execute the script 106. In one non-limiting embodiment, reference runtime 112 may include: a runtime provided by a software vendor, such as Direct3D® runtime. The system also includes a reference driver 116, which is a reference software driver for the graphics driver.

Client's Docket No.: S3U06-0029-TW TT's Docket No: 0608D-A41514-TW/Final/Joanne 14 1356321 • Those skilled in the art will understand that 'reference drive 116 can be used between the application and the model that represents the hardware design. The interface can also validate features defined by the graphical specification. In addition, the reference drive 116 can provide a baseline of performance analysis or performance goal summary for a graphical hardware design. Reference drive 116 can communicate with graphics processing unit model 122 such that graphics processing unit model 122 generates reference drive image 126 or reference drive frame, &quot; with script 106, at script engine 108 and reference runtime 112, and reference The command corresponding to the generation of the parameters by the graphics processing unit model 122 under the guidance of the driver 116 corresponds. Thus, the user of the system can analyze and verify the design of the device driver 118 using a video or graphics frame produced by the reference driver in the same hardware design. The user can also analyze the tracking information 130, and the resulting reference drive image 126' can also cause the transmitted image 126 and tracking information 130 to be displayed through the user interface 110. The user can also compare the reference drive image 126 and the GPU image 128, or perform scaling, rotation or other operations on the two images through the user interface 11 to test and verify by analyzing the image generated by the system. Design of device drivers and graphic hardware designs. The system also includes a reference gate 120 capable of rendering a video or audio frame, or a rendered reference image I26 that communicates with the reference gate 120 via reference runtime 112 based on commands in the script '106. The software vendor or the creator of the graphical application programming interface can provide a reference gate 12 as a reference tool for graphics hardware designers such as Direct3D® or OpenGL® graphics API. The reference gate 120 can also be created independently, and the graphics API provides the functionality created. The reference grid 120 is a typical tool implemented in software.

Client's Docket No.: S3U06-0029-TW TT's Docket No: 0608D-A41514-TW/Final/Joanne 135.6321 Analog reference hardware implementation, but typically does not have the necessary operating characteristics required by the market, nor can it be translated as hard The realization of the body design. Based on the commands in script 106, reference grid 120 can generate reference image 124 for communication via reference runtime 112. The user may wish to view and verify the execution of the hardware design or device driver by viewing the reference image through the user interface 110 or comparing the reference image 124 with the reference drive image 126 or the GPU image 128. ^ The system of the present invention provides at least 3 execution paths to execute scripts. The ® user will select a different .. line path through the user interface '\ or by commands embedded in the script. Different execution paths can be processed in parallel, so users can compare the resulting images in parallel through the user interface or based on analytics tracking information. Referring now to Figure 3, in one of the plurality of execution paths, one of the execution paths with bold lines describes the principle block diagram of the system of the present invention. The execution path shown by the bold line is an example of the present invention. Those skilled in the art will appreciate that multiple execution paths can be used to analyze, test, or verify the graphical hardware design represented by the graphics processing unit model 122. The execution path indicated by the bold line describes a line of the system, and the script is executed by the script engine in the device driver 118 and the graphics processing unit model 122. The graphics processing unit represents the analysis required by the user of the system. Verified hardware design. As mentioned above, the typical case is to describe the hardware design in the HDL language, and usually the programming language uses a higher level language, such as C language. Hardware designs described in the HDL language are generally translated into more advanced languages, such as the C language. Designed for hardware

Client's Docket N〇.: S3U06-0029-TW TT's Docket No: 0608D-A41514-TW/Final/Joanne 16 1356321 A translation operation like this can also be used for the metamodel 12 2 . The user will also be able to pass the system test; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Estimated hardware design in the GPU model. : into the analysis and other various application information that can be tested for further steps (10), 114, device driver 118 and representative graphics at the == = = = design of the graphics processing unit model 122, this / body In the hard listener, rpTT country you perform script 106, generate - GPU images! 2 8, it can represent graphics or can be transformed into the graphics through the user interface 11 ^ 仃 析 、 缩放 缩放 缩放 仃 仃 , , , , , , , , , , 。 。 。 。 。 。 。 。 。 。 图形 图形 图形 图形 图形 图形 图形 图形 图形 图形 图形 图形 图形 图形The system can also generate graphically-driven graphics and video multiple times for the user of the system to analyze through the user interface. The corpse is now in Figure 4, which depicts the multiple execution paths of the system. The execution path marked with a bold line describes another frame of the system of the present invention. The ability to generate the reference drive pattern 126. The reference drive pattern 126 represents a graphics or video frame produced by the combination of the reference device driver 116 and the graphics processing unit model 122 representing the hardware design. Thus, the system user can The graphics generated by device driver 118 and the graphics generated by reference device driver U6 verify or analyze device driver 118. As described above, reference device driver 116 may be created by a software provider of graphics (eg, DireceD@AH). Can also be provided by a third-party driver

Client's Docket N〇.:S3U06-0029-TW TT s Docket No:0608D-A41514-TW/Final/Joanne 17 1356321 Drivers for 'third-party drivers are required to operate according to reference specifications and may be lost with hardware provider development The hardware-specific device drives the same high-efficiency stone-like design advantages. The reference drive graphics 126 that are repeatedly generated by the system and the GPU graphics 128 generated by the execution of the third diagram can be compared through the user interface. For example, both the reference drive graphic 126 and the GPU graphic 128 can be scaled, rotated, or otherwise processed so that the user can analyze the correctness of each of the generated graphics. Next, you can perform step-by-step analysis of the resulting graphics to verify and analyze the design and execution of hardware and software device drivers. - Scripting is performed using reference driver 116 and device driver 118, and the execution path indicated by the bold lines in Figure 4 allows the user to analyze the hardware design represented by graphics processing unit model 122. See Figure 5 for an example of another implementation of the system. The path indicated by the bold line allows the user to generate reference pattern 124 with reference run time 112. As noted above, the reference runtime 112 can provide the runtime provided by the software provider of the graphics API (e.g., Direct3D® API). The reference run time 112 can communicate with the reference gate 12, which can generate a video or graphics frame in a reference graphical format. As described above, the reference gate 120 is capable of performing graphics operations in accordance with the graphics API, providing a reference or baseline to provide alignment for ensuring the correctness of the hardware design or software device driver. Reference graphic 124 represents a video or graphics frame produced solely by the graphics API and a reference raster representing the reference graphics hardware. Through the user interface 110' the user can compare the reference graphic 124 and the reference drive graphic 126 or

Client's Docket N〇.:S3U06-0029-TW TT*s Docket No:0608D-A41514-TW/Final/Joanne 18 1356321 • GPU graphics 128, which is used to evaluate the hardware represented by device driver 118 or graphics processing unit model 122 Design is useful. For example, the user can zoom, rotate, or otherwise process the reference graphic 124 in the user interface 110, or can be compared to the reference drive graphic 126 or GPU graphic 128 to assist the user in verifying and analyzing the graphical hardware design. Referring to Figure 6, an embodiment of the present invention is described. In this embodiment, the present invention includes a debugger 150 that provides additional functionality to the user. • The debugger 150 can provide the user with the ability to allow further interaction with the scripting engine 108® and the ability to control the execution of the script in the scripting engine 108. For example, debugger 150 can interact with scripting engine 108 to provide the user with the ability to control script execution. For another example, when the user interface 130' is executed, when the bold line or other path indicates the current position of the script, the user can use the debugger 150 to execute the script step by step. Although not specifically described in other figures, those of ordinary skill in the art will appreciate that other embodiments may also include a similar debugger 150 that is in communication with script engine 108. ® In addition, through the user interface 110, the user can control the script 106 - step by step. When analyzing the script 106 and the hardware design or the device driver used by the analysis script 106, the user can choose to have the script 106 execute uninterrupted or continue to perform step by step. For example, if script 106 uses graphics processing unit model 122 or device driver 118 such that the resulting box does not meet expectations, the user can use debugger 150 to determine which script command caused the failure. In this way, the user can better understand which part of the hardware design or device driver 118 is causing a failure.

Client’s Docket No...S3U06-0029-TW TT’s Docket No:0608D-A41514-TW/Final/Joanne 19 1356321 In addition, the debug H150 can be placed or set to break points through the user interface n script room. When the I break point in the script 1G6 = up, it can be paused or stopped in the script material 1Q8. When the hardware represented by the graphics processing unit modulo pear 122 is determined, or it is expected to be provided at a pure resource (4) break point. Very (four) function. The material, the centering 150 can provide the tracking element mm generated by the unit model 122 to two: two, and the display is displayed to the user. The tracking information 13 can contain the data generated by the _ and # model (2) input to the graphics processing unit 122. The debugger 150 and/or the user interface can display the tracking information 13G, allowing for further operations such as data shelf, and other debugging functions that may be employed. More valuable is that compared with the construction of a hardware G p U and then the test, the present invention uses the interrupt point to make the script 106 _ . _ /- step by step to debug the user interface 110 to observe the chase _130, knife analysis It is better to verify the graphics processing unit model 122. Referring now to Figure 7, the method [4] of the present invention is described. Step 2, obtain the graphics operation in the software application 210 to automatically generate the foot = 106. For example, to generate a graphic or video frame, the 应用 application 21 will send a request to the graphics 作业 of the operating system. These requests can be retrieved to generate scripts 106 processed by scripting engine 108, as described above. 3 'The acquired graphics operation is translated into a script containing script commands. 1 '6 The script commands are defined by the scripting language. In one non-limiting embodiment, script commands are divided into four types: normal commands, two-dimensional commands, two-dimensional commands.

Product 1fnt’s Docket No.: S3U06-0029-TW s D〇cket No: 0608D-A41514-TW/Final/Joanne 20 1356321 Order and video commands. Step 3〇4, the script 106 is derived from the acquired graphics. The Scripting Room contains scripts defined by the scripting language, as described above. The script 1G6 contains commands corresponding to the graphics operations acquired from the body application 210 having the graphic elements. E.g,

The series of graphics operations in the program 210 that constrain the three-dimensional object will be executed in the various execution paths by the 'representation 106 with the chat 106' script or ^ in another embodiment, the user of the present invention manually creates the script 106, Script 106 contains script commands that produce graphics or video frames. Step 306, determining an execution path of the execution script 1〇6. As described above, with reference to the embodiments of Figures 1 through 6, the user can select a plurality of execution paths to analyze and verify the hardware design and/or device driver. For example, the user may choose to execute script 1〇6 in the execution path starting with step 308, including translation script 106. The commands defined by the chat language in the script are translated into a format that can be processed by the software device driver 216. As mentioned above, the script 106 contains script commands defined by the scripting language, and the script commands defined by the scripting language may not be in a format that can be understood by the device driver. Thus the 'script command is converted to the command format generated by the operating system graphics function, and the operating system graphics function responds to functions executed in the graphics API, such as Direct3D® or the 〇penGL® graphics API. Step 310' commands are processed in software graphics driver 216 or device driver 118. As is known, device driver 118 is a software component that allows the operating system or other software application 210 to communicate with the hardware components. Hardware components, such as graphics processing units, may or may not have an operating system knowledge and are used to interact with and perform hardware components.

Client's Docket N〇.:S3U06-0029-TW TT's Docket N〇:0608D-A41514-TW/Final/Joanne 1356321 — Standard communication protocol for operation. In step 312, the command processed by the software graphics driver 216 is executed in the graphics processing unit model 122. As noted above, the graphics processing unit model 122 can be a hardware model of a hardware design that communicates with the software model rather than with a hardware prototype or hardware GPU. This model can be implemented in C or other programming languages by translating hardware designs written in hardware-descriptive language (HDL) into high-level programming languages, such as C. Another alternative embodiment is that some hardware designs implement hardware design in a high-level language such as C, which is not required. • A preferred embodiment of the invention is to create a hard use of this C-model. The working software model of the body design. Because, for example, when debugging needs to be performed, it provides a simpler model operation than the hardware design represented by HDL. When testing and analyzing, it is much easier to manipulate a model represented by a high-level programming language than a model represented by the HDL language, because the higher-order language itself provides better adaptability. In step 314, graphics processing unit model 122 generates a graphics or video frame. The graphics processing unit model 122 represents commands in the script 106, which is processed by the software driver 216 and executed by the graphics processing unit model 122. The resulting graphics or video frames can be analyzed to evaluate the hardware design represented by graphics processing unit model 122 via user interface 110 or other methods known to those of ordinary skill in the art. For example, the user can: analyze whether the generated box is consistent with the expected result produced by the script 106 executed by the script engine 108. The user can check or manipulate the resulting box through the user interface 110 or compare the resulting box to the box produced by another optional execution path.

Clients Docket N〇.:S3U06-0029-TW TT's Docket No:0608D-A41514-TW/Final/Joanne 22 135.6321 Step 316 is the start of another optional execution path. The script 106 translates to a command at step 316, the difference between the present execution path and the path described above is: In step 317, the command is processed by the reference runtime 112. Subsequent to execution step 318, the reference software driver 116 processes the command. As described in the above embodiments of the present invention, the reference software driver 116 can be software driven, without having all the advantages of a hardware design, but is based on a reference graphics API, such as the Direct3D® or OpenGL® graphics API. At step 320, the commands processed by the reference software driver U6 are executed in a graphics processing unit model 122 representative of the hardware design. This execution path uses the graphics processing unit model 122 and the reference software driver 116 to execute the script 106' to enhance the testing and analysis capabilities. Step 322, the command in script 106 is executed by graphics processing unit model 122 after processing in reference software driver 116 to generate a graphics or video frame. Alternatively, the user can compare the block generated in step 322 with the frame generated in step 314 to analyze and verify the hardware or software driven or device driven implementation represented by the graphics processing unit model. Step 324 depicts an alternative embodiment of the present invention for performing an analysis of the graphical hardware design. The way this execution path is provided to the user is to process the script's command in reference runtime 112 and execute this command in reference gate 120. As noted above, the reference run 112 is a software component that is the subject of the art, typically provided by the provider of the software graphics ApI or implemented in accordance with the reference specifications. In step 328, the command processed with reference to run time 112 is executed in reference gate 12A. As described in the above embodiment of the present invention, in step 33, the reference gate 12 can be generated.

Client's Docket No.: S3U06-0029-TW TT's Docket No: 0608D-A41514.TW/Final/Joanne 23 Video or image frame. As is known in the art, reference tearing u = "8 API" is referenced to the graphics processing unit; it is sufficient to generate a graphics or video profile that conforms to the reference specification. H sees the quotient in the development of the hardware process will use the reference gate 12Q = body to provide hardware design and implementation comparison, to know the correctness. Compared with the box in which the user can use the box generated by step 330 with other handles, analyze and verify the hardware design or software driver or device driver generated by the graphics processing single fool. Implementation ^ · Represented now, see Figure 8-Figure, which describes a set of systems, including - "System 12, with two-two bodies: trial and verification martyrdom, such as keyboard or mouse. ;= : User input path... into a node,: 12 is also possible in the network WA\T丄仁疋 is not limited to LAN or = such a burst, used to generate scripts _ script or map = network The way 22 is transmitted from the remote device 24 to the connection between the computer system 24 and the electrical system 12 can be any type of network, such as cat-5, Firewire interface, Spoon, total, ., or other connections. the way. The computer system 12 can also have a chatbook Naga, the CD can contain a script H called the system program 210, to produce a computer ^ 12 contains a memory 3 4, can be used to store a lot of execution 'memory 34 contains a script translation module %, person P, die 38 and frame generation module 4. . The memory% can also be included in other modules of Xu Xi, for example, it can contain script translation module %,

Client's Docket No.:S3U〇6-〇〇29-TW TT s Docket No:0608D-A41514-TW/Final/J〇anne 24 1356321 Script processing miscellaneous 3 8 and box production (4) group 4 (^ submodule. Script A stencil, and 36 readable scripts containing graphical operations (10) translated into software-driven or device-driven drive drivers or device drivers for use in orthopaedic or hardware-like designs Parents. The above-mentioned devices drive the operating system or other software programs and hardware 2: software components to facilitate communication between the hardware. Hard, the hardware can be hardware graphics.

Execution, the script translation module 36 can be the same as the (four) I (four), for example, which of the following - do the execution:, participate in the movement, refer to the "software" component, other carcass components in hardware or hardware design or standard software Modeling interaction. For example, if the script Κ)6 represents (4) the _ (four) line is to be read, the script translation module 36 will put the script command into the singer-lion mode. And if the graphics ship represented by script 106 is processed in the reference run time,

The script translation module 36 will have the county command _ a format that can be recognized by the reference runtime. The script processing module 38 can run the scripts 1〇6 by causing the translated script commands to run in the software driver or device driver. The script processing module 38 controls the operation of the script 1〇6, and may include a debugging function that allows the user to step through the script 1〇6 ’, as well as the script 1.06 interrupt function. For example, 'the user can set a break point in the script 1〇6, and the script processing module 38 can interrupt the execution of the script 106 at this break point' to allow the user to check various materials about the script and continue execution according to the user's request. The script 106.

Client's Docket No.: S3U06-0029-TW TT's Docket No: 〇608D-A41514-TW/Final/Joanne 25 135.6321 The frame generation module 40 can generate an image or video frame according to the execution path selected by the user. The frame generation module can include at least three execution paths, as discussed in the above disclosed embodiments. For example, the frame generation module 40 can include a software-driven or device-driven test execution path and a software module representing a hardware design; it can include a reference device-driven reference drive execution path and software representing the hardware design. Module; can include a reference execution path using a reference run time and a reference gate. The at least three execution paths within the block generation module 40 allow the user to analyze the hardware design represented by the software module, as well as allowing the user to analyze the execution of the software driver or device driver. The block generation module 40 allows one or more execution paths to be used in parallel, so the user can execute the same or similar scripts using multiple execution paths to compare the boxes generated after the execution of these scripts. For example, the user can use the test execution path and the reference execution path to evaluate whether the hardware design and the execution of the software driver produced the expected results associated with the boxes generated by the reference execution path. 0 It should be noted that in some embodiments, the script translation module 36, the script processing module 38, and the frame generation module 40 can be combined into a single module for performing any one of these separate separations. A combination of tasks performed by the module. Thus, any of the modules or sub-modules described herein are not limited to existing separate modules. In fact, all modules can be run individually or in combination, or they can be easily combined into one module. In some embodiments, the user can control the script translation module 36 through the graphical user interface within the user input device 16 and display 14.

Client's Docket N〇.:S3U06-0029-TW TT^s Docket N〇:0608D-A415 14-TW/Final/Joanne 26 135.6321 Script Processing Module 38 and Frame Generation · 4q Parent-- and any-sub-modules , can generate a list of execution instructions of the pull, used to implement 3 - arranged feet, module 36, script processing \:: and 'when the sub-module is implemented by software, can

Close the system or method. The use of or in connection with any computer, the computer readable medium referred to herein may be, but is not limited to, =, optical, infrared, or other physical device or method, and is used to contain or store computer programs for use, or Computer: or method associated. More computer readable media can include (not limited to) examples: secret, portable computer core, random access memory, electrically erasable read-only memory, fiber optics. Figure 9 depicts an exemplary embodiment in which a script translation module 36, a script processing module 38, and a box generation module are run on a computer system: 0 The general 'computer system 12 can include any wired or wireless computing. Devices such as desktops, portable computers, special computers, multi-processor computing devices, mobile phones, personal digital assistants, handheld computers, embedded devices, etc. Regardless of the specifics, computer system 12 can be packaged, for example, memory 34, processing device 42, multiple input/output interfaces 44, network interface device 46, and centralized storage 48, each of which is permeable to each other. The data bus bars 50 are connected to each other. Processing device 42 may comprise any custom or general purpose processor,

Client's Docket N〇.:S3U06-0029-TW TT,s Docket No:0608D-A415]4-TW/Final/Joanne 27 135.6321 Central or secondary processor, macro processor, one or more special application complexes Circuits, multiple digital logic gates, and other well-known electronic devices. Memory 34 may contain non-permanent memory elements (e.g., random access memory (RAM, such as DRAM, SRAM, etc.) or permanent memory elements (e.g., ROM, hard disk, magnetic tape, CDROM, etc.). Memory 34 typically includes operating system 52, one or more applications, emulation systems or emulation programs, and the like. For example, the application can include application specific software 54, which includes a script translation module 36, a script processing module 38, and a frame generation module 40. One of ordinary skill in the art should understand that the memory 34 can include other components and will not be described here for brevity and ease of understanding. The input/output interface 44-bit input and output data provides a number of interfaces. For example, when computer system 12 includes a personal computer, the interface will be user input device 12, such as a keyboard or mouse. When the computer system contains a handheld device (such as a PDA, mobile phone), the interface will be a button or a button, a touch screen, a format, and the like. Display 14 can include a computer monitor or plasma screen or liquid crystal display, and the like. Referring further to FIG. 9, network interface device 46 includes a plurality of y cattle for transmitting and/or receiving data over network 22. For example, network interface device 46 includes a device that can communicate with both the input device and the output device, such as a modem/modem (such as a modem), a radio transceiver (such as a radio frequency RF, a telephone interface, a north-south bridge, a router). , network card, etc.).

Client's Docket N〇.:S3U06-0029-TW TT*s Docket N〇:0608D-A41 5 14-TW/FinaI/Joanne 28 1356321 Although the present invention has been disclosed in the preferred embodiments as above, it is not intended to limit the present invention. The scope of the present invention is defined by the scope of the appended claims, and the scope of the invention is defined by the scope of the appended claims. quasi. BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 is a schematic diagram of an embodiment of the present invention; FIG. 2 is a block diagram of a script generator in an embodiment of the present invention; FIG. 3 is a diagram of the embodiment of FIG. A block diagram of an execution path; FIG. 4 is a block diagram of an alternative execution path of the embodiment of FIG. 1; FIG. 5 is a flow block of another alternative execution path of the embodiment of FIG. Figure 6 is a schematic view of another embodiment of the present invention; Figure 7 is a flow chart of a method for debugging and verifying in a graphic hardware design of the present invention; Figure 8 is a schematic diagram of debugging and verification of a graphic hard body design of the present invention Another flow chart of the method; Figure 9 is a schematic view of another embodiment of the present invention. [Main component symbol description] 102: editor; 104, 222: script generator;

Client’s Docket N〇_:S3U06-0029-TW TT's Docket N〇:0608D-A41514-TW/Final/Joanne 135.6321

106, 224: script; 110: user interface; 114: script engine interface; 118: device driver; 122: graphics processing unit model; 126: reference driver image; 13 0. chasing tribute, 202: data calculation; : event processing; 210: software application; 216: software graphics driver; 220: graphics box; 12: computer system; 16: user input device; 24: remote server; 34: memory; 38: script processing module 42: processing equipment; 46: network interface; 5 0. poor material bus, 54: application of special software. 108: script engine; 112: reference run time; 116: reference drive; 120: reference gate; 124: reference image; 128: GPU image; 150: debugger; 204: input/output; 208: graphical interface; : Operating system graphical interface 218 · · graphics processing hardware; 302 ~ 330: steps; 14 · not fast, 22: network; 28: CD drive; 36: script translation module; 40: frame generation module; : input/output interface; 48: centralized storage; 52: operating system;

Client's Docket No.:S3U06-0029-TW TT's Docket No:0608D-A41514-TW/Final/Joanne 30

Claims (1)

1356321 Case No. 096150827 Revised on July 1, 100, the scope of the patent application: I. A system for debugging and verifying the graphic hardware design, including: a script engine that translates a script representing a graphical function into a numerology = the engine interface, the command is translated as - the device driver can be - the graphics processing unit model, corresponding to the hard carving of a graphics processing unit, the command from the device axis is executed and the graphic frame and the image of the driving test frame are generated. At least one and two testers provide the ability to debug the graphics processing unit model. The script engine allows the user to compare at least two of the following. Less than one reference graphic frame is described in item 1 of design 2. Debug and verify the graphics hardware VIII, ^ test soft _ move 'process this life in the _ processing single city type: the graphics processing unit model is used to produce the corresponding reference drive graphics box of the graphics function in the script. A design (4), the debugging and verification of the graphics hardware described in the above--the graphics processing unit model is in a programmable language. 2 = Please refer to the range of debugging and verification graphics hardware as described in item 1 of the range, including: reference runtime, application interface including graphics operations; and S3U06-0029-TW/〇6〇 SD_A4]5M_Tw/Finaj] 31 a reference grid; wherein the system performs a history, a ray/_ order 'the reference grid generates M. The life in the reference grid. 5. As claimed in the patent field® item 1^^ ° . Design the system, which, and verify the graphics hardware of the script. formula. D allows the user to perform step by step. 6. For the system designed in the fifth application of the patent scope, and in the #, tricky and verify graphics hardware at least - a debug = point device allows the user to set in the script 7. The system designed in the fifth paragraph of the patent application, in which (4) n-shaped hardware test information. The adjustment allows the tenant to analyze the generated adjustment. 8. The system designed according to the scope of the patent application also includes:, & _ and verification graphics hardware generation representative: 一 a software application with graphical components Μ representative The script for the 5H graphics function. Design 9 is designed to debug and verify the graphics hardware described in item 8 of the scope, and the script generates 11 dimorphic operations from the software application to generate the script, which contains the software map opening &gt ; The command to drive. 10. A method for debugging and verifying a graphical hardware design, comprising the steps of: translating a script representing a graphical function into a command processed by a device driver; S3U06-0029-TW/〇6〇8D-A415J4-TW /FinaI-, 32-module and graphics processing in a single-unit script representing graphics hardware design corresponding to at least one graphics processing busy and at least one reference driving frame; at least two of At least one reference frame, the at least one drive frame and the at least one graphics processing unit frame; and an analysis of at least one of the following results based on the result of the comparison step: the graphic hardware design and the device driver the design of. The method for debugging and verifying graphics hard as described in (1) Patent (1), wherein the method further comprises: translating the script into a command processed by a reference software driver; and driving the reference software in the reference The command is processed in the processing unit model; and X generates at least one reference drive box corresponding to the command in the script. The method for debugging and verifying the graphic hardware design as described in the first paragraph of the patent scope includes: The at least one reference drive frame and the at least one graphics processing sapon frame are compared to analyze at least one of: the graphical hardware design and the device driven design. 13. The method of debugging and verifying a graphical hardware design as described in claim 1 further comprising: translating the script into a command processed by a reference gate; processing the command in the reference gate; generating at least A reference box that corresponds to the command in the script. S3U〇6-0029-TW/〇608D.A4i5i4.TW/Fjna|_ 1356321 14. The method of debugging and verifying the graphic hardware design as described in claim 10 of the patent application, further includes: executing the script step by step . 15. The method for debugging and verifying a graphic hardware design according to claim 10, further comprising: generating a debugging message from the graphic processing unit model representing the graphic hardware, and analyzing the debugging information to Verify the graphical hardware design. 16. The method for debugging and verifying a graphical hardware design as described in claim 10 of the patent application, further comprising: setting at least one interruption point in the script; executing the script to the at least one interruption point; analyzing the debug poor And continue to execute the script. 17. The method of debugging and verifying a graphical hardware design as described in claim 10, further comprising: obtaining a request from a software application that performs a graphics operation and converting the request to a command of the software graphics driver, Generate the script. S3U06-002 9-TW/0608D-A4 1514-TW/Final-l 34