Paralelizando….

Para este artículo les traigo un laboratorio muy simple sobre como acercar la escritura de código que paralelice procesamiento. Sabemos que hace un tiempo atrás se pensaba en megahercios pero actualmente podemos decir que pensamos en cores… Si esta hipótesis es correcta veamos cómo podemos hacer un mejor uso del multicore.

Para el laboratorio, voy a plantear un simple algoritmo secuencial y la misma resolución por medio de operaciones en paralelo. Como herramienta de desarrollo, voy a utilizar Visual Studio 2008, lenguaje C#, Plinq, una aplicación de consola, un biblioteca que aloje mi código en paralelo para luego validar su utilización desde otras presentaciones. Para realizar el análisis voy a emplear Vtune de Intel Corporation con Thread Profiler 3.1.

El eje de esta práctica tiene que ver con la aplicación de Plinq (Microsoft Parallel Extensions), en un esquema de componentes como el siguiente planteado:

Veamos el código llamador de la consola:

static
void Main(string[] args)

{

//Texto a trabajar

string texto = "Hola como es tu nombre";

string[] palabras = texto.Split(new
char[] { ' ', '\t', '\n', '\r', '-' }, StringSplitOptions.RemoveEmptyEntries);

// Secuencial

Cadenas c = new
Cadenas(); //Objeto con la logica de desarrollo

string[] resultado = c.Secuencial(palabras); //Metodo secuencial

Console.WriteLine("Completado"); //Informe de completado

// Paralelo

Cadenas cp = new
Cadenas(); //Objeto con la logica de desarrollo

string[] resultadop = cp.Parallelo(palabras);//Metodo Paralelo

Console.WriteLine("Completado"); //Informe de completado

}

Para el set de pruebas voy a realizar una actividad del analizador con el esquema secuancial y otro con el paralelo. Veamos el código de cada uno de los métodos:

///
<summary>

/// Metodo de comportamiento Secuencial

///
</summary>

///
<param name="cadenas">cadenas pasadas</param>

///
<returns></returns>

public
string[] Secuencial(string[] cadenas)

{

return (from cadena in cadenas

select OperarCadena(cadena)).ToArray();

}

///
<summary>

/// Metodo de comportamiento Parallelo

///
</summary>

///
<param name="cadenas"></param>

///
<returns></returns>

public
string[] Parallelo(string[] cadenas)

{

return (from cadena in cadenas.AsParallel().AsOrdered()

select OperarCadena(cadena)).ToArray();

}

///
<summary>

/// Actualmente no realiza lógica posibles comportamiento en un entorno elaborado.

///
</summary>

///
<param name="cadena"></param>

///
<returns></returns>

private
string OperarCadena(string cadena)

{

char[] cadenas = cadena.ToCharArray();

return
new
string(cadenas);

}

Bien, ya conocemos cada uno de los escenarios, vamos trabajar sobre el analizador, veamos la captura de datos del esquema secuencial:

Veamos la actividad sobre el escenario paralelo (notoriamente vemos el incremente de hilos para el trabajo de la problemática):

Veamos algo de gráfica:

Es claro que los ratios de paralelización se pueden visualizar y la misma ejecución mostró un mejor comportamiento en el ambiente paralelo, pero esto es solo un demo simple que incluso arroja datos de paralelización muy inferiores a los que realmente pueden ser aceptados en un aplicativo corporativo. A lo largo de algunos artículos les voy a graficar las mejores prácticas para llegar a un escenario consistente de programación paralela.

Espero les sea de utilidad.