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

This article was posted .