CN110825351B - Calculation method for software occupying RAM+ROM capacity in embedded ECU - Google Patents

Abstract

The invention discloses a calculation method for the capacity of RAM+ROM occupied by software in an embedded ECU, comprising the steps of providing a standard software library, wherein the standard software library comprises library modules, and each library module corresponds to the consumption of the RAM+ROM correspondingly used by the library module; after software writing is carried out by using library modules in a standard software library, calculating the sum of the RAM and ROM consumption of the used library modules; and judging the relation between the sum of the consumption and the hardware capacity, and returning to the previous step to replace the library module if the hardware capacity is exceeded. The beneficial effects of the invention are mainly as follows: the method has the advantages that in the software design stage, whether the RAM/ROM consumption of the software exceeds the ECU hardware limit can be judged, the software design can be adjusted in time, the problem is not found until the production stage is completed, and the cost is saved; the introduction of the standard software module library enables the software development process to be more standardized, and the software quality to be ensured.

Description

Calculation method for software occupying RAM+ROM capacity in embedded ECU

Technical Field

The invention belongs to the technical field of software development, and particularly relates to a method for calculating the capacity of RAM+ROM occupied by software in an embedded ECU.

Background

The software design method based on the model is widely applied to product development such as automobile electric control and industrial control. In order to meet the requirements of high real-time performance, high safety and low cost, the industries such as automobile electronics and the like have certain capacity use restrictions on the writing requirements of embedded software. However, before the target compiler compiles and links, the size of ram+rom occupied by the compiled software cannot be obtained.

In most circuitry, the RAM used by the system is specified by the designer at the time of hardware design, the capacity of the RAM is already fixed, and all program operations on the RAM operate according to the previously fixed RAM capacity. However, with the change of external conditions, such as the change of design requirement, the shutdown of RAM chip, etc., the hardware system may generate the requirement of RAM replacement, which may cause the change of RAM capacity. However, the hardware system cannot automatically adjust along with the change under the condition that the RAM capacity is changed, so that a designer is often required to re-write a software program, a great deal of manpower and energy are consumed, and the compatibility and expansibility of the hardware system cannot be well realized.

At present, the software compiling method in the embedded ECU generally comprises the steps of firstly compiling software main body codes, then configuring the software main body codes to a special compiling environment corresponding to hardware, then compiling and linking the software main body codes, obtaining the consumption of ram+rom from a target file and a MAP file, and if the consumption exceeds the hardware capacity, returning to modify and re-compiling the software main body codes, so that the operation is too time-consuming and labor-consuming.

Disclosure of Invention

The invention aims to solve the technical problems and provides a calculation method for the capacity of the RAM and the ROM occupied by software in an embedded ECU, which can acquire the consumption of the RAM and the ROM occupied by the software without compiling links in the software design stage.

In order to achieve the above object, the present invention provides the following solutions:

a calculation method for the capacity of RAM+ROM occupied by software in an embedded ECU comprises the following steps:

step S1, providing a standard software library, wherein the standard software library comprises library modules, and each library module corresponds to the corresponding using amount of RAM+ROM;

s2, after software writing is carried out by using library modules in a standard software library, calculating the sum of the RAM and ROM of the used library modules;

and S3, judging the relation between the sum of the consumption and the hardware capacity, and returning to the step S2 to replace the library module if the hardware capacity is exceeded.

Preferably, in the step S1, the RAM usage is estimated according to the number of variables and the data type in each library module.

Preferably, "estimating RAM usage based on the number of variables and data type in each library module" specifically includes,

step S11, calculating the consumption of variable RAM to be initialized, and multiplying the data type occupation amount of the variable to be initialized contained in the library module by the number of the variable to be initialized;

step S12, calculating the consumption of the RAM of the uninitialized global variable and the static variable in the program, determining the compiling environment of the software, and counting the consumption of the RAM occupied by the uninitialized global variable or static variable of the library module under the appointed compiling environment;

and step S13, summing the calculation results of the steps S11 and S12 to obtain the RAM consumption occupied by the library module.

Preferably, in the step S1, the ROM usage is estimated according to the self-capacity in the code, the number and data type of the constant/lookup table, and the data type and number used for initializing the variables.

Preferably, "estimating the ROM usage based on the own capacity of the code, the number and data type of the constant/lookup table, and the data type and number used for variable initialization" specifically includes,

s101, calculating the ROM consumption of the capacity of the code, and inquiring the code length, namely the ROM consumption occupied by the capacity of the code of the library module;

step S102, calculating the consumption of the constant ROM, and multiplying the data type occupation of the constant by the dimension to obtain the consumption of the constant ROM;

step S103, calculating the ROM consumption of the lookup table, adopting the mode of step S102 to calculate the ROM consumption of all constants in the lookup table, and summing the ROM consumption of all constants to obtain the ROM consumption of the lookup table;

step S104, calculating the consumption of the variable initial value ROM, and multiplying the data type occupation amount of the variable initial value by the number of the variable initial value;

step 105, summing the calculation results of steps 101 to 104 to obtain the ROM usage occupied by the library module.

Preferably, the step S2 includes determining whether different library modules are combined together, and when the sub-modules in the different library modules are the same, the same sub-module calculates the ROM usage only once.

Preferably, the step S2 includes determining whether there are multiple copies of the subsystem in the software, and the specific steps include,

s21, judging the copy number of the subsystem, and judging whether each copy is set to be reusable;

step S22, judging whether the constants, the lookup table and the variable initial values of the reusable copies are the same, and if so, calculating the ROM consumption only once.

The beneficial effects of the invention are mainly as follows:

1. the method has the advantages that in the software design stage, whether the RAM/ROM consumption of the software exceeds the ECU hardware limit can be judged, the software design can be adjusted in time, the problem is not found until the production stage is completed, and the cost is saved;

2. the introduction of the standard software module library enables the software development process to be more standardized, and the software quality is ensured;

3. the use of the design personnel is convenient, and the time and the labor are saved;

4. the invention has strict design and accurate result;

5. the invention can be directly applied to the software design in the embedded ECU, and can also be applied to the software development design of the traditional handwriting codes.

Drawings

In order to more clearly illustrate the embodiments of the present invention or the technical solutions of the prior art, the drawings that are needed in the embodiments will be briefly described below, it being obvious that the drawings in the following description are only some embodiments of the present invention, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.

FIG. 1 is a flow chart of a software compiling method in an embedded ECU in the prior art;

FIG. 2 is a schematic flow chart of a calculation method of the capacity of the RAM+ROM occupied by software in the embedded ECU;

FIG. 3 is a schematic diagram of a common library module of a common platform Simulink for embedded ECU development according to an embodiment of the present invention;

FIG. 4 is a calculation embodiment of the constant assignment state of the present invention;

FIG. 5 is a first exemplary embodiment of the present invention in a multiply-calculate state;

FIG. 6 is a second embodiment of the present invention in a multiply-calculate state.

Detailed Description

The following description of the embodiments of the present invention will be made clearly and completely with reference to the accompanying drawings, in which it is apparent that the embodiments described are only some embodiments of the present invention, but not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.

In order that the above-recited objects, features and advantages of the present invention will become more readily apparent, a more particular description of the invention will be rendered by reference to the appended drawings and appended detailed description.

As shown in fig. 2, the invention discloses a method for calculating the capacity of ram+rom occupied by software in an embedded ECU, comprising the following steps:

step S1, providing a standard software library, wherein the standard software library comprises library modules, and each library module corresponds to the corresponding using amount of RAM+ROM;

s2, after software writing is carried out by using library modules in a standard software library, calculating the sum of the RAM and ROM of the used library modules;

and S3, judging the relation between the sum of the consumption and the hardware capacity, and returning to the step S2 to replace the library module if the hardware capacity is exceeded.

In the step S1, the RAM usage is estimated according to the number of variables and the data type in each library module.

Generally, the RAM usage specifically includes:

(1) the variable Data to be initialized, the number of the variables to be initialized and the Data type of the variables to be initialized contained in each library module are determined; the data types occupy different memory spaces, for example, double type occupies 8 bytes, float type occupies 4 bytes, and uint8 occupies one byte. Multiplying the occupied amount of each Data type by the number to obtain the RAM occupied amount of the library module in the Data item;

(2) the global variable and the static variable BSS which are not initialized in the program are cleared before the software runs. Typically, no or little executable file usage is taken into account.

Thus, "estimating RAM usage based on the number of variables and data type in each library module" specifically includes,

step S11, calculating the consumption of variable RAM to be initialized, and multiplying the data type occupation amount of the variable to be initialized contained in the library module by the number of the variable to be initialized;

step S12, calculating the consumption of the RAM of the uninitialized global variable and the static variable in the program, determining the compiling environment of the software, and counting the consumption of the RAM occupied by the uninitialized global variable or static variable of the library module under the appointed compiling environment; because the uninitialized global variable or static variable is related to a module used by software and is also related to a compiling environment (compiler linker), and the corresponding code form of the module is implicit, the RAM usage (i.e. bss segment) occupied by the uninitialized global variable or static variable of each library module in a specified compiling environment needs to be counted through experiments;

and step S13, summing the calculation results of the steps S11 and S12 to obtain the RAM consumption occupied by the library module.

In the step S1, the ROM usage is estimated according to the self capacity in the code, the number and data type of the constant/lookup table, and the data type and number used for initializing the variables.

Generally, the ROM usage includes the sum of three parts:

(1) the code self capacity Program, the code length of each library module is determined, and the code length is the ROM usage occupied by the library module in the Program item;

(2) the number of constants contained in each library module and the data type are determined; the number of constants contained in the table in the lookup table contained in each library module and the data type are determined;

for the constant, the constant may be a number, a vector or a matrix, but the data type of each element is the same, and the ROM usage is obtained by multiplying the data type occupation amount by the dimension;

for the lookup table, the lookup table contains a plurality of constants, and the sum of the ROM usage of the lookup table is obtained by calculating the ROM usage of the plurality of constants through the steps;

the sum of all constants and the ROM consumption of the lookup table is the sum of the Constant consumption;

(3) the initial value Data of the variable, the Data and the Data type of the initial value of the variable contained in each library module are determined; the Data type occupation amount of each variable initial value is multiplied by the number to obtain the ROM occupation amount occupied by the database module in the Data item.

Thus, "estimating the ROM usage based on the self-capacity of the code, the number and data type of the constant/lookup table, and the data type and number used for variable initialization" specifically includes:

s101, calculating the ROM consumption of the capacity of the code, and inquiring the code length, namely the ROM consumption occupied by the capacity of the code of the library module;

step S102, calculating the consumption of the constant ROM, and multiplying the data type occupation of the constant by the dimension to obtain the consumption of the constant ROM;

step S103, calculating the ROM consumption of the lookup table, adopting the mode of step S102 to calculate the ROM consumption of all constants in the lookup table, and summing the ROM consumption of all constants to obtain the ROM consumption of the lookup table;

step S104, calculating the consumption of the variable initial value ROM, and multiplying the data type occupation amount of the variable initial value by the number of the variable initial value;

step 105, summing the calculation results of steps 101 to 104 to obtain the ROM usage occupied by the library module.

The present invention also contemplates a variety of special situations. For example, the step S2 includes determining whether different library modules are combined together, and when the sub-modules in the different library modules are the same, the same sub-module calculates the ROM usage only once.

When there are multiple copies of the subsystem in the software, estimating the occupied capacity can have the problem of repeated statistics. The multiple copies of the subsystem are reusable, the multiple copies generate a single Program, but the Constant and Data portions of the ROM may each be different, and the Data portion of the RAM may be different. This also cannot be simply superimposed, so that step S2 of the present invention includes determining whether there are multiple copies of the subsystem in the software, and includes the specific steps of:

s21, judging the copy number of the subsystem, and judging whether each copy is set to be reusable;

step S22, judging whether the constants, the lookup table and the variable initial values of the reusable copies are the same, and if so, calculating the ROM consumption only once.

The following description will take embedded ECU development common platform Simulink as an example, and the estimation method of the present invention will be described by combining the above steps. Common library modules of Simulink are shown in fig. 3, and include common calculation modules, and application software can be formed by extracting the required module library from the following libraries and splicing the modules.

Example 1: constant assignment

As shown in fig. 4, the Constant module implements a Constant assignment function, and the double type occupies 8 bytes of ROM; the RAM consumption is not occupied. (Out module is only interface, not occupied)

Example 2: multiplication computation

As shown in fig. 5, the GAIN module implements a single-input multiplication function, and the double-type single-input multiplication calculation code itself occupies 16 bytes, and also contains a constant which occupies 8 bytes, so that the total occupies 24 bytes. (In 1, out1 module is only interface, not occupied)

When different library modules are combined together, the estimated usage cannot be simply accumulated. As shown in fig. 6, the constant module is combined with the single-input multiplication module:

the usage calculation for this software mode cannot be simply summed with the usage of the Gain (24 bytes) module by Constant (8 bytes) to reach a conclusion of 32 bytes. The VAR in the Constant module is the same as the VAR of the GAIN module, and occupies only one ROM, and the calculation should not be repeated. The total ROM usage is also 32 bytes.

The principles and embodiments of the present invention have been described herein with reference to specific examples, the description of which is intended only to assist in understanding the methods of the present invention and the core ideas thereof; also, it is within the scope of the present invention to be modified by those of ordinary skill in the art in light of the present teachings. In view of the foregoing, this description should not be construed as limiting the invention.

Claims (3)

1. A calculation method for the capacity of RAM+ROM occupied by software in an embedded ECU is characterized by comprising the following steps:

step S1, providing a standard software library, wherein the standard software library comprises library modules, and each library module corresponds to the corresponding using amount of RAM+ROM;

s2, after software writing is carried out by using library modules in a standard software library, calculating the sum of the RAM and ROM of the used library modules;

s3, judging the relation between the sum of the consumption and the hardware capacity, and returning to the step S2 to replace the library module if the hardware capacity is exceeded;

in the step S1, the RAM usage is estimated according to the number of variables and the data type in each library module, which specifically includes,

step S11, calculating the consumption of variable RAM to be initialized, and multiplying the data type occupation amount of the variable to be initialized contained in the library module by the number of the variable to be initialized;

step S12, calculating the consumption of the RAM of the uninitialized global variable and the static variable in the program, determining the compiling environment of the software, and counting the consumption of the RAM occupied by the uninitialized global variable or static variable of the library module under the appointed compiling environment;

step S13, summing the calculation results of the steps S11 and S12 to obtain the RAM consumption occupied by the library module;

in the step S1, the ROM usage is estimated based on the self-capacity in the code, the number and data type of the constant/lookup table, and the data type and number used for initializing the variables, specifically including,

s101, calculating the ROM consumption of the capacity of the code, and inquiring the code length, namely the ROM consumption occupied by the capacity of the code of the library module;

step S102, calculating the consumption of the constant ROM, and multiplying the data type occupation of the constant by the dimension to obtain the consumption of the constant ROM;

step S103, calculating the ROM consumption of the lookup table, adopting the mode of step S102 to calculate the ROM consumption of all constants in the lookup table, and summing the ROM consumption of all constants to obtain the ROM consumption of the lookup table;

step S104, calculating the consumption of the variable initial value ROM, and multiplying the data type occupation amount of the variable initial value by the number of the variable initial value;

step 105, summing the calculation results of steps 101 to 104 to obtain the ROM usage occupied by the library module.

2. The method according to claim 1, wherein the step S2 includes determining whether different library modules are used together, and when the sub-modules in the different library modules are identical, the same sub-module calculates the ROM usage only once.

3. The method according to claim 1, wherein the step S2 includes determining whether there are multiple copies of the subsystem in the software, and the specific steps include,

s21, judging the copy number of the subsystem, and judging whether each copy is set to be reusable;

step S22, judging whether the constants, the lookup table and the variable initial values of the reusable copies are the same, and if so, calculating the ROM consumption only once.