Stackless Python的微线程在游戏状态机实现上比Lua的协程有什么优势?

发布于 2024-09-30 04:27:43 字数 54 浏览 10 评论 0原文

Stackless Python 实现相对于 Lua 协程有什么优势吗? 他们之间有什么区别?

Are there any advantages to Stackless Python implementation over Lua's coroutines?
What's the difference between them?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(1

白龙吟 2024-10-07 04:27:43

Stackless Python 和 tasklet

(我没有使用 Stackless Python 进行过任何编程,但我已经阅读了一些有关它如何实现的详细信息):

优点:
  1. 大多数时候都是轻量级的。
  2. 有调度程序来管理当前任务产生后下一个恢复哪个任务。
  3. 支持抢占式调度。 (即运行 X 指令)
  4. 微线程之间通信的通道。
缺点:
  1. 从 tasklet 中产生时有时需要 C 堆栈。 (即当从某些 C 回调中产生时)

带有普通协程的 Lua 5.1:

优点:
  1. 轻量级。
  2. resume()/yield() 函数允许消费者/生产者模型的通信。
缺点:
  1. 没有内置调度程序。您必须管理恢复和恢复产生协程。
  2. 无法从 C 函数、元方法或迭代器中产生。 (Lua 5.2 将消除大部分这些限制,LuaJIT 1.1 提供轻量级 c 堆栈切换以从任何地方进行屈服)
  3. 没有内置的抢占式调度支持。 (必须使用调试钩子)

带有 ConcurrentLua 的 Lua 5.1:

优点:
  1. 轻量级。
  2. 具有协作上下文切换的调度程序。
  3. 具有 Erlang 风格的任务之间的消息传递通信。
  4. 支持节点之间透明的分布式消息传递。
缺点:
  1. 无法从 C 函数、元方法或迭代器中产生。 (同样,大多数这些限制在 Lua 5.2 和 LuaJIT 中消失)
  2. 没有内置的抢占式调度支持。 (必须使用调试钩子)

带有 ConcurrentLua 的 LuaJIT 2.0 Beta:

优点:
  1. 轻量级。
  2. 具有协作上下文切换的调度程序。
  3. 具有 Erlang 风格的任务之间的消息传递通信。
  4. 支持节点之间透明的分布式消息传递。
  5. 非常快的 JIT 支持使得 Lua 速度更快然后是 Python
缺点:
  1. 现在可能无法从 C 函数中产生。这可能会在未来的版本中得到支持。
  2. 没有内置的抢占式调度支持。 (必须使用调试挂钩)

Stackless Python and tasklets

(I haven't done any programming with Stackless Python, but I have read some of the details about how it is implemented):

Pros:
  1. Lightweight most of the time.
  2. Has scheduler to manage which tasklet get resume next after the current one yields.
  3. Support for Preemptive Scheduling. (i.e. run for X instructions)
  4. Channels for communication between tasklets.
Cons:
  1. Sometimes need C-stack when yielding from a tasklet. (i.e. when yielding from some C callbacks)

Lua 5.1 with plain coroutines:

Pros:
  1. Lightweight.
  2. resume()/yield() functions allow consumer/producer model of communication.
Cons:
  1. No built-in scheduler. You have to manage resuming & yielding coroutines.
  2. Can't yield from a C function, a metamethod, or an iterator. (Lua 5.2 will remove most of these restrictions, LuaJIT 1.1 provides lightweight c-stack switching to yield from anywhere)
  3. No built-in Preemptive Scheduling support. (would have to use debug hooks)

Lua 5.1 with ConcurrentLua:

Pros:
  1. Lightweight.
  2. Scheduler with cooperative context switching.
  3. Has Erlang style of message passing communication between tasks.
  4. Support for transparent distributed message passing between nodes.
Cons:
  1. Can't yield from a C function, a metamethod, or an iterator. (again most of these restrictions go-away with Lua 5.2 and LuaJIT)
  2. No built-in Preemptive Scheduling support. (would have to use debug hooks)

LuaJIT 2.0 Beta with ConcurrentLua:

Pros:
  1. Lightweight.
  2. Scheduler with cooperative context switching.
  3. Has Erlang style of message passing communication between tasks.
  4. Support for transparent distributed message passing between nodes.
  5. Very fast JIT support makes Lua much faster then Python
Cons:
  1. Might not be able to yield from a C function right now. This might be supported in future releases.
  2. No built-in Preemptive Scheduling support. (would have to use debug hooks)
~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文