A method for dynamic self-organizing assembly of industrial software components for a task sequence

Abstract

This invention discloses a dynamic self-organizing assembly method for industrial software components in a task sequence. In this method, firstly, available industrial software components are self-organized and assembled for the first task in the task sequence to construct a basic industrial software system. Then, based on the functional requirements of subsequent tasks in the sequence, the components in this basic industrial software system are dynamically adjusted to meet the functional requirements of all subsequent tasks. This method allows subsequent tasks in the sequence to effectively utilize the software component set constructed by the preceding tasks, avoiding the need to completely reassemble components for each task, thus saving the cost of industrial software component assembly. Furthermore, subsequent tasks in the sequence can effectively reuse the execution results of similar preceding tasks, avoiding the waste of repetitive work and thus saving task execution costs.

Description

Technical Field

[0001] This invention relates to the field of industrial software systems, and more specifically to a dynamic self-organizing assembly method for industrial software components for task sequences. This method can effectively reduce the assembly cost of industrial software components and the execution cost of task sequences. Background Technology

[0002] Industrial software, as a crucial foundation and key support for the industrial sector, plays a pivotal role in promoting industrial upgrading and development. While China is a major industrial power, its industrial software development level lags significantly behind international advanced levels, becoming a major factor hindering its transformation from a large industrial nation to a leading industrial power. Therefore, developing industrial software has become a major national strategic need.

[0003] Industrial software components are used to develop, build, and maintain industrial software systems; they are essentially the "parts" that build industrial software. Component-based industrial software assembly methods can adapt to the dynamic complexity of industrial environments and achieve scalability for industrial software. Current component-based industrial software assembly is typically task-driven, meaning that suitable industrial software components are selected and assembled based on the functional requirements of the task to be performed, thereby building an industrial software system that meets the functional requirements of that task. Traditional task-driven industrial software component assembly methods usually assemble industrial software components independently for a single task, meaning that new tasks require reassembling the software components.

[0004] However, in actual industrial production environments, a series of task sequences are often encountered. For example, in manufacturing, a series of product production tasks may be assigned to the same workshop. If the industrial software system were reassembled and rebuilt separately for each task, it would result in very high costs. Therefore, this invention, considering the characteristics of task sequences, proposes a dynamic self-organizing assembly method for industrial software components in a task sequence. In this method, the execution order of tasks is first determined according to the task sequence. Then, for the first task to be executed, the available industrial software components are self-organized and assembled to build a basic industrial software system. Next, the components in this basic industrial software system are dynamically adjusted according to the functional requirements of subsequent tasks in the task sequence to meet the functional requirements of all tasks in the sequence. Compared to previous methods of assembling and building industrial software systems separately for each task, this method allows subsequent tasks in the task sequence to effectively utilize the component sets assembled by previous tasks, thus avoiding the waste caused by completely reassembling each task and saving on component assembly costs. Furthermore, subsequent tasks in the task sequence can effectively reuse the execution results of similar previous tasks, thus avoiding the waste of repeated execution and saving on task execution costs.

[0005] Therefore, the dynamic self-organizing assembly method for industrial software components for task sequences proposed in this invention patent can be applied to situations in the current industrial environment that undertake a series of task sequences, effectively achieving the goal of energy saving and efficiency improvement. Summary of the Invention

[0006] To address the aforementioned problems, this invention discloses a dynamic self-organizing assembly method for industrial software components in a task sequence. First, components are assembled to construct a basic industrial software system for the first task to be executed in the task sequence. Then, the components in the basic industrial software system are dynamically adjusted to meet the functional requirements of subsequent tasks in the task sequence. This method avoids the significant expense of reassembling industrial software components for each task in the task sequence individually. Furthermore, it allows subsequent tasks in the task sequence to effectively reuse the execution results of similar preceding tasks, thereby effectively reducing the cost of task execution. The assembly method comprises four parts: (1) a cost discount mechanism for sequential execution of the task sequence; (2) a component assembly cost calculation method for sequential execution of the task sequence; (3) an optimization objective for component assembly that satisfies sequential execution of the task sequence; and (4) a dynamic self-organizing assembly process for software components in sequential execution of the task sequence.

[0007] A dynamic self-organizing assembly method for industrial software components for task sequences includes the following four parts:

[0008] (1) Cost Discount Mechanism for Sequential Execution of Task Sequences. When a task sequence is executed by the same set of industrial software components, subsequent tasks can effectively utilize the execution results of previous tasks, thus reducing execution costs. This invention proposes a cost discount mechanism for sequential execution of task sequences. The more tasks preceding a task are executed, the more likely the task is to reuse the execution results of previous tasks, thus facilitating cost reduction (i.e., a larger cost discount); furthermore, the greater the similarity between a task and its preceding tasks, the more effectively the execution results of previous tasks can be utilized, resulting in lower costs (i.e., a larger cost discount).

[0009] (2) Calculation method for component assembly cost when task sequence is executed sequentially. The cost of assembling industrial software when task sequence is executed sequentially includes the following: basic software system transfer cost (component assembly cost of building basic software system for the first task in the task sequence, mainly determined by the number of components contained in the basic software system); software component dynamic adjustment cost during task sequence execution (mainly determined by the number of components that need to be deleted or added when subsequent tasks in the task sequence are executed); cost of sequential execution of task sequence (obtained through Part 1 above).

[0010] (3) Optimization objective for dynamic self-organizing assembly of industrial software components for task sequences. The optimization objective for dynamic self-organizing assembly of industrial software components for task sequences proposed in this invention is designed to minimize the component assembly cost of sequential execution of the task sequence as described in Part 2 above (including the cost of building the basic software system, the cost of dynamic adjustment of software components during task sequence execution, and the cost of sequential execution of the task sequence).

[0011] (4) Dynamic self-organizing assembly process of software components for sequential execution of task sequences. First, a basic industrial software system assembly and construction process for the first task in the task sequence is proposed: First, select a component from the candidate industrial software components that best matches the functional set required by the first task; then, select another component from the remaining candidate industrial software components that best matches the functional set lacking in the first task. This process is repeated until all functional sets required by the first task are covered by the selected component set. Then, these selected software components are assembled to build the basic industrial software system. Next, the existing assembled industrial software system is dynamically adjusted according to the functional requirements of subsequent tasks in the task series: First, software components in the existing industrial software system that cannot meet the functional requirements of subsequent tasks are deleted; based on the functional set lacking in the existing industrial software system when executing subsequent tasks, a component from the candidate industrial components that best matches the currently lacking functional set is selected; this process is repeated until all functional sets required by the subsequent task are met. Finally, the selected software components are assembled to build a new industrial software system to execute the task. For each subsequent task, the aforementioned process is repeated to dynamically adjust the components in the software system, thereby meeting the functional requirements of each task.

[0012] Beneficial effects:

[0013] (1) Save on the assembly cost of industrial software components. First, a basic industrial software system is assembled and built for the task sequence, and then dynamically adjusted according to the functional requirements of each task in the task sequence. Compared with the previous method of assembling and building an industrial software system for each task separately, this method allows subsequent tasks in the task sequence to effectively utilize the component set assembled and built by the previous tasks, avoiding the waste caused by completely reassembling each task, thereby saving the cost of component assembly.

[0014] (2) Reduce the cost of task execution. Subsequent tasks in a task sequence can effectively reuse the execution results of similar tasks in the preceding sequence, thus avoiding the waste of repeatedly executing parts of the task and saving the cost of task execution. Attached Figure Description

[0015] Figure 1 It is a process for assembling and dynamically adjusting industrial software components for task sequences.

[0016] Figure 2 It refers to a specific task t in the task sequence. x Self-organizing assembly process of industrial software components Detailed Implementation

[0017] This invention discloses a dynamic self-organizing assembly method for industrial software components for task sequences, which mainly includes four parts: (1) a cost discount mechanism for sequential execution of task sequences; (2) a component assembly cost calculation method for sequential execution of task sequences; (3) an optimization target for dynamic self-organizing assembly of industrial software components for task sequences; and (4) a dynamic self-organizing assembly process for software components for sequential execution of task sequences.

[0018] The present invention will be further illustrated below with reference to the accompanying drawings and specific embodiments. It should be understood that the following specific embodiments are for illustrative purposes only and are not intended to limit the scope of the present invention.

[0019] The specific implementation steps of the dynamic self-organizing assembly method for industrial software components based on task sequences described in this invention are as follows:

[0020] (1) Cost discount mechanism for sequential execution of task sequences. Assume the sequence of tasks to be executed sequentially is T = {t1, t2, ..., t...} m}, where m represents the number of tasks in task sequence T. Assume there are t tasks in T. x The set of functions required for (1≤x≤m) is F. x ={f x1 ,f x2 ,…,f xk}, k represents task t x Given the required number of functions, the similarity of functional requirements among all tasks in task sequence T is defined as follows:

[0021]

[0022] Assume task t in task sequence T y The required function set for (1≤y≤m) is F. y ={f y1 ,f y2 ,…,f yj}, where j represents task t y The required number of functions. Then task t... x With t y The functional requirements are similar between them as follows:

[0023]

[0024] Now, assuming the tasks in task sequence T are executed sequentially from beginning to end, each executed task can reuse the execution results of relevant parts of previous tasks, thus avoiding the waste of repetitive work and reducing its execution cost. The degree of this cost discount is related to the similarity of functional requirements of all tasks in the entire task sequence T, and the similarity of functional requirements between the currently executing task and the previous tasks. Assume task t in T... xThe cost required to execute (1≤x≤m) alone is c(t). x If all tasks in T are executed sequentially by a dynamically assembled industrial software system, then the total cost is:

[0025]

[0026] Where ψ is the discount function, its range is [0,1], and its value monotonically decreases as the independent variable increases. λ 1,0 =0.

[0027] (2) Calculation method for component assembly cost during sequential task execution. The cost of assembling industrial software during sequential task execution includes the following: basic software system assembly cost, dynamic adjustment cost of software components during task execution, and cost of sequential task execution. Therefore, the total component assembly cost during sequential task execution is the weighted sum of these three parts.

[0028] First, assuming the set of software components in the basic software system built for the first task t1 in the task sequence T is A1, then the assembly cost of the basic software system for this task sequence is Fab(|A1|), where Fab is a monotonically increasing function. Second, as the task sequence executes sequentially, the software components in the basic software system will dynamically adjust according to the functional requirements of the currently executing task, i.e., existing components will be removed and new components will be added. Therefore, the dynamic adjustment cost of software components is determined by the total number of software components removed and added during the execution of all tasks in the entire task sequence. Assume task t is executed... x The set of software components required for (1≤x≤m) is A. x The cost of dynamic adjustment of software components during task sequence execution is as follows:

[0029]

[0030] in It is a monotonically increasing function.

[0031] Secondly, the execution cost of executing the task sequence sequentially is calculated in Part 1 above.

[0032] Ultimately, the total assembly cost of industrial software components executed sequentially in the task sequence is:

[0033]

[0034] γ1, γ2, and γ3 are parameter values ​​that measure the relative importance of the three costs and will be set according to the specific industrial production environment and task situation.

[0035] (3) Satisfying the optimization objective of dynamic self-organizing assembly of industrial software components for sequential execution of task sequences. This invention designs the optimization objective of dynamic self-organizing assembly of industrial software components for sequential execution of task sequences as minimizing the total assembly cost of industrial software components for sequential execution of task sequences. Furthermore, this optimization objective also needs to satisfy the following conditions: the functional set of components in the basic software system formed by assembly can cover the functional set required by the first task in the task sequence; the functional set of components in the dynamically adjusted software system for each task can cover the functional set required by that task; and all tasks in the task set T are executed sequentially.

[0036] Assuming the set of all available industrial software components in an industrial environment is A, then the optimization objective for the dynamic self-organizing assembly of industrial software components that satisfies the sequential execution of the task sequence is: for the task sequence T = {t1, t2, ..., t...} m The combination scheme of the industrial software component set obtained by assembling and self-organizing software components is called Soft. T ={A1,A2,…,A m}, where A x (1≤x≤m) represents the sequence of tasks t in the task sequence. x进行 Given a set of assembled and dynamically adjusted software components, the optimization objective is to find a combination scheme for industrial software components that minimizes the total assembly cost of industrial software components executed sequentially in a task sequence, as shown below:

[0037]

[0038] satisfy:

[0039]

[0040]

[0041] Among them, FA x A represents x The set of functions possessed by all software components; finish(t x ) represents task t x The end time, start(t) y ) represents task t y The start time.

[0042] (4) Dynamic self-organizing assembly process of software components for sequential execution of task sequences. Assuming the set of available industrial software components in the current system environment is A, the process is implemented as follows:

[0043] (4.1) Assemble the components of the basic software system according to the functional requirements of the first task t1 in the task sequence. Follow these steps:

[0044] Step 1: Calculate the set of functions that task t1 currently lacks: Lack_F1 = F1; the set of software components A1 = {};

[0045] Step 2: Select from A the software component with the highest matching degree for the set of functions that t1 currently lacks (F_a i represents the set of functions owned by component a i ):

[0046]

[0047] Step 3: A = A - {a*}; A1 = A1 ∪ {a*}; Lack_F1 = Lack_F1 - F_a * ;

[0048] Step 4: If Lack_F1 ≠ {}, then go to Step 2; otherwise, go to Step 5:

[0049] Step 5: Output A1, which is the set of industrial software components assembled for task t1.

[0050] (4.2) Perform dynamic adjustment of software components for subsequent tasks in the task sequence. In the order of x from 2 to m, for subsequent tasks t in the task sequence x (1 < x ≤ m), perform dynamic adjustment of software components according to the following steps:

[0051] Step 1: A x = A x-1 ;

[0052] Step 2: If F_a i ∩F x == {}, then A x = A x - {a i};

[0053] Step 3: Calculate the set of functions that task t x currently lacks:

[0054] Step 4: Select from A the software component with the highest matching degree for the set of functions that t x currently lacks:

[0055]

[0056] Step 5: A = A - {a *}; A x = A x ∪ {a *};Lack_F x =Lack_F x -F_a * ;

[0057] Step 6: If Lack_F x If ≠ {}, proceed to step four; otherwise, proceed to step seven.

[0058] Step 7: Output A x Then it is for task t x The assembly of industrial software components.

Claims

1. A method for dynamic self-organizing assembly of industrial software components for a task sequence, characterized in that: The method includes the following parts: (1) Cost discount mechanism for sequential execution of task sequences; (2) Calculation method for component assembly cost when tasks are executed sequentially; (3) Optimization objective for dynamic self-organizing assembly of industrial software components for task sequences; (4) Dynamic self-organizing assembly process of software components for sequential execution of task sequences; The cost discount mechanism for sequential execution of task sequences designed in Part (1) is related to the number and similarity of tasks in the task sequence. Assuming the task sequence is... T , T ={ t 1 , t 2 ,…, t m }, m Represents a task sequence T The number of tasks in the process, assuming T Tasks in t x ( 1 ≤ x ≤ m The cost required when executed alone is c ( t x ), then when T The total cost required for all tasks to be executed sequentially by a dynamically assembled industrial software system is: ； in Let be a discount function, with a range of [0,1]. Its value monotonically decreases as the independent variable increases. Indicates task t x and t x-1 The similarity of functional requirements between them Sim T For task sequence T The functional requirements of all tasks are similar; The total component assembly cost for the sequential execution of the task sequence in Part (2) Includes: Basic software system assembly costs Fab (| A 1 |) Dynamic adjustment costs of software components during task sequence execution Adjust ( T The cost C of executing the task sequence sequentially. T ), as shown below: ； in , , The parameter values ​​for measuring the relative importance of the three costs will be set according to the specific industrial production environment and task situation; The optimization objective for the dynamic self-organizing assembly of industrial software components for task sequences in Part (3) is to minimize the task sequence. T The total cost of assembling components sequentially, assuming a task sequence. T ={ t 1 , t 2 ,…, t m The combination scheme of the industrial software component set obtained by assembling and self-organizing the software components is as follows: Soft T ={ A 1 ,A 2 ,…,A m },in A x ( 1 ≤ x ≤ m For tasks in a task sequence t x After assembling and dynamically adjusting the software component set, the optimization objective is as follows: ； in FA x express A x The set of functions possessed by all software components; F x Indicates task t x The required set of functions; finish ( t x ) indicates a task t x End time, start ( t y ) indicates a task t y Start time; Assume the set of available industrial software components in the current system environment is as follows: A The dynamic self-organizing assembly process of software components for sequential execution of task sequences in Part (4) can be implemented as follows: (5.1) performing the first task in the task sequence t 1 The component assembly of the base software system according to the functional requirements is performed according to the following steps: Step 1: Calculation Task t 1 The following features are currently missing: Lack_F 1 = F 1 Software component collection A 1 ={}; Step 2: From A Selected for t 1 The software component that best matches the currently missing set of functionalities is, among which... F_a i Representation Component a i The set of features it possesses: ； in, F 1 For the task t 1 A is the set of functional requirements; A is the set of optional industrial software components in the current system environment. Step 3: ; Lack_F 1 = Lack_F 1 - F_a * ; a * The software component selected from the candidate components with the highest matching degree; Step 4: If Lack_F 1 If ≠{}, proceed to step two; otherwise, proceed to step five. Step 5: Output A 1 This is for the task t 1 The assembly of industrial software components; (5.2) Dynamically adjust software components for subsequent tasks in the task sequence, according to... x From 2 to m The order of tasks in the task sequence. t x (1< x ≤ m To dynamically adjust software components, follow these steps: First step: A x = A x-1 ; Step Two: :if ,but A x = A x -{ a i }; Step 3: Calculation Task t x The following features are currently missing: ; Step 4: From A Selected for t x Currently, the software component with the highest degree of functional matching is lacking: ； Step 5: ; Lack_F x = Lack_F x - F_a * ; Lack_F x For the task t x The current missing set of functions; F_a * For the selected component a * A collection of functions; Step 6: If Lack_F x If the value is not equal to {}, proceed to step four; otherwise, proceed to step seven. Step 7: Output A x This is for the task t x The assembly of industrial software components.

Images