Execution model: Difference between revisions

Revision as of 10:30, 18 February 2023

Latest revision as of 04:20, 23 March 2024

(One intermediate revision by one other user not shown)

Line 24:

| publisher=Springer US

}}</ref>

and an article discussing execution models for [[Real-time computing|real-time embedded]] languages.<ref>{{cite journal

{{cite journal

| url=http://pertsserver.cs.uiuc.edu/~mcaccamo/papers/PREM_rtas11.pdf

| title=A Predictable Execution Model for COTS-based Embedded Systems

Line 39 ⟶ 38:

| publisher=IEEE

| journal=Real-Time and Embedded Technology and Applications Symposium

| access-date=2015-05-20

| archive-date=2017-08-12

| archive-url=https://web.archive.org/web/20170812100818/http://pertsserver.cs.uiuc.edu/~mcaccamo/papers/PREM_rtas11.pdf

| url-status=dead

}}</ref>

Line 79 ⟶ 82:

The complication comes from the fact that the execution model does not have any means for the execution of "give up ownership of the lock" to have any influence over which execution of "gain ownership of the lock" in some other timeline (thread) follows. Very often, only certain handoffs give valid results. Thus, the programmer must think of all possible combinations of one thread giving up a lock and another thread getting it next, and make sure their code only allows valid combinations.

Note that theThe only effect is that A-post-gain-lock statements come before B-post-gain-lock statements. No other effect happens, and no other relative ordering can be relied upon. Specifically, A-post-give-up-lock and B-post-gain-lock have ''no relative ordering'' defined, which surprises many people. But thread A may have been swapped out after giving up ownership, so A-post-give-up-lock statements may happen long after many B-post-gain-lock statements have finished. That is one of the possibilities that must be thought about when designing locks, and illustrates why multi-threaded programming is difficult.

Note that modernModern parallel languages have much easier to use execution models. The thread model was one of the original parallel execution models, which may account for why it has persisted despite being difficult to use.

== See also ==