Multi-version Execution for the Dynamic Updating
of Cloud Applications
Feng Chen, Weizhong Qiang, Hai Jin, Deqing Zou, Duoqiang Wang
Services Computing Technology and System Lab
Cluster and Grid Computing Lab
Huazhong University of Science and Technology, Wuhan, 430074, China
wzqiang@hust.edu.cn
Abstract—Softwares usually need to be updated to fix bugs
or add new features. On the other hand, some critical softwares,
such as cloud applications, need to provide service continuously,
thus should be updated without downtime. Conventional Dynamic
Software Updating (DSU) systems try to update programs while
running, but they hardly consider the communication of the
program to be updated with other programs, which may lead
to some inconsistency problems.
We handle the problem with an improved DSU system
by using multi-version execution. When a new update arrives,
instead of updating the application to the new version, we fork
a new process of the old version and dynamically update it to
the new version, then make these two versions run concurrently
until the update finishes. We implement a prototype system called
MUC (Multi-vesion for Updating of Cloud) on Linux. To verify
our prototype, we apply MUC to cloud applications Redis and
Icecast, and evaluate the overhead of MUC at runtime.
Keywords—Dynamic software updating, Multi-version, Cloud
I. INTRODUCTION
Cloud computing involves deploying groups of networked
software servers that allow centralized computing services and
data storage, as well as online access to them. More specif-
ically, clouds provide services with higher requirements for
continuity and reliability. For example, in IaaS (Infrastructure
as a Service), users’ operating environments run on the cloud
services, while users only own a thin client which works as a
terminal for accessing cloud, which is a centralized software
hosting mechanism that provides higher resource utilization,
but also leads to more challenges in terms of high availability.
On the other hand, softwares usually need to be updated to
fix bugs or add new features, and softwares in the cloud
need to updated more frequently because the cloud provides a
centralized way for software maintenance. In the conventional
way, a program is updated in three steps: stopped, updated,
and restarted. This update process will take a few minutes to
several hours. To provide continuous service and permit online
updates, DSU (Dynamic Software Update) [1] is proposed to
update an application while it is running.
Early DSU systems only consider single-thread program,
such as DYMOS [3], PODUS [4], Ginseng [5]. DSU systems
are applied in multi-thread program, such as UpStare [6],
Ksplice [7], JVOLVE [8], DTHREADS [9], Kitsune [10] and
Ekiden [11]. Existing DSU systems are only designed for stan-
dalone applications, and are not suitable for those applications
(e.g., cloud application) that include multiple participants who
interact with each other via IPC (inter process communication).
Therefore, updating one participant through DSU may cause
unexpected fault for the whole application. For example, when
a client connects with a server while the server is being updated
dynamically, the client may send a message to the server with
old version but the server with new version finally receives it.
At last, the server may get some unexpected results.
Our approach devotes to solving the dynamic update prob-
lem in the cloud. The key idea in our approach is to make
the new version and the old version run concurrently. When
a new update arrives, instead of updating the application to
the new version, we fork a new process of the old version
and dynamically update it. Then, we run the two versions
concurrently until the update finishes. We implement this
approach in a prototype system called MUC, which runs
in Linux with multicore processors. MUC consists of four
components: static analysis component (SAC), process spawn
component (PSC), process synchronization component (PSYC)
and process consistency component (PCC). We apply the
prototype to Redis and Icecast, and evaluate the overhead of
this prototype at runtime.
The rest of the paper is organized as follows. Section II
discusses related work. Section III proposes a motivation ex-
ample of the dynamic update for cloud applications. Section IV
presents the dynamic software update model in the cloud in
detail and analyzes the feasibility of the model. Section V
describes our prototype MUC and its implementation details.
Section VI presents our evaluation of MUC when it is applied
to Redis and Icecast. Section VII is the conclusion of our work.
II. R
ELATED WORK
Dynamic software updating. Gutpa [2] established formal
groundwork for reasoning about dynamic update in general.
Ginseng [5, 12] is the first general-purpose DSU system for
C, which is implemented as a source-to-source compiler using
the C intermediate language framework written in OCaml.
Subsequently, UpStare [6] and Kitsune [10] are proposed
for dynamically updating multi-threaded applications. Upstare
uses stack reconstruction to guarantee that all active functions
have the same version after an update. Kitsune updates the
whole program instead of updating individual functions within
a single program. However, these DSU systems are either for
single-threaded programs or multi-threaded programs. If an
2015 IEEE 39th Annual International Computers, Software & Applications Conference
0730-3157/15 $31.00 © 2015 IEEE
DOI 10.1109/COMPSAC.2015.130
185