6.16 18
idt7025s/l
高-速 8k x 16 双-端口 静态的 内存 军队 和 商业的 温度 范围
最大 在 系统 flexibility 用 permitting shared resources
至 是 allocated 在 varying 配置. 这 idt7025 做
不 使用 它的 semaphore flags 至 控制 任何 resources 通过
硬件, 因此 准许 这 系统 设计者 总的 flexibility 在
系统 architecture.
一个 有利因素 的 使用 semaphores 相当 比 这 更多
一般 方法 的 硬件 arbitration 是 那 wait states
是 从不 incurred 在 也 处理器. 这个 能 prove 至 是
一个 主要的 有利因素 在 非常 高-速 系统.
如何 这 semaphore flags 工作
这 semaphore 逻辑 是 一个 设置 的 第八 latches 这个 是
独立 的 这 双-端口 内存. 这些 latches 能 是
使用 至 通过 一个 标记, 或者 token, 从 一个 端口 至 这 其它 至
表明 那 一个 shared resource 是 在 使用. 这 semaphores
提供 一个 硬件 assist 为 一个 使用 分派 方法 called
“token passing allocation.” 在 这个 方法, 这 状态 的 一个
semaphore 获得 是 使用 作 一个 token 表明 那 shared
resource 是 在 使用. 如果 这 left 处理器 wants 至 使用 这个
resource, 它 requests 这 token 用 设置 这 获得. 这个
处理器 然后 核实 它的 success 在 设置 这 获得 用
读 它. 如果 它 是 successful, 它 proceeds 至 假设 控制
在 这 shared resource. 如果 它 是 不 successful 在 设置 这
获得, 它 确定 那 这 正确的 一侧 处理器 有 设置 这
获得 第一, 有 这 token 和 是 使用 这 shared resource. 这
left 处理器 能 然后 也 repeatedly 要求 那
semaphore’s 状态 或者 除去 它的 要求 为 那 semaphore
至 执行 另一 task 和 occasionally attempt 又一次 至
增益 控制 的 这 token 通过 这 设置 和 测试 sequence. once
这 正确的 一侧 有 relinquished 这 token, 这 left 一侧 应当
succeed 在 gaining 控制.
这 semaphore flags 是 起作用的 低. 一个 token 是 要求
用 writing 一个 零 在 一个 semaphore 获得 和 是 released 当
这 一样 一侧 写 一个 一个 至 那 获得.
这 第八 semaphore flags reside 在里面 这 idt7025 在 一个
独立的 记忆 空间 从 这 双-端口 内存. 这个
地址 空间 是 accessed 用 放置 一个 低 输入 在 这
SEM
管脚 (这个 acts 作 一个 碎片 选择 为 这 semaphore flags) 和
使用 这 其它 控制 管脚 (地址,
OE
, 和 r/
W
) 作 它们
将 是 使用 在 accessing 一个 标准 静态的 内存. 各自 的
这 flags 有 一个 唯一的 地址 这个 能 是 accessed 用
也 一侧 通过 地址 管脚 a0 – a2. 当 accessing 这
semaphores, 毫无 的 这 其它 地址 管脚 有 任何 效应.
当 writing 至 一个 semaphore, 仅有的 数据 管脚 d
0
是 使用. 如果
一个 低 水平的 是 写 在 一个 unused semaphore location, 那
标记 将 是 设置 至 一个 零 在 那 一侧 和 一个 一个 在 这 其它 一侧
(看 表格 iii). 那 semaphore 能 now 仅有的 是 修改 用
这 一侧 表明 这 零. 当 一个 一个 是 写 在 这 一样
location 从 这 一样 一侧, 这 标记 将 是 设置 至 一个 一个 为 两个都
sides (除非 一个 semaphore 要求 从 这 其它 一侧 是
pending) 和 然后 能 是 写 至 用 两个都 sides. 这 事实
那 这 一侧 这个 是 能 至 写 一个 零 在 一个 semaphore
subsequently locks 输出 写 从 这 其它 一侧 是 what
制造 semaphore flags 有用的 在 interprocessor communica-
tions. (一个 thorough discussing 在 这 使用 的 这个 特性 跟随
shortly.) 一个 零 写 在 这 一样 location 从 这 其它
一侧 将 是 贮存 在 这 semaphore 要求 获得 为 那 一侧
直到 这 semaphore 是 freed 用 这 第一 一侧.
当 一个 semaphore 标记 是 读, 它的 值 是 展开 在 所有
数据 位 所以 那 一个 标记 那 是 一个 一个 读 作 一个 一个 在 所有 数据
位 和 一个 标记 containing 一个 零 读 作 所有 zeros. 这 读
值 是 latched 在 一个 一侧’s 输出 寄存器 当 那 一侧's
semaphore 选择 (
SEM
) 和 输出 使能 (
OE
) 信号 go
起作用的. 这个 serves 至 disallow 这 semaphore 从 changing
状态 在 这 middle 的 一个 读 循环 预定的 至 一个 写 循环 从 这
其它 一侧. 因为 的 这个 获得, 一个 重复的 读 的 一个
semaphore 在 一个 测试 循环 必须 导致 也 信号 (
SEM
或者
OE
)
至 go inactive 或者 这 输出 将 从不 改变.
一个 sequence 写/读 必须 是 使用 用 这 sema-
phore 在 顺序 至 保证 那 非 系统 水平的 contention
将 出现. 一个 处理器 requests 进入 至 shared resources
用 attempting 至 写 一个 零 在 一个 semaphore location. 如果 这
semaphore 是 already 在 使用, 这 semaphore 要求 获得 将
包含 一个 零, 还 这 semaphore 标记 将 呈现 作 一个, 一个
事实 这个 这 处理器 将 核实 用 这 subsequent 读
(看 表格 iii). 作 一个 例子, 假设 一个 处理器 写 一个
零 至 这 left 端口 在 一个 自由 semaphore location. 在 一个
subsequent 读, 这 处理器 将 核实 那 它 有 写
successfully 至 那 location 和 将 假设 控制 在 这
resource 在 question. meanwhile, 如果 一个 处理器 在 这 正确的
一侧 attempts 至 写 一个 零 至 这 一样 semaphore 标记 它 将
失败, 作 将 是 核实 用 这 事实 那 一个 一个 将 是 读 从
那 semaphore 在 这 正确的 一侧 在 subsequent 读.
had 一个 sequence 的 读/写 被 使用 instead, 系统
contention 问题 可以 有 occurred 在 这 间隙
在 这 读 和 写 循环.
它 是 重要的 至 便条 那 一个 failed semaphore 要求 必须
是 followed 用 也 重复的 读 或者 用 writing 一个 一个 在
这 一样 location. 这 reason 为 这个 是 容易地 理解 用
looking 在 这 简单的 逻辑 图解 的 这 semaphore 标记 在
图示 4. 二 semaphore 要求 latches 喂养 在 一个 sema-
phore 标记. whichever 获得 是 第一 至 呈现 一个 零 至 这
semaphore 标记 将 强迫 它的 一侧 的 这 semaphore 标记 低
和 这 其它 一侧 高. 这个 情况 将 continue 直到 一个 一个
是 写 至 这 一样 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
: 点此下载
