#include <tpl_agent_graph.H>

Diagrama de herencias de Aleph::Agent_Graph< __GT, __Node, __Arc, __Agent >

Diagrama de colaboración para Aleph::Agent_Graph< __GT, __Node, __Arc, __Agent >:

Clases
class	Agent_Iterator

Tipos públicos
typedef GT::Node	Node
	El tipo de nodo.

typedef GT::Arc	Arc
	El tipo de arco.

typedef __Agent	Agent

typedef Concurrent_Graph< __GT, __Node, __Arc >	Base_Graph

typedef Node::Node_Type	Node_Type
	El tipo de información que contiene el nodo.

typedef Arc::Arc_Type	Arc_Type
	El tipo de información que contiene el arco.

typedef Agent::Agent_Type	Agent_Type
	El tipo de información que contiene el agente.

Tipos públicos heredados desde Aleph::Concurrent_Graph< __GT, __Node, __Arc >
typedef __GT< Lock_Object < __Node >, Lock_Object< __Arc > >	GT

typedef __GT::Node	Node

typedef __GT::Arc	Arc

typedef __GT::Node_Type	Node_Type
	El tipo de nodo concurrente.

typedef __GT::Arc_Type	Arc_Type
	El tipo de arco concurrente.

Métodos públicos
size_t	get_num_agents () const
	Retorna el número total de agentes del grafo.

size_t	get_num_threads () const
	Retorna el número de threads que ejecutan a los agentes.

Agent *	get_first_agent ()

void	remove_agent (Agent *agent)

void	start_graph (const bool block_caller=true)

void	stop_graph ()

void	suspend_graph ()

void	resume_graph ()

void	clear_agent_list ()

const long &	get_num_agents_ready () const

const long &	get_num_agents_suspended () const

void	suspend_agent (Agent *agent)

void	resume_agent (Agent *agent)

	Agent_Graph (const size_t &__num_threads=3, const size_t &num_mutexes=4)

void	set_num_threads (const size_t &__num_threads)

	Agent_Graph (const Agent_Graph &g)

Agent *	insert_agent_in_node (Agent agent, Node p, const bool suspended=false)

Agent *	insert_agent_in_arc (Agent agent, Arc a, const bool suspended=false)

Agent *	create_agent_in_node (const Agent_Type &agent_data, Node node, long(process_node)(void agent, void graph, void src, void &arc)=NULL, long(process_arc)(void agent, void graph, void arc)=NULL, const bool suspended=false)

Agent *	create_agent_in_arc (const Agent_Type &agent_data, Arc arc, long(process_node)(void agent, void graph, void src, void &arc)=NULL, long(process_arc)(void agent, void graph, void arc)=NULL, const bool &suspended=false)

template<class Equal >
Agent *	search_agent (const Agent_Type &agent_data)

Agent *	search_agent (const Agent_Type &agent)

int	get_status ()

void	set_time_callback (Time_Callback __time_callback, const int &sec=10, const long &nanosec=0)

void	cancel_time_callback ()

Métodos públicos heredados desde Aleph::Concurrent_Graph< __GT, __Node, __Arc >
pthread_mutex_t *	get_mutex (int i)

pthread_mutex_t *	allocate_mutex ()

	Concurrent_Graph (const size_t &n_mut=1)
	Instancia un grafo concurrente vacío.

	Concurrent_Graph (const Concurrent_Graph &g)
	Instancia un grafo concurrente copia de otro grafo concurrente.

void	set_num_mutexes (const size_t &n)

void	distribute_mutexes_randomly ()

void	distribute_mutexes_uniformly ()

size_t	get_num_nodes ()
	Retorna el número de nodos que tiene el grafo concurrente.

size_t	get_num_arcs ()
	Retorna el número de arcos que tiene el grafo concurrente.

size_t	get_num_mutexes ()

Node *	search_node (const Node_Type &node_info)
	Busca un nodo según su información contenida.

Node *	insert_node (Node *node)
	Inserta un nodo ya creado en un grafo.

Node *	insert_node (const Node_Type &node_info)
	Crea e inserta un nuevo nodo con información node_info.

Node *	get_first_node ()
	Retorna el primer nodo de un grafo; no hay un orden determinado.

Arc *	get_first_arc ()
	Retorna el primer arco de un grafo.

void	verify_graphs (Concurrent_Graph &g)

void	remove_node (Node *node)
	Elimina un nodo de un grafo (junto con todos sus arcos adyacentes).

void	sort_arcs ()
	ordena los arcos de un grafo concurrente según criterio Compare.

Arc *	insert_arc (Node src_node, Node tgt_node, const Arc_Type &arc_info)
	Crea un arco en un grafo concurrente.

Arc *	insert_arc (Node src_node, Node tgt_node)
	Crea un arco en un grafo concurrente.

void	remove_arc (Arc *arc)
	Elimina un arco en un grafo concurrente.

Arc *	search_arc (Node src_node, Node tgt_node)
	Busca un arco que conecte a dos nodos.

Arc *	search_arc (const Arc_Type &arc_info)
	Busca un arco con información arc_info.

bool	arc_belong_to_graph (Arc *arc)
	Retorna true si el arco arc pertenece al grafo.

Amigas
class	Agent_Iterator

Otros miembros heredados
Métodos protegidos heredados desde Aleph::Concurrent_Graph< __GT, __Node, __Arc >
void	init_mutexes ()

void	uninit_mutexes ()

Atributos protegidos heredados desde Aleph::Concurrent_Graph< __GT, __Node, __Arc >
pthread_mutex_t	mutex

size_t	num_mutexes

DynArray< pthread_mutex_t >	mutexes

Descripción detallada

template<template< class, class > class GT, class Node, class Arc, class Agent>
class Aleph::Agent_Graph< GT, Node, Arc, Agent >

Grafo de agentes "caminantes".

Agent_Graph<Node, Arc,Agent> es una clase que modeliza grafos representados mediante listas de adyacencia en la cual todas sus operaciones son reentrantes, pueden ser manejadas concurrente y coherentemente por varias threads y maneja "agentes" que caminan concurrentemente por las diversas partes del grafo.

Una gran parte de la interfaz es casi idéntica a la de Concurrent_Graph.

La clase Agent_Graph maneja tres parámetros tipo fundamentales:

Node: el tipo de los nodo. Éste debe estar definido mediante la clase Agent_Node.
Arc: el tipo de los arcos definido mediante la clase Agent_Arc.
Agent: el tipo de agente base derivado de la clase Walking_Agent.

Estas clases deben haberse definido previamente.

Una vez instanciado un Agent_Graph, los nodos, arcos y agentes deben accederse mediante los tipos internos:

Agent_Graph::Node.
Agent_Graph::Arc.
Agent_Graph::Agent.

Cada agente maneja una función de transición que lo "camina" a través del grafo. Los agentes pueden crearse en cualquier arco o nodo del grafo sin más limitación que los recursos computacionales. El Agent_Graph tiene una cola de planificación round-robin en la cual se colocan los agentes. Varias threads, cuyo número es definido en tiempo de construcción, ejecutan las funciones de transición de los agentes. Cada thread saca un agente de la cola, ejecuta la función de transición y mete de nuevo el agente al final de la cola.

Agent_Graph es concurrente y dinámico. Su estructura puede cambiar durante la ejecución.

Los agentes se "mueven" en el grafo mediante funciones especiales provistas por la clase Agent_Graph. Puesto que cada lugar del grafo donde puede estar un agente contiene un mutex, éstos deben usarse adecuadamente en los lugares origen y destino del movimiento de un agente. En este sentido, es

Parámetros

__Node	el tipo de nodo. Debe estar definido a partir de la clase Agent_Node, bien sea por inclusión de atributos, por derivación o por combinación de ambos.
__Arc	el tipo de arco. Debe estar definido a partir de la clase Agent_Arc, bien sea por inclusión de atributos, por derivación o por combinación de ambos.
Agent	el tipo de agente. Debe estar definido a partir de la clase Walking_Agent, bien sea por inclusión de atributos, por derivación o por combinación de ambos

Ver también: Agent_Node Agent_Arc Walking_Agent; Agent_Digraph

Nota: Algunos métodos sobre esta clase están brevemente documentados, pues su semántica es la misma que para la clase Concurrent_Graph.

Documentación de las funciones miembro

template<template< class, class > class __GT, class __Node, class __Arc, class __Agent>

const long& Aleph::Agent_Graph< __GT, __Node, __Arc, __Agent >::get_num_agents_ready ( ) const

inline

Funciones sobre el Grafo

La documentación para esta clase fue generada a partir del siguiente fichero:

tpl_agent_graph.H

Clases

Tipos públicos

Métodos públicos

Amigas

Otros miembros heredados

Descripción detallada

template<template< class, class > class __GT, class __Node, class __Arc, class __Agent> class Aleph::Agent_Graph< __GT, __Node, __Arc, __Agent >

Documentación de las funciones miembro

template<template< class, class > class GT, class Node, class Arc, class Agent>
class Aleph::Agent_Graph< GT, Node, Arc, Agent >