Mikolasek, Vaclav

Zolda, Michael

English

University of Hertfordshire Research Archive

Towards Distributed Robustness in Embedded SystemsVa´clav Mikola´sˇek and Michael ZoldaInstitute of Computer EngineeringVienna University of TechnologyVienna, Austria{mikolasek,michaelz}@vmars.tuwien.ac.at1. Degeneracy, Robustness, and ComplexityRecently, we witness a significant amount of effort be-ing put into a research of robustness of complex computersystems. Computer scientists noticed that, despite decadesof investigations into dependability, computer systemsstill lack the degree of resilience which can be seen inbiological systems. In the biological context, one of themain aspects that stand behind a system’s robustness isdegeneracy [1] also known as distributed robustness [2].We say that a system has a high degree of degener-acy if a high number of the system’s parts functionallyoverlap. A system designer can harness degeneracy andprovide fault-tolerance through procedural (in contrast tostructural) redundancy. A system element is structurallyredundant if another element in the system provides iden-tical functionality. However, an element is procedurallyredundant if various system parts can interact in sucha way that it is possible to reproduce the element’sfunctionality.For illustration, consider a hypothetical calculator whichwas designed for degeneracy. Such a calculator does nothave a central CPU, but its functionality is rather dis-tributed among number of function blocks which providebasic arithmetic operations (plus, minus, multiplication,and division). If one of the function blocks is affected bya permanent error, there is no other functionally identicalelement which could take over the lost function. Yet, theblocks functionally overlap. If, for example, the multipli-cation operator failed, the calculator could transform anymultiplication into a sequence of additions and use the plusoperator. If the plus operator failed, the minus operator canbe used in a similar fashion.Dependable computer system of today are still clumsily“inorganic”, with a nonexistent or very low degree ofadaptability. Procedural redundancy due to degeneracy isa promising way to achieve highly robust and adaptablesystems. But designing for degeneracy, and that is wherewe want to make our point, requires a paradigm shift inthe way computing is done. We argue for a novel modelof computation which enables a design for degeneracy.2. HierarchiesAlongside degeneracy, hierarchical structure, too, isessential for robustness – both in biological and artificialsystems. System components on all levels of a hierarchyexhibit the same pattern: intra-component interactions arestrong and frequent whereas the inter-component ones arerelatively weak and sporadic. This pattern is responsiblefor near-decomposability of a system and this in turnprovides for adaptability. A system component at a certainlevel of hierarchy can be replaced by another component atthe same level (structural redundancy) or recreated throughinteractions of other components (procedural redundancydue to degeneracy).With embedded systems – which lay at the borderlineof hardware and software – we face a particular situation.There are two separate, unrelated hierarchies: hardwareand software. Indeed, any software abstraction dissolvesthe moment a program is compiled into a machine codeand executed, one instruction after another. The hard-ware layer is an execution platform for software and asoftware hierarchy is in no sense a continuation of thehardware hierarchy: software components are expressed inprogramming languages which do not reflect the structureof hardware.The reason why current embedded systems do notexhibit degeneracy and do not make use of proceduralredundancy is exactly the separation of the two hierarchies.Besides structural redundancy, present systems do notprovide any other way to recover, for example, a failed PIDcontroller. Indeed, it is because the PID controller is notexpressed in terms of lower-level component interactionsand therefore the system cannot make use of a proceduralredundancy as in the calculator example. Even if thePID controller was expressed in terms of componentinteractions (and note that due to its simplicity, the lower-level components would need to be in fact basic arithmeticoperations or similarly simple functions) it would not beof any help as long as the system itself is not able toseparately invoke other lower-level components in a newcontext and thus recreate the PID functionality.Edelman and Gally [1] pointed out that degeneracycan be observed only in sufficiently complex systems. Inorder to achieve a high degree of degeneracy in embeddedsystems, we need to change the way computation is done –we need to connect the software and hardware hierarchies.3. A Design for DegeneracyIn order to create a computer system with a high degreeof degeneracy (so that we can take advantage of proceduralredundancy) we must meet the following requirements:1) Each non-atomic component is expressed as a com-bination of lower-level components from a commoncomponent set.2) Atomic components form fault-containment unitsand3) they are also the basic building blocks of a program-ming language used to implement the system.4) The system is built in a bottom-up fashion.5) A good degree of a functional overlap is preservedon all levels of the system hierarchy.6) The system has a sufficient degree of complexity.The first requirement ensures that a system has a hier-archical structure and particular system elements belongto a common component set, that is, they can be invokedindependently in different contexts. Recovery, diagnosis,and procedural redundancy would be very difficult toachieve, if the system design did not meet the second pointrequiring a physical separation of atomic components.The argument behind the point 3 is that in a strictlyhierarchical design, a programmer expresses each systempart as a combination of lower-level system parts and aprogramming language must capture this feature by mak-ing the system’s atomic components its own basic buildingblocks. Top-down design leads to a creation of specificpurpose components which cannot be easily reused indifferent contexts, in contrast, a bottom-up design leads toa set of general purpose components which are repeatedlyused across the whole system. Although the bottom-upapproach is a help, only if a designer chooses the setsof components on different levels of the system hierarchycarefully, the resulting system will obtain a high degreeof degeneracy; this requirement is captured by the point5. Although the sixth requirement is probably the leastspecific one, it has a great importance. Even with anintuitive understanding of complexity, we can see that acomponent can be made procedurally redundant only ifthe system provides a number of functionally overlappingparts. Such complexity is lacking, for example, in a simplecontrol system containing a few sensors, actuators, and acontroller. However, in the next section, we shall showthat by connecting the hardware and software hierarchies,even this simple system can make use of degeneracy.4. Dense-network-based ComputationAlthough current software engineering practice favorsa top-down system design, large-scale distributed systemsof today (e.g., those seen on the Internet) can showdegeneracy and make use of procedural redundancy. Thecomplexity of such systems is arguably sufficient, com-puter nodes (i.e., servers) form fault-containment units,and there is no reason why the rest of the six requirementsfrom Section 3 could not be met. However, in embeddedsystems we once again face a particular situation:• either a computer node (or an IP core) is seen asan atomic, fault-containment unit thus meeting thesecond requirement, but failing to meet the firstand fourth because the computer nodes implementapplication specific and high-level components suchas a controller, actuator, etc.,• or the high-level components are expressed in termsof lower-level components interactions, but then thelater ones do not form fault-containment units due tothe separation of hardware and software hierarchies.For these reasons, we argue for a new computationalparadigm based on computation via dense-networks [3]and present our vision of a dense-network processor(DNP).A DNP moves away from the current instruction ex-ecution paradigm towards a network-based computing.The core of the processor comprises thousands of atomic,simple, and highly interconnected computational nodes. Aprogram for such a processor expresses its functionalitystrictly in terms of creating connections and addressingamong the atomic components. An operational memory isreplaced by a component repository where the descriptionof components is stored along with the component’s state.A controller/scheduler oversees the processor’s operationand authorizes components instantiations, serialization,addressing, and so forth. A DNP merges software andhardware hierarchies (each software component can bedirectly mapped to a dynamic hardware structure) andmakes a design for degeneracy and procedural redundancypossible. With DNPs, we can meet all the six requirementsfrom Section 3 and achieve a high degree of degeneracyeven in embedded systems. On a system level, projectssuch as GENESYS [4] could provide the needed hierar-chical continuation to the low-level degeneracy establishedby DNPs.We believe that investigations of procedural redundancyvia dense-network-based computing yields a very promis-ing research program with a vast potential. With new nano-scale technologies emerging, a DNP need not remain onlya vision.AcknowledgementOur thanks go to Hermann Kopetz and Sven Bu¨nte forthe important discussions we had. This work was in partsupported by an Austrian FIT-IT project CLIC no.819482.References[1] G. M. Edelman and J. A. Gally, “Degeneracy and complex-ity in biological systems,” in Proceedings of the NationalAcademy of Sciences of the United States, 2001.[2] A. Wagner, “Distributed robustness versus redundancy ascauses of mutational robustness,” Bioessays, vol. 27, no. 2,pp. 176–188, Feb 2005.[3] N. Shanbhag, S. Mitra, G. de Veciana, M. Orshansky,R. Marculescu, J. Roychowdhury, D. Jones, and J. Rabaey,“The search for alternative computational paradigms,” De-sign & Test of Computers, IEEE, vol. 25, no. 4, pp. 334–343,July-Aug. 2008.[4] R. Obermaisser, C. El Salloum, B. Huber, and H. Kopetz,“Fundamental design principles for embedded systems:The architectural style of the cross-domain architectureGENESYS,” in Proceedings of ISORC conference, 2009.

Towards Distributed Robustness in Embedded Systems

Abstract

Similar works

Full text

Available Versions

University of Hertfordshire Research Archive