#ifdef SYNCH

The DEFINES variable in the Makefile should be modified as:

DEFINES = -DTHREADS -DSYNCH

The intention is that if you choose to not specify the -DSYNCH flag in the makefile, nachos should behave as it did when you first copied it.

Remember: Properly synchronized code should work no matter what order the scheduler chooses to run the threads on the ready list. In other words, we should be able to put a call to Thread::Yield() anywhere in your code, where interrupts are enabled, without changing the correctness of your code. To aid you in this, code linked with nachos will cause Thread::Yield() to be called on your behalf in a repeatable but unpredictatble way. Nachos code is repeatable in that if you call it repeatedly with the same arguments, it will do exactly the same thing each time. However, if you invoke nachos -rs #, with a different number each time, calls to Thread::Yield() will be inserted at different places in the code. Make sure that your code can handle context switches in an unpredictable manner (not just when Thread::Yield() is called explicitly). Further, it would also help a lot if you get familiarized with other command line options of nachos. A useful description of those options is provided in main.cc.

Problem 1

Problem 2

Problem 3

#include "system.h"
#include "synch.h"

int value;

void Increment(int delta)
{
  int i=0;

  int read_value;
  int write_value;

  for (;i<5;i++)
    {
      
      read_value = value;
      printf("%s read value:%d\n",currentThread->getName(),read_value);
      write_value = read_value + delta;

      currentThread->Yield();

      value = write_value;
      printf("%s wrote value:%d\n",currentThread->getName(),write_value);
      currentThread->Yield();
    }

  printf("%s saw final value:%d\n",currentThread->getName(),value);
}

void ThreadTest()
{
    value=0;

    Thread *t1 = new Thread("thread 1");
    Thread *t2 = new Thread("thread 2");
    Thread *t3 = new Thread("thread 3");

    t1->Fork(Increment, 1);
    t2->Fork(Increment, 2);
    t3->Fork(Increment, 3);
}

Problem 4

#include "copyright.h"
#include "system.h"
#include "synch.h"

#define STORAGE 5
#define MAXVAL 10


int array[STORAGE];
int read_head=0, write_head=0;
Semaphore *s;
int consumer_has_work=0;

void Produce(int dummy)
{
  static int data=1;
  int i=0;

  s->P();

  for (;i < MAXVAL;i++)
    {
      while ((write_head==read_head) && consumer_has_work)
	  currentThread->Yield();

      DEBUG('p',"in producer: read head:%d write head: %d\n",read_head,
	    write_head);

      array[write_head]=data++;
      write_head= (write_head+1)%STORAGE;
      
      consumer_has_work=1;
    }
  s->V();

}

void Consume(int dummy)
{

  int data;

  s->P();

  while (1)
    {
      while (consumer_has_work)
	{
	  DEBUG('p',"in consumer: read head:%d write head: %d\n",read_head,
		write_head);
	  
	  data=array[read_head];
	  read_head=(read_head+1)%STORAGE;
	  
	  printf("output:%d\n",data*data);
	  
	  if (data==MAXVAL)
	    return;

	  if (read_head==write_head)
	    consumer_has_work=0;
	}

      currentThread->Yield();
    }
  s->V();
}  
  
void ThreadTest()
{
    DEBUG('t', "Entering SimpleTest");

    Thread *t1 = new Thread("forked thread 1");
    Thread *t2 = new Thread("forked thread 2");

    s=new Semaphore("mutex",1);

    t2->Fork(Consume, 2);
    t1->Fork(Produce, 1);
}

Part a:

Part b:

Problem 5

Problem 6

Part a: the votes are static and each thread votes the same way independent of the motion. Assign the following names to the threads: "1", "2", "3", "4", "5", "6". The threads with odd numbered identifiers vote FOR the motion and threads with even numbered identifiers vote AGAINST the motion.

Part b: each thread votes randomly on each motion. You can use rand() to obtain a random integer ('man rand' will tell you more).

The code for these versions is to be left in VOTE1.cc and VOTE2.cc respectively. Your code must work when run using nachos -rs.