Modèles de réseau
Un modèle de réseau comprend des modèles atomiques et d'autres modèles de réseau qui sont reliés entre eux. modèles de réseau peuvent être des composants d'autres modèles de réseau, permettant ainsi la construction de systèmes à plusieurs niveaux. A la différence des modèles atomiques, les modèles de réseau ne définissent pas directement un nouveau comportement dynamique. La dynamique d'un modèle de réseau sont déterminées par la dynamique de ses éléments constitutifs et de leurs interactions. modèles atomiques définissent les comportements fondamentaux; modèles de réseau définissent la structure.
modèles de réseau sont dérivées de la classe réseau. Cette classe a deux méthodes virtuelles: itinéraire et getComponents. Le procédé met en oeuvre de l'itinéraire des connexions entre les composants du réseau et entre ces composants et les entrées et sorties du réseau lui-même. La méthode getComponents fournit l'ensemble des composants qui constituent le réseau.
La méthode de la route
La méthode de la route réalise trois types de connexions. Les premiers sont des connexions entre les composants du réseau. Les seconds sont les connexions à partir des entrées du réseau aux entrées de ses modèles de composants. Le troisième des connexions des sorties des composants aux sorties du réseau. La signature de la méthode de la route est
L'argument de valeur est l'objet de la route, l'argument de modèle est le réseau ou d'un modèle atomique qui est la source de l'objet de valeur, et l'argument r est un sac à remplir avec des modèles qui doivent recevoir l'objet de valeur en entrée. Chaque cible est décrite par un objet d'événement qui porte deux éléments d'information: un pointeur vers le modèle qui est la cible et l'objet à livrer à cette cible. Le simulateur utilise les objets de l'événement dans une de trois manières en fonction de la relation entre la source de l'objet et sa cible. Ces utilisations sont- Si la source est un composant du réseau et la cible est le réseau lui-même, la valeur devient une sortie du réseau.
- Si la source est le réseau et la cible est un composant du réseau, la valeur devient une entrée pour ce composant.
- Si la source et la cible sont les deux composantes du réseau, la valeur devient une entrée à la cible.
Figure: Deux composants connectés atomique dans un seul réseau.
Figure: un réseau avec une entrée externe, une sortie externe, et le couplage interne.
Bien que non montré ci-dessus, le procédé de l'itinéraire est autorisé à modifier l'objet de valeur avant de l'envoyer à une cible. Cela peut être utile dans certains cas.
La méthode getComponents
Figure: couplage illégal dans un modèle de réseau.
Il n'y a pas de règles spéciales pour la simulation des modèles hiérarchiques. Le simulateur considère la collection de modèles atomiques pour déterminer la prochaine fois que l'événement, la sortie de modèles atomiques sont récursive acheminés vers leurs destinations atomiques, et les transitions d'état et la collecte des ordures sont effectuées sur l'ensemble des composants atomiques actifs. Hiérarchies des modèles de réseau sont un outil d'organisation pratique pour le modeleur, mais le simulateur aplatit (indirectement, via son routage récursif des événements) des réseaux à plusieurs niveaux lors de la simulation.
Le SimpleDigraph dispose de deux méthodes pour la construction d'un réseau. La méthode add prend un modèle atomique ou réseau et ajoute à l'ensemble des composants. Procédé couple accepte une paire de composants et relie la première à la seconde. Voici la définition de classe pour le modèle. Notez qu'il a un paramètre de modèle pour définir son entrée et le type de sortie. Le SimpleDigraph a deux variables membres. Le premier est un ensemble de pointeurs vers les composants du réseau. Ceux-ci sont stockés dans l'ensemble des modèles appelés. Les composants peuvent être des objets atomiques, des objets réseau, ou les deux. Ces composants de la SimpleDigraph sont les nœuds de son graphe orienté. La deuxième variable est membre des liens du réseau. Ceux-ci sont stockés dans la carte graphique appelé.
Le SimpleDigraph a quatre méthodes et l'itinéraire requis et getComponents. L'un d'entre eux est le constructeur, ce qui crée un réseau vide. Une autre est le destructor, qui supprime tous les composants du réseau. Les deux autres sont ajouter et couple.
La méthode add fait trois choses. Tout d'abord, il vérifie que le réseau ne soit pas ajouté à lui-même. Cette pratique est illégale et fera le simulateur de lancer une exception. , Il ajoute ensuite le nouveau composant à son ensemble de composants. Enfin, le SimpleDigraph se fait parent du composant. Ce nécessaire pour que le simulateur peut monter et descendre l'arbre du modèle. Si cette étape est omise alors le routage récursif des événements échouera. Voici la mise en œuvre de la méthode add.
Sur les deux méthodes nécessaires, la route est plus compliquée. Les arguments de la route sont un objet devant être acheminé, l'élément de réseau (à savoir soit le SimpleDigraph ou l'un de ses composants) qui a créé cet objet, et le sac à remplir avec des objets d'événements qui indiquent les récepteurs de l'objet. Le procédé commence par la recherche de la collection de composants qui sont connectés à la source de l'objet. Ensuite, il parcourt cette collection et pour chaque récepteur ajoute un événement au sac de récepteurs. Lorsque cela est fait la méthode retourne. La mise en œuvre est ci-dessous.
La seconde méthode requise, getComponents. est trivial. Si nous avions utilisé une collection autre qu'un ensemble pour stocker les composants, la méthode aurait besoin d'insérer explicitement chaque modèle de composant dans le c Set. Mais parce que les modèles et c sont les deux objets Set et le jeu a un opérateur d'affectation, un appel à cet opérateur suffit.
Le constructeur et le destructeur complètent la classe. Le constructeur appelle que le constructeur superclasse. Le destructor supprime les modèles de composants. Sa mise en œuvre est présentée ci-dessous.
Figure: Un modèle Digraph à deux composants.
Les composants d'un Digraph doivent utiliser adevs :: objets valeurport pour leur entrée et le type de sortie. Le Digraph est une classe de modèle avec deux paramètres du modèle. Le premier paramètre est le type d'objet utilisé pour une valeur dans ses objets valeurport. Le second paramètre est le type d'objet utilisé pour un port dans les objets valeurport. Le paramètre de port est de type `int » par défaut.
Le Digraph a deux méthodes qui sont utilisées pour construire un réseau. La méthode add ajoute un composant au réseau. L'argument de la méthode d'ajout est le modèle à inclure dans le réseau. La méthode couple relie les composants du réseau. Les deux premiers arguments de la méthode de couple est le modèle source et le port. Les deux autres arguments sont le modèle de destination et le port.
Cette fonction de sortie met une valeur de type `* de client » sur le `` arriver « port » du générateur; rappelons que « IO_Type » est un typedef pour `valeurport
Figure: modèles de composants et leurs interconnexions dans le modèle de dépanneur multi-greffier.
Le modèle multi-employé est mis en œuvre en dérivant une nouvelle classe de Digraph. Le constructeur de cette nouvelle classe crée et ajoute les modèles de composants et établit leurs interconnexions. Voici le fichier d'en-tête pour ce nouveau modèle multi-employé. Et voici le fichier source Notez que la destructor MultiClerk ne supprime pas ses modèles de composants. En effet, les composants sont adoptés par la classe de base quand ils sont ajoutés à l'aide de la méthode d'ajout de Digraph. Par conséquent, les modèles de composants sont supprimés par la classe de base destructor, plutôt que le Destructeur de la classe dérivée.
Un modèle d'espace de cellule est une collection de modèles atomiques et de réseau dispose sur une grille régulière et avec chaque modèle reliée à ses modèles voisins. jeu de la vie de Conway est un exemple classique d'un modèle spatial cellulaire qui peut être décrit très bien comme un système d'événements discrets. Ce jeu se joue sur un plateau plat divisé en cellules régulières tout comme un damier. Chaque cellule a une zone qui comprend les huit cellules adjacentes: ci-dessus, en dessous, à gauche, à droite, et les quatre coins. Une cellule peut être morte ou vivante. Le passage de la mort à vie et vice versa se produit selon deux règles:- (Règle de la mort). Si une cellule est vivant et il a moins de deux ou plus de trois voisins vivant alors la cellule meurt.
- (Règle Rebirth). Si une cellule est morte et il a trois trois voisins vivants alors la cellule renaît.
Notre mise en œuvre du jeu de la vie a deux parties: modèles atomiques qui mettent en œuvre les cellules individuelles et un Espac qui contient les cellules. Le Espac est un type de réseau. et ses composants échange d'objets CellEvent qui ont quatre attributs: x, y, et les coordonnées z de la cellule cible (l'espace de cellule peuvent avoir trois dimensions, le jeu de la vie utilise seulement deux) et l'objet à livrer à cette cible. La classe CellEvent est une classe de modèle dont l'argument modèle définit le type d'objet que l'événement offre. La taille de l'Espac est déterminée lorsque l'objet Espac est créé, et il a des procédés pour l'ajout et la récupération des cellules par emplacement.
Les cellules atomiques dans notre jeu de la vie ont deux variables d'état: le statut mort ou vivant de la cellule et son nombre de voisins vivant. Deux méthodes sont mises en œuvre pour tester les règles de la mort et la renaissance, et la cellule définit son avance de temps de 1 à chaque fois qu'une règle est satisfaite.
La sortie de la cellule est son nouvel état mort ou vivant. Afin de produire s CellEvent bien ciblé, chaque cellule connaît son propre emplacement dans l'espace cellulaire. La fonction de transition interne provoque la cellule de changer son état mort / vivant. La fonction de transition externe met à jour le décompte de la cellule des voisins vivant que ces voisins changent leur état mort / vivant. Voici le fichier d'en-tête pour notre jeu de cellule de vie.
La méthode output_func montre comment une cellule envoie des messages à ses voisins. Le imbriquée pour les boucles créent une CellEvent ciblée à chaque cellule adjacente. La localisation de la cellule ciblée est écrite dans les x, y et z des attributs de l'objet CellEvent. Tout comme les tableaux, les emplacements vont de zéro à la taille de l'un moins de l'espace cellulaire. Les routes Espac les objets CellEvent à leurs cibles. Toutefois, si la cible de l'CellEvent est en dehors de l'espace cellulaire, l'Espac se produira le CellEvent en sortie.
Le reste du programme de simulation ressemble beaucoup à des programmes de simulation que nous avons vu. Un objet Espac est créé et nous ajoutons des cellules à elle. Ensuite, un objet Simulator est créé et un pointeur vers l'Espac est transmis au constructeur du simulateur. Enfin, nous exécutons des événements jusqu'à ce que nos critères d'arrêt est remplie. La partie d'exécution est déjà familière, nous allons nous concentrer sur la création de l'Espac. Voici l'extrait de code qui effectue la construction.
Tout comme avec la classe Digraph, l'argument de modèle de Espac détermine le type de valeur pour les objets CellEvent utilisés comme entrée et sortie. Le constructeur Espac définit les dimensions de l'espace. Chaque Espac est en trois dimensions, et le constructeur accepte trois arguments pour ses x, y et z dimensions. arguments Omission par défaut à 1. La signature du constructeur est
Les composants sont ajoutés à la Espac avec la méthode add. Ce procédé met un composant à x spécifique, y, z et l'emplacement. Sa signature est là cellule est un Devs (atomique ou réseau) par la définition de type aussi comme le Digraph. l'Espac supprime ses composants lors de leur suppression.
Le Espac a cinq méthodes pour récupérer les cellules et les dimensions de l'espace cellulaire. Ceux-ci sont plus ou moins explicite; les signatures sont présentées ci-dessous.
