JP2015153275A - Hierarchization/parallelization device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a hierarchization/parallelization device capable of automatically turning a huge flat state chart into an easily comprehensible hierarchized/parallelized state chart.SOLUTION: A hierarchization/parallelization device includes a hierarchization/parallelization candidate generation unit which receives a flat original state chart to be processed, sorts all transitions on the original state chart into either or both of resultant two state charts, and generates pairs of hierarchized or parallelized state charts in the form of a candidate list. The device derives a hierarchized/parallelized state chart from the candidate list.

Description

  Embodiments described herein relate generally to a hierarchization / parallelization apparatus that obtains a hierarchized / parallelized state chart diagram.

  A statechart diagram focuses on a state existing in a system or a change in the state of the system, and focuses on a specific system and models a life cycle from generation to disappearance. The state chart diagram is suitable for representing state transition in various systems.

  In particular, statechart diagrams created by designers with little experience in designing statecharts tend to be huge and flat without hierarchies and parallel representations, and poor maintainability such as readability and comprehension There was a problem.

JP 2011-123588 A

  The problem to be solved by the present invention is to provide a hierarchization / parallelization device that automatically obtains a statechart diagram that is hierarchized and parallelized so that it can be easily understood by humans. It is to be.

  The hierarchization / parallelization device of the embodiment inputs a flat original state chart diagram as a target, and makes all transitions of the original state chart diagram one of two resulting state chart diagrams, Alternatively, a state chart diagram that includes a hierarchization / parallelization candidate generation unit that generates a pair of state chart diagrams that are distributed, hierarchized or parallelized as a candidate list, and is hierarchized and parallelized using the candidate list. Ask for.

It is a figure which shows the state chart figure by UML. It is a figure explaining hierarchization of the state chart figure in this embodiment. It is a figure explaining normal hierarchization of the state chart figure in this embodiment. It is a figure explaining the history hierarchization of the state chart figure in this embodiment. It is a figure explaining parallelization of the state chart figure in this embodiment. It is a figure explaining the special case 1 of parallelization. It is a figure explaining the special case 2 of parallelization. It is a figure explaining the production | generation of a some candidate. It is a block diagram which shows schematic structure of the hierarchization / parallelization apparatus which concerns on embodiment of this invention. It is a figure which shows the structure of each data which appears in this embodiment. It is a figure which shows the state chart figure used as the origin used in description of an operation example. It is a figure which shows the data structure in the state chart figure shown in the operation example of FIG. FIG. 12 is a diagram illustrating creation of an initial state in the operation example illustrated in FIG. 11. It is a figure explaining creation of the pattern which distributes transition "ON" of an example of operation. It is a figure explaining creation of the pattern which distributes the transition "cooling / heating switching" from "in cooling" to "in heating" of the operation example. It is a figure explaining creation of the pattern which distributes transition "OFF" of an example of operation. It is a figure explaining a check of contradiction. It is a figure explaining creation of the pattern which distributes the transition "cooling / heating switching" from "in heating" to "in cooling" of the operation example with respect to patterns (i), (iii), and (ii). It is a figure explaining creation of the pattern which distributes transition "OFF" from "in heating" of an operation example to "stopping" with respect to pattern (i), (iii), (ii), (iii). It is a figure explaining the arrangement of transition conditions. It is a figure explaining hierarchization of a candidate. It is a figure showing the data structure in the hierarchization / parallelization candidate production | generation process which produces | generates the candidate list used as a result. It is a flowchart which shows the detailed example of a hierarchization / parallelization candidate production | generation process. It is a flowchart which shows the flow of an unqualified candidate rejection process. It is a flowchart which shows the flow of the unsuitability determination process in the case of the type a. It is a flowchart which shows the flow of the unsuitability determination process in the case of the type b. It is a flowchart which shows the flow of an optimal candidate selection process. It is a flowchart which shows the flow of the optimal candidate classification | category process by the index value regarding maintainability. It is a figure which shows an example of the optimal candidate selection by an index value. It is the figure which showed the state transition of the fully automatic washing machine with the flat state chart figure. It is a figure which shows an example of the state chart figure selected based on the candidate narrowing-down function. It is a figure which shows an example of the state chart figure selected based on the candidate narrowing-down function. It is a figure which shows an example of the conversion from a source code to a state chart figure. It is a state chart figure after hierarchization and parallelization about the example shown in FIG.

  Hereinafter, an embodiment of the present invention will be described with reference to the drawings. In the drawings, the same portions are denoted by the same reference numerals, and redundant description is omitted.

  First, main terms used in the present embodiment will be described.

"State chart diagram of UML (Unified Modeling Language)"
UML unifies the notation for object-oriented modeling. FIG. 1 shows a state chart by UML.

  In the state chart diagram by UML, the state of the object is represented by a rounded rectangle, and the state name is written therein. The initial state (start state) is indicated by a black circle. State transitions from one state to another are related by arrows. An event (condition) that causes a state transition is described next to the arrow. The operation accompanying the transition is described next to the event (condition) as an action. Actions can be described at the entrance and exit of the state transition. The transition includes, for example, data of “start state”, “end state”, “event”, “condition”, and “action”. If there is a common action for all transitions that enter a certain state, instead of describing the same action in the transition, it can be described as an entry / entry action and an exit / exit action. In addition, operations that take time to complete and are performed continuously are described as do / activity. The statechart diagram also supports hierarchical representation and parallel representation. Furthermore, it is possible to describe variables. In the present embodiment, actions and conditions are described in a C language format (with restrictions).

"Layering of statechart diagrams (normal hierarchy)"
In the state chart diagram, when the current state of the state chart diagram is a certain state, a more detailed state chart diagram can be nested in the state. This is called a hierarchy. When there is a statechart with a hierarchy that behaves in the same way as a statechart with no hierarchy, rewriting it to such a statechart is called “hierarchy”, and “history hierarchy” described later This is called “normal hierarchization” for distinction. When a state chart without a hierarchy can be hierarchized, a state chart with a hierarchy is often easier to read.

  FIG. 2 is a diagram for explaining hierarchization of the state chart diagram in the present embodiment. As shown in FIG. 2, the original state chart diagram is called the upper hierarchy, and the detailed state chart diagram is called the lower hierarchy. The state of the upper layer connecting the layers is referred to as a “layered state”. As shown in FIG. 2, every time the current state becomes a hierarchical state (in the example shown in FIG. 2, “in operation”), the lower-level state chart is in the initial state (example shown in FIG. 2). Let ’s start with “Cooling”). In the upper layer, the current state is a hierarchized state ("in operation" in the example shown in FIG. 2), and a transition (in FIG. In the example shown, when “OFF”) occurs, the lower hierarchy ends.

  FIG. 3 is a diagram for explaining normal hierarchization of the state chart diagram in the present embodiment. The same behavior occurs even when the flat state chart shown in FIG. 3A is rewritten to the normal hierarchical state chart shown in FIG. 3B.

"Hierarchization of state chart diagrams (history hierarchy)"
A “history state” and a “deep history state” can be placed in the hierarchy of the state chart diagram. “History state” represents the state of the layer when the layer was last left. The “deep history state” represents the state of the layer and all the lower layers when the layer is finally left. The transition from the outside of the hierarchy to the “history state” and “deep history state” is that the return destination state of the hierarchy at the time of the transition is a state represented by “history state” and “deep history state”, respectively. Indicates. This hierarchy is called a history hierarchy. When there is a state chart having a history hierarchy that has the same behavior as a state chart without a hierarchy, rewriting to such a state chart is called “history hierarchy”. When history hierarchies can be made so as to perform the same behavior, it is often easier to read the history hierarchy.

  FIG. 4 is a diagram for explaining history hierarchization of the state chart diagram in the present embodiment. The same behavior is obtained even when the flat state chart shown in FIG. 4A is rewritten to the state chart shown in FIG. The history hierarchy state is represented by a symbol in which H is enclosed by an ellipse, and the deep history layer state is represented by a symbol obtained by adding + to H.

  In the example of the deep history state illustrated in FIG. 4B, when the transition “ON” occurs in the “stopped” state, the last state when the transition is made from the “in operation” state (turned off) previously. It represents the operation from ("cooling" or "heating").

"Parallel statechart diagram"
In the statechart diagram, two statechart diagrams can be written and described in parallel. Extracting elements that operate independently from the original statechart diagram, and rewriting the two statechart diagrams that behave in the same way to those described in parallel is called “parallelization”.

  FIG. 5 is a diagram for explaining parallelization of the state chart diagram in the present embodiment. Even if the flat state chart shown in FIG. 5A is rewritten to the parallel state chart shown in FIG. 5B, the same behavior is obtained. In the example shown in FIG. 5B, the “cooling / heating state” and the “air blowing state” indicate that they operate independently.

<Relationship between layering and parallelization>
In this embodiment, “stratification” can be regarded as a special case of “parallelization”. In the following, description will be given for each case.

(1) Normal hierarchization (special case 1)
Normal hierarchization behaves the same as parallelization that satisfies the following conditions (normal hierarchization conditions).

  a. All transitions from the initial state of the state chart corresponding to the lower order (“initial transition”) occur only in the upper hierarchical state.

  b. There are transitions from the upper hierarchical state and transitions from all the states of the lower state chart to the initial state (referred to as “hierarchy exit transition”) with the same event and the same conditions.

  FIG. 6 is a diagram for explaining a special case 1 of parallelization. FIG. 6A illustrates an example of the same parallel hierarchy as in the case where the lower-level state chart of B is present under the state “a3”. In the example shown in FIG. 6A, the transition “e1” from the state “b1” to the state “b2” in the lower state chart B satisfies the condition of the state “a3” in the upper state chart A. It can be seen that FIG. 6B shows an example of a normal hierarchized state chart diagram that behaves the same as the parallel state chart diagram shown in FIG.

(2) History stratification (special case 2)
History stratification has the same behavior as parallelization that satisfies the following conditions (history stratification conditions).

  a. All the transitions in the state chart corresponding to the lower order all occur only in the upper hierarchical state.

  FIG. 7 is a diagram for explaining the special case 2 of parallelization. FIG. 7A shows an example of the same parallel hierarchy as in the case where there is a B lower state chart under the state “a3”. FIG. 7B shows an example of a state chart in a history hierarchy that has the same behavior as the parallel state chart shown in FIG.

  In this embodiment, the “transition” of the target flat state chart diagram is divided into two state chart diagrams, and the result of hierarchization or parallelization is generated as a candidate. When dividing by hierarchy and parallelization, the same event is always processed in the same state chart diagram. Furthermore, when layering and parallelization are possible, priority is given to layering. This is to make the generated state chart easier to read.

  In general, when a flat state chart diagram is hierarchized or parallelized so as to have the same behavior, a pair of state chart diagrams is generated as “candidates”. FIG. 8 is a diagram for explaining generation of a plurality of candidates. As will be described later, in this embodiment, a plurality of “candidates” are narrowed down to optimum candidates.

  FIG. 9 is a block diagram showing a schematic configuration of the hierarchization / parallelization apparatus according to the embodiment of the present invention. This apparatus is realized using a general-purpose computer (for example, a personal computer (PC) or the like) and software operating on the computer. The computer includes an engineering workstation (EWS) suitable for CAD (Computer Aided Design) and CAE (Computer Aided Engineering). The present embodiment can also be implemented as a program for generating “transition” of a target state chart diagram into two state chart diagrams and generating a result of hierarchization or parallelization as candidates on such a computer.

  As shown in FIG. 9, the hierarchization / parallelization device 100 according to the present embodiment mainly includes an input unit 10, a hierarchization / parallelization candidate generation unit 20, an ineligible candidate rejection unit 30, an optimal candidate selection unit 40, The state chart data storage unit 50, the candidate list storage unit 60, and the optimum candidate list storage unit 70 are configured.

  The input unit 10 takes in “state chart data” stored in the state chart data storage unit 50. “Statechart data” is a data format on a computer for expressing a statechart diagram. For example, it includes data of “state list”, “transition list”, and “(initial) state”.

  The hierarchization / parallelization candidate generation unit 20 distributes all transitions in the original state chart diagram to either or both of the resulting two state chart diagrams, and there is no contradiction in the “state correspondence data”. In this way, by repeating the consistency determination, two state charts that are hierarchized and parallelized are generated as one “candidate”. Here, the “state correspondence data” includes, for example, “state (in the original state chart diagram)”, “(state in the created first state chart diagram)”, “(created second state chart diagram). It consists of "state" data. “Candidate” is one of the results of layering / parallelization. For example, “(first) state chart data”, “(second) state chart data”, “state correspondence” It consists of “data list”, “type”, and “hierarchical state”. The “state correspondence data list” is a list of one or more state correspondence data. The “type” is information indicating which of “parallelization with dependency”, “parallelization without dependency”, “history hierarchy”, and “normal hierarchy”. The “hierarchical state” specifically indicates a hierarchical “state”.

  The hierarchization of state chart diagrams and the parallelization of state chart diagrams will be described later.

  The ineligible candidate rejection unit 30 determines whether or not the “candidates” in the two state chart diagrams generated by the hierarchization / parallelization candidate generation unit 20 have high maintainability, and leaves the one with high maintainability. And generate. Here, “high maintainability” means, in other words, that the generated state chart diagram is “easy to read”.

  The ineligible candidate rejection unit 30 can be composed of a low maintainability determination unit 31 and an ineligibility determination unit 32. The low maintainability determination unit 31 checks whether there are transitions that receive the same event in the two statechart diagrams that are generated "in a state that does not occur at the same time". To do. The “state that does not occur simultaneously” is obtained from the state correspondence data list. The inappropriateness determination unit 32 determines that the two received statechart diagrams simultaneously receive the same event other than the “hierarchy escape transition” of the normal hierarchization of the two generated statechart diagrams.

  The optimal candidate selection unit 40 narrows down the plurality of generated candidates (pairs in the state chart diagram) to those with higher maintainability. In order to narrow down those having higher maintainability, it is preferable to use an index value relating to maintainability for a pair of state chart diagrams. It is preferable to weight the index values related to maintainability, for example, parallelization with a dependency relationship <parallelization without a dependency relationship <history hierarchy <normal hierarchy>. The narrowed down result is an optimal candidate list. The narrowing will be described later.

  The state chart data storage unit 50 stores state chart data.

  The candidate list storage unit 60 stores a “candidate list”. The “candidate list” is a list in which a plurality of “candidates” as a result of hierarchization and parallelization are arranged.

  The optimum candidate list storage unit 70 stores the optimum candidate list narrowed down by the optimum candidate selection unit 40.

<Operation example>
Next, an operation example of the hierarchization / parallelization apparatus configured as described above will be described. First, FIG. 10 is a diagram showing a structure of each data appearing in the present embodiment. In FIG. 10, “*” indicates that one or more pieces of the data are arranged. The underlined data is data that is not further decomposed and is represented by a character string.

  FIG. 11 is a diagram showing a state chart as a source used in the description of the operation example. The state chart shown in FIG. 11A can also be expressed in the tree format shown in FIG. The data structure in the state chart shown in the operation example of FIG. 11 is as shown in FIG.

  The operation of the hierarchization / parallelization device can be broadly divided into (1) hierarchization / parallelization candidate generation processing, (2) ineligible candidate rejection processing, (3) optimum candidate selection processing, and (2) ineligible candidates. The rejection process is subdivided into (2a) low maintainability determination process and (2b) inappropriate determination process.

<Tiering / parallelization candidate generation processing>
The hierarchization / parallelization candidate generation unit 20 receives the original statechart diagram S and generates statechart diagrams A and B which are hierarchization / parallelization candidates. The outline of the algorithm for candidate generation is described below, and candidates are generated while repeating selection of any of the search patterns (i), (ii), and (iii). All candidates can be found by covering all options. A (ai) is “true” when the state of the state chart diagram A is ai, and B (bj) is “true” when the state of the state chart diagram B is bj. This is called “state constraint”.

(Procedure 1) Create initial states of A and B. The initial state is created by allocating each transition starting from the initial state chart S to the two state charts A and B. When the distribution is performed with priority in width and all transitions are processed, the process ends. In the operation example shown in FIG. 11, the transition is described as being composed only of events for the sake of simplicity. FIG. 13 is a diagram for explaining the creation of the initial state in the operation example shown in FIG. As shown in FIG. 13, the correspondence between the states can be found from the created initial state. The original state chart diagram S being “stopped” corresponds to the state chart diagram A being in the state a1 and the state chart diagram B being in the state b1.

(Procedure 2) State state set JA, B state set JB, original state chart diagram S and created state chart diagrams A and B data JT indicating state correspondence, final state correspondence As the result JT ′ of the data list, the initial state of JT and JT ′ is determined.

(Procedure 3) One “state correspondence” is extracted from JT. The state correspondence shown in FIG. 12 corresponds to JT ′ in step 3. If JT is empty, go to step 8.

(Procedure 4) One “transition” is extracted from the “state” in the original state chart diagram S of the extracted state correspondence data, and one of the following search patterns (i), (ii), and (iii) is selected. Run.

  (I) Allocate the extracted “transition” to the state chart diagram A.

  (Ii) The extracted “transition” is allocated to the state chart diagrams A and B.

(Iii) The extracted “transition” is allocated to the state chart diagram B.
FIG. 14 is a diagram illustrating the creation of a pattern for distributing the transition “ON” in the operation example. As shown in FIG. 14, the state list represents the states constituting each state chart diagram. Here, JA = {a1, a2} and JB = {b1}.

  FIG. 15 is a diagram illustrating the creation of a pattern for distributing the transition “cooling / heating switching” from “during cooling” to “during heating” in the operation example. For each pattern, a transition corresponding to the transition “cooling / heating switching” is created. In the example shown in FIG. 15, the pattern (i) is extracted and shown. The correspondence between states after distribution is as shown in the figure.

  FIG. 16 is a diagram for explaining creation of a pattern for distributing the transition “OFF” in the operation example. Transitions corresponding to the transition “OFF” are created for each pattern. In the example shown in FIG. 16, patterns (i) and (iii) are extracted and shown. The correspondence between states after distribution is as shown in the figure.

  When “transition” becomes empty, the process proceeds to step 3.

(Procedure 5) If there is a contradiction, the distribution pattern is discarded. In the example shown in FIG. 16, in the patterns (i), (iii), and (i) after the distribution, the state correspondence {a1, b2} is assigned to “stopped”, but already {a1, b1} Assigned. Similarly, in the patterns (i), (iii), and (iii) after the distribution, the state correspondence {a2, b2} is assigned to “stopped”, but {a1, b1} is already assigned. . FIG. 17 is a diagram for explaining a contradiction check. In the patterns (i), (iii), and (i), the state of the state chart diagram B when “stopped” can be b1 and b2, which are contradictory. Therefore, patterns (i), (iii), and (i) are discarded. Similarly, in the patterns (i), (iii), and (iii), the state of the state chart diagram A at the time of “stopped” can be a1 and a2, and there is a contradiction. Therefore, the patterns (i), (iii), and (iii) are discarded.

(Procedure 6) Move to procedure 3.

  FIG. 18 is a diagram for explaining the creation of a pattern for allocating the transition “cooling / heating switching” from “heating” to “cooling” in the operation example with respect to patterns (i), (iii), and (ii). . As shown in FIG. 18, since “cooling / heating switching” has already been assigned to the state chart diagram B, it is finally discarded by the ineligible candidate rejecting unit 30.

  Next, FIG. 19 shows creation of a pattern for allocating the transition “OFF” from “heating” to “stopping” in the operation example to patterns (i), (iii), (ii), and (iii). FIG. As shown in FIG. 19, since “OFF” has already been assigned to the state charts A and B, the patterns (i), (iii), (ii), (iii), (i) and the pattern (i) , (Iii), (ii), (iii), (iii) are finally discarded by the ineligible candidate rejecting unit 30.

(Procedure 7) Summarize transitions to be summarized.

(Procedure 8) The state restrictions that can be removed are removed.

  FIG. 20 is a diagram for explaining the arrangement of transition conditions. The state b2 in the state chart diagram B is established only when heating = {a2, b2} from the state correspondence data. That is, it can be seen that the state of a2 is always in the state of b2. Therefore, as shown in FIG. 20B, the edge condition A (a2) from the state b2 is always “true” and can be omitted.

(Procedure 9) In accordance with the normal hierarchization condition and the history hierarchization condition, what can be hierarchized is changed into a hierarchical expression. FIG. 21 is a diagram for explaining candidate hierarchization. Through the procedure 1 to procedure 8 described above, state charts A and B shown in FIG. 21A are finally generated. The generated state chart diagrams A and B satisfy the normal hierarchization condition. Therefore, when it is rewritten in a hierarchical form for easy reading, it becomes as shown in FIG.

  In the operation example described above, since only one candidate is finally completed, the layered / parallelized candidate generation process is completed.

  FIG. 22 is a diagram illustrating a data structure in a hierarchization / parallelization candidate generation process for generating a candidate list as a result.

<Detailed flow of hierarchical / parallelization candidate generation processing>
FIG. 23 is a flowchart illustrating a detailed example of the hierarchization / parallelization candidate generation process.

  First, assume that the initial state of the original state chart diagram S is s1, the set of states other than s1 is JS, the initial state of state chart diagram A is a1, and the initial state of state chart diagram B is b1.

  A state set (state list) in the state chart diagram A is JA, a state set (state list) in the state chart diagram B is JB, and the state chart diagram A and B corresponding to the original state chart diagram S is created. The data shown is JT = {(s1. (A1, b1))}, and JT ′ finally resulting in the state correspondence data list is JT ′ = {(s1. (A1, b1))} (step S231). ).

  Subsequently, one piece of state correspondence data is extracted from the state correspondence data list JT, and this is set as (si, (as, bs)) (step S232). If the state correspondence data list JT is empty, the process proceeds to step S236.

  Next, one transition from si is extracted from the transition list of the original state chart diagram S, and this is set as si-E / [C] F → sj (step S233). If the transition list is empty, the process proceeds to step S232.

  One of the following search patterns (i), (ii), and (iii) is selected and executed (step S234).

  (I) The transition as-E / [C∧B (bs)] F → at and the state at are added to the state chart diagram A as sj = (at, bs). Add (sj, (at, bs)) to JT and JT '.

  (Ii) Transition bs−E / [C∧A (as)] F → bt and state bt are added to the state chart diagram B as sj = (as, bt). (Sj, (as, bt)) is added to JT and JT ′.

(Iii) Transition as-E / [C∧B (bs)] F → at and state at are added to statechart diagram A as sj = (at, bt), and transition bs-E / [C in statechart diagram B ∧A (as)] F → bt and add state bt. Add (sj, (at, bt)) to JT and JT '.
Next, if (sj, (ai, bi)) εJT ′ for a certain ai, bi, the consistency is checked as sj = (ai, bi) (step S235). That is, in the case of (i), at = ai, bs = bi, and in the case of (ii), as = at, bt = bi, and the presence or absence of contradiction is checked. In the original statechart diagram S, different states sn, sm are both aj bj where sn = (aj, bj), sm = (aj, bj), or a certain state sn is different ajbj, If sn = (aj, bj), sn = (aj, bj) for ajbj (either one is acceptable), there is a contradiction. If it is not consistent, it is a failure.

  Next, the transitions from the same state, which are different only in the condition state constraints, are combined into one using ∨ (step S236). For example, if as-E / [C∧B (bs)] F → at and as―E / [C∧B (bu)] F → at are combined, as―E / [C∧ (B (bs) ∨ B (bu))] F → at.

  Next, for each state, find the set of states in the other statechart diagram that occur simultaneously from JT '. At this time, if there is a transition from this state that matches the state constraint of the condition and this set, the state constraint of this transition is removed (step S237).

  Thereafter, what can be hierarchized is changed into a hierarchical expression according to the normal hierarchization condition and the history hierarchization condition.

  If the above algorithm ends successfully, one division pattern is found. In the case of failure, all the divided patterns can be found by returning to the selection of the nearest search pattern (i), (ii), (iii) where the selection candidate remains and exhaustively searching for another candidate. it can.

<Disqualification candidate rejection process>
FIG. 24 is a flowchart showing the flow of the ineligible candidate rejection process. In the ineligible candidate rejection process, every time a hierarchically / parallelized candidate (statechart data pair) is generated by the hierarchical / parallelized candidate generation unit 20, the candidate is fetched (step S241), It is determined whether or not the candidate should be rejected as an ineligible candidate based on a predetermined criterion (step S242). As a determination criterion, it is preferable to make a determination based on good maintainability. What is not ineligible is output as one layered / parallelized candidate (two state charts).

<Inappropriate judgment processing>
In the present embodiment, a hierarchically / parallelized candidate (a pair of statechart data) is determined to be “inappropriate” in the following cases.

(Type a) When dividing into two state chart diagrams, only the state chart diagram A receives the same event or only the state chart diagram B receives the state chart diagram depending on the situation.

(Type b) The state chart diagram A and the state chart diagram B receive the same event other than the transition from the hierarchical state to the normal state in the normal hierarchization.

  FIG. 25 is a flowchart showing the flow of the inappropriateness determination process in the case of type a.

  First, all events received by the two state chart diagrams A and B are searched, and a set of these events is set as E (step S2501).

  For each event eεE (step S2502), it is determined whether only one of the state charts A and B has a transition due to e (step S2503). If only one side has a transition due to e, it is not suitable, and the process proceeds to the determination for the next candidate (state chart diagram pair).

  When there is a transition due to e in both statechart diagrams A and B, a set of transitions due to e in each of the statechart diagrams A and B is set to A (e) and B (e) (step S2504).

  For each sεA (e) (step S2505), the starting state of s is set to k (s). All the states of B that occur simultaneously with k (s) are extracted from the state correspondence data and set as B_k (s) (step S2506).

  For each t∈B_k (s) (step S2507), it is determined whether or not there is a transition from t to the same event and condition as s (step S2508). If there is no corresponding transition, it is determined as inappropriate.

  If there is a corresponding transition, the starting state of u is set to k (u) for each uεB (e) (step S2509). All the states of A that occur simultaneously with k (u) are extracted from the state correspondence data, and are set as A_k (u) (step S2510).

  For each vεA_k (u) (step S2511), it is determined whether there is no transition from v to u with the same event and condition (step S2512). If there is no corresponding transition, it is determined as inappropriate. If there is a corresponding transition, it is determined as “appropriate”.

  FIG. 26 is a flowchart showing the flow of the inappropriateness determination process in the case of type b.

  First, it is determined whether or not normal hierarchization is performed (step S2601). If it is normal hierarchization, it is determined as “suitable”.

  When it is not normal hierarchization, for each event eεE (step S2602), it is determined whether there is a transition due to e in only one of the state chart diagrams A and B (step S2603). If there is a transition due to e only in one side, it is not a history stratification, and the process proceeds to determination on the next candidate (a pair in the state chart diagram).

  When there are transitions due to e in both of the state chart diagrams A and B, a set of transitions due to each of A and B is defined as A (e) and B (e) (step S2604).

  For each sεA (e) (step S2605), the starting state of s is set to k (s).

  All the B states that occur simultaneously with k (s) are extracted from the state correspondence data and set as B_k (s) (step S2606).

  For each tεB_k (s) (step S2607), it is determined whether there is a transition from t to the same event and condition as s (step S2608). If it is present, it is determined as inappropriate.

For each u∈B (e) (step S2609),
Let u (u) be the starting state of u. All the states of A that occur simultaneously with k (u) are extracted from the state correspondence data and set as A_k (u) (step S2610).

For each v∈A_k (u) (step S2611),
It is determined whether there is a transition due to the same event and condition as v to u (step S2612).

  If there is a corresponding transition, it is determined as inappropriate. If there is no corresponding transition, it is determined as “appropriate”.

<Optimum candidate selection process>
FIG. 27 is a flowchart showing the flow of the optimum candidate selection process. In the optimal candidate selection process, each time a hierarchically / parallelized candidate (statechart data pair) is generated by the hierarchical / parallelization candidate generation unit 20 (step S271), the presence / absence of the next candidate is determined. Determination is made (step S272).

  When the generation of all candidates is completed (NO in step S272), in the optimum candidate selection unit 40, all candidates are aligned by the “maintainability comparison unit” (step S273). “Conservativeness comparison means”, for example, gives a total order indicating good / bad maintainability to a pair of statechart diagrams that are hierarchized / parallelized by a predetermined index value. .

  Next, a set of the best candidates (a plurality when there are a plurality of candidates) is selected (step S274) and output.

<Selection process by index value>
In the optimal candidate selection unit 40, candidates that are layered and parallelized (statechart data pairs) are classified into parallelization with dependency, parallelization without dependency, history hierarchization, and normal hierarchization. Hierarchy> History hierarchy> Parallelization without dependency> Parallelization with dependency and order are determined. FIG. 28 is a flowchart showing the flow of the optimum candidate classification process based on the index value related to maintainability.

  First, (a) all transitions from the initial state of the state chart corresponding to the lower order occur only in the upper hierarchical state, and (b) the same event and the same condition as the transition from the upper hierarchical state. Thus, it is determined whether or not the condition that there is a transition from all the states in the lower state chart diagram to the initial state is satisfied (step S281). If the above condition is satisfied (Yes in step S281), it is determined as “normal hierarchy” (step S282).

  Next, it is determined whether or not all the transitions in the state chart corresponding to the lower level occur only in the upper hierarchical state (step S283). When such a condition is satisfied (Yes in step S283), it is determined as “history hierarchy” (step S284).

  Next, it is determined whether or not all transitions include a condition that refers to the other state (step S285). If such a condition is satisfied (Yes in step S285), it is determined that “parallelization without dependency” (step S286).

  Candidates that are not classified into any of the above are determined as “parallelization with dependency” (step S287).

<Example of optimal candidate selection>
An example of optimal candidate selection in the optimal candidate selection unit 40 will be described. FIG. 29 is a diagram illustrating an example of optimal candidate selection based on index values. From the original state chart shown in FIG. 29A, candidate 1 shown in FIG. 29B and candidate 2 shown in FIG. 29C are generated. As shown in FIG. 29 (b), candidate 1 is a pair of state chart data in a history hierarchy. As shown in FIG. 29 (c), candidate 2 is a pair of parallel statechart data having a dependency relationship. Therefore, candidate 1 is selected as the optimal candidate.

<Example>
Here, the state transition in the fully automatic washing machine in which the dehydration function can select “strong” or “weak” is illustrated as an example. FIG. 30 is a diagram showing a state transition of the fully automatic washing machine in a flat state chart diagram. From the original state chart shown in FIG. 30, it is possible to make a hierarchy having a dependency relationship with the normal hierarchy. Therefore, the normal hierarchization is selected based on the candidate narrowing function. FIG. 31 is a diagram illustrating an example of a state chart selected based on the candidate narrowing function.

  Furthermore, it is possible to hierarchize / parallelize the state chart diagram of the lower hierarchy of the state “ON”. From the processing result, a parallelized one having a dependency relationship with the history stratification can be a candidate. Therefore, the normal hierarchization is selected based on the candidate narrowing function. FIG. 32 is a diagram illustrating an example of a state chart selected based on the candidate narrowing function.

  As described above, according to this embodiment, it is possible to generate, as candidates, state chart diagrams in which the transition of a target flat state chart diagram is hierarchized or parallelized so that the meaning and behavior can be easily understood.

  FIG. 33 is a diagram illustrating an example of conversion from a source code to a state chart diagram. In the example shown in FIG. 33, a washing machine is taken as an example, and the number of states is 20, the number of transitions is about 170, and the original source code is 400 lines is converted into a state chart diagram. The state chart shown in FIG. 33 is difficult to understand at first glance. FIG. 34 is a state chart after hierarchization / parallelization for the example shown in FIG. Looking at FIG. 34, it is easy to understand the meaning and behavior.

  Although several embodiments of the present invention have been described, these embodiments are presented by way of example and are not intended to limit the scope of the invention. These novel embodiments can be implemented in various other forms, and various omissions, replacements, and changes can be made without departing from the scope of the invention. These embodiments and modifications thereof are included in the scope and gist of the invention, and are included in the invention described in the claims and the equivalents thereof.

DESCRIPTION OF SYMBOLS 100 ... Hierarchization / parallelization apparatus 10 ... Input part 20 ... Hierarchization / parallelization candidate generation part 30 ... Unqualified candidate rejection part 40 ... Optimal candidate selection part 50 ... State Chart data storage unit 60 ... Candidate list storage unit 70 ... Optimal candidate list storage unit

Claims (8)

Enter the target flat original statechart diagram,
All the transitions of the original statechart diagram are divided into either or both of the resulting two statechart diagrams, and a hierarchical list or a parallelized statechart diagram pair is generated as a candidate list. With a parallelization candidate generator,
A hierarchization / parallelization apparatus that obtains a hierarchized / parallelized state chart using the candidate list. About the candidate list, it is determined whether or not the maintainability is high, and the ineligible candidate rejecting unit that generates a highly maintainable candidate list as a high maintainability candidate list,
The hierarchization / parallelization apparatus according to claim 1, further comprising: an optimum candidate selection unit that narrows down the highly maintainable candidate list to a higher maintainability and generates an optimum candidate list. The hierarchy is
When the current state of the statechart diagram is a certain state, a normal hierarchization described by nesting a more detailed statechart diagram or a history state or a deep history state is placed in the state. Categorized into history stratification,
The history status represents the status of the hierarchy when it last exited the hierarchy where it was placed,
3. The hierarchization / parallelization device according to claim 1, wherein the deep history state represents a state of the hierarchy and all the lower hierarchies when the last exit from the placed hierarchy. 4.   The hierarchization / parallelization device according to any one of claims 1 to 3, wherein the hierarchization / parallelization candidate generation unit prioritizes hierarchization when hierarchization and parallelization are possible. The ineligible candidate rejection unit is
When there is a transition that receives the same event in the state chart pair that does not occur at the same time, a low maintainability determination unit that determines that maintainability is low, and
The pair of state charts includes an improper determination unit that determines that a state chart that simultaneously receives both state charts resulting in the same event is inappropriate except in the case of the normal hierarchization. The layering / parallelizing device according to any one of the above.   5. The hierarchization / parallelization device according to claim 2, wherein the optimum candidate selection unit narrows down the pair of the state chart diagrams by using an index value relating to maintainability.   7. The hierarchization / parallelization device according to claim 6, wherein the index value related to maintainability is weighted in the order of parallelization with dependency relationship <parallelization without dependency relationship <history hierarchy> normal hierarchy. A state chart data storage section for storing state chart data indicating the original state chart diagram;
A candidate list storage unit for storing the candidate list;
The hierarchization / parallelization device according to claim 1, further comprising an optimal candidate list storage unit that stores the optimal candidate list.