improvements, and started parallel

inf2440/hw4/Main.java

@@ -9,16 +9,23 @@ class Main {
 		Oblig4 seq = new Sequential(points);
 		Oblig4 par = new Parallel(points);
 
-		Timer ts = new Timer().start();
-		seq.solve();
-		ts.end();
-		System.out.println("Sequential: "+ts.prettyTime());
+		Timer tseq = run(seq, null);
+		run(par, tseq);
+	}
+
+	static Timer run(Oblig4 o, Timer base) {
+		System.out.println(o.name+": filling...");
+		o.fill();
+		System.out.println("Done.");
 
-		Timer tp = new Timer().start();
-		par.solve();
-		tp.end();
-		System.out.println("Parallel: "+tp.prettySpeedup(ts));
+		Timer t = new Timer().start();
+		o.solve();
+		t.end();
+		if (base == null)
+			System.out.println(o.name+": "+t.prettyTime());
+		else
+			System.out.println(o.name+": "+t.prettySpeedup(base));
 
-		seq.draw();
+		return t;
 	}
 }

inf2440/hw4/Oblig4.java

@@ -16,6 +16,10 @@ abstract class Oblig4 {
 		x = new int[n];
 		y = new int[n];
 		coHull = new IntList();
+	}
+
+	// Fill x and y arrays
+	void fill() {
 		points.fyllArrayer(x, y);
 	}
 

inf2440/hw4/Parallel.java

@@ -1,4 +1,8 @@
 class Parallel extends Oblig4 {
+	int nThreads = Math.min(
+		Runtime.getRuntime().availableProcessors(),
+		16);
+
 	Parallel(NPunkter17 points) {
 		super(points);
 		name = "Parallel";
@@ -6,5 +10,67 @@ class Parallel extends Oblig4 {
 
 	@Override
 	void solve() {
+		MinMaxXY minmax = findMinMax();
+		MAX_X = x[minmax.maxX];
+		MAX_Y = y[minmax.maxY];
+
+		IntList indexes = new IntList(n);
+		for (int i = 0; i < n; ++i)
+			indexes.add(i);
+	}
+
+	class MinMaxXY {
+		int minX, maxX, maxY;
+	}
+
+	class FindMinMaxWorker extends Thread {
+		int start, end;
+		int minX, maxX, maxY;
+		FindMinMaxWorker(int start, int end) {
+			this.start = start;
+			this.end = end;
+			this.minX = start;
+			this.maxX = start;
+			this.maxY = start;
+		}
+
+		public void run() {
+			for (int i = start + 1; i < end; ++i) {
+				if (x[i] < x[minX])
+					minX = i;
+				if (x[i] > x[maxX])
+					maxX = i;
+				if (y[i] > y[maxY])
+					maxY = i;
+			}
+		}
+	}
+
+	MinMaxXY findMinMax() {
+		FindMinMaxWorker[] workers = new FindMinMaxWorker[nThreads];
+
+		int d = n / nThreads;
+		for (int i = 0; i < nThreads; ++i) {
+			workers[i] = new FindMinMaxWorker(
+				d * i,
+				(i == nThreads - 1
+					? n - 1
+					: d * (i + 1)));
+			workers[i].start();
+		}
+
+		MinMaxXY minmax = new MinMaxXY();
+		for (FindMinMaxWorker w: workers) {
+			try { w.join(); } catch (InterruptedException ex) {}
+
+			if (x[w.minX] < x[minmax.minX])
+				minmax.minX = w.minX;
+			if (x[w.maxX] > x[minmax.maxX])
+				minmax.maxX = w.maxX;
+			if (y[w.maxY] > y[minmax.maxY])
+				minmax.maxY = w.maxY;
+		}
+
+		return minmax;
 	}
 }

inf2440/hw4/Sequential.java

@@ -31,18 +31,14 @@ class Sequential extends Oblig4 {
 	MinMaxXY findMinMax() {
 		int minX = 0;
 		int maxX = 0;
-
 		int maxY = 0;
 
 		for (int i = 1; i < n; ++i) {
-			int px = x[i];
-			if (px < x[minX])
+			if (x[i] < x[minX])
 				minX = i;
-			if (px > x[maxX])
+			if (x[i] > x[maxX])
 				maxX = i;
-
-			int py = y[i];
-			if (py > y[maxY])
+			if (y[i] > y[maxY])
 				maxY = i;
 		}