KR101099491B1 - Power Consumption Analysis Method - Google Patents

Abstract

The present invention relates to a power analysis method, and more particularly, to a power consumption analysis method for generating a design model that is efficient for power consumption and for analyzing power consumption in a short time. As such, the present invention may be configured to process instructions processed by a CPU and an operating system in a modeling and analysis of real-time and embedded system (MARTE) profile for unified modeling language (UML) and power consumption analysis. Expanding to create an embedded software design model; Converting the designed embedded software into an extensible markup language (XML), and parsing the converted XML to extract UML model elements; And analyzing and identifying the extended instructions corresponding to the extracted UML model elements, and calculating power consumption of embedded software using the stored power consumption of each extended instruction. .

Power Analysis, Power Consumption, UML, MARTE, Profile

Description

Power Consumption Analysis Method {METHOD FOR ANALYZING POWER CONSUMPTION}

The present invention relates to a power analysis method, and more particularly, to a power consumption analysis method for generating a design model that is efficient for power consumption and for analyzing power consumption in a short time.

Conventional design model-based power consumption analysis methods develop a separate model for analyzing power consumption, and define a base structure for analyzing the power together to perform power analysis. However, these methods require additional activities beyond those performed during normal software development.

In other words, additional efforts are needed to build a model for power analysis and an infrastructure for analysis.

Thus, since the power analysis method for the conventional software is performed through a separate model and analysis method, there is a problem that it is not easy to apply the analysis result to the software development process.

The present invention has been devised in view of the above problems, and helps to create a design model that is efficient for power consumption by performing power analysis on software in the early stage of development, and consumes power in a short time. The purpose is to provide analytical methods.

Another object of the present invention is to extend the MARTE profile for designing and analyzing the non-functional requirements of UML and embedded software that are commonly used in software design, and to analyze the power consumption of embedded software. In providing.

Technical problems of the present invention are not limited to the technical problems mentioned above, and other technical problems not mentioned will be clearly understood by those skilled in the art from the following description.

Power consumption analysis method according to an aspect of the present invention for achieving the above object, the modeling and analysis of Real-Time and Embedded (MARTE) for power consumption analysis (UML) and UML (Unified Modeling Language) System) Generating an embedded software design model by extending the instructions (instruction) processed by the CPU and the operating system of the profile; Converting the designed embedded software into an extensible markup language (XML), and parsing the converted XML to extract UML model elements; And analyzing and identifying the extended instructions corresponding to the extracted UML model elements, and calculating power consumption of embedded software by using the stored power consumption of each extended instruction.

Preferably, the extended instructions include basic type profiles (EAM_Basic Types) including basic instructions processed by the CPU and system_function instructions processed by the operating system, and UML model elements mapped to the basic type profiles. Characterized in that consisting of the configuration type profile (EAM_Fixed Types) consisting of.

Preferably, the basic instructions processed by the CPU are at least one of load, store, add, call, divide, call modulo, mult, compare, conver Type, branch, bitAND, bitNOT, bitOR, bitXOR, bitShiftLeft or bitShiftRight. It is done.

Preferably, the command processed by the operating system is fork (), waitpid (), wait (), signal (), msgsnd (), msgrcv (), msgget (), msgctl (), semget (), semctl (), semop (), pipe (), pipe open (), pipe write (), file open (), file close (), file read (), file write (), shmget (), semat (), shmdt (), or It is characterized in that at least one of shmctl ().

Preferably, the configuration type profiles (EAM_Fixed Types) are

  synch {SystemFunctionKind = msgsnd (), msgrcv ()}   asynch {SystemFunctionKind = msgsnd (), msgrcv ()}   alt {PrimitiveInstructionKind = load, compare, branch}   par {SystemFunctionKind = fork ()}   loop {PrimitiveInstructionKind = load, compare, branch, load, add, store}   opt {PrimitiveInstructionKind = load, compare, branch}   open {SystemFunctionKind = file open ()}   write {SystemFunctionKind = file write ()}   read {SystemFunctionKind = file read ()}   close {SystemFunctionKind = file close ()} + {PrimitiveInstructionKind = add}   - {PrimitiveInstructionKind = sub}   * {PrimitiveInstructionKind = mult}   Of {PrimitiveInstructionKind = divide}   % {PrimitiveInstructionKind = call modulo}   & {PrimitiveInstructionKind = bitAND}   | {PrimitiveInstructionKind = bitOR}   ^ {PrimitiveInstructionKind = bitXOR}   << {PrimitiveInstructionKind = bitShiftLeft}   >> {PrimitiveInstructionKind = bitShiftRight}   ~ {PrimitiveInstructionKind = bitShiftNOT}   = {PrimitiveInstructionKind = store}   ++ {PrimitiveInstructionKind = compare}   - {PrimitiveInstructionKind = load, sub, store}   [] {PrimitiveInstructionKind = bitShiftLeft, load}   ! {PrimitiveInstructionKind = compare}   == {PrimitiveInstructionKind = compare}   ! = {PrimitiveInstructionKind = compare}   > {PrimitiveInstructionKind = compare}   > = {PrimitiveInstructionKind = compare}   < {PrimitiveInstructionKind = compare}   <= {PrimitiveInstructionKind = compare}   && {PrimitiveInstructionKind = compare, branch}   || {PrimitiveInstructionKind = compare, branch}

It is made as, characterized in that consisting of the extended command of the basic type profile (EAM_Basic Types) corresponding to the UML model element.

The present invention does not need to develop a separate power analysis model by the above-mentioned problem solving means, there is an effect that can easily apply the power consumption analysis results to the software design model.

In addition, by using UML and MARTE profiles, which are frequently used in embedded software model design, power consumption can be analyzed without using separate analysis models, and feedback on analysis results can be applied to design models. .

In addition, the reflection of the power consumption analysis results in the design model has the effect of providing an opportunity to develop low-power embedded software.

In the following description, specific details of the power consumption analysis method of the present invention are shown to provide a more general understanding of the present invention. It will be apparent to those of ordinary skill in the art.

In the following description, the present invention defines an extended MARTE profile as an Energy Analysis Model (EAM). Here, the MARTE profile refers to a profile that supports analysis of non-functional requirements (performance, security, etc.) for software models designed with UML.

Hereinafter, preferred embodiments according to the present invention will be described in detail with reference to the accompanying drawings, with reference to the parts necessary for understanding the operation and operation according to the present invention.

1 is an exemplary diagram for explaining a metamodel for embedded software power consumption analysis according to an embodiment of the present invention.

Referring to FIG. 1, in order to include information required for power consumption analysis of embedded software in an existing MARTE profile, a metamodel for power consumption analysis of embedded software for power consumption analysis of embedded software such as FIG. 1 is defined.

Software model elements 100 may be defined as a pattern of an instruction level 200 through implementation. The instruction is divided into a set of primitive instructions 201 such as Load, Add, and Store, and a function_ys instruction 202 such as Wait () and fork (). These instructions require information of operand type 203, such as int, char, double, etc., because the power consumption varies depending on the type of the operand.

Software model elements, which may be represented as a set of instructions, are grouped 300 into processes or execution units and assigned to hardware model elements 400.

Hardware model elements consist of hardware information 401 and information about power consumption 402.

Information represented by the metamodel as shown in FIG. 1 is used for power consumption analysis of embedded software, but the existing UML or MARTE profiles do not represent all the information shown in FIG. UML is an abbreviation of Unified Modeling language and is a modeling language for specifying, developing, and documenting outputs generated during a software development process. That is, it is used as a means for designing software.

In other words, the shaded portion of FIG. 1 can be expressed using UML and MARTE profiles, but there is no way to express the portion not.

Therefore, the present invention has extended the MARTE profile to represent this part. For expansion, elements that cannot be expressed in the existing MARTE derived from FIG. 1 are summarized as shown in Table 1 below.

Extension element The details Instruction Has a command identifier corresponding to the classifier for the UML model element and the corresponding command pattern. That is, it consists of Primitive Instructions and Sys_function Instructions that represent model elements. Primitive Instruction Represents a list of commands at a general level. System_function Instruction Represents a list of system function instructions at the general level (embedded operating system).

2 is an exemplary diagram for explaining a higher domain model of an extended MARTE profile (EAM) according to an embodiment of the present invention.

Referring to FIG. 2, the EAM profile 500 is defined as a higher domain model that can express power consumption information by extending a Generic Quantitative Analysis Model (GQAM) package that defines concepts for building various analysis models in the MARTE profile. It became. In addition, EAM_BasicTypes 600 and EAM_FixedType 700 define mapping information of instructions derived from Table 1 and instructions for UML model elements, respectively.

Table 2 below shows the commands defined in EAM_BasicTypes in FIG. 2.

The defined instructions are defined in a generalized form with minimal dependency on the hardware platform for extensibility. Primitive instructions are generalized by referring to the instructions provided by Strong Arm, which are often used for embedded system configuration. System_function instructions are generalized by referring to the system functions provided by Embedded Linux. . A detailed definition of the EAM_BasicTypes 600 of FIG. 2 that is included in the MARTE profile and extended is shown in FIG. 3. PrimitiveInstructionKind 601 of FIG. 3 defines the Primitive instructions of FIG. 3, and SystemFunctionKind 602 defines the System_function instructions.

Looking at the instructions of such PrimitiveInstructionKind (601) as follows.

load: Load memory data into the registers of the processor. In other words, this command is used to read data from memory.

store: Stores the register values of the processor in memory. Used to store data in memory as opposed to load.

add: Adds the values stored in two registers.

call divide A command that performs a divide operation on the values stored in two registers.

call modulo: This command finds the remainder of the quotient of the division operation on the values stored in two registers.

mult: This command multiplies the values stored in two registers.

compare: Compares the values in two registers for equality.

convertType: Command to change the data value of numeric type. Change it to int-> float, int-> double, float-> int, double-> int.

branch: A command to branch the flow of a program.

bitAND: performs the function of AND among bit logic operators.

bitNOT: Performs NOT function among bit logic operators.

bitOR: Performs OR function among the bit logic operators.

bitXOR: Performs XOR function among bit logic operators.

bitShiftLeft: Move Bit to the left.

bitShiftRight: Move Bit to the right.

Next, the instructions of SystemFunctionKind (602) are as follows.

fork (): This is a system function that creates a copy process for the currently running process.

waitpid (), wait (): This is a system function that checks the exit status of a created child process.

signal (): This is a system function that returns a handler pointer of a previously generated signal.

msgsnd (): A system function that sends a message to a specific process.

msgrcv (): System function called by a specific process to receive a message.

msgget (): This is a system function to get the ID value of a specific message.

msgctl (): A system function that controls the behavior of a particular message.

semget (): Gets a semaphore value.

semctl (): A system function that controls a specific semaphore.

semop (): A system function that performs an operation on a specific semaphore.

pipe (): System function that creates a pipe with a pair of file descriptors for process communication.

pipe open () is a system function that opens a file descriptor for a pipe.

pipe write (): A system function that writes data to a pipe that is sent through process communication.

File open () is a system function that opens a file for use.

File close (): This is a system function that closes a file after using it.

File read (): System function used to read a file.

File write (): This is a system function used to write specific data to a file.

shmget (): This is a system function to get the ID of the shared memory used by the current system.

shmat (): A system function that attaches shared memory into a specific process.

shmdt (): The reverse of semat (), a system function that separates shared memory within a particular process.

shmctl (): A system function that performs control operations on shared memory.

3, the internal behavior of software model elements modeled by UML can be expressed by instructions. The software model elements represented by the command may perform power consumption analysis through the mapping information 701 of FIG. 4. The mapping represents the relationship between UML model elements and instructions for Action Semantic. That is, it expresses a set of instructions corresponding to UML model element and action semantic action.

The mapping information 701 of FIG. 4 includes the extended instructions of the basic type profile (EAM_Basic Types) corresponding to the UML model elements on the left side. In other words, by mapping the extended EAM profile with UML model elements, accurate power consumption can be calculated during software design.

The UML model elements of these basic type profiles are described as follows.

synch: A model element that sends a sync message to another object (subsystem).

asynch: Model element for sending asynchronous messages to other objects (subsystems).

alt: Model element that decides execution based on specific condition.

par: Model element used for parts that need to be done in parallel.

loop: This is the model element used for the part that needs to be done repeatedly.

opt: Model element used to express work to be performed after some work.

open: A model element used to represent an operation on opening a file.

write: Model element used to represent the operation of writing a file.

read: Model element used to express the operation of reading a file.

close: A model element used to express the action of closing a file.

5 is a flowchart illustrating a power consumption analysis method according to an embodiment of the present invention.

Referring to FIG. 5, an embedded software design model 803 is generated using the UML 801 and the EAM Profile 802 extending the MARTE profile for power consumption analysis (S501).

The designed software model is converted into XML (804), and the converted XML (eXtensible Markup Language) is parsed to extract UML model elements (S503).

Subsequently, the commands corresponding to the extracted UML model elements are analyzed (S505), identified according to the analysis result, and the power consumption of the embedded software is calculated using the stored power consumption of each extended instruction (S507).

That is, the power consumption of the software model designed by summing all the stored power consumption of the extended instructions of the basic type profile (EAM_Basic Types) mapped to the UML model elements using the above description of FIG. Will be obtained.

Meanwhile, in the detailed description of the present invention, specific embodiments have been described, but various modifications are possible without departing from the scope of the present invention. Therefore, the scope of the present invention should not be limited to the described embodiments, but should be defined not only by the scope of the following claims, but also by the equivalents of the claims.

1 is an exemplary diagram for explaining a metamodel for embedded software power consumption analysis according to an embodiment of the present invention.

2 is an exemplary diagram for explaining a higher domain model of an extended MARTE profile (EAM) according to an embodiment of the present invention.

FIG. 3 is an exemplary diagram for describing details of EAM_BasicTypes in FIG. 2. FIG.

FIG. 4 is an exemplary diagram for explaining details of EAM_FixedTypes in FIG. 2. FIG.

5 is a flow chart showing a power consumption analysis method according to an embodiment of the present invention.

Claims (5)

Control programs based on software design models are handled by the CPU and operating system in the Unified Modeling Language (UML) and Modeling and Analysis of Real-Time and Embedded System (MARTE) profiles for power consumption analysis. Extending the instructions to generate an embedded software design model; Converting the designed embedded software into an extensible markup language (XML) in a control program based on the software design model, and parsing the converted XML to extract UML model elements; And Analyzing and identifying the extended instructions corresponding to the extracted UML model elements in the control program based on the software design model, and calculating the power consumption of embedded software using the stored power consumption of each extended instruction. Power consumption analysis method comprising a. The method of claim 1, wherein the expanded command is: Basic Type Profiles (EAM_Basic Types) including Basic Instructions processed by the CPU and System_function Instructions processed by the OS, and Configuration Type Profiles (EAM_Fixed Types) consisting of UML model elements mapped to the Basic Type Profile. Power consumption analysis method characterized in that consisting of. The method of claim 2, wherein the basic instructions processed by the CPU are: Power consumption analysis method characterized in that at least one of load, store, add, call, divide, call modulo, mult, compare, conver Type, branch, bitAND, bitNOT, bitOR, bitXOR, bitShiftLeft or bitShiftRight. The method of claim 2, wherein the command processed by the operating system comprises: fork (), waitpid (), wait (), signal (), msgsnd (), msgrcv (), msgget (), msgctl (), semget (), semctl (), semop (), pipe (), pipe open (), pipe write (), file open (), file close (), file read (), file write (), shmget (), semat (), shmdt () or shmctl () Power consumption analysis method. The method of claim 2, wherein the configuration type profiles (EAM_Fixed Types) are:   synch {SystemFunctionKind = msgsnd (), msgrcv ()}   asynch {SystemFunctionKind = msgsnd (), msgrcv ()}   alt {PrimitiveInstructionKind = load, compare, branch}   par {SystemFunctionKind = fork ()}   loop {PrimitiveInstructionKind = load, compare, branch, load, add, store}   opt {PrimitiveInstructionKind = load, compare, branch}   open {SystemFunctionKind = file open ()}   write {SystemFunctionKind = file write ()}   read {SystemFunctionKind = file read ()}   close {SystemFunctionKind = file close ()} + {PrimitiveInstructionKind = add}   - {PrimitiveInstructionKind = sub}   * {PrimitiveInstructionKind = mult}   Of {PrimitiveInstructionKind = divide}   % {PrimitiveInstructionKind = call modulo}   & {PrimitiveInstructionKind = bitAND}   | {PrimitiveInstructionKind = bitOR}   ^ {PrimitiveInstructionKind = bitXOR}   << {PrimitiveInstructionKind = bitShiftLeft}   >> {PrimitiveInstructionKind = bitShiftRight}   ~ {PrimitiveInstructionKind = bitShiftNOT}   = {PrimitiveInstructionKind = store}   ++ {PrimitiveInstructionKind = compare}   - {PrimitiveInstructionKind = load, sub, store}   [] {PrimitiveInstructionKind = bitShiftLeft, load}   ! {PrimitiveInstructionKind = compare}   == {PrimitiveInstructionKind = compare}   ! = {PrimitiveInstructionKind = compare}   > {PrimitiveInstructionKind = compare}   > = {PrimitiveInstructionKind = compare}   < {PrimitiveInstructionKind = compare}   <= {PrimitiveInstructionKind = compare}   && {PrimitiveInstructionKind = compare, branch}   || {PrimitiveInstructionKind = compare, branch} Consisting of, Power consumption analysis method comprising the extended instructions of the basic type profile (EAM_Basic Types) corresponding to the UML model element.

Images