src/tests/threads/Grading

 # Percentage of the testing point total designated for each set of
 # tests.
 
-20.0%	tests/threads/Rubric.alarm
-40.0%	tests/threads/Rubric.priority
-40.0%	tests/threads/Rubric.mlfqs
+30.0%	tests/threads/Rubric.alarm
+70.0%	tests/threads/Rubric.priority
+#40.0%	tests/threads/Rubric.mlfqs

src/tests/threads/Make.tests

@@ -7,9 +7,9 @@ alarm-negative priority-change priority-donate-one			\
 priority-donate-multiple priority-donate-multiple2			\
 priority-donate-nest priority-donate-sema priority-donate-lower		\
 priority-fifo priority-preempt priority-sema priority-condvar		\
-priority-donate-chain                                                   \
-mlfqs-load-1 mlfqs-load-60 mlfqs-load-avg mlfqs-recent-1 mlfqs-fair-2	\
-mlfqs-fair-20 mlfqs-nice-2 mlfqs-nice-10 mlfqs-block)
+priority-donate-chain)
+#mlfqs-load-1 mlfqs-load-60 mlfqs-load-avg mlfqs-recent-1 mlfqs-fair-2 \
+#mlfqs-fair-20 mlfqs-nice-2 mlfqs-nice-10 mlfqs-block)
 
 # Sources for tests.
 tests/threads_SRC  = tests/threads/tests.c

src/tests/userprog/sc-bad-sp.c

-/* Invokes a system call with the stack pointer (%esp) set to a
-   bad address.  The process must be terminated with -1 exit
-   code. 
-
-   For Project 3: The bad address lies approximately 64MB below
-   the code segment, so there is no ambiguity that this attempt
-   must be rejected even after stack growth is implemented.
-   Moreover, a good stack growth heuristics should probably not
-   grow the stack for the purpose of reading the system call
-   number and arguments. */
-
 #include "tests/lib.h"
 #include "tests/main.h"
 

src/tests/vm/Rubric.functionality

-Functionality of virtual memory subsystem:
-- Test stack growth.
-3	pt-grow-stack
-3	pt-grow-stk-sc
-3	pt-big-stk-obj
-3	pt-grow-pusha
-
-- Test paging behavior.
-3	page-linear
-3	page-parallel
-3	page-shuffle
-4	page-merge-seq
-4	page-merge-par
-4	page-merge-mm
-4	page-merge-stk
-
-- Test "mmap" system call.
-2	mmap-read
-2	mmap-write
-2	mmap-shuffle
-
-2	mmap-twice
-
-2	mmap-unmap
-1	mmap-exit
-
-3	mmap-clean
-
-2	mmap-close
-2	mmap-remove

src/tests/vm/Rubric.robustness

-Robustness of virtual memory subsystem:
-- Test robustness of page table support.
-2	pt-bad-addr
-3	pt-bad-read
-2	pt-write-code
-3	pt-write-code2
-4	pt-grow-bad
-
-- Test robustness of "mmap" system call.
-1	mmap-bad-fd
-1	mmap-inherit
-1	mmap-null
-1	mmap-zero
-
-2	mmap-misalign
-
-2	mmap-over-code
-2	mmap-over-data
-2	mmap-over-stk
-2	mmap-overlap
-

src/tests/vm/page-merge-mm.ck

-# -*- perl -*-
-use strict;
-use warnings;
-use tests::tests;
-check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
-(page-merge-mm) begin
-(page-merge-mm) init
-(page-merge-mm) sort chunk 0
-(page-merge-mm) sort chunk 1
-(page-merge-mm) sort chunk 2
-(page-merge-mm) sort chunk 3
-(page-merge-mm) sort chunk 4
-(page-merge-mm) sort chunk 5
-(page-merge-mm) sort chunk 6
-(page-merge-mm) sort chunk 7
-(page-merge-mm) wait for child 0
-(page-merge-mm) wait for child 1
-(page-merge-mm) wait for child 2
-(page-merge-mm) wait for child 3
-(page-merge-mm) wait for child 4
-(page-merge-mm) wait for child 5
-(page-merge-mm) wait for child 6
-(page-merge-mm) wait for child 7
-(page-merge-mm) merge
-(page-merge-mm) verify
-(page-merge-mm) success, buf_idx=1,048,576
-(page-merge-mm) end
-EOF
-pass;

src/tests/vm/page-merge-par.c

-#include "tests/main.h"
-#include "tests/vm/parallel-merge.h"
-
-void
-test_main (void) 
-{
-  parallel_merge ("child-sort", 123);
-}

src/tests/vm/page-merge-par.ck

-# -*- perl -*-
-use strict;
-use warnings;
-use tests::tests;
-check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
-(page-merge-par) begin
-(page-merge-par) init
-(page-merge-par) sort chunk 0
-(page-merge-par) sort chunk 1
-(page-merge-par) sort chunk 2
-(page-merge-par) sort chunk 3
-(page-merge-par) sort chunk 4
-(page-merge-par) sort chunk 5
-(page-merge-par) sort chunk 6
-(page-merge-par) sort chunk 7
-(page-merge-par) wait for child 0
-(page-merge-par) wait for child 1
-(page-merge-par) wait for child 2
-(page-merge-par) wait for child 3
-(page-merge-par) wait for child 4
-(page-merge-par) wait for child 5
-(page-merge-par) wait for child 6
-(page-merge-par) wait for child 7
-(page-merge-par) merge
-(page-merge-par) verify
-(page-merge-par) success, buf_idx=1,048,576
-(page-merge-par) end
-EOF
-pass;

src/tests/vm/page-merge-seq.c

-/* Generates about 1 MB of random data that is then divided into
-   16 chunks.  A separate subprocess sorts each chunk in
-   sequence.  Then we merge the chunks and verify that the result
-   is what it should be. */
-
-#include <syscall.h>
-#include "tests/arc4.h"
-#include "tests/lib.h"
-#include "tests/main.h"
-
-/* This is the max file size for an older version of the Pintos
-   file system that had 126 direct blocks each pointing to a
-   single disk sector.  We could raise it now. */
-#define CHUNK_SIZE (126 * 512)
-#define CHUNK_CNT 16                            /* Number of chunks. */
-#define DATA_SIZE (CHUNK_CNT * CHUNK_SIZE)      /* Buffer size. */
-
-unsigned char buf1[DATA_SIZE], buf2[DATA_SIZE];
-size_t histogram[256];
-
-/* Initialize buf1 with random data,
-   then count the number of instances of each value within it. */
-static void
-init (void) 
-{
-  struct arc4 arc4;
-  size_t i;
-
-  msg ("init");
-
-  arc4_init (&arc4, "foobar", 6);
-  arc4_crypt (&arc4, buf1, sizeof buf1);
-  for (i = 0; i < sizeof buf1; i++)
-    histogram[buf1[i]]++;
-}
-
-/* Sort each chunk of buf1 using a subprocess. */
-static void
-sort_chunks (void)
-{
-  size_t i;
-
-  create ("buffer", CHUNK_SIZE);
-  for (i = 0; i < CHUNK_CNT; i++) 
-    {
-      pid_t child;
-      int handle;
-
-      msg ("sort chunk %zu", i);
-
-      /* Write this chunk to a file. */
-      quiet = true;
-      CHECK ((handle = open ("buffer")) > 1, "open \"buffer\"");
-      write (handle, buf1 + CHUNK_SIZE * i, CHUNK_SIZE);
-      close (handle);
-
-      /* Sort with subprocess. */
-      CHECK ((child = exec ("child-sort buffer")) != -1,
-             "exec \"child-sort buffer\"");
-      CHECK (wait (child) == 123, "wait for child-sort");
-
-      /* Read chunk back from file. */
-      CHECK ((handle = open ("buffer")) > 1, "open \"buffer\"");
-      read (handle, buf1 + CHUNK_SIZE * i, CHUNK_SIZE);
-      close (handle);
-
-      quiet = false;
-    }
-}
-
-/* Merge the sorted chunks in buf1 into a fully sorted buf2. */
-static void
-merge (void) 
-{
-  unsigned char *mp[CHUNK_CNT];
-  size_t mp_left;
-  unsigned char *op;
-  size_t i;
-
-  msg ("merge");
-
-  /* Initialize merge pointers. */
-  mp_left = CHUNK_CNT;
-  for (i = 0; i < CHUNK_CNT; i++)
-    mp[i] = buf1 + CHUNK_SIZE * i;
-
-  /* Merge. */
-  op = buf2;
-  while (mp_left > 0) 
-    {
-      /* Find smallest value. */
-      size_t min = 0;
-      for (i = 1; i < mp_left; i++)
-        if (*mp[i] < *mp[min])
-          min = i;
-
-      /* Append value to buf2. */
-      *op++ = *mp[min];
-
-      /* Advance merge pointer.
-         Delete this chunk from the set if it's emptied. */ 
-      if ((++mp[min] - buf1) % CHUNK_SIZE == 0)
-        mp[min] = mp[--mp_left]; 
-    }
-}
-
-static void
-verify (void) 
-{
-  size_t buf_idx;
-  size_t hist_idx;
-
-  msg ("verify");
-
-  buf_idx = 0;
-  for (hist_idx = 0; hist_idx < sizeof histogram / sizeof *histogram;
-       hist_idx++)
-    {
-      while (histogram[hist_idx]-- > 0) 
-        {
-          if (buf2[buf_idx] != hist_idx)
-            fail ("bad value %d in byte %zu", buf2[buf_idx], buf_idx);
-          buf_idx++;
-        } 
-    }
-
-  msg ("success, buf_idx=%'zu", buf_idx);
-}
-
-void
-test_main (void)
-{
-  init ();
-  sort_chunks ();
-  merge ();
-  verify ();
-}

src/tests/vm/page-merge-seq.ck

-# -*- perl -*-
-use strict;
-use warnings;
-use tests::tests;
-check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
-(page-merge-seq) begin
-(page-merge-seq) init
-(page-merge-seq) sort chunk 0
-(page-merge-seq) sort chunk 1
-(page-merge-seq) sort chunk 2
-(page-merge-seq) sort chunk 3
-(page-merge-seq) sort chunk 4
-(page-merge-seq) sort chunk 5
-(page-merge-seq) sort chunk 6
-(page-merge-seq) sort chunk 7
-(page-merge-seq) sort chunk 8
-(page-merge-seq) sort chunk 9
-(page-merge-seq) sort chunk 10
-(page-merge-seq) sort chunk 11
-(page-merge-seq) sort chunk 12
-(page-merge-seq) sort chunk 13
-(page-merge-seq) sort chunk 14
-(page-merge-seq) sort chunk 15
-(page-merge-seq) merge
-(page-merge-seq) verify
-(page-merge-seq) success, buf_idx=1,032,192
-(page-merge-seq) end
-EOF
-pass;

src/tests/vm/page-merge-stk.c

-#include "tests/main.h"
-#include "tests/vm/parallel-merge.h"
-
-void
-test_main (void) 
-{
-  parallel_merge ("child-qsort", 72);
-}

src/tests/vm/page-merge-stk.ck

-# -*- perl -*-
-use strict;
-use warnings;
-use tests::tests;
-check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
-(page-merge-stk) begin
-(page-merge-stk) init
-(page-merge-stk) sort chunk 0
-(page-merge-stk) sort chunk 1
-(page-merge-stk) sort chunk 2
-(page-merge-stk) sort chunk 3
-(page-merge-stk) sort chunk 4
-(page-merge-stk) sort chunk 5
-(page-merge-stk) sort chunk 6
-(page-merge-stk) sort chunk 7
-(page-merge-stk) wait for child 0
-(page-merge-stk) wait for child 1
-(page-merge-stk) wait for child 2
-(page-merge-stk) wait for child 3
-(page-merge-stk) wait for child 4
-(page-merge-stk) wait for child 5
-(page-merge-stk) wait for child 6
-(page-merge-stk) wait for child 7
-(page-merge-stk) merge
-(page-merge-stk) verify
-(page-merge-stk) success, buf_idx=1,048,576
-(page-merge-stk) end
-EOF
-pass;

src/tests/vm/page-parallel.c

-/* Runs 4 child-linear processes at once. */
-
-#include <syscall.h>
-#include "tests/lib.h"
-#include "tests/main.h"
-
-#define CHILD_CNT 4
-
-void
-test_main (void)
-{
-  pid_t children[CHILD_CNT];
-  int i;
-
-  for (i = 0; i < CHILD_CNT; i++) 
-    CHECK ((children[i] = exec ("child-linear")) != -1,
-           "exec \"child-linear\"");
-
-  for (i = 0; i < CHILD_CNT; i++) 
-    CHECK (wait (children[i]) == 0x42, "wait for child %d", i);
-}

src/tests/vm/page-parallel.ck

-# -*- perl -*-
-use strict;
-use warnings;
-use tests::tests;
-check_expected (IGNORE_EXIT_CODES => 1, [<<'EOF']);
-(page-parallel) begin
-(page-parallel) exec "child-linear"
-(page-parallel) exec "child-linear"
-(page-parallel) exec "child-linear"
-(page-parallel) exec "child-linear"
-(page-parallel) wait for child 0
-(page-parallel) wait for child 1
-(page-parallel) wait for child 2
-(page-parallel) wait for child 3
-(page-parallel) end
-EOF
-pass;

src/tests/vm/page-shuffle.c

-/* Shuffles a 128 kB data buffer 10 times, printing the checksum
-   after each time. */
-
-#include <stdbool.h>
-#include "tests/arc4.h"
-#include "tests/cksum.h"
-#include "tests/lib.h"
-#include "tests/main.h"
-
-#define SIZE (128 * 1024)
-
-static char buf[SIZE];
-
-void
-test_main (void)
-{
-  size_t i;
-
-  /* Initialize. */
-  for (i = 0; i < sizeof buf; i++)
-    buf[i] = i * 257;
-  msg ("init: cksum=%lu", cksum (buf, sizeof buf));
-    
-  /* Shuffle repeatedly. */
-  for (i = 0; i < 10; i++)
-    {
-      shuffle (buf, sizeof buf, 1);
-      msg ("shuffle %zu: cksum=%lu", i, cksum (buf, sizeof buf));
-    }
-}