CoE 135 Problem Set 1
Raphael Cyron Robles
Electrical and Electronics Engineering Institute
University of the Philippines Diliman
Quezon City, Philippines
cyron.robles@eee.upd.edu.ph
I pledge that I answered all the items in this Problem
Set to the best of my understanding, and with the aid of
properly cited resources and collaborators in problems I
could not solve on my own. I made sure that I cited all
resources and stated the names of all those who guided
me in answering all the items along with their invaluable
contributions.
Raphael Cyron M. Robles
2015-06938
I. P ROBLEMS
1. During your Arch Linux installation procedure in
Machine Exercise 1, you were required to set up the boot
loader for Arch Linux. Why is that step required? Why does an
Ubuntu installation not require the same procedure? Why do
we need boot loaders in general What is their role? Give two
examples of boot loaders, and compare their highlight features.
Setting up the boot loader is required because the
boot loader is the first piece of software started by the BIOS
or UEFI, responsible for loading the kernel and initial RAM
disk with the wanted parameters and configurations. [1].
Since the default installation of Arch Linux is a minimal
base system, the user has to add and configure whatever is
required, e.g. the boot loader. Ubuntu installation does not
require the exact same procedure for configuring the boot
loader; however, it still requires the installation of a boot loader
which comes preconfigured, only prompting for the user’s
input to which device the boot loader should be installed on.
One of the most common bootloaders, and the one that
comes preconfigured for Ubuntu, is GRUB(GRand Unified
Bootloader). GRUB supports both UEFI and BIOS firmware,
multi-booting, full support for ext4, ReiserFS v3, VFAT,
XFS, and Btrfs without zstd compression. rEFInd is a UEFI
boot loader designed to be platform-neutral and to simplify
booting multiple OSes, auto-detecting kernels and parameters
without explicit configuration and offers full support for
VFAT, Btrfs without encryption and zstd compression, ext4
without encryption, ReiserFS v3 without tail-packing feature.
[1].
Self Grade for Number 1: 4
2. Discuss the essential properties of the following types of
operating systems: Batch, Interactive, Time Sharing, Real
Time, Network, Parallel, Distributed, Clustered, Handheld.
The batch operating system does not let the user
interact with the computer directly. Instead, the user
uses devices like punch cards which are then submitted
to the computer operator. The computer operator then
has to sort these programs into batches that share
similar needs in order to speed up processing. [2].
Interactive operating system, on the other hand,
allows the user to interact directly with the operating
system. It is done with the use of a user interface, be
it graphical or command line, and allows interaction
with the OS while multiple progrums are running. [2]
Time sharing enables multiple users to use the system
to use the system effectively ’at the same time’. The time
sharing operating system is optimized for responsiveness
through frequent switching of the CPU between
multiple jobs. It uses scheduling and multiprogramming
to provide the users a small portion of time. [2]
A real time operating system features the ability
to handle input data within little and guaranteed
response time. It must have a well defined and
fixed time constraints, otherwise it would fail. [3]
The network operating system has the purpose of
allowing file and device access to multiple computers
connected in a network. It runs on the server which
has the capability to manage data, users, groups,
applications and other networking functions. [2]
Parallel operating systems are the interface between
parallel computers and applications executed on them.
It is designed to speed up program execution times by
’dividing’ the program and processing it simultaneously.
Distributed operating systems operates over a collection of
independent, networked and separate nodes. Jobs are handled
and distributed along multiple CPUs accordingly. To do this,
the processors communicate through various communication
lines(e.g. high speed buses, telephone lines). [3]
A clustered operating system features multiple computers
that share a common file system equally. It is used to
maximize availability, where if a system fails, another
one from the cluster can take over, effectively using
multiple computers to acomplish a single task. [3]
Handheld operating systems are optimized
with features that are necessary for handheld
devices(e.g. touchscreen interface, network connections).
 Self Grade for Number 2: 4
3. mmap() is a system call that is always invoked whenever
our programs start executing according to the output of
our strace experiment in Machine Exercise 3. What are
the use cases of mmap(), including and aside from its
usage in your test programs for the lab? Provide at least
three code snippets that use mmap() in three different ways.

A common use case for mmap() is for dynamic/shared Fig. 3. Mapping with mprotect().
libraries. We mmap() the contents of the program in the
address space of the program if it has dynamic linkage [2].

Fig. 4. Reading a file from mmap.

4. We have two sets of API to perform file handling, the

standard version provided by <stdio.h> and the system call
file management API. When do we use one version over the
Fig. 1. Strace output for a simple hello world program. other? When should we use buffered I/O? When should we use
non-buffered I/O? Provide concrete examples for each case.

The system call file management API uses non-buffered

I/O and the standard version uses buffered I/O. We use the
non-buffered version when we need to ensure that the output
Fig. 2. Mapping ld.so.cache has been written before continuing, e.g. errors, and to avoid
having an extra copy into a second buffer when we have a large
From the strace output, the first usage of mmap() is
sequence of file ready to write to disk. The buffered version,
at line 7, highlighted at Fig.2, where it mmaps the file
on the other hand, accumulates writes to an intermediate
descriptor 3 obtained from /etc/ld.so.cache, returning
buffer, only sends it to the OS file system when enough
the starting address of the mapped file in memory.
data has accumulated or flush() is called to reduce the
Next usage from the output comes from the lines
number of file system calls. Hence, we use the non-buffered
shown in Fig. 3 where mmap() is called multiple
version when we need large buffers to send. We use the
times along with mprotect() to map libc.so.6 into
buffered I/O when we need to implement portable programs
the memory, this time with mprotect() protecting
since it has specific implementations on various host OSes.
certain memory portions as read only to prevent the
Generally, buffered I/O is faster but can be less reliable
program from writing to memory that is not mapped for it.
in certain circumstances. We would want to use the buffered
I/O when we will be limited by the hardware may be due to
Another sample usage for mmap is for reading files.
high latency or only permitting data to be accessed in chunks
Fig. 4 shows the code for a program that reads that file
and typically when we want to minimize the system calls
“myfile” int-by-int from the mmap.
used to improve speed which is generally the case for most
Self Grade for Number 3: 4 programs. Unbuffered I/O on the other hand would be useful
for applications where data is being changed randomly such
as multithreaded applications and using a buffered I/O would
result in a stale buffer, leading to incorrect results.

Self Grade for Number 4: 4

5. There are many ways to implement all the data structures
in general programming. How does the Linux Kernel
implement its data structures? What interface does the
Linux Kernel provide for Kernel Developers to make
use of its data structures? How can we implement
stacks and queues using the fundamental data structure
provided by the Linux Kernel as a base data structure?

Linux kernel implements its data structures through

its simplest and most common data structure, the linked
list. The implementation of the linked list in the Linux
kernel is unique to common linked list implementations. The
approach is to embed a linked list node in the structure. [5]
The Linux kernel provides the developers the code for the
linked list data structure in the header file <linux/list.h>
Stacks and queues can be implemented in Linux using
linked list. The two functions needed for the most basic
functionality of stacks ans queues are push and pop. Push
and enqueue will have the same functionality for both stack
and queues where it will add a new item at the end of the
linked list. Push and dequeue, on the other hand, will differ
with from where they remove the item from the list, dequeue
removes the first item for the queue and pop removes the last
item for the stack.
Self Grade for Number 5: 4
6. You are given the code snippet below:
fork();
fork() && fork() || fork();
if (fork() || (!fork()))
if (fork() && (!fork()))
if (fork() || fork())
fork();
printf("CoE 135");
How many processes are created? Why? Draw the
tree diagram for the process tree created by this code
snippet. Tip for drawing: You can just scan/take a picture
+ use CamScanner or similar apps to submit your drawing.
The code can be divided into two blocks, block 1
which contains the first two blocks and block 2 with
everything else. Block 1 is pretty straightforward where
the the and(&&) and or(||) operators does not really
matter since it only affects the return value of the line.
Block 1 finishes with 10 processes as shown in Fig. 5.
Block 2 introduces a series of conditional statements
where some processes finishes ’forking’ because the condition
in the statement has not been satisfied and proceeds to finish
Fig. 5. Block 1 tree.
the code. Block 2 finishes with 15 processes as shown in Fig.6.
Since block 1 finished with 10 processes, each of
those processes will enter block 2 therefore the total
number of processes created can be computed by
multilying 10 to the number of processes in block 2
giving a total of 150 processes created in the program.
Self Grade for Number 6: 4
7. Write a program that creates a parent an child process.
The parent process will take integer inputs. All integer
inputs greater than zero will be sent to its child process.
The child process will then compute the Collatz Sequence
of the received integer and shares the entire sequence to the
parent process. The sharing scheme must be implemented
using Message Passing API and Shared Memory API.
Hint: You *really* would want to work on this as a group.
Code for Collatz Sequence with sharing is shown in
Fig. 7. This item is answered in collaboration with John
Raphael Pascua.
Self Grade for Number 7: 3
8. Compare and contrast the behavior and
use cases of blocking and nonblocking func-
tions. Provide an example for each case.
Blocking functions, as the name suggests, blocks
the execution of the code following it until the blocking
function finishes execution. It essentially creates a schedule
for events by waiting for certain functions to finish first,
implementing synchronous activity. Nonblocking functions,
on the other hand, calls the function and then proceeds
to the succeeding lines and it does not matter if the
 Fig. 6. Block 2 tree.

nonblocking function has finished execution or not. [6]

sleep(n) is an example of a blocking function.
It suspends the program for n seconds and it will only
continue executing the succeeding lines of code once n
seconds has passed or an interrupt is received. Another
example of blocking functions are scanf() and fgets()
where a user input is required to proceed with execution.
An example for a nonblocking function would be
select(). It can monitor different resources at the same
time and poll for network activity without blocking. [6]

Self Grade for Number 8: 4

9. One of the data structures used by the kernel is the
Process Control Block. The Process Control Block is used
to store all the information about a process. Upon close
inspection of the struct definition of the PCB, it heavily
makes use of macros. Give at least three examples of
macros used in Linux’s PCB, their meaning, and a brief
description of their purpose. Explain why the kernel makes
extensive use of macros and macro functions in general. Fig. 7. Collatz Sequence Program.
Hint: Try to avoid going in too deep into the Linux
PCB data structure for now. It’s quite a deep rabbit hole.

The Linux kernel is heavily reliant on the use of

macros to maintain easy porting and compatibility. It is
beneficial to use macros since it would make changing
necessary values(for adjustments for different architectures)
across the whole kernel system much more easier since
the kernel is basically one huge chunk of code. [7]
Some examples of macros used in Linux’s PCB
are __init, __nosavedata and __setup_param.
__init is used to mark functions or initialized data for
the kernel to be able to identify that it is only being used
for initialization process only and it can be freed afterwards.
__nosavedata is used to mark data not to be saved by
software suspend. __setup_param is used to force the
alignment so the compiler doesn’t space elements of the
obs kernel param ”array” too far apart in .init.setup. [8]
Self Grade for Number 9: 4
10. We can make use of mutexes and condition variables
to synchronise multiple threads. However we can also
make use of time and timer functions to synchronise
threads. When is forced synchronization via time and
timer functions applicable and not applicable? Provide
sample code for each case and explain why your provided
programs will synchronise and not synchronise using Fig. 8. Timer synchronized snippet
purely time and timer functions alone. Hint: Lecture :)

Synchronization using time functions would be applicable
for multiple threads that each does not necessarily need
a significant amount of time handling the resources(i.e.
you are sure that the program will finish modifying the
resources before the timer functions, with reasonable wait
times, ends). It would not be applicable for applications
that would result in a highly varying amount of processing
time(e.g. Fig. 8) where it would be better to synchronise
using mutexes and condition variables to prevent the case
where threads will still use exclusive resources when
the timer has already finished for cases that we cannot
predict the execution time needed by the thread to finish.
Self Grade for Number 10: 4
11. Programs tend to perform many I/O operations over
time. We have several methods to maximize CPU utilization
and user experience with I/O, namely, signal-driven I/O,
multithreading, and spawning multiple processes. When is it
best to make use of signal-driven I/O? When is it best to make
use of multithreading? When is it best to make use of multiple
processes? Provide a real-world usage example for each case.
Signal driven I/O is used to handle asynchronous
events where the kernel sends a signal when something
happens to a file descriptor. It is best used for system
timers, keyboards, mice, controllers. Multithreading is
best used for program has mutually independent tasks.
It can improve the program with the introduction of
parallelism. Examples of use cases would be for really
long computational functions that would be optimized
for multithreading or local two player games. Spawning
multiple processes allows better throughput since it takes
advantage of multiple cores, with the cost of using separate
memory space. An example for this case would be a web
browser, where a tab can be treated as a new separate process.
Self Grade for Number 11: 4
R EFERENCES
[1] ArchWiki, “Category:Boot loaders - ArchWiki,” [Online]. Available:
https://wiki.archlinux.org/index.php/Category:Boot loader [Accessed 20
Sep. 2018].
[2] TutorialsPoint, “Types of Operating System,” [Online]. Available:
https://www.tutorialspoint.com/operating system/os types.htm
[Accessed 26 Sep. 2018].
[3] TeachICT, “Category:Boot loaders - ArchWiki,”
[Online]. Available: http://www.teach-ict.com/
as a2 ict new/ocr/A2 G063/332 designing systems/operating systems/
miniweb/index.htm [Accessed 26 Sep. 2018].
[4] M.F. Wani, “What are some real world uses of mmap() Linux system
call?,” [Online]. Available: https://www.quora.com/What-are-some-real-
world-uses-of-mmap-Linux-system-call [Accessed 25 Sep. 2018].
[5] Shichao’s Notes, “Chapter 6.Kernel Data Structures,” [Online].
Available: https://notes.shichao.io/lkd/ch6/#chapter-6-kernel-data-
structures [Accessed 21 Sep. 2018].
[6] K-State, “Blocking and Nonblocking I/O,” [Online]. Available:
http://faculty.salina.k-state.edu/tim/ossg/Device/blocking.html
[Accessed 26 Sep. 2018].
[7] A. Gargi, A. Mujeeb, “Why does the Linux kernel define a lot of
macros?,” [Online]. Available: https://www.quora.com/Why-does-the-
Linux-kernel-define-a-lot-of-macros [Accessed 26 Sep. 2018].
[8] B.P. Singh, “Linux kernel Macros and their meaning,” [On-
line]. Available: https://www.linkedin.com/pulse/linux-kernel-macros-
meaning-bhanu-prakash-singh [Accessed 26 Sep. 2018].