VIOLA -

A Scalable and Fault-Tolerant

Video-on-Demand System

Y.B. Lee P.C. Wong

Information Networking Laboratories
Faculty of Engineering
The Chinese University of Hong Kong
Tel:(852)-2603-7360 Fax:(852)-2603-7327
Email: jack@inl.cuhk.edu.hk
Advanced Network System Laboratory
Department of Information Engineering
The Chinese University of Hong Kong
Tel:(852)-2609-8390 Fax:(852)-2603-5032
Email: pcwong@ie.cuhk.edu.hk

Abstract

In this paper, we present the architecture of a Video-on-Demand system called VIOLA. This system exhibits two
distinctive features not found in other Video-on-Demand systems, namely scalability, and fault tolerance.
System scalability is achieved through a novel Server Array architecture in which video data are distributed
among an array of servers. This allows one to scale up the system capacity (like memory capacity, storage
capacity, network bandwidth, and CPU processing power) simply by adding more servers and redistributing the
video data among them. For fault tolerance, we further extend the server array architecture to a novel
Redundant Array of Inexpensive Servers (RAIS) architecture where server failure can be sustained. The
resultant VIOLA system can provide non-stop, continuous video services before, during, and after a server
failure.

1. Introduction

The advances in communications technologies enabled retrievals of vast amount of information from a great
distance. Today’s information servers not only service simple texture data, but also a rich combination of texts,
graphics, images, animations, audio, and even videos. Among the many different types of media, retrieving full-
motion, high-quality video in real time - video-on-demand (VoD), poses the greatest challenges. Digital video
requires orders of magnitude more storage spaces and transmission bandwidth than traditional data services.
Moreover, video data must be received in time for continuous playback to the user. For this reason, there have
been plenty of researches in the last decades to tackle the above problems.

One common architecture shared by almost all existing VoD systems is that they are based on a single server.
The video server can range from a standard PC for small-scale systems to massively-parallel supercomputers
with thousands of processors for large-scale systems. However this single-server approach has its limitations.

Firstly, the capacity of a single server is limited. When the demand reaches the server’s capacity limit, one may
need to replicate data to a new server, doubling the storage requirement of the system. Considering that high-

1
quality digital video requires vast amount of storage, this approach could be prohibitively expensive. A second
approach is to partition the videos into disjoint subsets and store each subset in a different video server. This
approach does not require extra storage but suffer from a problem - load balancing. Empirical studies have
shown that video retrievals are highly skewed, i.e. some videos are more popular than the others. Furthermore
this skewness is not fixed, but changes with time (e.g. when most users have seen the video). The implication is
that some video servers might be overloaded by a popular title, while others might be under-utilized. Drawn
from the same principle of disk array, we propose a novel server array architecture [1] for designing scalable
video servers. Rather than partition videos among multiple servers, we divide a video into fixed-size units, and
store them evenly across all servers. In this way, each and every video is served by all servers and hence the
loading is shared evenly. To increase the system capacity, one only need to add a new server and redistribute the
video data.

Secondly, a single-server VoD system cannot survive server failure. Again, one can use a backup server to
improve reliability, or partition videos into multiple servers to improve availability. Obviously these two
approaches suffer from the same problem discussed previously. In this respect, we draw similar principles from
the Redundant Array of Inexpensive Disks (RAID) architecture [2], and extend it to the server level - Redundant
Array of Inexpensive Servers (RAIS) [3]. By building a video server using the RAIS approach, we can achieve
server-level fault tolerance at a fraction of the cost of server mirroring, and at the same time enjoy load-
balancing across all servers.

The rest of the paper is organized as follows: Section 2 describes the server array architecture; Section 3
describes Redundant Array of Inexpensive Servers (RAIS); and Section 4 presents some system performance
results. We draw a conclusion in Section 5

2. VIOLA Video Server Array

Figure 1 shows the architecture of the video server array system. It consists of an array of autonomous servers
directly connected to the client stations through an interconnection network. Both servers and clients are
conventional computers with one or more network interfaces connected to the network. Video files (streams) are
divided into fixed-size blocks and stored inside the servers. To retrieve a video stream, a client sends requests to
each server, and merges the received blocks into one stream of data. The client stations have a hardware or
software decoding device which can decode the received data stream into video for output to a computer monitor
or television. The striping of video blocks ensures that the loading of every stream is shared by all servers.
Since each server has its own disks, memory, processor, and network interfaces, we can scale up the system by
adding more servers for more storage capacity, memory capacity, processing power, and network bandwidth.

2
 VIOLA
Network
Video Server Array
Switch

Video
Clients

Figure 1: System architecture of a video server array system.

3. VIOLA Redundant Array of Inexpensive Servers (RAIS)

As data units are striped instead of replicated, any one server failure will render the entire system inoperable.
Fortunately, schemes operate at the server level analogue to Redundant Array of Inexpensive Disks (RAID) can
be devised for the server array. Through redundant data allocation and failure recovery scheme, a server array
can have fault tolerant capability.

To support fault tolerance, we reserve stripe units within a stripe to store redundant data. Let there be NS servers
in the server array. If we want to tolerate K simultaneous server failures, we need to reserve K redundant units in
every stripe, leaving ND= NS −K stripe units for data. Note that a stripe is also called a parity group and we will
use these terms interchangeably in this paper.

As an example, Figure 2 shows the striping policy with a redundancy level K=1. We have one redundant unit in
every stripe. When a server (say, server 2) fails, the client can recover the lost stripe unit of the failed server by
retrieving the corresponding stripe units from the remaining servers, and performing erasure-correcting
computation over the received units.

S0 S1 S2 S3 S4 Parity Calculation

Stripe u0 u1 u2 u3 p0 p0= u0⊕ u1⊕ u2⊕ u3

(or parity group)
Stripe unit u4 u5 u6 p1 u7 p1= u4⊕ u5⊕ u6⊕ u7

One u8 u9 p2 u10 u11 p2= u8⊕ u9⊕ u10⊕ u11

server
u12 p3 u13 u14 u15 p3= u12⊕ u13⊕ u14⊕ u15

Parity unit p4 u16 u17 u18 u19 p4= u16⊕ u17⊕ u18⊕ u19

Figure 2: Storage configuration of a RAIS system.

3
4. System Performance

In this section, we present some performance results of the VIOLA system. Interested readers are referred to [1,
3] for more details.

4.1 System Capacity

To evaluate the capacity of a server array, we set up video server arrays with one, two, and four servers
respectively. We striped video streams across all servers and measured the server throughput versus different
client loading. The results are plotted in Figure 3. We observe that under the same client loading, the per-server
loading is reduced by half for a two-servers server array, and reduced to one fourth for a four-servers server
array. Therefore while one low-end server can only support 10 video sessions, the server array approach allows
us to scale up the system capacity.

1800000

1600000
Per-Server Throughput (B/s)

1400000

1200000
1 Server
1000000
2 Servers
800000 4 Servers

600000

400000

200000

0
0 5 10 15 20 25 30 35 40
Number of STP Clients

Figure 3: Server throughput versus loading for a video server array.

4.2 RAIS Server Performance

To demonstrate the fault tolerance capability of RAIS, we conduct experiments to obtain the server utilization
before and after a server failure. The test is run with four servers using distributed single-parity coding
(i.e. K=1). In all cases, client video continues playback without interruption before, during and after the server
failure.

Figure 4 shows the test result for four servers and 10 concurrent video sessions. Server 3 is terminated after 3
minutes. The failure is detected by all clients and subsequently all clients enter failure-mode operation. The
above tests show that our RAIS system can perform lost data recovery and maintain video continuity in the midst
of server failures.

4
 700000

600000

500000
Throughput (Bps)

Server 1
400000
Server 3 fails Server 2
Server 3
300000 Server 4

200000

100000

0
0 5 10 15 20 25 30 35 40 45 50 55 60 65
Time (5x seconds)

Figure 4: A test run using RAIS to sustain one server failure.

5. Conclusion

In this paper, we presented the architecture of the VIOLA Video-on-Demand system. By building VIOLA upon
the server array architecture, we can scale up the system to more users by using an array of autonomous servers.
Moreover, video data are distributed rather than replicated among the servers, thereby significantly reduces
storage cost. This enables one to build large VoD systems using low-cost PC hardware. On the other hand, by
employing the Redundant Array of Inexpensive Servers (RAIS) architecture, VIOLA can maintain non-stop
video services even when one of the server fails. The entire process is fully automatic and transparent to the end
users.

References

[1] Y.B. Lee, P.C. Wong, “A Server Array Approach for Video-on-demand Service on Local Area
Networks,” IEEE INFOCOM ‘96, San Francisco, USA, March 25-28.

[2] D. Patterson, G. Gibson, R. Katz, “A Case for Redundant Arrays of Inexpensive Disks (RAID),”
Proceeding of the ACM SIGMOD Conference, June, 1988, pp. 109-116.

[3] P.C.Wong, and Y.B.Lee, “Redundant Array of Inexpensive Servers (RAIS) for On-Demand Multimedia
Services,” Proc. ICC’97, Montreal, Canada, June 8-12, 1997.