The schema¶
How the concepts connect. The ontology says what each concept is a kind of. This page draws everything else: what a concept is built on, what it helps prevent, what it can lead to, what it is an alternative to, and what it is often confused with.
Every connection is written once, in the data behind these pages (11_Concepts/<category>/concepts.toml), and appears on both concepts' pages — so a link from mutex to deadlock cannot exist without the link back.
Reading a diagram. An arrow points from the concept a relation is written from: mutex —can cause→ deadlock. A line without an arrowhead reads the same both ways (deadlock — vs — livelock). A dashed box is a concept from another category, drawn because something in this one connects to it. See also links appear on the pages and in the table at the end, but not in the diagrams, which they would clutter.
The relations¶
| Relation | Read it as | On the other page |
|---|---|---|
is_a |
A — is a kind of — B | B — kinds — A |
uses |
A — is built on — B | B — is used by — A |
prevents |
A — helps prevent — B | B — is prevented by — A |
causes |
A — can lead to — B | B — can be caused by — A |
alternative |
A — an alternative to — B | the same, both ways |
contrasts |
A — often confused with — B | the same, both ways |
related |
A — see also — B | the same, both ways |
Between categories¶
Each arrow counts the connections from concepts in one category to concepts in another.
flowchart LR
c_foundations["Foundations"]
c_units_of_execution["Units of execution"]
c_scheduling["Scheduling"]
c_hazards["Hazards"]
c_synchronization["Synchronization"]
c_lock_free["Lock-free"]
c_communication["Communication"]
c_async["Async"]
c_parallelism["Parallelism"]
c_safety_in_languages["Safety in languages"]
c_distributed["Distributed systems"]
c_real_time["Real-time systems"]
c_testing_and_tools["Testing and tools"]
c_async -->|4| c_hazards
c_async -->|2| c_scheduling
c_async -->|1| c_units_of_execution
c_communication -->|1| c_hazards
c_communication -->|1| c_synchronization
c_communication -->|1| c_units_of_execution
c_distributed -->|1| c_synchronization
c_foundations -->|1| c_distributed
c_foundations -->|3| c_hazards
c_foundations -->|1| c_units_of_execution
c_lock_free -->|6| c_hazards
c_lock_free -->|2| c_synchronization
c_parallelism -->|1| c_async
c_parallelism -->|2| c_communication
c_parallelism -->|2| c_foundations
c_parallelism -->|2| c_scheduling
c_parallelism -->|1| c_synchronization
c_parallelism -->|4| c_units_of_execution
c_real_time -->|2| c_scheduling
c_safety_in_languages -->|4| c_hazards
c_safety_in_languages -->|1| c_lock_free
c_safety_in_languages -->|2| c_synchronization
c_scheduling -->|1| c_async
c_scheduling -->|1| c_synchronization
c_scheduling -->|1| c_units_of_execution
c_synchronization -->|9| c_hazards
c_synchronization -->|2| c_lock_free
c_synchronization -->|1| c_scheduling
c_testing_and_tools -->|1| c_hazards
c_units_of_execution -->|1| c_async
c_units_of_execution -->|1| c_hazardsFoundations¶
Dashed boxes belong to other categories.
flowchart LR
n_asynchrony["Asynchrony"]
n_concurrency["Concurrency"]
n_contention["Contention"]
n_context_switch["Context switch"]
n_data_parallelism["Data parallelism"]
n_distributed_computing["Distributed computing"]
n_heisenbug["Heisenbug"]
n_interleaving["Interleaving"]
n_multitasking["Multitasking"]
n_nondeterminism["Nondeterminism"]
n_oversubscription["Oversubscription"]
n_parallelism["Parallelism"]
n_race_condition["Race condition"]
n_sequential_execution["Sequential execution"]
n_task_parallelism["Task parallelism"]
n_asynchrony ---|vs| n_concurrency
n_asynchrony ---|vs| n_parallelism
n_concurrency ---|vs| n_distributed_computing
n_concurrency ---|vs| n_parallelism
n_concurrency ---|vs| n_sequential_execution
n_data_parallelism -->|is a| n_parallelism
n_interleaving -->|can cause| n_race_condition
n_multitasking -->|uses| n_context_switch
n_nondeterminism -->|can cause| n_heisenbug
n_oversubscription -->|can cause| n_contention
n_task_parallelism -->|is a| n_parallelism
classDef outside stroke-dasharray: 4 3
class n_contention,n_context_switch,n_data_parallelism,n_distributed_computing,n_heisenbug,n_race_condition,n_task_parallelism outsideUnits of execution¶
Dashed boxes belong to other categories.
flowchart LR
n_async_state_machine["Async functions as state machines"]
n_subprocess["Child process"]
n_context_switch["Context switch"]
n_coroutine["Coroutine"]
n_daemon_thread["Daemon and detached threads"]
n_data_race["Data race"]
n_fiber["Fiber"]
n_future_and_promise["Future and promise"]
n_goroutine["Goroutine"]
n_green_thread["Green threads and M:N scheduling"]
n_ipc["Inter-process communication"]
n_mpi["MPI"]
n_multiprocessing["Multiprocessing"]
n_multitasking["Multitasking"]
n_openmp["OpenMP"]
n_parallel_iterators["Parallel iterators and streams"]
n_process["Process"]
n_scheduler["Scheduler"]
n_async_task["Task (async)"]
n_thread["Thread"]
n_thread_pool["Thread pool and executor"]
n_thread_local_storage["Thread-local storage"]
n_ui_thread["UI thread"]
n_virtual_thread["Virtual thread"]
n_async_state_machine -->|uses| n_coroutine
n_async_task ---|vs| n_thread
n_async_task -->|uses| n_future_and_promise
n_daemon_thread -->|is a| n_thread
n_fiber -->|is a| n_coroutine
n_goroutine -->|is a| n_green_thread
n_green_thread -->|is a| n_thread
n_ipc -->|uses| n_process
n_mpi -->|uses| n_process
n_multiprocessing -->|uses| n_process
n_multitasking -->|uses| n_context_switch
n_openmp -->|uses| n_thread_pool
n_parallel_iterators -->|uses| n_thread_pool
n_process ---|vs| n_thread
n_scheduler -->|uses| n_context_switch
n_subprocess -->|is a| n_process
n_thread_local_storage -->|prevents| n_data_race
n_thread_pool -->|uses| n_thread
n_ui_thread -->|is a| n_thread
n_virtual_thread -->|is a| n_green_thread
classDef outside stroke-dasharray: 4 3
class n_async_state_machine,n_data_race,n_future_and_promise,n_ipc,n_mpi,n_multiprocessing,n_multitasking,n_openmp,n_parallel_iterators,n_scheduler outsideScheduling¶
Dashed boxes belong to other categories.
flowchart LR
n_async_await["Async and await"]
n_async_runtime["Async runtime (executor and reactor)"]
n_blocking_the_event_loop["Blocking the event loop"]
n_busy_waiting["Busy waiting"]
n_condition_variable["Condition variable"]
n_context_switch["Context switch"]
n_cooperative_scheduling["Cooperative scheduling"]
n_earliest_deadline_first["Earliest deadline first"]
n_event_loop["Event loop"]
n_event_driven_programming["Event-driven programming"]
n_fork_join["Fork-join"]
n_io_multiplexing["I/O multiplexing"]
n_parallel_iterators["Parallel iterators and streams"]
n_polling["Polling"]
n_preemptive_scheduling["Preemptive scheduling"]
n_rate_monotonic_scheduling["Rate-monotonic scheduling"]
n_scheduler["Scheduler"]
n_scheduling_policy["Scheduling policy"]
n_spinlock["Spinlock"]
n_suspension_point["Suspension point"]
n_work_stealing["Work stealing"]
n_async_await -->|uses| n_suspension_point
n_async_runtime -->|uses| n_event_loop
n_async_runtime -->|uses| n_io_multiplexing
n_async_runtime -->|uses| n_polling
n_async_runtime -->|uses| n_work_stealing
n_busy_waiting ---|or| n_condition_variable
n_cooperative_scheduling -->|can cause| n_blocking_the_event_loop
n_cooperative_scheduling ---|vs| n_preemptive_scheduling
n_cooperative_scheduling -->|is a| n_scheduling_policy
n_cooperative_scheduling -->|uses| n_suspension_point
n_earliest_deadline_first -->|is a| n_preemptive_scheduling
n_event_driven_programming -->|uses| n_event_loop
n_event_loop -->|uses| n_io_multiplexing
n_fork_join -->|uses| n_work_stealing
n_parallel_iterators -->|uses| n_work_stealing
n_preemptive_scheduling -->|is a| n_scheduling_policy
n_rate_monotonic_scheduling -->|is a| n_preemptive_scheduling
n_scheduler -->|uses| n_context_switch
n_scheduler -->|uses| n_scheduling_policy
n_spinlock -->|uses| n_busy_waiting
n_work_stealing -->|is a| n_scheduling_policy
classDef outside stroke-dasharray: 4 3
class n_async_await,n_blocking_the_event_loop,n_condition_variable,n_context_switch,n_earliest_deadline_first,n_event_driven_programming,n_fork_join,n_parallel_iterators,n_rate_monotonic_scheduling,n_spinlock outsideHazards¶
Dashed boxes belong to other categories.
flowchart LR
n_aba_problem["ABA problem"]
n_atomic_variable["Atomic variable"]
n_blocking_the_event_loop["Blocking the event loop"]
n_cancellation["Cancellation"]
n_compare_and_swap["Compare-and-swap"]
n_contention["Contention"]
n_data_race["Data race"]
n_data_race_freedom["Data-race freedom by construction"]
n_deadlock["Deadlock"]
n_deterministic_testing["Deterministic scheduling for tests"]
n_hazard_pointers["Hazard pointers"]
n_heisenbug["Heisenbug"]
n_immutability["Immutability"]
n_interleaving["Interleaving"]
n_task_leak["Leaked tasks"]
n_livelock["Livelock"]
n_liveness_failure["Liveness failure"]
n_lock_ordering["Lock ordering"]
n_lock_free["Lock-free"]
n_mutex["Mutex"]
n_mutual_exclusion["Mutual exclusion"]
n_nondeterminism["Nondeterminism"]
n_oversubscription["Oversubscription"]
n_priority_inversion["Priority inversion"]
n_race_condition["Race condition"]
n_read_write_lock["Read-write lock"]
n_safety_failure["Safety failure"]
n_scoped_lock["Scoped locking"]
n_send_and_sync["Send and Sync"]
n_shared_memory["Shared memory"]
n_starvation["Starvation"]
n_structured_concurrency["Structured concurrency"]
n_thread_confinement["Thread confinement"]
n_thread_local_storage["Thread-local storage"]
n_toctou["Time of check to time of use"]
n_timeout["Timeout"]
n_transactional_memory["Transactional memory"]
n_aba_problem -->|is a| n_race_condition
n_atomic_variable -->|prevents| n_data_race
n_blocking_the_event_loop -->|can cause| n_starvation
n_cancellation -->|prevents| n_task_leak
n_compare_and_swap -->|can cause| n_aba_problem
n_compare_and_swap -->|prevents| n_toctou
n_data_race ---|vs| n_race_condition
n_data_race -->|is a| n_safety_failure
n_data_race_freedom -->|prevents| n_data_race
n_deadlock ---|vs| n_livelock
n_deadlock ---|vs| n_starvation
n_deadlock -->|is a| n_liveness_failure
n_deterministic_testing -->|prevents| n_heisenbug
n_hazard_pointers -->|prevents| n_aba_problem
n_immutability -->|prevents| n_data_race
n_interleaving -->|can cause| n_race_condition
n_livelock -->|is a| n_liveness_failure
n_lock_free -->|prevents| n_deadlock
n_lock_ordering -->|prevents| n_deadlock
n_mutex -->|can cause| n_contention
n_mutex -->|can cause| n_deadlock
n_mutex -->|can cause| n_priority_inversion
n_mutual_exclusion -->|prevents| n_data_race
n_mutual_exclusion -->|prevents| n_race_condition
n_mutual_exclusion -->|prevents| n_toctou
n_nondeterminism -->|can cause| n_heisenbug
n_oversubscription -->|can cause| n_contention
n_priority_inversion -->|is a| n_liveness_failure
n_race_condition -->|can cause| n_heisenbug
n_race_condition -->|is a| n_safety_failure
n_read_write_lock -->|can cause| n_starvation
n_scoped_lock -->|prevents| n_liveness_failure
n_send_and_sync -->|prevents| n_data_race
n_shared_memory -->|can cause| n_data_race
n_starvation -->|is a| n_liveness_failure
n_structured_concurrency -->|prevents| n_task_leak
n_task_leak -->|is a| n_liveness_failure
n_thread_confinement -->|prevents| n_data_race
n_thread_local_storage -->|prevents| n_data_race
n_timeout -->|prevents| n_deadlock
n_toctou -->|is a| n_race_condition
n_transactional_memory -->|prevents| n_deadlock
classDef outside stroke-dasharray: 4 3
class n_atomic_variable,n_blocking_the_event_loop,n_cancellation,n_compare_and_swap,n_data_race_freedom,n_deterministic_testing,n_hazard_pointers,n_immutability,n_interleaving,n_lock_ordering,n_lock_free,n_mutex,n_mutual_exclusion,n_nondeterminism,n_oversubscription,n_read_write_lock,n_scoped_lock,n_send_and_sync,n_shared_memory,n_structured_concurrency,n_thread_confinement,n_thread_local_storage,n_timeout,n_transactional_memory outsideSynchronization¶
Dashed boxes belong to other categories.
flowchart LR
n_atomic_variable["Atomic variable"]
n_barrier["Barrier"]
n_busy_waiting["Busy waiting"]
n_channel["Channel"]
n_condition_variable["Condition variable"]
n_contention["Contention"]
n_data_race["Data race"]
n_deadlock["Deadlock"]
n_futex["Futex"]
n_gil["Global interpreter lock"]
n_interior_mutability["Interior mutability"]
n_latch["Latch"]
n_liveness_failure["Liveness failure"]
n_lock_ordering["Lock ordering"]
n_monitor["Monitor"]
n_mvcc["Multi-version concurrency control"]
n_mutex["Mutex"]
n_mutual_exclusion["Mutual exclusion"]
n_priority_inversion["Priority inversion"]
n_race_condition["Race condition"]
n_rcu["Read-copy-update"]
n_read_write_lock["Read-write lock"]
n_reentrancy["Reentrancy"]
n_reentrant_lock["Reentrant lock"]
n_once_initialization["Run-once initialization"]
n_scoped_lock["Scoped locking"]
n_semaphore["Semaphore"]
n_spinlock["Spinlock"]
n_starvation["Starvation"]
n_synchronization["Synchronization"]
n_toctou["Time of check to time of use"]
n_transactional_memory["Transactional memory"]
n_atomic_variable ---|or| n_mutex
n_barrier ---|vs| n_latch
n_barrier -->|is a| n_synchronization
n_busy_waiting ---|or| n_condition_variable
n_channel ---|or| n_mutex
n_condition_variable -->|is a| n_synchronization
n_condition_variable -->|uses| n_mutex
n_gil -->|uses| n_mutex
n_interior_mutability -->|uses| n_mutex
n_latch -->|is a| n_synchronization
n_lock_ordering -->|prevents| n_deadlock
n_monitor -->|is a| n_synchronization
n_monitor -->|uses| n_condition_variable
n_monitor -->|uses| n_mutex
n_mutex ---|or| n_transactional_memory
n_mutex -->|can cause| n_contention
n_mutex -->|can cause| n_deadlock
n_mutex -->|can cause| n_priority_inversion
n_mutex -->|is a| n_mutual_exclusion
n_mutex -->|uses| n_futex
n_mutual_exclusion -->|is a| n_synchronization
n_mutual_exclusion -->|prevents| n_data_race
n_mutual_exclusion -->|prevents| n_race_condition
n_mutual_exclusion -->|prevents| n_toctou
n_mvcc ---|or| n_read_write_lock
n_once_initialization -->|is a| n_synchronization
n_rcu ---|or| n_read_write_lock
n_read_write_lock -->|can cause| n_starvation
n_read_write_lock -->|is a| n_mutex
n_reentrancy ---|vs| n_reentrant_lock
n_reentrant_lock -->|is a| n_mutex
n_scoped_lock -->|prevents| n_liveness_failure
n_scoped_lock -->|uses| n_mutex
n_semaphore -->|is a| n_synchronization
n_spinlock -->|is a| n_mutex
n_spinlock -->|uses| n_atomic_variable
n_spinlock -->|uses| n_busy_waiting
classDef outside stroke-dasharray: 4 3
class n_atomic_variable,n_busy_waiting,n_channel,n_contention,n_data_race,n_deadlock,n_gil,n_interior_mutability,n_liveness_failure,n_mvcc,n_priority_inversion,n_race_condition,n_rcu,n_reentrancy,n_starvation,n_toctou,n_transactional_memory outsideLock-free¶
Dashed boxes belong to other categories.
flowchart LR
n_aba_problem["ABA problem"]
n_atomic_variable["Atomic variable"]
n_compare_and_swap["Compare-and-swap"]
n_concurrent_data_structures["Concurrent data structures"]
n_data_race["Data race"]
n_deadlock["Deadlock"]
n_hazard_pointers["Hazard pointers"]
n_interior_mutability["Interior mutability"]
n_lock_free["Lock-free"]
n_mutex["Mutex"]
n_rcu["Read-copy-update"]
n_read_write_lock["Read-write lock"]
n_spinlock["Spinlock"]
n_toctou["Time of check to time of use"]
n_transactional_memory["Transactional memory"]
n_wait_free["Wait-free"]
n_atomic_variable ---|or| n_mutex
n_atomic_variable -->|prevents| n_data_race
n_compare_and_swap -->|can cause| n_aba_problem
n_compare_and_swap -->|prevents| n_toctou
n_concurrent_data_structures -->|uses| n_compare_and_swap
n_hazard_pointers -->|prevents| n_aba_problem
n_interior_mutability -->|uses| n_atomic_variable
n_lock_free -->|prevents| n_deadlock
n_lock_free -->|uses| n_atomic_variable
n_lock_free -->|uses| n_compare_and_swap
n_mutex ---|or| n_transactional_memory
n_rcu ---|or| n_read_write_lock
n_rcu -->|uses| n_atomic_variable
n_spinlock -->|uses| n_atomic_variable
n_transactional_memory -->|prevents| n_deadlock
n_wait_free -->|is a| n_lock_free
classDef outside stroke-dasharray: 4 3
class n_aba_problem,n_data_race,n_deadlock,n_interior_mutability,n_mutex,n_read_write_lock,n_spinlock,n_toctou outsideCommunication¶
Dashed boxes belong to other categories.
flowchart LR
n_actor_model["Actor model"]
n_backpressure["Backpressure"]
n_bounded_channel["Buffered and bounded channels"]
n_channel["Channel"]
n_csp["Communicating sequential processes"]
n_data_race["Data race"]
n_fan_out_fan_in["Fan-out, fan-in"]
n_ipc["Inter-process communication"]
n_message_passing["Message passing"]
n_mpi["MPI"]
n_multiprocessing["Multiprocessing"]
n_mutex["Mutex"]
n_otp_behaviours["OTP behaviours"]
n_pipeline["Pipeline"]
n_process["Process"]
n_producer_consumer["Producer-consumer"]
n_publish_subscribe["Publish-subscribe and broadcast"]
n_select["Select"]
n_shared_memory["Shared memory"]
n_signals["Signals"]
n_supervision["Supervision"]
n_task_queue["Task queue"]
n_unbuffered_channel["Unbuffered channel"]
n_worker_pool["Worker pool"]
n_actor_model ---|vs| n_csp
n_actor_model -->|is a| n_message_passing
n_backpressure -->|uses| n_bounded_channel
n_bounded_channel ---|vs| n_unbuffered_channel
n_bounded_channel -->|is a| n_channel
n_channel ---|or| n_mutex
n_channel -->|is a| n_message_passing
n_csp -->|is a| n_message_passing
n_csp -->|uses| n_unbuffered_channel
n_fan_out_fan_in -->|uses| n_channel
n_ipc -->|uses| n_process
n_message_passing ---|or| n_shared_memory
n_mpi -->|uses| n_message_passing
n_multiprocessing -->|uses| n_ipc
n_otp_behaviours -->|uses| n_actor_model
n_otp_behaviours -->|uses| n_supervision
n_pipeline -->|uses| n_channel
n_producer_consumer -->|uses| n_bounded_channel
n_publish_subscribe -->|is a| n_message_passing
n_select -->|uses| n_channel
n_shared_memory -->|can cause| n_data_race
n_signals -->|is a| n_ipc
n_supervision -->|uses| n_actor_model
n_task_queue -->|uses| n_producer_consumer
n_unbuffered_channel -->|is a| n_channel
n_worker_pool -->|uses| n_channel
classDef outside stroke-dasharray: 4 3
class n_data_race,n_mpi,n_multiprocessing,n_mutex,n_process outsideAsync¶
Dashed boxes belong to other categories.
flowchart LR
n_async_await["Async and await"]
n_async_state_machine["Async functions as state machines"]
n_async_stream["Async stream"]
n_blocking_the_event_loop["Blocking the event loop"]
n_callback["Callback"]
n_cancellation["Cancellation"]
n_cooperative_scheduling["Cooperative scheduling"]
n_coroutine["Coroutine"]
n_deadlock["Deadlock"]
n_event_loop["Event loop"]
n_event_driven_programming["Event-driven programming"]
n_fork_join["Fork-join"]
n_future_and_promise["Future and promise"]
n_join["Join"]
n_task_leak["Leaked tasks"]
n_reactive_programming["Reactive programming"]
n_starvation["Starvation"]
n_structured_concurrency["Structured concurrency"]
n_suspension_point["Suspension point"]
n_async_task["Task (async)"]
n_timeout["Timeout"]
n_async_await -->|uses| n_future_and_promise
n_async_await -->|uses| n_suspension_point
n_async_state_machine -->|uses| n_coroutine
n_async_stream -->|uses| n_future_and_promise
n_async_task -->|uses| n_future_and_promise
n_blocking_the_event_loop -->|can cause| n_starvation
n_callback ---|or| n_future_and_promise
n_cancellation -->|prevents| n_task_leak
n_cooperative_scheduling -->|can cause| n_blocking_the_event_loop
n_event_driven_programming ---|vs| n_reactive_programming
n_event_driven_programming -->|uses| n_callback
n_event_driven_programming -->|uses| n_event_loop
n_fork_join -->|uses| n_join
n_reactive_programming -->|uses| n_async_stream
n_structured_concurrency -->|prevents| n_task_leak
n_structured_concurrency -->|uses| n_cancellation
n_structured_concurrency -->|uses| n_join
n_timeout -->|prevents| n_deadlock
n_timeout -->|uses| n_cancellation
classDef outside stroke-dasharray: 4 3
class n_cooperative_scheduling,n_coroutine,n_deadlock,n_event_loop,n_fork_join,n_task_leak,n_starvation,n_suspension_point,n_async_task outsideParallelism¶
Dashed boxes belong to other categories.
flowchart LR
n_data_parallelism["Data parallelism"]
n_fork_join["Fork-join"]
n_gil["Global interpreter lock"]
n_gpu_computing["GPU computing"]
n_ipc["Inter-process communication"]
n_join["Join"]
n_map_reduce["Map-reduce"]
n_message_passing["Message passing"]
n_mpi["MPI"]
n_multiprocessing["Multiprocessing"]
n_mutex["Mutex"]
n_openmp["OpenMP"]
n_parallel_iterators["Parallel iterators and streams"]
n_parallel_prefix_sum["Parallel prefix sum"]
n_parallelism["Parallelism"]
n_process["Process"]
n_simd["SIMD"]
n_task_parallelism["Task parallelism"]
n_thread_pool["Thread pool and executor"]
n_work_stealing["Work stealing"]
n_data_parallelism ---|vs| n_task_parallelism
n_data_parallelism -->|is a| n_parallelism
n_fork_join -->|is a| n_task_parallelism
n_fork_join -->|uses| n_join
n_fork_join -->|uses| n_work_stealing
n_gil -->|uses| n_mutex
n_gpu_computing -->|is a| n_data_parallelism
n_map_reduce -->|is a| n_data_parallelism
n_mpi -->|uses| n_message_passing
n_mpi -->|uses| n_process
n_multiprocessing -->|uses| n_ipc
n_multiprocessing -->|uses| n_process
n_openmp -->|uses| n_thread_pool
n_parallel_iterators -->|is a| n_data_parallelism
n_parallel_iterators -->|uses| n_thread_pool
n_parallel_iterators -->|uses| n_work_stealing
n_parallel_prefix_sum -->|is a| n_data_parallelism
n_simd -->|is a| n_data_parallelism
n_task_parallelism -->|is a| n_parallelism
classDef outside stroke-dasharray: 4 3
class n_ipc,n_join,n_message_passing,n_mutex,n_parallelism,n_process,n_thread_pool,n_work_stealing outsideSafety in languages¶
Dashed boxes belong to other categories.
flowchart LR
n_atomic_variable["Atomic variable"]
n_data_race["Data race"]
n_data_race_freedom["Data-race freedom by construction"]
n_immutability["Immutability"]
n_interior_mutability["Interior mutability"]
n_linearizability["Linearizability"]
n_mutex["Mutex"]
n_reentrancy["Reentrancy"]
n_reentrant_lock["Reentrant lock"]
n_send_and_sync["Send and Sync"]
n_sequential_consistency["Sequential consistency"]
n_thread_confinement["Thread confinement"]
n_data_race_freedom -->|prevents| n_data_race
n_data_race_freedom -->|uses| n_send_and_sync
n_immutability -->|prevents| n_data_race
n_interior_mutability -->|uses| n_atomic_variable
n_interior_mutability -->|uses| n_mutex
n_linearizability ---|vs| n_sequential_consistency
n_reentrancy ---|vs| n_reentrant_lock
n_send_and_sync -->|prevents| n_data_race
n_thread_confinement -->|prevents| n_data_race
classDef outside stroke-dasharray: 4 3
class n_atomic_variable,n_data_race,n_mutex,n_reentrant_lock outsideDistributed systems¶
Dashed boxes belong to other categories.
flowchart LR
n_clock_skew["Clock skew and drift"]
n_concurrency["Concurrency"]
n_distributed_computing["Distributed computing"]
n_durable_execution["Durable execution"]
n_idempotency["Idempotency"]
n_logical_clocks["Logical clocks"]
n_mvcc["Multi-version concurrency control"]
n_read_write_lock["Read-write lock"]
n_clock_skew ---|or| n_logical_clocks
n_concurrency ---|vs| n_distributed_computing
n_durable_execution -->|uses| n_idempotency
n_mvcc ---|or| n_read_write_lock
classDef outside stroke-dasharray: 4 3
class n_concurrency,n_read_write_lock outsideReal-time systems¶
Dashed boxes belong to other categories.
flowchart LR
n_earliest_deadline_first["Earliest deadline first"]
n_preemptive_scheduling["Preemptive scheduling"]
n_rate_monotonic_scheduling["Rate-monotonic scheduling"]
n_wcet["Worst-case execution time"]
n_earliest_deadline_first ---|vs| n_rate_monotonic_scheduling
n_earliest_deadline_first -->|is a| n_preemptive_scheduling
n_earliest_deadline_first -->|uses| n_wcet
n_rate_monotonic_scheduling -->|is a| n_preemptive_scheduling
n_rate_monotonic_scheduling -->|uses| n_wcet
classDef outside stroke-dasharray: 4 3
class n_preemptive_scheduling outsideTesting and tools¶
Dashed boxes belong to other categories.
flowchart LR
n_deterministic_testing["Deterministic scheduling for tests"]
n_heisenbug["Heisenbug"]
n_deterministic_testing -->|prevents| n_heisenbug
classDef outside stroke-dasharray: 4 3
class n_heisenbug outside