[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [tlaplus] Re: Fairness in programming languages
- From: Jones Martins <jonesmvc@xxxxxxxxx>
- Date: Wed, 10 Nov 2021 19:00:50 -0300
- Ironport-data: A9a23:LuZ+l60+Cb1fqlYEJfbD5fJwkn2cJEfYwER7XOPLsXnJ0W4h3zNVymMZCm2OO/aJYDH1fN1xaNux9EwCvZ+Dzd8SHQtv/xmBbVoa8JufXYzxwmTYZn7JcJWbFCqL1yivAzX5BJhcokT0+1H9bdANkVEmjfvRH+OlULafUsxMbVYMpBkJ2UoLd9ER2dYAbeiRW2thiPuqyyHtEAfNNw1cbgr435m+RCZH55wejt+3UmsWPpintHeG/5Uc4Ql2yauZdxMUSaEMdgK2qnqq8V23wo/Z109F5tKNl7/6dggNQ+eXM1He0TxZXK+thhUErSs3uko5HKBEOAEH1nPQwY83kYUW3XCzYV9B0qnkhOAUSx1FCGJ0O6Zs04//flqfjpa243fsUkbH/NpBJWQZBKAjpMdPO0Zv3fMfLz8JYx+ZgP+u2/SwTewEasELd5CxYdhD4hmMyhmAVap8KXzZeI3G5MRTwSwrrtxKFLDbfNBcaDx1bR2GYhtVO15RBohWoQsCrm2nJmUe9EbM8PJxu3yJmVQ3jOa0bs6OL4TMGNEKy2+GgEnD2Uj5JjATEOCF7QSE12b13rqX2XvvMG4JPLix9/ovh1zKg2JKWEZQWly8rv20zEW5Xrpix4Uv0nJGhcAPGIaDF7ERniFUoUJoejYZUttUVuo7sUSDk/qPpQmeAWcAQ3hKb9lOWAoeLdA1/gfhoj8rLWUHXH6ppba1+bCToje/NjISMHcZIyQDSGPpJvH99ZorgEunoslLScaIYx6cJd006z+Nqyc6iroJitMTzOOw+lWvb/eEznTWZlZd2zg7lV5JIu+0iEBJqmBoBZXmAS58Ebuk
- Ironport-hdrordr: A9a23:a2pdR6802NEmcRZZXIluk+DmI+orL9Y04lQ7vn2ZKCYlEPBw8vrEoB1173/JYVoqN03I+urtBEDjex7hHPdOiOEs1NGZPTUO0FHYSb2KhrGSoAEIdReRygb6v50QF5RWOZnVNxxblsbhpC21Dt4MyMSOmZrDudvj
- References: <email@example.com> <firstname.lastname@example.org> <email@example.com>
Thank you, Markus.
I supposed it was mostly kernel level. Also, it's nice to remember about ReentrantLock; I'll read the documentation about it.
May I ask in your BlockingQueue spec, why do you need to prove Deadlock freedom in the sense that why is it necessary? Is it good practice to prove specs of its size?
On 11/10/21 8:34 AM, Willy Schultz wrote:
> Typically, whether or not liveness is ensured (i.e. via fairness) for a
> multi-threaded concurrent program (e.g. in C++) may be dependent on the
> policy of the OS scheduler. It may also, for example, be dependent on
> the scheduling/queuing policy implemented in the synchronization
> primitives you use (e.g. locks, condition variables, etc.). In general,
> though, I usually consider such fairness concerns in real world
> concurrent programs as things that are "under the hood" e.g. at the OS
> kernel level.
> This might vary from instance to instance, though. For example, if you
> have a program where threads are scheduled in user space, you may have
> more fine grained control over the scheduling policies. Also, in a
> distributed system, where separate programs are operating concurrently,
> fairness assumptions for each process may also become more explicit
> and/or controllable e.g. "if a process is non-faulty for long enough and
> has a message in its queue then it will eventually process the message"
> or something like that.
Java's ReentrantLock  is an example of a synchronization primitive
where fairness is exposed to the programmer. By the way, the (fair)
lock essentially implements the fairness constraint  of a high-level
You received this message because you are subscribed to a topic in the Google Groups "tlaplus" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/tlaplus/4bAoiI44xGY/unsubscribe.
To unsubscribe from this group and all its topics, send an email to tlaplus+unsubscribe@xxxxxxxxxxxxxxxx.
To view this discussion on the web visit https://groups.google.com/d/msgid/tlaplus/d61c9c8a-09ed-2875-e196-71270259f974%40lemmster.de.
You received this message because you are subscribed to the Google Groups "tlaplus" group.
To unsubscribe from this group and stop receiving emails from it, send an email to tlaplus+unsubscribe@xxxxxxxxxxxxxxxx.
To view this discussion on the web visit https://groups.google.com/d/msgid/tlaplus/CABW84KzOsRK18Z_zxO9WReOYAOLvs4Hu9i8%3D%3Db%3Diu7PJeLJ47w%40mail.gmail.com.