Self-Healing Protocol Implementations

Current studies on self-configuring and adaptive networks aim at developing specific and fixed protocols which are able to optimize their configuration in a variable network environment. In this talk we study the problem where the protocols need to cope with a defective execution, including the lossy execution or the injection of foreign code. One guiding question will be the creation of robust execution circuits which can distribute over a network and which continue their service despite parts of the implementation being knocked out. The ultimate goal is to enable protocol implementations to detect by themselves that they are malfunctioning and to let them correct their own operation mode and code base. As a show case, we present a protocol implementation which is robust against deletion (knock-out) of any single instruction, regardless whether this deletion affects the core protocol functionality or the resilience logic. The technique used in this first of its kind example is the self-modification of the running program, which can be naturally situated in an active networking context. Ultimately, a self-correcting protocol implementation has to constantly rewrite itself according to the (self-)observed performance. In this talk we will also point to related fields like self-correcting software, fault tolerant quantum computing and self-healing properties of biological systems. This is joint work with Lidia Yamamoto, Hitachi Europe

Self–Healing Protocol Implementations Extended Abstract

In this talk we consider an extended failure model for communication software: Instead of having to handle only external failures like lost or corrupted data packets, invalid routes and crashing nodes, we request the software to also handle internal errors. Internal errors can be the unfaithful execution of some instructions or the partial loss of the code base. We then ask whether software is able to detect such internal errors (self-monitoring), is able to continue operation despite such errors (resilience) and is able to correct such errors (self-healing). As a first step towards a better understanding of this problem, we restrict our attention to a simple “knock-out ” criteria: The challenge is to demonstrate a program that continues correct execution despite removal of an arbitrary instructions. Having such resilient protocol implementations would permit to distribute the corresponding execution circuits over a network without having to worry about unreliable execution platforms in the same way as we expect current protocols to handle unreliable communication channels. Reasons to “harden ” Communication Software Resilience and self-healing ability are essential properties of a truly self-organizing network, where functional and coherent protocol structures must emerge out of basic protocol submodules. A resilient network must be able to detect and replace misbehaving software at run time, while continuin