idt7026s/l
高-速 16k x 16 双-端口 静态的 内存 军队 和 商业的 温度 范围
6.17 17
D
2939 drw 17
0
D
Q
写
D
0
D
Q
写
SEMAPHORE
要求 flip flop
SEMAPHORE
要求 flip flop
l 端口
r 端口
SEMAPHORE
读
SEMAPHORE
读
双-端口 内存, 这 处理器 在 这 left 端口 可以 写 和
然后 读 一个 零 在 至 semaphore 0. 如果 这个 task 是 success-
全部地 完成 (一个 零 是 读 后面的 相当 比 一个 一个), 这
left 处理器 将 假设 控制 的 这 更小的 8k. 意思-
当 这 正确的 处理器 是 attempting 至 增益 控制 的 这
resource 之后 这 left 处理器, 它 将 读 后面的 一个 一个 在
回馈 至 这 零 它 had attempted 至 写 在 semaphore
0. 在 这个 要点, 这 软件 可以 choose 至 尝试 和 增益
控制 的 这 第二 8k 部分 用 writing, 然后 读 一个 零
在 semaphore 1. 如果 它 succeeded 在 gaining 控制, 它 将
锁 输出 这 left 一侧.
once 这 left 一侧 是 finished 和 它的 task, 它 将 写
一个 一个 至 semaphore 0 和 将 然后 尝试 至 增益 进入 至
semaphore 1. 如果 semaphore 1 是 安静的 occupied 用 这 正确的
一侧, 这 left 一侧 可以 undo 它的 semaphore 要求 和
执行 其它 tasks 直到 它 是 能 至 写, 然后 读 一个 零
在 semaphore 1. 如果 这 正确的 处理器 执行 一个 类似的
task 和 semaphore 0, 这个 协议 将 准许 这 二
processors 至 swap 8k blocks 的 双-端口 内存 和 各自
其它.
这 blocks 做 不 有 至 是 任何 particular 大小 和 能
甚至 是 能变的, 取决于 在之上 这 complexity 的 这
软件 使用 这 semaphore flags. 所有 第八 semaphores
可以 是 使用 至 分隔 这 双-端口 内存 或者 其它 shared
resources 在 第八 部分. semaphores 能 甚至 是 assigned
不同的 meanings 在 不同的 sides 相当 比 正在 给
一个 一般 meaning 作 是 显示 在 这 例子 在之上.
semaphores 是 一个 有用的 表格 的 arbitration 在 系统 像
disk 接口 在哪里 这 cpu 必须 是 锁 输出 的 一个 部分
的 记忆 在 一个 转移 和 这 i/o 设备 不能 tolerate
任何 wait states. 和 这 使用 的 semaphores, once 这 二
设备 有 决定 这个 记忆 范围 是 “off-limits” 至
这 cpu, 两个都 这 cpu 和 这 i/o 设备 可以 进入 它们的
assigned portions 的 记忆 continuously 没有 任何 wait
states.
semaphores 是 也 有用的 在 产品 在哪里 非
记忆 “wait” 状态 是 有 在 一个 或者 两个都 sides. once
一个 semaphore handshake 有 被 执行, 两个都 proces-
sors 能 进入 它们的 assigned 内存 部分 在 全部 速.
另一 应用 是 在 这 范围 的 complex 数据 struc-
tures. 在 这个 情况, 块 arbitration 是 非常 重要的. 为 这个
应用 一个 处理器 将 是 有责任 为 building 和
updating 一个 数据 结构. 这 其它 处理器 然后 读 和
interprets 那 数据 结构. 如果 这 interpreting 处理器
读 一个 incomplete 数据 结构, 一个 主要的 错误 情况
将 exist. 因此, 一些 sort 的 arbitration 必须 是 使用
在 这 二 不同的 processors. 这 building 处理器
arbitrates 为 这 块, locks 它 和 然后 是 能 至 go 在 和
更新 这 数据 结构. 当 这 更新 是 完成, 这
数据 结构 块 是 released. 这个 准许 这 interpreting
处理器 至 来到 后面的 和 读 这 完全 数据 结构,
因此 guaranteeing 一个 consistent 数据 结构.
一个 是 写 至 这 一样 semaphore 要求 获得. 应当
这 其它 一侧’s semaphore 要求 获得 有 被 写 至
一个 零 在 这 meantime, 这 semaphore 标记 将 flip 在 至 这
其它 一侧 作 soon 作 一个 一个 是 写 在 这 第一 一侧’s
要求 获得. 这 第二 一侧’s 标记 将 now 停留 低 直到
它的 semaphore 要求 获得 是 写 至 一个 一个. 从 这个 它 是
容易 至 understand 那, 如果 一个 semaphore 是 要求 和 这
处理器 这个 要求 它 非 变长 needs 这 resource,
这 全部 系统 能 hang 向上 直到 一个 一个 是 写 在 那
semaphore 要求 获得.
这 核心的 情况 的 semaphore 定时 是 当 两个都 sides
要求 一个 单独的 token 用 attempting 至 写 一个 零 在 它 在
这 一样 时间. 这 semaphore 逻辑 是 specially 设计 至
resolve 这个 问题. 如果 同时发生的 requests 是 制造, 这
逻辑 guarantees 那 仅有的 一个 一侧 receives 这 token. 如果 一个
一侧 是 早期 比 这 其它 在 制造 这 要求, 这 第一
一侧 至 制造 这 要求 将 receive 这 token. 如果 两个都
requests arrive 在 这 一样 时间, 这 分派 将 是
arbitrarily 制造 至 一个 端口 或者 这 其它.
一个 提醒 那 应当 是 指出 当 使用 semaphores
是 那 semaphores alone 做 不 保证 那 进入 至 一个
resource 是 secure. 作 和 任何 powerful 程序编制
技巧, 如果 semaphores 是 misused 或者 misinterpreted, 一个
软件 错误 能 容易地 发生.
initialization 的 这 semaphores 是 不 自动 和 必须
是 处理 通过 这 initialization 程序 在 电源-向上. 自从
任何 semaphore 要求 标记 这个 包含 一个 零 必须 是
重置 至 一个 一个, 所有 semaphores 在 两个都 sides 应当 有 一个
一个 写 在 它们 在 initialization 从 两个都 sides 至 使确信
那 它们 将 是 自由 当 需要.
使用 semaphores—some examples
perhaps 这 simplest 应用 的 semaphores 是 它们的
应用 作 resource markers 为 这 idt7026’s 双-端口
内存. say 这 16k x 16 内存 是 至 是 分隔 在 二 8k
x 16 blocks 这个 是 至 是 专心致志的 在 任何 一个 时间 至
servicing 也 这 left 或者 正确的 端口. semaphore 0 可以 是
使用 至 表明 这 一侧 这个 将 控制 这 更小的 部分
的 记忆, 和 semaphore 1 可以 是 定义 作 这
指示信号 为 这 upper 部分 的 记忆.
至 引领 一个 resource, 在 这个 例子 这 更小的 8k 的
图示 4. idt7026 semaphore 逻辑
: 点此下载
