TSM67V05
rev. e (21 fev. 97)
7
预告(展)
matra mhs
这 semaphore 必须 使用 一个 写/读 sequence 在
顺序 至 确保 那 非 系统 水平的 conflict 将 出现. 一个
处理器 requests 进入 至 shared resources 用
attempting 至 写 一个 零 至 一个 semaphore location. 如果 这
semaphore 是 already 在 使用, 这 semaphore 要求 获得
将 包含 一个 零, 还 这 semaphore 标记 将 呈现 作
一个 一个, 和 这 处理器 将 发现 这个 状态 在 这
subsequent 读 (看 表格 5). 为 例子, 假设 一个
处理器 写 一个 零 至 这 left 端口 在 一个 自由 semaphore
location. 在 一个 subsequent 读, 这 处理器 将 核实
那 它 有 写 succesfully 至 那 location 和 将
假设 控制 在 这 resource 影响. 如果 一个
处理器 在 这 正确的 一侧 然后 attempts 至 写 一个 零
至 这 一样 semaphore 标记 它 将 失败, 作 将 是 核实
用 一个 subsequent 读 returning 一个 一个 从 这 semaphore
location 在 这 正确的 一侧 had 一个 读/写 sequence
被 使用 instead, 系统 conflict 问题 可以
occurred 在 这 间隔 在 这 读 和 写
循环.
它 必须 是 指出 那 一个 failed semaphore 要求 needs 至
是 followed 用 也 重复的 读 或者 用 writing 一个 一个
至 这 一样 location. 这 简单的 逻辑 图解 为 这
semaphore 标记 在 图示 2 illustrates 这 reason 为 这个
quite clearly. 二 semaphore 要求 latches deed 在 一个
semaphore 标记. 这 第一 获得 至 send 一个 零 至 这
semaphore 标记 将 强迫 它的 一侧 的 这 semaphore 标记
低 和 其它 一侧 高. 这个 状态 将 是 maintained
直到 一个 一个 是 写 至 这 一样 semaphore 要求 获得.
应当 一个 零 是 写 至 这 其它 一侧’s semaphore
要求 获得 在 这 meantime, 这 semaphore 标记 将 flip
在 至 这个 第二 一侧 作 soon 作 一个 一个 是 写 至 这
第一 一侧’s 要求 获得. 这 第二 一侧’s 标记 将 now
停留 低 直到 它的 semaphore 要求 获得 是 changed 至 一个
一个. 因此, clearly, 如果 一个 semaphore 标记 是 要求 和 这
处理器 requesting 它 非 变长 需要 进入 至 这
resource, 这 全部 系统 能 hang 向上 直到 一个 一个 是
写 至 这 semaphore 要求 获得 影响.
semaphore 定时 变为 核心的 当 两个都 sides
要求 这 一样 token 用 attempting 至 写 一个 零 至 它
在 这 一样 时间. semaphore 逻辑 是 specially conceived
至 resolve 这个 问题. 这 逻辑 确保 那 仅有的 一个
一侧 将 receive 这 token 如果 同时发生的 requests 是
制造. 这 第一 一侧 至 制造 一个 要求 将 receive 这
token 在哪里 要求 做 不 arrive 在 这 一样 时间. 在哪里
它们 做 arrive 在 这 一样 时间, 这 逻辑 将 assign 这
token arbitrarily 至 一个 的 这 端口.
它 应当 是 指出, 不管怎样, 那 semaphores alone 做 不
保证 那 进入 至 一个 resource 是 secure. 作 和 任何
powerful 程序编制 技巧, errors 能 是
introduced 如果 semaphores 是 misused 或者 misinterpreted.
代号 integrity 是 的 这 utmost 效能 当
semaphores 是 正在 使用 instead 的 slower, 更多
restrictive 硬件-intensive 系统.
semaphore initialization 是 不 自动 和 必须
因此 是 组成公司的 在 这 电源 向上 initialization
程序. 自从 任何 semaphore 标记 containing 一个 零
必须 是 重置 至 一个, initialization 应当 写 一个 一个 至
所有 要求 flags 从 两个都 sides 至 确保 那 它们 将
是 有 当 必需的.
使用 semaphores – 一些 examples
perhaps 这 simplest 应用 的 semaphores 是 它们的
使用 作 resource markers 为 这 tsm67v05’s 双-端口
内存. 如果 它 是 需要 至 分割 这 8 k
×
8 内存 在 二
4 k
×
8 blocks 这个 是 至 是 专心致志的 至 serving 也
这 left 或者 正确的 端口 在 任何 一个 时间. semaphore 0 能 是
使用 至 表明 这个 一侧 是 controlling 这 更小的
段 的 记忆 和 semaphore 1 能 是 定义 作
表明 这 upper 段 的 记忆.
至 引领 控制 的 一个 ressource, 在 这个 情况 这 更小的 4 k
的 一个 双-端口 内存, 这 left 端口 处理器 将 然后
写 一个 零 在 semaphore 标记 0 和 然后 读 它 后面的.
如果 succesful 在 带去 这 token (读 后面的 一个 零 相当
比 一个 一个), 这 left 处理器 可以 然后 引领 控制 的
这 更小的 4 k 的 内存. 如果 这 正确的 处理器 attempts 至
执行 这 一样 函数 至 引领 控制 的 这 resource
之后 这 left 处理器 有 already 完毕 所以, 它 将 读
后面的 一个 一个 在 回馈 至 这 attempted 写 的 一个 零 在
semaphore 0. 在 这个 要点 这 软件 将 choose 至
attempt 至 增益 控制 在 这 第二 4 k 段 的 内存
用 writing 和 然后 读 一个 零 在 semaphore 1. 如果
successful, 它 将 锁 输出 这 left 处理器.
once 这 left 一侧 有 完成 它的 task 它 将 写 一个 一个
至 semaphore 0 和 将 然后 attempt 至 进入
semaphore 1. 如果 semaphore 1 是 安静的 occupied 用 这 正确的
一侧, 这 left 一侧 将 abandon 它的 semaphore 要求 和
执行 其它 行动 直到 它 是 能 至 写 和 然后
读 一个 零 在 semaphore 1. 如果 这 正确的 处理器 执行
这 一样 运作 和 semaphore 0, 这个 协议 将
然后 准许 这 二 处理 至 swap 4 k blocks 的
双-端口 内存 在 一个 另一.
这 blocks 做 不 有 至 是 任何 particular 大小, 和 将
甚至 是 的 能变的 大小 取决于 在 这 complexity 的
这 软件 使用 这 semaphore flags. 所有 第八
semaphores 可以 是 使用 至 分隔 这 双-端口 内存 或者
其它 shared resources 在 第八 部分. semaphores 能
甚至 是 assigned 不同的 meanings 在 各自 一侧, 相当
比 having 一个 一般 meaning 作 是 描述 在 这
在之上 例子.
: 点此下载
