pintos-doxygen/html/priority-fifo_8c_source.html

/** Creates several threads all at the same priority and ensures

   that they consistently run in the same round-robin order.


   Based on a test originally submitted for Stanford's CS 140 in

   winter 1999 by by Matt Franklin

   <startled@leland.stanford.edu>, Greg Hutchins

   <gmh@leland.stanford.edu>, Yu Ping Hu <yph@cs.stanford.edu>.

   Modified by arens. */


#include <stdio.h>

#include "tests/threads/tests.h"

#include "threads/init.h"

#include "devices/timer.h"

#include "threads/malloc.h"

#include "threads/synch.h"

#include "threads/thread.h"


struct simple_thread_data

  {

    int id;                     /**< Sleeper ID. */

    int iterations;             /**< Iterations so far. */

    struct lock *lock;          /**< Lock on output. */

    int **op;                   /**< Output buffer position. */

  };


#define THREAD_CNT 16

#define ITER_CNT 16


static thread_func simple_thread_func;


void

test_priority_fifo (void)

{

  struct simple_thread_data data[THREAD_CNT];

  struct lock lock;

  int *output, *op;

  int i, cnt;


  /* This test does not work with the MLFQS. */

  ASSERT (!thread_mlfqs);


  /* Make sure our priority is the default. */

  ASSERT (thread_get_priority () == PRI_DEFAULT);


  msg ("%d threads will iterate %d times in the same order each time.",

       THREAD_CNT, ITER_CNT);

  msg ("If the order varies then there is a bug.");


  output = op = malloc (sizeof *output * THREAD_CNT * ITER_CNT * 2);

  ASSERT (output != NULL);

  lock_init (&lock);


  thread_set_priority (PRI_DEFAULT + 2);

  for (i = 0; i < THREAD_CNT; i++)

    {

      char name[16];

      struct simple_thread_data *d = data + i;

      snprintf (name, sizeof name, "%d", i);

      d->id = i;

      d->iterations = 0;

      d->lock = &lock;

      d->op = &op;

      thread_create (name, PRI_DEFAULT + 1, simple_thread_func, d);

    }


  thread_set_priority (PRI_DEFAULT);

  /* All the other threads now run to termination here. */

  ASSERT (lock.holder == NULL);


  cnt = 0;

  for (; output < op; output++)

    {

      struct simple_thread_data *d;


      ASSERT (*output >= 0 && *output < THREAD_CNT);

      d = data + *output;

      if (cnt % THREAD_CNT == 0)

        printf ("(priority-fifo) iteration:");

      printf (" %d", d->id);

      if (++cnt % THREAD_CNT == 0)

        printf ("\n");

      d->iterations++;

    }

}


static void

simple_thread_func (void *data_)

{

  struct simple_thread_data *data = data_;

  int i;


  for (i = 0; i < ITER_CNT; i++)

    {

      lock_acquire (data->lock);

      *(*data->op)++ = data->id;

      lock_release (data->lock);

      thread_yield ();

    }

}

ASSERT
#define ASSERT(CONDITION)
This is outside the header guard so that debug.h may be included multiple times with different settin...
Definition: debug.h:31

init.h

name
char * name[]
Definition: insult.c:47

snprintf
int snprintf(char *buffer, size_t buf_size, const char *format,...)
Like printf(), except that output is stored into BUFFER, which must have space for BUF_SIZE character...
Definition: stdio.c:62

printf
int printf(const char *format,...)
Writes formatted output to the console.
Definition: stdio.c:79

msg
void msg(const char *format,...)
Definition: lib.c:28

malloc
void * malloc(size_t size)
Obtains and returns a new block of at least SIZE bytes.
Definition: malloc.c:90

malloc.h

lock
static struct lock lock
Definition: priority-condvar.c:13

simple_thread_func
static thread_func simple_thread_func
Definition: priority-fifo.c:29

THREAD_CNT
#define THREAD_CNT
Definition: priority-fifo.c:26

test_priority_fifo
void test_priority_fifo(void)
Definition: priority-fifo.c:32

ITER_CNT
#define ITER_CNT
Definition: priority-fifo.c:27

NULL
#define NULL
Definition: stddef.h:4

lock
Lock.
Definition: synch.h:22

lock::holder
struct thread * holder
Thread holding lock (for debugging).
Definition: synch.h:23

simple_thread_data
Creates several threads all at the same priority and ensures that they consistently run in the same r...
Definition: priority-fifo.c:19

simple_thread_data::op
int ** op
Output buffer position.
Definition: priority-fifo.c:23

simple_thread_data::iterations
int iterations
Iterations so far.
Definition: priority-fifo.c:21

simple_thread_data::lock
struct lock * lock
Lock on output.
Definition: priority-fifo.c:22

simple_thread_data::id
int id
Sleeper ID.
Definition: priority-fifo.c:20

lock_release
void lock_release(struct lock *lock)
Releases LOCK, which must be owned by the current thread.
Definition: synch.c:229

lock_init
void lock_init(struct lock *lock)
Initializes LOCK.
Definition: synch.c:176

lock_acquire
void lock_acquire(struct lock *lock)
Acquires LOCK, sleeping until it becomes available if necessary.
Definition: synch.c:193

synch.h

tests.h

thread_mlfqs
bool thread_mlfqs
If false (default), use round-robin scheduler.
Definition: thread.c:60

thread_get_priority
int thread_get_priority(void)
Returns the current thread's priority.
Definition: thread.c:343

thread_create
tid_t thread_create(const char *name, int priority, thread_func *function, void *aux)
Creates a new kernel thread named NAME with the given initial PRIORITY, which executes FUNCTION passi...
Definition: thread.c:166

thread_set_priority
void thread_set_priority(int new_priority)
Sets the current thread's priority to NEW_PRIORITY.
Definition: thread.c:336

thread_yield
void thread_yield(void)
Yields the CPU.
Definition: thread.c:302

thread.h

PRI_DEFAULT
#define PRI_DEFAULT
Default priority.
Definition: thread.h:24

thread_func
void thread_func(void *aux)
Definition: thread.h:116

timer.h