done

inf2440/hw2/Parallel.java

@@ -221,35 +221,6 @@ class Parallel implements Solver {
 
 		FactorMonitor monitor = new FactorMonitor(sieve, num, nThreads);
 		return monitor.getFactors();
-
-		/*
-		int[] primes = sieve.getPrimes();
-
-		ArrayList<Long> factors = new ArrayList<>();
-		int sqrt = (int)Math.sqrt(num);
-		for (int i = 0; i < primes.length; ++i) {
-			int p = primes[i];
-			if (p == 0)
-				break;
-
-			if (p > sqrt)
-				break;
-
-			while (num % p == 0) {
-				factors.add(new Long(p));
-				num /= p;
-				sqrt = (int)Math.sqrt(num);
-			}
-		}
-
-		if (num != 1)
-			factors.add(num);
-
-		long[] arr = new long[factors.size()];
-		for (int i = 0; i < arr.length; ++i)
-			arr[i] = factors.get(i);
-		return arr;
-		*/
 	}
 
 	public void stopThreads() {

inf2440/hw2/output.txt

@@ -1,11 +1,11 @@
-elli ~/tmp $ java Main 2000000000
+martin@elli:~/tmp$ java Main 2000000000
 Max prime: 2000000000
 
 Finding primes sequentially...
-Sequential: 9.83s
+Sequential: 9.92s
 
 Finding primes in parallel...
-Parallel: 6.92s (1.42x speedup)
+Parallel: 6.88s (1.44x speedup)
 
 Factoring sequentially...
 4000000000000000000 = 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5
@@ -19,7 +19,7 @@ Factoring sequentially...
 3999999999999999902 = 2 * 49965473 * 40027640687
 3999999999999999901 = 19 * 2897 * 72670457642207
 3999999999999999900 = 2 * 2 * 3 * 5 * 5 * 89 * 1447 * 1553 * 66666667
-Sequential: 1176.19s
+Sequential: 19.46s (194.60ms per factor)
 
 Factoring in parallel...
 4000000000000000000 = 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5
@@ -33,5 +33,4 @@ Factoring in parallel...
 3999999999999999902 = 2 * 49965473 * 40027640687
 3999999999999999901 = 19 * 2897 * 72670457642207
 3999999999999999900 = 2 * 2 * 3 * 5 * 5 * 89 * 1447 * 1553 * 66666667
-Parallel: 356.50s (3.30x speedup)
-
+Parallel: 11.66s (1.67x speedup) (116.55ms per factor)

inf2440/hw2/rapport.txt

@@ -35,60 +35,52 @@ tallet til listen faktorer, siden vi da vet at det er en faktor.
 Måten primtallene fordeles på, er at hver tråd tar hvert n-te primtall, hvor n
 er antall tråder, og hver tråd gis en unik startposisjon. Hvis det for eksempel
 er 2 tråder, vil tråd 1 ta primtall 1(3), 3(7), 5(13), etc, og tråd 2 vil ta
-primtall 2(5), 4(11), 6(17), etc. (I trådene later jeg som at alle primtall er
-oddetall og at 3 er det første primtallet, og lar monitoren ta seg av 2, fordi
-det gjør ting mye lettere.)
-
-Legg også merke til at jeg gjenbruker trådene mine, fordi det hadde tatt en del
-tid å lage 400 tråder, 4 for hver faktorisering.
-
-Noe jeg kunne ha gjort, som ville ha gjort koden min mye raskere,
-er å lage et array av primtall, istedenfor å bare gå igjennom oddetall og
-spørre silen om det er et primtall. Dette kom jeg på for sent til å kunne
-prøve det ut.
+primtall 2(5), 4(11), 6(17), etc. (Monitoren tar seg av de første 4
+primtallene, fordi det tar så kort tid å finne dem at det ikke gir mening
+å ha tråder som leter etter dem)
 
 # Tider
 
 CPU: quad core Intel Xeon E31225 @ 3.1 GHz (ingen hyperthreading)
 
-## Analyse:
-
-* Erastothenes' sil sekvensielt:
-	Tidene øker tilnærmet lineært mellom 20m, 200m, og 2 milliarder;
-	10x større tall betyr 10x lengre tid.
-	Mellom 2m og 20m øker tiden av en eller annen grunn bare 4.5x, men det
-	er nærme nok 10x at jeg ikke vet om det betyr noe.
-* Erastothenes' sil parallelt:
-	Igjen øker tidene tilnærmet lineært mellom 20m, 200m, og 2 milliarder,
-	og forskjellen på 2m og 20m er igjen bare rundt 4x.
-	Både parallelt og sekvensielt kan det se ut som at
-	jo større tallene er, jo nærmere kommer vi lineær økning.
-
-* Faktorisering sekvensielt:
-	Her er økningen i tid stort sett lineær mellom alle verdier.
-* Faktorisering parallelt:
-	Igjen er økningen tilnærmet lineær.
-
 2 000 000 000:
 	* Erastothenes' Sil sekvensielt: 9.82s
 	* Erastothenes' Sil parallelt: 6.77s (1.45x speedup)
-	* Faktorisering sekvensielt: 1176.19s
-	* Faktorisering parallelt: 356.50s (3.3x speedup)
+	* Faktorisering sekvensielt: 19.46s (294.60ms per)
+	* Faktorisering parallelt: 11.66s (1.67x speedup) (116.55ms per)
 
 200 000 000:
 	* Erastothenes' Sil sekvensielt: 829.98ms
 	* Erastothenes' Sil parallelt: 618.72ms (1.34x speedup)
-	* Faktorisering sekvensielt: 115.10s
-	* Faktorisering parallelt: 37.20s (3.09x speedup)
+	* Faktorisering sekvensielt: 4.82s (48.25 per)
+	* Faktorisering parallelt: 1.46s (3.30x speedup) (14.64ms per)
 
 20 000 000:
 	* Erastothenes' Sil sekvensielt: 68.11ms
 	* Erastothenes' Sil parallelt: 41.41ms (1.64x speedup)
-	* Faktorisering sekvensielt: 13.82s
-	* Faktorisering parallelt: 4.31s (3.21x speedup)
+	* Faktorisering sekvensielt: 508.17ms (5.08ms per)
+	* Faktorisering parallelt: 213.90ms (2.38x speedup) (2.14ms per)
 
 2 000 000:
 	* Erastothenes' Sil sekvensielt: 15.67ms
 	* Erastothenes' Sil parallelt: 9.58ms (1.64x speedup)
-	* Faktorisering sekvensielt: 1.17s
-	* Faktorisering parallelt: 534.75s (2.18x speedup)
+	* Faktorisering sekvensielt: 93.61ms (936.07μs per)
+	* Faktorisering parallelt: 73.76ms (1.27x speedup) (737.58μs per)
+
+## Analyse:
+
+* Erastothenes' sil sekvensielt:
+	Tidene øker tilnærmet lineært mellom 20m, 200m, og 2 milliarder;
+	10x større tall betyr 10x lengre tid.
+	Mellom 2m og 20m øker tiden av en eller annen grunn bare 4.5x, men det
+	er nærme nok 10x at jeg ikke vet om det betyr noe.
+* Erastothenes' sil parallelt:
+	Igjen øker tidene tilnærmet lineært mellom 20m, 200m, og 2 milliarder,
+	og forskjellen på 2m og 20m er igjen bare rundt 4x.
+	Både parallelt og sekvensielt kan det se ut som at
+	jo større tallene er, jo nærmere kommer vi lineær økning.
+
+* Faktorisering sekvensielt:
+	Økningen her ligner mer på eksponensiell økning.
+* Faktorisering parallelt:
+	Igjen ser økningen eksponensiell ut.