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]

"Programs, like people, get old. We can't prevent aging, but we can understand its causes, take steps to limit its effects, temporarily reverse some of the damage it has caused, and prepare for the day when the software is no longer viable."[3]

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] 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 Mac OSX 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.[5] 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.[6]

Software rejuvenation

To prevent crashes or degradation a software rejuvenation can be employed proactively as inevitably aging leads to failures in software systems. This happens by removing the accumulated error condition and freeing up system resources, some examples to clean the internal state of the software are to flush operating system kernel tables, garbage collection, reinitialize internal data structures and a well known example of rejuvenation is a system reboot.

Multinational telecommunications corporation, AT&T have implemented software rejuvenation in the real time system collecting billing data in the United States for most telephone exchanges.[7]

Different systems have also implemented the software rejuvenation method which are:[8]

  1. Transaction processing systems
  2. Web servers
  3. Spacecraft systems

Memory leaks

A program can request temporary memory from the system when it is required to store information during execution. However, the system has a limited amount of memory in total and therefore if one application is using a large amount of free memory then other applications won't be able to obtain the memory they require. In low memory conditions the system usually functions slower however, applications become unresponsive and ones which regularly request large amount of memory unexpectedly crash. The responsibility to "free" dynamically requested memory lies with the application when they have finished using it and therefore available for another application when needed. Memory leak happens when the application has dynamically allocated memory but not freed the memory when finished using it. This then doesn't allow the system or any other application to use the memory which hasn't been re-allocated causing the system to eventually run out of memory as memory leaks add up over time.[9] In Windows, explorer plug-ins and long running processes like services can impact the reliability of the operating system and in some cases make the system unusable. This would require a reboot to put it back to a functioning state.[10]

Software rejuvenation helps with memory leaks as it involves terminating an application and thus a clean internal state is the outcome of an immediate restart. The two methods for implementing rejuvenation are:

  1. Time based rejuvenation
  2. Prediction based rejuvenation

Memory bloating

Memory bloating occurs due to garbage collection, which is the form of automatic memory management. For example, the .NET Framework manages the allocation and release of memory for software running on a modern OS such as Windows. .Net based web services has several types of memory such as stack, unmanaged and managed heap (free space). An example is when an operating system occurs a problem because it ran out of physical memory and the OS starts swapping unmanaged heap.[11] The common language runtime allocates memory from the managed heap every time a new object is created, thus will continue to allocate space for new objects. On the other hand, the garbage collection must carry out a collection of data to free up some memory as memory is not infinite. As allocations are being made, the garbage collection that has an optimized engine performs a collection for objects in the managed heap as they are no longer being used by the application, therefore reclaiming their memory.[12] As a result, OS which extensively swap heap can lead to garbage collection cycles extended from milliseconds to tens of seconds. This results to usability problems with applications with loaded caches due to memory bloating.

References

  1. ↑ Shereshevsky, Mark; Crowell, Jonathan; Cukic, Bojan; Gandikota, Vijai; Liu, Yan (2003-01-01). "Software Aging and Multifractality of Memory Resources". 2014 44th Annual IEEE/IFIP International Conference on Dependable Systems and Networks. Los Alamitos, CA, USA: IEEE Computer Society. 0: 721. doi:10.1109/DSN.2003.1209987. ISBN 0-7695-1952-0.
  2. ↑ Grottke, M.; Matias, R.; Trivedi, K.S. (2008-11-01). "The fundamentals of software aging". IEEE International Conference on Software Reliability Engineering Workshops, 2008. ISSRE Wksp 2008: 1–6. doi:10.1109/ISSREW.2008.5355512.
  3. ↑ Parnas, D.L. (1994-05-01). "Software aging". 16th International Conference on Software Engineering, 1994. Proceedings. ICSE-16: 279–287. doi:10.1109/ICSE.1994.296790.
  4. ↑ Garg, S.; van Moorsel, A.; Vaidyanathan, K.; Trivedi, K.S. (1998-11-01). "A methodology for detection and estimation of software aging". The Ninth International Symposium on Software Reliability Engineering, 1998. Proceedings: 283–292. doi:10.1109/ISSRE.1998.730892.
  5. ↑ Castelli, V.; Harper, R.E.; Heidelberger, P.; Hunter, S.W.; Trivedi, K.S.; Vaidyanathan, K.; Zeggert, W.P. (2001-03-01). "Proactive management of software aging". IBM Journal of Research and Development. 45 (2): 311–332. doi:10.1147/rd.452.0311. ISSN 0018-8646.
  6. ↑ Gross, K.C.; Bhardwaj, V.; Bickford, R. (2002-12-01). "Proactive detection of software aging mechanisms in performance critical computers". 27th Annual NASA Goddard/IEEE Software Engineering Workshop, 2002. Proceedings: 17–23. doi:10.1109/SEW.2002.1199445.
  7. ↑ Trivedi, Kishor S.; Vaidyanathan, Kalyanaraman (2004-01-01). Reis, Ricardo, ed. Software Rejuvenation - Modeling and Analysis. IFIP International Federation for Information Processing. Springer US. pp. 151–182. doi:10.1007/1-4020-8159-6_6. ISBN 978-1-4020-8158-3.
  8. ↑ Li, Lei; Vaidyanathan, K.; Trivedi, K.S. (2002-01-01). "An approach for estimation of software aging in a Web server". Empirical Software Engineering, 2002. Proceedings. 2002 International Symposium n: 91–100. doi:10.1109/ISESE.2002.1166929.
  9. ↑ "Overview of Memory Leaks". msdn.microsoft.com. Retrieved 2015-11-04.
  10. ↑ "Preventing Memory Leaks in Windows Applications (Windows)". msdn.microsoft.com. Retrieved 2015-11-04.
  11. ↑ S.R., Chaitra; Basu, Anirban. "Software Rejuvenation in Web Services" (PDF). International Journal of Computer Applications. 54 (8): 31–35. doi:10.5120/8589-2340.
  12. ↑ "Garbage Collection". msdn.microsoft.com. Retrieved 2015-11-04.

Further reading

  • R. Matias Jr. and P. J. Freitas Filho, "An experimental study on software aging and rejuvenation in web servers," Proceedings of the 30th Annual International Computer Software and Applications Conference (COMPSAC'06), Vol. 01, pp. 189 – 196, 2006.
  • M. Grottke, R. Matias Jr., and K. S. Trivedi, "The Fundamentals of Software Aging," Workshop of Software Aging and Rejuvenation (WoSAR/ISSRE), 2008.
  • R. Matias Jr, P. Barbetta, K. Trivedi, P. Freitas Filho "Accelerated Degradation Tests Applied to Software Aging Experiments," IEEE Transactions on Reliability 59(1): 102-114,2010.
  • M. Grottke, L. Li, K. Vaidyanathan, and K.S. Trivedi, "Analysis of software aging in a web server," IEEE Transactions on Reliability, vol. 55, no. 3, pp. 411–420, 2006.
  • M. Grottke, K. Trivedi, "Fighting Bugs: Remove, Retry, Replicate, and Rejuvenate," IEEE Computer 40(2): 107-109, 2007.
  • More papers on Proceedings of Workshop of Software Aging and Rejuvenation (WoSAR'08,'10, '11, '12, '13, '14) at IEEE Xplore.
This article is issued from Wikipedia - version of the 9/8/2016. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.