Integrantes:

Jose Luis Quispe Huaman

Oskar Cunisi Chuquitapa

Qué es el paralelismo
Paralelismo es la ejecución simultánea de dos o más tareas. Se considera una
propiedad del hardware, ya que requiere recursos físicos para ejecutar cada
tarea simultáneamente, y su objetivo se basa en realizar una tarea en el menor
tiempo posible.

Paralelismo NO es concurrencia
El término paralelismo suele confundirse en numerosas ocasiones con el
concepto de concurrencia. Ambos se basan en la programación multitarea, pero
no son lo mismo.

Código del proyecto haciendo uso de los métodos mergesort() y sort()

Result solve (Problem problem) {

if problem.size < SEQUENTIAL_THRESHOLD
return solveSequentially(problem);
else {
Result left, right;
INVOKE-IN-PARALLEL {
left = solve(extractLeftHalf(problem));
right = solve(extractRightHalf(problem));
}
return combine(left, right);
}
}

function mergesort(a)
var left as array = a[0] ... a[n/2]
var right as array = a[n/2+1] ... a[n]
left = mergesort(left)
right = mergesort(right)
return merge(left, right)
end function

function merge(left,right)
var result as array
while length(left) > 0 and length(right) > 0
if first(left) ≤ first(right)
append first(left) to result
 left = rest(left)
else
append first(right) to result
right = rest(right)
if length(left) > 0
append rest(left) to result
if length(right) > 0
append rest(right) to result
return result
end function

public class MergeSort {

public void sort(Integer[] a) {
Integer[] helper = new Integer[a.length];
mergesort(a, helper, 0, a.length - 1);
}

private void mergesort(Integer[] a, Integer[] helper, int lo, int hi) {

if (lo < hi) {
int mid = lo + (hi - lo) / 2;
mergesort(a, helper, lo, mid);
mergesort(a, helper, mid + 1, hi);
merge(a, helper, lo, mid, hi);
} else {
return;
}
}

private void merge(Integer[] a, Integer[] helper, int lo, int mid, int hi) {
/* code */
}
}

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

public class MergeSortForkJoin {

public void sort(Integer[] a) {
Integer[] helper = new Integer[a.length];
ForkJoinPool forkJoinPool = new ForkJoinPool();
forkJoinPool.invoke(new MergeSortTask (a, helper, 0, a.length-1));
}

private class MergeSortTask extends RecursiveAction{

private static final long serialVersionUID = -749935388568367268L;
private final Integer[] a;
 private final Integer[] helper;
private final int lo;
private final int hi;

public MergeSortTask(Integer[] a, Integer[] helper, int lo, int hi){

this.a = a;
this.helper = helper;
this.lo = lo;
this.hi = hi;
}

@Override
protected void compute() {
if (lo < hi) {
int mid = lo + (hi-lo)/2;
MergeSortTask left = new MergeSortTask (a, helper, lo, mid);
MergeSortTask right = new MergeSortTask (a, helper, mid+1, hi);
invokeAll(left, right);
merge(this.a, this.helper, this.lo, mid, this.hi);
} else {
return;
}
}

private void merge(Integer[] a, Integer[] helper, int lo, int mid, int hi) {
/* code */
}
}
}

Estas pruebas han consistido en la ordenación de colecciones de distintos

tamaños, siendo las colecciones una generación de números enteros aleatorios
entre -100.000 y 100.000, y ordenándose cada colección siempre primero en
secuencial y después en paralelo.
Para las pruebas de colecciones grandes se han fijado cuatro tamaños para las
colecciones a ordenar: 50, 100, 250 y 500 elementos. Para cada tamaño se
han generado tres listas, ordenando cada una mediante MergeSort secuencial
y posteriormente ordenando cada una a través de MergeSort paralelizado