Started implementing Algorithm R and updated README

Author: Samuel Pollard

LICENSE.txt LICENSE

@@ -1 +1,11 @@
-# Quantifying error for MPI Reduce
+# Quantifying Error for MPI Reduce
+
+## Dependencies
+- [SimGrid](https://github.com/simgrid/simgrid) - preferably most recent git version. Also requires cmake
+
+## Building
+- To build: `make`
+- To run quick test `make quick`
+- To run some experiments `make sim`. This outputs results in a tsv, with the
+  exception of SimGrid diagnostics.
+

README.md

@@ -1,83 +1,100 @@
-/* The t is for "Template" C++ file
+/* Implementation of random_reduction_tree template
  */
 
 #include "assoc.hxx"
 using namespace std;
 
-random_kary_tree::random_kary_tree() { };
-random_kary_tree::~random_kary_tree() { };
+random_reduction_tree::random_reduction_tree() { };
+random_reduction_tree::~random_reduction_tree() { };
 
-random_kary_tree::random_kary_tree(int k, long n, FLOAT_T* A) : k_(k), n_(n), A_(A)
+random_reduction_tree::random_reduction_tree(int k, long n, FLOAT_T* A)
+	: k_(k), n_(n), A_(A)
 {
 	typename tree<FLOAT_T>::iterator top, root;
 	top = t.begin();
 	root = t.insert(top, nan(""));
-	if (k != 2) {
+	irem = n-1; /* Inner nodes remaining */
+	lrem = n;   /* Leaf nodes remaining */
+	changed_t v;
+	if (k == 2) {
+		// changed_t v = fill_balanced_binary_tree(irem, root, lrem);
+		v = grow_random_binary_tree(root, lrem);
+	} else {
 		fprintf(stderr, "generic k-ary trees not supported yet (%d)\n", k);
-		throw 3;
+		throw TREE_ERROR;
 	}
-	irem = n-1;
-	lrem = n;
-	changed_t v = fill_balanced_binary_tree(irem, root, lrem);
-	// changed_t v = fill_binary_tree(irem, root, lrem);
+
 	if (v.inner != irem || v.leaf != lrem) {
 		fprintf(stderr, "Didn't fill tree correctly: (irem=%ld lrem=%ld, n=%ld)\n",
 		        v.inner, v.leaf, n_);
-		throw 3;
+		throw TREE_ERROR;
 	}
 }
 
-FLOAT_T random_kary_tree::sum_tree()
+FLOAT_T random_reduction_tree::sum_tree()
 {
 	return 0.0/0.0;
 }
 
-FLOAT_T random_kary_tree::multiply_tree()
+FLOAT_T random_reduction_tree::multiply_tree()
 {
 	return 0.0/0.0;
 }
 
-changed_t random_kary_tree::fill_balanced_binary_tree(
+/* Make a balanced binary tree. Not random */
+changed_t random_reduction_tree::fill_balanced_binary_tree(
 		long irem, tree<FLOAT_T>::iterator current, long lrem)
 {
 	return (changed_t) {.inner = 0, .leaf = 0};
 }
 
-/* Helper, recursive function for fill_random_kary_tree */
-/* irem: The number of inner nodes remaining.
+/* Make a random binary tree. Algorithm R from The Art of Computer
+ * Programming, Volume 4, pre-fascicle 4A: A Draft of Section 7.2.1.6:
+ * Generating All Trees, Donald Knuth.
+ * irem: The number of inner nodes remaining.
  * t: Current node of the tree
  * lrem: Number of leaves remaining to add
  * A: Array of values to place in the tree. Removed from the right.
  * returns: The number of inner nodes and leaf nodes added in the subtree
  */
-changed_t random_kary_tree::fill_binary_tree(
-		long irem, tree<FLOAT_T>::iterator current, long lrem)
+changed_t random_reduction_tree::grow_random_binary_tree(
+		tree<FLOAT_T>::iterator root, long lrem)
 {
-	int dir = 0;
-	changed_t rv {.inner = 0, .leaf = 0};
-	typename tree<FLOAT_T>::iterator l, r;
-	/* To add another inner node we need at least 2 left in leaf budget */
-	if (irem > 0 && lrem >= 2) {
-		dir = rand() % 2;
-	} else {
-		dir = 0;
+	if ((2 * lrem + 1) >= RAND_MAX) {
+		fprintf(stderr, "tree too big\n");
+		throw TREE_ERROR;
 	}
-
-	if (dir == 0) { /* I'm a leaf */
-		*current = A_[lrem - 1];
-		rv.leaf++;
-	} else { /* I'm an inner node */
-		l = t.append_child(current, nan(""));
-		r = t.append_child(current, nan(""));
-		rv = fill_binary_tree(irem-1, l, lrem-1); // Save at least 1 leaf
-		/* Subtract how much we filled on the left side */
-		rv = fill_binary_tree((n_-1)-rv.inner, r, n_-rv.leaf);
+	/* Allocate an array */
+	long x, k, b, n, rem;
+	long *L;
+	L = (long *) malloc((2*lrem + 1)*sizeof(long));
+	/* Initialize (R1) */
+	n = 0;
+	L[0] = 0;
+	while (n < lrem) { /* Done? (R2) */
+		/* Advance i (R3) */
+		x = rand() % (4 * n + 1);
+		n++;
+		b = x % 2;
+		k = x / 2;
+		L[2*n - b] = 2*n;
+		L[2*n - 1 + b] = L[k];
+		L[k] = 2*n - 1;
+	}
+	/* Debug */
+	printf("[%ld", L[0]);
+	for (rem = 1; rem < 2 * lrem + 1; rem++) {
+		printf(", %ld", L[rem]);
 	}
-	return rv;
+	printf("]\n");
+
+	/* Now, to convert to C++ tree */
+	free(L);
+	return (changed_t) {.inner = 0, .leaf = 0};
 }
 
 /* Explicit template instantiation. Here, we see two flavors, respectively:
  * classes and class member functions */
-/* template class random_kary_tree<double>; */
-/* template random_kary_tree<double>::random_kary_tree(int k, long n, double* A); */
+/* template class random_reduction_tree<double>; */
+/* template random_reduction_tree<double>::random_reduction_tree(int k, long n, double* A); */
 

assoc.cxx

@@ -16,31 +16,33 @@
 #define FLOAT_T double
 #endif
 
+#define TREE_ERROR 3
+
 /* For recursive fill_binary_tree function */
 typedef struct chg {
 	long inner;
 	long leaf;
 } changed_t;
 
-/* Look at C++ Concepts */
-class random_kary_tree {
+class random_reduction_tree {
 	public:
-		random_kary_tree();       // Empty constructor
-		random_kary_tree(int k, long n, FLOAT_T* A);  // Construct and randomize
-		~random_kary_tree();      // Destructor
+		random_reduction_tree();   // Empty constructor
+		random_reduction_tree(int k, long n, FLOAT_T* A);  // Construct and randomize
+		~random_reduction_tree(); // Destructor
 		FLOAT_T sum_tree();       // Add all leaves. Sum is at the root.
 		FLOAT_T multiply_tree();  // Multiply all leaves. Product is at the root.
 		changed_t fill_binary_tree(
-			long irem, tree<FLOAT_T>::iterator current, long lrem);
+				long irem, tree<FLOAT_T>::iterator current, long lrem);
 	private:
+		changed_t grow_random_binary_tree(
+				tree<FLOAT_T>::iterator root, long lrem);
 		changed_t fill_balanced_binary_tree(
-			long irem, tree<FLOAT_T>::iterator current, long lrem);
+				long irem, tree<FLOAT_T>::iterator current, long lrem);
 		tree<FLOAT_T> t;     // The tree
 		int k_;              // Fan-out of tree
 		long n_;             // Size of array of elements to insert
 		FLOAT_T* A_;         // Elements to put in the leaves
 		long irem;           // Inner nodes remaining
 		long lrem;           // Leaf nodes remaining
 };
-
 #endif

assoc.hxx

@@ -9,7 +9,7 @@
 *      + omp_dotprod_mpi.c     - MPI only version
 *      - omp_dotprod_hybrid.c  - Hybrid MPI and OpenMP version
 * SOURCE: Blaise Barney
-* LAST REVISED: 5/18/20 - Samuel Pollard
+* LAST REVISED: 6/18/20 - Samuel Pollard
 ******************************************************************************/
 #define USAGE "mpirun -np <N> ./dotprod_mpi <veclen> <topology>"
 
@@ -45,7 +45,7 @@ int main (int argc, char* argv[])
 	int taskid, numtasks;
 	long i, j, chunk, len, rc=0;
 	double *a, *b, *as, *bs, *rank_sum;
-	double mysum, nc_sum, par_sum, can_mpi_sum; //, rassoc_sum;
+	double mysum, nc_sum, par_sum, can_mpi_sum, rassoc_sum;
 	double starttime, endtime, ptime;
 	union udouble {
 		double d;
@@ -139,7 +139,7 @@ int main (int argc, char* argv[])
 		printf("numtasks\tveclen\ttopology\treduction algorithm\treduction order\tparallel time\tFP (decimal)\tFP (%%a)\tFP (hex)\n");
 
 		// Generate a random summation (TODO)
-		// rassoc_sum = associative_sum_rand<double>(numtasks, rank_sum, 1);
+		rassoc_sum = associative_sum_rand<double>(numtasks, rank_sum, 1);
 		// pv.d = rassoc_sum;
 		// printf("Random assocs:     dot(x,y) =\t%a\t0x%lx\n", rassoc_sum, pv.u);
 		pv.d = par_sum;
@@ -173,9 +173,9 @@ template <typename T>
 T associative_sum_rand(long n, T* A, int seed)
 {
 	srand(seed);
-	random_kary_tree t;
+	random_reduction_tree t;
 	try {
-		t = random_kary_tree(2, n, A);
+		t = random_reduction_tree(2, n, A);
 	} catch (int e) {
 		return 0.0/0.0;
 	}