“Software aging”的意思、由来-开放百科全书

In software engineering, software aging refers to all software's tendency to fail, or cause a system failure after running continuously for a certain time. As the software gets older it becomes less immune and will eventually stop functioning as it should, therefore rebooting or reinstalling the software can be seen as a short term fix.^[1] A proactive fault management method to deal with the software aging incident is software rejuvenation. This method can be classified as an environment diversity technique that usually is implemented through software rejuvenation agents (SRA).

From both an academic and industrial point of view, the software aging phenomenon has increased. The main focus has been to understand its effects from a verifiable observation and theoretical understanding.^[2]

Memory bloating and leaking, along with data corruption and unreleased file-locks are particular causes of software aging.

Proactive management of software aging

Software aging

Software failures are a more likely cause of unplanned systems outages compared to hardware failures.^[4]^[5] This is because software exhibits over time an increasing failure rate due to data corruption, numerical error accumulation and unlimited resource consumption. In widely used and specialized software, a common action to clear a problem is rebooting because aging occurs due to the complexity of software which is never free of errors. It is almost impossible to fully verify that a piece of software is bug-free. Even high-profile software such as Windows and macOS must receive continual updates to improve performance and fix bugs. Software development tends to be driven by the need to meet release deadlines rather than to ensure long-term reliability.^[6] Designing software that can be immune to aging is difficult. Not all software will age at the same rate as some users use the system more intensively than others.^[7]

Rejuvenation

To prevent crashes or degradation software rejuvenation can be employed proactively as inevitable aging leads to failures in software systems. This proactive technique was identified as a cost-effective solution during research at the AT&T Bell Laboratories on fault-tolerant software in the 1990s.^[8] Software rejuvenation works by removing accumulated error conditions and freeing up system resources, for example by flushing operating system kernel tables, using garbage collection, reinitializing internal data structures, and perhaps the most well known rejuvenation method is to reboot the system.

There are simple techniques and complex techniques to achieve rejuvenation. The method most individuals are familiar with is the hardware or software reboot. A more technical example would be the web server software Apache's rejuvenation method. Apache implements one form of rejuvenation by killing and recreating processes after serving a certain number of requests.^[9]

Another technique is to restart virtual machines running in a cloud computing environment.^[10]

The multinational telecommunications corporation AT&T has implemented software rejuvenation in the real time system collecting billing data in the United States for most telephone exchanges.^[11]

The IEEE International Symposium on Software Reliability Engineering (ISSRE) hosted the 5th annual International Workshop on Software Aging and Rejuvenation ([https://sites.google.com/site/wosar2013/home woSAR]) in 2013. Topics included:

Memory leaks

In systems that use an OS user programs have to request memory blocks in order to perform an operation. After this operation (e.g. a subroutine) is completed, the program is expected to free up all the memory blocks allocated for it in order to make it available to other programs for use. In programming languages without a garbage collector (e.g. C and C++) it's up to the programmer to call the necessary memory releasing functions and to account for all the unused data within the program. However this doesn't always happen. Due to software bugs the program might consume more and more memory eventually causing the system to run out of memory.^[13] In low memory conditions, the system usually functions slower due to the performance bottleneck caused by intense swapping (thrashing), applications become unresponsive and those that request large amounts of memory unexpectedly may crash. In case the system runs out of both memory and swap even the OS might crash causing the whole system to reboot.^[14]

Programs written in programming languages that use a garbage collector (e.g. Java) usually rely on this feature for avoiding memory leaks. Thus the "aging" of these programs is at least partially dependent on the quality of the garbage collector built into the programming language's runtime environment itself.

Sometimes critical components of the OS itself can be a source of memory leaks and be the main culprit behind system stability issues. In Microsoft Windows, for example, the memory use of Windows Explorer plug-ins and long-lived processes such as services can impact the reliability of the system to the point of making it unusable. A reboot might be needed to make the system work again.^[15]

Software rejuvenation helps with memory leaks as it forces all the memory used by an application to be released. The application can be restarted but starts with a clean slate.

Implementation

Memory bloating

Garbage collection is a form of automatic memory management whereby the system automatically recovers unused memory. For example, the .NET Framework manages the allocation and release of memory for software running under it. But automatically tracking these objects takes time and is not perfect.

.NET based web services manage several logical types of memory such as stack, unmanaged and managed heap (free space). As the physical memory gets full, the OS writes rarely-used parts of it to disk, so that it can reallocate it to another application, a process known as paging or swapping. But if the memory does need to be used, it must be reloaded from disk. If several applications are all making large demands, the OS can spend much of its time merely moving data between main memory and disk, a process known as disk thrashing.^[16] Since the garbage collector has to examine all of the allocations to decide which are in use, it may exacerbate this thrashing. As a result, extensive swapping can lead to garbage collection cycles extended from milliseconds to tens of seconds. This results in usability problems.

References

1. ^{{Cite book|title = Software Aging and Multifractality of Memory Resources|url = http://www.computer.org/csdl/proceedings/dsn/2003/1952/00/19520721-abs.html|publisher = IEEE Computer Society|journal = 2014 44th Annual IEEE/IFIP International Conference on Dependable Systems and Networks|date = 2003-01-01|location = Los Alamitos, CA, USA|isbn = 978-0-7695-1952-4|pages = 721|volume = 0|doi = 10.1109/DSN.2003.1209987|first = Mark|last = Shereshevsky|first2 = Jonathan|last2 = Crowell|first3 = Bojan|last3 = Cukic|first4 = Vijai|last4 = Gandikota|first5 = Yan|last5 = Liu}}
2. ^{{Cite book|title = The fundamentals of software aging|journal = IEEE International Conference on Software Reliability Engineering Workshops, 2008. ISSRE Wksp 2008|date = 2008-11-01|pages = 1–6|doi = 10.1109/ISSREW.2008.5355512|first = M.|last = Grottke|first2 = R.|last2 = Matias|first3 = K.S.|last3 = Trivedi|isbn = 978-1-4244-3416-9}}
3. ^{{Cite book|title = Software aging|url = http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=296790|journal = 16th International Conference on Software Engineering, 1994. Proceedings. ICSE-16|date = 1994-05-01|pages = 279–287|doi = 10.1109/ICSE.1994.296790|first = D.L.|last = Parnas|isbn = 978-0-8186-5855-6}}
4. ^{{Cite web | url=https://oatd.org/oatd/record?record=oai%5C%3Awvuscholar.wvu.edu%5C%3A21029 | title=Oatd: -}}
5. ^{{Cite book|title = A methodology for detection and estimation of software aging|journal = The Ninth International Symposium on Software Reliability Engineering, 1998. Proceedings|date = 1998-11-01|pages = 283–292|doi = 10.1109/ISSRE.1998.730892|first = S.|last = Garg|first2 = A.|last2 = van Moorsel|first3 = K.|last3 = Vaidyanathan|first4 = K.S.|last4 = Trivedi|isbn = 978-0-8186-8991-8}}
6. ^{{Cite journal|title = Proactive management of software aging|journal = IBM Journal of Research and Development|date = 2001-03-01|issn = 0018-8646|pages = 311–332|volume = 45|issue = 2|doi = 10.1147/rd.452.0311|first = V.|last = Castelli|first2 = R.E.|last2 = Harper|first3 = P.|last3 = Heidelberger|first4 = S.W.|last4 = Hunter|first5 = K.S.|last5 = Trivedi|first6 = K.|last6 = Vaidyanathan|first7 = W.P.|last7 = Zeggert|citeseerx = 10.1.1.28.7273}}
7. ^{{Cite book|title = Proactive detection of software aging mechanisms in performance critical computers|journal = 27th Annual NASA Goddard/IEEE Software Engineering Workshop, 2002. Proceedings|date = 2002-12-01|pages = 17–23|doi = 10.1109/SEW.2002.1199445|first = K.C.|last = Gross|first2 = V.|last2 = Bhardwaj|first3 = R.|last3 = Bickford|isbn = 978-0-7695-1855-8}}
8. ^Cotroneo, D., Natella, R., Pietrantuono, R., and Russo, S. 2014. A survey of software aging and rejuvenation studies. ACM J. Emerg. Technol. Comput. Syst. 10, 1, Article 8 (January 2014), 34 pages.
9. ^Trivedi, K. S. and Vaidyanathan, K. 2007. Software Aging and Rejuvenation. Wiley Encyclopedia of Computer Science and Engineering.
10. ^{{Cite journal | doi=10.1109/TC.2013.30|title = Workload-Based Software Rejuvenation in Cloud Systems| journal=IEEE Transactions on Computers| volume=62| issue=6| pages=1072–1085|year = 2013|last1 = Bruneo|first1 = Dario| last2=Distefano| first2=Salvatore| last3=Longo| first3=Francesco| last4=Puliafito| first4=Antonio| last5=Scarpa| first5=Marco}}
11. ^{{Cite book|title = Software Rejuvenation - Modeling and Analysis|publisher = Springer US|date = 2004-01-01|isbn = 978-1-4020-8158-3|pages = 151–182|series = IFIP International Federation for Information Processing|doi = 10.1007/1-4020-8159-6_6|first = Kishor S.|last = Trivedi|first2 = Kalyanaraman|last2 = Vaidyanathan|editor-first = Ricardo|editor-last = Reis}}
12. ^{{Cite book|title = An approach for estimation of software aging in a Web server|journal = Empirical Software Engineering, 2002. Proceedings. 2002 International Symposium N|date = 2002-01-01|pages = 91–100|doi = 10.1109/ISESE.2002.1166929|first = Lei|last = Li|first2 = K.|last2 = Vaidyanathan|first3 = K.S.|last3 = Trivedi|isbn = 978-0-7695-1796-4}}
13. ^{{Cite web|title = Overview of Memory Leaks|url = https://msdn.microsoft.com/en-us/library/ms859408.aspx|website = msdn.microsoft.com|accessdate = 2015-11-04}}
14. ^{{cite web|url=https://www.ibm.com/developerworks/aix/library/au-aix7memoryoptimize3/index.html|title=Optimizing AIX 7 memory performance Part 3, Tuning swap space settings|authors=Martin Brown and Ken Milberg|date={{date|2010-11-16}}}}
15. ^{{Cite web|title = Preventing Memory Leaks in Windows Applications (Windows)|url = https://msdn.microsoft.com/en-us/library/windows/desktop/dd744766(v=vs.85).aspx|website = msdn.microsoft.com|accessdate = 2015-11-04}}
16. ^{{Cite journal|title = Software Rejuvenation in Web Services|url = http://research.ijcaonline.org/volume54/number8/pxc3882340.pdf|journal = International Journal of Computer Applications|pages = 31–35|volume = 54|issue = 8|doi = 10.5120/8589-2340|first = Chaitra|last = S.R.|first2 = Anirban|last2 = Basu|year = 2012}}