JP2011076619A - Program code compression device, program code compression method, and program of program code compression method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a program code compression method and the like to realize a program execution device and the like reducing the memory capacity of a buffer while preventing reduction in an execution processing speed. <P>SOLUTION: The program code compression device compresses a program code constructed of one or more execution codes, each of which is constructed of a command showing execution processing content and processing data used by the command for execution processing and is described in a character string format of text data. The program code compression device is equipped with: a processing data-command discrimination part 1A discriminating each of the execution codes between the processing data and the command by collating the respective execution codes with a dictionary storing the all commands previously; and a conversion part 1B performing conversion processing on each of the processing data and the command respectively, to compress the execution codes. <P>COPYRIGHT: (C)2011,JPO&INPIT

Description

  The present invention relates to a program code compression method, device, and the like for realizing a program execution device, method, and the like that execute execution processing based on a program code.

  In home appliances (air conditioners, refrigerators, washing machines, discharge lamp lighting devices, etc.), etc., a program execution device is incorporated in order to control the operation (hereinafter, such appliances, home appliance adapters, etc. are incorporated). Called). Here, in order for the program execution apparatus to execute the execution process, data called a predetermined program code is required. This program code is stored in advance in storage means such as a ROM (Read Only Memory) provided in the embedded device, for example, and the program execution device reads (inputs) the program code stored in the ROM and executes it Processing is in progress.

  Here, there is a program execution device that reduces the cost associated with the storage means by compressing the program code, reducing the amount of data to be stored, and reducing the storage capacity of the storage means such as ROM as much as possible (for example, Patent Document 1). Reducing the data amount of the program code in this way is convenient in the case where embedded devices are connected to each other via a network in the future and, for example, transmit / receive a signal including program code data.

JP 2002-318696 A

  Usually, when the program code is compressed, the execution processing speed of the program execution device is reduced. Therefore, a method of storing the expanded program code in a temporary storage means (buffer) composed of RAM (Randam Access Memory) or the like is employed. Therefore, a large capacity of RAM is required.

  Therefore, the present invention is a program capable of reducing the storage capacity of a buffer to be prepared while reducing the storage capacity of the ROM by the compressed program code and further preventing the reduction of the execution processing speed of the program execution device. It is an object of the present invention to realize a program code compression method, apparatus and the like for realizing an execution apparatus and method.

  The program code compression apparatus according to the present invention is a program comprising one or a plurality of execution codes composed of commands representing execution processing contents and processing data used by the commands for the execution processing and described in a character string format of text data. A program code compression apparatus for compressing a code, wherein each execution code is compared with a dictionary in which all commands are stored in advance to identify each execution code into processing data and a command, processing data, Conversion means for performing a conversion process on each of the commands and compressing the execution code.

  According to the present invention, when compressing a program code composed of an execution code in which processing data and a command are sequentially arranged in a character string format of text data, the identification unit identifies the processing data and the command of each execution code. Since the conversion means performs the conversion process to generate the compressed execution code, the process data and the command can be respectively processed and compressed.

It is a figure showing the compression process of the program code which concerns on 1st Embodiment. It is a figure showing the program execution apparatus which concerns on Embodiment 2 of this invention. It is a flowchart showing the operation | movement in a program execution apparatus. FIG. 10 is a diagram illustrating compressed execution code according to the third embodiment.

Embodiment 1 FIG.
FIG. 1 is a diagram showing a program code compression process according to the first embodiment of the present invention. An example of the execution code is shown on the upper side of FIG. Here, it is described as text data. The program code is composed of one or a plurality of execution codes. First, the execution code will be described. In the present embodiment, it is assumed that Forth is used as the language used for the program code, and the code is for executing processing according to the ECHONET (ECHONET is a trademark of the ECHONET Consortium) standard. ECHONET is a network (communication line) standard for controlling home appliances while linking them. Forth is a language based on reverse Polish notation (postfix notation) that is easy or unnecessary to parse. In the present embodiment, the execution code is processed when executing an execution process based on a command (instruction) data (hereinafter referred to as a command; referred to as word in Forth) representing a process to be executed by the program execution device. It consists of data (hereinafter referred to as processing data). Then, processing data and commands are described in this order. Here, each command and its processing contents are defined (associated) in advance and registered as data (hereinafter referred to as a dictionary). Therefore, if the number and character string data in the execution code is registered in the dictionary, it is a command, and if not registered, it is processing data. In the present embodiment, it is assumed that a dictionary is stored in the storage unit 2 described later.

  The command RGST_EPC is described to execute registration processing of property information of the embedded device. The object id is an id attached to the object of the embedded device. Two bits are assigned to represent the object id. The ECHONET property is a code of a property that can be set according to the type of embedded device (for example, the air volume setting state in an air conditioner). The code value is determined by the ECHONET standard, and 8 bits are assigned. Here, seven types of property data types are prepared, and 3 bits are assigned. The access rule indicates whether or not writing (Set), reading (Get), and notification are possible, and 3 bits are assigned. The status change announcement presence / absence is an index (flag) indicating whether or not to notify via the network when the property state changes, and 1 bit is assigned. The data size is for defining the data size of the property. In the ECHONET standard, the maximum value is 8640 bytes, and 14 bits are assigned to represent the numerical value.

  Next, the configuration and processing of the program code compression processing device will be described. It is assumed that the program code compression apparatus in the present embodiment is composed of a control processing unit 1, a storage unit 2, and a communication unit 3. The control processing means 1 has a processing data / command identification unit 1A and a conversion unit 1B. In the control processing means 1, the data / command identification unit 1A compares each execution code of the program code with a dictionary stored in the storage means 2, and uses a character string, number, etc. that does not match the dictionary as processing data, and matches By using the character string (script) as a command, the processing data and the command are identified. Here, with respect to the execution code, for example, a program code generation unit (not shown) provided in the preceding stage of the data / command identification unit 1A of the control processing unit 1 based on instructions, data, and the like input by the operator from the input unit It is also possible to generate the code at the same time, or to process the execution code included in the signal generated by another device and transmitted via a communication line (not necessarily related to ECHONET). .

  The conversion unit 1B represents processing data and a command in binary format data (hereinafter referred to as binary data), and generates data divided for each predetermined data amount. In this embodiment, 7 bits are set as a predetermined unit. For example, if the processing data is not divisible by 7, for example, the remaining bits are supplemented with “0”. For data representing processing data (hereinafter, this data is also referred to as processing data), “0” is added to each of the divided head bits, and data for determining a command (hereinafter, this data is also referred to as a command). "1" is attached to the above. That is, this is a determination bit (flag) for determining whether it is processing data or a command. Thereby, as shown in the lower side of FIG. 1, each execution code (program code) is divided into data (byte data) in units of 1 byte (8 bits). In this way, the processing data divided into the character strings of the respective elements (items) are collectively encoded as binary data and encoded (encoded) to reduce the data amount.

  On the other hand, for a command, a numerical value (code value) corresponding to the command on a one-to-one basis is represented by binary data. Thereby, the command represented by the binary data can be determined. The relationship between the command and the binary data is associated and stored in the storage unit 2, and the conversion unit 1B refers to the data when generating the data. Here, if the number of commands is 128 or less, one byte is sufficient to determine the command. For example, if the number of commands is more than that, it will be 2 bytes or more, but even in that case, for a command that is frequently used (appears) for execution processing (for example, property-related), 1 byte of data However, if it can be discriminated, the data amount relating to the entire program code can be further reduced. The byte data generated by the method according to the present embodiment may be further compressed by a known bit string compression method such as a run length method.

  The compressed program code data generated as described above is actively distributed in response to a download request transmitted from the embedded device side via the network, for example, or from the program code compression processing device (control processing means 1) side. Thus, the data is stored in the program code storage unit 24 of the embedded device according to the second embodiment to be described later via the communication unit 3 and a wired or wireless communication line.

  As described above, according to the first embodiment, the processing data and the command of each execution code are identified, and the processing data collects each element (item) as binary data. As data, each data is divided into predetermined units (7 bits in the present embodiment), and a determination bit for determining whether the data includes processing data or data including a command is attached to each data. Since it is divided into byte data, processing data and commands can be compressed respectively. Then, when executing the execution process, reading is performed for each byte, and it can be easily determined whether the data includes processing data or a command. Further, by making the program code a language based on the reverse Polish notation such as Forth, the execution code is configured in the order of the processing data and the command, so that the processing data and the command can be easily identified. Furthermore, by setting the unit for dividing the program code to 1 byte, a processing device such as a one-chip microcomputer can be used when executing the execution process. For example, the compression effect can be further enhanced by adjusting the frequency according to, for example, reducing the number of bytes including commands that are frequently used (appear) in the execution process.

Embodiment 2. FIG.
FIG. 2 is a diagram illustrating a program execution device according to Embodiment 2 of the present invention. In the present embodiment, the program execution apparatus includes a code type determination unit 21, a code expansion unit 22, an execution unit 23, a program code storage unit 24, and a buffer storage unit 25. Then, an execution process based on the compressed program code generated in the first embodiment is performed.

  The code type determination unit 21 reads (inputs) the compressed (encoded) program code stored in the program code storage unit 24 with a predetermined amount of data. In the present embodiment, in accordance with the first embodiment, the predetermined data amount is 1 byte (8 bits). Then, it is determined whether the read data is data including processing data (data byte, data not including a command) or data including a command (command byte). The code type determination unit 21 performs determination based on the determination bit (flag) described in the first embodiment. If it is determined that it is processing data, the processing data is stored in the buffer storage unit 25, and if it is determined that it is a command, control of processing is passed to the code decompression unit 22.

  When the code type determination unit 21 determines that the code is a command, the code expansion unit 22 generates (decompresses or decodes) an execution code based on the processing data and the command stored in the buffer storage unit 25. When the execution code is generated, control of processing is transferred to the execution means 23.

  The execution unit 23 performs an execution process based on the execution code generated by the code expansion unit 22. Here, in this embodiment, it is assumed that the execution means 23 is an interpreter that executes a command execution process on the processing data while interpreting (translating) the execution code. Therefore, the program code is sequentially executed for each execution code. Here, it is assumed that the execution means 23 has the dictionary described in the first embodiment in the storage means (not shown) in order to interpret the execution code. When the execution process ends, control of the process is passed to the code type determination means 21.

  Both the program code storage means 24 and the buffer storage means 25 are storage means. Here, in the present embodiment, the program code storage means 24 is a non-volatile memory, but it is not a mere ROM, but a storage means (for example, a program code can be rewritten such as adding, changing part or all, or deleting). , EPROM, EEPROM, etc.). When the program code is rewritten, as described in the first embodiment, the communication means (not shown) of the embedded device receives a signal including the program code, for example, by downloading via a network, and the program code storage means 24 Stored and retained.

  The buffer storage means 25 is, for example, a volatile memory. The buffer storage means 25 is a temporary storage means for storing at least processing data until the code decompression means 22 generates an execution code, and is not left if the next processing data is input. Therefore, the storage capacity of the buffer storage unit 25 is arbitrary, but preferably the maximum storage that can store the processing data portion (or execution code) of the execution code that the embedded device (program execution device) executes at a time. Capacity.

  In the present embodiment, compressed program code data to be executed is read byte by byte, and it is determined whether the data is processing data or a command. If it is processing data, it is stored in the buffer storage means 25, and if it is determined that it is a command, the decompression means 22 uses the processing data and command stored in the buffer storage means 25 as an execution code. The execution means 23 executes the execution code. Thus, execution processing for each execution code is performed based on the compressed program code stored in the program code storage unit 24 by the program execution device. Here, the execution code (program code) for which the execution process has been completed is not inadvertently left in the buffer storage means 25 such as a RAM, so that the process data (or execution data) of the execution code necessary for one execution process is kept. The storage capacity of the buffer storage means 25 is suppressed so as not to exceed the amount necessary for temporarily storing the code). The code type determination means 21, code decompression means 22 and execution means 23 may be configured by physically independent means, but usually the program execution device is configured by a computer such as a so-called microcomputer. These means are comprised by the control processing apparatus centering on CPU, for example. Then, the control processing device executes processing of each means, thereby realizing execution processing of the program execution device.

  FIG. 3 is a flowchart showing the operation when executing the execution process in the program execution device. Here, the processing performed by the code type determination unit 21, the code expansion unit 22, and the execution unit 23 of the program execution apparatus will be mainly described. The code type determination unit 21 reads the compressed program code data from the program code storage unit 24 in units of 1 byte (S1). The code type determination unit 21 determines whether the read data is a command or processing data depending on whether the determination bit described in the first embodiment is “0” or “1” ( It is determined whether it is a command (S2). If it is determined that the data is processed data (not a command), the determination bit is removed and stored in the buffer storage means 25 (S3), and the compressed program code data is read in units of 1 byte (S1).

  On the other hand, if it is determined that the read data is a command, control is passed to the code expansion means 22. Based on the read data (binary data), the code decompression means 22 determines a command represented by the data and converts it into a script format command. For this determination, the relationship between the binary data and the command described in the first embodiment is used. If the command can be identified, the element (item) of the processing data to be executed by the command and the allocated data amount (number of bits) can be known, so the processing data of each element (item) is based on the binary data of the processing data. Divide into The decompression process as described above is performed to generate an execution code (S4).

  When control is passed from the code decompression means 22 to the execution means 23, execution processing is performed based on the execution code generated by the code decompression means 22 (S5). In a language based on reverse Polish notation, each element (item) is put on a stack and processed based on a command. When the execution process based on the execution code is completed, control is passed to the code type determination unit 21 and a process for the execution process based on the next execution code is performed. As described above, the execution process for each execution code is sequentially performed to execute the program code, and the embedded device operates. In addition, a signal including data based on the execution process is transmitted to a device outside the embedded device via a network to be operated.

  As described above, according to the second embodiment, the compressed program code data is read from the program code storage unit 24 with a predetermined data amount (1 byte in the present embodiment), and the code type determination unit 21 performs processing. If it is determined that the data includes data, the processing data is temporarily stored in the buffer storage unit 25. If it is determined that the data includes a command, the code decompression unit 22 then generates an execution code. Since the execution means 23 performs the execution process based on the execution code, the buffer storage means 25 only needs to store the processing data until the execution code is generated, thereby providing the buffer storage means 25. The storage capacity that should be kept can be reduced. In addition, since the entire processing of the program execution device from data reading of the compressed program code to execution processing of the execution code is simple, speed can be maintained even if the generated execution code (program code) is not retained. Can be prevented. As described above, the program execution device according to the present embodiment can achieve both reduction in storage capacity related to processing and maintenance of execution processing speed, so that there is a high demand for cost control for operation control. This is especially effective when incorporated. In addition, since the signal including the compressed program code data is transmitted to the embedded device or the like via the communication line so that the data of the program code storage means 24 can be rewritten, the program code of the program code storage means 24 is changed. Latest, more efficient and more advanced.

Embodiment 3 FIG.
FIG. 4 is a diagram showing a data structure of the compressed execution code according to the third embodiment of the present invention. In the first embodiment described above, the processing data converted into binary data is divided every 7 bits from the top (so-called left-justified in the indicated data string), and there is a surplus when the processing data is not divisible by 7. The remaining bits are supplemented with “0” or the like.

  Here, when performing an execution process based on the execution code, if a data structure such as a stack is adopted, the data loaded last is the head, and the process starts from that data (that is, the right side of the indicated data string) Will be processed from the data). For example, when the number of elements (items) can be changed, the number of data is shown at the top of the stack. For this reason, it may be more convenient to be unified in the same processing system. Therefore, as shown in FIG. 4 (a), binary data is so-called right-justified so that the beginning (not supplemental data) of the binary data is part of the processing data in the decompression processing of the code decompression means 22. .

  Also, as shown in FIG. 4B, the code type can be obtained by including data representing the number of bytes of data not including a command in 1-byte data (data not including a command) read first. The determination means 21 can determine whether the data includes a command. In FIG. 4B, 5 bits (numerical values from 0 to 31) are allocated to data for representing the number of bytes of processing data. Thereby, it is not necessary to provide a determination bit for each byte data. Therefore, more efficient compression can be performed as the number of bytes (number of bits) of data including processing data increases. Moreover, since the number of bytes of the processing data is known and the command follows the processing data, it is not necessary to provide a determination bit for the command. As a result, the number of commands that can be discriminated by, for example, 1 byte is doubled as compared with the case where a determination bit is provided. Therefore, it is effective even when the number of commands is large.

Embodiment 4 FIG.
In the above-described embodiment, the program code is described in a language based on reverse Polish notation, and the execution means 23 is an interpreter that interprets the description and executes execution processing. The present invention is not limited to this. For example, interpreter is JavaVM (or JVM (Java, Java Virtual Machine JVM is a trademark or registered trademark of Sun Microsystems, Inc. in the United States and other countries). It may be configured as a system, and it may be possible to generate more advanced code by making it applicable to more general-purpose languages.

  DESCRIPTION OF SYMBOLS 1 Control processing means, 1A Processing data and command identification part, 1B conversion part, 2 Storage means, 3 Communication means, 21 Code classification judgment means, 22 Code expansion means, 23 Execution means, 24 Program code storage means, 25 Buffer storage means .

Claims (5)

A program code compression apparatus for compressing a program code composed of one or a plurality of execution codes composed of a command representing execution processing contents and processing data used by the command for execution processing and described in a character string format of text data There,
Identifying means for identifying each execution code as the processing data and the command by comparing each execution code with a dictionary in which all commands are stored in advance;
Conversion means for compressing the execution code by performing conversion processing on the processing data and the command, respectively;
A program code compression apparatus comprising: Storage means for associating and storing numerical values corresponding to the respective commands as data;
The conversion means converts the command identified by the identification means into the corresponding numerical data based on the data stored in the storage means, and determines flag data for determining the command data The program code compression processing apparatus according to claim 1, wherein a process of attaching a program is performed.   The conversion means collectively converts the processing data for each element constituting the processing data into binary format with respect to the processing data identified by the identification means, and divides the processing data into a predetermined amount of data. 3. The program code compression processing apparatus according to claim 1, wherein a process of attaching flag data for determining the above to the divided data is performed. An execution code composed of a command representing execution processing contents and processing data used by the command for execution processing is read and compared with a predetermined character string of the command by reading an execution code described in a character string format of text data. Identifying a column as the command and identifying each execution code as the processing data and the command;
Performing a conversion process on each of the processing data and the command to compress an execution code for each execution code of a program code composed of one or a plurality of the execution codes, Program code compression processing method. An execution code composed of a command representing execution processing contents and processing data used by the command for execution processing is read and compared with a predetermined character string of the command by reading an execution code described in a character string format of text data. Identifying a column as the command and identifying each execution code as the processing data and the command;
Performing a conversion process on the processing data and the command, respectively, and compressing an execution code,
A program for compressing a program code, which causes a computer to execute the execution code of the program code composed of one or a plurality of the execution codes.

Images