Evaluating Library Services

Problem Description
Problem Statement
Library management is considering improving the service at their closed stack library by adding
additional clerks to improve the time borrowers take to check out a book (that is the time from
which the borrower arrives at the service desk to the time the borrower leaves with the book). In
addition, management is also interested in ensuring that clerks are sufficiently busy.
SUI Details
The diagram shows the setup of the library with a
close stack policy.
C

Library clerks are responsible for retrieving books

from the stacks for the borrowers.
Borrowers: A borrower checks, using the library
inventory system, that a book is available. The
borrower prints out a checkout slip for the desired
book using the library inventory system and
deposits it the service desk. The borrower then
waits for his or her name to be called by a clerk to
obtain the desired book.
The library inventory system ensures that
the borrower can check out only one book
and that it is available.

Library Clerks

Library Stacks
C

Checkout Slips

Service Desk

B
Depositing Checkout Slip

Receiving book

Clerks: A clerk picks up a maximum of 4 checkout

slips from the service desk. The clerks will then
retrieve the four books requested on the slips. The
Waiting for Clerk with book
clerk returns to the service desk and calls out the
names of each borrower for them to retrieve the requested books.
Checkout slips are picked up by clerks on a first-come, first-served basis. Books are
returned to customers also on a first-come first-serve basis.
If two or more clerks are idle when a borrower arrives at the checkout desk, the clerk who
has been idle the longest services the borrower.
If two or more slips are at the checkout desk and two or more clerks are available, the
clerks DO NOT divide the work evenly among themselves. One clerk takes up to 4 slips;
then if there are still borrowers with slips to be picked up, the next clerk takes as many
slips as possible, and so on

Project Goal
The main goal of this study is to find the effect of changing the number of clerks on the
utilization of the clerks and the average turnaround time for borrowers (time it borrowers stay in
the library after submitting a slip).
A steady-state study is to be used to study the operation of the library during the busy period
using the number of customers served for terminating the simulation (note that although the busy
period is of finite time, for the purposes of the study, the busy period is being extended). A single
parameter has been defined the number of clerks servicing borrowers (from the current 3 to 4
and 5).
Parameters

numClerks: The number of clerks in the library.

Experimentation

Time units: minutes

Observation interval: Steady state study.
The parameter numClerks is varied from 3 to 4 to 5, that is, there are three cases to this
project.

Output

avgBorrowerResponseTime: The average turnaround time of borrowers.

clerkUtil[numClerks] : Clerk utilization. This is a set of numClerk scalar values that
shows the utilization (percent time each clerk was busy).

ABCmod Conceptual Model

High Level Conceptual Model
Simplifications

Checkout slips are not explicitly modelled. Instead, the Customer entities serve as surrogates
for the slips.

Structural View
Q.ClerksIdle

RQ.Clerk[numClerks]
1

Q.Slips
Legend
iC.
iC.
iC.

iC.Borrower

Figure 1 Library Structural Diagram

Entity Structures
1. Borrower: represents the persons arriving to borrow a book.
2. Clerk: A set of resource queue entities that represents the clerks that carry out the
retrieval of books.
3. Slips: This queue represents the queue of checkout slips presented by the borrowers. Note
that the Borrower entities serve as surrogates for the slips.
4. ClerksIdle: This queue represents the queue of clerks that are idle. Note that identifiers to
the Clerk entities are found in this queue.
Notes:
Clerks can service up to 4 borrowers at a time. Servicing is completed (i.e. the check out)
on a first-come first serve basis. Thus the Clerk entities have a dual role resource and
queue.
Note that the slips are not explicitly modeled. When the Clerks are finding books using
the slips, the Borrower entity is attached to the Clerk entity in lieu of an explicit Slip
entity. This represents the servicing of the Borrower by the Clerk (i.e. finding a book for
the borrower). This Queue role of the Clerk entity ensures that Borrower entities are
serviced on a first-come first-serve basis.
The diagram shown shows the state of the system when an idle clerk is about to pick up
the slips from 3 borrowers waiting for a clerk.
The ClerksIdle Queue contains identifiers of R.Clerk entities; this queue is required to
ensure that the clerk who has been idle the longest services borrowers first.

Behavioural View
BorrowerArrival

FindBooks

CheckOut

(a) Borrower Lifecycle

CheckOut

FindBooks

b) Clerk Lifecycle
Library Behaviour Diagram

Scheduled Action Constructs:

BorrowerArrival: Arrival of borrowers to the checkout counter.
Activity Constructs:
FindBooks: Condition activity where a clerk searches stacks for up to 4 books for the
Borrowers.
Checkout: A conditional activity where the clerk checks out a single borrower after finding
their book.
Notes
The FindBooks activity has been placed in the Borrowers life cycle. Although in reality the
Clerk is searching for books using the slips picked up from the borrowers (which means that
the Borrowers are not really interacting with the Clerk resource), and that the slips are not
modelled explicitly (instead the iC.Borrower entities are attached to the R.Clerk[j] entity to
represent the slips), the activity was included in the Borrowers lifecycle diagram. The
perspective adopted is that the FindBooks activity is one in which the Clerk services the
Borrower.
The Clerk initially starts in the wait point at the top of the Clerk Lifecycle diagram waiting
for slips to become involved in a FindBooks activity instance.
Input
Variable
uBorrowerArr

Variable
uFindBooksTime
uCheckOutTime

Exogenous Input (Entity Streams)

Description
Domain Sequence
Input entity stream variable
for borrowers at the
checkout counter.

RVP.DuBorrowerArr()

Range Sequence
N/A 1 borrower arrives at
each arrival time.

Endogenous Input (semi-independent)

Description
Values
Time to find books in the
stacks for 1 to 4 borrowers.
Time to check out a book
for a borrower.

RVP.uFindBooksTime(num), where num defines the

number of borrowers.
RVP.uCheckOutTime()

Detailed Conceptual Model

Structural Components
Constants
Description

Name
MAX_SLIPS

Maximum number of slips that the clerk picks up

at the checkout desk to find books in the stacks.

Parameters
Description

Name
numClerks

Value
4

Number of clerks for servicing borrowers.

Value
3, 4 and 5

Consumer Class: Borrower

A person wishing to borrow a book.

Attributes
arrivalTime

Description
Time the person arrived at the desk to check out a book. Used to compute the
response time.

Resource Queue Set[numClerks]: Clerk

The clerks for servicing the borrowers. The number of clerks available is defined by the parameter
numClerks. Since the entity can service multiple borrowers at the same time, in the same order that it
received the slips, the role of Queue has been added.

Attributes
status

n
list
servicing

Description
Set to IDLE when waiting for Borrowers (i.e. placed the Q.ClerksIdle), and
BUSY otherwise. This attribute is required to observe the amount of time the
Clerk is busy.
Number of borrowers being serviced when Status is set to Busy (one to
MAX_SLIPS).
List of iC.Borrower's being serviced. Slips are not explicitly modeled. Instead a
reference to the iC.Borrower is attached to the RQ.Clerk member.
This attributes reflects the phase of servicing in which the Clerk is involved. It
is only significant when the Status attribute is set to BUSY. I can have one of
two values:
FINDBOOKS - when searching for books in the stacks
READYCHECKOUT - ready to check out a book with a borrower
CHECKINGOUT - checking out a book with a borrower.

Queue Unary: Slips

The borrowers line up at the checkout desk to present a slip for borrowing a book. This queue
represents the line of borrowers waiting to give their slip to a clerk.

Attributes
n
list

Description
Number of borrowers waiting to give a slip to a clerk.
List of references to iC.Borrower's waiting to give a slip to a clerk.

Queue Unary: ClerksIdle

This queue represents the clerks that are idle and waiting for slips from borrowers.

Attributes
n
list

Description
The number of idle clerks.
The list of identifiers to RG.Clerk members that are idle.

Behavioural components
Time units: minutes
Observation interval: Steady state study.

Action: Initialise
TimeSequence
Event SCS

<0>
Q.Slips.n 0
num 0
WHILE(num < numClerks)
RQ.Clerk[num].status IDLE
SP.InsertQue(Q.ClerksIdle, num)
num num+1
END

Output
OUTPUTS
Trajectory Sets
Name

Description

TRJ[RQ.Clerk[id].status]

There are numClerk trajectory sets are defined: id is varied from 0 to

numClerks-1, to monitor the status attribute of each clerk
(RQ.Clerk[id].status).

Sample Sets
Name

Description

PHI[responseTime]

Name

Collects the times it takes the response times for borrowers to check out a
book (from the time the borrower arrives at the checkout desk to the time he
or she leaves with the book). When the checkout procedure is completed for a
borrower, the time is computed as (t-iC.Borrower.arrivalTime).

Derived Scalar Output Variables (DSOV's)

Description
Data Set Name

AvgResponseTime
ClerkUtil[id]

The average response time

for borrowers.
Where id is numbered 0 up
to numClerks-1. There are
numClerk scalar output
variables defined, one for
each clerk in the model.

Operator

PHI[responseTime]

AVG

TRJ[RQ.Clerk[id].Status]

AVG

User Defined Procedures

Name
ClerkReadyToCheckOut()

User Defined Procedures

Description
This procedure returns an identifier for an RQ.Clerk member that is
ready to checkout a book with a borrower. This conditions exists when:
1) The status attribute of the member is set to BUSY
2) The servicing attribute of the member is set to READYCHECKOUT
2) The n attribute of the member is non-zero.
If no RQ.Clerk member is ready to check out the books, the procedure
returns NONE (-1).

Input Constructs

Name

Random Variate Procedures

Description
Data Model

DuBorrowerArr()

The times borrowers

arrive at the checkout
desk with slips.

uFindBooksTime(n)

Returns the amount of

time required to find
books according to the
number of books to
find.

uCheckOutTime()

Returns the time to

check out a book.

{tk: k = 0, 1, 2, ----}
with t0 = EXP(ARRIVAL_MEAN) and for k>0,
tk = t(k-1) + EXP(ARRIVAL_MEAN)
where ARRIVAL_MEAN = 2 minutes
n=1: Normal(MEAN_ONE,STD_DEV_ONE)
n=2: Normal(MEAN_TWO, STD_DEV_TWO)
n=3: Normal(MEAN_THREE, STD_DEV_THREE)
n=4: Normal(MEAN_FOUR, STD_DEV_FOUR)
where:
MEAN_ONE = 4 min.,STD_DEV_ONE = 0.8 min
MEAN_TWO = 7 min.,STD_DEV_ TWO = 1.4 min
MEAN_ THREE = 9 min.,STD_DEV_ THREE = 1.8 min
MEAN_ FOUR = 12 min.,STD_DEV_ FOUR = 2.4 min
UNIFORM(CHECK_OUT_MIN, CHECK_OUT_MAX)
where
CHECK_OUT_MIN = 1 min., CHECK_OUT_MAX = 3 min.

Action: BorrowerArrival
The arrival of a borrower with a slip to borrow a book.
TimeSequence RVP.DuBorrowerArr()
Event SCS
iC.Borrower SP.Derive(Borrower)
iC.Borrower.arrivalTime t
SP.InsertQue(Q.Slips, iC.Borrower)

Behavioural Constructs
Activity: FindBooks
Pickup slips and find the books in the stack.
Precondition (Q.Slips.n > 0) AND (Q.ClerksIdle.n > 0)
Event SCS
clerkId SP.RemoveQu(Q.ClerksIdle)
IF(Q.Slips.n > MAX_SLIPS)
numSlips MAX_SLIPS
ELSE
numSlips Q.Slips.n
ENDIF
num 0
WHILE (num < numSlips)
iC.Borrower SP.RemoveQu(Q.Slips)
SP.InsertQu(RQ.Clerk[clerkId], iC.Borrower)
num num+1
ENDWHILE
RQ.Clerk[clerkId].status BUSY
RQ. Clerk[clerkId].servicing FINDBOOKS
Duration
RVP.uFindBooksTime(RQ.Clerk[clerkId].n)
Event SCS
RQ.Clerk[clerkId].servicing READYCHECKOUT

Activity Construct: CheckOut

Time to process the end of the checkout of books with each customer.
Precondition UDP.ClerkReadyToCheckout() NONE
Event SCS
clerkId UDP.ClerkReadyToCheckOut()
RQ.Clerk[clerkId].servicing CHECKINGOUT
Duration
RVP.uCheckOutTime()
Event SCS
iC.Borrower SP.RemoveQu(RQ.Clerk[clerkId])
SP.Put(PHI[ResponseTime], t - iC.Borrower.arrivalTime)
SP.Leave(iC.Borrower)
IF(RQ.Clerk[clerkId].n = 0)
RQ.Clerk[clerkId].status IDLE
SP.InsertQu(Q.ClerksIdle, clerkId)
ELSE
RQ.Clerk[clerkId].servicing READYCHECKOUT
ENDIF

Design of Validation Experimentation

Trace Logging

Annex A Data Modelling