Каков наилучший способ для межпроцессорной связи в Linux?

Question

У меня есть два процессора на чипе, и у них есть разделяемая память. Это не архитектура SMP. Всего два процессора на чипе с общей памятью.

На первом процессоре есть Unix-подобная операционная система, а на втором процессоре есть операционная система Linux.

Первый процессор выполняет некоторую работу, и результатом этого задания являются некоторые данные. После того как первый процессор завершит свою работу, он должен сказать другому процессору, что задание завершено, а второй процессор должен обработать эти данные.

Каков способ обработки межпроцессорной связи? Какой алгоритм я должен использовать для этого?

Любые ссылки на статью об этом были бы весьма признательны.

Answer 1

Действительно хороший способ - просто отправить IP-пакеты взад и вперед (используя сокеты). это имеет то преимущество, что вы можете протестировать материал вне чипа - как в, запустить тестовую версию одного процесса на ПК, если у вас есть сети.

Answer 2

Как насчет использования общего доступа?

Я не имею хорошую ссылку прямо сейчас, но если вы Google для IPC + поделился MEM я уверен, вы найдете много интересной информации :)

Answer 3

Вы уверены, что вам нужно сделать это? По моему опыту вам лучше позволить вашей компилятору & операционная система управлять тем, как ваш процесс использует несколько процессоров.

Answer 4

Все зависит от оборудования. Если все, что у вас есть, является общей памятью и не имеет другого способа связи, то вам нужно использовать какой-либо опрос.

Оба процессора работают под управлением Linux? Как они обрабатывают общую память? Хорошим решением является использование связанного списка как fifo. На этом fifo вы помещаете дескриптор данных, например, адрес и размер.

Например, вы можете иметь входной и выходной FIFO, и идти, как это:

• процессор делает некоторые вычисления
• процессор раздвинуть данные descriptoron выход ФИФО
• процессор ожидания для дескриптора данных на входе FIFO

• петля

• процессора B ожиданий для дескриптора данных на выходе ФИФО

• Процессор B работает с данными
• Процессора В толчке используется дескриптор данных на входе FIFO
• петля

Конечно, твердая часть в замке. Может быть, вам следует переформулировать свой вопрос, чтобы подчеркнуть, что это не «стандартный» SMP.

Если у вас нет атомарного теста и задана операция бит в памяти, я думаю, вам нужно пойти со схемой, где некоторая зона памяти записывается только для одного процессора и читается только для другого.

Редактировать: см. Ответ Hasturkun для передачи сообщений от одного процессора к другому, используя упорядоченную запись вместо атомарности для обеспечения последовательного доступа к некоторым предопределенным данным.

Answer 5

Если оба процессора управляются одним os, то вы можете использовать любой из стандартных IPC для связи друг с другом, поскольку ОС заботится обо всем. Если они работают на разных ОС, то сокеты будут наилучшим выбором.

Answer 6

EDIT

Быстрая однонаправленная версия:

• Готового флаг
• Done флаг

INIT:

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

автор:

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

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

читателя:

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

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

---

Постройте система передачи сообщений через общий мем (который должен быть когерентным, либо будучи некэшированным для обоих процессоров, или путем использования кэш-памяти flush/invalidate calls).

Ваша общая структура памяти должна иметь (по крайней мере) следующие поля:

• Текущий владелец
• Сообщения активное (как, следует читать)
• поля использования Запроса

Поток, вероятно, будет таким: (предполагается, что send/recv синхронизирован не для запуска в одно и то же время)

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

Хорошо. Я понимаю вопрос. Я работал над этой проблемой.

Теперь первое, что вам нужно понять, это работа общей памяти, которая существует между двумя ЦП. Поскольку к этой общей памяти можно обращаться по-разному, вам нужно выяснить, какой из них подходит наилучшим образом.

В большинстве случаев аппаратные семафоры будут предоставляться в общей памяти вместе с аппаратным прерыванием, чтобы уведомить передачу сообщения от одного процессора к другому процессору.

Так что взгляните на это в первую очередь.