Current software cost estimation models, such as the 1981 Constructive Cost Model (COCOMO) for software cost estimation and its 1987 Ada COCOMO update, have been experiencing increasing difficulties in estimating the costs of software developed to new life cycle processes and capabilities. These include non-sequential and rapid-development process models; reuse-driven approaches involving commercial off-the*shelf (COTS) packages, re-engineering, applications composition, and applications generation capabilities; object-oriented approaches supported by distributed middleware; and software process maturity initiatives. This paper summarizes research in deriving a baseline COCOMO 2.0 model tailored to these new forms of software development, including rationale for the model decisions. The major new modeling capabilities of COCOMO 2.0 are a tailorable family of software sizing models, involving Object Points, Function Points, and Source Lines of Code; nonlinear models for software reuse and re-engineering; an exponentdriver approach for modeling relative software diseconomies of scale; and several additions, deletions and updates to previous COCOMO effort-multiplier cost drivers. This model is serving as a framework for an extensive current data collection and analysis effort to further refine and calibrate the model's estimation capabilities.
Given r numbers s 1 , …, s r , algorithms are investigated for finding all possible combinations of these numbers which sum to M . This problem is a particular instance of the 0-1 unidimensional knapsack problem. All of the usual algorithms for this problem are investigated in terms of both asymptotic computing times and storage requirements, as well as average computing times. We develop a technique which improves all of the dynamic programming methods by a square root factor. Empirical studies indicate this new algorithm to be generally superior to all previously known algorithms. We then show how this improvement can be incorporated into the more general 0-1 knapsack problem obtaining a square root improvement in the asymptotic behavior. A new branch and search algorithm that is significantly faster than the Greenberg and Hegerich algorithm is also presented. The results of extensive empirical studies comparing these knapsack algorithms are given
Exact and approximate algorithms are presented for scheduling independent tasks in a multiprocessor environment in which the processors have different speeds. Dynamic programming type algorithms are presented which minimize finish time and weighted mean flow time on two processors. The generalization to m processors is direct. These algorithms have a worst-case complexity which is exponential in the number of tasks. Therefore approximation algorithms of low polynomial complexity are also obtained for the above problems. These algomthms are guaranteed to obtain solutions that are close to the optimal. For the case of minimizing mean flow time on m-processors an algorithm is given whose complexity is 0(n log ran).KEY WORDS AND PHRASES: scheduling independent tasks, uniform processors, unrelated processors, finish time, mean flow time, weighted mean flow time, exact algorithms, approximate algorithm, complexity CR CATEGORIES: 4.32, 5.39
] ntroductionWe are concerned here with scheduling n >_ 1 independent tasks Tl, ..-, T, on nn >_ 1 processors P~, • • • , P~. Thus we assume there are no precedence constraints on the tasks and also that all schedules must be nonpreemptive. The execution time of task % on processor P, will be denoted by t, yielding an m X n matrix of processing times. Each t, is assumed to be a positive rational number and without loss of generality tie, 1 < j _~ n is normalized to a positive integer.Formally a schedule S for m processors is a partition of the set of task indices, { 1, 2, • • • , n I into m disjoint, ordered sets R1, • • • , R,~ such that (i) R, = {r,l,r~2, "." , r,~,}, j, > 0, (ii) U~<,_
A major problem in requirements engineering is obtaining requirements that address the concerns of multiplestakeholders. An approach to such a problem is the Theory-W based Spiral Model. This paper focuses on the problem of developing a support system for such a model. In particular it identifies needs and capabilities required to ad(iress the problem of negotiation and renegotiation that arises when the model is applied to incremental reqliiretnents engineering. The paper fortnulutes elements qf dle support system, called Win Win, for providing such capabilities. The key elenwnts of Win Win are described and their use in incremental requirements engineering are demonstrated, using an emmple renegotiation scenariofrom the liotnain of software engineering environments ,for satellite ground stations.
scite is a Brooklyn-based organization that helps researchers better discover and understand research articles through Smart Citations–citations that display the context of the citation and describe whether the article provides supporting or contrasting evidence. scite is used by students and researchers from around the world and is funded in part by the National Science Foundation and the National Institute on Drug Abuse of the National Institutes of Health.
hi@scite.ai
10624 S. Eastern Ave., Ste. A-614
Henderson, NV 89052, USA
Copyright © 2024 scite LLC. All rights reserved.
Made with 💙 for researchers
Part of the Research Solutions Family.