spinlock | Different implementations of spinlock | Machine Learning library

I dont think so. If its possible, any parameter would be a global as well. Making it more complex.

Global variables are ok for this. Create your own global panic object and give it to a new panic handler from the real one.

std::condition_variable only supports std::unique_lock. Use std::condition_variable_any instead.

The condition_variable_any class is a generalization of std::condition_variable. Whereas std::condition_variable works only on std::unique_lock, condition_variable_any can operate on any lock that meets the BasicLockable requirements.

The question is actually an XY problem. I'll answer it with the caveat that the experiment might be useless or even misleading.

The hypothesis that disabled spinning will decrease CPU usage is not necessary correct. Without spinning, a contended lock ends up in calling into OS kernel to park/unpark threads. A system call with a context switch is expensive, so, depending on the number of threads and the length of the critical section, this may actually increase CPU usage.

The options to disable spinning on intrinsic locks in OpenJDK 11 are:

All make systems (as required by POSIX) have a number of built-in rules including rules that know how to compile object files from C files.

For information on GNU make's built-in rules you can review the manual.

I'll ignore your code for the sake of the answer, the answer generally is yes.

A lock does the following things :

1. allows only one thread to acquire it at any given time
2. when the lock is acquired, a read barrier is placed
3. right before the lock is released, a write barrier is placed

The combination of the 3 points above makes the critical section thread safe. only one thread can touch the shared memory, all changes are observed by the locking thread because of the read barrier, and all the changes are to be visible to other locking threads, because of the write barrier.

Can you use atomics to achieve it? Yes, And real life locks (provided for example, by Win32/Posix) ARE implemented by either using atomics and lock free programming, either by using locks that use atomics and lock free programing.

Now, realistically speaking, should you use a self-written lock instead of the standard locks? Absolutely not.

Many concurrency tutorials preserve the notion that spin-locks are "more efficient" than regular locks. I can't stress enough how foolish it is. A user-mode spinlock IS NEVER more efficient than a lock that the OS provides. The reason is simple, that OS locks are wired to the OS scheduler. So if a lock tries to lock a lock and fails - the OS knows to freeze this thread and not reschedule it to run until the lock has been released.

With user-mode spinlocks, this doesn't happen. The OS can't know that the relevant thread tries to acquire to the lock in a tight loop. Yielding is just a patch and not a solution - we want to spin for a short time, then go to sleep until the lock is released. With user mode spin locks, we might waste the entire thread quantum trying to lock the spinlock and yielding.

I will say, for the sake of honesty, that recent C++ standards do give us the ability to sleep on an atomic waiting for it to change its value. So we can, in a very lame way, implement our own "real" locks that try to spin for a while and then sleep until the lock is released. However, implementing a correct and efficient lock when you're not a concurrency expert is pretty much impossible.

My own philosophical opinion that in 2021, developers should rarely deal with those very low-level concurrency topics. Leave those things to the kernel guys. Use some high level concurrency library and focus on the product you want to develop rather than micro-optimizing your code. This is concurrency, where correctness >>> efficiency.

A related rant by Linus Torvalds

(This answer corresponds to Linux kernel version 5.4.)

The newly created kernel thread task executes the function kthread in "kernel/kthread.c". If all is well kthread calls the thread function referred to by the kthread_run's (or kthread_create's) threadfn parameter. However, the final test before calling the threadfn function pointer is to check the kernel thread's KTHREAD_SHOULD_STOP bit. If the KTHREAD_SHOULD_STOP bit is set, the threadfn function pointer will not be called and the new kernel thread task will call do_exit with the exit code -EINTR. The relevant piece of code at the end of function kthread is as follows:

The type of mutex lock we have been describing is also called a spinlock because the process “spins” while waiting for the lock to become available.

Maybe you're misreading the book (that is, "The type of mutex lock we have been describing" might not refer to the exact passage you think it does), or the book is outdated. Modern terminology is quite clear in what a mutex is, but spinlocks get a bit muddy.

• A mutex is a concurrency primitive that allows one agent at a time access to its resource, while the others have to wait in the meantime until it the exclusive access is released. How they wait is not specified and irrelevant, their process might go to sleep, get written to disk, spin in a loop, or perhaps you are using cooperative concurrency (also known as "asynchronous programming") and passing control to the event loop as your 'waiting operation'.

• A spinlock does not have a clear definition. It might be used to refer to:

  1. A synonym for mutex (this is in my opinion wrong, but it happens).
  2. A specific mutex implementation that always waits in a busy loop.
  3. Any sort of busy-waiting loop waiting for a resource. A semaphore, for example, might also get implemented using a 'spinlock'.

  I would consider any use of the word to refer to a (part of a) specific implementation of a concurrency primitive that waits in a busy loop to be correct, if a more general term is not appropriate. That is, use mutex (or whatever primitive you desire) unless you specifically want to talk about a busy-waiting concurrency primitive.

This is more of a comment, really...

I don't use libvirt myself, but as far as I can tell there aren't any audio devices in your config.

Here are the qemu command line options I use for guest (Win10 and others) audio output to PulseAudio output on -machine q35 :

.ContinueWith(_ => DoActionAsync(i)) Returns a Task (or specifically a Task) that completes when DoActionAsync returns. DoActionAsync will return at the first await, thus completing the outer Task and allowing the next operation to begin.

So it will run each "create" serially, but "Finished" will run asynchronously.

A simple solution would be to schedule all the tasks using a LimitedconcurrencyTaskScheduler instead. Or just create a queue of the operations and have a thread processing the queue in order.