removed stupid solution

inf2440/hw3.stupid/Main.java

-import java.util.Random;
-
-class Main {
-	public static void main(String[] args) {
-
-		Solver sseq = new Sequential();
-		Solver spar = new Parallel();
-
-		if (args.length != 1) {
-			System.out.println(" bruk : >java SekvensiellRadix <n> ");
-		} else {
-			int n = Integer.parseInt(args[0]);
-			Timer seq = test(sseq, n);
-			System.out.println("Sequential: "+seq.prettyTime());
-
-			Timer par = test(spar, n);
-			System.out.println("Parallel: "+par.prettySpeedup(seq));
-		}
-	}
-
-	static Timer test (Solver s, int len) {
-		Random r = new Random(123);
-
-		int[] a = new int[len];
-		for (int j = 0; j < len; j++) {
-			a[j] = r.nextInt(len);
-		}
-
-		Timer t = new Timer().start();
-		a = s.sort(a);
-		t.end();
-		new MultiRadix().testSort(a);
-
-		return t;
-	} // end doIt
-}

inf2440/hw3.stupid/MultiRadix.java

-import java.util.*;
-/***********************************************************
- * Oblig 3 - sekvensiell kode, INF2440 v2017.
- *            Ifi, Uio, Arne Maus
- * for store verdier av n > 100 m, kjør (f.eks):
- *     >java -Xmx16000m MultiRadix 1000000000
- ************************************************************/
-class MultiRadix{
-	int n;
-	int [] a;
-	final static int NUM_BIT = 7; // alle tall 6-11 .. finn ut hvilken verdi som er best
-
-	int []  radixMulti(int [] a) {
-		long tt = System.nanoTime();
-		// 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];
-		while (max >= (1L<<numBit) )numBit++; // antall binaere siffer i max
-		//System.out.println("A: "+ta.end().prettyTime());
-
-		// bestem antall bit i numBits sifre
-		numDigits = Math.max(1, numBit/NUM_BIT);
-		bit = new int[numDigits];
-		int rest = (numBit%numDigits), sum =0;;
-
-		// fordel bitene vi skal sortere paa jevnt
-		for (int i = 0; i < bit.length; i++){
-			bit[i] = numBit/numDigits;
-			if ( rest-- > 0)  bit[i]++;
-		}
-
-		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[]
-			sum += bit[i];
-			// swap arrays (pointers only)
-			t = a;
-			a = b;
-			b = t;
-		}
-		if (bit.length%2 != 0 ) {
-			// et odde antall sifre, kopier innhold tilbake til original a[] (nå b)
-			System.arraycopy (a,0,b,0,a.length);
-		}
-
-		return a;
-	} // end radixMulti
-
-	/** Sort a[] on one digit ; number of bits = maskLen, shiftet up 'shift' bits */
-	void radixSort ( int [] a, int [] b, int maskLen, int shift){
-		int  acumVal = 0, j, n = a.length;
-		int mask = (1<<maskLen) -1;
-		int [] count = new int [mask+1];
-
-		// b) count=the frequency of each radix value in a
-		//Timer tb = new Timer().start();
-		for (int i = 0; i < n; i++) {
-			count[(a[i]>>> shift) & mask]++;
-		}
-		//System.out.println("B: "+tb.end().prettyTime());
-
-		// c) Add up in 'count' - accumulated values
-		//Timer tc = new Timer().start();
-		for (int i = 0; i <= mask; i++) {
-			j = count[i];
-			count[i] = acumVal;
-			acumVal += j;
-		}
-		//System.out.println("C: "+tc.end().prettyTime());
-
-		// d) move numbers in sorted order a to b
-		//Timer t = new Timer().start();
-		for (int i = 0; i < n; i++) {
-			b[count[(a[i]>>>shift) & mask]++] = a[i];
-		}
-		//t.end();
-		//System.out.println("seq D: "+t.prettyTime());
-
-	}// end radixSort
-
-	void testSort(int [] a){
-		for (int i = 0; i< a.length-1;i++) {
-			if (a[i] > a[i+1]){
-				System.out.println("SorteringsFEIL på plass: "+i +" a["+i+"]:"+a[i]+" > a["+(i+1)+"]:"+a[i+1]);
-				return;
-			}
-		}
-	}// end simple sorteingstest
-}// end SekvensiellRadix

inf2440/hw3.stupid/MultiRadixPar.java

-import java.util.*;
-
-class MultiRadixPar{
-	int n;
-	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);
-
-	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();
-		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());
-
-		// bestem antall bit i numBits sifre
-		numDigits = Math.max(1, numBit/NUM_BIT);
-		bit = new int[numDigits];
-		int rest = (numBit%numDigits), sum =0;;
-
-		// fordel bitene vi skal sortere paa jevnt
-		for (int i = 0; i < bit.length; i++){
-			bit[i] = numBit/numDigits;
-			if ( rest-- > 0)  bit[i]++;
-		}
-
-		int[] t=a, b = new int [n];
-
-		for (int i =0; i < bit.length; i++) {
-			radixSort( b,bit[i],sum );    // i-te siffer fra a[] til b[]
-			sum += bit[i];
-			// swap arrays (pointers only)
-			t = a;
-			a = b;
-			b = t;
-		}
-		if (bit.length%2 == 0 ) {
-			// et odde antall sifre, kopier innhold tilbake til original a[] (nå b)
-			System.arraycopy (b,0,a,0,a.length);
-		}
-
-		return a;
-	} // end radixMulti
-
-	class PartDWorker implements Runnable {
-		int start, end, shift, mask;
-		int[] b, count;
-
-		PartDWorker(int start, int end, int[] b, int[] count, int shift, int mask) {
-			this.start = start;
-			this.end = end;
-			this.b = b;
-			this.count = count;
-			this.shift = shift;
-			this.mask = mask;
-		}
-
-		public void run() {
-			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 [] 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();
-		int j = 0;
-		int acumVal = 0;
-		for (int i = 0; i <= mask; i++) {
-			j = count[i];
-			count[i] = acumVal;
-			acumVal += j;
-		}
-		//System.out.println("C: "+tc.end().prettyTime());
-
-		//Timer td = new Timer().start();
-		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);
-
-			PartDWorker w = new PartDWorker(start, end, b, count, shift, mask);
-			Thread t = threads[i] = new Thread(w);
-			t.start();
-		}
-
-		for (Thread t: threads) {
-			try { t.join(); } catch (InterruptedException ex) {}
-		}
-		//System.out.println("par D: "+td.end().prettyTime());
-	}// end radixSort
-
-	void testSort(int [] a){
-		for (int i = 0; i< a.length-1;i++) {
-			if (a[i] > a[i+1]){
-				System.out.println("SorteringsFEIL på plass: "+i +" a["+i+"]:"+a[i]+" > a["+(i+1)+"]:"+a[i+1]);
-				return;
-			}
-		}
-	}// end simple sorteingstest
-}// end SekvensiellRadix

inf2440/hw3.stupid/Parallel.java

-class Parallel implements Solver {
-	public int[] sort(int[] arr) {
-		return new MultiRadixPar().radixMulti(arr);
-	}
-}

inf2440/hw3.stupid/Sequential.java

-class Sequential implements Solver {
-	public int[] sort(int[] arr) {
-		return new MultiRadix().radixMulti(arr);
-	}
-}

inf2440/hw3.stupid/Solver.java

-interface Solver {
-	int[] sort(int[] a);
-}

inf2440/hw3.stupid/Timer.java

-import java.util.Arrays;
-
-class Timer implements Comparable<Timer> {
-	public long time = 0;
-
-	private long start = 0;
-
-	Timer() {}
-	Timer(long time) {
-		this.time = time;
-	}
-
-	public Timer start() {
-		start = System.nanoTime();
-		return this;
-	}
-	public Timer end() {
-		time = System.nanoTime() - start;
-		return this;
-	}
-
-	public String prettyTime() {
-		if (time < 1000)
-			return String.format("%.2fns", time / 1f);
-		else if (time < 1000000)
-			return String.format("%.2fμs", time / 1000f);
-		else if (time < 1000000000)
-			return String.format("%.2fms", time / 1000000f);
-		else
-			return String.format("%.2fs", time / 1000000000f);
-	}
-
-	public String prettySpeedup(Timer base) {
-		double speedup = (double)base.time / (double)time;
-		return String.format("%s (%.2fx speedup)",
-			prettyTime(), speedup);
-	}
-
-	public static Timer median(Timer[] timers) {
-		Arrays.sort(timers);
-		Timer med = new Timer();
-
-		int mid = timers.length / 2;
-		if (timers.length % 2 == 0)
-			med.time = (timers[mid].time + timers[mid+1].time) / 2;
-		else
-			med.time = timers[mid].time;
-
-		return med;
-	}
-
-	public int compareTo(Timer t) {
-		if (this.time < t.time)
-			return -1;
-		else if (this.time > t.time)
-			return 1;
-		else
-			return 0;
-	}
-}

inf2440/hw3.stupid/output.txt

-martin@elli:~/tmp$ java Main 200000000
-Sequential: 4.99s
-Parallel: 2.11s (2.37x speedup)

inf2440/hw3.stupid/rapport.txt

-Kompilering: `javac *.java`
-Kjøring: `java Main <tall>`
-
-# Eksempelutskrift
-
-I filen output.txt finner du et eksempel på å kjøre `java Main 2000000000`.
-
-# Tider
-
-CPU: quad core Intel Xeon E31225 @ 3.1 GHz (ingen hyperthreading)
-
-200 000 000:
-	* Sekvensiell: 4.99s
-	* Parallell: 2.11s (2.37x speedup)
-
-20 000 000:
-	* Sekvensiell: 257.75ms
-	* Parallell: 186.53ms (1.48x speedup)
-
-2 000 000:
-	* Sekvensiell: 54.04ms
-	* Parallell: 44.87 (1.20x speedup)
-
-200 000:
-	* Sekvensiell: 22.94ms
-	* Parallell: 12.46ms (1.84x speedup)
-
-20 000:
-	* Sekvensiell: 3.87ms
-	* Parallell: 4.54ms (0.85x speedup)
-
-2 000:
-	* Sekvensiell:895.36μs
-	* Parallell: 2.68ms (0.33x speedup)
-
-## Del C
-
-Jeg skjønte ikke helt grunnen til å paralellisere del C. I mine tester tar C
-mikrosekunder, så det ville tatt lengre tid å spawne trådene enn å bare
-gjøre det sekvensielt??