CN117724804A - Virtual machine instruction set generation method, device and equipment - Google Patents
Virtual machine instruction set generation method, device and equipment Download PDFInfo
- Publication number
- CN117724804A CN117724804A CN202311758043.1A CN202311758043A CN117724804A CN 117724804 A CN117724804 A CN 117724804A CN 202311758043 A CN202311758043 A CN 202311758043A CN 117724804 A CN117724804 A CN 117724804A
- Authority
- CN
- China
- Prior art keywords
- virtual machine
- node
- instruction set
- generating
- machine instruction
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 52
- 238000012545 processing Methods 0.000 claims abstract description 18
- 230000006870 function Effects 0.000 claims description 89
- 230000009471 action Effects 0.000 claims description 10
- 238000004590 computer program Methods 0.000 claims description 4
- 230000006399 behavior Effects 0.000 description 15
- 230000008569 process Effects 0.000 description 15
- 238000010586 diagram Methods 0.000 description 12
- 238000004088 simulation Methods 0.000 description 8
- 238000012360 testing method Methods 0.000 description 8
- 230000007246 mechanism Effects 0.000 description 6
- 230000003993 interaction Effects 0.000 description 5
- 238000006243 chemical reaction Methods 0.000 description 3
- 230000009977 dual effect Effects 0.000 description 3
- 230000007613 environmental effect Effects 0.000 description 3
- 238000005457 optimization Methods 0.000 description 3
- 238000013461 design Methods 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 238000007689 inspection Methods 0.000 description 2
- 239000012528 membrane Substances 0.000 description 2
- 230000008520 organization Effects 0.000 description 2
- 230000008439 repair process Effects 0.000 description 2
- 230000009466 transformation Effects 0.000 description 2
- 241000283070 Equus zebra Species 0.000 description 1
- 230000006978 adaptation Effects 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 230000003542 behavioural effect Effects 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000004422 calculation algorithm Methods 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000004140 cleaning Methods 0.000 description 1
- 210000001072 colon Anatomy 0.000 description 1
- 238000005094 computer simulation Methods 0.000 description 1
- 238000012937 correction Methods 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000002452 interceptive effect Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000003058 natural language processing Methods 0.000 description 1
- 238000011160 research Methods 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000000844 transformation Methods 0.000 description 1
- 230000001960 triggered effect Effects 0.000 description 1
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Devices For Executing Special Programs (AREA)
Abstract
The disclosure relates to a method, a device and equipment for generating a virtual machine instruction set. The method for generating the virtual machine instruction set comprises the following steps: acquiring a source code of an automatic driving scene description language; analyzing and processing the source codes of the automatic driving scene description language to obtain a grammar tree; and generating a virtual machine instruction set according to the grammar tree and the instruction format of a preset virtual machine. The scheme of the disclosure can be suitable for various automatic driving scene requirements.
Description
Technical Field
The disclosure relates to the technical field of automatic driving, and in particular relates to a method, a device and equipment for generating a virtual machine instruction set.
Background
The simulation test scene is a main mode for testing the automatic driving safety, and can cover the edge scene which is difficult to meet in the real scene while the concurrency is high, so that the high-quality simulation test scene is more beneficial to finding out the automatic driving safety loophole in a shorter test time. The automatic driving scene engine generates a behavior tree by analyzing the scene description, and further generates a dynamic simulation test scene for interaction. Current autopilot scenario engines are inadequate in terms of domain-specific language programming capability, the instruction set may be too simple to provide enough or detailed instructions to cover all possible scenario requirements, and to meet different autopilot scenario requirements, which results in it being neither convenient nor flexible enough in terms of scenario simulation.
Disclosure of Invention
The embodiment of the disclosure aims to provide a method, a device and equipment for generating a virtual machine instruction set, which are used for adapting to different requirements of automatic driving scenes.
In a first aspect, an embodiment of the present disclosure provides a method for generating an instruction set of a virtual machine, including:
acquiring a source code of an automatic driving scene description language;
analyzing and processing source codes of the automatic driving scene description language to obtain a grammar tree;
and generating a virtual machine instruction set according to the grammar tree and the instruction format of the preset virtual machine.
Optionally, analyzing and processing the source code of the autopilot scene description language to obtain a syntax tree, including:
performing lexical analysis on a source code of the automatic driving scene description language to obtain a target symbol;
and carrying out grammar analysis on the target symbol according to grammar rules to obtain a grammar tree.
Optionally, generating the virtual machine instruction set from the syntax tree according to an instruction format of a preset virtual machine includes:
under the condition that the grammar tree is checked to be correct by utilizing semantic analysis, traversing each node in the grammar tree, and generating a virtual machine instruction set according to the instruction format of a preset virtual machine.
Optionally, traversing each node in the syntax tree, and generating a virtual machine instruction set according to an instruction format of a preset virtual machine, including:
Traversing each node in the grammar tree, and determining the type of each node in the grammar tree;
determining a node function corresponding to the node according to the type of the node;
converting the nodes according to an instruction format of a preset virtual machine and a node function corresponding to the nodes to obtain a virtual machine instruction set; the instruction format of the preset virtual machine comprises the following steps: a preset number of bytes, a preset byte value field, a preset byte meaning, and a preset instruction type.
Optionally, converting the node includes:
determining child nodes according to the nodes;
and calling a node function corresponding to the node according to an instruction format of a preset virtual machine, and converting the node and the child node into a virtual machine instruction set.
Optionally, the method further comprises:
creating a new stack frame for a function in the virtual machine instruction on the stack when the virtual machine instruction in the virtual machine instruction set is executed; the new stack frame contains the local variables, parameters, and return addresses of the function;
when the function is executed and returned, a new stack frame is popped from the stack.
Optionally, the method further comprises:
and generating virtual machine instructions of the scene semantic model according to conditions and actions occurring between scene elements of the automatic driving scene description language.
In a second aspect, an embodiment of the present disclosure provides a generating apparatus for a virtual machine instruction set, including:
the acquisition module is used for acquiring source codes of the automatic driving scene description language;
the processing module is used for analyzing and processing the source codes of the automatic driving scene description language to obtain a grammar tree;
the generation module is used for generating a virtual machine instruction set according to the grammar tree and the instruction format of the preset virtual machine.
In a third aspect, embodiments of the present disclosure provide a computing device comprising: a processor, a memory storing a computer program which, when executed by the processor, performs the steps of the method of generating a set of virtual machine instructions as in the first aspect.
In a fourth aspect, embodiments of the present disclosure provide a computer-readable storage medium storing instructions that, when executed on a computer, cause the computer to perform the steps of the method of generating a set of virtual machine instructions as in the first aspect.
In the embodiment of the disclosure, the grammar tree is obtained by analyzing and processing the source code of the automatic driving scene description language, and then the grammar tree is used for generating a virtual machine instruction set according to the instruction format of a preset virtual machine, so that enough and detailed instructions are provided, all possible scene requirements are covered, and different automatic driving scene requirements are adapted.
Drawings
FIG. 1 is a flow chart of a method of generating a virtual machine instruction set provided by an embodiment of the present disclosure;
FIG. 2 is a schematic illustration of lexical and grammatical analysis of source code of an autopilot scene description language;
FIG. 3 is a schematic diagram of a single length instruction format of a default virtual machine;
FIG. 4 is a diagram illustrating a dual length instruction format of a default virtual machine;
FIG. 5 is a flow chart of a method of generating a virtual machine instruction set in one particular embodiment provided by embodiments of the present disclosure;
FIG. 6 is a schematic diagram of a structure of a 16 byte stack of a base object format;
FIG. 7 is a schematic diagram of a stack with instruction format of 4 bytes;
fig. 8 is a schematic structural diagram of a generating device of a virtual machine instruction set according to an embodiment of the present disclosure;
fig. 9 is a schematic diagram of a hardware structure of a computing device provided to implement an embodiment of the present disclosure.
Detailed Description
Technical solutions in the embodiments of the present disclosure will be clearly described below with reference to the drawings in the embodiments of the present disclosure, and it is apparent that the described embodiments are some embodiments of the present disclosure, but not all embodiments. All other embodiments obtained by one of ordinary skill in the art based on the embodiments in this disclosure are within the scope of the present disclosure.
The terms first, second and the like in the description and in the claims, are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used may be interchanged, where appropriate, such that embodiments of the disclosure may be practiced in sequences other than those illustrated and described herein, and that the objects identified by "first," "second," etc. are generally of the same type and are not limited to the number of objects, e.g., the first object may be one or more. Furthermore, in the description and claims, "and/or" means at least one of the connected objects, and the character "/", generally means that the associated object is an "or" relationship.
The method, the device and the computing equipment for generating the virtual machine instruction set provided by the embodiment of the disclosure are described in detail below through specific embodiments and application scenes thereof with reference to the accompanying drawings.
Fig. 1 is a flowchart of a method for generating a virtual machine instruction set according to an embodiment of the present disclosure, and referring to fig. 1, the method may include the following steps:
step 101, acquiring a source code of an automatic driving scene description language;
Here, the source code of the autopilot description language is a programming or markup language that is specifically used to describe the autopilot, and may be a natural language. A specific example of source code for an autopilot scenario description language is: assuming a simple autopilot scenario description language, the source code may be as follows: this source code describes a scene of driving on a highway where there are two vehicles and defines a "cut-in" event. Form of autopilot scene description language: although a programming language-like format is used herein, the autopilot scenario description language is not limited to this form. It may also be natural language, such as: "on a highway on sunny days, one vehicle is running at a speed of 60km/h and the other vehicle is approaching at a speed of 62 km/h. ". However, the complexity and ambiguity of natural language processing may lead to difficulties in parsing and conversion, and thus specialized programming or markup languages are more common. Provider and format: the autopilot scenario description language is typically provided by a research institution, vehicle manufacturer, or third party company. Such languages typically have specific grammars and formats to ensure accuracy and consistency. Use: the main purpose of the autopilot scenario description language is to simulate and test an autopilot system. Through this language, developers and researchers can create various complex driving scenarios to test the performance and safety of autopilot algorithms in a virtual environment. This method is safer, faster and more cost-effective than testing in the real world. In summary, the autopilot description language is a tool that is specifically used to describe and simulate autopilot, which may be in source code form, or in other forms, but specialized programming or markup languages are more common to ensure accuracy and efficiency.
102, analyzing and processing source codes of an automatic driving scene description language to obtain a grammar tree;
when step 102 is implemented, it may include:
step 1021, performing lexical analysis on the source codes of the automatic driving scene description language to obtain target symbols;
step 1022, parse the target symbol according to the grammar rule to obtain the grammar tree.
Fig. 2 is a schematic diagram of a lexical and grammatical analysis of source code of an autopilot scene description language. Referring to fig. 2, a specific embodiment of lexical analysis and syntax analysis of source code of the autopilot description language is:
lexical analysis: assume the following scene description language source code:
```dsl
Car:MyCar
Speed:60km/h
```
through the lexical analyzer, the piece of code is broken down into a series of symbols or tokens (tokens).
For example:
-`Car`
-`:`
-`MyCar`
-`Speed`
-`:`
-`60`
-`km/h`
these tokens are the least significant units in the source code, such as keywords, identifiers, operators, and word denominations. The form of the symbol: typically, the symbol will be a structure containing the type of token (e.g., key, identifier, number), text value, and possibly location information. The function is as follows: the main purpose of lexical analysis is to convert human-readable source code into a sequence of symbols that can be more easily processed by a machine, i.e., target symbols.
Syntax analysis: these tokens are then processed by a parser, which organizes them into a structured syntax tree according to predefined syntax rules. For the above symbol sequence (target symbol), the parser may generate the following syntax tree:
predefined grammar rules: grammar rules define the structure of a language. For example, the language may have a rule that states that each claim must be followed by a colon and a value; form of syntax tree: a syntax tree is a hierarchical data structure that represents the nested structure of source code. Each node represents a structure (e.g., declaration or expression) in the source code, and the child nodes represent components of the structure. The function is as follows: the purpose of the parsing is to verify that the structure of the source code is correct and to provide a structured representation for the subsequent compilation or interpretation process.
In summary, lexical analysis and grammatical analysis are the first two stages of the compilation process that convert human-readable source code into a structured format that can be understood and processed by a machine.
And step 103, generating a virtual machine instruction set according to the grammar tree and the instruction format of the preset virtual machine.
Specifically, under the condition that the grammar tree is checked to be correct by utilizing semantic analysis, each node in the grammar tree is traversed, and a virtual machine instruction set is generated according to the instruction format of a preset virtual machine.
Semantic analysis is a key stage in the compilation process to check if the meaning of the source code is clear, correct, and to provide the necessary information for the code generation stage. It not only checks the correctness of a single statement, but also checks the relationships between statements.
One specific example of semantic analysis is:
assume the following syntax tree of scene description language:
for an autopilot scenario, it is assumed that the upper vehicle speed limit is 100km/h. In the semantic analysis stage, the analyzer checks whether each attribute value is within a valid range.
The inspection mode includes type inspection: ensuring that each variable, expression, and type of assignment is correct. For example, ensure that the speed value is a number in units of 'km/h'; range checking: for the above example, the speed '150 km/h' exceeds the upper allowable limit, and the analyzer reports an error indicating that the speed is outside the allowable range; name binding: ensuring that each variable or entity referenced in the scene description has a definition, e.g., if an entity named 'other car' is referenced, but no definition is provided for it, the analyzer reports an error; flow control check: ensuring that the execution path of the code is unambiguous, although this is more common in conventional programming languages, it may also be required in some complex scene description languages; consistency check: ensuring that descriptions of scenes are consistent, e.g., ensuring that the same entity is not assigned different attributes in the scene descriptions; and (3) correction: when the analyzer finds an error, it typically reports the error and stops the compilation process, in some cases the analyzer may provide repair suggestions, but in most cases the developer needs to manually repair the error and recompile.
Once the semantic analysis is successfully completed (i.e., without errors), the next step is typically code generation, converting the syntax tree into the instruction set of the target virtual machine. In general, semantic analysis ensures that scene descriptions are not only syntactically correct, but also logically and in sense.
When step 103 is implemented, it may include:
step 1031, traversing each node in the syntax tree, and determining the type of each node in the syntax tree; to generate virtual machine instructions, the compiler will traverse the syntax tree and generate corresponding instructions for each node.
Step 1032, determining a node function corresponding to the node according to the type of the node; the type of the node may be any one of an entity declaration type, an attribute setting type, an event declaration type, a conditional statement type, and a function call type, and the corresponding node functions are also different, for example, the node function corresponding to the entity declaration type is 'uncleareeEntity ()', the node function corresponding to the attribute setting type is 'setAttribute ()', and the like.
Step 1033, converting the nodes according to the instruction format of the preset virtual machine and the node function corresponding to the nodes to obtain an instruction set of the virtual machine; the instruction format of the preset virtual machine comprises the following steps: a preset number of bytes, a preset byte value field, a preset byte meaning, and a preset instruction type.
FIG. 3 is a schematic diagram of a single length instruction format of a default virtual machine; FIG. 4 is a diagram illustrating a dual length instruction format of a default virtual machine; referring to fig. 3 and 4, the instruction format of the preset virtual machine may be that the instruction is composed of 4 bytes, among which there are five possible value ranges: the first byte of each instruction is an opcode, which determines the operation to be performed (e.g., add, subtract, function call, etc.), and the remaining bytes define the destination or operand of the operation, which can be divided into long and short instructions depending on the length of the operand. This instruction format provides a specific, optimized instruction set format for virtual machines that differs from existing virtual machine technology based on certain specific requirements or considerations (e.g., to simplify the implementation of the interpreter, or to increase execution efficiency), which is an optimized virtual machine instruction set format designed for a particular application or context.
Generating virtual machine instructions is a critical stage that converts nodes in the semantically parsed syntax tree into instructions that can be directly executed by the virtual machine. This process is referred to as "code generation" or virtual machine instruction set generation. One specific embodiment of virtual machine instruction set generation is: assume the following syntax tree of scene description language:
This syntax tree describes an entity named 'MyCar' and its attribute 'Speed', with a value of '60 km/h', and to generate virtual machine instructions, the compiler traverses the syntax tree and generates the corresponding instructions for each node. The specific processing mode is as follows: entity declaration: for the ' Entity ' Car ' node, the compiler may generate an instruction to declare a new vehicle Entity, such as: declareEntity Car, myCar'; attribute setting: for the 'Attribute' node, the compiler may generate an instruction to set the properties of the entity, for example: setAttribute MyCar, speed,60 km/h'; finally, for this simple syntax tree, the compiler might generate the following sequence of virtual machine instructions:
```
DeclareEntity Car,MyCar
SetAttribute MyCar,Speed,60km/h
```
these instructions may be executed directly by the virtual machine to create an entity named 'MyCar' in the simulation environment and set its speed to '60 km/h'.
Other processes may also be involved, such as optimization: some optimizations may be performed by the compiler, such as deleting unnecessary instructions, reordering instruction sequences to improve execution efficiency, etc.; and (3) resource management: a compiler may need to allocate memory or other resources for entities and other resources, which may involve generating additional instructions to manage these resources; error handling: if the compiler finds any syntax or semantics that are not compatible with the target virtual machine during the code generation phase, it will report an error; in general, the code generation process involves traversing the syntax tree and generating corresponding virtual machine instructions for each node, thereby converting the high-level scene description into low-level instructions that can be executed by the virtual machine.
When step 1033 is implemented, it may include:
step 10331, determining child nodes according to the nodes;
step 10332, calling the node function corresponding to the node according to the instruction format of the preset virtual machine, and converting the node and the child node into the virtual machine instruction set.
In the virtual machine instruction set generation phase, each node in the syntax tree typically corresponds to a set of virtual machine instructions. The specific instructions depend on the type of node and its semantics in the source code. The following are examples of some common syntax tree node types, corresponding child nodes, and virtual machine instructions that may be generated:
1. entity declaration:
-syntax tree node: ' EntityDeclarization
-a child node: "EntityName", "EntityType
-function call: 'DeclareEntity ()'
-the generated instructions: for example,' DeclareEntityCar, myCar
2. Attribute setting:
-syntax tree node: attributeAssignment
-a child node: "AttributeName", "AttributeValue
-function call: "setatttribute ()"
-the generated instructions: for example,' SetAttribute MyCar, speed,60km/h
3. Event declaration:
-syntax tree node: eventDeclaration
-a child node: the ' EventName ', ' triggerCondition ', ' Action
-function call: "DeclareEvent ()," SetTriggerCondition (), "SetEventAction ()", and "SetTriggerCondition ()"
-the generated instructions: for example, ' DeclareEvent Overtake ', ' SetTriggerCondition Overtake, distance (MyCar, other Car) <10m ', ' SetEventAction Overtake, notifyDriver (MyCar)
4. Conditional statement:
-syntax tree node: ifStatement
-a child node: "Condition", "true Branch", and "false Branch" (if else part exists)
-function call: generally involves parsing the 'Condition' and generating the appropriate jump instruction, and then parsing the 'TrueBranch' and 'FalseBranch' in order
-the generated instructions: for example, ' Evaluate Condition ', ' JumpIfFalse to LabelX ', ' true branch instructions ', ' LabelX:. False branch instructions
5. Function call:
-syntax tree node: "FunctionCall
-a child node: "FunctionName", "images
-function call: function call instruction directly converted into virtual machine
-the generated instructions: for example,' CallFunction NotifyDriver, myCar
The above is just a few simplified examples, and the actual compilation process may involve more complex syntax tree structures and more instructions. The goal of the code generation stage is to translate each node of the syntax tree into a set of virtual machine instructions that, when executed, produce the same effect as the original source code.
Referring to fig. 1, in an alternative embodiment, the method for generating the virtual machine instruction set further includes:
104, when the virtual machine instruction in the virtual machine instruction set is executed, creating a new stack frame for the functions in the virtual machine instruction on the stack; the new stack frame contains the local variables, parameters, and return addresses of the function;
when the function is executed and returned, a new stack frame is popped from the stack, step 105.
In many virtual machines and computer architectures, the stack is a critical data structure for storing temporary data, return addresses for function calls, local variables, and the like. Push (push) and pop (pop) are two basic operations for adding and removing data from a stack. When a virtual machine instruction executes, one specific description of using the instruction for push and pop operations is:
1. push (Push):
when a value needs to be saved in the stack, a push instruction may be used.
Instructions to: "PUSH < value >"
The operation is as follows: this instruction will place the 'value' at the top of the stack and update the stack pointer to point to the new stack top.
For example, if the value 10' is to be put on the stack, an instruction may be used:
```
PUSH 10
```
2. pop (Pop):
pop instructions may be used when a value needs to be fetched from the stack.
Instructions to: POP
The operation is as follows: this instruction removes a value from the top of the stack and updates the stack pointer to point to the new stack top. Typically, the value that is popped up may be stored in a register or memory location, or discarded directly.
For example, to fetch a value from the stack and store it in register 'R1', an instruction may be used:
```
POP R1
```
application in function call:
when a function is called, the location (return address) of the current execution and other necessary context information need to be saved so that execution can continue when the function returns. This is typically done by a push operation. For example:
1. saving the return address: PUSH return_address
2. Saving local variables and parameters: "PUSH local_variable", "PUSH parameter
3. Executing a function
4. Recovering local variables and parameters: POP parameter,' POP local_variable
5. Resume and jump to return address: "POP return_address" and "JUMP return_address
The above is just a simplified description, and the actual stack operation may be more complex, depending on the particular virtual machine or computer architecture, and how the compiler generates the code.
Referring to fig. 1, in an alternative embodiment, the method for generating the virtual machine instruction set further includes:
And 106, generating virtual machine instructions of the scene semantic model according to conditions and actions occurring between scene elements of the automatic driving scene description language.
The virtual machine instructions generated by the autopilot scene description language are somewhat interrelated with the virtual machine instructions of the scene semantic model, but the emphasis and processing of them may be slightly different. Virtual machine instructions of the scene semantic model: scene semantic models typically include the logical structure and behavior of a scene, which involves relationships between scene elements (e.g., vehicles, pedestrians, traffic signals, etc.), interactions, and how these interactions change over time; a specific embodiment of virtual machine instructions of a scene semantic model is: assume the following scenario description:
when `CarA` approaches `PederstrianX` by at least 10 meters, `CarA` should be slowed down.
If 'TrafficLight' is red, 'car a' should stop.
Based on the above description, the virtual machine instructions of the scene semantic model may be:
1.`MonitorDistance CarA,PedestrianX`
2.`If Distance<10,SlowDown CarA`
3.`Moni torTrafficLight CarA,TrafficLight`
4.`If TrafficLight＝＝RED,Stop CarA`
virtual machine instructions generated by the autopilot scene description language: the method comprises the steps of converting source codes describing scenes into grammar trees through lexical, grammatical and semantic analysis, and then generating virtual machine instructions according to the grammar trees; a specific embodiment of a virtual machine instruction generated by an autopilot scene description language is:
Source code:
```dsl
Entity CarA；
Entity PedestrianX；
Condition CarA near PedestrianX<10m->Action CarA slow_down；
Condition TrafficLight＝＝RED->Action CarA stop；
```
the corresponding syntax tree may be: based on the syntax tree, the virtual machine instructions generated may be similar to the instructions of the scene semantic model described above.
Logical relationship between virtual machine instructions generated by the autopilot scene description language and virtual machine instructions of the scene semantic model: virtual machine instructions of a scene semantic model, which are more focused on the logic and behavior of the scene, are often more advanced, directly describing how scene elements interact; the virtual machine instructions generated by the autopilot scene description language are more focused on how to translate source code into executable instructions, which typically involve various stages in the compilation process, from source code to syntax trees, to virtual machine instructions. The two are interrelated in that the final goal of generating virtual machine instructions based on the autopilot scene description language is to generate an instruction set that can describe scene logic and behavior, which is consistent with the goal of the scene semantic model.
According to the method for generating the virtual machine instruction set, the grammar tree is obtained by analyzing and processing the source code of the automatic driving scene description language, and then the grammar tree is used for generating the virtual machine instruction set according to the instruction format of the preset virtual machine, so that enough and detailed instructions are provided, all possible scene requirements are covered, and different automatic driving scene requirements are adapted.
All the above optional technical solutions may be combined arbitrarily to form an optional embodiment of the present disclosure, which is not described here in detail.
Fig. 5 is a flowchart of a method for generating a virtual machine instruction set in a specific embodiment provided by an embodiment of the present disclosure. Referring to fig. 5, the method first converts an autopilot scene description language (DSL) into instructions of a virtual machine after lexical analysis, grammatical analysis and semantic analysis; wherein, lexical analysis is mainly responsible for decomposing source codes into meaningful symbols; the grammar analysis organizes the symbols into grammar trees according to grammar rules; semantic analysis is responsible for checking the correctness of the syntax tree and generating virtual machine instructions. This series of conversion processes ensures that the code of the DSL can be interpreted or executed by the virtual machine.
Wherein the syntax tree is a structured representation of DSL source code reflecting the hierarchical structure and semantic relationships of the code; in the syntax tree, a function call is usually represented by a specific node, and the node contains information such as names, parameters and the like of functions; each node in the syntax tree (e.g., a function call, an assignment statement, or a conditional statement) may be converted to a series of virtual machine instructions; when the function call node is converted into a virtual machine instruction, a series of instructions are generated, wherein the instructions firstly assign values to the parameters of the function, then execute the function call, and finally possibly process the return value of the function; when the virtual machine executes a function call instruction, it creates a new stack frame for the function on the stack. This stack frame contains the local variables, parameters, and return addresses of the function. When the function is executed and returned, the corresponding stack frame is popped from the stack.
The method comprises the steps of redesigning a virtual machine, wherein the virtual machine comprises byte codes and instruction sets of the virtual machine and stack frame implementation of function call, and the byte codes are an intermediate representation form and are used for being executed on the virtual machine; the instruction set is a set of operations that the virtual machine can perform; the stack frame is used for storing the information such as local variables, return addresses and the like in the function calling process. The virtual machine is designed mainly for the following reasons:
1. scene specific: since this virtual machine is designed for the autopilot scenario description language (DSL), it may contain some instructions or functions specific to this domain, such as instructions tailored to the scenario semantic model.
2. Optimization and efficiency: the virtual machine may be specifically optimized for the nature of the autopilot scenario to ensure efficient execution and response.
3. Security and robustness: autopilot scenarios require a high degree of safety and robustness, so virtual machines may need to take these factors into account, ensuring stable, safe operation in all situations.
4. Interaction with hardware: the autopilot system may need to interact with various sensors and actuators of the vehicle, and thus the virtual machine may need some specific instructions or interfaces to support such interactions.
In summary, while the basic concept and architecture is similar to that of a traditional virtual machine, the virtual machine may have some unique design and implementation details for the specific needs of an autopilot scenario.
The virtual machine key implementation steps comprise:
virtual machine function call and stack, virtual machine support multithread execution, each thread has its own execution environment, including stack, virtual register and call information, etc. FIG. 6 is a schematic diagram of a structure of a 16 byte stack of a base object format; FIG. 7 is a schematic diagram of a stack with instruction format of 4 bytes; referring to fig. 6 and 7, in fig. 6, the stack 600 is shown with a bottom 602 and a top 608 above, and when the function 601 is function (& ret 1), the function parameter 603 may have a plurality of parameters such as argc1 (& ret 2), argc2 … … argmentn, the local variable 604 may have a plurality of parameters such as localVariable1, localVariable2 … … localVariable n, the member reference 605 may have a plurality of parameters such as membrane reference1, membrane reference2 … … memberReference N, and the Register 606 may have a plurality of parameters such as Register1, register2 … … Register n, wherein the total length between the function parameters argc1 (& ret 2) to Register n is the stack total length 607. Each time a function is called, an object called "CI" (CallInfo) is generated that contains the base (base) and top (top) information of the current stack. By saving the base address and stack top of the current function in the CI object (rather than pushing it on stack), the current CI-1 object can be made to acquire the execution frame of the last function. The parameters of the function are pushed onto the stack by the caller, and then the function to be called is also pushed onto the stack, with the top of the stack pointing to the function. The "call" instruction contains information of the number of parameters and the number of return values, and stores the current base address, the stack top (calculated according to the number of parameters, the current stack top+the number of parameters+1) and the program counter (pc) in the current CI object. The "call" instruction then creates a new CI object and saves the number of returned values. The "call" instruction will set the new pc (code area pointer program counter), base address and top of stack, where the base address is equal to the top of stack, and set the parameters to the top of stack of the last CI object. When executing the return function instruction, acquiring the last several values of the current stack according to the return quantity, cleaning the current CI object, recovering the previous CI object, and pushing the return values into the stack in sequence. After the function compilation is completed, the stack size inside the function should be known. Each time a scope is entered, the stack space required for all variables within the scope is pre-allocated. This implementation is to calculate the stack size for each function prototype at compile time. For variable parameter implementation, if a parameter variable is used in the discovery function at compile time, the first local variable is defined as a parameter, and all parameters are set into an array.
Memory management and reclamation, supporting memory garbage reclamation, virtual machine memory management and reclamation, must hold and be able to find all allocated memory. Whether to reclaim may then be determined by traversing the index. In the implementation of coroutines, virtual machines provide support for coroutines and have implemented the definition of the scenario.
Event mechanisms of the autopilot simulation scene domain model, about which events are compiled into specific types, update the state of the event every clock cycle after registering into the event system using wait functions. When updating the state, if the event reaches the expected condition, the corresponding script is directly called. The event mechanism of the autopilot simulation scene domain model can be seen as an integral part of the scene semantic model. The event mechanism is a key concept in autopilot simulation, and is used for describing and managing various events occurring in a scene, considering the complexity of a scene semantic model, and besides the events, the model may include the following main objects: entity (Entities): this may include vehicles, pedestrians, signal lights, etc. Each entity may have its own attributes (e.g., speed, location) and behaviors (e.g., driving, parking); environmental factor (Environmental Factors): this may include weather conditions, road conditions, traffic flow, etc.; behavior pattern (Behavioral Patterns): describing how an entity responds to other entities or events in a scene, for example, when a pedestrian appears in front of a zebra crossing, the vehicle should stop; trigger (triggerers): triggering certain actions or events when certain conditions are met; constraints (Constraints): describing allowed or disallowed behavior in the scene, such as a speed limit; for these objects to translate into virtual machine instructions, several core functions may be involved: register entity (): for registering entities in the scene and assigning attributes thereof; setEnvironment (): setting environmental factors; defining behavior (): defining a behavior mode of an entity; addTrigger (): adding a trigger; setConstraint (): constraints are set.
Namespaces, in terms of namespaces, the compilation time determines the referencing relationships of variables. The definition performed outside the function will go into the global table. For parameters inside the function, the local definition is first looked up, and then the variables of the upper level space (including definition and value of the upper level space) are looked up. If the upper level space is still not found, the recursive lookup continues until a variable is found and is added as upvalue. If it is still not found at the outermost layer, it is looked up in the global table (variable name is saved in const table) and the corresponding value is obtained. "namespaces" refer to mechanisms that determine the referencing relationship of variables at compile time and resolve variable references at runtime. This is relevant to the member references in the stack, but they are not all the same thing. The following is a specific description:
1. namespaces: this is a concept in programming for organizing and managing the scope of variables, functions, and other identifiers. Namespaces determine where a variable can be accessed and avoid naming conflicts.
2. Member references in stack: when a function is called, its parameters, local variables, and other related information (e.g., return address) are pushed onto the stack. The organization of this information on the stack is related to the namespaces of the functions. For example, local variables inside a function are typically stored on a stack and popped off when the function returns.
When a variable is referenced:
first look up in the local space of the current function (i.e. the current stack frame of the stack).
If not found in the local space, the variables of the upper space are looked up, which may involve other stack frames (corresponding to other function calls).
If not found in all local spaces, it is finally found in the global table.
This lookup mechanism ensures proper resolution of the variable references, whether the variables are defined in the current function, external function, or global space. Namespaces are closely related to member references in a stack, but they are two different concepts. Namespaces relate to the organization and scope of variables, while member references in a stack relate to how these variables are stored and accessed at runtime.
Code definition (preset virtual machine instruction format), code definition is 4 bytes, wherein five value ranges are used: values in the code are up (U), stack (R), const (K), close (CL). The first byte of each instruction is an operation code, and the other fields are operation targets; instructions can be divided into long instructions and short instructions according to the difference of operands; long instructions use two bytes to represent operands, while short instructions use only one byte to represent operands. The number of values in a function is typically less than 256, so it can be represented in one byte. For stack and const, one byte may also be used to represent.
As shown in fig. 3 and 4, instructions may be classified into single-operand single instructions, double-operand double instructions, three-operand single instructions, and three-operand double instructions. Wherein, single operand single instruction: an instruction involves only one operand and there is only one instruction; double-operand double instruction: an instruction involves two operands and consists of two instructions, where the opcode of the second instruction is the opcode of the first instruction plus one (pc+1); three-operand single instruction: an instruction involves three operands and there is only one instruction; three-operand dual instruction: an instruction involves three operands and consists of two instructions, where the opcode of the second instruction is the opcode of the first instruction plus one (pc+1). Such instruction structures may implement different operations through combinations of opcodes and operands. Table 1 is a virtual machine instruction set:
TABLE 1 virtual machine instruction set
/>
/>
/>
/>
The 'EmitStrutContEvent, A, B, C' instruction in Table 1 describes the operation of a trigger architecture event. When event B occurs, it invokes the listening function registered in structure object a and passes in message parameter C. Such instructions may be the result of some node transformations in a syntax tree or scene semantic model.
This conversion is illustrated below:
example 1: function call
Assume that there are the following code segments in the scene description language:
```dsl
onEvent(car1,collision,notifyDriver)
```
here, 'onEvent' is a function call, which means that when 'car 1' occurs 'colletion' event, a 'notify driver' function is called.
The corresponding syntax tree may be as follows:
```
FunctionCall
|--FunctionName:onEvent
|--Argument1:car1
|--Argument2:collision
|--Argument3:notifyDriver
```
this syntax tree node may be converted to virtual machine instruction 'emitsstructevent, car1, collision, notafydriver'.
# # example 2: conditional statement
Consider the following code segment:
here, one condition is described: if `car1` collides with `car2` an event is triggered.
The corresponding syntax tree may be as follows:
in this case, the virtual machine instruction may be a series of instructions, first evaluating the condition 'collides with (car 1, car 2'), and then according to the result of the condition, may execute 'emitsstructevent, car1, collision, notafydriver'.
High-level structures in the scene description language (e.g., function calls, conditional statements, etc.) are converted into a series of virtual machine instructions. The specific transformation rules therein depend on the design of the compiler and the instruction set of the virtual machine.
The instructions further comprise instructions for customizing the scene semantic model. These custom instructions are used to implement conditions and actions that occur between various scene elements in the scene, such as roads, vehicles, pedestrians, etc., and the interactive behavior between them. The scene semantic model may provide a high level abstraction for an autopilot scene, defining a specific set of operations or behaviors. To support these operations or behaviors, the virtual machine needs to implement a set of instruction sets corresponding to the operations or behaviors, which are used to define specific behaviors and implementations of virtual machine instructions converted by an automatic driving scene description language (DSL) on the virtual machine, simply, to execute the virtual machine instructions converted according to the driving scene description language, so as to ensure that the virtual machine instructions converted by the driving scene description language can run correctly and efficiently on the virtual machine. The scene semantic model may define some advanced operations or behaviors specific to the autopilot scene. These operations or actions may be represented in the syntax tree by specific nodes that, when converted into virtual machine instructions, convert into a series of specific, scene-dependent instructions.
The syntax tree provides structural and semantic information of the code, which is converted into virtual machine instructions at compile time; the function call and stack mechanism of the virtual machine provides support during operation, so that correct execution of codes is ensured; the scene semantic model provides higher-level semantic support for specific application fields.
According to the virtual machine instruction set generation method, the automatic driving scene description language is converted into the virtual machine instruction set, so that scene simulation is convenient and flexible.
Fig. 8 is a schematic structural diagram of a generating apparatus for a virtual machine instruction set according to an embodiment of the present disclosure, referring to fig. 8, the apparatus 800 includes:
an acquiring module 801, configured to acquire source codes of an autopilot scene description language;
the processing module 802 is configured to analyze and process a source code of the autopilot scene description language to obtain a syntax tree;
the generating module 803 is configured to generate a virtual machine instruction set according to a preset virtual machine instruction format from the syntax tree.
Optionally, the processing module 802 includes:
the first processing sub-module is used for performing lexical analysis on the source codes of the automatic driving scene description language to obtain target symbols;
And the second processing sub-module is used for carrying out grammar analysis on the target symbol according to grammar rules to obtain a grammar tree.
Optionally, the generating module 803 traverses each node in the syntax tree under the condition that the syntax tree is checked to be correct by using semantic analysis, and generates a virtual machine instruction set according to an instruction format of a preset virtual machine.
Optionally, the generating module 803 includes:
the first generation sub-module is used for traversing each node in the grammar tree and determining the type of each node in the grammar tree;
the second generation submodule is used for determining a node function corresponding to the node according to the type of the node;
the third generation submodule is used for converting the nodes according to the instruction format of the preset virtual machine and the node function corresponding to the nodes to obtain a virtual machine instruction set; the instruction format of the preset virtual machine comprises the following steps: a preset number of bytes, a preset byte value field, a preset byte meaning, and a preset instruction type.
Optionally, the third generating submodule includes:
a third generating subunit, configured to determine a child node according to the node;
and the fourth generation subunit is used for calling a node function corresponding to the node according to the instruction format of the preset virtual machine and converting the node and the child node into a virtual machine instruction set.
Optionally, the generating device 800 of the virtual machine instruction set further includes:
an execution module 804, configured to create a new stack frame on the stack for the functions in the virtual machine instruction when the virtual machine instruction in the virtual machine instruction set is executed; the new stack frame contains the local variables, parameters, and return addresses of the function;
a return module 805, configured to pop a new stack frame from the stack when the function is executed and returned.
Optionally, the generating device 800 of the virtual machine instruction set further includes:
the model instruction generating module 806 is configured to generate a virtual machine instruction of the scene semantic model according to conditions and actions occurring between scene elements of the autopilot scene description language.
According to the virtual machine instruction set generating device, the grammar tree is obtained by analyzing and processing the source code of the automatic driving scene description language, and then the virtual machine instruction set is generated according to the instruction format of the preset virtual machine, so that enough and detailed instructions are provided, all possible scene requirements are covered, and different automatic driving scene requirements are adapted.
It should be noted that: in the generating device of the virtual machine instruction set provided in the above embodiment, only the division of the above functional modules is used for illustration, and in practical application, the above functional allocation may be performed by different functional modules according to needs, that is, the internal structure of the device is divided into different functional modules to complete all or part of the functions described above. In addition, the generating device of the virtual machine instruction set provided in the foregoing embodiment and the generating method embodiment of the virtual machine instruction set belong to the same concept, and the specific implementation process of the generating device is detailed in the method embodiment, which is not described herein again.
The generating device of the virtual machine instruction set in the embodiment of the disclosure may be a virtual device, or may be a component, an integrated circuit or a chip in a server or a terminal. The device may be a mobile electronic device or a non-mobile electronic device. By way of example, the mobile electronic device may be a cell phone, tablet computer, notebook computer, palm top computer, vehicle mounted electronic device, wearable device, ultra-mobile personal computer (ultra-mobile personal computer, UMPC), netbook or personal digital assistant (personal digital assistant, PDA), etc., and the non-mobile electronic device may be a server, network attached storage (Network Attached Storage, NAS), personal computer (personal computer, PC), television (TV), teller machine or self-service machine, etc., and the embodiments of the disclosure are not limited in particular.
The generating device of the virtual machine instruction set in the embodiment of the present disclosure may be a device having an operating system. The operating system may be an Android operating system, an ios operating system, or other possible operating systems, and the embodiments of the present disclosure are not limited specifically.
Optionally, as shown in fig. 9, embodiments of the present disclosure further provide a computing device 900, including: the processor 901, and the memory 902 storing a computer program, where the computer program when executed by the processor 901 performs the processes of the above embodiment of the method for generating a virtual machine instruction set, and can achieve the same technical effects, and for avoiding repetition, a detailed description is omitted herein. It should be noted that, the computing device in the embodiments of the present disclosure includes the mobile electronic device and the non-mobile electronic device described above.
While the foregoing is directed to the preferred embodiments of the present disclosure, it should be noted that modifications and adaptations to those skilled in the art may be made without departing from the principles of the present disclosure and are intended to be comprehended within the scope of the present disclosure.
Claims (10)
1. A method for generating a virtual machine instruction set, comprising:
acquiring a source code of an automatic driving scene description language;
analyzing and processing the source codes of the automatic driving scene description language to obtain a grammar tree;
and generating a virtual machine instruction set according to the grammar tree and the instruction format of a preset virtual machine.
2. The method for generating the virtual machine instruction set according to claim 1, wherein analyzing the source code of the autopilot scene description language to obtain the syntax tree comprises:
performing lexical analysis on the source codes of the automatic driving scene description language to obtain target symbols;
and carrying out grammar analysis on the target symbol according to grammar rules to obtain a grammar tree.
3. The method for generating the virtual machine instruction set according to claim 2, wherein generating the virtual machine instruction set from the syntax tree according to a preset virtual machine instruction format includes:
Under the condition that the grammar tree is checked to be correct by utilizing semantic analysis, traversing each node in the grammar tree, and generating a virtual machine instruction set according to the instruction format of a preset virtual machine.
4. The method for generating a virtual machine instruction set according to claim 3, wherein traversing each node in the syntax tree generates the virtual machine instruction set according to a preset virtual machine instruction format, and comprises:
traversing each node in the grammar tree, and determining the type of each node in the grammar tree;
determining a node function corresponding to the node according to the type of the node;
converting the node according to an instruction format of a preset virtual machine and a node function corresponding to the node to obtain an instruction set of the virtual machine; the instruction format of the preset virtual machine comprises the following steps: a preset number of bytes, a preset byte value field, a preset byte meaning, and a preset instruction type.
5. The method of generating a virtual machine instruction set of claim 4, wherein translating the node comprises:
determining a child node according to the node;
and calling a node function corresponding to the node according to an instruction format of a preset virtual machine, and converting the node and the child node into a virtual machine instruction set.
6. The method of generating a virtual machine instruction set of claim 1, further comprising:
when the virtual machine instruction in the virtual machine instruction set is executed, creating a new stack frame for the functions in the virtual machine instruction on a stack; the new stack frame contains the local variables, parameters, and return addresses of the function;
when the function is executed and returned, the new stack frame is popped from the stack.
7. The method of generating a virtual machine instruction set of claim 1, further comprising:
and generating virtual machine instructions of the scene semantic model according to conditions and actions occurring between scene elements of the automatic driving scene description language.
8. A virtual machine instruction set generation apparatus, comprising:
the acquisition module is used for acquiring source codes of the automatic driving scene description language;
the processing module is used for analyzing and processing the source codes of the automatic driving scene description language to obtain a grammar tree;
and the generation module is used for generating a virtual machine instruction set according to the grammar tree and the instruction format of the preset virtual machine.
9. A computing device, comprising: a processor, a memory storing a computer program which, when executed by the processor, performs the method of any one of claims 1 to 7.
10. A computer readable storage medium storing instructions which, when run on a computer, cause the computer to perform the method of any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311758043.1A CN117724804B (en) | 2023-12-19 | 2023-12-19 | Virtual machine instruction set generation method, device and equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311758043.1A CN117724804B (en) | 2023-12-19 | 2023-12-19 | Virtual machine instruction set generation method, device and equipment |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN117724804A true CN117724804A (en) | 2024-03-19 |
| CN117724804B CN117724804B (en) | 2024-06-14 |
Family
ID=90210348
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311758043.1A Active CN117724804B (en) | 2023-12-19 | 2023-12-19 | Virtual machine instruction set generation method, device and equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117724804B (en) |
Citations (15)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5838980A (en) * | 1994-01-18 | 1998-11-17 | Sybase, Inc. | Compilation and virtual machine arrangement and process for source code including pre-runtime executable language structure constructs |
| CN101000555A (en) * | 2006-01-13 | 2007-07-18 | 北京金远见电脑技术有限公司 | Hand terminal system |
| CN103123590A (en) * | 2011-11-18 | 2013-05-29 | 中国科学院沈阳计算技术研究所有限公司 | Compiling method from intermediate language (IL) program to C language program of instruction list |
| RU2016137177A (en) * | 2016-09-16 | 2018-03-19 | Оракл Интернэйшнл Корпорейшн | IMPROVED TRANSFORMATION OF SOURCE PROGRAMMING LANGUAGE CODE |
| US20190213102A1 (en) * | 2018-01-08 | 2019-07-11 | Codevalue D.T. Ltd. | Time Travel Source Code Debugger Incorporating Point In Time Links |
| CN110018816A (en) * | 2019-04-12 | 2019-07-16 | 王晨 | A kind of virtual machine control system and its control method based on C/C++ compiling system |
| CN112328356A (en) * | 2020-10-21 | 2021-02-05 | 成都安易迅科技有限公司 | Android and Windows intercommunication method and device, storage medium and computer equipment |
| CN112799653A (en) * | 2021-03-17 | 2021-05-14 | 中汽数据有限公司 | Compiler for generating source code in test scenario and test scenario generation system |
| US20210318896A1 (en) * | 2020-08-31 | 2021-10-14 | Alipay (Hangzhou) Information Technology Co., Ltd. | Methods, blockchain nodes and storage media for executing smart contracts |
| CN114238097A (en) * | 2021-12-09 | 2022-03-25 | 深圳慕智科技有限公司 | Automatic driving system simulation test technology based on scene description language |
| CN115016793A (en) * | 2022-04-25 | 2022-09-06 | 中国平安人寿保险股份有限公司 | Code generation method and device based on syntax tree, electronic equipment and storage medium |
| CN116382662A (en) * | 2023-04-11 | 2023-07-04 | 东北大学秦皇岛分校 | System for converting Chinese codes into executable programs |
| WO2023206873A1 (en) * | 2022-04-28 | 2023-11-02 | 三六零科技集团有限公司 | Abstract syntax tree-based code test method, apparatus, device, and storage medium |
| CN117008920A (en) * | 2023-08-07 | 2023-11-07 | 上海哔哩哔哩科技有限公司 | Engine system, request processing method and device, computer equipment and storage medium |
| CN117113347A (en) * | 2023-08-24 | 2023-11-24 | 北京关键科技股份有限公司 | Large-scale code data feature extraction method and system |
-
2023
- 2023-12-19 CN CN202311758043.1A patent/CN117724804B/en active Active
Patent Citations (15)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5838980A (en) * | 1994-01-18 | 1998-11-17 | Sybase, Inc. | Compilation and virtual machine arrangement and process for source code including pre-runtime executable language structure constructs |
| CN101000555A (en) * | 2006-01-13 | 2007-07-18 | 北京金远见电脑技术有限公司 | Hand terminal system |
| CN103123590A (en) * | 2011-11-18 | 2013-05-29 | 中国科学院沈阳计算技术研究所有限公司 | Compiling method from intermediate language (IL) program to C language program of instruction list |
| RU2016137177A (en) * | 2016-09-16 | 2018-03-19 | Оракл Интернэйшнл Корпорейшн | IMPROVED TRANSFORMATION OF SOURCE PROGRAMMING LANGUAGE CODE |
| US20190213102A1 (en) * | 2018-01-08 | 2019-07-11 | Codevalue D.T. Ltd. | Time Travel Source Code Debugger Incorporating Point In Time Links |
| CN110018816A (en) * | 2019-04-12 | 2019-07-16 | 王晨 | A kind of virtual machine control system and its control method based on C/C++ compiling system |
| US20210318896A1 (en) * | 2020-08-31 | 2021-10-14 | Alipay (Hangzhou) Information Technology Co., Ltd. | Methods, blockchain nodes and storage media for executing smart contracts |
| CN112328356A (en) * | 2020-10-21 | 2021-02-05 | 成都安易迅科技有限公司 | Android and Windows intercommunication method and device, storage medium and computer equipment |
| CN112799653A (en) * | 2021-03-17 | 2021-05-14 | 中汽数据有限公司 | Compiler for generating source code in test scenario and test scenario generation system |
| CN114238097A (en) * | 2021-12-09 | 2022-03-25 | 深圳慕智科技有限公司 | Automatic driving system simulation test technology based on scene description language |
| CN115016793A (en) * | 2022-04-25 | 2022-09-06 | 中国平安人寿保险股份有限公司 | Code generation method and device based on syntax tree, electronic equipment and storage medium |
| WO2023206873A1 (en) * | 2022-04-28 | 2023-11-02 | 三六零科技集团有限公司 | Abstract syntax tree-based code test method, apparatus, device, and storage medium |
| CN116382662A (en) * | 2023-04-11 | 2023-07-04 | 东北大学秦皇岛分校 | System for converting Chinese codes into executable programs |
| CN117008920A (en) * | 2023-08-07 | 2023-11-07 | 上海哔哩哔哩科技有限公司 | Engine system, request processing method and device, computer equipment and storage medium |
| CN117113347A (en) * | 2023-08-24 | 2023-11-24 | 北京关键科技股份有限公司 | Large-scale code data feature extraction method and system |
Non-Patent Citations (1)
| Title |
|---|
| 孙梓森 , 原庆能: "C plus编译器设计", 广西工学院学报, no. 3, 30 December 2005 (2005-12-30) * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN117724804B (en) | 2024-06-14 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11036614B1 (en) | Data control-oriented smart contract static analysis method and system | |
| US5381547A (en) | Method for dynamically linking definable program elements of an interactive data processing system | |
| CN107041158B (en) | Restrictive access control for modular reflection | |
| US6523171B1 (en) | Enhanced source code translator from procedural programming language (PPL) to an object oriented programming language (OOPL) | |
| WO2019237701A1 (en) | Cross-language programming | |
| US20080189683A1 (en) | Direct Access of Language Metadata | |
| Jackson | Alloy 3.0 reference manual | |
| JPH06501583A (en) | How to configure the folding mechanism within a multilingual optimizing compiler | |
| CN111679852B (en) | Detection method and device for conflict dependency library | |
| CN110096264A (en) | A kind of code operation method and device | |
| US10846417B2 (en) | Identifying permitted illegal access operations in a module system | |
| US20170075668A1 (en) | Methods and Systems for Generating Client-Server Applications for Target Devices | |
| KR20040077410A (en) | System and method for defining and using subclasses declaratively within markup | |
| US20070044080A1 (en) | Structure initializers and complex assignment | |
| CN108664238A (en) | A kind of execution method and device of explanation type script C-SUB | |
| CN117724804B (en) | Virtual machine instruction set generation method, device and equipment | |
| CN114611500A (en) | Expression processing method and device, electronic equipment and computer readable storage medium | |
| CN111767033A (en) | Programming system for mechanical arm program development and function extension method | |
| Heitzinger | Algorithms with Julia | |
| Yin et al. | The Implementation of Simple Smart Contract Language and Its Compiler Based on Ethereum Platform | |
| JPH09179738A (en) | Object-oriented language processing method and processor | |
| Maliavko et al. | Functionally Imperative Programming Language El and its Implementation | |
| Jordan et al. | The Development of Lexer and Parser as parts of compiler for GAMA32 processor’s instruction-set using Python | |
| CN117075912B (en) | Method for program language conversion, compiling method and related equipment | |
| CN112162738B (en) | Data conversion method and device, terminal equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |