Moved tests to modules/packages/collections

Author: LouisJenkinsCS

test/modules/packages/collections/CollectionCounter.chpl

@@ -0,0 +1,69 @@
+use DistributedBag;
+use DistributedDeque;
+use Barrier;
+
+// For this test, we implement a simple counter; we add a predetermined number
+// of elements, then concurrently remove all elements from it until it is empty,
+// testing that all elements added were removed.
+config param isBoundedDeque = false;
+config param isDeque = false;
+config param isBag = false;
+
+config param nElems = 1000;
+const expected = (nElems * (nElems + 1)) / 2;
+
+var c = (
+  if isBoundedDeque then new DistributedDeque(int, cap=nElems)
+  else if isDeque then new DistributedDeque(int)
+  else if isBag then new DistributedBag(int)
+  else compilerError("Require 'isBoundedDeque', 'isDeque', or 'isBag' to be set...")
+);
+
+
+// Fill...
+for i in 1 .. nElems {
+  c.add(i);
+}
+
+assert(c.size == nElems);
+assert(c.contains((nElems / 2) : int));
+
+// Iterate over the collection.
+var actual = 0;
+for elem in c {
+  actual = actual + elem;
+}
+assert(actual == expected);
+assert(c.size == nElems);
+
+// Iterate concurrently over the collection.
+var concurrentActual : atomic int;
+forall elem in c {
+  concurrentActual.add(elem);
+}
+assert(concurrentActual.read() == expected);
+assert(c.size == nElems);
+
+// Empty collection. Make sure all tasks start around same time...
+if isBag then c.balance();
+concurrentActual.write(0);
+var barrier = new Barrier(here.maxTaskPar * numLocales);
+coforall loc in Locales do on loc {
+  var perLocaleActual : atomic int;
+  const _c = c;
+  coforall tid in 0..#here.maxTaskPar {
+    barrier.barrier();
+    var (hasElem, elt) : (bool, int) = (true, 0);
+    var perTaskActual : int;
+    while hasElem {
+      perTaskActual = perTaskActual + elt;
+      (hasElem, elt) = _c.remove();
+    }
+    perLocaleActual.add(perTaskActual);
+  }
+  concurrentActual.add(perLocaleActual.read());
+}
+
+assert(concurrentActual.read() == expected);
+assert(c.size == 0 && c.isEmpty());
+writeln("SUCCESS");

test/modules/packages/collections/CollectionCounter.compopts

@@ -0,0 +1,3 @@
+--no-loop-invariant-code-motion -sisDeque --main-module=CollectionCounter
+--no-loop-invariant-code-motion -sisBag --main-module=CollectionCounter
+--no-loop-invariant-code-motion -sisBoundedDeque --main-module=CollectionCounter

test/modules/packages/collections/CollectionCounter.good

@@ -0,0 +1 @@
+SUCCESS

test/modules/packages/collections/CollectionNQueens

@@ -0,0 +1,193 @@
+use Barrier;
+use DistributedBag;
+use DistributedDeque;
+
+/*
+Precomputed number of solutions...
+
+N x N | Total | Unique
+1 x 1 	 1 	 1
+2 x 2 	 0 	 0
+3 x 3 	 0 	 0
+4 x 4 	 2 	 1
+5 x 5 	 10 	 2
+6 x 6 	 4 	 1
+7 x 7 	 40 	 6
+8 x 8 	 92 	 12
+9 x 9 	 352 	 46
+10 x 10 	 724 	 92
+11 x 11 	 2,680 	 341
+12 x 12 	 14,200 	 1,787
+13 x 13 	 73,712 	 9,233
+14 x 14 	 365,596 	 45,752
+15 x 15 	 2,279,184 	 285,053
+16 x 16 	 14,772,512 	 1,846,955
+17 x 17 	 95,815,104 	 11,977,939
+18 x 18 	 666,090,624 	 83,263,591
+19 x 19 	 4,968,057,848 	 621,012,754
+20 x 20 	 39,029,188,884 	 4,878,666,808
+21 x 21 	 314,666,222,712 	 39,333,324,973
+22 x 22 	 2,691,008,701,644 	 336,376,244,042
+23 x 23 	 24,233,937,684,440 	 3,029,242,658,210
+24 x 24 	 227,514,171,973,736 	 28,439,272,956,934
+25 x 25 	 2,207,893,435,808,350 	 275,986,683,743,434
+26 x 26 	 22,317,699,616,364,000 	 2,789,712,466,510,280 */
+
+
+config param nQueens = 8;
+config param isDeque = false;
+config param isBag = false;
+
+inline proc getTotalSolutions() {
+  var retval = 0;
+  select nQueens {
+    when 1 do retval = 1;
+    when 2 do retval = 0;
+    when 3 do retval = 0;
+    when 4 do retval = 2;
+    when 5 do retval = 10;
+    when 6 do retval = 4;
+    when 7 do retval = 40;
+    when 8 do retval = 92;
+    when 9 do retval = 352;
+    when 10 do retval = 724;
+    when 11 do retval = 2680;
+    when 12 do retval = 14200;
+    when 13 do retval = 73712;
+    when 14 do retval = 365596;
+    when 15 do retval = 2279184;
+    when 16 do retval = 14722512;
+    when 17 do retval = 95815104;
+    when 18 do retval = 666090624;
+    otherwise do halt("Bad parameter for nQueens: ", nQueens, "; Must be in 1 .. 18");
+  }
+
+  return retval;
+}
+
+proc findFirstEmptyRow(board) {
+  var idx = 1;
+  for row in board {
+    if idx > nQueens {
+      return nQueens + 1;
+    }
+    if row == 0 {
+      return idx;
+    }
+    idx = idx + 1;
+  }
+
+  return nQueens + 1;
+}
+
+proc canPlaceQueen(board, row, col) {
+  // If at any row, the column is taken, we can't occupy the slot...
+  for occupiedCol in board {
+    if occupiedCol == col then return false;
+  }
+
+  // Horizontal - Left/Right
+  var x = 1;
+  while x <= nQueens {
+    if board[x] == col then return false;
+    x = x + 1;
+  }
+
+  // Note: We do not need to check vertical, as it is ensured already to be vacant
+
+  // Diagonal - Up Right
+  x = row + 1;
+  var y = col + 1;
+  while x <= nQueens && y <= nQueens {
+    if board[x] == y then return false;
+
+    x = x + 1;
+    y = y + 1;
+  }
+
+  // Diagonal - Down Left
+  x = row - 1;
+  y = col - 1;
+  while x > 0 && y > 0 {
+    if board[x] == y then return false;
+    x = x - 1;
+    y = y - 1;
+  }
+
+  // Diagonal - Up Left
+  x = row - 1;
+  y = col + 1;
+  while x > 0 && y <= nQueens {
+    if board[x] == y then return false;
+    x = x - 1;
+    y = y + 1;
+  }
+
+  // Diagonal - Down Right
+  x = row + 1;
+  y = col - 1;
+  while x <= nQueens && y > 0 {
+    if board[x] == y then return false;
+    x = x + 1;
+    y = y - 1;
+  }
+
+  return true;
+}
+
+
+
+
+type boardType = nQueens * int;
+const totalSolutions = getTotalSolutions();
+var found : atomic int;
+var c : Collection(boardType);
+if isDeque {
+  c = new DistributedDeque(boardType);
+} else if isBag {
+  c = new DistributedBag(boardType);
+} else {
+  halt("Require 'isDeque' or 'isBag' to be set...");
+}
+
+// Fill with initial board...
+c.add(_defaultOf(boardType));
+
+// Begin concurrent NQueens...
+var barrier = new Barrier(here.maxTaskPar * numLocales);
+coforall loc in Locales do on loc {
+  coforall tid in 0 .. #here.maxTaskPar {
+    barrier.barrier();
+    var nSpins : int;
+    while found.read() < totalSolutions {
+      var (exists, myBoard) = c.remove();
+      // Spin: We haven't found solution yet...
+      if !exists {
+        nSpins = nSpins + 1;
+        if nSpins == 1000000 {
+          halt("Spun: ", nSpins);
+        }
+        chpl_task_yield();
+        continue;
+      }
+
+      nSpins = 0;
+
+      const firstEmptyRow = findFirstEmptyRow(myBoard);
+      if firstEmptyRow == nQueens+1 {  //no empty row
+        // We are done: Alert everyone that it is done (including ourselves...)
+        found.add(1);
+        continue;
+      }
+      for j in 1..nQueens {
+        if canPlaceQueen(myBoard, firstEmptyRow, j) {
+          var newBoard = myBoard;
+          newBoard[firstEmptyRow] = j;
+          c.add(newBoard);
+        }
+      }
+    }
+  }
+}
+
+writeln("SUCCESS");

test/modules/packages/collections/CollectionNQueens.chpl

@@ -0,0 +1,2 @@
+-sisDeque --main-module=CollectionNQueens
+-sisBag --main-module=CollectionNQueens

test/modules/packages/collections/CollectionNQueens.compopts

@@ -0,0 +1 @@
+SUCCESS

test/modules/packages/collections/CollectionNQueens.good

@@ -0,0 +1,70 @@
+use DistributedDeque;
+
+// We test both FIFO and LIFO capabilities of the Deque, as well as total ordering.
+// This test differs from DequeAccumulator in that it is entirely sequential and
+// that the outcome should be deterministic.
+
+config param isBounded = false;
+
+const nElems = 1000;
+var deque = (if isBounded then new DistributedDeque(int, cap = nElems) else new DistributedDeque(int));
+
+// FIFO
+for i in 1 .. nElems {
+  deque.enqueue(i);
+}
+
+assert(deque.size == nElems);
+assert(deque.contains(nElems / 2));
+
+var expect = 1;
+for elem in deque.these(Ordering.FIFO) {
+  assert(elem == expect);
+  expect += 1;
+}
+
+for i in 1 .. nElems {
+  var (hasElem, elem) = deque.dequeue();
+  assert(hasElem && elem == i);
+}
+var hasElem = deque.dequeue()[1];
+assert(deque.size == 0 && deque.isEmpty() && !hasElem);
+
+// LIFO
+for i in 1 .. nElems {
+  deque.push(i);
+}
+assert(deque.size == nElems);
+assert(deque.contains(nElems / 2));
+
+expect = nElems;
+for elem in deque.these(Ordering.LIFO) {
+  assert(elem == expect);
+  expect -= 1;
+}
+
+for i in 0 .. #nElems {
+  var (hasElem, elem) = deque.pop();
+  assert(hasElem && elem == nElems - i);
+}
+hasElem = deque.dequeue()[1];
+assert(deque.size == 0 && deque.isEmpty() && !hasElem);
+
+// Total Ordering
+// In this case, we add the middle element, then all elements preceeding it to the
+// beginning, and all elements succeeding it to the end.
+var middle = nElems / 2;
+deque.add(middle);
+for i in 1 .. middle - 1 {
+  deque.pushFront(middle - i);
+}
+for i in middle + 1 .. nElems {
+  deque.pushBack(i);
+}
+assert(deque.size == nElems);
+for i in 1 .. nElems {
+  var (hasElem, elem) = deque.dequeue();
+  assert(hasElem && elem == i);
+}
+
+writeln("SUCCESS");

test/modules/packages/collections/CollectionNQueens_real

@@ -0,0 +1,2 @@
+--main-module=DequeOrdering
+--main-module=DequeOrdering -sisBounded=true

test/modules/packages/collections/DequeOrdering.chpl

@@ -0,0 +1 @@
+SUCCESS