here - Stefan-Marr.de

3. Which Concepts for Concurrent and Parallel Progr. does a VM need to Support?
or computational intensive operations provided by the underlying system or
primitives. Thereby, it enables a certain degree of parallel execution and latency
hiding. C modules for Python are able to use PyEval_AcquireLock()
and PyEval_ReleaseLock() to release the lock before starting I/O or computational
intensive operations that do not require interpreter intervention and
thereby enable other threads to use it.
The threading module provides threads, locks, recursive locks, barriers,
semaphores, and condition variables. However, only thread operations, locks,
and recursive locks are implemented as primitives. Barriers, semaphores, and
condition variables are built completely on top of them.
Similarly to Mozart, Python’s support for Communicating Isolates is discussed
separately in Sec. 3.1.2.3.
Ruby Similarly to Python, Ruby’s standard implementation is based on a
GIL, called global VM lock (gvl). C modules that want to execute in parallel
can do so by using the high-level rb_thread_blocking_region(..) function,
by which they promise to take care of threading issues by themselves, and
the VM will release the gvl during execution. However, this is of course not
offered at the language level.
To the user, Ruby offers primitives for Threads and Mutexes combined with
the shared memory model as part of VM support. The standard library builds
on this basic support by offering for instance condition variables.
Self and Squeak Squeak is based on the ideas of Smalltalk-80 [Goldberg and
Robson, 1983] and follows its specification closely (cf. sections 4.3 and 4.4).
Self [Chambers et al., 1989] belongs to the Smalltalk family of languages as
well, but has significant differences in terms of its object model. Furthermore,
it pioneered important language implementation techniques such as dynamic
optimization. Both Squeak and Self closely follow the standard Smalltalk
model when it comes to concurrent and parallel programming. They offer
the notion of green threads in combination with semaphores.
Squeak implements these concepts based on primitives. It provides for instance
yield, resume, and suspend primitives to influence the scheduling of
green threads (instances of the Process class). Furthermore, it provides the
signal and wait primitives to interact with the semaphore implementation
of the VM. Based on these, the libraries provide mutexes, monitors, and concurrent
data structures such as queues.
48