JP2005346272A - Memory-using method for data of structure-type array - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To simultaneously handle a plurality data in a storage area and make it easy to handle data which are defined outside, by reducing memory usage of variable array of a structure. <P>SOLUTION: An area to be used for a memory is set (82), and the remaining area is found when an area using a certain variable in the whole area of the memory is set (83, 84 and 85), and the memory is permitted to be used by another variable in accordance with the remaining area (86). Then, a processing procedure for writing the variable to be used for a function to be written in the memory is determined (87), and another variable is coupled with a certain variable (88) according to the writing processing procedure, and the variable thus coupled is described as a certain variable corresponding to a certain variable (89). <P>COPYRIGHT: (C)2006,JPO&NCIPI

Description

  The present invention relates to a method of using a memory of structure type array data used for program data such as C language.

  Specifically, it reduces the amount of memory used when accessing unsigned type data in a structure type array used for program data such as C language. The present invention relates to a field that places importance on the applicability of software that does not depend on processing systems, such as digital home appliances that perform signal processing using software.

  In the case of a structure type array, in the conventional method, as shown in FIG. 9, one data 98 is assigned to members 92, 93, 94, 95, 96, 97 indicating one variable by a structure type declaration 91. It was. Accordingly, the memory usage increases as the number of data included in the structure increases.

  Further, FIG. 10 shows an example of a conventional memory-type device using a structure type array. In FIG. 10, a conventional memory using device 102 is controlled by the control means 101 and a program (not shown), and stores a memory 103 for storing structure type members 92, 93, 94, 95, 96, and 97, and a structure type member 92. , 93, 94, 95, 96, 97, and a memory 104 for storing structure type members 92, 93, 94, 95, 96, 97 and data 98 to which the members are assigned. .

  In addition, as shown in FIG. 11, when a bit field that determines how many bits of one variable are used, the variables 112, 113, 114, and 115 by the structure type declaration 111 can be handled in bit units. A plurality of data can be packed with one variable and stored in the memory 116, but in this case, how the data is handled varies greatly depending on the processing system.

  As shown in FIG. 12, whether a field in which variables 122, 123, 124, and 125 according to a structure type declaration 121 are assigned in units of bits is assigned from right to left or left to right in the memory 126 is processed. It depends on the compiler of the system.

  Further, as shown in FIG. 13, when a field to which variables 132, 133, 134, 135, 136 assigned by a structure type declaration 131 are allocated in bit units is stored in the memory 137, as shown by 138, this bit Whether a field setting is allowed to cross variable boundaries also depends on the implementation. For this reason, the method using a bit field is not suitable for using data originally defined outside the bit field.

  As shown in FIG. 14, when unions are used as the variables 142, 143, 144, and 145 in the structure type declaration 141, variable data having different types can be handled in one storage area. For this reason, arbitrary combinations are possible as indicated by 146, and since only one data can be held as indicated by 147, sequential access is possible.

  However, a plurality of different data cannot be shared simultaneously in one storage area. For this reason, it becomes non-exclusive as shown at 148, and when two different data are written at the same time as shown at 149, only the last written data is held, so the first data does not remain.

  FIG. 15 shows a flowchart of a conventional method for reading data from a structure. FIG. 16 shows a flowchart of a conventional method for writing data to a structure. Each operation of the flowchart will be described.

At the time of reading, in FIG. 15, data to be read from the structure member is loaded from the memory into the register (F41).
Next, the data is read from the register and stored in a memory variable that holds the read data (F42).

At the time of writing, in FIG. 16, data to be written to the structure member is loaded from the memory to the register (F51).
Next, the data to be written is stored in the structure member on the memory from the register (F52).

  An example of a conventional C language program is shown below. Assume that a structure like the following number 1 is declared.

[Equation 1]
typedef struct {
unsigned int data_a;
char data_b;
} STRUCT_DATA;

Equation 1 indicates that, as a structure declaration, integer type data a without a sign bit and signed data b are named STRUCT_DATA.
Furthermore, it is assumed that the structure is declared as an array as shown in Equation 2 below.

[Equation 2]
STRUCT_DATA tmp_data [120];

Equation 2 indicates that an actual storage area of 120 bits is secured as the number of STRUCT_DATA.
Here, at the time of the reading process, a reading operation as shown in the following Equation 3 is performed.

[Equation 3]
void read_data (STRUCT_DATA * s_data, short index, unsigned int * read_a, char * read_b) {

* read_a = s_data [index]->data_a;
* read_b = s_data [index]->data_b;

return;
}

Equation 3 shows an operation of reading data a and data b indicated by the pointer addresses as STRUCT_DATA.
Further, during the writing process, a writing operation as shown in the following equation 4 is performed.

[Equation 4]
void write_data (STRUCT_DATA * s_data, short index, unsigned intwrite_a, char write_b) {

s_data [index]-> data_a = write_a;
s_data [index]-> data_b = write_b;

return;
}

Equation 4 shows an operation of writing data a and data b indicated by the pointer addresses as STRUCT_DATA.
As a general method of using a memory, there is a technique shown in Patent Document 1 by the present applicant.
Japanese Patent Laid-Open No. 08-272657

  The conventional method described above has a disadvantage that the memory usage of the array increases as the number of members indicating the variables of the structure increases. Further, when a union is used, there is a disadvantage that a plurality of data cannot be handled simultaneously for one storage area. Further, when the bit field is used, there is a disadvantage that the way of handling the data depends on the processing system and is not suitable for handling the data defined outside.

  Therefore, the present invention reduces the amount of memory used by the variable array of structures, enables the handling of a plurality of data simultaneously for one storage area, and facilitates the handling of data defined externally. An object of the present invention is to provide a method of using memory of structure type array data that can be generated.

  In order to solve the above-described problems and achieve the object of the present invention, the method of using the data of the structure type array of the present invention sets an area to be used for the memory and uses a certain variable in the entire area of the memory. Find the surplus area when setting the area, allow the use of other variables for the memory according to the surplus area, and determine the procedure for writing variables used for functions written to the memory. According to the write processing procedure, another variable is synthesized with a certain variable, and the synthesized variable is described as a certain variable corresponding to the certain variable.

  In addition, the memory use method of the structure type array data of the present invention sets the area to be used for the memory, obtains the surplus area when setting the area to use a certain variable in all areas of the memory, Depending on the area of the memory, the use of other variables for the memory is permitted, the read processing procedure of the variable used for the function that is written by combining with the variable that has other variables for the memory is determined, and the read processing According to the procedure, another variable is separated from a certain variable, and the separated other variable is described as a certain variable corresponding to the certain variable.

  As described above, in the present invention, as shown in FIG. 1, the amount of data indicating the range 5 of data actually used for a certain member 2, 3 and 4 indicating the variable of the structure according to the declaration 1 of the structure type is set. Pay attention and calculate in advance how far bit 6 (0-21 bits) actually used will be used for the allowable range (0-31 bits) of the data type of declared members 2, 3, 4 In addition, by assigning data 8 (0 to 8 bits) of other members to unused bits 7 (22 to 31 bits) that become the free capacity of the member, a plurality of data 9 is assigned to one member 13. , 10 coexist.

For example, when accessing the data of a structure when the member is an unsigned type, if it is known in advance that a certain bit from the most significant bit of the member to the lower direction is always unused, the processing system is big. Regardless of the little endian, the memory usage of the structure can be reduced by allocating unused bits of the member to different data at the same time.
Further, when the structure array is declared to use a plurality of variables, the memory usage of the structure can be reduced.

  Also, when accessing a structure, how to read data A of a specific size assigned to unused upper bits of a member, how to read the remaining data B from the same member, or unused upper bits of a member The memory usage of the structure is reduced by determining the procedure for writing to the data A of a specific size assigned to the bits and writing to the remaining data B of the member.

  According to the present invention, it is possible to reduce the memory usage with respect to the conventional method while maintaining the data amount to be handled as it is. In addition, unlike a shared object, a plurality of independent data can be handled independently in one storage area, and handling of externally defined data is easy because it does not depend on a processing system like a bit field. .

  For example, when unsigned int type members and char (or unsigned char) type members are grouped together, if the number of arrays is 1024, the memory usage can be reduced by 1 kbyte. When unsigned int type members and unsigned short type members are grouped together, if the number of arrays is 1024, the memory usage can be reduced by 2 kbytes.

  The present invention relates to a technique for reducing the amount of memory used by allowing a plurality of data to coexist in one member when accessing unsigned type data in a structure type array.

  As shown in FIG. 2, in the case of a 32-bit CPU, when the type declaration of a structure member is an unsigned int type 21, the data amount 22 that can be handled is 0 to 4294967295, but the data amount 23 that is actually handled is 0 to 16777215, for example. If so, 8 bits are unused 24 and are free.

  When data in a range that can be handled by this vacant bit field 24 is used by other members of the same structure, two data can coexist in one member.

  The present invention is applied only to unsigned type data. Therefore, it cannot be applied to other signed type or floating point type data.

  FIG. 4 shows a flowchart for reading data according to the present invention. Similarly, FIG. 5 shows a flowchart for writing data. A flowchart for packing data is shown in FIG. Each operation of the flowchart will be described.

First, at the time of data reading, in FIG. 4, the unsigned int type member of the structure to be read is loaded from the memory into the register A (F1).
Next, it is determined whether data A or data C is read (F2).
If the data A is read out, it is masked with 0x00FFFFFF in order to read out the lower 24 bits of the member (F3).
Next, the masked data is stored in the register B (F4).
Then, the data in the register B is stored in the memory (F5).

If data C is to be read, the data is masked with 0xFF000000 and shifted to the right by 15 bits in order to read the upper 8 bits of the member (F6).
Next, the masked data is stored in the register B (F7).
Then, the data in the register B is stored in the memory (F8).
This completes the data reading (F9).

Next, when writing data, in FIG. 5, the unsigned int type member of the structure to be written is loaded from the memory into the register A (F11).
Next, the data to be written is loaded from the memory to the register B (F12).
It is determined whether data A or C is to be written (F13).

If data A is to be written, data C is taken out for backup (F14). Here, the data masked with 0xFF000000 is loaded into the register C.
Once the data to be written is masked with 0x00FFFFFF, it is stored in register A (F15).
Next, the data C of the backup register C is stored in the register A by a logical OR for each bit (F16).
Then, the data of the register C is stored in the memory (F17).

If the data C is to be written, the data A is taken out for backup (F18). Here, the data masked with 0x00FFFFFF is loaded into the register C.
Once the data to be written is masked with 0xFF000000, it is stored in register A (F19).
Next, the data A of the backup register C is stored in the register A by a logical OR for each bit (F20).
Then, the data of the register C is stored in the memory (F21).
This completes the data writing (F22).

Next, at the time of data packing, in FIG. 6, the corresponding member of the structure for packing data A and data B is loaded from the memory into the register (F31).
First, the corresponding member of the structure to be packed is initialized with 0 (F32).
Next, data A to be written to the corresponding member is loaded from the memory to the register (F33).
Further, data B to be written to the corresponding member is loaded from the memory to the register (F34).

Here, the data B is shifted to the left in advance by the size of the data A, and then the data A and the data B are packed by a logical OR for each bit and held in the register (F35).
Then, the packed data is stored from the register to the storage area on the memory of the member of the corresponding structure (F36).
The above-described processes are repeated until all the structures are packed (F37).
This completes the data pack (F38).

  A program example in C language according to the present invention is shown below. Assume that a structure like the following number 5 is declared.

[Equation 5]
typedef struct {
unsigned int data_a;
int data_b;
char data_c;
} STRUCT_DATA;

Formula 5 indicates that the structure type declaration has integer type data a without a sign bit, signed data b, and signed data c named STRUCT_DATA. In the present invention, it is not necessary to describe the data c by “char data_c;”.
Furthermore, it is assumed that the structure is declared as an array as shown in Equation 6 below.

[Equation 6]
STRUCT_DATA tmp_data [120];

Equation 6 indicates that an actual storage area of 120 bits is secured as the number of STRUCT_DATA.
At this time, it is known in advance that data 0 to 16777215 (referred to as data A) is accessed for the member data_a of the structure, and similarly data 0 to 100 (data C and Call it) is known to be accessed. At this time, an example of a program for reading / writing a packed (synthesized) storage area as shown in FIG. 2 and a packing process for causing data A and data C to coexist in data_a is shown.

2 shows the amount of data that can be handled when unsigned int type data and char type data coexist. As shown in FIG. 3, as shown in FIG. 3, unsigned int type data 31 and short type / unsigned short Coexistence of type data 33 and coexistence of unsigned short type data 35 and char type / unsigned char type data 37 have a further memory reduction effect.
Here, at the time of the reading process, a reading operation as shown in the following Expression 7 is performed.

[Equation 7]
void read_data (STRUCT_DATA * s_data, short index, char size_l, char sw, unsigned int * read) {
/ *
* s_data: An array of structures holding data.
index: Indicates the index of the array to be read.
size_l: Indicates the size of data A (larger data) and indicates the bit unit.
sw: Indicates the specification of the data A / C read source.
* read: Indicates a pointer to the variable that holds the read data.
* /
unsigned int tmp_data = 0;

/ * Read member * /
tmp_data = s_data [index]->data_a;

/ * Determine the data to read * /
/ * When reading data A * /
if (sw == DATA_A) {
/ * Read only data A according to the size of data A * /
* read = tmp_data & (0xffffffff << size_l) ~;
}
/ * When reading data C * /
if (sw == DATA_C) {
/ * Read upper byte right by size_l * /
* read = tmp_data >>size_l;
}
return;
}

Equation 7 shows an operation of reading the data a and the data c that are combined and stored indicated by the address of the pointer as STRUCT_DATA.
Next, at the time of the writing process, a writing operation as shown in Equation 8 below is performed.

[Equation 8]
void write_data (STRUCT_DATA * s_data, short index, char size_l, char sw, unsigned int write) {
/ *
* s_data: An array of structures holding data.
index: Indicates the index of the array to be written.
size_l: Indicates the size of data A (larger data) and indicates the bit unit.
sw: Indicates the specification of the write destination to data A / C.
write: Indicates a variable of data to be written.
* /
unsigned int tmp_data_a, tmp_data_c = 0;

/ * Determine write destination * /
/ * When writing to data A * /
if (sw == DATA_A) {
/ * Backup of data C * /
tmp_data_c = (s_data [index]-> data_a) & ((0xffffffff >> size_l) <<size_l);

/ * Copy the data to write to a temporary variable * /
tmp_data_a = write & (0xffffffff << size_l) ~;

/ * Return data C * /
tmp_data_a = tmp_data_a | tmp_data_c;
}
/ * When writing to data C * /
if (sw == DATA_C) {
/ * Backup data A * /
tmp_data_a = (s_data [index]-> data_a) & (0xffffffff << size_l) ~;

/ * Copy the data to write to a temporary variable * /
tmp_data_c = write & ((0xffffffff >>size_l);
tmp_data_c = tmp_data_c <<size_l;

/ * Return data A * /
tmp_data_a = tmp_data_a | tmp_data_c;
}
/ * Write data A and C * /
s_data [index]-> data_a = tmp_data_a;

return;
}

Equation 8 shows an operation of combining and writing data a and data c indicated by the address of the pointer as STRUCT_DATA.
Next, during the packing process, a packing operation as shown in the following equation 9 is performed.

[Equation 9]
void pack_data (STRUCT_DATA * s_data, int count, char size_l, unsigned int * write_a, unsigned int * write_b) {
/ *
* s_data: An array of structures holding data.
counter: Indicates the number of structures.
size_l: Indicates the size of data A (larger data) and indicates the bit unit.
* write_a: Indicates an array of data to be written to data A.
* write_c: Data C Data array to be written.
* /
unsigned int tmp_data_a, tmp_data_c = 0;
int c = 0;

/ * Structure initialization * /
for (c = 0; c <count; c ++) {
s_data [c]-> data_a = 0;
}

/ * Write to data A * /
for (c = 0; c <count; c ++) {
/ * Copy write_a to write to temporary variable * /
tmp_data_a = write_a [c] & (0xffffffff << size_l) ~;

/ * Copy write_b to write to temporary variable * /
tmp_data_c = write_b [c] & ((0xffffffff >>size_l);
tmp_data_c = tmp_data_c <<size_l;

/ * pack of data_a, data_c * /
tmp_data_a = tmp_data_a | tmp_data_c;

/ * Actual write * /
s_data [c]-> data_a = tmp_data_a;
}

return;
}

  Equation 9 shows an operation of packing (combining) data a and data b indicated by the address of the pointer as STRUCT_DATA.

FIG. 7 shows a configuration example of a memory usage reduction device for a structure type array.
In FIG. 7, the audio codec IC 73 includes a memory usage reduction unit 74 and an audio codec unit 80. The memory usage reduction unit 74 is controlled by the control means 72 and the program 71, and has a memory 75 for storing members having a structure type, and an area for using other members for an area using a member having a structure type. Discriminating means 76 for discriminating whether or not there is, a register 77 for reading and holding a member having a structure type and other members, an arithmetic means 78 for synthesizing a member having a structure type and other members, and a synthesized member Is stored as a member.

  Here, since the dynamic range of the A / D converter is determined, the audio codec unit 80 is configured not to use audio data having a number of bits larger than the dynamic range.

  Therefore, when the memory is used in the encoding and decoding processing of the audio data in the audio codec unit 80, the memory usage amount reducing unit 74 uses other data in an unused area for certain data. And other data are processed as combined data, the memory usage can be reduced.

FIG. 8 is a block diagram illustrating functions of the memory usage reduction unit 74.
In FIG. 8, when a normal C language description 81 is given to the memory usage reduction unit 74, the memory usage reduction unit 74 first sets an area to be used for the memory as indicated by 82. 83, 84, and 85, the remaining area when an area using a certain variable in all areas of the memory is set is obtained.

  Next, the memory usage reduction unit 74 permits the use of other variables for the memory according to the surplus area as indicated by 86 and is used for a function written to the memory as indicated by 87. Determine the variable write processing procedure.

  Therefore, the memory usage reduction unit 74 combines other variables with a certain variable in accordance with the write processing procedure as shown at 88, and describes the synthesized variable as a certain variable corresponding to the certain variable as shown at 89.

  Specifically, when a description is made in a normal C language, the memory usage reduction unit 74 automatically synthesizes another variable with a certain variable so that the remaining area and other variables can be used automatically. To describe as a variable.

It is a figure which shows the procedure of the memory usage reduction of the structure type | mold array of this invention. It is a figure which shows the data amount which can be handled with an unsigned int type variable. It is a figure which shows the example of a combination of the sharing of the member of the structure which can reduce memory. It is a flowchart at the time of the data reading of this invention. It is a flowchart at the time of the data writing of this invention. It is a flowchart at the time of packing the data of this invention. It is a figure which shows the structural example of the memory usage-amount reduction apparatus of the structure type | mold array of this invention. It is a block diagram which shows the function of a memory usage reduction part. It is a figure which shows the technique of a prior art. It is a figure which shows the memory using apparatus of a prior art. It is a figure which shows the usage example of a bit field. It is a figure which shows allocation of a bit field. It is a figure which shows the boundary condition of a bit field. It is a figure which shows the usage example of a shared body. It is a flowchart at the time of the data reading of a prior art. It is a flowchart at the time of the data writing of a prior art.

Explanation of symbols

1 ... Declaration of structure type, 2, 3, 4 ... members, 5 ... Data range, Declared members 2, 3, 4, 6 ... Bits actually used, 7 ... Unused bits, 8 ... Others Data of members, 9, 10 ... plural data, 12 ... other members, 13 ... one member, 21 ... unsigned int type, 22 ... data amount that can be handled, 23 ... data amount actually handled, 24 ... unused 8 Bits 31 ... unsigned int type data 33 ... short type / unsigned short type data 35 ... unsigned short type data 37 ... char type / unsigned char type data 71 ... program 72 ... control means 73 ... audio codec IC 74 ... Memory usage reduction unit, 75 ... Memory, 76 ... Discrimination means, 77 ... Register, 78 ... Calculation means, 79 ... Memory, 80 ... Audio codec part, 81 ... Description in ordinary C language, 82 ... Memory Set the area to be used, 83 ... all areas of the memory, 84 ... set the area to use a certain variable, 85 ... the remaining area, 86 ... allow writing of other variables, 87 ... determine the processing procedure, 88 ... Combining other variables with a variable, 89 ... described as a variable

Claims (10)

In a method of using memory of structure type array data that uses several variables when constructing a function,
Set the area to be used for the above memory,
Find the surplus area when setting the area that uses a certain variable in all areas of the above memory,
Allow the use of other variables for the memory according to the remainder area,
Determine the procedure for writing variables used for functions written to the above memory,
Combining the other variables with a variable according to the write processing procedure,
A method of using memory of structure type array data, wherein the synthesized variable is described as a variable corresponding to the variable. The method of using memory of structure type array data according to claim 1,
The memory usage of the structure type array data, wherein the variable of the function is an unsigned type. The method of using memory of structure type array data according to claim 1,
The method for using memory of structure type array data, wherein the function is described in C language. The method of using memory of structure type array data according to claim 1,
The above-mentioned function is applied to specific data in which the number of bits used is determined. The method of using memory of structure type array data according to claim 1,
The method of using a memory of structure type array data, wherein the write processing procedure is a write function and a calculation procedure. In a method of using memory of structure type array data that uses several variables when constructing a function,
Set the area to be used for the above memory,
Find the surplus area when setting the area that uses a certain variable in all areas of the above memory,
Allow the use of other variables for the memory according to the remainder area,
Determine the read processing procedure of the variable used for the function written by combining with the variable that has the other variable in the memory,
Separating the other variables from a variable according to the read processing procedure,
A method of using memory of structure type array data, wherein the separated other variable is described as a variable corresponding to the certain variable. The method of using memory of structure type array data according to claim 6,
The memory usage of the structure type array data, wherein the variable of the function is an unsigned type. The method of using memory of structure type array data according to claim 6,
The method for using memory of structure type array data, wherein the function is described in C language. The method of using memory of structure type array data according to claim 6,
The above-mentioned function is applied to specific data in which the number of bits used is determined. The method of using memory of structure type array data according to claim 6,
The method for using a memory of structure type array data, wherein the read processing procedure is a write function and a calculation procedure.

Images