commit 63f27e6a939009e6257c910d8883cb9250bbc59a Author: Claudio Maggioni Date: Sun May 7 18:10:54 2023 +0200 Added assignment sources diff --git a/Assignment04-model_checking.pdf b/Assignment04-model_checking.pdf new file mode 100644 index 0000000..52e999d Binary files /dev/null and b/Assignment04-model_checking.pdf differ diff --git a/Reversal/.gitignore b/Reversal/.gitignore new file mode 100644 index 0000000..ec376bb --- /dev/null +++ b/Reversal/.gitignore @@ -0,0 +1,2 @@ +.idea +target \ No newline at end of file diff --git a/Reversal/README.md b/Reversal/README.md new file mode 100644 index 0000000..3cf19f7 --- /dev/null +++ b/Reversal/README.md @@ -0,0 +1,7 @@ +# Array reverser Java sources + +To compile and execute the reverser run: + +```shell +mvn clean compile exec:java +``` \ No newline at end of file diff --git a/Reversal/pom.xml b/Reversal/pom.xml new file mode 100644 index 0000000..c822ad8 --- /dev/null +++ b/Reversal/pom.xml @@ -0,0 +1,27 @@ + + 4.0.0 + + ch.usi.inf.si + reverse + jar + 1.0.0 + + + 1.8 + 1.8 + + + + + + org.codehaus.mojo + exec-maven-plugin + 1.2.1 + + ReverserTest + + + + + diff --git a/Reversal/src/main/java/ArrayReverser.java b/Reversal/src/main/java/ArrayReverser.java new file mode 100644 index 0000000..a64933a --- /dev/null +++ b/Reversal/src/main/java/ArrayReverser.java @@ -0,0 +1,19 @@ +abstract class ArrayReverser implements Reverser +{ + volatile int[] array; + volatile int[] reversed; + + public void setArray(int[] array) { + this.array = array; + this.reversed = new int[array.length]; + } + + public int[] array() { + return array; + } + + public int[] reversed() { + return reversed; + } + +} diff --git a/Reversal/src/main/java/ParallelReverser.java b/Reversal/src/main/java/ParallelReverser.java new file mode 100644 index 0000000..0d19aa3 --- /dev/null +++ b/Reversal/src/main/java/ParallelReverser.java @@ -0,0 +1,64 @@ +import java.util.ArrayList; + +class ParallelReverser extends ArrayReverser +{ + + // number of threads + private final int N; + // number of elements mapped by each thread + private final int S; + + // reverse `array` using N threads + public ParallelReverser(int[] array, int N) { + setArray(array); + this.N = N; + this.S = array.length / this.N; + } + + public void reverse() { + ArrayList threads = new ArrayList<>(); + for (int n = 0; n < N; n++) { + // thread t will reverse a[n*S..n*S + S] + int from = n*S; + int to = (n*S + S); + // the last thread takes what's left + if (n == N - 1) + to = array.length; + ThreadedReverser s = new ThreadedReverser(array, from, to, reversed); + Thread t = new Thread(s); + threads.add(t); + // start the thread + t.start(); + } + // wait for all threads to terminate + for (int k = 0; k < threads.size(); k++) { + try { + Thread t = threads.get(k); + // wait for thread t to terminate + t.join(); + } catch (InterruptedException s) { + System.out.println("Thread interrupted"); + } + } + } + +} + + +class ThreadedReverser extends SequentialReverser implements Runnable +{ + private int from, to; + + ThreadedReverser(int[] array, int from, int to, int[] result) { + super(array); + // reverse `array` into the given `result` array + this.reversed = result; + this.from = from; + this.to = to; + } + + public void run() { + reverse(from, to); + } + +} diff --git a/Reversal/src/main/java/Reverser.java b/Reversal/src/main/java/Reverser.java new file mode 100644 index 0000000..87f5e53 --- /dev/null +++ b/Reversal/src/main/java/Reverser.java @@ -0,0 +1,17 @@ +interface Reverser +{ + + // reverse current array + void reverse(); + + // set array to be reversed and resets reversed array + void setArray(int[] array); + + // get current, unreversed array + int[] array(); + + // get the results after calling reverse() + int[] reversed(); + +} + diff --git a/Reversal/src/main/java/ReverserTest.java b/Reversal/src/main/java/ReverserTest.java new file mode 100644 index 0000000..b7ca764 --- /dev/null +++ b/Reversal/src/main/java/ReverserTest.java @@ -0,0 +1,70 @@ +import java.util.Arrays; + +class ReverserTest +{ + + private int[] testSequential(int[] a) { + SequentialReverser rev = new SequentialReverser(a); + rev.reverse(); + boolean ok = true; + for (int k = 0; k < a.length; k++) + ok = ok && (a[k] == rev.reversed()[a.length - k - 1]); + if (!ok) + System.out.println("Reversal error: " + Arrays.toString(a) + " reversed: " + Arrays.toString(rev.reversed())); + return rev.reversed(); + } + + private int[] testParallel(int[] a, int N) { + ParallelReverser rev = new ParallelReverser(a, N); + rev.reverse(); + return rev.reversed(); + } + + private boolean check(int[] a, int N) { + int[] s = testSequential(a); + int[] p = testParallel(a, N); + boolean result = Arrays.equals(s, p); + if (result) + System.out.println("Test successful"); + else + System.out.println("Sequential reversal: " + Arrays.toString(s) + " but parallel reversal: " + Arrays.toString(p)); + return result; + } + + void test1() { + int[] a = {1, 2, 3, 4, 5, 6}; + check(a, 1); + check(a, 2); + check(a, 3); + check(a, 5); + } + + void test2() { + int[] a = {-1, 2, -3, 4, -5, 6, -7}; + check(a, 3); + check(a, 4); + } + + void test3() { + int[] a = { }; + check(a, 1); + check(a, 2); + check(a, 3); + } + + void test4() { + int[] a = { 1 }; + check(a, 1); + check(a, 2); + check(a, 3); + } + + public static void main(String[] args) { + ReverserTest o = new ReverserTest(); + o.test1(); + o.test2(); + o.test3(); + o.test4(); + } + +} diff --git a/Reversal/src/main/java/SequentialReverser.java b/Reversal/src/main/java/SequentialReverser.java new file mode 100644 index 0000000..293fb63 --- /dev/null +++ b/Reversal/src/main/java/SequentialReverser.java @@ -0,0 +1,20 @@ +class SequentialReverser extends ArrayReverser +{ + + public SequentialReverser(int[] array) { + setArray(array); + } + + public void reverse() { + // reverse all elements of `array` + reverse(0, array.length); + } + + // reverse elements of `array` from index `from` (included) to + // index `to` (excluded) into array `reversed` + void reverse(int from, int to) { + for (int k = from; k < to; k++) + reversed[reversed.length - k - 1] = array[k]; + } + +}