speed-up, but kinda borked

inf2440/hw3/Main.java

 		Random r = new Random(123);
 
 		int[] a = new int[len];
-		for (int j = 0; j < len; j++) {
-			a[j] = r.nextInt(len);
-		}
-		s.sort(a);
-
 		for (int j = 0; j < len; j++) {
 			a[j] = r.nextInt(len);
 		}

inf2440/hw3/MultiRadix.java

 		int [] bit ;
 
 		// a) finn max verdi i a[]
-		//Timer ta = new Timer().start();
+		Timer ta = new Timer().start();
 		for (int i = 1 ; i < n ; i++)
 			if (a[i] > max) max = a[i];
 		while (max >= (1L<<numBit) )numBit++; // antall binaere siffer i max
-		//System.out.println("A: "+ta.end().prettyTime());
+		System.out.println("A: "+ta.end().prettyTime());
 
 		// bestem antall bit i numBits sifre
 		numDigits = Math.max(1, numBit/NUM_BIT);

inf2440/hw3/MultiRadixPar.java

 
 class MultiRadixPar{
 	int n;
-	int [] a;
+	volatile int[] a;
 	final static int NUM_BIT = 7; // alle tall 6-11 .. finn ut hvilken verdi som er best
 	int nThreads = Math.min(
 		Runtime.getRuntime().availableProcessors(),
 		8);
 
-	int []  radixMulti(int [] a) {
-		long tt = System.nanoTime();
+	class PartAWorker implements Runnable {
+		int start;
+		int end;
+		int biggest;
+
+		PartAWorker(int start, int end) {
+			this.start = start;
+			this.end = end;
+			this.biggest = a[start];
+		}
+
+		public void run() {
+			for (int i = start + 1; i < end; ++i) {
+				if (a[i] > biggest)
+					biggest = a[i];
+			}
+		}
+	}
+
+	int []  radixMulti(int [] a_) {
+		this.a = a_;
+
 		// 1-5 digit radixSort of : a[]
 		int max = a[0], numBit = 2, numDigits, n =a.length;
 		int [] bit ;
 
 		// a) finn max verdi i a[]
-		//Timer ta = new Timer().start();
-		for (int i = 1 ; i < n ; i++)
-			if (a[i] > max) max = a[i];
+		Timer ta = new Timer().start();
+		int d = a.length / nThreads;
+		Thread[] threads = new Thread[nThreads];
+		PartAWorker[] workers = new PartAWorker[nThreads];
+		for (int i = 0; i < nThreads; ++i) {
+			PartAWorker w = workers[i] = new PartAWorker(
+				d * i, i == nThreads - 1 ? a.length : d * (i + 1));
+
+			Thread t = threads[i] = new Thread(w);
+			t.start();
+		}
+		for (Thread t: threads) { try { t.join(); } catch (InterruptedException ex) {} }
+		max = workers[0].biggest;
+		for (int i = 1; i < nThreads; ++i) {
+			if (workers[i].biggest > max)
+				max = workers[i].biggest;
+		}
 		while (max >= (1L<<numBit) )numBit++; // antall binaere siffer i max
-		//System.out.println("A: "+ta.end().prettyTime());
+		System.out.println("A: "+ta.end().prettyTime());
+		System.out.println(max);
 
 		// bestem antall bit i numBits sifre
 		numDigits = Math.max(1, numBit/NUM_BIT);
 		int[] t=a, b = new int [n];
 
 		for (int i =0; i < bit.length; i++) {
-			radixSort( a,b,bit[i],sum );    // i-te siffer fra a[] til b[]
+			radixSort( b,bit[i],sum );    // i-te siffer fra a[] til b[]
 			sum += bit[i];
 			// swap arrays (pointers only)
 			t = a;
 		return a;
 	} // end radixMulti
 
-	class Worker implements Runnable {
+	class PartDWorker implements Runnable {
 		int start, end, shift, mask;
-		int[] a, b, count;
+		int[] b, count;
 
-		Worker(int start, int end, int[] a, int[] b, int[] count, int shift, int mask) {
+		PartDWorker(int start, int end, int[] b, int[] count, int shift, int mask) {
 			this.start = start;
 			this.end = end;
-			this.a = a;
 			this.b = b;
 			this.count = count;
 			this.shift = shift;
 		}
 
 		public void run() {
-			for (int i = 0; i < a.length; i++) {
+			for (int i = 0; i < n; i++) {
 				int var = (a[i] >>> shift) & mask;
 				if (var >= start && var < end) {
 					b[count[var]++] = a[i];
 	}
 
 	/** Sort a[] on one digit ; number of bits = maskLen, shiftet up 'shift' bits */
-	void radixSort ( int [] a, int [] b, int maskLen, int shift){
+	void radixSort (int [] b, int maskLen, int shift){
 		int n = a.length;
 		int mask = (1<<maskLen) -1;
 		int [] count = new int [mask+1];
+		int biggestVar = 0;
 
 		// b) count=the frequency of each radix value in a
 		//Timer tb = new Timer().start();
 		for (int i = 0; i < n; i++) {
 			int var = (a[i]>>>shift) & mask;
 			count[var]++;
+			if (var > biggestVar)
+				biggestVar = var;
 		}
 		//System.out.println("B: "+tb.end().prettyTime());
 
 		// c) Add up in 'count' - accumulated values
-		//Timer tc = new Timer().start();
+		Timer tc = new Timer().start();
 		int j = 0;
 		int acumVal = 0;
 		for (int i = 0; i <= mask; i++) {
 			count[i] = acumVal;
 			acumVal += j;
 		}
-		//System.out.println("C: "+tc.end().prettyTime());
+		System.out.println("C: "+tc.end().prettyTime());
+
+		// It doesn't make sense to do stuff in parallel if all values are 0
+		if (biggestVar == 0) {
+			System.out.println("biggest is 0");
+			for (int i = 0; i < b.length; i++) {
+				b[i] = 0;
+			}
+			return;
+		}
 
 		Timer td = new Timer().start();
-		int d = n / nThreads;
+		int d = biggestVar / nThreads;
 		Thread[] threads = new Thread[nThreads];
 		for (int i = 0; i < nThreads; ++i) {
 			int start = d * i;
 			int end = i == nThreads - 1 ? n + 1 : d * (i + 1);
 
-			Worker w = new Worker(start, end, a, b, count, shift, mask);
+			PartDWorker w = new PartDWorker(start, end, b, count, shift, mask);
 			Thread t = threads[i] = new Thread(w);
 			t.start();
 		}
 			try { t.join(); } catch (InterruptedException ex) {}
 		}
 		System.out.println("par D: "+td.end().prettyTime());
-
-		//System.out.println("");
 	}// end radixSort
 
 	void testSort(int [] a){