CN109814924A - A software complexity calculation method - Google Patents
A software complexity calculation method Download PDFInfo
- Publication number
- CN109814924A CN109814924A CN201910081440.7A CN201910081440A CN109814924A CN 109814924 A CN109814924 A CN 109814924A CN 201910081440 A CN201910081440 A CN 201910081440A CN 109814924 A CN109814924 A CN 109814924A
- Authority
- CN
- China
- Prior art keywords
- software
- complexity
- component
- execution route
- activity
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000004364 calculation method Methods 0.000 title claims abstract description 26
- 230000000694 effects Effects 0.000 claims abstract description 45
- 238000000034 method Methods 0.000 claims description 64
- 239000000203 mixture Substances 0.000 claims description 40
- 230000008569 process Effects 0.000 claims description 25
- 230000006870 function Effects 0.000 claims description 24
- 230000008859 change Effects 0.000 description 8
- 230000008901 benefit Effects 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 3
- 238000004590 computer program Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 238000011156 evaluation Methods 0.000 description 2
- 238000004458 analytical method Methods 0.000 description 1
- 238000013473 artificial intelligence Methods 0.000 description 1
- 230000033228 biological regulation Effects 0.000 description 1
- 238000004422 calculation algorithm Methods 0.000 description 1
- 239000000039 congener Substances 0.000 description 1
- 230000007423 decrease Effects 0.000 description 1
- 238000001035 drying Methods 0.000 description 1
- 239000000284 extract Substances 0.000 description 1
- 238000010801 machine learning Methods 0.000 description 1
- 230000037361 pathway Effects 0.000 description 1
- 230000002035 prolonged effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Landscapes
- Stored Programmes (AREA)
Abstract
The invention discloses a kind of software complexity calculation methods, comprising: obtains each activity that the component in software includes；The each activity for including according to the component executes each component in the software by operational semantics rule, obtains the corresponding routing information of execution route of the software；According to the corresponding routing information of the execution route of the software, the complexity of the software is calculated.The present invention proposes the modeling language towards complexity, and operational semantics rule is devised for the modeling language, it can be in the complexity of each stage metric software product of software development based on the modeling language and operational semantics rule, and the DYNAMIC COMPLEX degree of component can be both calculated, again the accuracy of software complexity calculating can be improved with the average complexity of software for calculation structure.
Description
Technical field
The invention mainly relates to software technology field more particularly to a kind of software complexity calculation methods.
Background technique
With the fast development of computer and Internet technology, the development in the fields such as artificial intelligence, machine learning, cloud computing
Prospect is more and more wide, more and more extensive using the application system of these technological development, while being also constantly changing people's
Life style.Software systems scale constantly expands, and function also becomes to become increasingly complex.Due to the continuous innovation of software technology,
Requirement of the people for software function is higher and higher, and not requiring nothing more than software can be realized powerful function, and software is produced
The requirement of the qualitative attributes such as reliability, the stability of product is also higher and higher, therefore becomes increasingly to the evaluation work of software quality
It is important.
In software development, software complexity is a key factor for influencing software quality, therefore is also developer
The aspect being especially concerned about.The complexity of software is excessively high, will lead to the matter such as efficiency, maintainability, testability, the reliability of software
Horizontal decline is measured, while will increase the risk of software, it is very great that this requires high field to have software quality
It threatens.The quality of one software quality is that can software guarantee to occur that mistake does not occur even less in prolonged use
Important factor of evaluation.
Complexity metric mode relatively conventional at present has: lines of code mode, cyclomatic complexity mode and Halstead are multiple
Miscellaneous degree mode.Wherein, lines of code mode measures the size of software size according to the line number of software code.Lines of code is got over
It is more, show that software is more complicated.But there is very big one-sidedness, assessment that can only be rough, assessment result inaccuracy in this mode.Circle is multiple
Miscellaneous degree is primarily used to measure the complexity of a modular structure, calculates the item number of independent pathway, but it is not distinguished not
The complexity of congener control stream, and do not account for the complexity of sequential statement.Halstead complexity is in program
The operator and operand of appearance are count target, using the number that they occur as target is counted, calculate program appearance accordingly
Amount, workload.But there is no the complexity to interact between modules is calculated, there are errors.
From the foregoing, it will be observed that the existing generally existing accuracy of software complexity calculation is low, the big problem of error.
Summary of the invention
In order to solve the above problem, the invention proposes a kind of software complexity calculation methods, propose building towards complexity
Mould language, and operational semantics rule is devised for the modeling language, it can be soft based on the modeling language and operational semantics rule
The complexity of each stage metric software product of part exploitation, and the DYNAMIC COMPLEX degree of component can have not only been calculated, but also can count
Calculate the average complexity of software configuration.
Specifically, the invention proposes a kind of software complexity calculation methods, comprising:
Obtain each activity that the component in software includes；
The each activity for including according to the component executes each component in the software by operational semantics rule,
Obtain the corresponding routing information of execution route of the software；
According to the corresponding routing information of the execution route of the software, the complexity of the software is calculated.
Preferably, each activity that the component obtained in software includes, comprising:
The corresponding component information of component for including by the modeling language abstraction towards complexity；
Each activity that the component includes is identified from the component information, the activity is made of binary group, described
Binary group includes the corresponding function of the activity and the complexity for executing the function generation.
Preferably, each activity for including according to the component is executed in the software by operational semantics rule
Each component, obtain the corresponding routing information of execution route of the software, comprising:
The Component composition relationship in the software between each component is determined by the modeling language towards complexity；
By the operational semantics rule, the software is executed according to the executing rule of the Component composition relationship；
Record executes the corresponding routing information of each execution route in the software process, and the routing information includes executing
Each activity that path includes.
Preferably, the corresponding routing information of the execution route according to the software, calculates the complexity of the software,
Include:
The sum of each movable complexity that the corresponding routing information of the execution route includes is calculated, by obtain and value
DYNAMIC COMPLEX degree as the software under the execution route.
Preferably, the corresponding routing information of the execution route according to the software, calculates the complexity of the software,
Include:
The sum of each movable complexity that the corresponding routing information of each execution route includes is calculated separately, is obtained each
The corresponding Path complexity of execution route；
According to the corresponding Path complexity of each execution route, the average complexity of the software is calculated.
It is preferably, described that the average complexity of the software is calculated according to the corresponding Path complexity of each execution route,
Include:
Calculate the sum of corresponding Path complexity of each execution route, the total number of be calculated and value and execution route
Between ratio, using the ratio as the average complexity of the software.
Further, the method also includes:
If the complexity of the software is greater than preset threshold, the complexity for each Component composition that the software includes is determined
Degree；
According to the complexity of each Component composition, the structure of the software is optimized, until the software
Complexity is less than or equal to the preset threshold.
Preferably, the complexity according to each Component composition, optimizes the structure of the software, until
The complexity of the software is less than or equal to the preset threshold, comprising:
The maximum first component combination of complexity is determined from each Component composition；
It obtains second component to combine, between the function that the function of the second component combination is combined with the first component
Similarity is greater than preset value, and the complexity of the second component is less than the complexity of first component combination；
First component combination is replaced with into the second component combination；
The complexity of institute's software is recalculated, if the complexity of the software is still greater than the preset threshold, return is held
Row determines the operation of the maximum first component combination of complexity from each Component composition, until the complexity of the software
Degree is less than or equal to the preset threshold.
Further, the method also includes:
Show that the structure chart of the software, the structure chart include each component in the software in the form of patterned
And each activity that each component includes.
Further, the method also includes:
In the structure chart of the software of graphic software platform, each component and/or each activity are marked in implementation procedure
In generated complexity.
Compared with existing software complexity assessment technology, software complexity calculation method of the present invention has such as
It is lower the utility model has the advantages that
The embodiment of the present invention proposes the modeling language towards complexity, and devises operational semantics rule for the modeling language
Then, the description software configuration that can be more clear, the complexity being depicted in the process of implementation that operational semantics can be very rigorous
The situation of change of property.It can be in each stage metric software product of software development based on the modeling language and operational semantics rule
Complexity, and can not only calculate the DYNAMIC COMPLEX degree of component, but also can improve with the average complexity of software for calculation structure
The accuracy that software complexity calculates.It is further to study by using algebraic method on the basis of software for calculation complexity
The evolution problem of software configuration, it is intended to can optimization software structure, reduce the complexity of the software configuration.And also provide modeling
The patterned representation method of language enables developer more very clear for the structure of software, patterned expression
Method also may indicate that complexity caused by each component or activity in the process of implementation.
Detailed description of the invention
By reading the following detailed description of the preferred embodiment, various other advantages and benefits are common for this field
Technical staff will become clear.The drawings are only for the purpose of illustrating a preferred embodiment, and is not considered as to the present invention
Limitation.And throughout the drawings, the same reference numbers will be used to refer to the same parts.In the accompanying drawings:
Attached drawing 1 shows the composition schematic diagram of software configuration provided in an embodiment of the present invention.
Attached drawing 2 shows a kind of flow chart of software complexity calculation method provided in an embodiment of the present invention.
Attached drawing 3 shows the flow chart of another software complexity calculation method provided in an embodiment of the present invention.
Specific embodiment
The illustrative embodiments of the disclosure are more fully described below with reference to accompanying drawings.Although showing this public affairs in attached drawing
The illustrative embodiments opened, it being understood, however, that may be realized in various forms the disclosure without the reality that should be illustrated here
The mode of applying is limited.It is to be able to thoroughly understand the disclosure on the contrary, providing these embodiments, and can be by this public affairs
The range opened is fully disclosed to those skilled in the art.
In embodiments of the present invention, the modeling language towards complexity is proposed, on the basis of componentbased development, is taken out
As software configuration, the composition schematic diagram of software configuration as shown in Figure 1, regulation software configuration of the embodiment of the present invention is by multiple structures
Part composition, component is made of multiple activities, and activity is made of binary group, stores work in the corresponding binary group of activity
It moves corresponding function and executes complexity caused by the function.The modeling language is that component is made up of activity, component composition
The mode of software configuration describes a software product.The function and complexity of software configuration are described using the modeling language
Degree, the relationship understood between Component composition that can be more clear and the in the process of implementation situation of change of complexity.
The embodiment of the present invention is also that the modeling language proposes operational semantics rule, and operational semantics rule can be very rigorous
The situation of change of the complexity of component in the process of implementation is depicted, therefore specified using the operational semantics rule of the modeling language
Execute regular of Component composition and in the process of implementation caused by complexity.
Based on the above-mentioned modeling language towards complexity and operational semantics rule, the embodiment of the present invention proposes a kind of new soft
Part complexity calculating method, the routing information executed according to component come the complexity of software for calculation, can software for calculation dynamic
Complexity can also calculate the average complexity of entire software configuration.
Referring to fig. 2, the embodiment of the present invention comes the complexity of software for calculation, packet especially by following steps 101-103 operation
It includes:
Step 101: obtaining each activity that the component in software includes.
Specifically, the corresponding component information of component for including by the modeling language abstraction towards complexity；From structure
Each activity that identification means include in part information, activity are made of binary group, and binary group includes the corresponding function of activity and holds
The complexity that row function generates.
Modeling language towards complexity refers to use form method, and abstract component information, it is specified that component be by
Activity composition, activity is made of a binary group, is to be made of movable function with complexity needed for executing function.
Activity is to form the minimum unit of component.Component is the basic unit for forming software configuration, is taken out in the modeling language newly proposed
As software configuration, component is the composition most important part of software configuration.
Wherein, formalization method is to solve the problems in field of software engineering by using mathematical logic inference method
Method is an important channel for guaranteeing software system design correctness.Wherein, algebra, logic, automatic machine etc. constitute form
The theoretical basis of change method.Formalization realizes modeling and analysis to system style and structure style.Use form method
Ambiguity can be eliminated in the development phase, make all design works all and will comply with certain mathematical theory.In addition, formalization method
Machine expression is more conducive to by using stringent mathematical notation and is calculated.Modeling language towards complexity: the present invention be using
One group of syntax rule of formal definitions is used to describe component and Component composition, and specified campaign be form component minimum it is single
, the combination between component constitutes a software configuration；The modeling language mainly specifies sequence, concurrent, selection, calling etc.
Syntagmatic between component.
Step 102: each activity for including according to component, by each component in operational semantics rule runs software,
Obtain the corresponding routing information of execution route of software.
The combinations such as the characteristics of operational semantics rule is according to above-mentioned modeling language, respectively sequence, concurrent, selection, calling are closed
System define executing rule, the operational semantics rule in specify function executing rule and syntagmatic brought by complexity
Variation, complexity caused by the syntagmatic between component is shown by operational semantics rule, can be more clear
The situation of change of the complexity of the clear each component of understanding in the process of implementation.
Operational semantics rule define Component composition relationship executing rule and Component composition relationship caused by complexity
The calculating of degree.According to operational semantics rule, complexity required for component can be calculated in the process of implementation, and can chase after
The routing information of track component implementation procedure.
Specifically, the Component composition relationship in software between each component is determined by the modeling language towards complexity,
Component composition relationship includes sequence, concurrent, selection and call relation.By operational semantics rule, according to Component composition relationship
Executing rule runs software；The corresponding routing information of each execution route during runs software is recorded, routing information includes holding
Each activity that walking along the street diameter includes.
Step 103: according to the corresponding routing information of the execution route of software, the complexity of software for calculation.
According to operational semantics rule, it is able to record component routing information caused by implementation procedure, both included in path
The institute that component executes is functional, and contains the information for executing the complexity of syntagmatic between these functions and component,
Therefore the size of complexity required for component can be calculated according to routing information in the process of implementation.
The calculation method provided through the embodiment of the present invention can also both be calculated with the DYNAMIC COMPLEX degree of software for calculation
The average complexity of software.The routing information of execution route includes each activity that the execution route includes, and activity is by function
And the binary group of complexity composition indicates.And since there are different Component composition relationships between component each in software, no
With Component composition relationship may cause in software running process that there are multiple execution routes.Therefore for DYNAMIC COMPLEX degree, meter
The sum of each movable complexity that the corresponding routing information of execution route includes is calculated, using obtain and value as the execution route
The DYNAMIC COMPLEX degree of lower software.The DYNAMIC COMPLEX degree of the corresponding software of each execution route can be obtained in this manner.
For the average complexity of software product, calculate separately that the corresponding routing information of each execution route includes is each
The sum of movable complexity obtains the corresponding Path complexity of each execution route；According to the corresponding path of each execution route
Complexity, the average complexity of software for calculation.
When according to the average complexity of the corresponding Path complexity software for calculation of each execution route, specifically, calculate
The sum of corresponding Path complexity of each execution route, the ratio between be calculated and value and the total number of execution route,
Using the ratio as the average complexity of software.
In embodiments of the present invention, due in software development process, software configuration is that component is built by activity, then by structure
Part finally forms entire software configuration, and whole process is a dynamic development process, with the continuous propulsion of development process, software
The activity or component for being included are more and more.The embodiment of the present invention is the complexity calculating method of Component- Based Development, in software development
Each stage can metric software product in the manner described above DYNAMIC COMPLEX degree or average complexity.
In the manner described above, the embodiment of the present invention can software for calculation DYNAMIC COMPLEX degree, can also calculate entire software knot
The average complexity of structure can help the case where assessing software complexity under present case in software development process, according to multiple
The size of miscellaneous degree makes appropriate adjustment to develop more optimal software product, and has studied software knot using algebraic method
The evolution problem of structure proposes some algebraic rules to help optimization software structure.
Calculate the complexity of software through the above way, the complexity can be DYNAMIC COMPLEX degree or average complexity,
The complexity of software is compared with preset threshold later, if the complexity of software is greater than preset threshold, is shown current soft
The complexity of part is excessively high, needs to optimize software configuration.Specifically, it is determined that each Component composition that software includes out is answered
Miscellaneous degree, Component composition can be embodied by the Component composition relationship between multiple components, Component composition relationship can for sequence,
Concurrently, selection and call relation.By operational semantics rule, according to the executing rule of Component composition relationship, it is capable of determining that every
The complexity of a Component composition.Later according to the complexity of each Component composition, the structure of software is optimized, until software
Complexity be less than or equal to above-mentioned preset threshold.
Specifically, the maximum first component combination of complexity is determined from each Component composition；Obtain second component group
It closes, the similarity between the function that combine with first component of function of second component combination is greater than preset value, and second component
Complexity is less than the complexity of first component combination；First component combination is replaced with into second component combination；Recalculate software
Complexity, if the complexity of software is still greater than preset threshold, determined from each Component composition again complexity maximum
First component combination, and replace first component combination in the manner described above, until the complexity of software be less than or equal to it is pre-
If threshold value.
In embodiments of the present invention, the structure chart of software is also shown in the form of patterned, which includes in software
Each component and each activity that includes of each component.It further, can also be in the structure chart of the software of graphic software platform
In, mark complexity caused by each component and/or each activity in the process of implementation.
The embodiment of the present invention is carried out on the basis of componentbased development, and use form method is proposed towards complexity
The modeling language of degree, and the patterned representation method of the language is also provided, enable developer for software structure
More very clear, patterned representation method also may indicate that multiple caused by each component or activity in the process of implementation
Miscellaneous degree.The modeling language analyzes the syntagmatic between component, and these syntagmatics be divided into sequence, concurrent, selection and
Call relation.And specify these relationships on influence brought by the complexity of software.One also is devised for the modeling language simultaneously
Cover the operational semantics rule executed, the description software configuration that can be more clear.Operational semantics rule very rigorous can retouch
State out the situation of change of complexity in the process of implementation.
As shown in figure 3, the embodiment of the present invention proposes the modeling language towards complexity, and behaviour is devised for the modeling language
Make semantic rules, the calculating of software complexity is carried out based on the modeling language and operational semantics rule, is calculating complex software
Software configuration is optimized on the basis of degree.
The embodiment of the present invention can simulate the execution of component according to operational semantics rule, and record in the process
The complexity for all activities and generation that component executes, all letters that component can be executed by way of this record
Breath preserves, and according to the routing information that component executes, extracts complexity information all in implementation procedure, and you can get it should
The complexity of component or software configuration.The present invention can calculate different complexities according to the difference of path length, it can
The DYNAMIC COMPLEX degree for calculating component, can also calculate the average complexity of entire software configuration.In software for calculation complexity
On the basis of, by using algebraic method, the further evolution problem for studying software configuration, it is intended to can optimization software structure,
Reduce the complexity of the software configuration.
In embodiments of the present invention, it proposes the modeling language towards complexity, and devises operation language for the modeling language
Adopted rule, the description software configuration that can be more clear, operational semantics very rigorous can be depicted in the process of implementation
The situation of change of complexity.It can be in each stage metric software of software development based on the modeling language and operational semantics rule
The complexity of product, and the DYNAMIC COMPLEX degree of component can have not only been calculated, but also can mention with the average complexity of software for calculation structure
The accuracy that high software complexity calculates.On the basis of software for calculation complexity, by using algebraic method, further
Study software configuration evolution problem, it is intended to can optimization software structure, reduce the complexity of the software configuration.And it also provides
The patterned representation method of modeling language enables developer more very clear for the structure of software, patterned
Representation method also may indicate that complexity caused by each component or activity in the process of implementation.
It should be understood that
Algorithm and display be not inherently related to any certain computer, virtual bench or other equipment provided herein.
Various fexible units can also be used together with teachings based herein.As described above, it constructs required by this kind of device
Structure be obvious.In addition, the present invention is also not directed to any particular programming language.It should be understood that can use various
Programming language realizes summary of the invention described herein, and the description done above to language-specific is to disclose this hair
Bright preferred forms.
In the instructions provided here, numerous specific details are set forth.It is to be appreciated, however, that implementation of the invention
Example can be practiced without these specific details.In some instances, well known system, structure is not been shown in detail
And technology, so as not to obscure the understanding of this specification.
Similarly, it should be understood that in order to simplify the disclosure and help to understand one or more in each inventive aspect,
Above in the description of exemplary embodiment of the present invention, each feature of the invention is grouped together into single implementation sometimes
In example, figure or descriptions thereof.However, the system of the disclosure should not be construed to reflect an intention that i.e. required guarantor
Shield the present invention claims features more more than feature expressly recited in each claim.More precisely, as following
Claims reflect as, inventive aspect is all features less than single embodiment disclosed above.Therefore,
Thus the claims for following specific embodiment are expressly incorporated in the specific embodiment, wherein each claim itself
All as a separate embodiment of the present invention.
Those skilled in the art will understand that can be carried out adaptively to the step in the equipment in embodiment
Change and they are arranged in one or more devices different from this embodiment.It can be the step or step in embodiment
Rapid or component is combined into a step or step or component, and furthermore they can be divided into multiple steps or sub-step or sons
Component.Other than such feature and/or at least some of process or step exclude each other, any group can be used
It closes to all features disclosed in this specification (including adjoint claim, abstract and attached drawing) and so disclosed any
All processes or step of system or equipment are combined.Unless expressly stated otherwise, this specification is (including adjoint right
It is required that, abstract and attached drawing) disclosed in each feature can carry out generation with an alternative feature that provides the same, equivalent, or similar purpose
It replaces.
In addition, it will be appreciated by those of skill in the art that although some embodiments described herein include other embodiments
In included certain features rather than other feature, but the combination of the feature of different embodiments mean it is of the invention
Within the scope of and form different embodiments.For example, in the following claims, embodiment claimed is appointed
Meaning one of can in any combination mode come using.
Various component embodiments of the invention can be implemented in hardware, or to run on one or more processors
Software steps realize, or be implemented in a combination thereof.It will be understood by those of skill in the art that can be used in practice
One in the creating device of microprocessor or digital signal processor (DSP) to realize virtual machine according to an embodiment of the present invention
The some or all functions of a little or whole components.The present invention is also implemented as executing system as described herein
Some or all device or device programs (for example, computer program and computer program product).Such realization
Program of the invention can store on a computer-readable medium, or may be in the form of one or more signals.This
The signal of sample can be downloaded from an internet website to obtain, and is perhaps provided on the carrier signal or mentions in any other forms
For.
It should be noted that the above-mentioned embodiments illustrate rather than limit the invention, and ability
Field technique personnel can be designed alternative embodiment without departing from the scope of the appended claims.In the claims,
Any reference symbol between parentheses should not be configured to limitations on claims.Word "comprising" does not exclude the presence of not
Element or step listed in the claims.Word "a" or "an" located in front of the element does not exclude the presence of multiple such
Element.The present invention can be by means of including the hardware of several different elements and being come by means of properly programmed computer real
It is existing.If several in these devices can be through the same hardware branch in the step claim for listing equipment for drying
To embody.The use of word first, second, and third does not indicate any sequence.These words can be explained and be run after fame
Claim.
The foregoing is only a preferred embodiment of the present invention, but scope of protection of the present invention is not limited thereto,
In the technical scope disclosed by the present invention, any changes or substitutions that can be easily thought of by anyone skilled in the art,
It should be covered by the protection scope of the present invention.Therefore, protection scope of the present invention should be with the protection model of the claim
Subject to enclosing.
Claims (10)
1. a kind of software complexity calculation method characterized by comprising
Obtain each activity that the component in software includes；
The each activity for including according to the component executes each component in the software by operational semantics rule, obtains
The corresponding routing information of the execution route of the software；
According to the corresponding routing information of the execution route of the software, the complexity of the software is calculated.
2. the method according to claim 1, wherein the component each activity that includes obtained in software,
Include:
The corresponding component information of component for including by the modeling language abstraction towards complexity；
Identify that each activity that the component includes, the activity are made of binary group from the component information, the binary
Group includes the corresponding function of the activity and the complexity for executing the function generation.
3. the method according to claim 1, wherein each activity for including according to the component, passes through
Operational semantics rule executes each component in the software, obtains the corresponding routing information of execution route of the software, packet
It includes:
The Component composition relationship in the software between each component is determined by the modeling language towards complexity；
By the operational semantics rule, the software is run according to the executing rule of the Component composition relationship；
Record runs the corresponding routing information of each execution route in the software process, and the routing information includes execution route
Including each activity.
4. the method according to claim 1, wherein the corresponding path of the execution route according to the software
Information calculates the complexity of the software, comprising:
Calculate the sum of each movable complexity that the corresponding routing information of the execution route includes, using obtain and value as
The DYNAMIC COMPLEX degree of the software under the execution route.
5. the method according to claim 1, wherein the corresponding path of the execution route according to the software
Information calculates the complexity of the software, comprising:
The sum of each movable complexity that the corresponding routing information of each execution route includes is calculated separately, each execution is obtained
The corresponding Path complexity in path；
According to the corresponding Path complexity of each execution route, the average complexity of the software is calculated.
6. according to the method described in claim 5, it is characterized in that, described complicated according to the corresponding path of each execution route
Degree, calculates the average complexity of the software, comprising:
The sum of corresponding Path complexity of each execution route is calculated, between be calculated and value and the total number of execution route
Ratio, using the ratio as the average complexity of the software.
7. -6 any method according to claim 1, which is characterized in that the method also includes:
If the complexity of the software is greater than preset threshold, the complexity for each Component composition that the software includes is determined；
According to the complexity of each Component composition, the structure of the software is optimized, until the complexity of the software
Degree is less than or equal to the preset threshold.
8. the method according to the description of claim 7 is characterized in that the complexity according to each Component composition, right
The structure of the software optimizes, until the complexity of the software is less than or equal to the preset threshold, comprising:
The maximum first component combination of complexity is determined from each Component composition；
Second component combination is obtained, it is similar between the function that the function of the second component combination is combined with the first component
Degree is greater than preset value, and the complexity of the second component is less than the complexity of first component combination；
First component combination is replaced with into the second component combination；
The complexity of the software is recalculated, if the complexity of the software is still greater than the preset threshold, returns to execution
The operation that the maximum first component combination of complexity is determined from each Component composition, until the complexity of the software
Less than or equal to the preset threshold.
9. method according to claim 1-6, which is characterized in that the method also includes:
Show the structure chart of the software in the form of patterned, the structure chart includes each component in the software and every
Each activity that a component includes.
10. according to the method described in claim 9, it is characterized in that, the method also includes:
In the structure chart of the software of graphic software platform, each component and/or each activity institute in the process of implementation are marked
The complexity of generation.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910081440.7A CN109814924B (en) | 2019-01-28 | 2019-01-28 | A software complexity calculation method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910081440.7A CN109814924B (en) | 2019-01-28 | 2019-01-28 | A software complexity calculation method |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109814924A true CN109814924A (en) | 2019-05-28 |
| CN109814924B CN109814924B (en) | 2020-10-02 |
Family
ID=66605574
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910081440.7A Active CN109814924B (en) | 2019-01-28 | 2019-01-28 | A software complexity calculation method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109814924B (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110688152A (en) * | 2019-09-27 | 2020-01-14 | 厦门大学 | Software reliability quantitative evaluation method combining software development quality information |
| CN110825350A (en) * | 2019-09-16 | 2020-02-21 | 北京银企融合技术开发有限公司 | Method and system for changing functional requirements of software products |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105468521A (en) * | 2015-11-18 | 2016-04-06 | 北京航空航天大学 | Pointer related semantic error location method based on subgraph search |
| CN107391124A (en) * | 2017-06-30 | 2017-11-24 | 东南大学 | A kind of condition dicing method based on golden section search and software perform track |
| US20180189487A1 (en) * | 2014-08-07 | 2018-07-05 | Ut Battelle, Llc | Behavior specification, finding main, and call graph visualizations |
| CN108509336A (en) * | 2018-03-05 | 2018-09-07 | 华东师范大学 | A kind of operating system canonical form chemical examination card and test method |
-
2019
- 2019-01-28 CN CN201910081440.7A patent/CN109814924B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20180189487A1 (en) * | 2014-08-07 | 2018-07-05 | Ut Battelle, Llc | Behavior specification, finding main, and call graph visualizations |
| CN105468521A (en) * | 2015-11-18 | 2016-04-06 | 北京航空航天大学 | Pointer related semantic error location method based on subgraph search |
| CN107391124A (en) * | 2017-06-30 | 2017-11-24 | 东南大学 | A kind of condition dicing method based on golden section search and software perform track |
| CN108509336A (en) * | 2018-03-05 | 2018-09-07 | 华东师范大学 | A kind of operating system canonical form chemical examination card and test method |
Non-Patent Citations (2)
| Title |
|---|
| 俞磊: "基于UML活动图的仿真与测试方法研究", 《中国优秀硕士学位论文全文数据库_信息科技辑》 * |
| 黄珍锡: "仿生软件体系结构及其复杂度研究", 《中国优秀硕士学位论文全文数据库_信息科技辑》 * |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110825350A (en) * | 2019-09-16 | 2020-02-21 | 北京银企融合技术开发有限公司 | Method and system for changing functional requirements of software products |
| CN110688152A (en) * | 2019-09-27 | 2020-01-14 | 厦门大学 | Software reliability quantitative evaluation method combining software development quality information |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109814924B (en) | 2020-10-02 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Masuhara et al. | Modeling crosscutting in aspect-oriented mechanisms | |
| CN104636256B (en) | A kind of abnormal detection method and device of internal storage access | |
| US9207935B2 (en) | Early analysis of software design diagrams | |
| US20210081841A1 (en) | Visually creating and monitoring machine learning models | |
| CN106326107B (en) | A Non-Intrusive Embedded Software Exception Handling Verification Method Based on Simulation Environment | |
| US20080320457A1 (en) | Intermediate Code Metrics | |
| KR100921514B1 (en) | A Software Development Apparatus for Providing Performance Prediction and A method thereof | |
| US20130332908A1 (en) | Serial Debugging Experience for Parallel Programs | |
| CN114365095A (en) | System and method for evaluating code contribution of software developer | |
| Wang et al. | Accurate source-level simulation of embedded software with respect to compiler optimizations | |
| CN108228187B (en) | Global optimization method of numerical program | |
| Butgereit | Using machine learning to prioritize automated testing in an agile environment | |
| CN109814924A (en) | A software complexity calculation method | |
| Sarkar et al. | LightningSim: Fast and accurate trace-based simulation for High-Level Synthesis | |
| Wägemann et al. | GenE: A benchmark generator for WCET analysis | |
| KR101503620B1 (en) | Intelligent architecture creator | |
| Kumar | Estimation of an early wcet using different machine learning approaches | |
| Salman et al. | Automatic test case generation from UML state chart diagram: a survey | |
| CN109815148A (en) | A software complexity calculation system | |
| da Silva et al. | On-the-fly verification of discrete event simulations by means of simulation purposes. | |
| Joy et al. | Automated source code annotation for timing analysis of embedded software | |
| Fontes et al. | Automated support for unit test generation | |
| JP2004220269A (en) | Integrated test management system | |
| Greiner et al. | Maturity Evaluation of Domain-Specific Language Ecosystems for Cyber-Physical Production Systems | |
| Marsso et al. | Asynchronous testing of synchronous components in GALS systems |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |