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

Question

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

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

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

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

Любая ссылка на статью об этом будет принята с благодарностью.

Answer 1

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

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

Например, у вас может быть входной и выходной fifo, и вы можете пойти так:

• Процессор A выполняет некоторые вычисления
• Процессор A выдвигает дескриптор данных на выходе fifo
• Процессор Ожидание дескриптора данных на входе fifo

• петли

• Процессор B ожидает дескриптор данных на выходе fifo

• Процессор B работает с данными
• Процессор B помещает используемый дескриптор данных на вход fifo

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

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

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

Answer 2

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

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

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

Итак, взгляните на это первым.

Answer 3

EDIT

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

• Флаг готовности
• Готово флаг

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;
}

---

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

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

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

Поток, вероятно, будет выглядеть следующим образом: (предполагается, что синхронизация 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 4

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

Answer 5

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

Answer 6

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

Answer 7

Как насчет использования общей памяти?

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