Esqueleto Algorítmico - ulpgc

Dpto. Estadística, I. O. y Computación. U. de La Laguna 

Implementación Secuencial y Paralela de 

Técnicas Algorítmicas: Aplicación a 

Problemas de Optimización Combinatoria 

Seminario Invitado: Dpto. de Métodos Cuantitativos en 

Economía y Gestión 

Marzo 2007 

Isabel Dorta, Coromoto León, Angélica Rojas 

http://nereida.deioc.ull.es/

Implementación Secuencial y Paralela de Técnicas Algorítmicas: 

Aplicación a Problemas de Optimización Combinatoria 

Seminario Invitado: Dpto Métodos Cuantitativos en Economía y Gestión 

apartados 

apartados 

Índice 

1. Introducción 

2. Interfaz de usuario de la librería MaLLBa 

subapartados 

subapartados 

3. Implementación de Patrones de Resolución 

o Esqueletos Secuenciales 

4. Implementación de Patrones de Resolución 

o Esqueletos Paralelos 

5. Experimentos Computacionales 

6. Conclusiones 

Mª Isabel Dorta González 

Marzo, 2007




Introducción 

Interfaz de 

Usuario de MaLLBa 

Apartado I: Introducción 

Patrones 

Secuenciales 

Patrones Paralelos 

Experimentos 

Computacionales 

Conclusiones 

1. Problema de optimización Combinatoria 

2. Técnicas Algorítmicas 

• Ramificación y Acotación 

• Divide y Vencerás 

3. Esqueletos Algorítmicos 

4. Programación Paralela 

• Herramienta MPI 

• Herramienta OpenMP 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 

Esqueletos 

Algorítmicos 

Definiciones sobre 

Programación 

Paralela 

Optimización Combinatoria 

Un problema de optimización combinatoria es una t-upla 

∏=(I, S, f, g) donde: 

• I es el conjunto de instancias de ∏. Si x ∈ I se dice que x es 

una instancia (o una entrada) de ∏ 

• Dada una instancia x ∈ I, S(x) denota el conjunto de 

soluciones factibles de x 

• Dada una instancia x ∈ I y una solución factible σ ∈ S(x), 

f(x, σ) representa el costo de σ con respecto a ∏ y x. La 

función f se denomina función objetivo 

•g ∈{max, min}. El objetivo de ∏ es encontrar una solución 

factible que optimice f en función de g: dado un valor x ∈ I, 

se trata de determinar una solución óptima σ´∈ S(x) tal que 

f(x, σ´) = g {f(x, σ) / σ ∈S(x)}. 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 

Definición: 

Caso de Estudio: El Problema de la Mochila 0/1 

“Se dispone de una mochila 

de capacidad C y de un 

conjunto de N objetos, siendo 

b k y p k el beneficio y 

el peso asociado al objeto k. 

Sin exceder la capacidad de 

la mochila, los objetos deben 

ser insertados en ésta 

proporcionando el máximo 

beneficio” 

Formulación como problema de 

Optimización 

sujeto 

a : 

max 

N 

∑ 

k = 1 

x 

p 

k 

∀k 

∈ 

k 

N 

∑ 

k = 1 

x 

k 

b 

k 

x 

k 

C 

{ 0, 

1} 

{ 1,...,N} 

∈ 

≤ 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 


Patrones 

Secuenciales 


Experimentos 


p = 20 

b = 100 

p = 30 

b = 60 

p = 2 

b = 15 

Conclusiones 

b = 90 

b = 1 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 

p = 20 

p = 40 

p = 10 

b = 40 b = 15 

p = 30 

b = 10 

C = 102 

La capacidad C es 102 

Los elementos N son 8 


Marzo, 2007 

p = 60




Introducción 

Interfaz de 

Usuario 

Técnicas Algorítmicas 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 

Son técnicas de diseño de algoritmos, que se adaptan al 

problema particular que se desea resolver. 

• Fuerza bruta 

• Divide y Vencerás (Divide and Conquer) 

• Búsqueda con retroceso (Backtracking) 

• Ramificación y Acotación (Branch and Bound) 

• Programación Dinámica 

• … 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 


Marzo, 2007 

• Árbol de búsqueda 

• Nodos: 

☺ 

 

 

• Vivo : no se han 

generado aún todos 

sus hijos 

• Muerto: no se van a 

generar más hijos 

• Actual: se están 

generando sus hijos 

• Lista de Nodos vivos 

Ramificación y Acotación 

 

 

 

☺ 

 

☺ 

☺ 

 

 

☺




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 

Ramificación y Acotación 

• Paso 1: Si la lista de nodos vivos está vacía, terminar. 

• Paso 2: Extraer un nodo vivo 

• Paso 3: Calcular su coste esperado. 

• Paso 4: Si el coste esperado es peor que el de la mejor 

solución hasta el momento, considerar ese nodo como nodo 

muerto y volver al paso 1. 

• Paso 5: Si el coste esperado es mejor que el de la mejor 

solución actual pero no es solución factible, generar todos 

sus hijos y convertirlo en nodo muerto. Ir al paso 1. 

• Paso 6: Si el coste esperado es mejor que el de la mejor 

solución actual y es solución factible, ésta pasa a ser la 

mejor solución. Ir al paso 1. 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 


Marzo, 2007 

 

No 


Cres = 102 

obj = 2 

pf = 0 

Cres = 102 

obj = 1 

pf = 0 

Cres = 102 

obj = 0 

pf = 0 

No Si 

Cres = 82 

obj = 1 

pf = 100 

No Si No Si 

Si 

Cres = 90 

obj = 2 

pf = 30 

 

Cres = 82 

obj = 2 

pf = 100 

Espacio de búsqueda, organizado como un árbol 

No 

 

. . . . . . 

. . . . . . 

Cres = 52 

obj = 2 

pf = 115 

Si




Introducción 

Interfaz de 

Usuario 

Problema de Ordenación 

Patrones 

Secuenciales 

b = 100 

b = 60 

b = 15 


Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 

p = 20 

b = 90 

p = 20 

b = 10 

p = 30 

b = 1 

p = 10 

b = 15 

p = 2 

b 

p 

1 

1 

≥ 

b 

p 

2 

2 

≥ 

b 

p 

3 

3 

≥ 

... 

≥ 

b 

p 

Beneficios b k = {15,100, 90, 60, 40, 15, 10, 1} 

Pesos p k = { 2, 20, 20, 30, 40, 30, 60, 10} 

N 

N 



p = 60 

p = 30 


Programación 

Paralela 

b = 40 


Marzo, 2007 

p = 40 

1 2 3 4 5 6 7 8

Cres = 102 

obj = 2 

pf = 0 

Cres = 102 

obj = 1 

pf = 0 

No Si 

No Si No Si 

. . . 

Cres = 82 

obj = 2 

pf = 100 

. . . 

Cres = 102 

obj = 0 

pf = 0 

Cres = 100 

obj = 2 

pf = 15 

. . . 

 

Cres = 100 

obj = 1 

pf = 15 

No 

Cres = 80 

obj = 3 

pf = 115 

Cres = 80 

obj = 2 

pf = 115 

No 

Si 

Cres = 60 

obj = 3 

pf = 205 

Cres = 30 

obj = 6 

pf = 265 

 

. . . 

No 

Cres = 30 

obj = 5 

pf = 265 

No 

Si 

Cres = 30 

obj = 4 

pf = 265 

Cres = 0 

obj = 7 

pf = 280 

Si 

Cres = 0 

obj = 6 

pf = 280 

Si 




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

No Si 

 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 

. . . No 




Programación 

Paralela 


Árbol de Búsqueda: 

Problema de la Mochila 

Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 

Divide y Vencerás 

• Descomponer el problema a resolver en 

un cierto número de subproblemas más 

pequeños que el original, pero con la 

misma estructura 

• Resolver independientemente cada 

subproblema 

• Combinar los resultados obtenidos para 

obtener la solución al problema original 

Aplicar esta técnica recursivamente 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 


• Paso 1: Si x es suficientemente simple resolverlo, 

devolver la solución e ir al paso 6. En caso contrario ir 

al paso 2. 

• Paso 2: descomponer x en casos más pequeños 

x 1 ,x 2 ,…,x k 

• Paso 3: para i = 1, …, k aplicar el mismo 

procedimiento hasta obtener y i = Divide y Vencerás (x i ) 

• Paso 4: recombinar los y i , para obtener una solución y 

de x 

• Paso 5: devolver y 

• Paso 6: finalizar 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Problema 

de 

Ordenación 

b 

p 

1 

1 

b 

> 

p 

2 

2 

> ... > 

b 

p 

N 

N 

1 0,1 5 2 7,5 4,5 0,1 0,5 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 

Fase 

de 

división 

1 0,1 5 2 7,5 4,5 0,1 0,5 


Marzo, 2007 

1 0,1 5 2 7,5 4,5 0,1 0,5




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


1 0,1 5 2 7,5 4,5 0,5 0,1 

Experimentos 


Conclusiones 

Fase de 

combinación 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 

5 2 1 0,1 7,5 4,5 0,5 0,1 




Programación 

Paralela 


Marzo, 2007 

7,5 5 4,5 2 1 0,5 0,1 0,1




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 

La definición que se da de esqueleto 

en el diccionario de la Lengua 

Española de la Real Academia es la 

que sigue: 

“Anat. Conjunto de piezas duras y 

resistentes, por lo regular trabadas y 

articuladas entre sí, que da 

consistencia al cuerpo de los 

animales, sosteniendo o protegiendo 

sus partes blandas. Armazón que 

sostiene algo. Col., Cos. Rica, Guat., 

Méx., y Nic., Modelo o patrón 

impreso en el que se dejan blancos 

que se rellenan a mano.” 



Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Esqueleto Algorítmico 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 

Esqueleto algorítmico: conjunto de procedimientos 

que constituyen el armazón con el que 

desarrollar programas para resolver un 

problema dado utilizando una técnica particular. 

Este software tiene algunos blancos que se han 

de rellenar para adaptarlo a la resolución de un 

problema concreto. 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Definiciones sobre Programación Paralela 

Patrones 

Secuenciales 


Experimentos 


Modelo 

Algoritmo 

Implementación 

Secuencial 

Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 

MPI, 

Java Sockets, 

OpenMP, 

Herramientas: 

esqueletos 


Marzo, 2007 

Implementación Paralela




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Herramienta 

MPI 


Multicomputador o 

Modelo Multiprocesador con Paso de Mensaje 

Red de interconección 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 

Mensajes 

Procesador 

Memoria 

local 


Computadores 

Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 



Modelo Multiprocesador de Memoria Compartida 

Experimentos 


Conclusiones 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 


Marzo, 2007 

Herramienta 

OpenMP 

Memoria compartida 

Red de interconección 

Procesadores




Introducción 

Interfaz de 

Usuario 


Patrones 

Secuenciales 


Experimentos 


• Contenido 

Conclusiones 

Mensaje 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 


Marzo, 2007 

• Sobre 

• Qué procesador envía el mensaje 

• Dónde están los datos en el procesador 

emisor 

• Qué clase de datos se están enviando y 

cuántos. 

• Qué procesador(es) tienen que recibir el 

mensaje. 

• Dónde se deben dejar los datos en el 

procesador receptor. 

• Cuántos datos debe estar el procesador 

receptor preparado para recibir




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Tiempo de ejecución: 

Definiciones sobre Programación paralela 

• programa secuencial t(n) 

Conclusiones 

• programa paralelo 

t(n,p)= ta(n,p) + tc(n,p) 

Optimización 

Combinatoria 

Técnicas 

Algorítmicas 




Programación 

Paralela 

- ta(n,p) : suma de los tiempos de las distintas partes de 

computación 

- tc(n,p) : suma de los tiempos de las distintas partes de 

comunicación 

- Desbalanceo de la carga 

Aceleración (Speed-up) 


Marzo, 2007 

S(n,p) = t(n) / t(n,p)




Introducción 

Interfaz de 

Usuario 

Apartado II: Interfaz de Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

1. Interfaz de Usuario Genérica de MaLLBa 

2. Interfaz de Usuario para Ramificación y Acotación 

1. Clases Requeridas 

2. Ejemplo: El Problema de la Mochila 0/1 

3. Interfaz de Usuario para Divide y Vencerás 

1. Clases requeridas 

2. Ejemplo: Problema de Ordenación 

4. Clases Proporcionadas 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

MaLLBa ofrece un conjunto de 

técnicas de resolución para 

resolver problemas de 

Optimización Combinatoria. 

Cada técnica se encapsula en 

un “esqueleto”. 

Interfaz de Usuario de MaLLBa 

Combinador de 


Interfaz de Usuario 

de MaLLBa 

Interfaz Ramificación 

y Acotación 

Interfaz Divide y 

Vencerás 

Clases 

Proporcionadas 


Marzo, 2007 

Las entidades de un esqueleto 

algorítmico MaLLBa son: 

• Programador de 


• Programador de 

Soluciones 

• Usuario de Esqueletos 

• Combinador de 


Usuario de 


Programador de 

Soluciones 

Programador de 

Esqueletos




Introducción 

Interfaz de 

Usuario 

Interfaz de Usuario de MaLLBa 

Patrones 

Secuenciales 

Técnica.req.cc 

Solution 

Setup 


Experimentos 


Conclusiones 


Setup 

Solver 

Técnica.pro.cc 


de MaLLBa 

Solver 

Técnica.hh 


y Acotación 


Vencerás 

Solution 

Problem 

Specific 

classes 

Clases 


Specific 

Classes 

Setup 


Marzo, 2007 

Requeridas 

Solver




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Requeridas 

Interfaz de Usuario de MaLLBa::BnB: Esquema UML 

Solution Problem Setup SubProblem 

+ lower_bound() 

+ upper_bound() 

+ branch() 


de MaLLBa 


«interface» 

Solver 


y Acotación 


Vencerás 

Solver_Seq 

Solver_Lan 

Solver_SM 

Clases 


Solver_Centralized 

Solver_Distributed 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Clases Requeridas Esqueleto B&B 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 


de MaLLBa 


y Acotación 


Vencerás 

Clases 


• Problem 

• Solution 

• SubProblem 

• initSubProblem 

• branch 

• lower_bound 

• upper_bound 

Solution 

Problem 

SubProblem 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 


de MaLLBa 


y Acotación 


Vencerás 

Ejemplo: EL Problema de la Mochila 0/1 

requires class Problem { 

public: 

Number C, // Capacidad 

N; // Número de objetos 

vector p, // beneficios 

w; // pesos 

Problem (); 

~Problem (); 

inline Direction direction() const {return Maximize;}; 

. . . 

friend opacket& operator> (ipacket& is, Problem& pbm); 

}; 

requires class Solution { 

public: 

vector s; 

Clases 



Marzo, 2007 

} 

Solution (); 

~Solution (); 

. . . 

friend opacket& operator> (ipacket& is, Solution& sol);




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 


de MaLLBa 


requires class SubProblem { 

public: 

Number CRest, // capacidad actual 

obj, // objeto siguiente 

profit; // beneficio actual 

Solution sol; // Solución actual 

SubProblem (); // constructor 

~SubProblem (); // destructor 

... 


y Acotación 


Vencerás 

Clases 



Marzo, 2007 

}; 

friend opacket& operator> (ipacket& is, SubProblem& sp); 

void initSubProblem (const Problem& pbm); 

void branch (const Problem& pbm, 

branchQueue& subpbms); 

Bound upper_bound (const Problem& pbm, Solution& ls); 

Bound lower_bound (const Problem& pbm, Solution& us);




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 


void SubProblem::initSubproblem (const Problem& pbm) 

{ 

Crest = pbm.C; 

obj = 0; 

profit = 0; 

} 


de MaLLBa 


y Acotación 


Vencerás 

Clases 



Marzo, 2007 

void SubProblem::branch (const Problem& pbm, 

container& subpbms) 

{ 

SubProblem spNO = SubProblem(CRest,obj+1,profit); 

subpbms.insert(spNO); 

Number newC = CRest - pbm.w[obj]; 

if (newC >= 0) { 

SubProblem spYES = SubProblem (newC, obj+1, profit + 

pbm.p[obj]); 

subpbms.insert(spYES); 

} 

}




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 


de MaLLBa 


y Acotación 


Vencerás 

Clases 



Bound Subproblem::upper_bound (const Problem& pbm, Solution& sl) 

{ 

Bound upper, weigth, pft; 

Number i; 

} 

for (i = obj, weigth = 0, pft = profit; weigth




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 


de MaLLBa 


y Acotación 


Vencerás 

Clases 



Marzo, 2007 


Bound Subproblem::lower_bound (const Problem& pbm, Solution& us) 

{ 

Bound lower, weigth, pft; 

Number i, tmp; 

} 

us = sol; 

for(i = obj, weigth = 0, pft = profit; weigth




Introducción 

Interfaz de 

Usuario 

Clases Requeridas Esqueleto D&C 

Patrones 

Secuenciales 


• Problem 

Experimentos 


Conclusiones 

• SubProblem 

• initSubProblem 

• easy 

Solution 

Problem 


de MaLLBa 


y Acotación 

• solve 

• divide 

• Solution 

• combine 

SubProblem 

Auxiliar 


Vencerás 

• Auxiliar 

Clases 



Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Ejemplo: Problema de Ordenación 

void SubProblem::initSubProblem (const Problem& pbm) { 

for (unsigned i = 0; i < pbm.l.size(); i++) 

l.push_back(pbm.l[i]); 

} 


de MaLLBa 


y Acotación 


Vencerás 

Clases 


bool SubProblem::easy () { 

return (l.size()




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 


void SubProblem::divide (const Problem& pbm, 

vector& subpbms, 

Auxiliar& aux){ 

SubProblem sp1, sp2; 

unsigned i, middle = l.size() / 2; 


de MaLLBa 


y Acotación 


Vencerás 

Clases 


} 

for (i = 0; i < middle; i++) 

sp1.l.push_back(l[i]); 

for (i = middle; i < l.size(); i++) 

sp2.l.push_back(l[i]); 

subpbms.push_back(sp1); 

subpbms.push_back(sp2); 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 


de MaLLBa 


y Acotación 


Vencerás 

Clases 



Marzo, 2007 


void Solution::combine (const Problem& pbm, 

{ 

} 

const Auxiliar& aux, 

const vector& subsols) 

vector::const_iterator i = subsols[0].l.begin(); 

vector::const_iterator j = subsols[1].l.begin(); 

while ((i!=subsols[0].l.end()) && 

(j!=subsols[1].l.end())) { 

} 

if (*i < *j) { l.push_back(*i); i++; } 

else { l.push_back(*j); j++; } 

while (i != subsols[0].l.end()) { 

l.push_back(*i); i++; } 

while (j != subsols[1].l.end()) { 

l.push_back(*j); j++; }




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 


de MaLLBa 


y Acotación 


Vencerás 

Clases 


• SetUp: por ej: tipo 

de búsqueda: 

• en profundidad, 

• en anchura, 

• primero-el mejor 

• Solver: Implementa 

la estrategia a seguir. 

Compuesta por ella y: 

• Solver_Seq 

• Solver_Lan 

• Solver_SM 

Clases Proporcionadas 

Solver 

Setup 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Apartado III: Patrones de Resolución Secuenciales 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

1. Patrón de Resolución Secuencial para la 

técnica Ramificación y Acotación 

2. Patrón de Resolución Secuencial para la 

técnica Divide y Vencerás 

3. Combinación de esqueletos 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Algoritmo Secuencial para el Esqueleto MaLLBa:BnB 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Estructura de datos 

BranchQueue Head 

SP 

P N 

Patrón de Resolución 

Ramificación y 

Acotación Secuencial 

SP 

P N 

SP 

P N 



Secuencial 

Combinación de 


SP 

P N 

SP 

P N 

SP 

P N 

SP 

P N 

BranchQueue Tail 


Marzo, 2007




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 






Secuencial 




Marzo, 2007 

Algoritmo Secuencial para el Esqueleto MaLLBa:BnB 

1 Bound BB (const Problem& pbm, const SubProblem& sp, 

2 Solution& sol) { 

3 branchQueue bqueue; 

4 Solution sl; 

5 Bound high, low; 

Maximización 

6 SubProblem sp; 

7 bqueue.insert(sp); 

8 while (!bqueue.empty()) { 

9 sp = bqueue.remove(); 

10 high = sp.upper_bound (pbm, sl); 

11 if (high > bestSol){ 

12 low = sp.lower_bound(pbm, sl); 

13 if (low > bestSol) { 

14 bestSol = low; 

15 sol = sl; 

16 } 

17 if (low != high) 

18 sp.branch(pbm, bqueue); 

19 } } 

20 return(bestSol); 

21 }




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 






Secuencial 




Marzo, 2007 

Algoritmo Secuencial para el Esqueleto MaLLBa:DnC 

1 procedure DandC(pbm, sol) { 

2 Local DivQueue, ComQueue; 

3 

4 push(DivQueue, pbm); 

/** Fase División **/ 

5 while (not empty(DivQueue)) { 

6 subProblem = pop(DivQueue); 

7 if (easy(subProblem)) { 

8 solve(subProblem, subSol); 

9 push(ComQueue, subSol); 

10 } else { 

11 divide(subProblem, subpbm); 

12 for i := 1 to numProblem() do 

13 push(DivQueue, subpbm[i]); 

14 } } 

15 

/** Fase Combinación **/ 

16 while (not empty(ComQueue)) { 

17 for (int i=0; i




Introducción 

Interfaz de 

Usuario 

Patrones 

Secuenciales 


Experimentos 


Conclusiones 






Secuencial 




Marzo, 2007 

p 

w 

1 

1 

≥ 

p 

w 

2 

2 

≥ 

p 

w 

3 

3 

≥ 

... 

≥ 

p 

w 

N 

N 

Instanciación de los esqueletos 

1 int main (int argc, char** argv) { 

2 Knapsack::Problem pbm; 

3 Knapsack::Solution ksol; 

4 Knapsack::Bound bs; 

5 ... 

6 Knapsack::Problem opbm; //ordered problem 

7 QuickSort::Solution ssol; 

8 ... 

9 QuickSort::Solver_Seq svs(pbm); 

10 svs.run(); 

11 ssol = svs.solution(); 

12 ... 

13 opbm.setN(pbm.N); 

14 opbm.setCapacity(pbm.C); 

15 for (Knapsack::Number i = 0; i < n ; i++) { 

16 opbm.setWeight(pbm.w[ssol.l[i]]); 

17 opbm.setProfit(pbm.p[ssol.l[i]]); 

18 } 

19 Knapsack::Solver_Seq svk(opbm, st); 

20 svk.run(); 

21 bs = svk.bestSolution(); ksol = svk.solution(); . . . 

22 }




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 

Apartado IV: Patrones de Resolución Paralelos 

1. Patrones de Resolución Paralelos para la 

técnica Ramificación y Acotación 

a. Esquema Centralizado 

b. Esquema Distribuido 

c. Esquema para Memoria Compartida 

2. Patrón de Resolución Paralelo para la técnica 



Marzo, 2007




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 

Patrón B&B Paralelo 

Centralizado 


Distribuido 

Patrón B&B Memoria 

Compartida 

Patrón D&C Paralelo 

• Paso de Mensaje 

• Estrategia Maestro/Esclavo 

• Maestro: 

• Tareas de Monitorización 

• Gestión de las Colas 

• Distribución de 

subproblemas 

• Recepción de Mensajes 

• Esclavo: 

• Recepción de mensajes 

• Trabajar en los procesos 

propios de la técnica 

• Esquema Centralizado 

• Esquema Distribuido 

• Memoria Compartida 

Esqueletos MaLLBa:BnB Paralelos 

Maestro 

Esclavos 


Marzo, 2007




Introducción 


Patrones 

Secuenciales 

Esquema Paralelo Centralizado MaLLBa:BnB 

Patrones 

Paralelos 

Experimentos 


Conclusiones 


Centralizado 


Distribuido 

 

 


Compartida 


Maestro 

Esclavos 

Maestro 

Esclavos 


Marzo, 2007




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 


Esquema Paralelo Centralizado de MaLLBa:BnB 

Processor Master 


SP 

PN 

SP 

SP 

SP 

SP 


Centralizado 

PN 

PN 

PN 

PN 


Distribuido 

BranchQueue Tail 


Compartida 


Head 

Processor slave 

Head 

Processor slave 

SP 

SP 

SP 

SP 

SP 

SP 


Marzo, 2007 

PN 

PN 

Tail 

PN 

PN 

PN 

Tail 

PN




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 

Código MPI Centralizado de MaLLBa:BnB: Maestro 

1 busy[0] = 1; for i = 1, nProcs { busy[i] = 0; } 

2 idle = nProcs - 1; 

3 auxbqueue; // queue of subproblems sent by the slave 

4 bqueue.insertAtBack(sp); // Insert the subproblem into the queue 

5 while ((!bqueue.empty()) || (idle < groupSize)) { // Stop condition 

6 while ((!bqueue.empty()) && (idle > 0)) { 

7 auxSp = bqueue.removeFromFront(); 


Centralizado 


Distribuido 


Compartida 


8 op.send(firstidle, auxSp, bestSol, sol); 

9 idle--; 

10 IDLE2WORKING(busy, lastIdle); mark slave as working 

11 } 

12 MLB_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, flag, status) 

13 while (flag) { 

14 if (MPI_SOLVE_TAG) { 

15 ip.recv(source, bestSol, sol); 


Marzo, 2007 

16 WORKING2IDLE(busy, source); // mark the slave as idle 

17 }




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 

Código MPI Centralizado de MaLLBa:BnB: Maestro 

18 if (MPI_BnB_TAG) { 

19 ip.recv(source, bstemp, high); // Receive the best solution 

20 if ( high > bestSol) { 

21 bestSol = bstemp; 

22 op




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 

Código MPI Centralizado de MaLLBa:BnB: Esclavo 

1 while (1) { 

2 MLB_Probe(MASTER,MPI_ANY_TAG, flag, status) 

3 if (flag) { 

4 switch(status.MPI_TAG) { 

5 if (END_TAG){ // Ending message 

6 ip.recv(MASTER, MPI_END_TAG); 

7 return; 


Centralizado 


Distribuido 


Compartida 



Marzo, 2007 

8 } 

9 if (PBM_TAG){ // Receive the problem to branch 

10 ip.recv(MASTER, MPI_PBM_TAG, auxSp, bestSol, auxSol); 

11 high = auxSp.upper_bound(pbm, auxSol); 

12 if ( high > bestSol ) { 

13 low = auxSp.lower_bound(pbm, auxSol); 

14 if ( low > bestSol ) { 


16 sol = auxSol; 

17 } }




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 

Código MPI Centralizado de MaLLBa:BnB: Esclavo 

18 if ( high = low ) { 

19 // send best solution to Master 

20 op.send(MASTER, MPI_SOLVE_TAG, bestSol); 

21 } 

22 else { 

23 op.send(MASTER, MPI_BnB_TAG, bestSol, high); 

24 } 


Centralizado 


Distribuido 


Compartida 



Marzo, 2007 

25 // Receive from Master the indication to branch or not 

26 ip.recv(MASTER, MPI_QUEUEREQUEST_TAG); 

27 ip >> count; 

28 if ( count = 1) { // to branch the subproblem 

29 auxSp.branch(pbm, bqueue); 

30 op.send(MASTER, bqueue); 

31 } 

32 bqueue.clean(); 

33 } } // switch 

34 } } // while




Introducción 


Patrones 

Secuenciales 

Esquema Paralelo Distribuido de MaLLBa:BnB 

Patrones 

Paralelos 

Experimentos 


Conclusiones 


Centralizado 


Distribuido 


Compartida 


Maestro 

Esclavos 

Maestro 

Esclavos 


Marzo, 2007




Introducción 


Patrones 

Secuenciales 

Esquema Paralelo Distribuido de MaLLBa:BnB 

Patrones 

Paralelos 

Experimentos 


Conclusiones 


Processor 0: Master 


SP 

PN 


Centralizado 


Distribuido 


Compartida 

Processor 1: slave 

SP 

PN 

Processor 2: slave 

SP 

PN 


SP 

SP 

SP 

SP 

SP 

SP 

PN 

PN 

PN 

PN 

PN 

PN 


Tail 

Tail 

Marzo, 2007




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 


Centralizado 


Distribuido 


Compartida 



Marzo, 2007 

Código MPI Distribuido de MaLLBa:BnB: Maestro 

1 busy[0] = 1; for i = 1, nProcs { busy[i] = 0;} 

2 idle = nProcs - 1; 

3 // Send initial subproblem to first idle slave 

4 auxSp = sp.initSubProblem(); 

5 op.send(firstIdle, auxSp, bestSol, sol); 

6 idle--; 

7 IDLE2WORKING(busy,firstIdle); // mark this slave like working 

8 while (idle < (groupSize-1)) { // while there are working slaves 

9 recv(source, flag); 

10 while(flag) { 

11 if (SOLVE_TAG) { // receive the final solution 

12 ip.recv(source, bestSol, sol); 

13 } 

14 if (BnB_TAG) { // receive a slave request 

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 

30 } 

31 if (IDLE_TAG) { // receive the signal of an idle slave 

32 ip.recv(source, IDLE); 

33 idle++; 

34 WORKING2IDLE(busy,source); // mark this slave like idle 

35 } 


37 } } // while (idle < (groupSize-1)) 

38 // Send the ending message 

39 for i = 1, groupSize { op.send(i, END); }




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 


Centralizado 


Distribuido 


Compartida 



Marzo, 2007 

Código MPI Distribuido de MaLLBa:BnB: Maestro 

14 if (BnB_TAG) { // receive a slave request 

15 ip.recv(source, 

16 high, // upper bound associated to the problem 

17 nSlaves); // the number of required slaves 

18 if ( high > bestSol) { // the problem must be branched 

19 total= ((nSlaves




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 


Centralizado 


Distribuido 


Compartida 



Marzo, 2007 

Código MPI Distribuido de MaLLBa:BnB: Esclavo 

1 while (1) { 


3 while (flag) { 

4 if (END_TAG){ // receive the finishing message 

5 ip.recv(MASTER, END); return; 

6 } 

7 if (PBM_TAG){ // receive the problem to be branched 

8 ip.recv(source, // receive from a slave or the Master: 

9 auxSp, // the initial subproblem 

10 bestSol, // the best solution value 

11 sol); // the current solution 

12 auxSol = sol; 

13 bqueue.insert(auxSp); // insert it in the local queue 

14 while(!bqueue.empty()) { 

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 

37 } 

38 op.send(MASTER, IDLE_TAG); // send the signal Idle 

39 } 


41 } // while (flag) 

42 } // while(1)




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 


Centralizado 


Distribuido 


Compartida 



Marzo, 2007 

Código MPI Distribuido de MaLLBa:BnB: Esclavo 


15 auxSp = bqueue.remove(); // pop a problem from the local queue 

16 high = auxSp.upper_bound(pbm,auxSol); 

17 if ( high > bestSol ) { 

18 low = auxSp.lower_bound(pbm,auxSol); 

19 if ( low > bestSol ) { 


21 sol = auxSol; 

22 op.send(MASTER, SOLVE_TAG, bestSol, sol); 

23 } 

24 if ( high != low ) { 

25 // the number of required slaves 

26 rSlaves = bqueue.getNumberOfNodes(); 

27 op.send(MASTER, BnB_TAG, high, rSlaves); 

28 ip.recv(MASTER, nfSlaves, bestSol, rank {1,..., nfSlaves}); 

29 if ( nfSlaves >= 0) { 

30 auxSp.branch(pbm,bqueue); //branch and save in the local queue 

31 for i=0, nfSlaves{ // send subproblems to the assigned slaves 

32 auxSp = bqueue.remove(); 

33 // send to the slave: 

34 op.send(rank, PBM_TAG, auxSp, bestSol, sol); 

35 } 

36 } // if nfSlaves == DONE the problem is bounded (cut) 

37 } }




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 

Esquema para Memoria Compartida de MaLLBa:BnB 

 

 

 

 


Centralizado 


Distribuido 


Compartida 


Procesadores 

Procesadores 


Marzo, 2007




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 

Esquema de MaLLBa:BnB para Memoria Compartida 

Estructura 

de datos 


SP 

P N 

SP 

P N 

SP 

P N 


Centralizado 


Distribuido 

SP 

P N 

SP 

P N 

SP 

P N 

SP 

P N 


Compartida 

SP 

P N 

SP 

P N 

BranchQueue 

Tail 


SP 

SP 

SP 

SP 

SP 


Marzo, 2007 

Threads 

P 

N 

P 

N 

P 

N 

P 

N 

P 

N




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Conclusiones 


Centralizado 


Distribuido 


Compartida 



Marzo, 2007 

Pseudocódigo OpenMP para Solver_SM 

1 // shared variables {bqueue, bstemp, soltemp, data} 

2 // private variables {auxSol, high, low} 

3 // the initial subproblem is inserted in the global shared queue 


5 nn = bqueue.getNumberOfNodes(); // the number of needed threads 

6 nt = (nn > maxthread)?maxthread:nn; 

7 data = new SubProblem[nt]; // compute the subproblem for each thread 

8 for (int j = 0; j < nt; j++) 

9 data[j] = bqueue.remove(); 

10 set.num.threads(nt); // establish the number of threads 

11 parallel forall (i = 0; i < nt; i++) { 

12 high = data[i].upper_bound(pbm,auxSol); 

13 if ( high > bstemp ) { 

14 if ( low > bstemp ) { // critical region 

15 // only one thread can change the value at any time 

16 bstemp = low; 

17 soltemp = auxSol; 

18 } 

19 if ( high != low ) { // critical region 

20 // just one thread can insert subproblems 

21 // in the queue at any time 

22 data[i].branch(pbm,bqueue); 

23 } } } } 

24 bestSol = bstemp; 

25 sol = soltemp;




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Esquema Paralelo D&C 

Fase de División 

Conclusiones 


Centralizado 


Distribuido 


Compartida 



Marzo, 2007




Introducción 


Patrones 

Secuenciales 

Patrones 

Paralelos 

Experimentos 


Esquema Paralelo D&C 

Fase de Combinación 

Conclusiones 


Centralizado 


Distribuido 


Compartida 



Marzo, 2007




Introducción 


Patrones 

Secuenciales 

Apartado V: Experimentos Computacionales 


Experimentos 


Conclusiones 

• Descripción de las Máquinas 

• Resultados Computacionales 


Marzo, 2007




Introducción 


Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Descripción de las 

Máquinas 

Resultados 

computacionales 

• Sunfire 6800 SMP, con la siguiente configuración: 

• 24 procesadores 750 MHz UltraSPARC-III, 

• 48 Gbyte de memoria compartida cada uno y 

• 120 Gbyte de disco duro. 

• Origin 3000, con la siguiente configuración: 

• 160 procesadores 600 MHz MIPS R14000, 

• 1 Gbyte de memoria 

• 900 Gbyte de disco 

Descripción de las Máquinas 

• Un heterogéneo Cluster de PCs, con la siguiente configuración 

• 2 Procesadores 750 MHz AMD Duron, 

• 4 Procesadores 800 MHz AMD Duron, 

• 7 Procesadores 500 MHz AMD-K6 3D, 

• 256 Mbyte de memoria, 

• 32 Gbyte de disco duro 

EPCC (Edinburgh Parallel 

Computing Center) 

CIEMAT (Centro de 

Investigaciones Energéticas, 

Medioambientales y 

Tecnológicas) 

Cluster de PCs del Grupo de 

Paralelismo de la Universidad 

de La Laguna 


Marzo, 2007




Introducción 


Patrones 

Secuenciales 

Resultados computationales 


Experimentos 


Conclusiones 

SIZE FIFO LIFO PRIORITY 

1,000 0.181 0.072 0.100 

1,500 0.073 0.103 0.131 

5,000 2.533 3.326 3.441 

Descrición de las 

Máquinas 

Resultados 


10,000 2.109 5.491 5.566 

50,000 128.980 391.767 389.987 

100,000 652.969 1,780.297 1,793.152 


Marzo, 2007




Introducción 


Patrones 

Secuenciales 



Experimentos 


Conclusiones 

TAMAÑO FIFO LIFO TREESET 

1,000 1.568 1.163 1.237 

1,500 0.657 1.239 1.287 


Máquinas 

Resultados 


5,000 50.488 55.938 107.830 

10,000 23.672 102.677 102.344 

50,000 2,500.708 -- -- 


Marzo, 2007




FIFO LIFO PRIORITY 

TAMAÑO N_GEN N_VISIT N_GEN N_VISIT N_GEN N_VISIT 

1,000 21,824 11,620 12,402 11,520 20,858 10,857 

1,500 5,161 3,106 9,877 8,587 4,724 2,823 

5,000 93,589 58,444 166,333 159,712 113,886 79,293 

10,000 37,886 22,108 135,372 128,002 38,303 22,266 

50,000 404,802 202,617 2,172,245 2,137,110 406,361 203,513 

100,000 1,158,033 608,696 4,750,148 4,680,425 1,140,929 599,641 


Table 1. Número de nodos generados y visitados (prime 107) 

Marzo, 2007




Introducción 


Patrones 

Secuenciales 



KNP N = 50,000 

Experimentos 


7,00 

Conclusiones 

6,00 

5,00 


Máquinas 

Resultados 


Speedup 

4,00 

3,00 

2,00 

Sunfire-NoSol 

Origin-NoSol 

Sunfire-Sol 

Origin-Sol 

1,00 


Marzo, 2007 

0,00 

2 3 4 8 16 24 32 

Procesadores




Introducción 


Patrones 

Secuenciales 


Experimentos 



KNP no Sol, Size = 100,000 

Conclusiones 

7,00 


Máquinas 

Resultados 


Speedup 

6,00 

5,00 

4,00 

3,00 

2,00 

1,00 

0,00 

2 3 4 8 16 24 32 

Processors 


Marzo, 2007 

Sunfire 6800 Origin 3000 PC Cluster




Introducción 


Patrones 

Secuenciales 


Experimentos 


Conclusiones 

No solution vector 

7,00 


Sunfire vs. Origin 


Máquinas 

Resultados 


Speedup 

6,00 

5,00 

4,00 

3,00 

2,00 

1,00 

Sunfire-100,000 

Origin-100,000 


Origin-50,000 


Origin-10,000 

0,00 

2 3 4 8 16 24 32 


Marzo, 2007 

Procesadores




Introducción 


Patrones 

Secuenciales 


Experimentos 


Conclusiones 

7,00 

6,00 

5,00 


KNP no Sol, Size = 100,000 


Máquinas 

Resultados 


Speedup 

4,00 

3,00 

2,00 

1,00 

0,00 

2 3 4 8 16 24 32 

Procesadores 


Marzo, 2007 

Sunfire-MPI Origin-MPI Origin-OpenMP




Introducción 


Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Conclusiones 

• Diseño de un nuevo esqueleto para la técnica de 

Ramificación y Acotación: 

MaLLBa:BnB 

• Diferentes implementaciones de resolutores: 

• Uno Secuencial 

• Dos resolutores usando Paso de Mensaje: 

• Centralizado 

• Distribuido 

• Uno para Memoria Compartida 


Marzo, 2007




Introducción 


Patrones 

Secuenciales 


Experimentos 


Conclusiones 

Conclusiones 

• Metodología de trabajo para la resolución de 

Problemas de Optimización Combinatoria 

mediante la técnica de Ramificación y 

Acotación 

• Implementación de problemas académicos: 

Mochila y TSP 

• Resultados Computacionales 

• Supercomputadores 

• Redes de PC 


Marzo, 2007

Esqueleto Algorítmico - ulpgc

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?