Quel est le meilleur moyen de communication interprocesseur sous Linux?

Question

J'ai deux processeurs sur la puce et ils ont une mémoire partagée. Ce n'est pas une architecture SMP. Juste deux processeurs sur la puce avec de la mémoire partagée.

Il existe un système d'exploitation de type Unix sur la première unité centrale et un système d'exploitation Linux sur la deuxième unité centrale.

La première unité centrale effectue un travail et le résultat de ce travail est constitué de données. Une fois que le premier processeur a terminé son travail, il doit indiquer à un autre processeur que le travail est terminé et que le second processeur doit traiter ces données.

Quelle est la manière de gérer la communication entre processeurs? Quel algorithme dois-je utiliser pour faire cela?

Toute référence à un article à ce sujet serait grandement appréciée.

Answer 1

Une très bonne méthode consiste simplement à envoyer des paquets IP d'avant en arrière (en utilisant des sockets). Cela a l'avantage que vous pouvez tester des choses hors puce - comme dans, exécuter une version de test d'un processus sur un PC, si vous avez un réseau.

Answer 2

Comment utiliser la mémoire partagée?

Je n'ai pas un bon lien en ce moment, mais si vous google pour IPC + partagiez mem Je parie que vous trouverez une bonne info :)

Answer 3

Êtes-vous sûr que vous devez faire? Dans mon expérience, vous feriez mieux de laisser votre système d'exploitation de compilateur & gérer la façon dont votre processus utilise plusieurs processeurs.

Answer 4

Tout dépend du matériel. Si tout ce que vous avez est la mémoire partagée, et aucun autre moyen de communication, alors vous devez utiliser une sorte d'interrogation.

Vos deux processeurs fonctionnent-ils sous Linux? Comment gèrent-ils la mémoire partagée? Une bonne solution consiste à utiliser une liste chaînée en tant que FIFO. Sur ce fifo vous mettez un descripteur de données, comme l'adresse et la taille.

Par exemple, vous pouvez avoir une entrée et sortie fifo, et se présenter comme suit:

• processeur A fait un calcul
• processeur A pousser les données descriptoron la sortie fifo
• processeur Une attente pour descripteur de données sur l'entrée fifo

• boucle

• processeur B attente de descripteur de données sur la sortie fifo

• Processeur B fonctionne avec des données
• processeur B-poussoir utilisé descripteur de données sur l'entrée fifo
• boucle

Bien entendu, la partie dure est en verrouillage. Peut-être devriez-vous reformuler votre question pour souligner que ce n'est pas un PSM «standard». Si vous n'avez pas de test atomique et que vous ne réglez pas les bits sur la mémoire, je suppose que vous devez utiliser un schéma où une zone de mémoire est réservée à l'écriture d'un processeur et la lecture à l'autre.Editer: Voir la réponse de Hasturkun, pour un moyen de passer des messages d'un processeur à l'autre, en utilisant l'écriture ordonnée au lieu de l'atomicité pour fournir un accès sérialisé à certaines données prédéfinies.

Answer 5

Si les deux processeurs sont gérés par un seul os, vous pouvez utiliser l'un des IPC standard pour communiquer entre eux comme OS se charge de tout. Si elles sont exécutées sur des systèmes d'exploitation différents, les sockets seraient votre meilleur pari.

Answer 6

EDIT

Version unidirectionnelle rapide:

• drapeau Prêt
• drapeau Fait

INIT:

init() 
{ 
    ready = 0; 
    done = 1; 
} 

écrivain:

send() 
{ 
    while (!done) 
     sleep(); 

    /* copy data in */ 
    done = 0; 
    ready = 1; 
} 

lecteur:

poll() 
{ 
    while (1) 
    { 
     if (ready) 
     { 
      recv(); 
     } 
     sleep(); 
    } 
} 

recv() 
{ 
    /* copy data out */ 
    ready = 0; 
    done = 1; 
} 

---

Construire un système de transmission de message via le mem partagé (qui devrait être cohérente, que ce soit en étant uncached pour les deux processeurs, ou par l'utilisation du cache vider/invalider les appels).

Votre structure de mémoire partagée doit avoir (au moins) les champs suivants:

• propriétaire actuel
• message actif (comme ils doivent être lus)
• champs d'utilisation Demande

Flow probablement comme ceci: (send/recv supposé synchronisé ne pas fonctionner en même temps)

poll() 
{ 
    /* you're better off using interrupts instead, if you have them */ 
    while(1) 
    { 
     if (current_owner == me) 
     { 
      if (active) 
      { 
       recv(); 
      } 
      else if (!request[me] && request[other]) 
      { 
       request[other] = 0; 
       current_owner = other; 
      } 
     } 
     sleep(); 
    } 
} 

recv() 
{ 
    /* copy data... */ 
    active = 0; 
    /* check if we still want it */ 
    if (!request[me] && request[other]) 
    { 
     request[other] = 0; 
     current_owner = other; 
    } 
} 

send() 
{ 
    request[me] = 1; 
    while (current_owner != me || active) 
    { 
     sleep(); 
    } 

    request[me] = 0; 

    /* copy data in... */ 

    /* pass to other side */ 
    active = 1; 
    current_owner = other; 
} 

Answer 7

Ok. Je comprends la question. J'ai travaillé sur ce genre de problème.

Maintenant première chose que vous devez comprendre est le travail de la mémoire partagée qui existe entre les 2 processeurs. Parce que ces mémoires partagées peuvent être consultées de différentes manières, vous devez déterminer lequel vous convient le mieux.

La plupart du temps sémaphores de matériel seront fournis dans la mémoire partagée ainsi que le matériel d'interruption pour notifier le transfert de messages d'un processeur à l'autre processeur.

Alors jetez un oeil à ce premier.