Tracking program states when replacing running program modules using dynamic linking

Atsushi Yamamoto, Hideo Taniguchi

Research output: Contribution to journalArticle

Abstract

It would be possible to provide uninterrupted service for 24 hours a day if it were possible to replace a program module without having to terminate processes which are providing services. We thus propose a method for controlling replacement of a program module while running. An essential condition for replacing a program module is that no processes be currently executing the program module. It is therefore necessary to track the execution state of the program module by processes. If our replacement method is considered from a practical standpoint, then it is undesirable to create an application program that need be aware of state tracking. However, a problem with conventional state tracking methods has been that the object files, executable files, and the source code of the application program need to be re-created in order for the state to be capable of being tracked. In the present paper, therefore, we propose a method that makes it possible to track state without having to re-create these files and code, by making it a prerequisite that dynamic linking be used as the method for creating the application program, and using the dynamic linking function. In particular, we demonstrate a method whereby during execution of an application program, the dynamic linker automatically detects calls and returns among program modules, which are triggers for transitions in execution state. The proposed method also shows a way to reduce the processing overhead accompanying state tracking. Furthermore, through a process of implementation and assessment, we demonstrate that our proposed method, when contrasted with a conventional method, does not require the creation of an application program that is aware of state tracking, and has a lower effective processing overhead associated with state tracking.

Original languageEnglish
Pages (from-to)22-34
Number of pages13
JournalSystems and Computers in Japan
Volume37
Issue number10
DOIs
Publication statusPublished - Sep 2006

Fingerprint

Application programs
Linking
Module
Processing
Replacement
Terminate
Trigger
Demonstrate
Necessary

Keywords

  • Dynamic link
  • Process
  • Program swapping
  • Reliability
  • Software

ASJC Scopus subject areas

  • Theoretical Computer Science
  • Information Systems
  • Hardware and Architecture
  • Computational Theory and Mathematics

Cite this

Tracking program states when replacing running program modules using dynamic linking. / Yamamoto, Atsushi; Taniguchi, Hideo.

In: Systems and Computers in Japan, Vol. 37, No. 10, 09.2006, p. 22-34.

Research output: Contribution to journalArticle

@article{5a35af3ef43e4e55bc29c6b801494302,
title = "Tracking program states when replacing running program modules using dynamic linking",
abstract = "It would be possible to provide uninterrupted service for 24 hours a day if it were possible to replace a program module without having to terminate processes which are providing services. We thus propose a method for controlling replacement of a program module while running. An essential condition for replacing a program module is that no processes be currently executing the program module. It is therefore necessary to track the execution state of the program module by processes. If our replacement method is considered from a practical standpoint, then it is undesirable to create an application program that need be aware of state tracking. However, a problem with conventional state tracking methods has been that the object files, executable files, and the source code of the application program need to be re-created in order for the state to be capable of being tracked. In the present paper, therefore, we propose a method that makes it possible to track state without having to re-create these files and code, by making it a prerequisite that dynamic linking be used as the method for creating the application program, and using the dynamic linking function. In particular, we demonstrate a method whereby during execution of an application program, the dynamic linker automatically detects calls and returns among program modules, which are triggers for transitions in execution state. The proposed method also shows a way to reduce the processing overhead accompanying state tracking. Furthermore, through a process of implementation and assessment, we demonstrate that our proposed method, when contrasted with a conventional method, does not require the creation of an application program that is aware of state tracking, and has a lower effective processing overhead associated with state tracking.",
keywords = "Dynamic link, Process, Program swapping, Reliability, Software",
author = "Atsushi Yamamoto and Hideo Taniguchi",
year = "2006",
month = "9",
doi = "10.1002/scj.20522",
language = "English",
volume = "37",
pages = "22--34",
journal = "Systems and Computers in Japan",
issn = "0882-1666",
publisher = "John Wiley and Sons Inc.",
number = "10",

}

TY - JOUR

T1 - Tracking program states when replacing running program modules using dynamic linking

AU - Yamamoto, Atsushi

AU - Taniguchi, Hideo

PY - 2006/9

Y1 - 2006/9

N2 - It would be possible to provide uninterrupted service for 24 hours a day if it were possible to replace a program module without having to terminate processes which are providing services. We thus propose a method for controlling replacement of a program module while running. An essential condition for replacing a program module is that no processes be currently executing the program module. It is therefore necessary to track the execution state of the program module by processes. If our replacement method is considered from a practical standpoint, then it is undesirable to create an application program that need be aware of state tracking. However, a problem with conventional state tracking methods has been that the object files, executable files, and the source code of the application program need to be re-created in order for the state to be capable of being tracked. In the present paper, therefore, we propose a method that makes it possible to track state without having to re-create these files and code, by making it a prerequisite that dynamic linking be used as the method for creating the application program, and using the dynamic linking function. In particular, we demonstrate a method whereby during execution of an application program, the dynamic linker automatically detects calls and returns among program modules, which are triggers for transitions in execution state. The proposed method also shows a way to reduce the processing overhead accompanying state tracking. Furthermore, through a process of implementation and assessment, we demonstrate that our proposed method, when contrasted with a conventional method, does not require the creation of an application program that is aware of state tracking, and has a lower effective processing overhead associated with state tracking.

AB - It would be possible to provide uninterrupted service for 24 hours a day if it were possible to replace a program module without having to terminate processes which are providing services. We thus propose a method for controlling replacement of a program module while running. An essential condition for replacing a program module is that no processes be currently executing the program module. It is therefore necessary to track the execution state of the program module by processes. If our replacement method is considered from a practical standpoint, then it is undesirable to create an application program that need be aware of state tracking. However, a problem with conventional state tracking methods has been that the object files, executable files, and the source code of the application program need to be re-created in order for the state to be capable of being tracked. In the present paper, therefore, we propose a method that makes it possible to track state without having to re-create these files and code, by making it a prerequisite that dynamic linking be used as the method for creating the application program, and using the dynamic linking function. In particular, we demonstrate a method whereby during execution of an application program, the dynamic linker automatically detects calls and returns among program modules, which are triggers for transitions in execution state. The proposed method also shows a way to reduce the processing overhead accompanying state tracking. Furthermore, through a process of implementation and assessment, we demonstrate that our proposed method, when contrasted with a conventional method, does not require the creation of an application program that is aware of state tracking, and has a lower effective processing overhead associated with state tracking.

KW - Dynamic link

KW - Process

KW - Program swapping

KW - Reliability

KW - Software

UR - http://www.scopus.com/inward/record.url?scp=33747461006&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=33747461006&partnerID=8YFLogxK

U2 - 10.1002/scj.20522

DO - 10.1002/scj.20522

M3 - Article

AN - SCOPUS:33747461006

VL - 37

SP - 22

EP - 34

JO - Systems and Computers in Japan

JF - Systems and Computers in Japan

SN - 0882-1666

IS - 10

ER -