Soma-notes - User contributions [en]

Operating Systems 2017F: Assignment 2

2017-10-18T02:44:10Z

Jean: /* Questions */

'''This assignment is not yet finalized.'''

Please submit the answers to the following questions via CULearn by 11:55 PM on Thursday, October 26, 2017. There are ?? points in ?? questions.

Submit your answers as a single text file named "<username>-comp3000-assign2.txt" (where username is your MyCarletonOne username). The first four lines of this file should be "COMP 3000 Assignment 2", your name, student number, and the date of submission. You may wish to format your answers in Markdown to improve their appearance.

No other formats will be accepted. Submitting in another format will likely result in your assignment not being graded and you receiving no marks for this assignment. In particular do not submit an MS Word or OpenOffice file as your answers document!

Don't forget to include what outside resources you used to complete each of your answers, including other students, man pages, and web resources. You do not need to list help from the instructor, TA, or information found in the textbook.

==Questions==

# [2] How could you modify 3000test.c so it can report on whether two device files are equal without actually accessing the underlying devices? Specify the changes you would make to 3000test.c rather than doing this from scratch.
# [2] Does the MAP_SHARED flag on line 60 of 3000test.c (inside the call to mmap) make a significant difference in its execution? Specifically, what happens when you remove it or changed it to MAP_PRIVATE? Why?
# [1] Why does a different version of stat(), lstat(), exist that treats symbolic links differently? Why isn't a different version needed for hard links?

Operating Systems 2017F: Tutorial 4

2017-10-15T22:02:09Z

Jean: /* 3000random.c */

'''This tutorial is not yet finalized.'''

In this tutorial you will be experimenting with and extending [http://homeostasis.scs.carleton.ca/~soma/os-2017f/code/tut4/3000pc.c 3000pc.c] and [http://homeostasis.scs.carleton.ca/~soma/os-2017f/code/tut4/3000random.c 3000random.c] (both listed below).

==Tasks/Questions==

# Compile and run 3000pc.c. Note that you'll need to add a "-pthread" option to your compile command. First run it with a -1 for both delay intervals, then try other values. When does the producer signal the consumer? When does the consumer signal the producer?
# How can you output the random words to a file so that you only see the signal messages on the console?
# Modify the producer so that it never unlocks each entry (but does lock it). What happens?
# Modify the consumer so that it never unlocks each entry (but does lock it). What happens?
# What happens if you remove all entry locking/unlocking? How does the behavior change?
# Remove the SIGUSR1 signal handler from the producer (so it uses the C library default signal handler). How does the program behave?
# Remove the SIGUSR1 signal handler from the consumer (so it uses the C library default signal handler). How does the program behave?
# Change the producer and consumer so they only sleep for 1000 nanoseconds (1 millisecond) rather than 1 second during each delay interval. How does the behavior of the program change?
# Compile and run 3000random.c. Note that it takes two arguments. Where does this program get its random numbers from?
# Change 3000random.c to use /dev/random rather than /dev/urandom. How does its performance change, especially when generating a large number of random numbers?
# Change 3000pc.c to use random numbers from /dev/urandom rather than using the standard library function random(). How does this change affect the relative speed of the producer and consumer processes?
# '''(Bonus)''' Modify 3000pc.c so it takes in an additional command line argument that is the filename of a word list. This file should have one word per line. The program should then use this read-in word list rather than the hard coded word list. Pay attention to:
#* where you read the file (in the producer, consumer, or before the fork)
#* where and how you store the words in memory (the word list should be arbitrarily long, but the maximum length of a word can be fixed)
# '''(Bonus)''' Modify 3000pc.c so that it has multiple producers and consumers running concurrently, with the number of each specified on the command line.

==Code==

===3000pc.c===
<source lang="c" line>
/* 3000pc.c */
/* producer-consumer example using signals, processes and mmap */
/* v1 Oct. 15, 2017 */
/* Licenced under the GPLv3, copyright Anil Somayaji */
/* You really shouldn't be incorporating parts of this in any other code,
it is meant for teaching, not production */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <semaphore.h>
#include <string.h>
#include <time.h>

#define QUEUESIZE 32
#define WORDSIZE 16

const int wordlist_size = 27;
const char *wordlist[] = {
"Alpha",
"Bravo",
"Charlie",
"Delta",
"Echo",
"Foxtrot",
"Golf",
"Hotel",
"India",
"Juliet",
"Kilo",
"Lima",
"Mike",
"November",
"Oscar",
"Papa",
"Quebec",
"Romeo",
"Sierra",
"Tango",
"Uniform",
"Victor",
"Whiskey",
"X-ray",
"Yankee",
"Zulu",
"Dash"
};

typedef struct entry {
char word[WORDSIZE];
sem_t lock;
} entry;

typedef struct shared {
int prod_waiting;
int con_waiting;
entry queue[QUEUESIZE];
int last_produced;
int last_consumed;
pid_t prod_pid;
pid_t con_pid;
int prod_count;
int con_count;
} shared;

void report_error(char *error)
{
fprintf(stderr, "Error: %s\n", error);
}

void usage_exit(char *progname)
{
fprintf(stderr,
"Usage: %s <event count> <prod delay int> <con delay int>\n",
progname);
exit(-1);
}

void producer_handler(int the_signal)
{
if (the_signal == SIGUSR1) {
fprintf(stderr, "Producer received SIGUSR1.\n");
return;

} else {
fprintf(stderr, "Producer: No handler for for signal %d?!\n",
the_signal);
return;
}
}

void consumer_handler(int the_signal)
{
if (the_signal == SIGUSR1) {
fprintf(stderr, "Consumer received SIGUSR1.\n");
return;
} else {
fprintf(stderr, "Consumer: No handler for for signal %d?!\n",
the_signal);
return;
}
}

void pick_word(char *word)
{
int pick;

pick = random() % wordlist_size;

strcpy(word, wordlist[pick]);
}

void wait_for_producer(shared *s)
{
struct timespec delay;

delay.tv_sec = 100;
delay.tv_nsec = 0;

s->con_waiting = 1;

while (s->con_waiting) {
nanosleep(&delay, NULL);
}
}

void wait_for_consumer(shared *s)
{
struct timespec delay;

delay.tv_sec = 100;
delay.tv_nsec = 0;

s->prod_waiting = 1;

while (s->prod_waiting) {
nanosleep(&delay, NULL);
}
}

void wakeup_consumer(shared *s)
{
if (s->con_waiting) {
s->con_waiting = 0;
kill(s->con_pid, SIGUSR1);
}
}

void wakeup_producer(shared *s)
{
if (s->prod_waiting) {
s->prod_waiting = 0;
kill(s->prod_pid, SIGUSR1);
}
}

void output_word(int c, char *w)
{
printf("Word %d: %s\n", c, w);
}

int queue_word(char *word, shared *s)
{
entry *e;
int current, retval;

current = (s->last_produced + 1) % QUEUESIZE;

e = &s->queue[current];

sem_wait(&e->lock);

if (e->word[0] != '\0') {
/* consumer hasn't consumed this entry yet */
sem_post(&e->lock);
wait_for_consumer(s);
sem_wait(&e->lock);
}

if (e->word[0] != '\0') {
fprintf(stderr, "ERROR: No room for producer after waiting!\n");
retval = -1;
goto done;
} else {
strncpy(e->word, word, WORDSIZE);
s->last_produced = current;
s->prod_count++;
wakeup_consumer(s);
retval = 0;
goto done;
}

done:
sem_post(&e->lock);
return retval;
}

int get_next_word(char *word, shared *s)
{
entry *e;
int current, retval;

current = (s->last_consumed + 1) % QUEUESIZE;

e = &s->queue[current];

sem_wait(&e->lock);

if (e->word[0] == '\0') {
/* producer hasn't filled in this entry yet */
sem_post(&e->lock);
wait_for_producer(s);
sem_wait(&e->lock);
}

if (e->word[0] == '\0') {
fprintf(stderr, "ERROR: Nothing for consumer after waiting!\n");
retval = -1;
goto done;
} else {
strncpy(word, e->word, WORDSIZE);
e->word[0] = '\0';
s->last_consumed = current;
s->con_count++;
wakeup_producer(s);
retval = 0;
goto done;
}

done:
sem_post(&e->lock);
return retval;
}

void producer(shared *s, int event_count, int producer_delay_interval)
{
char word[WORDSIZE];
int i;
struct sigaction signal_handler_struct;

memset (&signal_handler_struct, 0, sizeof(signal_handler_struct));
signal_handler_struct.sa_handler = producer_handler;

if (sigaction(SIGUSR1, &signal_handler_struct, NULL)) {
fprintf(stderr, "Producer couldn't register SIGUSR1 handler.\n");
}

for (i=0; i < event_count; i++) {
pick_word(word);
queue_word(word, s);
if (producer_delay_interval > 0) {
if (i % producer_delay_interval == 0) {
sleep(1);
}
}
}

printf("Producer finished.\n");
exit(0);
}

void consumer(shared *s, int event_count, int consumer_delay_interval)
{
char word[WORDSIZE];
int i;
struct sigaction signal_handler_struct;

memset (&signal_handler_struct, 0, sizeof(signal_handler_struct));
signal_handler_struct.sa_handler = consumer_handler;

if (sigaction(SIGUSR1, &signal_handler_struct, NULL)) {
fprintf(stderr, "Consumer couldn't register SIGUSR1 handler.\n");
}

for (i=0; i < event_count; i++) {
get_next_word(word, s);
output_word(s->con_count, word);
if (consumer_delay_interval > 0) {
if (i % consumer_delay_interval == 0) {
sleep(1);
}
}
}

printf("Consumer finished.\n");
exit(0);
}

void init_shared(shared *s)
{
int i;

s->con_waiting = 0;
s->last_consumed = -1;

s->prod_waiting = 0;
s->last_produced = -1;

s->prod_pid = -1;
s->con_pid = -1;

s->prod_count = 0;
s->con_count = 0;

for (i=0; i<QUEUESIZE; i++) {
s->queue[i].word[0] = '\0';
/* semaphore is shared between processes,
and initial value is 1 (unlocked) */
sem_init(&s->queue[i].lock, 1, 1);
}
}

int main(int argc, char *argv[])
{
int pid, count, prod_interval, con_interval;

shared *s;

srandom(42);

if (argc < 4) {
if (argc < 1) {
report_error("no command line");
usage_exit(argv[0]);
} else {
report_error("Not enough arguments");
usage_exit(argv[0]);
}
}

count = atoi(argv[1]);
prod_interval = atoi(argv[2]);
con_interval = atoi(argv[3]);

s = (shared *) mmap(NULL, sizeof(shared),
PROT_READ|PROT_WRITE,
MAP_SHARED|MAP_ANONYMOUS, -1, 0);

if (s == MAP_FAILED) {
report_error(strerror(errno));
}

init_shared(s);

pid = fork();

if (pid) {
/* producer */
s->prod_pid = getpid();
producer(s, count, prod_interval);
} else {
/* consumer */
s->con_pid = getpid();
consumer(s, count, con_interval);
}

/* This line should never be reached */
return -1;
}
</source>

===3000random.c===

<source lang="c" line>
/* 3000random.c */
/* prints out random numbers obtained from system /dev/urandom */
/* (This is much, much better than using rand() or random())! */
/* v1 Oct. 15, 2017 */
/* Licenced under the GPLv3, copyright Anil Somayaji */
/* You really shouldn't be incorporating parts of this in any other code,
it is meant for teaching, not production */

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>

#define BUFSIZE 1024

typedef struct rand_state {
unsigned long buffer[BUFSIZE];
int current;
int fd;
} rand_state;

void fill_rand_buffer(rand_state *r)
{
ssize_t count;

count = read(r->fd, (void *) &r->buffer,
BUFSIZE * sizeof(unsigned long));

if (count > sizeof(unsigned long)) {
r->current = count % sizeof(unsigned long);
} else {
fprintf(stderr, "Couldn't fill random buffer.\n");
}
}

void system_rand_init(rand_state *r)
{
r->fd = open("/dev/urandom", O_RDONLY);

fill_rand_buffer(r);
}

long system_rand(long max, rand_state *r)
{
unsigned long val;

if (r->current < 0) {
fill_rand_buffer(r);
if (r->current < 0) {
/* fill_rand_buffer should have already
reported an error */
return 0;
}
}

val = r->buffer[r->current];
r->current--;
return val % max;
}

int main(int argc, char *argv[])
{
int count, i;
long max, x;
rand_state r;

if (argc != 3) {
fprintf(stderr, "Usage: %s <count> <max>\n", argv[0]);
exit(-1);
}

count = atoi(argv[1]);
max = atol(argv[2]);

printf("count = %d, max = %ld\n", count, max);

system_rand_init(&r);

for (i = 0; i < count; i++) {
x = system_rand(max, &r);
printf("%ld\n", x);
}

return 0;
}
</source>

Operating Systems (Fall 2017) Course Outline

2017-09-18T14:46:22Z

Jean:

==Course Information==

*'''Course Number:''' COMP 3000
*'''Term:''' Fall 2017
*'''Title:''' Operating Systems
*'''Institution:''' Carleton University, School of Computer Science
*'''Instructor:''' [http://people.scs.carleton.ca/~soma Anil Somayaji] (anil.somayaji at carleton.ca): Mon., Wed. 2:30-3:30 PM in HP 5137
*'''Teaching Assistants:''' (office hours in TBD) Jean-Elie Jean-Gilles (jeaneliejeangilles at cmail.carleton.ca): Tuesday and Thursday 2:30-3:30 PM 
*'''Lectures:''' Tues. and Thurs. 1:05-2:25 PM in AT 102
*'''Tutorials (in HP 4155):''' Monday 11:35-12:55 PM Monday 1:05-2:25 PM Wednesday 8:35-9:55 AM
*'''Course Website''': http://homeostasis.scs.carleton.ca/wiki/index.php/Operating_Systems_%28Fall_2017%29

==Official Course Description==

Operating system implementation course stressing fundamental issues in design and how they relate to modern computer architectures. Assignments involve the modification and extension of a multitasking operating system.

==Learning Outcomes==

By the end of this course, students should:
* be able to write C code that uses low-level Linux services and should be able to implement simple Linux kernel extensions (modules),
* have a strong conceptual model of how an operating system works that allows them to determine the relative role of application and operating system code when debugging software, and
* understand the basic use and architecture of virtual-machine based cloud architectures.

Note that in order to achieve these objectives students should have come into this course with a strong background in C programming and general application development.

==Grading==

The marking scheme for this course is:

* 20% for tutorial participation
* 20% for the assignments
* 25% for the midterm on November 2 (Thursday) during class
* 35% for the final exam (date TBA)

I also calculate grades using alternative marking schemes at the end of the semester, assigning the highest grade for each student from any of the marking schemes. Thus your final grade may be higher than might be suggested by strict following of the above scheme.

==Communication==

This wiki page is the canonical source of information on this course. Please refer to it for updates. When significant changes are made to this document it will be either announced in lecture and/or posted in the course discussion forum.

Course discussions will be on [https://culearn.carleton.ca cuLearn]. While you may discuss assignments there, do not post outright answers to them. You may post in either the Questions and Answers forum or the General Discussion forum.

You may get an account on class wiki so you can edit content there. Email Prof. Somayaji to get one with your preferred username and email address to which a password should be sent. (Note this is not a requirement.)

==Collaboration==

Collaboration on all work is allowed except for the two tests. Collaboration, however, should be clearly acknowledged.

For assignments, while you may get help from others and even collaboratively solve technical problems, the code and answers submitted should all be your own work. For example, you may not divide an assignment into parts, give a part to another student or anyone else to solve, and then submit that work as your own. You have to have participated in the creation of every part of your submitted work. An easy way to make sure this happens is never share files regarding coursework or copy and paste answers into email. Instead, meet together to work on an assignment and then separate to write up your solutions.

The final project may be a group project, but again there it should be clearly documented what contribution was made by each group member.

Similarity between submitted assignments and projects that has not been appropriately documented will be treated as plagiarism - the same as copying on a midterm or a final - and will be submitted to the Dean for disciplinary action.

==Course Notes/Multimedia==

Audio and sometimes video from lectures will be available via the [[Operating Systems (Fall 2017)|lecture pages on the main course website]]. These same pages will also contain notes.

Do not rely upon the lectures and notes to cover all material related to this class. You are expected to keep up with the assigned textbook readings and material covered in the tutorials.

==Required Textbooks==

The course will be using the textbook [http://pages.cs.wisc.edu/~remzi/OSTEP/ Operating Systems: Three Easy Pieces]. The chapters of this textbook are available for free online; you can also buy a full epub, PDF, or paper copy if you wish.

Individual chapters will be linked with the lectures associated with them. You should plan on reading the assigned chapters '''before''' coming to class, as the material in lectures will be easier to understand then. The lectures are designed to supplement the textbook, not replace them.

==Course Software==

In this course we will primarily working with [http://www.lubuntu.net/ Lubuntu], a low-resource variant of [http://www.ubuntu.com/ Ubuntu] Linux distribution. You may use other Linux distributions in the tutorials to complete the assigned work; there will be differences, however, in some aspects (such as installing software), particularly if you use a distribution not based on Ubuntu or Debian.

==University Policies & Resources==

===Undergraduate Academic Advisor===

The undergraduate advisor for the School of Computer Science is available in Room
5302C HP, by telephone at 520-2600, ext. 4364 or by email at
undergraduate_advisor@scs.carleton.ca. The advisor can assist with information about
prerequisites and preclusions, course substitutions/equivalencies, understanding your
academic audit and the remaining requirements for graduation. The undergraduate
advisor will also refer students to appropriate resources such as the Science Student
Success Centre, Learning Support Services and the Writing Tutorial Services.

===Student Academic Integrity Policy===

Every student should be familiar with the Carleton University student academic integrity policy. A student found in violation of academic integrity standards may be awarded penalties which range from a reprimand to receiving a grade of F in the course or even being expelled from the program or University. Some examples of offences are: plagiarism and unauthorized co-operation or collaboration. Information on this policy may be found in the Undergraduate Calendar.

===Plagiarism===

As defined by Senate, "plagiarism is presenting, whether intentional or not, the ideas, expression of ideas or work of others as one's own". Such reported offences will be reviewed by the office of the Dean of Science.

===Unauthorized Co-operation or Collaboration===

Senate policy states that "to ensure fairness and equity in assessment of term work, students shall not co-operate or collaborate in the completion of an academic assignment, in whole or in part, when the instructor has indicated that the assignment is to be completed on an individual basis".

Please see above for the specific collaboration policy for this course.

===Academic Accommodations for Students with Disabilities===

The Paul Menton Centre for Students with Disabilities (PMC) provides services to students with Learning Disabilities (LD), psychiatric/mental health disabilities, Attention Deficit Hyperactivity Disorder (ADHD), Autism Spectrum Disorders (ASD), chronic medical conditions, and impairments in mobility, hearing, and vision. If you have a disability requiring academic accommodations in this course, please contact PMC at 613-520-6608 or pmc@carleton.ca for a formal evaluation. If you are already registered with the PMC, contact your PMC coordinator to send me your Letter of Accommodation at the beginning of the term, and no later than two weeks before the first in-class scheduled test or exam requiring accommodation (if applicable). After requesting accommodation from PMC, meet with me to ensure accommodation arrangements are made. Please consult the PMC website for the deadline to request accommodations for the formally-scheduled exam (if applicable) at https://www.carleton.ca/pmc/new-and-current-students/dates-and-deadlines

===Religious Obligation===

Write to the instructor with any requests for academic accommodation during the first two weeks of class, or as soon as possible after the need for accommodation is known to exist. For more details visit the Equity Services website: https://www.carleton.ca/equity/

===Pregnancy Obligation===

Write to the instructor with any requests for academic accommodation during the first two weeks of class, or as soon as possible after the need for accommodation is known to exist. For more details visit the Equity Services website: https://www.carleton.ca/equity/

===Medical Certificate===

The following is a link to the official medical certificate accepted by Carleton University for the deferral of final examinations or assignments in undergraduate courses. To access the form, please go to https://www.carleton.ca/registrar/forms