Pattern for parallel programming - concurrency stage

Introduction

This article is a code example that is changed from serial to parallel.




In the book "patterns for parallel programming" by Timothy G. Mattson, Beverly A. Sanders and Berna L. Massingill.
They have broken the pattern language structure into 4 design spaces.




The first design space is: "finding concurrency". In the next code ( that
show a plane that can shooting ) exists a "concurrency block" when each
shoot is moving. But this code is serial.




The serial code

#include <stdio.h>
#include <conio.h>
#include <windows.h>

/*
@autor jose jesus ambriz meza
@fecha 23/en/2010
@descrip programa en "simbolo de sistema" que muestra un avion
   lanzando tiros ( máximo 10 ) no validado todavía la
   eliminación de los tiros que llegan a la máxima columna.
   
   this airplane can shooting 10 shot. It has a 
   concurrent code when the shots are moving.
*/
#define SIMBOLO_ASTERISCO '*'
#define CHARACTER_SALIDA 'x'
#define SIMBOLO_ARRIBA 'e'
#define SIMBOLO_ABAJO 'c'
#define SIMBOLO_DISPARO ' '
#define CANTIDAD_MAXIMA_DISPAROS 5
#define SIMBOLO_GUION '-'
#define TIEMPO_ESPERA_ENTRE_DISPAROS 30
#define COLUMNA_MAXIMA 40

void mostrarAvion( int c, int r, char simbolo );
void mostrarSimbolo( int c, int r, char simbolo );
void agregarDisparo( int c, int r, int colDisparos[],int renDisparos[], int *cantDisparos );

void main()
{
 int colAsterisco=3, renAsterisco=10; //posicion del avion
 char letra; //letra recibida
 int colDisparos[ CANTIDAD_MAXIMA_DISPAROS ]; //columna de cada disparo
 int renDisparos[ CANTIDAD_MAXIMA_DISPAROS ]; //renglón de cada disparo
 int cantDisparos= 0; //cantidad de disparos
 int disparoActual= 0;
 
 clrscr(); //limpiar pantalla
 mostrarAvion( colAsterisco, renAsterisco, SIMBOLO_ASTERISCO ); //mostrar avion por primera vez
 while ( (letra=getch())!= CHARACTER_SALIDA ) //tomar lectura de teclado
 {
  mostrarAvion( colAsterisco, renAsterisco, SIMBOLO_DISPARO ); //borrar avion en cada movimiento
  switch ( letra )
  {
   case SIMBOLO_ARRIBA: //avion hacia arriba
    if ( renAsterisco>2 ) //si se puede hacer hacia arriba
    {
     renAsterisco-=1;
    }
    break;
   case SIMBOLO_ABAJO:  //avion hacia abajo
    if ( renAsterisco<79 ) //si se puede hacer hacia abajo
    {
     renAsterisco+=1;
    }
    break;
   case SIMBOLO_DISPARO:
    if ( cantDisparos< CANTIDAD_MAXIMA_DISPAROS ) //hay disparos disponibles
    {
     agregarDisparo( colAsterisco, renAsterisco, colDisparos,renDisparos, &cantDisparos );
    }
    break;
  }
  mostrarAvion( colAsterisco, renAsterisco, SIMBOLO_ASTERISCO ); //mostrar avion en cada movimiento
  /*
  Begins concurrency block
  */
  while ( !kbhit() )
  {
   if ( cantDisparos>0 ) //si hay disparos
   {
    mostrarSimbolo(   //borrar el disparo
     colDisparos[ disparoActual ],
     renDisparos[ disparoActual ], 
     SIMBOLO_DISPARO );
    colDisparos[ disparoActual ]+=1;
    mostrarSimbolo(   //mostrar el disparo
     colDisparos[ disparoActual ],
     renDisparos[ disparoActual ], 
     SIMBOLO_GUION );
    Sleep( TIEMPO_ESPERA_ENTRE_DISPAROS );
    //si el disparo realizado se salió de los límites de la pantalla
    if ( colDisparos[ disparoActual ] >= COLUMNA_MAXIMA )
    {
     mostrarSimbolo(   //borrar el disparo
      colDisparos[ disparoActual ],
      renDisparos[ disparoActual ], 
      SIMBOLO_DISPARO );
     //si quedan más disparos por hacer
     if ( disparoActual<(cantDisparos-1) )
     {
      //el último disparo remplaza al disparo actual
      colDisparos[ disparoActual ]= colDisparos[ cantDisparos -1 ];
      renDisparos[ disparoActual ]= renDisparos[ cantDisparos -1 ];
      //se vuelve al anterior disparo para el siguiente 
      //IF repita el disparo de la posición actual
      disparoActual -=1 ; 
     }
     cantDisparos -= 1; //se elimina el último disparo porque este cambio de lugar por el disparo eliminado
    }
    //si NO se recorrieron todos los disparos
    if ( disparoActual< (cantDisparos-1) )
     disparoActual += 1; //seguir con el siguiente disparo
    else
     disparoActual= 0;  //volver al primer disparo
   }
  }
  /*
  Ends concurrency block
  */

 }
}

/*
@descrip muestra el avion en una posición determinada
@param c columna de las alas del avión
@param r renglón del centro del avión
@param simbolo character con el cual se escribirá el avion, puede
  mostrarse o borrarse el avión con la misma subrutina.
*/
void mostrarAvion( int c, int r, char simbolo )
{
 gotoxy(c,r);printf("%c", simbolo );
 gotoxy(c,r-1);printf("%c", simbolo );
 gotoxy(c,r+1);printf("%c", simbolo );
 gotoxy(c+1,r);printf("%c", simbolo );
}

/*
@descrip muestra un símbolo en una posición determinada
@param c columna del símbolo
@param r renglón del símbolo
@param simbolo character que se muestra
*/
void mostrarSimbolo( int c, int r, char simbolo )
{
 gotoxy(c,r);
 printf("%c", simbolo );
}

/*
@descrip agrega un disparo al arreglo de disparos
@param c columna del avión del cual sale el disparo
@param r renglón del avión del cual sale el disparo
@param renDisparos arreglo que contiene los renglones de cada disparo
@param colDisparos arreglo que contiene las columnas de cada disparo
@param *cantDisparos cantidad de disparos, se cambiará al final
*/
void agregarDisparo( int c, int r, int colDisparos[],int renDisparos[], int *cantDisparos )
{
 colDisparos[ *cantDisparos ]= c + 2;
 renDisparos[ *cantDisparos ]= r;
 (*cantDisparos) += 1;
}

The next step is "Algorithm structure". One decision is made a thread for
the plane and another for all the shoots; but you can made a thread for the plane y one thread for each shoot.
Which are the best choice?

to be continued in the next article...

References
[1] Timothy G. Mattson, Beverly A. Sanders and Berna L. Massingill.
Patterns for Parallel Programming. 2005. Addison Wesley

Example of threads and Application.Run with two forms

In this code, Main method generate two applications in differents threads

using System;
using System.Windows.Forms;
using System.Threading;

/*
@descrip Execute two forms with "application.run" method.
@autor   José Jesús Ambriz Meza
@fecha  19/03/2010
@version 1
*/
namespace variasVentanas
{
 public class ventana: Form
 {
  public ventana(string t)
  {
   this.Text= t;
  }

  //start method for threading
  public void inicio()
  {
   Application.Run( this ); //start this application
  }
    
  public static void Main()
  {
   //new ventana object ( form object )
   ventana obj1= new ventana("uno");
   //new ventana object ( form object )
   ventana obj2= new ventana("dos");
   //new thread with obj1
   Thread t1= new Thread( obj1.inicio );
   //new thread with obj2
   Thread t2= new Thread( obj2.inicio );
   //execute Application.Run with obj1
   t1.Start();
   //execute Application.Run with obj2
   t2.Start();
  }
 }
}

recomendación de curso en sitio web de Intel

Esta es un video que muestra un curso que recomiendo para iniciar en la programaciòn paralela. Este curso se encuentra en los cursos que promueve ( courseware access ) Intel link.

Red de desarrolladores en programaciòn paralela

Es un esfuerzo de Intel por motivar la autocapacitación y el intercambio de experiencias entre programadores de todo el mundo en programación paralela.

link

Conversión aplicación consola a modo windowsForm

La información del programa mostrado en el anterior post (que tiene un video ) es colocada en el grupo de programación paralela que se encuentra en el siguiente enlace

Ejemplo en VS2008

A continuación se presenta un video que explica la conversión de una aplicación explicada en anteriores post ( ejecutada en modo consola ) a una aplicación de windows ( windows form application ) utilizando Ms Visual Studio 2008.

El código de la aplicación es el siguiente:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace winapp1
{
    public partial class Form1 : Form
    {
        private void calculaPares(object nombre)
        {
            int cont = 0;
            System.Console.WriteLine("iniciando: {0}", ((mensaje)nombre).msg);
            for (int i = 1; i <= 500000; cont += (i % 2 == 0 ? 1 : 0), i += 1) ;
            ((mensaje)nombre).msg= "pares " + cont.ToString();
        }

        public Form1()
        {
            InitializeComponent();
        }

        private void btn_iniciar_Click(object sender, EventArgs e)
        {
            mensaje objMsg1 = new mensaje("pares");     //objeto intercambio de datos creado
            Thread t1 = new Thread(this.calculaPares);  //Objeto hilo creado
            this.lb_pares.Text = objMsg1.msg;           //etiqueta de la forma = "pares"
            t1.Start( objMsg1 );                        //inicia el hilo
            while (t1.ThreadState == ThreadState.Running) ; //ciclo para esperar al hilo
            this.lb_pares.Text = objMsg1.msg;           //etiqueta de la forma = resultado hilo
        }
    }

    public class mensaje
    {
        String msg_;

        public mensaje(String valor)
        {
            msg_ = valor;
        }

        public String msg
        {
            get
            {
                return msg_;
            }
            set
            {
                msg_ = value;
            }
        }
    }

}

Diferencia entre c# y JAVA en los hilos.

Para JAVA hay dos métodos para programar hilos en una clase. Uno de ellos es heredar de la clase Thread [1]. Esta es otra diferencia de C# con JAVA, el primero permite a una clase heredar de JAVA.

Por ejemplo dado este código.

using System;
using System.Threading;

namespace codigosEjemplov2
{
 
 public class ejemplo1 :Thread
 {

  public static void calculaPares(object nombre)
  {
   int cont=0;
   System.Console.WriteLine("iniciando: {0}", ((mensaje) nombre).msg );
   for(int i=1; i<=500000; cont+=(i%2 ==0?1:0), i+=1 );
   System.Console.WriteLine("pares {0} ", cont);
  }

  public static void Main()
  {
   ejemplo1 obj1= new ejemplo1(ejemplo1.calculaPares);
   obj1.Start( );
  }
 }
}

Al compilar esta clase ejemplo1 se muestra el siguiente mensaje de error:

C:\temp>csc codigosEjemplov2.cs


Compilador de Microsoft (R) Visual C# 2008, versión 3.5.30729.1
para Microsoft (R) .NET Framework, versión 3.5
(C) Microsoft Corporation. Reservados todos los derechos.

codigosEjemplov2.cs(7,15): error CS0509: 'codigosEjemplov2.ejemplo1': no puede
        derivar del tipo sealed 'System.Threading.Thread'
c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\mscorlib.dll: (Ubicación del
        símbolo relacionado con el error anterior)

La definición de la clase Thread como de tipo Sealed se dio en la ayuda de las referencias [1] en el siguiente párrafo.

[ComVisibleAttribute(true)]
[ClassInterfaceAttribute(ClassInterfaceType.None)]
public sealed class Thread : CriticalFinalizerObject, 
    _Thread

Referencia
[1] Class Thread. Sun. enlace 1

[2] MSDN Library, No declarar miembros protegidos en tipos sealed.
enlace 2