[ruby-core:88338] [Ruby trunk Feature#14717] [PATCH] thread: allow disabling preempt

From: ko1@...
Date: 2018-08-08 05:39:18 UTC
List: ruby-core #88338
Issue #14717 has been updated by ko1 (Koichi Sasada).


# The following is the fact I want to clear

(fix me if my understanding is wrong)

I believe this proposal is equals to auto-fiber from user perspective except "how to create" and implementation.

The created concurrent entity (CE) is same:

* CE does not support preemption by timer.
* CE only switches other CE when explicit action (`Thread.pass`) or implicit blocking operations.

The CE is not same:

* implementation
  * Using native-thread (OS resource) (by `preemptible=false`)
  * Using only memory (by auto-fiber).
* creation.
  * we can switch`preemptible` by `preemptible=` method.
  * auto-fiber should be created from special constructor(s)

# This is my opinion

I don't think it is good idea to support `Thread#preemptible=false` because someone can misuse this feature as "locking" like `Thread.exclusive` on Ruby 1.8 (this method prevented thread switching. From 1.9, this method changed meaning).

I agree with Eregon:

> However, I think making preemption an argument of the constructor, or a special Thread class/factory method would help implementing it on Ruby implementations without a GVL.

and this is what auto-fiber do. I don't against to introduce auto-fiber if the name is related to Thread (not related to Fiber. The implementation is based on Fiber, but the semantics is not Fiber. They should not have `#resume` method and so on).


----------------------------------------
Feature #14717: [PATCH] thread: allow disabling preempt
https://bugs.ruby-lang.org/issues/14717#change-73366

* Author: normalperson (Eric Wong)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
In some cases, it may be beneficial to disable preemptibility to
have more predictable behavior than increasing Thread#priority.
Threads with preempt disabled will run until they either:

    a) encounter a thread blocking region
    b) call Thread.pass

This allows native threads to act cooperatively without
being interrupted by other threads.

Thread#preemptible? => true or false
Thread#preemptible = (true|false)


I plan to implement timer-based switching to "auto-fiber/threadlet/thriber/whatever-name"
[Feature #13618] to minimize migration costs from Thread.

However, I think based on the discussion in [Feature #13618]; having
predictability of non-preemptible threads is beneficial.  So implement it
for native Thread for now.

I will unify the behavior of [Feature #13618] with existing Thread.
I think green/native threads can be unified under Thread class similar to
how Fixnum/Bignum are both "Integer".


---Files--------------------------------
0001-thread-allow-disabling-preempt.patch (4.16 KB)


-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:[email protected]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>

In This Thread

Prev Next