This paper presents a layered hierarchical switching-software technology, which is based on an object-oriented design approach, that improves software reusability and productivity. This technology enables a non-stop, service-enhanceable software environment (called NOSES), which satisfies customer demands for quick provisioning of new service features without interrupting service, and which improves software reliability. This technology was developed as part of our overall plan to establish a communications software platform that can be customized for use by various communications systems, such as STM, ATM, and IN. The developed non-stop service enhanceable software techniques are call-recovery restart, system file update, and on-line partial file modification; they were achieved by using dynamic program modification. A system file update inevitably affects calls in service, despite efforts to save in-service calls by copying the call data from the old file to the new one. We have therefore developed a different approach: on-line partial-file modification. Our prototype switching system has proven the effectiveness of this modification method and has shown that it can cover a limited range of service feature additions (which meets customer demands for quick service provisioning), as well as all bug fixes (which can lead to higher software reliability due to not using conventional machine code for software patching), without interrupting service. This paper describes on-line partial-file modification, which can be applied to communications systems that require resident program modification or initialization without program loading; that is, the program exists permanently in main memory. An evaluation of this approach also showed that the productivity of service-layer software increases about two times and that the total increase in systems development productivity is about 25%.

The Non-stop Service-Enhanceable Software (NOSES) platform was developed as part of our overall plan to establish a communications software platform that can be customized for use by various communications systems, such as STM, ATM and IN. The developed NOSES techniques are call-recovery restart, system file update, and on-line partial file modification, so called "Plug-in"; they were achieved by using dynamic program modification. A system-file update inevitably affects calls in service, despite efforts to save in-service calls by copying the call data from the old file to the new one. We therefore developed a different approach: Plug-in modification. This paper evaluates the applicability of the plug-in mechanism of the NOSES platform. Plug-in is a dynamic partial-file modification technique that does not affect calls in service in a communication switching system. In order to apply plug-in program modification widely, the static and dynamic properties of the modified software must be considered. Therefore, an applicability judgement matrix is introduced. The evaluated applicability of plug-in based on case studies and field data was about 60% for service feature additions and modifications. Thus, plug-in is effective for file maintenance of switching systems from the viewpoint of quick provisioning of new service features and bug fixes.

This paper describes two main technologies for achieving reliable real-time distributed communications systems. One is the technology to prevent the influence of a fault in an autonomous distributed system from spreading to the whole system (called autonomous distributed system control). The other is a software structure based on distributed processing, the object-oriented approach, and layering for better maintainability and expandability (called OO software structure). For the autonomous distributed system control, several inter-subsystem communication methods are proposed and evaluated. From the standpoints of the fault processing and processing load, frames should be sent through a data link over ATM connection and when a fault occurs the link should be switched over without loss of data. A pilot system achieved good reliability without an excessive number of dynamic steps. This autonomous control method will lead to a highly reliable communications system with large capacity. For the OO software structure, this paper gives experimental results from the implementation of a prototype system. Its distributed environment should lead to high reliability by extending the CHILL run-time routine (RTR). This software structure promises to provide service quickly, to reduce costs, and to make the development of each layer's software independent. A real-time OS, e.g., CTRON kernel combined with RTR can give real-time performance, high reliability and high productivity over the distributed system. The use of RTR can reduce the time for the call recovery process.

The productivity of developing software for switching systems and the effects of using advanced software development methods were evaluated and analyzed. Productivity was found to be improved by using automatic code generation, simulator debugging, a hierarchical object-oriented software structure, and software-development-support tools. The evaluation showed that the total productivity was improved by about 20%, compared with a case where these efforts were not introduced. It also showed each effect of these methods and tools by evaluating their manpower saving ratios. These results are expected to benefit the development of various types of communication-switching and multimedia service systems. Also, our development-support tools and methods are expected to be the basis for attaining higher software development productivity.

This paper proposes a Java online plug-in mechanism that can be used to modify any part in a system file coded in Java, even while the part is running, without service interruption. The Java-related plug-in capabilities are devised by using the plug-in functional elements offered by the existing C++ online plug-in that we proposed. In particular, measures on how to deal with the use of Just In Time compilation and inline expansion are considered. New linkage and file-back up techniques are proposed for this purpose. Case studies reveal its wide applicability and the degree of memory area saving effects. Evaluation proves this mechanism does not affect the performance of ordinary service processing. It is expected to be used in practice for Java-based service processing such as VoIP and Instant Messaging.

Three types of mechanisms were evaluated to determine their applicability to partially modifying an online switching system file and to creating a partial file during the debugging phase. First, the applicability of the basic plug-in mechanism, currently used in commercial switching systems, was evaluated by using data obtained from an initial implementation of PHS and ATM switching systems. It was found to be applicable irrespective of software type (call-processing or OA&M) and service type (PHS or ATM). It was also found to be applicable to both specification changes and service feature additions. Then, an extended plug-in mechanism that is enhanced to be more robust against complicated software behaviour was evaluated by simulation. It was found to cover cases where the basic plug-in mechanism is difficult to apply. Used together, these two mechanisms guarantee stable and effective file management of an online switching system. A plug-in for offline file creation was found to be applicable to almost all types of file modifications, except when the interface definition is significantly changed. These plug-in mechanisms can serve as the basis for managing the files in multimedia communication service systems.

The sizes of recent Java-based server-side applications, like J2EE containers, have been increasing continuously. Past techniques for improving the performance of Java applications have targeted relatively small applications. Moreover, when the methods of these small target applications are invoked, they are not usually distributed over the entire memory space. As a result, these techniques cannot be applied efficiently to improve the performance of current large applications. We propose a dynamic code repositioning approach to improve the hit rates of instruction caches and translation look-aside buffers. Profiles of method invocations are collected when the application performs with its heaviest processor load, and the code is repositioned based on these profiles. We also discuss a method-splitting technique to significantly reduce the sizes of methods. Our evaluation of a prototype implementing these techniques indicated 5% improvement in the throughput of the application.