Provide a way for sets to zipper with more things

modules/internal/ChapelHashtable.chpl

@@ -144,7 +144,7 @@ module ChapelHashtable {
     const minSizePerTask = dataParMinGranularity;
 
     // We are simply slicing up the table here.  Trying to do something
-    //  more intelligent (like evenly dividing up the full slots, led
+    //  more intelligent (like evenly dividing up the full slots), led
     //  to poor speed ups.
 
     if debugAssocDataPar {
@@ -644,5 +644,34 @@ module ChapelHashtable {
 
       rehash(newSize);
     }
+
+    iter _evenSlots(param tag) where tag == iterKind.leader {
+      for i in (0..<this.tableNumFullSlots).these(tag) {
+        yield i;
+      }
+    }
+
+
+    iter _evenSlots(followThis, param tag) const ref
+      where tag == iterKind.follower {
+
+      var space = followThis(0);
+
+      var curNumFull = 0;
+
+      for i in 0..#(this.tableSize) {
+        if this.isSlotFull(i) {
+          if (curNumFull >= space.low) {
+            if (curNumFull <= space.high) {
+              yield this.table[i].key;
+            } else {
+              break;
+            }
+          }
+
+          curNumFull += 1;
+        }
+      }
+    }
   }
 }

modules/standard/Set.chpl

@@ -564,16 +564,17 @@ module Set {
     @chpldoc.nodoc
     iter const these(param tag) where tag == iterKind.leader {
       var space = 0..#_htb.tableSize;
-      for followThis in space.these(tag) {
+      for followThis in _htb._evenSlots(tag) {
         yield followThis;
       }
     }
 
     @chpldoc.nodoc
     iter const these(param tag, followThis) const ref
     where tag == iterKind.follower {
-      foreach idx in followThis(0) do
-        if _htb.isSlotFull(idx) then yield _htb.table[idx].key;
+      foreach val in _htb._evenSlots(followThis, tag) {
+        yield val;
+      }
     }
 
     @chpldoc.nodoc

test/library/standard/Set/these/setZipDifferentSize.chpl

@@ -7,6 +7,8 @@ proc test() {
   var s2 = s1;
   s2.add(9);
 
+  // We want to detect this case eventually, but it will be easier with
+  // with leader/follower improvements (see #11505)
   forall (x, y) in zip(s1, s2) do
     var tmp = x + y;
 

test/library/standard/Set/these/setZipDifferentSize.good

@@ -1 +0,0 @@
-setZipDifferentSize.chpl:10: error: zippered iterations have non-equal lengths

test/library/standard/Set/these/setZipDifferentSize2.chpl

@@ -0,0 +1,16 @@
+use Set;
+
+proc test() {
+  var s1: set(int);
+  for i in 1..8 do s1.add(i);
+
+  var s2 = s1;
+  s2.add(9);
+
+  forall (x, y) in zip(s2, s1) do
+    var tmp = x + y;
+
+  return;
+}
+test();
+

test/library/standard/Set/these/setZipDifferentSize2.good

@@ -0,0 +1 @@
+setZipDifferentSize2.chpl:10: error: zippered iterations have non-equal lengths

test/library/standard/Set/these/setZipDifferentSize2.skipif

@@ -0,0 +1,2 @@
+# Follower checks are skipped when compiling with --fast
+COMPOPTS <= --fast

test/library/standard/Set/zippering/arrayShorter.chpl

@@ -0,0 +1,21 @@
+use Set;
+
+config const verbose = false;
+
+var LocalSet= new set(int,parSafe = true);
+LocalSet.add(1);
+LocalSet.add(2);
+LocalSet.add(3);
+LocalSet.add(4);
+LocalSet.add(5);
+
+var A: [0..3] int;
+writeln(A.size, " ", LocalSet.size);
+
+// This should fail to zip, the set is longer than the array.  But it doesn't,
+// improvements to leader/follower (#11505) would make it easier to detect
+forall (a,b) in zip(A,LocalSet) {
+    a=b;
+    if verbose then writeln(b);
+}
+writeln(A);

test/library/standard/Set/zippering/arrayShorter.good

@@ -0,0 +1,2 @@
+4 5
+5 1 4 2

test/library/standard/Set/zippering/arrayShorter2.chpl

@@ -0,0 +1,20 @@
+use Set;
+
+config const verbose = false;
+
+var LocalSet= new set(int,parSafe = true);
+LocalSet.add(1);
+LocalSet.add(2);
+LocalSet.add(3);
+LocalSet.add(4);
+LocalSet.add(5);
+
+var A: [0..3] int;
+writeln(A.size, " ", LocalSet.size);
+
+// Expect this to fail to zip, the set is longer than the array
+forall (b, a) in zip(LocalSet, A) {
+    a=b;
+    if verbose then writeln(b);
+}
+writeln(A);

test/library/standard/Set/zippering/arrayShorter2.good

@@ -0,0 +1,2 @@
+4 5
+arrayShorter2.chpl:16: error: halt reached - size mismatch in zippered iteration (dimension 0)

test/library/standard/Set/zippering/sameLength.chpl

@@ -0,0 +1,13 @@
+use Set;
+
+var s1, s2: set(int);
+
+for i in 1..10 { s1.add(i); s2.add(i+10); }
+
+writeln("s1 = ", s1);
+writeln("s2 = ", s2);
+
+forall (i,j) in zip(s1, s2) do
+  writeln(i, " ", j);
+
+writeln("all done");

test/library/standard/Set/zippering/sameLength.good

@@ -0,0 +1,13 @@
+all done
+s1 = {5, 7, 8, 1, 4, 6, 2, 10, 9, 3}
+s2 = {16, 20, 12, 17, 19, 13, 15, 11, 18, 14}
+1 17
+2 15
+3 14
+4 19
+5 16
+6 13
+7 20
+8 12
+9 18
+10 11

test/library/standard/Set/zippering/sameLength.prediff

@@ -0,0 +1,3 @@
+#!/bin/sh
+sort -n $1.exec.out.tmp > $1.prediff.tmp
+mv $1.prediff.tmp $1.exec.out.tmp

test/library/standard/Set/zippering/toArray.chpl

@@ -0,0 +1,17 @@
+use Set;
+
+var LocalSet= new set(int,parSafe = true);
+LocalSet.add(1);
+LocalSet.add(2);
+LocalSet.add(3);
+LocalSet.add(4);
+LocalSet.add(5);
+
+var A : [0..4] int;
+
+writeln("A = ", A);
+writeln("LocalSet = ", LocalSet);
+forall (a,b) in zip (A,LocalSet.toArray()) {
+  a=b;
+}
+writeln("A = ", A);

test/library/standard/Set/zippering/toArray.good

@@ -0,0 +1,3 @@
+A = 0 0 0 0 0
+LocalSet = {5, 1, 4, 2, 3}
+A = 5 1 4 2 3

test/library/standard/Set/zippering/withArray1.chpl

@@ -0,0 +1,18 @@
+use Set;
+
+config const verbose = false;
+
+var LocalSet= new set(int,parSafe = true);
+LocalSet.add(1);
+LocalSet.add(2);
+LocalSet.add(3);
+LocalSet.add(4);
+LocalSet.add(5);
+
+var A : [0..4] int;
+writeln(A.size, " ", LocalSet.size);
+forall (a,b) in zip(A,LocalSet) {
+    a=b;
+    if verbose then writeln(b);
+}
+writeln(A);

test/library/standard/Set/zippering/withArray1.good

@@ -0,0 +1,2 @@
+5 5
+5 1 4 2 3

test/library/standard/Set/zippering/withArray2.chpl

@@ -0,0 +1,18 @@
+use Set;
+
+config const verbose = false;
+
+var LocalSet= new set(int,parSafe = true);
+LocalSet.add(1);
+LocalSet.add(2);
+LocalSet.add(3);
+LocalSet.add(4);
+LocalSet.add(5);
+
+var A : [0..4] int;
+writeln(A.size, " ", LocalSet.size);
+forall (b, a) in zip(LocalSet, A) {
+    a=b;
+    if verbose then writeln(b);
+}
+writeln(A);

test/library/standard/Set/zippering/withArray2.good

@@ -0,0 +1,2 @@
+5 5
+5 1 4 2 3

test/library/standard/Set/zippering/withArrayLonger1.chpl

@@ -0,0 +1,17 @@
+use Set;
+
+config const verbose = false;
+
+var LocalSet= new set(int,parSafe = true);
+for i in 1..10 {
+  LocalSet.add(i);
+}
+
+var A : [0..9] int;
+writeln(A.size, " ", LocalSet.size);
+forall (a,b) in zip(A,LocalSet) {
+    a=b;
+    if verbose then writeln(b);
+}
+writeln(LocalSet);
+writeln(A);

test/library/standard/Set/zippering/withArrayLonger1.good

@@ -0,0 +1,3 @@
+10 10
+{5, 7, 8, 1, 4, 6, 2, 10, 9, 3}
+5 7 8 1 4 6 2 10 9 3

test/library/standard/Set/zippering/withRange1.chpl

@@ -0,0 +1,14 @@
+use Set;
+
+var s1: set(int);
+var r1 = 1..10;
+
+for i in 1..10 { s1.add(i); }
+
+writeln("s1 = ", s1);
+writeln("r1 = ", r1);
+
+forall (i,j) in zip(r1, s1) do
+  writeln(i, " ", j);
+
+writeln("all done");

test/library/standard/Set/zippering/withRange1.good

@@ -0,0 +1,13 @@
+all done
+r1 = 1..10
+s1 = {5, 7, 8, 1, 4, 6, 2, 10, 9, 3}
+1 5
+2 7
+3 8
+4 1
+5 4
+6 6
+7 2
+8 10
+9 9
+10 3

test/library/standard/Set/zippering/withRange1.prediff

@@ -0,0 +1,3 @@
+#!/bin/sh
+sort -n $1.exec.out.tmp > $1.prediff.tmp
+mv $1.prediff.tmp $1.exec.out.tmp

test/library/standard/Set/zippering/withRange2.chpl

@@ -0,0 +1,14 @@
+use Set;
+
+var s1: set(int);
+var r1 = 1..10;
+
+for i in 1..10 { s1.add(i); }
+
+writeln("s1 = ", s1);
+writeln("r1 = ", r1);
+
+forall (i,j) in zip(s1, r1) do
+  writeln(i, " ", j);
+
+writeln("all done");

test/library/standard/Set/zippering/withRange2.good

@@ -0,0 +1,13 @@
+all done
+r1 = 1..10
+s1 = {5, 7, 8, 1, 4, 6, 2, 10, 9, 3}
+1 4
+2 7
+3 10
+4 5
+5 1
+6 6
+7 2
+8 3
+9 9
+10 8

test/library/standard/Set/zippering/withRange2.prediff

@@ -0,0 +1,3 @@
+#!/bin/sh
+sort -n $1.exec.out.tmp > $1.prediff.tmp
+mv $1.prediff.tmp $1.exec.out.tmp