WO2023093134A1

WO2023093134A1 - Method and apparatus for generating system resource allocation code, and electronic device and medium

Info

Publication number: WO2023093134A1
Application number: PCT/CN2022/112144
Authority: WO
Inventors: 李鹏; 陈彬; 洪坤; 王波; 薛志宏; 李禄财; 何剑; 李翌
Original assignee: 中兴通讯股份有限公司
Priority date: 2021-11-25
Filing date: 2022-08-12
Publication date: 2023-06-01
Also published as: CN116166412A

Abstract

The embodiments of the present invention relate to the technical field of embedded systems. Disclosed are a method and apparatus for generating a system resource allocation code, and an electronic device and a medium. The method for generating a system resource allocation code comprises: according to a predefined meta-structure for describing components in an operating system, acquiring instantiation information, which is generated by each component during an instantiation process; and according to the instantiation information of each component and a preset code template corresponding to a component type, generating an allocation code for each component, so as to obtain a system resource allocation code.

Description

Method, device, electronic device and medium for generating system resource allocation code

technical field

The embodiments of the present application relate to the technical field of embedded systems, and in particular to a method, device, electronic device and medium for generating system resource allocation codes.

Background technique

The operating system kernel generally refers to the hardware-independent part. When it is actually ported to a specific single-board hardware, it needs to be linked and loaded together with the Board Support Package (Board Support Package, BSP) and user code. It is unacceptable in some critical areas such as aircraft because code errors outside the core of the operating system may cause the collapse of the entire system. Therefore, the operating system currently requires users to provide handwritten initialization codes and initial configurations. However, this method is prone to errors during subsequent system operation due to various reasons such as clerical errors, misunderstandings, and unreasonable configurations, and such errors are generally not The first scene is more difficult to investigate.

At present, the common practice in the industry is to describe the configuration of the system through an agreed format, such as Extensible Markup Language (XML), generate relevant configuration data, and analyze and apply the configuration when the system is running. Realize the allocation of system resources; the second way is to describe the abstract model of the system according to the Architecture Analysis and Design Language (AADL) language proposed by System Architecture Evolution (SAE), and finally carry out the allocation of system resources. distribute.

However, the first method above requires both the user and the operating system (Operating System) to fill in the configuration according to the same template. If a new resource description is added, the configuration template and related parsing code need to be changed to achieve scalability and flexibility. poor. The AADL in the above-mentioned second method is very large and complex, with 185 grammatical rules and more than 500 semantic rules. It is a design close to a general-purpose programming language, and it does not directly provide semantics related to system resource division. Developers need to design and develop again on the AADL framework, and the learning cost is relatively high.

Contents of the invention

The main purpose of the embodiments of the present application is to provide a method, device, electronic device and medium for generating system resource allocation codes, which can improve the scalability and flexibility of system resource allocation, and have low learning costs.

In order to achieve the above purpose, the embodiment of the present application provides a method for generating system resource allocation code, including: according to the predefined metastructure used to describe the components in the operating system, obtain the instance generated by each component during the instantiation process generation information; according to the instantiation information of each component and the preset code template corresponding to the component type, generate the allocation code of each component, and obtain the system resource allocation code.

In order to achieve the above purpose, the embodiment of the present application also provides a system resource allocation code generation device, including: an information acquisition module, used to acquire the components in the instance The instantiation information generated in the process of instantiation; the generation module is used to generate the allocation code of each component according to the instantiation information of each component and the preset code template corresponding to the component type, so as to obtain the system resource allocation code.

To achieve the above purpose, an embodiment of the present application further provides an electronic device, including: at least one processor; and a memory connected to the at least one processor in communication; wherein, the memory stores information that can be used by the at least one processor An instruction executed by a processor, the instruction is executed by the at least one processor, so that the at least one processor can execute the above method for generating system resource allocation code.

To achieve the above purpose, the embodiment of the present application further provides a computer-readable storage medium storing a computer program, and when the computer program is executed by a processor, the above-mentioned method for generating the system resource allocation code is implemented.

Description of drawings

One or more embodiments are exemplified by corresponding pictures in the drawings, and these exemplifications do not constitute a limitation to the embodiments, and elements with the same reference numerals in the drawings represent similar elements, Unless otherwise stated, the drawings in the drawings are not limited to scale.

FIG. 1 is a flowchart of a method for generating system resource allocation codes according to an embodiment of the present invention;

Fig. 2 is a flowchart of a method for defining a component metastructure provided according to an embodiment of the present invention;

Fig. 3 is a working flow diagram of a CDL compiler provided according to an embodiment of the present invention;

FIG. 4 is a structural diagram of system resource allocation code generation provided according to an embodiment of the present invention;

FIG. 5 is a flowchart of a method for generating system resource allocation codes according to another embodiment of the present invention;

FIG. 6 is a schematic diagram of an apparatus for generating system resource allocation codes according to another embodiment of the present invention;

Fig. 7 is a schematic structural diagram of an electronic device according to another embodiment of the present invention.

Detailed ways

In order to make the purpose, technical solutions and advantages of the embodiments of the present application clearer, the embodiments of the present application will be described in detail below with reference to the accompanying drawings. However, those of ordinary skill in the art can understand that in each embodiment of the application, many technical details are provided for readers to better understand the application. However, even without these technical details and various changes and modifications based on the following embodiments, the technical solutions claimed in this application can also be realized. The division of the following embodiments is for the convenience of description, and should not constitute any limitation to the specific implementation of the present application, and the embodiments can be combined and referred to each other on the premise of no contradiction.

An embodiment of the present invention relates to a method for generating system resource allocation codes, which is applied to servers. The specific implementation flowchart of the generation method of the system resource allocation code of the present embodiment is as shown in Figure 1, at least includes the following steps:

Step 101, according to the predefined metastructure used to describe the components in the operating system, obtain the instantiation information generated by each component during the instantiation process.

In step 102, according to the instantiation information of each component and the preset code template corresponding to the component type, the allocation code of each component is generated to obtain the system resource allocation code.

In this embodiment, according to the predefined metastructure used to describe the components in the operating system, the instantiation information generated by each component of the system during the instantiation process is obtained, and then according to the generated instantiation information of each component and the preset The code template corresponding to the component type is used to generate the allocation code of each component of the system, that is, the system resource allocation code is obtained. By predefining the meta structure used to describe the components in the operating system and the pre-set code templates corresponding to the component types, when adding a description of the resources required by a component, only the meta of the new component needs to be pre-defined The structure and pre-set the code template corresponding to the component type of the new component, which improves the scalability and flexibility of system resource allocation, and can automatically generate system resource allocation code without redesigning and developing on the AADL framework, learning The cost is lower.

The implementation details of the method for generating system resource allocation codes in this embodiment are described in detail below. The following content is only implementation details provided for easy understanding, and is not necessary for implementing this solution.

In step 101, the server obtains the instantiation information generated by each component during the instantiation process according to the predefined metastructure used to describe the components in the operating system.

Specifically, the accessible address space in the operating system can be used as a global resource, and a special language, namely Component Description Language (CDL), can be designed to describe the metastructure of each component in the operating system, so as to predict Defines the metastructure of components in the operating system. Then instantiate the component. During the instantiation process, the instantiation information of the component will be generated, that is, the relevant information of the metastructure of the component, for example, the ID name of the metastructure of the component, the specific value of the memory space occupied by the component, etc. .

Among them, the metastructure of the component includes: a unique identifier, component meta properties, initialized fixed properties and runtime variable properties. Fig. 2 is a flowchart of a method for defining a metastructure of a component, specifically including:

S201, define an identity identification number (Identity document, ID) of the component.

Among them, ID is used to describe the unique identification of the component.

S202, defining meta properties of the component.

Wherein, the component meta-attribute includes: the memory location of the component and/or the occupied memory size.

S203, define fixed attributes for component initialization.

Wherein, the initialized fixed attributes include one of the following or any combination thereof: the stack used by the system task, the base priority, and the entry address.

S204, define variable properties of the component during runtime.

Wherein, the variable attributes at runtime include: the running priority of the system task.

In a specific computer implementation, it is necessary to instantiate the component according to the metastructure of the component defined in the method shown in Figure 2, that is, first instantiate the unique identifier of the component, then instantiate the meta-property of the component, and then instantiate the initialization of the component Fixed properties, variable properties when the component is finally instantiated at runtime.

In step 102, the server generates allocation codes for each component according to the instantiation information generated during the instantiation process and a preset code template corresponding to the component type to obtain system resource allocation codes.

Specifically, firstly, the instantiation information generated during the instantiation process is translated into machine recognition code according to the preset translation rules, and then the preset code template is matched with the component type of the component to obtain the code template, and fill in the machine identification code into the code template corresponding to the component type, and finally generate the allocation code of each component to obtain the system resource allocation code.

Wherein, the code template is a code template provided according to a programming language, such as C language. Since the code template only contains the basic programming language framework and does not contain the instantiation information of the component, it is necessary to translate the instantiation information into the programming language according to the preset translation rules, that is, after the machine recognizes the code, fill in the machine recognition code In the code template of the programming language, the missing information of the code template is supplemented, the allocation code of each component is generated, and the system resource allocation code is obtained.

In one example, since system resource allocation code needs to be generated to generate a loadable execution image and execute the loadable execution image, the resource description of the component, that is, the instantiation information of the component is not a kind of machine identification code, so , the instantiation information of each component needs different translation rules to translate it into machine recognition code, and then fill the machine recognition code into the code template corresponding to the component type, wherein the translation rules need to be pre-defined according to the component type.

In the specific implementation, the CDL compiler (CDLCompiler) tool is used to convert the instantiation information into machine identification code according to the translation rules defined in advance for each component, and fill the machine identification code into the code template corresponding to the component type, and finally generate each The allocation code of the component is used to obtain the system resource allocation code. Figure 3 is the workflow diagram of CDLCompiler. The specific implementation process of CDLCompiler includes:

S301. The CDLCompiler parses the translation rules.

Among them, the specific process of parsing translation rules is as follows:

(1) Perform grammatical and semantic analysis on the translation rules;

(2) Check the type of the translation rule to obtain the intermediate expression.

S302. Interpret and execute the instantiation information of the component according to the translation rule to obtain the machine identification code.

S303, according to the machine identification code and the code template corresponding to the component type, generate the allocation code of each component, and obtain the system resource allocation code.

In one example, after the system resource allocation code is obtained, the system resource allocation code is combined with the implementation code of the system component to generate a loadable execution image, that is, a final executable program. Wherein, the implementation code of the system components includes: the core code of the system and the user code. By executing the loadable execution image, the allocation of system resources can be realized.

In one example, the structure diagram generated by the system resource allocation code of this embodiment can be shown in Figure 4, wherein component.tr is the translation rule, component.cdl is the instantiation information of the component, and init.c is the system resource allocation Code, the OS component is the implementation code of the system component, (Executable and Linking Format, ELFImage) is the loadable execution image of the system.

It should be noted that, the above-mentioned examples in this embodiment are illustrations for easy understanding, and do not limit the technical solution of the present invention.

In this embodiment, after obtaining the instantiation information generated by each component during the instantiation process according to the predefined metastructure used to describe the components in the operating system, a tool is used to automatically generate system resource allocation code, avoiding handwritten code An error occurs that affects the health of the system.

The step division of the above various methods is only for the sake of clarity of description. During implementation, it can be combined into one step or some steps can be split and decomposed into multiple steps. As long as they include the same logical relationship, they are all within the scope of protection of this patent. ; Adding insignificant modifications or introducing insignificant designs to the algorithm or process, but not changing the core design of the algorithm and process are all within the scope of protection of this patent.

Another embodiment of the present invention relates to a method for generating system resource allocation codes. The implementation details of the method for generating system resource allocation codes in this embodiment are described in detail below. It is necessary to implement this solution, and Fig. 5 is a flow chart of the generation method of the system resource allocation code described in this embodiment, which at least includes the following steps:

Step 501, according to the predefined metastructure used to describe the components in the operating system, obtain the instantiation information generated by each component during the instantiation process.

Wherein, step 501 is substantially the same as step 101, and will not be repeated here.

Step 502, according to the instantiation information of each component, check the rationality of the instantiation information of each component.

Specifically, the server traverses the resources required by each component according to the acquired instantiation information of each component, and detects the memory space occupied by each component. There is no overlap in the memory space occupied by each component, and If the maximum value and the minimum value of the memory space of each component are within the legal range, the rationality test is passed. Wherein, the legal range is the range specified by the system. According to the instantiation information of each component, the resources required by each component can be obtained, and then the memory space occupied by each component is detected to obtain the resource allocation of the system, so as to judge whether the allocation is reasonable according to the system regulations.

Step 503 , after passing the rationality test, execute to generate the distribution code of each component according to the instantiation information of each component and the preset code template corresponding to the component type.

Specifically, if the maximum and minimum values of the memory space of each component are within the legal range, it indicates that the instantiation information of each component has passed the rationality test. The code template corresponding to the component type generates the allocation code of each component, and obtains the system resource allocation code, so as to achieve the purpose of rational allocation of system resources and make the system run normally.

In one example, if the maximum value and the minimum value of the memory space of each component and/or are not within the legal range, it indicates that the instantiation information of each component has not passed the rationality check, therefore, the instantiation information according to each component will not be executed Information and pre-set code templates corresponding to component types generate the operation of the allocation code of each component to avoid unreasonable allocation of system resources.

In related technologies, system resources are allocated according to the operating status of the system. This way of dynamically allocating system resources will affect the predictability and stability of the system. Allocate resources for each component, that is, statically allocate resources, and rationalize the instantiation information of each component before generating the allocation code of each component according to the instantiation information of each component and the preset code template corresponding to the component type Detection can identify unreasonable resource allocation before the system runs, avoiding the influence of unreasonable system resource allocation on the operating status of the system, and improving the predictability and stability of the system.

Another embodiment of the present invention relates to a device for generating system resource allocation codes. The details of the device for generating system resource allocation codes in this embodiment are described in detail below. The following content is only implementation details provided for easy understanding, not implementation Needless to this example, FIG. 6 is a schematic diagram of a system resource allocation code generation device described in this embodiment, including: an information acquisition module 601 and a generation module 602 .

Specifically, the information acquiring module 601 is configured to acquire the instantiation information generated by each component during the instantiation process according to the predefined metastructure used to describe the components in the operating system.

The generating module 602 is configured to generate allocation codes of each component according to the instantiation information of each component and a preset code template corresponding to the component type, so as to obtain the system resource allocation code.

In an example, the generation module 602 is further configured to translate the instantiation information into machine identification codes according to preset translation rules; and fill the machine identification codes into the code template corresponding to the component type.

In an example, the generation module 602 is further configured to, after obtaining the system resource allocation code, combine the system resource allocation code with the implementation code of the system component to generate a loadable execution image.

In one example, the generation module 602 is further configured to generate the distribution code of each component according to the instantiation information of each component and the preset code template corresponding to the component type, The instantiation information of each component is checked for rationality; after passing the reasonableness check, the allocation code of each component is generated according to the instantiation information of each component and the preset code template corresponding to the component type.

It is not difficult to find that this embodiment is an apparatus embodiment corresponding to the above method embodiment, and this embodiment can be implemented in cooperation with the above method embodiment. The relevant technical details and technical effects mentioned in the above embodiments are still valid in this embodiment, and will not be repeated here to reduce repetition. Correspondingly, the relevant technical details mentioned in this embodiment can also be applied in the above embodiments.

It is worth mentioning that all the modules involved in this embodiment are logical modules. In practical applications, a logical unit can be a physical unit, or a part of a physical unit, or multiple physical units. Combination of units. In addition, in order to highlight the innovative part of the present invention, units that are not closely related to solving the technical problem proposed by the present invention are not introduced in this embodiment, but this does not mean that there are no other units in this embodiment.

Another embodiment of the present invention relates to an electronic device, as shown in FIG. 7 , including: at least one processor 701; and a memory 702 communicatively connected to the at least one processor 701; wherein, the memory 702 stores An instruction that can be executed by the at least one processor 701, the instruction is executed by the at least one processor 701, so that the at least one processor 701 can execute the system resource allocation code method in each of the foregoing embodiments.

Wherein, the memory and the processor are connected by a bus, and the bus may include any number of interconnected buses and bridges, and the bus connects one or more processors and various circuits of the memory together. The bus may also connect together various other circuits such as peripherals, voltage regulators, and power management circuits, all of which are well known in the art and therefore will not be further described herein. The bus interface provides an interface between the bus and the transceivers. A transceiver may be a single element or multiple elements, such as multiple receivers and transmitters, providing means for communicating with various other devices over a transmission medium. The data processed by the processor is transmitted on the wireless medium through the antenna, further, the antenna also receives the data and transmits the data to the processor.

The processor is responsible for managing the bus and general processing, and can also provide various functions, including timing, peripheral interface, voltage regulation, power management, and other control functions. Instead, memory can be used to store data that the processor uses when performing operations.

Another embodiment of the present invention relates to a computer-readable storage medium storing a computer program. The above method embodiments are implemented when the computer program is executed by the processor.

That is, those skilled in the art can understand that all or part of the steps in the method of the above-mentioned embodiments can be completed by instructing related hardware through a program, the program is stored in a storage medium, and includes several instructions to make a device ( It may be a single-chip microcomputer, a chip, etc.) or a processor (processor) to execute all or part of the steps of the methods described in the various embodiments of the present application. The aforementioned storage media include: U disk, mobile hard disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), magnetic disk or optical disc, etc., which can store program codes. .

Those of ordinary skill in the art can understand that the above-mentioned embodiments are specific examples for realizing the present invention, and in practical applications, various changes can be made to it in form and details without departing from the spirit and spirit of the present invention. scope.

Claims

A method for generating system resource allocation codes, including:

Obtain the instantiation information generated by each component during the instantiation process according to the predefined metastructure used to describe the components in the operating system;

According to the instantiation information of each component and the preset code template corresponding to the component type, the allocation code of each component is generated to obtain the system resource allocation code.
The method for generating system resource allocation codes according to claim 1, wherein the generating the allocation codes of the components according to the instantiation information of the components and the preset code template corresponding to the component type includes :

Translating the instantiated information into machine identification codes according to preset translation rules;

Filling the machine identification code into the code template corresponding to the component type.
The method for generating a system resource allocation code according to claim 1, wherein, after said obtaining the system resource allocation code, further comprising:

The system resource allocation code is combined with the implementation code of the system component to generate a loadable execution image.
The method for generating system resource allocation codes according to any one of claims 1 to 3, wherein said each component is generated according to the instantiation information of each component and a preset code template corresponding to the component type The component's allocation code, including:

Performing a rationality check on the instantiation information of each component according to the instantiation information of each component;

After passing the rationality check, execute the code template corresponding to the component type according to the instantiation information of each component and the preset code template to generate the allocation code of each component.
The method for generating system resource allocation codes according to claim 4, wherein said checking the rationality of the instantiation information of said components comprises:

Traversing the resources required by the components according to the instantiation information of the components;

Detecting the memory space occupied by each component;

When the memory spaces occupied by the various components do not overlap, and the maximum and minimum values of the memory spaces of the various components are both within a legal range, the rationality test is passed.
The method for generating system resource allocation code according to any one of claims 1 to 3, wherein the metastructure of the component comprises:

Unique identifiers, component meta properties, fixed properties at initialization, and mutable properties at runtime.
The generation method of system resource allocation code according to claim 6, wherein,

The component meta-attributes include: the memory location of the component and/or the occupied memory size;

The fixed attributes of the initialization include at least one of the following: the stack used by the system task, the base priority, and the entry address;

The variable attributes at runtime include: the running priority of the system task.
A device for generating system resource allocation codes, including:

An information acquisition module, configured to acquire instantiation information generated by each component during the instantiation process according to a predefined metastructure used to describe the components in the operating system;

The generating module is configured to generate the allocation codes of the components according to the instantiation information of the components and the preset code templates corresponding to the component types, so as to obtain the system resource allocation codes.
An electronic device, comprising:

at least one processor; and,

a memory communicatively coupled to the at least one processor; wherein,

The memory stores instructions executable by the at least one processor, the instructions are executed by the at least one processor, so that the at least one processor can perform the operation described in any one of claims 1 to 7 The generation method of the system resource allocation code described above.
A computer-readable storage medium storing a computer program, wherein, when the computer program is executed by a processor, the method for generating the system resource allocation code according to any one of claims 1 to 7 is realized.