4

我的芯片上有两个 CPU，它们有一个共享内存。这不是 SMP 架构。芯片上只有两个具有共享内存的 CPU。

第一个 CPU 上有一个类 Unix 操作系统，第二个 CPU 上有一个 Linux 操作系统。

第一个 CPU 做了一些工作，这个工作的结果是一些数据。在第一个 CPU 完成其工作后，它应该告诉另一个 CPU 工作已完成，并且第二个 CPU 必须处理此数据。

处理处理器间通信的方法是什么？我应该使用什么算法来做到这一点？

任何关于它的文章的参考将不胜感激。

4

7 回答 7

3

这完全取决于硬件。如果您只有共享内存，没有其他通信方式，那么您必须使用某种轮询。

你的两个处理器都运行 linux 吗？他们如何处理共享内存？一个好的解决方案是使用链表作为 fifo。在这个 fifo 上放置数据描述符，例如地址和大小。

例如，您可以有一个输入和输出 fifo，然后像这样：

  • 处理器 A 进行一些计算
  • 处理器 A 将数据描述符推送到输出 fifo
  • 处理器 A 等待输入 fifo 上的数据描述符

  • 环形

  • 处理器 B 等待输出 fifo 上的数据描述符

  • 处理器 B 处理数据
  • 处理器 B 在输入 fifo 上推送使用的数据描述符
  • 环形

当然，困难的部分在于锁定。也许您应该重新提出您的问题，以强调这不是“标准”SMP。

如果您在内存上没有可用的原子测试和设置位操作，我想您必须采用一种方案，其中某些内存区域仅对一个处理器写入，而对另一个处理器只读。

编辑：请参阅 Hasturkun 答案，了解一种将消息从一个处理器传递到另一个处理器的方法，使用有序写入而不是原子性来提供对某些预定义数据的序列化访问。

于 2009-08-25T08:02:50.600 回答
2

好的。我理解这个问题。我已经解决了这种问题。

现在，您需要了解的第一件事是 2 个 CPU 之间存在的共享内存的工作方式。因为这些共享内存可以通过不同的方式访问，所以您需要找出最适合您的方式。

大多数情况下，硬件信号量将与硬件中断一起在共享内存中提供，以通知从一个处理器到另一个处理器的消息传输。

所以先看看这个。

于 2009-12-18T17:29:50.033 回答
1

编辑

快速单向版本：

  • 就绪标志
  • 完成标志

在里面：

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

通过共享内存构建一个消息传递系统（这应该是一致的，或者通过对两个处理器不缓存，或者通过使用缓存刷新/无效调用）。

您的共享内存结构应该（至少）具有以下字段：

  • 当前所有者
  • 消息活动（如，应阅读）
  • 请求使用字段

流程可能是这样的：（假设发送/接收同步不会同时运行）

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;
}
于 2009-08-25T08:31:07.767 回答
1

一个非常好的方法是来回发送 IP 数据包（使用套接字）。这样做的好处是您可以在芯片外测试东西——例如，如果您有网络，可以在 PC 上运行一个进程的测试版本。

于 2009-08-24T07:00:20.437 回答
1

如果两个处理器都由一个操作系统管理，那么您可以使用任何标准 IPC 相互通信，因为操作系统会处理所有事情。如果它们在不同的操作系统上运行，那么套接字将是您最好的选择。

于 2009-08-25T08:20:17.757 回答
0

使用共享内存怎么样？

我现在没有好的链接，但如果你用谷歌搜索 IPC + 共享内存，我敢打赌你会找到一些好的信息 :)

于 2009-08-24T07:02:05.113 回答
0

你确定你需要这样做吗？根据我的经验，您最好让您的编译器和操作系统管理您的进程如何使用多个 CPU。

于 2009-08-25T07:44:14.803 回答