# Patent

## Title
Hardware component graph to hardware description language translation method

## Abstract

An HCG to HDL translation method, which can automatically generate VHDL codes. The method reads a hardware component graph (HCG) to find a start node and obtain a corresponding hardware component subgraph of the start node, analyzes all information of the start node to thereby add input and output components and generate a VHDL entity, determines types on all nodes of the hardware component, graph to thereby generate corresponding VHDL components and write associated information in a VHDL architecture, generates corresponding signal connections of VHDL components in accordance with edges of the hardware component graph, and outputs the VHDL entity and architecture to a file in a text form.

## Background
BACKGROUND OF THE INVENTION
1. Field of the Invention
The invention relates to a hardware component graph (HCG) to hardware description language (HDL) translation method and, more particularly, to a hardware component graph (HCG) to Very High Speed Integrated Circuit Hardware Description Language (VHDL) translation method.
2. Description of Related Art
Typically hardware description languages such as VHDL, Verilog cannot directly describe the programming logic and executing the flow of a high-level programming language. Accordingly, the high-level programming language is translated into an activity diagram (AD) defined in a unified modeling language (UML). The AD is a flow description diagram that represents the programming logic and executing flow of a high-level programming language. However, the AD is not associated with physical hardware components and cannot be translated directly into a hardware description language, unless the AD is first translated into a hardware component graph (HCG). Accordingly, components of such a HCG do not have corresponding VHDL components, and the HCG cannot be translated into accurate VHDL codes. Thus, the known method cannot translate a high-level programming language into a corresponding HDL.
Therefore, it is desirable to provide an improved method to mitigate and/or obviate the aforementioned problems.
SUMMARY OF THE INVENTION
The object of the invention is to provide an HCG to HDL translation method, which can automatically generate codes of an HDL.
To achieve the object, a hardware component graph (HCG) to hardware description language (HDL) translation method is provided, in which the HCG includes one or more start nodes and multiple component nodes. The method includes: (A) reading a hardware component graph, wherein the hardware component graph has multiple hardware component subgraphs; (B) finding a start node of the hardware component graph to thereby obtain a corresponding hardware component subgraph; (C) analyzing all information of the start node to thereby add input and output components and generate a VHDL entity, and repeating the analyzing until all start nodes are complete; (D) determining types on all nodes of the hardware component graph to thereby generate corresponding VHDL components and write associated information in a VHDL architecture; (E) generating corresponding signal connections of VHDL components in accordance with edges of the hardware component graph; and (F) outputting the VHDL entity and architecture to a file in a text form.
Other objects, advantages, and novel features of the invention will become more apparent from the following detailed description when taken in conjunction with the accompanying drawings.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a flowchart of an HCG to VHDL translation method in accordance with the invention;
FIG. 2 is a schematic graph of a start node, an end node and a component node in accordance with the invention;
FIG. 3 is a schematic graph of a control path module in accordance with the invention;
FIG. 4 is a schematic graph of a data path module in accordance with the invention;
FIG. 5 is a schematic view of Java codes for an addition in accordance with the invention;
FIG. 6 is a schematic graph of a hardware component device of FIG. 5 in accordance with the invention;
FIG. 7 is a schematic view of a Java adder in accordance with the invention;
FIG. 8 is a schematic graph of an HCG of the Java adder of FIG. 7 in accordance with the invention;
FIGS. 9 to 13 are schematic graphs of modifying the HCG of FIG. 8 in accordance with the invention;
FIGS. 14A to 14G are schematic graphs of translating an HCG into VHDL codes in accordance with the invention; and
FIG. 15 is a schematic graph of a synthesis circuit generated from an output of VHDL codes in accordance with the invention.



DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT
The method of the invention can translate a hardware component graph (HCG) into the Very High Speed Integrated Circuit Hardware Description Language (VHDL). The HCG includes at least one start node and multiple component nodes. FIG. 1 is a flowchart of an HCG to VHDL translation method in accordance with the invention. As shown in FIG. 1, step S101 reads an HCG having multiple hardware component subgraphs.
As shown in FIG. 2, the HCG includes three types of nodes, start node 201, end node 203 and component node 205. A node is connected to another node by a directional edge to indicate that an output port of a source object connects an input port of a target object.
The start node 201 records the information of class name, method name, parameter, local variable, global variable, return type of a Java program, wherein (1) “M” indicates the information of a method, including method name and its modifiers; (2) “R” indicates the information of a return value, including return type, bit size and return name; (3) “P” indicates the information of a parameter, including parameter type, bit size and parameter name; and (4) “L” indicates the information of local variable including local variable type, bit size and local variable name.
The end node 203 indicates that a method is ended, and a variable name to be returned is labeled. When the content of the end node 203 contains a keyword “VOID”, it indicated that no variable is returned.
The component node 205 is a hardware component of register, fork-element, adder or the like. The component node 205 can be grouped by disposition into control path modules and data path modules. Referring to FIG. 3, the control path modules include sequential element (notation “Q”) 301, fork-element (notation “F”) 303, join-element (notation “J”) 305, decoder-element (notation “D”) 307, merge-element (“M”) 309 and micro-operation (not shown).
A Q-element 301 indicates that the hardware corresponding to the Q-element 301 requires performing in sequence. A fork-element 303 indicates that the hardware corresponding to the fork-element 303 requires performing in parallel. A join-element 305 indicates that the hardware corresponding to the join-element 305 sends an output signal only when all associated operations are arrived. A decoder-element 307 indicates that the hardware corresponding to the decoder-element 307 selects an appropriate output signal after decoding. A merge-element 309 indicates that the hardware corresponding to the merge-element 309 merges input signals to output. A micro-operation indicates that the hardware corresponding to the micro-operation executes an expression statement or expression processing.
Referring to FIG. 4, the data path modules include arithmetic logic unit (ALU), compare-element, register-element 441 and constant 451.
The ALU is divided into AND-element (notation “AND2R”) 401, OR-element (notation “OR2R”) 403, XOR-element (notation “XOR2R”) 405, addition-element (notation “ADD”) 407, subtraction-element (notation “SUB”) 409, multiplication-element (notation “MUL”) 421, and division-element (notation “DIV”) 423.
The compare-element is divided into great and small comparison element (notation “CMP”) 431 and equal comparison element (notation “CMPEQ”) 433.
The content of the component node 205 can be represented as follows.
(1) The registers and the constants, which require labels to separate, can be expressed as:
Component_name_variable_name.
(2) The CMP-element 431, the merge-element 309 and the like, which do not require labels, can be expressed directly as:
Component_name.
In addition, the directional edge between the nodes can be expressed as:
source node output port→target node input port.
In FIG. 4, the edge labels are shown.
FIG. 5 is Java codes for a summation operation, and the HCG of which is shown in FIG. 6. As shown in FIG. 6, the uppermost two nodes are the start node 201, which respectively record the Java information of class and method, and the last node is the end node 203, which indicates that the method is ended with a return value request. The other nodes indicate the hardware components of registers, micro-operations, F-elements 303 and ADD-elements 407, and a directional edge between the nodes is used to indicate that an output port of a source object connects an input port of a target object.
Referring again to FIG. 1, step S103 modifies the HCG, for the HCG is not associated with physical hardware components and cannot be translated directly into a VHDL language. Thus, the components defined in the modified HCG and the VHDL language can match to each other. An example is given in the Java adder of FIG. 7, and an HCG corresponding to the Java adder of FIG. 7 is shown in FIG. 8.
Referring to FIGS. 7 to 9, a public method named “test” is first found in accordance with the class information and the HCG, and then an edge labeled “method_name req4p” is formed to connect a class start node to a method start node. In this case, the label on the edge indicates that the public method “test” has an input signal named “test req4p” on a corresponding hardware interface and the input signal is connected to a port named “req4p” at the method start node. Similarly, an edge labeled “ack4p method_name” is formed to connect the method start node to the class start node. In this case, the label “ack4p test” on the edge indicates an output signal named “test ack4p” on the hardware interface, which comes through a final connection from a port named “ack4p” at the method start node.
Each return can send a data and an end signal back to a start node. Accordingly, if a discriminant is found, multiple return values can be received. To overcome this, as shown in FIG. 10, multiple return nodes are merged by storing all return values to be sent in a register containing the name “retMethod_name” (such as the oval nodes “retmethod”), using a merge element “M” to connect a signal line to an end node labeled “return retMethod_name” (such as “Return retmethod”), and eliminating the end node in order to connect the merge node back to the method start node since the end node indicates only a flow end without any meaning in hardware and an acknowledgement is not returned to indicate an execution end in an asynchronous system.
Upon the class information and the HCG, public parameters and return values in the HCG can be found. As shown in FIG. 11, the nodes corresponding to the public parameters and return values found are linked to the class start node, which indicates that the nodes have corresponding hardware interfaces for external signal input and output. For a public parameter, an input signal line labeled “parameter_name w” is connected from the class start node to a register node containing the public parameter, which indicates that data is input from the hardware interface to a register indicated by the register node. In addition, a signal line labeled “ack4p parameter_name” is connected from the register node to the hardware interface, which indicates that an acknowledgement is returned from the register to the hardware interface. For a return value, a signal line is connected from the method start node to a return value register node. Because the port for output is identical to that connected to the class start node, a fork node is used to divide the line connected to the class start node into two, such that one can be connected to the return register node (“RxN_rettestzizi”). Also, the return register node uses a line to connect to the class start node for indicating a return value output labeled “q retMethod_name (“q rettest”)”.
As shown in FIG. 12, the method information is collected from the class information and the in/out edges or lines are collected from the HCG, thereby generating required method call information. The method call information is further used to change the edges in the HCG from the method call node to the method start node to thereby represent the method calls. At processing the edges, one or more multiplexers and demultiplexers are added to control corresponding inputs and outputs.
If multiple registers shown in the HCG have a same label, it indicates the multiple registers are the same. In this case, the registers are merged to form a modified HCG, as shown in FIG. 13.
Step S105 finds a start node of the modified HCG to thereby obtain a corresponding hardware component subgraph (briefly, subgraph). The start node found in step S105 is a method start node. Because the nodes in the modified HCG can be related to the respective VHDL objects, a translation to the VHDL objects can start with the method start node.
Step S107 analyzes the information, of the method start node to thereby add input and output components and generate a VHDL entity, and repeats until all start nodes are analyzed. FIGS. 14A to 14G are the VHDL codes obtained after the translation in accordance with the invention. In FIGS. 14A to 14G, an entity name directs to a method start node, and the edges of the method start node are translated into in/out ports of the entity.
Step 109 determines a type for each node of the modified HCG to thereby generate corresponding VHDL components and write associated information in a VHDL architecture. The VHDL components are generated by a component instantiation. For example, the node “test” in FIG. 13 is translated into a component containing a label “M6_testzIzI” in FIGS. 14A to 14G, and the node “RxN_retAddzizi” in FIG. 13 is translated into a component containing a label “M8_retaddzIzI” in FIGS. 14A to 14G.
Step S111 generates corresponding signal connections of the VHDL components in accordance with the edges of the modified HCG. Step S113 outputs the entity and architecture to a file in a text form, as shown in FIG. 14A to 14G. FIG. 15 is a synthesis circuit generated from an output of the VHDL codes in accordance with the invention.
In view of the foregoing, it is known that the invention modifies an HCG to generate a modified HCG, which can correspond to each VHDL component, such that the modified HCG can be translated into the VHDL codes easily. Thus, the prior problem that the HCG cannot be translated into the accurate VHDL codes is overcome.
Although the present invention has been explained in relation to its preferred embodiment, it is to be understood that many other possible modifications and variations can be made without departing from the spirit and scope of the invention as hereinafter claimed.

## Claims

1. A hardware component graph (HCG) to VHSIC (Very High-Speed Integrated Circuit) hardware description language (VHDL) translation method, the HCG including at least one start node and multiple component nodes, the method comprising the steps of:
(A) reading a hardware component graph, wherein the hardware component graph has multiple hardware component subgraphs;
(B) finding a start node of the hardware component graph to thereby obtain corresponding hardware component subgraphs, and finding start nodes of the corresponding hardware component subgraphs;
(C) analyzing all information of a respective one of the start nodes of the corresponding hardware component subgraphs to thereby add input and output components and generate a VHDL entity, and repeating the analyzing until analyses of all said start nodes are complete;
(D) determining types on all nodes of the hardware component graph and the hardware component subgraphs to thereby generate corresponding VHDL components and write associated information in a VHDL architecture;
(E) generating corresponding signal connections of VHDL components in accordance with all edges of the hardware component graph; and
(F) outputting the VHDL entity and architecture to a file in a text form.

2. The method as claimed in claim 1, wherein the step (A) further comprises the step of:
(A1) translating the HCG into a modified HCG to thereby perform a VHDL translation.

3. The method as claimed in claim 1, wherein the HCG comprises an end node.

4. The method as claimed in claim 1, wherein the HCG is a flow control graph.

5. The method as claimed in claim 1, wherein the HCG indicates a connection relation between hardware components.

6. The method as claimed in claim 1, wherein step (D) applies a component instantiation to generate the corresponding VHDL components.