Java - Programmation Distribuée, RMI?

Question

J'ai une doozy d'un problème. Je vise à construire un cadre pour permettre l'intégration des différents modèles de simulation de la circulation. Cette intégration est basée sur le partage des connectivités de lien, les coûts de liaison, et des véhicules entre les simulations.

Pour faire une simulation distribuée, je prévois d'avoir un « coordinateur » (topologie en étoile). Toutes les simulations participantes adhérez simplement, et ne parlent que le coordinateur. Le coordonnateur coordonne ensuite l'exécution de diverses tâches entre chaque simulation.

Un exemple rapide d'un problème de distribution, est une simulation quand est « responsable » de certains objets, comme une route. Et une autre est « en charge » d'autres routes. Cependant, ces routes sont reliés entre eux (et, par conséquent, nous avons besoin d'une synchronisation entre ces simulations, et doivent être en mesure d'échanger des données / appeler des méthodes à distance).

J'ai eu un coup d'œil à RMI et je pense qu'il peut être adapté à cette tâche. (Abstraire avoir à créer une discipline de signalisation sur fil).

Est-ce sain d'esprit? La question ici, est que les participants de simulation doivent centraliser certains de leur stockage de données dans le « coordinateur » pour assurer la synchronisation explicite entre les simulations. En outre, certaines simulations peuvent nécessiter des composants ou des méthodes d'autres simulations. (D'où l'idée d'utiliser RMI).

Mon approche de base est d'avoir le « coordinateur » exécuter un registre RMI géant. Et chaque simulation regarde simplement tout dans le registre, veiller à ce que les bons objets sont utilisés à chaque étape.

Quelqu'un a des conseils pour descendre ce chemin?

Answer 1

Vous pouvez consulter Hazelcast aussi. Hazelcast est une transaction open source, distribué / mise en œuvre partitionné de file d'attente, sujet, carte, ensemble, liste, verrouillage et service exécuteur testamentaire. Il est très facile de travailler avec; il suffit d'ajouter hazelcast.jar dans votre classpath et commencer à coder. Presque aucune configuration est nécessaire.

Si vous êtes intéressé par l'exécution de vos tâches exécutables, appelables de manière distribuée, alors s'il vous plaît consulter la documentation distribuée Exécuteur service à http://code.google.com/docreader/#p=hazelcast

Hazelcast est disponible sous la licence Apache et le soutien de qualité de l'entreprise est également disponible.

Answer 2

Est-ce sain d'esprit? À mon humble avis pas. Et je vais vous dire pourquoi. Mais d'abord je vais ajouter l'avertissement que c'est un sujet complexe de sorte que toute réponse doit être considérée comme gratter à peine la surface.

Tout d'abord au lieu de me répéter, je vais vous indiquer un résumé de la grille Java / technologies de cluster que j'ai écrit il y a quelque temps. Sa liste complète la plupart du temps.

La topologie en étoile est « naturelle » pour un « naïf » (je ne veux pas dire que, dans une mauvaise façon) la mise en œuvre parce que le point à point est simple et la centralisation de la logique clé de commande est également simple. Il est cependant pas tolérant aux pannes. Il présente des problèmes d'évolutivité et un goulot d'étranglement. Il introduit inefficacités de communication (à savoir les points de communiquer par l'intermédiaire d'un procédé en deux étapes à travers le centre).

Qu'est-ce que vous voulez vraiment pour ce qui est probablement un cluster (plutôt que d'une grille de données / Compute) solution et je vous suggère de vous regardez Terre cuite . Idéalement, vous devriez regarder Oracle Coherence mais il est sans aucun doute cher ( par rapport au libre). Il est un produit fantastique bien.

Ces deux produits peuvent être utilisés de plusieurs façons, mais le noyau des deux est de traiter un cache comme une carte distribuée. Vous mettez les choses, vous prenez les choses et vous le feu de code qui modifie le cache. Cohérence (avec laquelle je suis plus familière) dans ce qui concerne les échelles fantastiquement bien. Ce sont plus produits à base de « serveur » mais pour un vrai groupe.

Si vous cherchez à un modèle plus distribué alors vous devriez peut-être en train de regarder plus d'une approche SOA.

Answer 3

Jetez un oeil à http://www.terracotta.org/

sa machine virtuelle Java a distribué, il a l'avantage d'être l'application cluster semble pas différent d'une application Java standard.

Je l'ai utilisé dans les applications et la vitesse est très impressionnant jusqu'à présent.

Paul

Answer 4

Avez-vous envisagé d'utiliser une approche de file d'attente de messages? Vous pouvez utiliser JMS pour communiquer / coordonner les tâches et les résultats parmi un ensemble de serveurs / nœuds. Vous pouvez même utiliser les SQS d'Amazon (service de file d'attente simple: aws.amazon.com/sqs). Et que vos serveurs en cours d'exécution sur EC2 pour vous permettre d'intensifier et vers le bas, au besoin

Juste mes 2 cents.

Answer 5

Jetez un oeil à JINI, il pourrait être utile pour vous.

Answer 6

Eh bien, Jini, ou plus précisément JavaSpaces est un bon endroit pour commencer une approche simple au problème. JavaSpaces vous permet de mettre en œuvre un modèle maître-ouvrier, où votre maître (coordinateur dans votre cas) écrit des tâches à l'Javaspace et les travailleurs requête et traiter ces tâches, écrire les résultats de retour pour le maître. Étant donné que votre problème n'est pas honteusement parallèle et vos travailleurs ont besoin de synchroniser / l'échange de données, cela va ajouter une certaine complexité à votre solution.

L'utilisation JavaSpaces ajoutera beaucoup plus abstraction à votre mise en œuvre que l'utilisation de RMI ordinaire (qui est utilisé par le « protocole de fil » cadre Jini interne comme la valeur par défaut).

Jetez un oeil à cette de du soleil pour une intro.

Jini Tutoriel Jan Newmarch est un très bon endroit pour commencer à apprendre Jini

Answer 7

Tout comme un ajout aux autres réponses qui, autant que je l'ai vu tout l'accent sur la grille et l'informatique en nuage, vous remarquerez que les modèles de simulation ont une caractéristique unique: le temps de simulation.

Lors de l'exécution distribué des modèles de simulation en parallèle et synchronisées je vois deux options:

• Lorsque chaque modèle de simulation a sa propre liste d'horloge de simulation et d'événements, puis ceux-ci doivent être synchronisées sur le réseau.
• Sinon il pourrait y avoir une seule horloge de simulation et liste d'événements qui « tick le temps » pour tous les modèles distribués (sous).

La première option a été largement étudié pour le architecture de haut niveau (HLA) voir par exemple http: / /en.wikipedia.org/wiki/IEEE_1516 en entrée.

Cependant, la deuxième option semble plus simple et avec moins de frais généraux pour moi.

Answer 8

GridGain est une bonne alternative. Ils ont une carte / réduire la mise en œuvre avec « support API directe pour la fente et l'agrégation » et « session de travail distribuée ». Vous pouvez parcourir leurs exemples et voir si certains d'entre eux correspond à votre besoins.