Politecnico di Milano FACOLTÀ DI INGEGNERIA DELL INFORMAZIONE. Advanced Operating Systems A.A Exam date: 18 December 2014

Transcription

1 Politecnico di Milano FACOLTÀ DI INGEGNERIA DELL INFORMAZIONE Advanced Operating Systems A.A Exam date: 18 December 2014 Prof. William FORNACIARI Surname (readable)... Matr... Name (readable)... Signature... Q1 Q2 Q3 TOT NOTES It is forbidden to refer to texts or notes of any kind as well as interact with their neighbors. Anyone found in possession of documents relating to the course, although not directly relevant to the subject of the examination will cancel the test. It is not allowed to leave during the first half hour, the task must still be returned, even if it is withdrawn. The presence of the writing (not delivered) implies the renunciation of any previous ratings. Question Q1 Describe the main algorithms for the scheduling of a single-core CPU, paying particular attention to the possible overhead, fairness and reactivity. Question Q2 Consider the following multithreaded C program. 1) Describe the program flow from start to finish detailing the synchronizations that happen between the threads. Write what the program prints on the standard output. 2) Write the modifications that need to be performed to the code to have two consumers reading from the queue instead of one. It is not required to rewrite the entire program, just detail the source lines that need to be added and/or modified. 3) (optional, for one additional point) There is a deadlock in the program, find it. #include <stdio.h> 1/12

2 #include <stdlib.h> #include <pthread.h> #include <unistd.h> struct List char *str; struct List *next; ; pthread_mutex_t mutex=pthread_mutex_initializer; pthread_cond_t cond=pthread_cond_initializer; struct List *head=null; struct List *tail=null; int numitems=0; const int maxitems=3; void *thread(void *arg) for(;;) pthread_mutex_lock(&mutex); while(numitems==0) pthread_cond_wait(&cond,&mutex); char *s=head >str; struct List *temp=head; head=head >next; free(temp); if(numitems==maxitems) pthread_cond_signal(&cond); numitems ; pthread_mutex_unlock(&mutex); printf("%s\n",s); free(s); sleep(1); int main() pthread_t t; pthread_create(&t,null,thread,null); int i; for(i=0;i<5;i++) struct List *l=(struct List*)malloc(sizeof(struct List)); char *s=(char*)malloc(64); l >str=s; l >next=null; static const char tab[]="ohib"; sprintf(s,"%c %d",tab[i & 0x3], i*2 1); pthread_mutex_lock(&mutex); while(numitems==maxitems) pthread_cond_wait(&cond,&mutex); if(head==null) head=l; tail=l; else tail >next=l; tail=l; if(numitems==0) pthread_cond_signal(&cond); numitems++; pthread_mutex_unlock(&mutex); pthread_join(t,null); 2/12

3 1) The program is a producer-consumer with a FIFO buffer of strings between the threads implemented using a C singly linked list. When main starts it creates the consumer thread, while main itself is the producer. The producer inserts strings into the tail of the FIFO, stopping if the number of elements reaches 3. The consumer blocks every time the FIFO is empty, otherwise consumes an item from the head of the list, and prints it on the standard output. The program prints: o 1 h 1 i 3 b 5 o 7 2) In main it is necessary to create the second thread: pthread_t t1,t2; pthread_create(&t1,null,thread,null); pthread_create(&t2,null,thread,null); in addition, the lines pthread_cond_signal(&cond); need to be changed to pthread_cond_broadcast(&cond); otherwise the consumer runs the risk of waking up the other consumer instead of the producer, resulting in a deadlock. 3) The consumer never ends. Thus, main will block on the pthread_join and never return. 3/12

4 Question Q3 Consider the following fragment of an hypothetical datasheet which describes some registers of a UART peripheral. Bit access modes: u = undefined, writing has no effect, reading returns zero r = read-only bit, software writes are ignored rw = software reading and writing is allowed r-c1 = read and clear by writing 1 UART_CS: Address: 0x , Initial value upon reset: 0x0000 B16 OR RXNE TXE EN u u u u u u u u u u u rw rc-1 r r rw B16: If set to 1, a 16-bit data transmission/reception is enabled, otherwise the peripheral operates in 8 bit mode. In the latter case, bits from 8 to 15 in UART_TX and UART_RX are undefined. OR: Overrun flag. If the bit is set to 1, a new data has been received while the RXNE bit is 1. This signal a data loss. RXNE: if this bit is set to 1, the receiver register is not empty, so there is data that can be read. TXE: if the bit is 1, the transmission register is empty, so data can be written into it. EN: if this bit is 0, the peripheral is powered down. The bit needs to be 1 to utilize the peripheral. UART_TX: Address: 0x , Initial value upon reset: undefined Write into this register the data to transmit. w w w w w w w w w w w w w w w w UART_RX: Address: 0x , Initial value upon reset: 0x0000 Read received data. r r r r r r r r r r r r r r r r You are required to: 1. Write a data structure (namely UART_Struct) and a macro (namely UART) which could be used to access these peripheral registers, by a C/C++ coded program, using a syntax similar to UART->TX; 2. write a function void UART_Init(); to initialize the UART peripheral and make it ready to operate in 8 bit mode; 3. Write a function void UART_WriteStr(const char *data); that write a '\0'-terminated char string to the serial UART port; 4. Write a blocking function char UART_GetChar(); that returns a single char read from the serial UART port; 4/12

5 Solution: struct UART_Struct volatile unsigned short CS; 0x unsigned char padding1[14]; volatile unsigned short TX; 0x volatile unsigned short RX; 0x ; #define UART ((struct UART_Struct*)0x ) void UART_Init() UART->CS=1<<0; void UART_WriteStr(const char *data) while (*data!='\0') while ((UART->CS & (1<<1)) == 0); UART->TX=*data; data++; char UART_GetChar() while ((UART->CS & (1<<2)) == 0); return UART->RX; 5/12