Why some Linux devs still use spinlocks.

There is An interesting article, on another BB, which explains what some of the effects are, of spinlocks under Linux. But, given that at least under Linux, spinlocks are regarded as ‘bad code’ and constitute ‘a busy-wait loop’, I think that that posting does not explain the subject very well of why, in certain cases, they are still used.

A similar approach to acquiring an exclusive lock – that can exist as an abstract object, which does not really need to be linked to the resource that it’s designed to protect – could be programmed by a novice programmer, if there were not already a standard implementation somewhere. That other approach could read:


from time import sleep
import inspect
import thread

def acquire( obj ):
    assert inspect.isclass(obj)
    myID = thread.get_ident()
    if obj.owner is None:
        # Replace .owner with a unique attribute name.
        # In C, .owner needs to be declared volatile.
        # Compiler: Don't optimize out any reads.
        obj.owner = myID
    while obj.owner != myID:
        if obj.owner == 0:
            obj.owner = myID

def release( obj ):
    assert inspect.isclass(obj)
    if obj.owner is None:
        # In C, .owner needs to be declared volatile.
        obj.owner = 0
    if obj.owner == thread.get_ident():
        obj.owner = 0


(Code updated 2/26/2020, 8h50…

I should add that, in the example above, Lines 8-12 will just happen to work under Python, because multi-threading under Python is in fact single-threaded, and governed by a Global Interpreter Lock. The semantics that take place between Lines 12 and 13 would break in the intended case, where this would just be pseudo-code, and where several clock cycles elapse, so that the ‘Truth’ which Line 13 tests may not last, just because another thread would have added a corresponding attribute on Line 12. OTOH, adding another sleep() statement is unnecessary, as those semantics are not available, outside Python.

In the same vein, if the above code is ported to C, then what matters is the fact that in the current thread, several clock-cycles elapse between Lines 14 and 15. Within those clock cycles, other threads could also read that obj.owner == 0, and assign themselves. Therefore, the only sleep() instruction is dual-purpose. Its duration might exceed the amount of time the cache was slowed down to, to execute multiple assignments to the same memory location. After that, one out of possibly several threads would have been the last, to assign themselves. And then, that thread would also be the one that breaks out of the loop.

However, there is more that could happen between Lines 14 and 15 above, than cache-inefficiency. An O/S scheduler could cause a context-switch, and the current thread could be out of action for some time. If that amount of time exceeds 20 milliseconds, then the current thread would assign itself afterwards, even though another thread has already passed the retest of Line 13, and assumes that it owns the Mutex. Therefore, better suggested pseudo-code is offered at the end of this posting…



This pseudo-code has another weakness. It assumes that every time the resource is not free, the program can afford to wait for more than 20 milliseconds, before re-attempting to acquire it. The problem can crop up, that the current process or thread must acquire the resource, within microseconds, or even within nanoseconds, after it has become free. And for such a short period of time, there is no way that the O/S can reschedule the current CPU core, to perform any useful amount of work on another process or thread. Therefore, in such cases, a busy-wait loop becomes The Alternative.

I suppose that another reason, for which some people have used spinlocks, is just due to bad code design.


Note: The subject has long been debated, of what the timer interrupt frequency should be. According to kernel v2.4 or earlier, it was 100Hz. According to kernel v2.6 and later, it has been 1000Hz. Therefore, in principle, an interval of 2 milliseconds could be inserted above (in case the resource had not become free). However, I don’t really think that doing so would change the nature of the problem.

Explanation: One of the (higher-priority, hardware) interrupt requests consists of nothing but a steady pulse-train, from a programmable oscillator. Even though the kernel can set its frequency over a wide range, this frequency is known not to be terribly accurate. Therefore, assuming that the machine has the software installed, that provides ‘strict kernel marshalling’, every time this interrupt fires, the system time is advanced by a floating-point number, that is also adjusted over a period of hours and days, so that the system time keeps in-sync with an external time reference. Under Debian Linux, the package which installs that is named ‘ntp’.


There exist a few other tricks to understand, about how, in practice, to force an Operating System which is not an RTOS, to behave like a Real-Time O/S. I’ve known a person who understood computers on a theoretical basis, and who had studied Real-Time Operating Systems. That’s a complicated subject. But, given the reality that his operating system was not a Real-Time O/S, he was somewhat stumped by why then, it was able to play a video-clip at 24 FPS…

(Updated on 3/12/2020, 13h20 …)

Continue reading Why some Linux devs still use spinlocks.

Inkscape Extension ‘svg2tikz’ revisited.

In this earlier posting, I had written about the low-performing 3rd-party Inkscape Extension known as ‘svg2tikz’. Nevertheless, this extension may prove useful to some users, who wish to import an arbitrary document-type into Inkscape – preferably vector-based – and who wish to convert that into LaTeX in some way. And it seems that, even though this project was abandoned some time ago, work has slowly begun to resume on its source-code. And so, I should also fine-tune some of the earlier commentary I had made about this extension.

First off, there is an important detail about how to compile and install this extension, which its devs fail to point out anywhere. It needs to be built and installed, using Python 3, while many Linux computers still default to Python 2.7. Therefore, the commands to build and install it are:


$ python3 setup.py build
$ su
# python3 setup.py install


If one neglects this detail, then Unicode support is left out, and usually, SVG Files etc., will contain some Unicode characters. Further, as the Github comment states, while the importing of raster-based images is now supported, their import as Base-64 encoded, inline data is not. Therefore, within Inkscape, for example if a PDF File is being imported, the option needs to be unchecked, to ‘Embed’ graphics. And when Saving a Copy to TiKz Format, the option should also be unchecked, to ‘Indent Groups’.

But this last detail leads me to an important, additional observation. I have always known that the export of Text with the Figure has been dodgy. But lately, either because I’ve become more observant, or, because the behaviour of the latest version of the extension has improved, I’ve noticed what, exactly, goes wrong with Exporting Text along with the Figure.

(Updated 2/11/2020, 1h05 … )

Continue reading Inkscape Extension ‘svg2tikz’ revisited.

Some Issues, with Multiple Input Ports, on One PulseAudio Sound Device

My situation is such that my Linux computers have elaborate Graphical User Interfaces, as well as the Pulse Audio Server, for use in multimedia. Yet, to adapt them to my own needs, I have done some customizing of the Audio Server, specifically, giving it a ‘Loop-Back’ module, so that when I play music from my FM Receiver, to the Line Input jack of the PC in question, that music is ‘looped back’, to my speaker amp, for my enjoyment. Such configuration changes can have consequences on how to perform other multimedia tasks, such as Screen Recording, which, on the computer named ‘Phosphene’, requires that I plug a microphone into the Front Mic Jack because that Tower-PC has no internal Web-Cam or Mic.

Ever since I made the ‘loopback’ configuration change, I never retested the ability to plug in a Mic into the front jack, until only a few days ago. But when I finally did, it was with the initial purpose of testing whether certain Screen-Recording software works, which is different software from the software I’d normally use, which was not designed primarily for use with Linux, but the ability of which to connect to my sound inputs is as good, as that of the Web-browser (Chrome) that the extension runs within.

I got a rude surprise when running this test, in that plugging in an input, to the Front Mic Jack, borked my sound, at least until I restarted Pulse Audio. But beyond that, I learned that my sound issue was not due to this browser extension, but rather due to the way I had configured Pulse Audio, as well as perhaps, due to hardware limitations of the ‘Creative Sound Blaster X-Fi Xtreme’ sound card. I.e., Even if I did nothing to relaunch this extension I was first testing, but only plugged in a mike to the Front Mic Jack, during a clean Pulse Audio Server session, the malfunction came back.

So, what was the nature of this malfunction?

According to Pulse Audio, a computer could have one or more Sound Devices, which corresponds to the number of Analog-to-Digital Converters it has, in the case of capture devices, but each of those could have more than one Port, which would be the specific analog input, that is feeding the Sound Device in question. And, Pulse Audio supports the H/W feature of modern sound cards, to detect whether a plug has in fact been inserted into each jack, thus making the Port available. By default, what Pulse Audio would do is simple: Switch the input of the Sound Device, to the newly-plugged analog input. But, it doesn’t work.

When I plugged my external mike into the Front Jack for any reason, while the Line Input in the back of the computer was also active, which it is by default, just so that I could turn on my FM Receiver and hear music,

  • I got no sound input from the Front Mic, even though the GUI shows that the input has been switched,
  • Switching the input manually produced no difference in behaviour,
  • The loopback module will go into a corrupted state, in which it will loop back sound from the Line Input, but with a 10-30 second time delay. I was hearing music, long after I had turned my FM Receiver off…

I took numerous, lengthy steps to find out why this was happening, but my conclusion was, that the actual hardware is unable to activate the Front Mic Jack, as long as the (rear) Line Input is plugged in simultaneously. And this cannot be corrected from the software side, with my present H/W. And so, what I needed to do was, to develop a workflow that would ease switching from ‘Music Enjoyment Mode’, to ‘Screen Recording Mode’, and back again, in the fastest time possible, and without requiring excessive restarts…

In other words, even if I was setting up a Screen-Recording to be created using the native application I’d normally use, because either solution is at the application level, I’d need to follow the same steps to make them work.

Continue reading Some Issues, with Multiple Input Ports, on One PulseAudio Sound Device