liblfds.org blog

2021-06-16

Update

I’ve changed virtual server provider. This has meant shifting my web-sites from their existing server to a new server.

For liblfds, there were basically four systems to bring over - Bugzilla, Mediawiki, Esotalk (the forum) and Wordpress.

Bugzilla has now been ditched. It is not reasonably (or even unreasonably) possible to move from mySQL to Postgres. I will need in due course to write my own bug tracker; I like Bugzilla a lot, but I lost all my data, and I can’t ignore that.

Mediawiki has been brought over, although it’s for historical reference; future documentation will be markdown converted into [whatever] by pandoc.

The Forum only had a few posts, and no capability I think to export data, and I’ve had the same problem with previous forums, so I’ve written my own and that’s now in place.

Wordpress I wanted to ditch, too big, complicated and vulnerable, so I’ve written my own blog and that’s now in place.

2020-07-14

Mailing list blues

The mailing list has been down for a little while - I’ve been too busy to fix it until just now.

It used to work, and then it started throwing an error, and now I’ve debugged it, I think (but I could be wrong), Python’s behaviour changed - it became unable to call a function (“email.utils.parseaddr”) because later in the same function, the variable “email” would be declared. Of course, if an undeclared variable is used, then it’s an error, but I’m surprised Python confused the leading part of a module name with a variable name - and that it did not seem to do so before. But I am Python hacker, I’ve never sat down and really read the docs, so I may be completely wrong and it’s just me, not understanding.

2020-06-17

OH YEAH!

MAC                IP              hostname       valid until         manufacturer        
===============================================================================================
00:13:20:fe:2f:1d  10.0.0.6        minnow         2020-06-17 12:31:46 -NA-                
00:1e:06:42:30:d0  10.0.0.4        odroid-buster6 2020-06-17 12:32:14 -NA-                
70:b3:d5:92:f2:e0  10.0.0.7        freedom-u540   2020-06-17 12:36:53 -NA-                
b8:27:eb:b9:81:e4  10.0.0.2        raspberrypi    2020-06-17 12:30:10 -NA-                
d0:31:10:ff:73:17  10.0.0.5        ci20           2020-06-17 12:32:59 -NA-    

2020-06-16

Dev board setup update

Three of the five dev boards are now running - ARM64, ARM32, MIPS32. I built the SD card image for RISC-V yesterday and this morning (actually involves building an entire Linux distro!) but it looks like the power button on the SBC is broken so I can’t power the board up right now!

The Intel x86 (actual 32-bit only) SBC I tried powering up a few days ago but it didn’t play ball - that’s next to investigate, while I figure out what to do with the power button on the RISC-V.

Finally, my laptop is working (go figure :-) so x86_64 is working.

2020-06-12

Green shoots!

Astoundingly, I have begun to make some progress bringing the dev board fleet back on its feet.

I bought a decent little ethernet hub ages ago, and now a few days ago a set of little U/FTP flat ethernet cables (I had some S/FTP which were way too inflexible, because about half the dev boards have their ethernet sockets one way up, the others the other way up), and I’ve hooked up all the cabling and - now the difficult bit - I need to bring each dev board back to life.

My first problem was getting an IP to the dev board. Setting up a static IP on a headless dev board is a huge pain in the ass, because although configuring /etc/interfaces is trivial turning off DHCP when you can’t boot the sdcard is problematic, far as I know.

In the end I finally understood why the recommended method to configure static IP is to use a DHCP server to do it - the boards can all be configured with DHCP, and then they’ll work if they go into a router or into a local subnet hanging off your laptop.

My setup is that my laptop runs a Tor proxy and blocks all outbound access except that through the proxy. So I run a DHCP server now, on the ethernet port, which hooks to the hub, and the five dev boards are plugged into that, the dev boards IP from the DHCP server, and they’re all configured to proxy via the Tor proxy on my machine - beautiful. Nice and secure - the dev boards don’t even know my public IP, let alone have an ability to access the internetwebs (except via Tor proxy, which is fine for apt, but wget didn’t want to work first time so I need to look at that).

That’s the plan anyway - and right now I’ve got almost all of it working for the old Raspberry Pi 3. I only need to set up the static DHCP address - everything else is fine.

There is an enormous cost to this though.

Only more modern apts can proxy via socks, so I needed to move from I think it was Jessie (it’s been a while!) to the latest, Buster (and, tragically, Raspbian is now called Raspios - those whom the Gods would destroy, first they make mad).

This means all the GCCs I built natively on the devices will no longer run, because the clib has changed. I spent many month building as many GCC versions as I could - and it could take days to build a single GCC.

2020-04-29

Hola

I occasionally have emails from people asking me for the pre-release of 7.2.0, since it comes with ARM64.

I had one such email a couple of days ago, and it inspired me to get working again on liblfds - at least, in parallel with the other stuff that I’m working on (I’ve been writing a book for more than a year).

I’ve changed the ARM64 platform from a PINE64 to an Odroid N2 and this means I need to set up the N2 - get it into the IP network, configure it to be a build client, start building GCCs.

Well, it’s been 2.5 days now - about 20 hours - and I have failed to configure the N2 to have a single, static IP address. I’ve failed to do this on three different distros (Debian Buster, the current Armbian, and the current Ubuntu).

The cables work fine, as does the N2, as the N2 works fine with DHCP when connected to the router.

So putting this one down for a bit.

Now going to see about getting the RISC-V dev board up. I think I can get Debian going, but I’m wondering if I will run into the same problems with IP addresses.

Currently it looks to me like I will need to run a DHCP server to hand out static IP addresses, which is insane, but if madness is the only option remaining, well, what do you do?

2019-03-11

Proving correctness

I’ve been working on the new test/benchmark programme.

It’s a lot of work. There’s a -lot- of code.

Problem is, the test code is not serious. All it does is run lots of threads doing lots of work and tries to make things go wrong - there’s no directed effort to cause unusual cases, it’s just run-and-hope - and there’s fairly limited checking you can do at the end of the test to see if data is correct.

It does find bugs, but that’s the most you can say.

I need and I’ve known I’ve needed for a long time a more formal, rigourous test.

This is not a straightforward problem to solve. There’s ongoing research work into how to do this in a timely and practical manner - which is to say, on unmodified or essentially unmodified source code, no translating the source code into a model for a modeller (since such work obviously leads to bugs).

I read a white paper just now which is fairly recent (2014) and what’s being done basically is enumeration of paths of execution, with culling for paths which are equivelent, with the compiler back-end being co-oped to notice when memory accesses occur (although I don’t know how it really knows, since what the hardware does is different to what the compiler does - OTOH, in theory, the world looks normal to a single thread so maybe that all works out, and you the processor ensuring the world looks normal is enough?), and then there’s a correctness checker which I’ve not yet read about, so I’m not sure how it works.

The code is on github, it’s for C++, but you know open source - it doesn’t work. I’m going to need to write my own.

2019-03-08

Duration inspiration

So I’ve been banging away at getting the threading test/benchmark code working.

I had originally looked to use the Windows-type createprocess approach in Linux (you can do so) but this is wrong - the way Windows does this is more limited, and I can imagine use cases with Linux where thee more flexible fork() method will be -necessary-. So now Windows will use CreateProcess() (which needs a command line binary to execute) and Linux will use fork(), and that choice then defines the porting abstraction layer.

I also decided to move all memory allocation fully back out to the test/benchmark library caller - there was helper code in the library, but it’s just making life complicated and is potentially going to get in the way for some users.

So I’ve sorted out the fundamentals of the porting abstraction layer.

That leaves the duration problem - bare C89, so no timers. How do we know how long to run tests for? see previous post for details.

What’s just occured to me is to classify each test as slow or fast, and on the command line, the user can specify the number of iterations for each class, to over-ride the defaults.

It’s some complexity, but there has to be some user involvement because there is no way to measure time, so it’s impossible in the code to figure out how long to run a test for.

2019-03-05

Update

Working on the test and benchmark programme.

There’s a lot of functionality, so a lot of work.

Currently getting thread-based testing off the ground.

Making progress. Two main things to sort out - how to handle durations and memory allocation.

The standard library isn’t used, so there are no time functions.

Duration is number of iterations.

Problem is, tasks (tests and benchmarks) vary in how long an iteration takes, and will vary as the platform varies.

So some users will want less iterations, some more, and the number of iterations will still need to vary by task.

Memory allocation is a problem for the command line wrapper.

The test and benchmark code itself performs no allocations, but the caller has to.

The test and benchmark programme being general then needs to deal with NUMA and NUMA/shared memory, on Windows and Linux.

So, there’s quite a few variations of allocation methods.

Once that’s airborne, then process-based.

After that, then re-implementation of all tests, and also then a complete set of benchmarks.

At that point I can get back to actually coding lock-free data structures… =-)

(This Wordpress post was brought to you by Mousepad.)

Addendum - it’s even worse than I realised. You have to click “Publish” twice to publish.

2019-03-01

Minor site update

Finally got rid of the frames.

Moved the site back over to https (had time to sort out the certs from LetsEncrypt).  There’s still a http server for the site, it redirects to https.  I’m fairly sure everything is working.

Wordpress updated to v5 and the new editor is absolutely appalling, with no way to use the previous editor.  It’s about unusable.  It uses a tiny part of the screen for editing, the text and cursor keep being moved around when you perform operations in the UI, and the cursor disappears at times, not to mention the usual bizzaro-world totally unexpected jumping around when you’re doing editing and moving the cursor (that’s really the worst thing - the unpredictability and inconsistency of cursor movements - you have to think and pay attention to move the cursor, because it can’t be done on autopilot because the movements are not consistent).  Answer is editing in a real text editor and just pasting here.

I’ve had to write a book, the last few months.

Another month or two to go.

Then back to working on the next release.

2018-10-24

Cute little problem

Running into a cute little problem, to do with initializing the test and benchmark programme.

The test and benchmark code is in a library - there’s a command line wrapper provided for convenience. The code is in a library so users on embedded platforms and the like can use the test and benchmark functionality.

The code in the library performs no allocations - the user passes in memory. The user could after all be an embedded platform with no malloc and just global arrays.

The library code is complex enough there needs to be some flexibility in memory allocation, so the user provided memory is the store which is placed into an API and that API offers malloc() like behaviour.

The test and benchmark code, being NUMA aware, needs an allocation on each NUMA node.

Asking the user to do the work to figure out his NUMA arrangement is quite onerous, though - and in fact the porting layer already has this code in it.

So what we really want it to get the topology info from the porting layer.

To do this though we need… some store from the user.

So it kinda looks like first we make a topology instance, and then the user uses this to find out about his NUMA layout and make allocs.

To make a topology instance though the user needs to know how much store to allocate - and that’s the cute little problem.

How do you write code which can either work and do its job, or, tell you how many bytes of store it will need to do its job?

Now if the function is “flat”, in that it needs no allocations to find out how much store it needs, then it’s straightfoward enough.

However, if the function is “deep”, and it needs allocations, as it goes along, to find out how much store it needs, then life is more complicated - in fact, what must happen is that the user calls the function repeatedly, until he gets the same result twice, and the user needs to pass in each time as much store as the function asked for the time before.

There are Windows functions like this.

Problem is… now it’s quite a bit of extra work, and I’m not sure I’m getting very much for all this.

2018-10-19

Update

I’ve had some time to do a bit of work.

The library now compiles again.

I want to move over from using an array for pointer-and-counter to using a struct, but that’s a fundamental change, so I need to get the new test suite up and running.

So now I’m working to get the new test and benchmark programme working.

For now I think I’m only going to release single-segment position independence.

There’s a single multi-segment data structure, for the nodeallocate freelist; I’ll keep that, so I can benchmark it, to get a first sense of how much overhead multi-segment brings.

2018-10-09

A thought

With position independent data structures, I have to use an offset.

Maximum convenience is when the offset is from the data structure state structure - but this implies negative offsets can occur, which means I have a problem becasuse I can’t address the entire address range.

Well - if we say all pointers used will be to 4 or 8 bytes offsets, then we have two or three bits free at the LS bit end of things.

When we do pointer math we get a ptrdiff_t, like it or not.

What we could do is cast the pointers to int long long unsigned (or anyway the unsigned int same length as a pointer), figure out the difference and if it’s negative or positive and use one of those free LS bits as the sign bit.

That way the normal data structure can support the full address range, using offsets, and so is used in the normal case and is also sound for use with single segment relocations.

(Multi-segment still needs all the extra work with storing multiple base addresses.)

This is all fly-by-night, of course. Totally outside of the Standard.

The problem with this - user data is a void pointer for key and a void pointer for value.

These are both converted to an offset.

They could point to chars.

They could also be set directly. Being converted to an offset doesn’t hurt, you’re converted back afterwards, but having the LS bit used for something else will.

Ack. Just realised, direct setting is a problem for the normal signed offset variant. If the user sets a value directly, and the value is far enough away from the address of the data structure state, signed overflow will occur. Implementation defined is not a place I want to be. Need a different macro for setting direct values.

2018-10-08

Update

I was wrong about using unsigned offsets.

The result of pointer math will always be a ptrdiff_t, which is to say signed.

I can’t get an unsigned diff… well, mmm, unless I cast the pointers to unsigned ints first…?

I’m starting to worry that I’m pushing the limits here though.

In other news, where the offset/version combo for an offset has to be signed for the offset and unsigned for the version, an array of lfds720_pal_uint_t doesn’t work. I can take the address of the first element, cast it to a pointer to ptrdiff_t and then deref, but actually, having gone over the struct packing stuff again to be sure, I think I will actually be fine using a struct. I didn’t want to go that way, I felt it was opening a window for compiles to get things wrong, but I read a very nice article about it and now I feel happy.

This is the article;

http://www.catb.org/esr/structure-packing/

“The interesting news is that NTP has apparently being getting away with this for decades across a very wide span of hardware, operating systems, and compilers, including not just Unixes but under Windows variants as well. This suggests that platforms with padding rules other than self-alignment are either nonexistent or confined to such specialized niches that they’re never either NTP servers or clients.”

Anyways, the structures are nicer than the two element array - it’s clearer what’s going on.

2018-10-07

Update / I’m sad

I am sad.

This is because I think I need three variants of every data structure.

The first is the normal variant - pointers are what they are, absolute values (virtual or physical as they may be).

The second is the single segment variant - pointers are offsets, and all data must be within a contiguous range which is half the address range; the only way the user can guarantee this is to make a single contiguous allocation. So here we’re looking at shared memory, or buffers passed down into or up from the kernel, that sort of thing.

The third is the multi segment variant - pointers are offsets, and we keep track of the base address of each segment, and that has to be done on a per-address range basis (so each process needs to register each new block of shared memory, to indicate what the base address is in its virtual address range). However, since all offsets are positive, we can use unsigned (and we have to anyway, since we borrow some MS bits for a segment number), and so we support the entire address range. Downside is the per-address range state, which the user has to set up and add segments to when they are made, and the overheads (array scan) in the data structure to figure out which segment a given pointer belongs to. Oh also actually since we borrow MS bits for the segment number, the more segments you want to support, the smaller the maximum address range for each segment. Again, this means users have to allocate blocks.

The third variant supports what the second variant does, but the third variant I think it primarily for NUMA on Windows - not for everyone and their dog - and the second variant is so much easier to use and the single segment use case is going to be common, shared memory between processes, so it’s worth having that variant.

Update

I finally had two free days.

I’ve been working on position independence.

Been backwards and forwards a bit.

Currently thinking to make all normal data structures work using offsets, which means they support a single address range regardless of absolute address values, as long as the relative positions of all data structure states, elements and user data are the same.

There can then be an extra variant for each data structure which supports multiple segments.

The one (and big) problem with this is that if I make the API nice, and use offsets relative to the data struture state, I have to support negative offsets, which means on 32 bit machines all data needs to be within 2 GB of the data structure state. That is by no means guaranteed, and is outside of the control of the user. Actually the same problem exists on 64 bit machines - if we imagine a 64 bit virtual adress range (it’s not 64 bit in practise, but this doesn’t change things) we still only have 63 bits, so all data still needs to be within half the address range.

If the API is not quite so nice, and you specify a base address and so all offsets are positive, this problem goes away. Note though reading/writing data structure element user data is in the nice API relative to the data structure element, so in the not quite so nice API, we have somehow to know the base pointer, which means each element has to point to the state structure (which has a copy), and this is a significant extra cost in terms of memory access.

2018-10-01

C versions

So, I was working on the position independence stuff and thinking about how I’ve currently implemented multi-segment support - I’m comparing pointers in different allocations. This is not legit, but normally it works… which doesn’t fill me with joy.

While looking over how this can fail (I was thinking about memory range address extensions on 32-bit platforms) I came across some posts about the type of the result of subtracting a void pointer from a void pointer.

It’s a ptrdiff_t, of course…

…except it’s not.

Standard C does not support subtracting void pointers from void pointers, because the type is unknown.

GCC lets you do this as an extention - treats the pointers as pointers to unsigned char.

I then after a bit realised I was getting a -lot- of extras from using -std=gnu89 rather than -std=c89, which I’d done just to get C++ style comments.

So wrote a script, converted all C++ style comments to C comments, and changed to c99 with -pedantic-warnings.

Keeeeeeeeeerunch.

“Type long long not supported”.

Bloody right too - “long long” didn’t turn up in the Standard until C99.

It’s a GCC extension prior to C99.

My problem is I’ve had to support Windows, and MS stopped supporting C decades ago, so they’re still C89 - and in fact I’ve been using a platform extension there too. Until now I’ve not worried very much about the later C versions - I’ve got the specs, I need to sit down and read them through. I’d rather have a good book than the spec though - I originally learned C from “The C Book”, which is excellent. (But now I’ve got some time, yes, I’ll finally read through them all. It’s a shame in a way - I’d like to only have to know one version of C, but because of Windows, I need to hang on to remembering C89 - this is actually why I’ve not moved on yet.)

So anyways embarrassement aside, C99 is only really properly supported until GCC 4.5.0.

This is a bit of an interesting problem.

GCC doesn’t really start to compile for non x86/x86_64 platforms until about 4.5.4 (and 4.7.3 for ARM), so that’s okay.

However, I have GCC 4.20, 4.2.2 and 4.2.4 compiled for x86_64 - so if I wanted to support them, I’d need to use gnu89.

So…

All in all, looks like I need to use -std=c99.

This is fine for non-Windows platforms - it will enable long long, and I won’t use any other functionality, so I can still compile on Windows (since the porting layer defines will mean I use the platform extention on Windows for 64 bit types).

Ironically, of course, this means the work I did to replace C++ style comments with C style comments is now not necessary =-)

2018-09-30

Update

Been implementing multi-segment position indepndence.

Originally, I was thinking for each data structure instance would have its own list of segment base addresses. I realised while implementing in fact the list of segments could often for a process be the same across all data structure instances - I’m thinking there will normally be only a few shared memory segments, and they will contain all shared data, which means all the data for many data structures and their elements. As such then the multi-segment code needed to be in a little API of its own, so the same instance of segment base address information can be used with all data structure instances.

2018-09-29

Multi-segment position independent data structures

After a month of being a temporary full-time house-husband, I’m actually doing a bit of coding.

Writing up the first multi-segment position-independent data structure, just a freelist, simplest thing there is so I can go through the multi-segment stuff for the first time.

In the end there will be a single-segment and multi-segment position independent variation of every data structure.

2018-09-10

Update

Just finished a grand renaming.

Not happy with it really.

Have a better idea now.

One thing from this though - I did the work manually.

This does not work - it does not scale.

When you code base is large enough, you must have tools to make changes across the code-base.

So now I write a little script which will let me rename APIs.

2018-09-04

How not to validate data

Trying to make an account on a Russian site, to order a book.

Need to enter name, email address, password.

I enter my name - in Latin.

“Enter your real name”.

I translate to Cyrillic, now we’re okay.

I guess they just don’t want all the extra business that comes from overseas. Damn all that extra profit!

I enter my email address - in Latin - this is fine.

I enter a password.

“Your password contains a link or email address.”

Actually, what it contains which they don’t like are spaces.

I remove the spaces, and get a green tick - password okay.

I hit submit.

“Your password is more than 20 characters.”

The only reason I’m even trying with these jokers is that this is an out of print book for a birthday present, which I already obtained once - but which is no longer available from that seller - and which the Royal Mail in the UK lost the instant I posted it with them; it didn’t even make it out of the post office.

Turns out when I first tried to submit, and was told the password was too long, they sent me a registration email - but with a blank password. When I tried again with a password shorter than 20 characters, they again sent me a registration email, with the pasword in the clear. At this point, I am bailing - I mean, I would make a burner credit card for them, with a balance in roubles equal to the bill, so I’m safe enough, but this is beyond the pale.

As an aside, yesterday, I was configuring the router in my friends place (where I am now) and I turned off WPS.

This made the 5 GHz network disappear.

Really disappear, not just no SSID.

No software works.

Software is the single most unreliable device that exists in the world, except for the Royal Mail.

2018-08-13

More NUMA / shared memory thoughts

Spent the day thinking over shared memory and NUMA.

Supporting a single segment of shared memory is smooth and graceful. It looks good in the API, is simple and easy to understand for the user.

Multiple segments is messy. The user needs to provide per-process state, and to register each segment in each process, before it can be used. Most significant bits have to be taken from the offset value, to indicate which segment the offset is from. When the user passes in a pointer, a lookup has to occur to figure out which segment that pointer is from.

There is a reason to use multiple segments in Linux.

This is that memory policy is on a per-process basis, not per-data structure.

So if I go striped, fine, I can allocate one shared memory block and it’ll be striped on a page basis.

But what if I want striped for one data structure, but something else for another?

There is only one policy, and it is enforced when pages are swapped back in, so you can’t set it, do stuff, and then change it : whatever you have set now is what gradually comes to be applied, as pages swap in and out.

In fact this is a problem anyway : if I do have multiple shared memory segments, one per NUMA node, and I’m so controlling my NUMA directly, and striping on a per-entity bais - memory policy will mess it up for me by applying itself to my allocations.

So there is only one memory policy and it applies to everything in your process, like it or not. You’re fucked anyway. Multiple segments will not save you, unless you pin the pages so they can’t swap, which isn’t a reasonable thing to ask.

So on Linux, multple shared memory segments are not useful, because memory policy stops you from controlling your own NUMA anyway.

On Windows, you do need multiple shared memory segments because the OS does not control NUMA. You do it yourself. So if you want to spread an allocation over multiple NUMA nodes, you need to manually allocate on each of them and then put those elements into the data structure.

Multiple shared memory segments, NUMA, Linux and Windows

I bin learning fings, Oi have.

With position independent (i.e. or maybe e.g. shared memory) data structures;

On Linux you do not need support for multple shared memory segments as far as NUMA is concerned.

This is obvious really - you just turn on striping.

You do need support for multiple shared memory segments just because, i.e. the user may want this for whatever reason.

On Windows, you do need support for multiple shared memory segments as far as NUMA is concerned, to perform striping manually, which is how you have to do it under Windows.

You also need it for itself, as on Linux.

2018-08-12

Shared memory

Position independent data structures support shared memory (i.e. differing virtual address ranges) by using offsets from a known base rather than full virtul addresses.

So far I’ve only supported s single shared memory segment, so all data used has to be in that one segment. The offset is from the data structure state.

This is obviously a problem with NUMA.

With NUMA, you might well want to have a shared memory segment in every NUMA node.

This means in general multiple shared memory segments, which means mutiple offsets, which means when you are manipulating elements in the data structure and so working with offsets, knowing which shared memory segment a given offset is from, so you can know its base.

Central to almost all data structures is the atomic compare-and-swap (CAS).

If we have one segment only, we can compare the offsets across all the different virtual memory ranges and we will know we’re comparing the same data structure element.

If we have multiple segments, we can have the same offset but in different segements. Somehow we have to know, in the CAS, which segment an offset belongs to.

The only way I can see to do this is to borrow some most significant bits.

On 64-bit platforms this should be fine.

If we borrow say 8 bits, we can have 256 shared memory segments, and we have 56 bits remaining for the offset.

On 32-bit platforms it barely works.

If we borrow just 4 bits, and so can have 16 shared memory segments, we have 28 bits left over for the offset - which is 512mb.

It also means we have at times to do a lookup, in the data structure; we have an array, and here we store the base addresses of the different segements, and we look them up when we need to convert the offset to a full virtual address (which we do when we pass elements back to the user, i.e. after a dequeue() or pop()).

Position independence without NUMA is basically a fail, so I think this has to happen.

Shared memory and NUMA

I’ve been thinking about shared memory and NUMA.

Windows always does things differently to Linux, which is usually bad, because Linux usually gets it right or pretty much right.

I think Linux made a bad job of NUMA. Linux tries to make NUMA go away, in the sense of making it so the developer doesn’t need to think about it. This is done by the OS offering NUMA policies, which control how memory allocations are handled with regard to NUMA - local node, striping across all nodes, etc. Critically, when a page has been paged out and then is paged back in, the page is normally expected to be able to change which NUMA node it is in (although it might well not do so).

Windows, which went for a more “here are the controls, do the right thing” approach, is more like C. The developer has to handle the matter.

The library supports bare metal platforms so it does not perform memory allocation; rather, the user passes memory in. The same has to be true for the test and benchmark application, so it can be run on bare metal platforms.

So the user allocates memory and passes it in.

But what happens about shared memory, for the position independent data structures?

THe user allocates shared memory, rather than normal memory, and passes it in, and the child test processes when they run open the shared memory and use it.

So that’s okay.

What happens with NUMA?

The user allocates equal memory on each NUMA node and passes it all in.

There’s a function for this in Windows and Linux, so that’s okay for Windows, but what about Linux moving pages between NUMA nodes on paging-in? the only way to stop this is to pin a memory page, so it cannot be paged out.

So, okay, I can do this for the tests and benchmarks.

What about shared memory with NUMA?

Well, obviously now I would need to allocate equal blocks of shared memory on each NUMA node and pass them in.

Oh. Problems.

On Windows it’s fine - there’s a function to allocate shared memory on a specific NUMA node.

On Linux, there is no such function. Shared memory is placed on NUMA nodes just as non-shared memory, according to the NUMA policy.

I think I might be able to change the NUMA policy just before creation of the shared memory to use and only use a singe NUMA node, the one I want to use; but shared memory like all allocations is really allocated on faulting, so doing this doesn’t do anything.

I suspect what I need to do is change NUMA policy, create shared memory, pin the memory, then fault every page, then revert NUMA policy.

(Another way, says SO, is to create, then move the pages to the desired NUMA node.)

Obviously, this all feels wrong.

Am I doing the wrong thing?

Should I just suck it up and let Linux do what it want to do?

One issue here is comparing like with like.

Actually it raises the question of what is like with like?

If I run the benchmarks on Windows, with low-level NUMA control, and then I run them on Linux, with the same low-level NUMA control, I have like with like.

But if on Linux users are simply using NUMA policy, then I’m coming apples and oranges… …except if Linux is normally like this, then it really is what you normally get, and so that is what you have to compare against.

2018-08-06

Update

Just finished moving the test and benchmark library over to the single threaded data structures.

2018-08-05

Update

Made the test and benchmark library compile.

Both liblfds and libtest_and_benchmark (libtab for short) have subsets of libstds (library single threaded data structures) in.

Originally and wrongly I was expanding the subset in liblfds, where those data structures were being used by libtab. Now I have only the data structures needed by liblfds in liblfds, and only those needed by libtab in libtab.

I now need to move libtab fully away from using liblfds to using libstds.

It was a blunder to have used liblfds, because liblfds provides data structures to the extent you have atomic support, which means you might not have a list, for example - but libtab uses the list everywhere.

Actually maintaining this portability behaviour in the code is a lot of work. If I just assumed x64-level atomics, the portability code would go away. In a sense it matters, because the portability code right now is untested. I do not - and I will need to - build variants which pretend to have less support. With software if it’s not tested, it doesn’t work.

2018-07-29

Work getting done

Tzo!

Coded all day.

Have the new test and benchmark app to the point it compiles.

Still need to do some key work, but it’s an important step.

Importantly, I realised I’d made a huge blunder all along in test and benchmark - I use in test and in benchmark liblfds data structures, the list in particular.

I can’t do that, because liblfds is designed to offer data structures to the extent your system offers atomics; so you might not have the list.

In fact, the test and benchmark code needs to use single threaded data structures throughout.

This means I need to put some of the single-threaded data structure (stds) library data structures in the test and benchmark library.

I also need to introduce versioning on the stds code in liblfds, so multiple released can be compiled in the same project.

I finish my current contract work on Tuesday, and I’ll be taking a few years off, so the next release will come reasonable soon - few months tops.

2018-07-01

The road to hell is paved with affinity APIs

I’m working away on the new test and benchmark application.

I need to support creating processes, to test position-independent data structures.

That means I need to pin processes to particular logical cores.

Know what?

That’s what’s written on the sign that points the way into hell.

Let me put this bluntly : Windows has no API to set process affinity beyond the first processor group, which has a maximum of 64 logical cores.

You read that right.

So if you have say 128 cores, and let’s say Windows has split these up into two 64 core groups - you can only set process affinity to be on cores 0 to 63.

You can set thread affinity to be on any core - but this is not the same as process affinity, and is less performant - but it looks like this is the best you can do.

It’s problematic to do this remotely (from another process). To do so you’d need to call CreateRemoteThreadEx(). In my case, I’m spawning new processes and I want them to quit when the benchmark work is done, so I need to co-ordinate between the main thread (which begins when the process is spawned) and the thread created by CreateRemoteThreadEx(), which will be created at some point after the main thread… it’s hard to wait on things in the main thread which haven’t yet been created. I could busy wait on a global variable…. but this is stomach-twistingly bad. I don’t want to write code like this.

You can set thread affinity from within the process itself by calling SetThreadGroupAffinity(). Obviously to use this you have to pass in information about which logical core in which processor group. I’m passing in some information already to the child process, through the command line (shared memory name and length in bytes), so I’ll have to add this.

It’s still not what I actually want. I want to set process affinity, from the parent process.

Windows thread/process affinity APIs are Civil Service quality - and I don’t mean the British Civil Service. I mean the Egyptian Civil Service.

Next step, finding out how bad it is under Linux. It’ll be bad, but it won’t be as bad, even if it’s just by not having processor groups, which are the worst single concept I’ve encountered since MS-DOS was designed with a 640kb RAM limit.

2018-06-25

Shared memory and NUMA

Windows always does things differently to Linux, and this is almost always a problem, because Linux gets them right.

NUMA is the one exception I know of. Linux got it wrong, and Windows did it differently, and Windows did it right.

Linux has a system-wide policy which controls NUMA, and this is applied whenever a page is paged back in after being paged out. The upshot is you’ll get the system-wide NUMA policy, unless you pin your pages into memory so they can’t be paged. You youself in your application cannot control your NUMA behaviour. It’s controlled in the OS.

Windows does what you’d think would be done : when you make an allocation, you specify the NUMA node, and the OS tries as hard as it can to keep those pages in that node.

So this was all good and fine and clear until this week when I realised something.

I’ve been working on the test application for the position-independent data structures. They are intended for use with shared memory, where the shared memory has different virtual addresses in the difference processes; the data structures internally are using offsets rather than proper virtual memory addresses.

The new test application actually combines the test and the benchmark applications.

With the benchmarks, you want to be NUMA aware and take advantage of it. That means you need to pass in to the benchmark library a block of memory in each NUMA node, so it can put data in the correct places.

Now we see the problem - with shared memory, the data structure state, and all its elements, must be in the same single allocation.

How can you have one allocation per NUMA node and shared memory? because that means you have multiple allocations.

Suddenly Linux looks like it’s doing the right thing. Say you select striped allocations - your pages in any given allocation are striped over NUMA nodes. Okay, it’s not what you really want in your app - you want more fine grained control - but at least you’re able to do something meaningful with NUMA within a single allocation.

On Windows, where an allocation specifies its NUMA node, you just can’t do this.

You could in theory actually still make things work. In the data structure state, you’d have an array, which shows the address ranges for each allocation, and when you get hold of an offset (by popping an element from a freelist, say) you can then figure out which address range it is in, and so know the start of that range, and so figure out the actual virtual address represented by that offset.

Here though obviously you’re needing to do an array scan per freelist access, which is really not what you want.

Ironically, it’s on Windows where the position independent stuff really matters, because there are no locking primitives on Windows which are cross-process.

2018-06-05

Moving to GitLab

GitHub has been bought by Microsoft.

I will be moving to GitLab.

I am looking to move in such a way that the only change to end-users is that the domain name changes.

Will see how that works out when I make the move.

2018-05-28

Shock, amazement, actual work being done

I’ve been working on rewriting the test programme to handle processes, for the position-independent data structures.

Long story short, I’ve taken some of the existing code from test and benchmark, and started again : I’m actually now back to a single libraries, which is both test and benchmark, with a command line convenience wrapper as before (the library has to be there for people running on embedded systems - they don’t have a command line).

I originally wanted a porting abtraction layer library, but it can’t be done, because it’s just too messy to abstract away getting processor topology. To do that you need a topology library, to reduce complexity, and to do that, the porting abstration layer library has to include the main, non-porting library, which makes no sense : a porting abstraction layer should be at the very bottom, independent of everything else. You just can’t emit processor topology info in a clean way though - to do this you need a topology library.

Previously, in test, the test app simply ran one thread on every logical core. One really nice aspect of integrating test and benchmark is that the orthagonal logical processor sets can now be used also to run test, and that if only simple processor info is available (the user implements just say one system node, and then one logical core for each logical core), the benchmark app can still run on that toplogy.

It’s also much easier for the user to compile, and much easier to document.

I originally wanted to have test and benchmark run on threads in one process, then in one thread per process with many processes, then many threads in many processes.

Many threads in many processes turned out to be tricky - it’s not obvious what logical processor sets to compose.

So I backed out of that and now, using the normal logical processor sets, either run them as threads, or as processes.

I then ran into a nasty, messy problem, of starting up processes.

In Linux you fork and it’s great.

In Winodws, Jesus, all you can do is call an external binary. It’s horrific. The only way to communicate with it, without needing another bunch of abstractions (for pipes and so on) is passing it a command line!

I spent today finally getting a passable solution to this, with some abstraction for processes, process sets, command line arguments - oh and command lines are a complete PITA under Windows. In Linux, you pass in an array of pointers to strings. In Windows, you actually have to form up a single long string!

It’s like being in the dark ages.

So, making some progress at last.

I finish my current contract job in nine weeks, at which point I’ll be full time on liblfds until the next release is out (well, barring some time catching up with friends, which will take a week or two).

2018-04-24

Apologies for web-site disruption

I noticed Apache was mis-configured and was serving liblfds pages from other virtual domains on the server.

I fixed it.

This broke my configuration. (I hadn’t really fixed it.)

Apache is hard to configure because the docs are all over the place and there are a dozen ways of doing the same thing and there are plenty of strange behaviours built into the server.

I’ve backed out HTTPS for now, to get things working till I have time to sort them out properly.

(As an aside, Wordpress is a bit crap. If the site URL changes, you can only fix it by editing the mySQL database directly - it’s not actually config in a user-editable text file…)

2018-04-08

Update

So, been workng on the new test application.

I tried to just write it, but it’s too complex; I should have - and now have - composed a state machine.

I’m now implementing the state machine.

Honestly speaking, I only feel like I’ve done a serious piece of work, which I’m happy for other people to see and judge me by, when I’m using a state machine.

Non-state machine code, unless it’s trivially small, is not serious work.

2018-03-25

Untitled

Shock horror an actual post about liblfds.

I’ve been working on the test application.

With the additon of position independent data structure variants, I need to be able to spawn processes and use shared memory, for testing.

I have a number of platforms to think about, to form an abstraction layer over;

  1. Windows
  2. Linux
  3. Android
  4. Embedded

There’s also kernel mode to think about, but kernels don’t have processes as such, and so they don’t have shared memory as such. I do in principle want to test user-mode and kernel-mode code executing concurrently on the same data structure instance, but then I’ll need to really actually make something work in the kernel for both Windows and Linux. I’m familiar with Windows kernel programming, so I could do that (install a driver, then the test app communicates with it), but I’m not familiar with Linux kernel programming (I’ve a kbuild build of liblfds, but it’s not used in anything; I have no idea if it’s a valid build) so these aren’t on the cards right now.

Shared memory is pretty much identical across Windows and Linux so that’s no problem.

No clue how it works on Android - Googling shows up various Java APIs - hopefully Linux under the covers.

Embedded platforms don’t have processes, well, they have one process, the process, so no shared memory.

Where embedded doesn’t offer processes or shared memory, the test app needs to run differently on different platforms, or, rather, depending on what’s available in the platform abstraction layer; position independent tests only happen if there’s support for shared memory and processes.

A weaker form of position independent testing is available just by running them in the same address space, over multiple threads, so that might be something which happens if processes/shared are not available.

Then we come to processes.

Process are completely different between Linux and Windows.

Linux uses fork(). You call fork, and then you have two processes, and they each get a different return value from fork.

Windows uses CreateProcess, which takes a pathname to an executable, and spawns a new process running that executable. Parent and child by default have rights to access each others memory, child can inherit handles, etc.

These two things really are not the same.

Consider my use case; I want to spawn one process per logical core, have it open up a block of shared memory, and then, when everyone is ready (I’ll spinlock on a value in the shared memory) run a particular test.

One problem to begin with is that the design of libtest is based around threads; a “test” is a function which inits a threadset, and that spawns threads which are given a function pointer to the test code. This needs now to be a processset, not a threadset; this wouldn’t be too bad under Linux - but under Windows, to make a process, I have to give a pathname to an executable! and that means, if I want just one test binary (and I do), I need to invoke the test binary with command line arguments such that it knows what to do and will participate in the test which should now be run.

This is nuts. Invoking new processes should not involve work on the command line parser.

I can get around a bit I suppose by having just one special command line argument, which tells the test programme to open up shared memory and get its instructions from there.

2018-03-20

Forum blues

Back to square one for a forum.

Esotalk is really nice - but the recaptcha plugin has disappeared from github, and no forum is viable without a registration captcha.

Flarum is the successor to Esotalk, but last time I tried it, maybe six months ago, I couldn’t get it working. It’s not production ready, even for open source values of production.

Have to remove the forum tab from the site for now.

2018-01-28

Minor update

I’ve been working on the freelist variant using hazard pointers.

It is trying to push an element which is already top of the freelist, which gives you an element pointing to itself.

Not clear why.

In other news, I tried to order a pair of shoes from Jones the Bootmaker. Their site, I would say, silently fails under Firefox. The ordering process is a loop, where placing the order takes you to the beginning of the ordering sequence.

I am beginning to come to the view that using web-sites to place orders is a mistake. Certainly it is the case that forms on web-sites never, ever, EVER work first time. They require at least two attempts to work, and often more - and this is when they do work. Increasingly I am finding order forms simply do not work. This is common enough it’s better simply to order over the phone at the start, rather than spending time on the order form, where it may or may not function.

This is why I order most things from Amazon. It works, without hassle. Random retailer web-sites on the web generally do not work, and are often problematic to navigate or utilize.

I visited the local lesuire center, to tour their gym. They have a room of spinning bikes, but these can only be used in a class. There is a single spinning bike in the gym itself. This is not viable. There is a pool, but it it closed in the hours after work three days a week. This is also not viable. I suspect a State subsidy.

2018-01-23

Actual liblfds work - shock, surprise!

Shockingly, I’m actually do some liblfds work!

The hazard pointer implementation has a bug.

The tests for the implementation pass - but the hazard pointer-using freelist sometimes finds the freelist has a loop, when it comes to clean up the hazard pointer state.

Only happens when you come to deregister the threads. Mmm.

2017-12-28

Forum is back

As subject.

So, mailing list, forum. Now I can get back to working on the C code.

2017-12-27

Mailing list is up

Finally.

Going to put Esotalk back up as the forum. Flarum (the successor) isn’t ready for use.

2017-12-26

Mailing list

I’ve been working a lot on a mailing list.

A list has an email address, a user has an email address, a user can subscribe to a mailing list.

A subscribed user can email to that list, and all subscribers will get that email.

To subscribe, you give your email address, you receive a confirmation email, you click on the link to confirm.

Same to unsubscribe.

Simple, right?

Well it’s been a voyage of discovery :-)

So it’s CGIs in Python with an SQL database for the back-end. No need for anything more than this - this is a simple, lightweight mailing list. We’re not talking ongoing background processes here.

Obviously, I used a state machine to control the flow of execution, and on an impulse I decided to try implementing the state machine in the database - which is to say, there’s a table of states, of events, and the state -> event -> state combinations.

I then after some time realised I would need to implement my usual approach to error handling - Python just throws a wobbly when something goes wrong, and actually want to build up a sane and user-readable call stack and ensure I always emit something sane to the HTTP server (otherwise it just thinks the CGI has fallen over and prints a 5xx).

Having done all this, what I’ve realised is that I’ve not thought properly about what happens when the database goes down.

The state machine steps through states (no kidding right) and there are resting states (like subscribed, or waiting for a confirmation link to be clicked on) and there are sequences of states, where you start the sequence and it moves through a sequence of states (which states depends on the outcomes of each state) and then reaches a resting state.

So what happens if the database dies during a sequence of states?

Well, what has to happen is something picks up where we stopped.

Uh. Ain’t nothing doing that… all the scripts are CGIs, they run when the user makes them run.

So really we need something like a background task which applies the state machine as necessary to every email address subscribed to every list.

Well, okay…

…but in fact, all this state machine checking, you know why you need it? it’s for and only for handling the subscription and unsubscription work - sending out the email asking for confirmation.

Hmm.

So, those confirmations - they are good practise. In fact, on a list with any significant readership, they are necessary, to prevent abuse.

But are they necessary, now, for my list? my tiny list?

…no.

Not at all.

I could just have a subscribe / unsubscribe button, which directly issues the necessary single-statement SQL.

So in fact what we have here is an example - which has cost me many days of work - of writing unnecessary code.

This is in fact one of the key problems of software engineering - making sure you only write that which is actually needed.

2017-10-29

Good news

I’ve written the core functionality of a mailing list.

Python of course; I’ve completed the crontab scrpt - it reads email from a given user, looks at the email address it was sent to (using Postfix virtual addresses), checks the database for lists and who is subscribed to which list, and emails the incoming email on to the subscribers.

Also wrote two CGI scripts, one for subscribe/unsubscribe, the other is called from the confirmation email. Another day of work and it’ll be done.

Two days to write my own mailing list.

I think I must have spent two or three weeks all told experimenting with every mailing list available, and finding them all bad enough, in their different ways, that they were impossible to use.

I have really hopefully finally learned the lesson from this : use open source only if there is absolutely no other way for you to solve he problem. Write your own software if you possibly can, rather than use open source. Open source is awful. It does not work, in any way, at all, ever. Open source has no quality, configuration management, user experience or documentation. It is broken, out of the box, without any docs, and often without any logs or error messages (not to mention spurious and incorrect error messages). You must be a developer, and learn the application yourself, in all its unprofessional horror, and fix it, to make it work at all, and having done this, you will find it’s totally unfit for purpose anyway.

To say there’s a quality problem would be to somehow imply there was any quality at all to start with.

Do not use open source software.

2017-10-27

Open source blues

Well, mailman 2 is going pretty much the way of all open source software.

It’s broken out of the box, and there are no logs.

“Your mission, should you choose to accept it, is to debug some random, large application, which you’ve never touched before, purely from the source code, as there are no logs.”

I’ve spent two days on this now. I’m getting dem open source blues.

Basically it’s this : don’t use open source.

For some large projects, like a database or compiler, you have no choice, because you can’t write those yourself. For anything you can write yourself, for the love of God, write it yourself. It’s quicker, and the quality is infinitely higher, and it’s infinitely more flexible.

2017-10-26

Mailing lists

Are not working yet, but we’re getting there.

Mailman 3 is a joke - a mailing list front-end should not require a beefy server, guys.

Mailman 2 is, apart from the truely mind-blowing issue of mailing passwords in the clear, looking spot on.

2017-10-25

Annnhhhhhd we’re back

Proper post tomorrow.

Brief now note - I’m installing GNU mailman version two. Version three is a resource hog - completely insane for a mailing list.

Version two however has it’s own completely unexpected and utterly incompetent drawback…

Namely, it emails you, en clair, the password you set to control mailman.

Why not just post it to 4chan and have done with it?

It’s truely staggering. I mean, mindblowing. EMAILING A PASSWORD. Holy Jesus Christ on a fucking stick. I mean it’s so bad you’d never think to worry about it, because no one, and I mean, NO ONE, is going to do something SO BLATANTLY WRONG, are they? are they??

Oh wait. Mailman just did.

And you know what? mailman is actually the least worst mailing list out there.

I mean, it just posted my low-security password in public on the Internet during the install procedure, but APART from that…

2017-08-12

Update

Been making position independent versions of the data structures.

So far : freelist, stack, queue (unbounded many many), queue (unbounded single single).

Made tests for the position independent stack, they pass.

Need to make tests for the rest, and also make the position indepenent btree and lists.

Have to think about the freelist elimination array and position independence (I think it’s just okay - works no changes) and have to think about position independence and the SMR methods.

Again, I think they just work - have to switch them over to offsets internally, but that’s all - so it should be possible to make position independent versions of the SMR-using data structures.

The next thing though will be a quick extra benchmark for the freelist, to properly benchmark the elimination array. Gym first though :-)

2017-08-07

Update - first offset-based data structure (for use with shared memory / user-mode to kernel-mode)

Been busy visiting museums the last three days.

However, have now a compiling freelist which uses offsets (i.e. for shared memory use).

Next, tests.

Then have to make offset versions of all the existing data structures.

I’ve opted to use a new API in each case, so the docs are simple to explain, and it seems reasonable that when an instance is being used with shared memory, it will be distinct in its use to other data structures. It would be possible to overload the pointers in the current data structures, so they’re used for offsets, and then you could do things like pop from a shared memory freelist and push to a non-shared memory freelist, but then you have to explain to users all the caveats about use, and users have to make sure they don’t blunder into error.

It also strictly breaks ANSI, since it means I have to assume a pointer type can hold all the values in a ptrdiff_t. I can’t imagine a platform where this isn’t true, but I know I don’t know much.

2017-08-06

Update

Both SMRs now passing their (prety minimal but actually testinge everything) tests, at least on x86_64.

Will run a build-system wide build in the morning.

2017-07-22

build update #2

Removed 4.5.4 on mips32 - it seemed to fail to align correctly, which caused one of the test asserts to trigger immediately.

I think now everything should be right - I’ve now issued the full build. It’ll run overnight, and we’ll see in the morning.

build update

Lookin’ good!

Found and fixed a bug in DWCAS on 4.1.2 - 4.7.3 (related to the previous bug) and now that platform passes tests.

Have an all-compilers, ar-rel only build running now and I expect it to pass.

Then at some point I’ll need to run an all-compiler, all-variants build, which takes about six hours.

That then will finish the Linux work.

Then I’ll need to check the Windows (VM based) builds are still happy, and then the build system is all systems go!

liblfds compiled on mips64, ppc64 and sparc64

Thanks to the GCC Compile Farm, liblfds now has been built on mips64, ppc64 and sparc64!

Nicely, only ppc64 needed work - the defines in the porting layer header for the processor were wrong.

I can’t run the test programme on these platforms though - the test code runs at 100% on all CPUs for some time and would hammer the other users.

2017-07-21

build update

Focusing currently on latest GCC archive release builds.

Fixed a bug in the 32-bit DWCAS code for GCC >= 4.1.2 and 4.7.3.

Now what I’m left with is that test goes badly wrong on i686 with 4.5.4 and 4.6.4 and on mips with 4.5.4 (but 4.6.4 on mips is fine).

Later compilers work. I don’t have versions so far back except on x86_64, which I’ve not tried yet - so those compilers currently are only for those platforms.

The problem seems to be that DWCAS goes wrong.

Investigation continues.

2017-07-17

Step by step!

Frickin’ A.

Just had latestgcc and release variant build on all platforms (except x64 - because I’m using it and it’s disruptive to have it going on in the background :-), test pass, and benchmark complete, and gnuplots produced.

Overnight I’ll run the full build (again, except x64, because the fan noise makes it impossible to sleep :-), all compilers, all platforms, all variants.

Status re next release

So, todo list;

  1. full clean run of build system on all platforms and all supported GCCs
  2. check GC working properly
  3. implement GC-based freelist, queue and stack, and write their tests
  4. complete singly-linked list (with add and delete)
  5. try and figure out what’s happening with the performance of the unbounded/single/single queue
  6. modify freelist to use offsets rather than pointers (for easier use with shared memory)
  7. write a benchmark for the singly-linked list

and

  1. get the bloody forum and mailing list working.

2017-07-16

source control / github / versioning

I’ve opened a new github account, “liblfds2”. There will be one repo, “liblfds”. I’m going to follow a trunk-with-branches approach to source control. I couldn’t use the existing account, because it’s confusing, because of the older repos in there.

I’m using SVN myself, so I’ve moved over to the standard trunk/branches/tags layout.

libbenchmark has a private branch of the earlier versions of liblfds, with the porting abstraction layer and build files updates so they work with the current version (i.e. support the same platforms, so they can all be compiled and run together).

versioning

So, libbenchmark contains the older versions of the library (from 7.0.x onwards) so you can see how well the older versions are performing compared to the current version.

This leads to a problem where the current version can compile and run on more platforms than older versions, and this comes down to differences in the porting abstraction layer.

Deciding what to do with the abstraction layer is a bit problematic.

There are two reason for change;

  1. bug fixes
  2. ensuring older library versions can compile with the current benchmark app

The policy with regard to bug fix releases is of course bug fixes only.

This is not compatible with the sometimes major changes needed to work with the current benchmark app (such as adding new platforms).

The latest version may well have significant modifications (internal improvements), not just additions (new platforms).

We could imagine having two branches, one with bug fix changes only, one with an up-to-date abstraction layer for libbenchmark, but this is getting more complex for the user and also the current versioning system does not properly support this.

I begin to realise versioning systems are a straightjacket. It seems problematic to encode everything in them, but anything you can’t encode can’t happen in your source control system.

I have for a while (and originally did) have an integer version which simply increments. When you have branching, you then need something on your web-site to provide information about which version is which.

Problem is anything which isn’t directly obvious is going to lead people to mistakes.

Pick your poison.

I think what I may do is keep a private branch for libbenchmark.

Users won’t know about it, so it won’t muddy the waters.

twenty hours of debugging, problem now solved

I have just spent twenty hours (broken up by a night of sleep) debugging.

There was something amiss on aarch64 - benchmarks using DWCAS were segfaulting.

I uncovered one bug with the freelist elimination layer, which I fixed. Found another with thread startup ordering, and another with pointer/counter being the wrong way round still in 7.0.1 and 7.1.1.

Still, this didn’t fix the problem.

The particular example of the problem I focused on was this : the freelist benchmark for 7.0.1 with two threads. There’s two freelist elements, two threads, each pops and then pushes, in a tight loop. Problem is one of the threads was popping a NULL (empty freelist).

This in principle was impossible.

Well, I’ve just figured it out. After twenty hours of doing nothing but working on this, to figure it out. I’m pretty relieved and happy :-)

So, on aarch64, I implement my own DWCAS, using LL/SC. Have to, because libatomic is totally messed up right now. I don’t use memory barriers in the DWCAS itself - for me, they’re separate, in the code itself, rather than in the DWCAS.

This means though that the DWCAS is issuing “ldxp” to load, and then “stxp” to store.

If any other thread writes to the load/store location after the ldxp, the stxp will fail - so we’re protected against other thread writing between our load and store.

But…

…we are NOT protected against LOADING THE WRONG VALUE IN THE FIRST PLACE.

So we have (say) no memory barriers. We load the original value, this prior to the DWCAS. Someone else then does a write. We don’t see it, because we have not issued a load barrier - and then we enter into the DWCAS. We load the wrong value - we’ve not seen their write yet - and then we compare it with the compare value we loaded prior to the DWCAS, and lo and behold, they are the same and no one has written to the load/store location during the DWCAS. So we store!! and that messes things up completely.

There has to be a load barrier between the load of the compare and the DWCAS.

It’s plain now - extra plain - I need data structure implementations per processor family.

2017-07-14

freelist elimination array design flaw

So!

I’ve been working on the build system.

I uncovered one subtle bug (wrong type used) in the test library, fixed that.

Then I found that the benchmark for the freelist with elimination layer was crashing consistently with two threads on aarch64 for liblfds 7.1.2 (the in-development version of 7.1.1, where the liblfds core library is present in the benchmark library of 7.2.0, so it can be benchmarked and compared against other versions of liblfds).

I’ve been looking into this for two days.

I think I’ve found a design flaw in the elimination array. I’m still thinking it over, but I think so.

In the current design, you specify when initializing the freelist how many cache lines worth of elimination array you are providing - recommendation is on the order of one per thread you expect to be using the freelist (where the cache lines are used to store freelist element pointers).

You will then push elements onto the freelist. I think often it’s necessary to know how many elements are available - so you might push 32 elements, and you know you have 32 elements, and it might be for your use case you know you’ll never use more than 32, so you can then know the freelist will never be empty.

However, the elimination array is present.

The way it works (in 7.1.x - it’s a bit different in 7.2.0, I’ll come to that) is that a cache line is randomly chose (using a decent PRNG) and its scanned - if you want to push, you’re looking for a NULL, if you want to pop, you’re looking for a pointer.

Now, the first problem is the use of the PRNG (rather than round robin, which is how it works in 7.2.0). The PRNG produces a random value, where the number of elimination array lines is always a power of two, so we subtract one from the number of array lines and binary and that with the random value, to select the array line to use.

Of course, being a random number generator, there’s always a bit of difference in the number of each number produced - the percentage is constant, but the absolute value represented by that percentage rises as the number of operations increases. So if we have say 100 pops and 2 cache lines, we might find we have 49 on cache line 0 and 51 on cache line 1. After 100,000 pops we might find it’s 49,800 on cache line 0 and 51,200 on cache line 1.

The problem is that the number of elements in the cache lines is very small - usually eight.

This means that fairly quickly one cache line is full and the other is empty.

That breaks the elimination layer function anyway, but it actually then - after much crossing of eyes and scratching of head - led on to reveal a second issue.

So, consider the user wants to put 32 elements in the freelist - and rely on there being 32 elements in there. However, we have the elimination array. The freelist selects one line, scans it, if no luck it pops from the freelist proper.

Imagine we have 32 elements, but we have say oh 20 cache lines, each with eight pointers. We could imagine all the elements being popped, then pushed back to the array, but leaving some array lines empty - and then we try to pop, we pick an empty array line, then we go to the freelist proper - and it’s empty. Embarassed looks all round.

To cope with this, the user is expected to push in an extra number of elements - enough to fill the elimination array completely but minus one cache line, the reasoning being the worst possible arrangment of these extra elements leave all caches lines full except for one, we pick that one, miss, and then go to the freelist proper - so it all works.

It doesn’t work though.

Imagine the above scenary. Say there’s four cache lines, three are full, one is empty. There are say four elements on the freelist proper. We want to pop, we select the empty cache line, we begin to scan it - nothing so far… we’re halfway down the scan and the other threads pop the elements from the freelist, and push them into the array line BEHIND* where we are now*.

We think the array is empty, we go to pop from the freelist proper, embarrassed looks all round.

I half-think the only solution to this is that elimination array begins fully populated.

2017-07-11

build system development

It’s not perfect yet - there should be listings I think for test and benchmark failures - but you can see it’s getting there! the output isn’t very ordered yet, either. I also have a ton of benchmark gunplots, which were automatically generated :-)

Total time about 420 minutes on the slowest platform, so about seven hours (platforms run in parallel).

The “512 FAILED” is a bit of a bug - it should say failed, but the number seems unexpected =-)

localhost : x86_64 : gcc : 5.3.0 : ar_vanilla : build : 0 localhost : x86_64 : gcc : 5.3.0 : so_dbg : build : 0 localhost : x86_64 : gcc : 5.3.0 : so_rel : build : 0 localhost : x86_64 : gcc : 5.3.0 : ar_prof : build : 0 localhost : x86_64 : gcc : 5.3.0 : ar_cov : build : 0 localhost : x86_64 : gcc : 5.3.0 : ar_dbg : build : 0 localhost : x86_64 : gcc : 5.3.0 : so_prof : build : 0 localhost : x86_64 : gcc : 5.3.0 : so_vanilla : build : 0 localhost : x86_64 : gcc : 5.3.0 : so_tsan : build : 0 localhost : x86_64 : gcc : 5.3.0 : ar_rel : build : 0 localhost : x86_64 : gcc : 5.3.0 : ar_tsan : build : 0 localhost : x86_64 : gcc : 5.1.0 : ar_vanilla : build : 0 localhost : x86_64 : gcc : 5.1.0 : so_dbg : build : 0 localhost : x86_64 : gcc : 5.1.0 : so_rel : build : 0 localhost : x86_64 : gcc : 5.1.0 : ar_prof : build : 0 localhost : x86_64 : gcc : 5.1.0 : ar_cov : build : 0 localhost : x86_64 : gcc : 5.1.0 : ar_dbg : build : 0 localhost : x86_64 : gcc : 5.1.0 : so_prof : build : 0 localhost : x86_64 : gcc : 5.1.0 : so_vanilla : build : 0 localhost : x86_64 : gcc : 5.1.0 : so_tsan : build : 0 localhost : x86_64 : gcc : 5.1.0 : ar_rel : build : 0 localhost : x86_64 : gcc : 5.1.0 : ar_tsan : build : 0 localhost : x86_64 : gcc : 6.2.0 : ar_vanilla : build : 0 localhost : x86_64 : gcc : 6.2.0 : so_dbg : build : 0 localhost : x86_64 : gcc : 6.2.0 : so_rel : build : 0 localhost : x86_64 : gcc : 6.2.0 : ar_prof : build : 0 localhost : x86_64 : gcc : 6.2.0 : ar_cov : build : 0 localhost : x86_64 : gcc : 6.2.0 : ar_dbg : build : 0 localhost : x86_64 : gcc : 6.2.0 : so_prof : build : 0 localhost : x86_64 : gcc : 6.2.0 : so_vanilla : build : 0 localhost : x86_64 : gcc : 6.2.0 : so_tsan : build : 0 localhost : x86_64 : gcc : 6.2.0 : ar_rel : build : 0 localhost : x86_64 : gcc : 6.2.0 : ar_tsan : build : 0 localhost : x86_64 : gcc : 4.6.4 : ar_vanilla : build : 512 FAILED localhost : x86_64 : gcc : 4.6.4 : so_dbg : build : 512 FAILED localhost : x86_64 : gcc : 4.6.4 : so_rel : build : 512 FAILED localhost : x86_64 : gcc : 4.6.4 : ar_prof : build : 512 FAILED localhost : x86_64 : gcc : 4.6.4 : ar_cov : build : 512 FAILED localhost : x86_64 : gcc : 4.6.4 : ar_dbg : build : 512 FAILED localhost : x86_64 : gcc : 4.6.4 : so_prof : build : 512 FAILED localhost : x86_64 : gcc : 4.6.4 : so_vanilla : build : 512 FAILED localhost : x86_64 : gcc : 4.6.4 : ar_rel : build : 512 FAILED localhost : x86_64 : gcc : 7.1.0 : ar_vanilla : build : 0 localhost : x86_64 : gcc : 7.1.0 : so_dbg : build : 0 localhost : x86_64 : gcc : 7.1.0 : so_rel : build : 0 localhost : x86_64 : gcc : 7.1.0 : ar_prof : build : 0 localhost : x86_64 : gcc : 7.1.0 : ar_cov : build : 0 localhost : x86_64 : gcc : 7.1.0 : ar_dbg : build : 0 localhost : x86_64 : gcc : 7.1.0 : so_prof : build : 0 localhost : x86_64 : gcc : 7.1.0 : so_vanilla : build : 0 localhost : x86_64 : gcc : 7.1.0 : so_tsan : build : 0 localhost : x86_64 : gcc : 7.1.0 : ar_rel : build : 0 localhost : x86_64 : gcc : 7.1.0 : ar_tsan : build : 0 localhost : x86_64 : gcc : 6.3.0 : ar_vanilla : build : 0 localhost : x86_64 : gcc : 6.3.0 : so_dbg : build : 0 localhost : x86_64 : gcc : 6.3.0 : so_rel : build : 0 localhost : x86_64 : gcc : 6.3.0 : ar_prof : build : 0 localhost : x86_64 : gcc : 6.3.0 : ar_cov : build : 0 localhost : x86_64 : gcc : 6.3.0 : ar_dbg : build : 0 localhost : x86_64 : gcc : 6.3.0 : so_prof : build : 0 localhost : x86_64 : gcc : 6.3.0 : so_vanilla : build : 0 localhost : x86_64 : gcc : 6.3.0 : so_tsan : build : 0 localhost : x86_64 : gcc : 6.3.0 : ar_rel : build : 0 localhost : x86_64 : gcc : 6.3.0 : ar_tsan : build : 0 localhost : x86_64 : gcc : 4.8.0 : ar_vanilla : build : 0 localhost : x86_64 : gcc : 4.8.0 : so_dbg : build : 0 localhost : x86_64 : gcc : 4.8.0 : so_rel : build : 0 localhost : x86_64 : gcc : 4.8.0 : ar_prof : build : 0 localhost : x86_64 : gcc : 4.8.0 : ar_cov : build : 0 localhost : x86_64 : gcc : 4.8.0 : ar_dbg : build : 0 localhost : x86_64 : gcc : 4.8.0 : so_prof : build : 0 localhost : x86_64 : gcc : 4.8.0 : so_vanilla : build : 0 localhost : x86_64 : gcc : 4.8.0 : so_tsan : build : 0 localhost : x86_64 : gcc : 4.8.0 : ar_rel : build : 0 localhost : x86_64 : gcc : 4.8.0 : ar_tsan : build : 0 localhost : x86_64 : gcc : 6.1.0 : ar_vanilla : build : 0 localhost : x86_64 : gcc : 6.1.0 : so_dbg : build : 0 localhost : x86_64 : gcc : 6.1.0 : so_rel : build : 0 localhost : x86_64 : gcc : 6.1.0 : ar_prof : build : 0 localhost : x86_64 : gcc : 6.1.0 : ar_cov : build : 0 localhost : x86_64 : gcc : 6.1.0 : ar_dbg : build : 0 localhost : x86_64 : gcc : 6.1.0 : so_prof : build : 0 localhost : x86_64 : gcc : 6.1.0 : so_vanilla : build : 0 localhost : x86_64 : gcc : 6.1.0 : so_tsan : build : 0 localhost : x86_64 : gcc : 6.1.0 : ar_rel : build : 0 localhost : x86_64 : gcc : 6.1.0 : ar_tsan : build : 0 localhost : x86_64 : gcc : 4.9.4 : ar_vanilla : build : 0 localhost : x86_64 : gcc : 4.9.4 : so_dbg : build : 0 localhost : x86_64 : gcc : 4.9.4 : so_rel : build : 0 localhost : x86_64 : gcc : 4.9.4 : ar_prof : build : 0 localhost : x86_64 : gcc : 4.9.4 : ar_cov : build : 0 localhost : x86_64 : gcc : 4.9.4 : ar_dbg : build : 0 localhost : x86_64 : gcc : 4.9.4 : so_prof : build : 0 localhost : x86_64 : gcc : 4.9.4 : so_vanilla : build : 0 localhost : x86_64 : gcc : 4.9.4 : so_tsan : build : 0 localhost : x86_64 : gcc : 4.9.4 : ar_rel : build : 0 localhost : x86_64 : gcc : 4.9.4 : ar_tsan : build : 0 localhost : x86_64 : gcc : 4.8.5 : ar_vanilla : build : 0 localhost : x86_64 : gcc : 4.8.5 : so_dbg : build : 0 localhost : x86_64 : gcc : 4.8.5 : so_rel : build : 0 localhost : x86_64 : gcc : 4.8.5 : ar_prof : build : 0 localhost : x86_64 : gcc : 4.8.5 : ar_cov : build : 0 localhost : x86_64 : gcc : 4.8.5 : ar_dbg : build : 0 localhost : x86_64 : gcc : 4.8.5 : so_prof : build : 0 localhost : x86_64 : gcc : 4.8.5 : so_vanilla : build : 0 localhost : x86_64 : gcc : 4.8.5 : so_tsan : build : 0 localhost : x86_64 : gcc : 4.8.5 : ar_rel : build : 0 localhost : x86_64 : gcc : 4.8.5 : ar_tsan : build : 0 localhost : x86_64 : gcc : 5.4.0 : ar_vanilla : build : 0 localhost : x86_64 : gcc : 5.4.0 : so_dbg : build : 0 localhost : x86_64 : gcc : 5.4.0 : so_rel : build : 0 localhost : x86_64 : gcc : 5.4.0 : ar_prof : build : 0 localhost : x86_64 : gcc : 5.4.0 : ar_cov : build : 0 localhost : x86_64 : gcc : 5.4.0 : ar_dbg : build : 0 localhost : x86_64 : gcc : 5.4.0 : so_prof : build : 0 localhost : x86_64 : gcc : 5.4.0 : so_vanilla : build : 0 localhost : x86_64 : gcc : 5.4.0 : so_tsan : build : 0 localhost : x86_64 : gcc : 5.4.0 : ar_rel : build : 0 localhost : x86_64 : gcc : 5.4.0 : ar_tsan : build : 0 localhost : x86_64 : gcc : 4.5.4 : ar_vanilla : build : 512 FAILED localhost : x86_64 : gcc : 4.5.4 : so_dbg : build : 512 FAILED localhost : x86_64 : gcc : 4.5.4 : so_rel : build : 512 FAILED localhost : x86_64 : gcc : 4.5.4 : ar_prof : build : 512 FAILED localhost : x86_64 : gcc : 4.5.4 : ar_cov : build : 512 FAILED localhost : x86_64 : gcc : 4.5.4 : ar_dbg : build : 512 FAILED localhost : x86_64 : gcc : 4.5.4 : so_prof : build : 512 FAILED localhost : x86_64 : gcc : 4.5.4 : so_vanilla : build : 512 FAILED localhost : x86_64 : gcc : 4.5.4 : ar_rel : build : 512 FAILED raspberrypi : arm : gcc : 5.1.0 : ar_vanilla : build : 512 FAILED raspberrypi : arm : gcc : 5.1.0 : so_dbg : build : 512 FAILED raspberrypi : arm : gcc : 5.1.0 : so_rel : build : 512 FAILED raspberrypi : arm : gcc : 5.1.0 : ar_prof : build : 512 FAILED raspberrypi : arm : gcc : 5.1.0 : ar_cov : build : 512 FAILED raspberrypi : arm : gcc : 5.1.0 : ar_dbg : build : 512 FAILED raspberrypi : arm : gcc : 5.1.0 : so_prof : build : 512 FAILED raspberrypi : arm : gcc : 5.1.0 : so_vanilla : build : 512 FAILED raspberrypi : arm : gcc : 5.1.0 : ar_rel : build : 512 FAILED raspberrypi : arm : gcc : 4.8.5 : ar_vanilla : build : 512 FAILED raspberrypi : arm : gcc : 4.8.5 : so_dbg : build : 512 FAILED raspberrypi : arm : gcc : 4.8.5 : so_rel : build : 512 FAILED raspberrypi : arm : gcc : 4.8.5 : ar_prof : build : 512 FAILED raspberrypi : arm : gcc : 4.8.5 : ar_cov : build : 512 FAILED raspberrypi : arm : gcc : 4.8.5 : ar_dbg : build : 512 FAILED raspberrypi : arm : gcc : 4.8.5 : so_prof : build : 512 FAILED raspberrypi : arm : gcc : 4.8.5 : so_vanilla : build : 512 FAILED raspberrypi : arm : gcc : 4.8.5 : ar_rel : build : 512 FAILED raspberrypi : arm : gcc : 5.4.0 : ar_vanilla : build : 0 raspberrypi : arm : gcc : 5.4.0 : so_dbg : build : 0 raspberrypi : arm : gcc : 5.4.0 : so_rel : build : 0 raspberrypi : arm : gcc : 5.4.0 : ar_prof : build : 0 raspberrypi : arm : gcc : 5.4.0 : ar_cov : build : 0 raspberrypi : arm : gcc : 5.4.0 : ar_dbg : build : 0 raspberrypi : arm : gcc : 5.4.0 : so_prof : build : 0 raspberrypi : arm : gcc : 5.4.0 : so_vanilla : build : 0 raspberrypi : arm : gcc : 5.4.0 : ar_rel : build : 0 raspberrypi : arm : gcc : 4.9.4 : ar_vanilla : build : 512 FAILED raspberrypi : arm : gcc : 4.9.4 : so_dbg : build : 512 FAILED raspberrypi : arm : gcc : 4.9.4 : so_rel : build : 512 FAILED raspberrypi : arm : gcc : 4.9.4 : ar_prof : build : 512 FAILED raspberrypi : arm : gcc : 4.9.4 : ar_cov : build : 512 FAILED raspberrypi : arm : gcc : 4.9.4 : ar_dbg : build : 512 FAILED raspberrypi : arm : gcc : 4.9.4 : so_prof : build : 512 FAILED raspberrypi : arm : gcc : 4.9.4 : so_vanilla : build : 512 FAILED raspberrypi : arm : gcc : 4.9.4 : ar_rel : build : 512 FAILED raspberrypi : arm : gcc : 6.2.0 : ar_vanilla : build : 512 FAILED raspberrypi : arm : gcc : 6.2.0 : so_dbg : build : 512 FAILED raspberrypi : arm : gcc : 6.2.0 : so_rel : build : 512 FAILED raspberrypi : arm : gcc : 6.2.0 : ar_prof : build : 512 FAILED raspberrypi : arm : gcc : 6.2.0 : ar_cov : build : 512 FAILED raspberrypi : arm : gcc : 6.2.0 : ar_dbg : build : 512 FAILED raspberrypi : arm : gcc : 6.2.0 : so_prof : build : 512 FAILED raspberrypi : arm : gcc : 6.2.0 : so_vanilla : build : 512 FAILED raspberrypi : arm : gcc : 6.2.0 : ar_rel : build : 512 FAILED raspberrypi : arm : gcc : 7.1.0 : ar_vanilla : build : 0 raspberrypi : arm : gcc : 7.1.0 : so_dbg : build : 0 raspberrypi : arm : gcc : 7.1.0 : so_rel : build : 0 raspberrypi : arm : gcc : 7.1.0 : ar_prof : build : 0 raspberrypi : arm : gcc : 7.1.0 : ar_cov : build : 0 raspberrypi : arm : gcc : 7.1.0 : ar_dbg : build : 0 raspberrypi : arm : gcc : 7.1.0 : so_prof : build : 0 raspberrypi : arm : gcc : 7.1.0 : so_vanilla : build : 0 raspberrypi : arm : gcc : 7.1.0 : ar_rel : build : 0 raspberrypi : arm : gcc : 4.8.0 : ar_vanilla : build : 512 FAILED raspberrypi : arm : gcc : 4.8.0 : so_dbg : build : 512 FAILED raspberrypi : arm : gcc : 4.8.0 : so_rel : build : 512 FAILED raspberrypi : arm : gcc : 4.8.0 : ar_prof : build : 512 FAILED raspberrypi : arm : gcc : 4.8.0 : ar_cov : build : 512 FAILED raspberrypi : arm : gcc : 4.8.0 : ar_dbg : build : 512 FAILED raspberrypi : arm : gcc : 4.8.0 : so_prof : build : 512 FAILED raspberrypi : arm : gcc : 4.8.0 : so_vanilla : build : 512 FAILED raspberrypi : arm : gcc : 4.8.0 : ar_rel : build : 512 FAILED pine64 : aarch64 : gcc : 5.1.0 : ar_vanilla : build : 0 pine64 : aarch64 : gcc : 5.1.0 : so_dbg : build : 0 pine64 : aarch64 : gcc : 5.1.0 : so_rel : build : 0 pine64 : aarch64 : gcc : 5.1.0 : ar_cov : build : 0 pine64 : aarch64 : gcc : 5.1.0 : ar_dbg : build : 0 pine64 : aarch64 : gcc : 5.1.0 : so_prof : build : 0 pine64 : aarch64 : gcc : 5.1.0 : so_vanilla : build : 0 pine64 : aarch64 : gcc : 5.1.0 : ar_prof : build : 0 pine64 : aarch64 : gcc : 5.1.0 : ar_rel : build : 0 pine64 : aarch64 : gcc : 4.8.5 : ar_vanilla : build : 0 pine64 : aarch64 : gcc : 4.8.5 : so_dbg : build : 0 pine64 : aarch64 : gcc : 4.8.5 : so_rel : build : 0 pine64 : aarch64 : gcc : 4.8.5 : ar_cov : build : 0 pine64 : aarch64 : gcc : 4.8.5 : ar_dbg : build : 0 pine64 : aarch64 : gcc : 4.8.5 : so_vanilla : build : 0 pine64 : aarch64 : gcc : 4.8.5 : ar_rel : build : 0 pine64 : aarch64 : gcc : 5.4.0 : ar_vanilla : build : 0 pine64 : aarch64 : gcc : 5.4.0 : so_dbg : build : 0 pine64 : aarch64 : gcc : 5.4.0 : so_rel : build : 0 pine64 : aarch64 : gcc : 5.4.0 : ar_cov : build : 0 pine64 : aarch64 : gcc : 5.4.0 : ar_dbg : build : 0 pine64 : aarch64 : gcc : 5.4.0 : so_prof : build : 0 pine64 : aarch64 : gcc : 5.4.0 : so_vanilla : build : 0 pine64 : aarch64 : gcc : 5.4.0 : ar_prof : build : 0 pine64 : aarch64 : gcc : 5.4.0 : ar_rel : build : 0 pine64 : aarch64 : gcc : 4.9.1 : ar_vanilla : build : 0 pine64 : aarch64 : gcc : 4.9.1 : so_dbg : build : 0 pine64 : aarch64 : gcc : 4.9.1 : so_rel : build : 0 pine64 : aarch64 : gcc : 4.9.1 : ar_cov : build : 0 pine64 : aarch64 : gcc : 4.9.1 : ar_dbg : build : 0 pine64 : aarch64 : gcc : 4.9.1 : so_prof : build : 0 pine64 : aarch64 : gcc : 4.9.1 : so_vanilla : build : 0 pine64 : aarch64 : gcc : 4.9.1 : ar_prof : build : 0 pine64 : aarch64 : gcc : 4.9.1 : ar_rel : build : 0 pine64 : aarch64 : gcc : 4.9.0 : ar_vanilla : build : 0 pine64 : aarch64 : gcc : 4.9.0 : so_dbg : build : 0 pine64 : aarch64 : gcc : 4.9.0 : so_rel : build : 0 pine64 : aarch64 : gcc : 4.9.0 : ar_cov : build : 0 pine64 : aarch64 : gcc : 4.9.0 : ar_dbg : build : 0 pine64 : aarch64 : gcc : 4.9.0 : so_prof : build : 0 pine64 : aarch64 : gcc : 4.9.0 : so_vanilla : build : 0 pine64 : aarch64 : gcc : 4.9.0 : ar_prof : build : 0 pine64 : aarch64 : gcc : 4.9.0 : ar_rel : build : 0 pine64 : aarch64 : gcc : 7.1.0 : ar_vanilla : build : 0 pine64 : aarch64 : gcc : 7.1.0 : so_dbg : build : 0 pine64 : aarch64 : gcc : 7.1.0 : so_rel : build : 0 pine64 : aarch64 : gcc : 7.1.0 : ar_cov : build : 0 pine64 : aarch64 : gcc : 7.1.0 : ar_dbg : build : 0 pine64 : aarch64 : gcc : 7.1.0 : so_prof : build : 0 pine64 : aarch64 : gcc : 7.1.0 : ar_prof : build : 0 pine64 : aarch64 : gcc : 7.1.0 : so_vanilla : build : 0 pine64 : aarch64 : gcc : 7.1.0 : so_tsan : build : 0 pine64 : aarch64 : gcc : 7.1.0 : ar_rel : build : 0 pine64 : aarch64 : gcc : 7.1.0 : ar_tsan : build : 0 pine64 : aarch64 : gcc : 6.1.0 : ar_vanilla : build : 0 pine64 : aarch64 : gcc : 6.1.0 : so_dbg : build : 0 pine64 : aarch64 : gcc : 6.1.0 : so_rel : build : 0 pine64 : aarch64 : gcc : 6.1.0 : ar_cov : build : 0 pine64 : aarch64 : gcc : 6.1.0 : ar_dbg : build : 0 pine64 : aarch64 : gcc : 6.1.0 : so_prof : build : 0 pine64 : aarch64 : gcc : 6.1.0 : ar_prof : build : 0 pine64 : aarch64 : gcc : 6.1.0 : so_vanilla : build : 0 pine64 : aarch64 : gcc : 6.1.0 : so_tsan : build : 0 pine64 : aarch64 : gcc : 6.1.0 : ar_rel : build : 0 pine64 : aarch64 : gcc : 6.1.0 : ar_tsan : build : 0 pine64 : aarch64 : gcc : 6.3.0 : ar_vanilla : build : 0 pine64 : aarch64 : gcc : 6.3.0 : so_dbg : build : 0 pine64 : aarch64 : gcc : 6.3.0 : so_rel : build : 0 pine64 : aarch64 : gcc : 6.3.0 : ar_cov : build : 0 pine64 : aarch64 : gcc : 6.3.0 : ar_dbg : build : 0 pine64 : aarch64 : gcc : 6.3.0 : so_prof : build : 0 pine64 : aarch64 : gcc : 6.3.0 : ar_prof : build : 0 pine64 : aarch64 : gcc : 6.3.0 : so_vanilla : build : 0 pine64 : aarch64 : gcc : 6.3.0 : so_tsan : build : 0 pine64 : aarch64 : gcc : 6.3.0 : ar_rel : build : 0 pine64 : aarch64 : gcc : 6.3.0 : ar_tsan : build : 0 pine64 : aarch64 : gcc : 4.9.4 : ar_vanilla : build : 0 pine64 : aarch64 : gcc : 4.9.4 : so_dbg : build : 0 pine64 : aarch64 : gcc : 4.9.4 : so_rel : build : 0 pine64 : aarch64 : gcc : 4.9.4 : ar_cov : build : 0 pine64 : aarch64 : gcc : 4.9.4 : ar_dbg : build : 0 pine64 : aarch64 : gcc : 4.9.4 : so_prof : build : 0 pine64 : aarch64 : gcc : 4.9.4 : so_vanilla : build : 0 pine64 : aarch64 : gcc : 4.9.4 : ar_prof : build : 0 pine64 : aarch64 : gcc : 4.9.4 : ar_rel : build : 0 pine64 : aarch64 : gcc : 4.8.0 : ar_vanilla : build : 0 pine64 : aarch64 : gcc : 4.8.0 : so_dbg : build : 0 pine64 : aarch64 : gcc : 4.8.0 : so_rel : build : 0 pine64 : aarch64 : gcc : 4.8.0 : ar_cov : build : 0 pine64 : aarch64 : gcc : 4.8.0 : ar_dbg : build : 0 pine64 : aarch64 : gcc : 4.8.0 : so_vanilla : build : 0 pine64 : aarch64 : gcc : 4.8.0 : ar_rel : build : 0 minnow : i686 : gcc : 5.1.0 : ar_vanilla : build : 0 minnow : i686 : gcc : 5.1.0 : so_dbg : build : 0 minnow : i686 : gcc : 5.1.0 : so_rel : build : 0 minnow : i686 : gcc : 5.1.0 : ar_prof : build : 0 minnow : i686 : gcc : 5.1.0 : ar_cov : build : 0 minnow : i686 : gcc : 5.1.0 : ar_dbg : build : 0 minnow : i686 : gcc : 5.1.0 : so_prof : build : 0 minnow : i686 : gcc : 5.1.0 : so_vanilla : build : 0 minnow : i686 : gcc : 5.1.0 : ar_rel : build : 0 minnow : i686 : gcc : 4.8.5 : ar_vanilla : build : 0 minnow : i686 : gcc : 4.8.5 : so_dbg : build : 0 minnow : i686 : gcc : 4.8.5 : so_rel : build : 0 minnow : i686 : gcc : 4.8.5 : ar_prof : build : 0 minnow : i686 : gcc : 4.8.5 : ar_cov : build : 0 minnow : i686 : gcc : 4.8.5 : ar_dbg : build : 0 minnow : i686 : gcc : 4.8.5 : so_prof : build : 0 minnow : i686 : gcc : 4.8.5 : so_vanilla : build : 0 minnow : i686 : gcc : 4.8.5 : ar_rel : build : 0 minnow : i686 : gcc : 5.4.0 : ar_vanilla : build : 0 minnow : i686 : gcc : 5.4.0 : so_dbg : build : 0 minnow : i686 : gcc : 5.4.0 : so_rel : build : 0 minnow : i686 : gcc : 5.4.0 : ar_prof : build : 0 minnow : i686 : gcc : 5.4.0 : ar_cov : build : 0 minnow : i686 : gcc : 5.4.0 : ar_dbg : build : 0 minnow : i686 : gcc : 5.4.0 : so_prof : build : 0 minnow : i686 : gcc : 5.4.0 : so_vanilla : build : 0 minnow : i686 : gcc : 5.4.0 : ar_rel : build : 0 minnow : i686 : gcc : 4.6.4 : ar_vanilla : build : 512 FAILED minnow : i686 : gcc : 4.6.4 : so_dbg : build : 512 FAILED minnow : i686 : gcc : 4.6.4 : so_rel : build : 512 FAILED minnow : i686 : gcc : 4.6.4 : ar_prof : build : 512 FAILED minnow : i686 : gcc : 4.6.4 : ar_cov : build : 512 FAILED minnow : i686 : gcc : 4.6.4 : ar_dbg : build : 512 FAILED minnow : i686 : gcc : 4.6.4 : so_prof : build : 512 FAILED minnow : i686 : gcc : 4.6.4 : so_vanilla : build : 512 FAILED minnow : i686 : gcc : 4.6.4 : ar_rel : build : 512 FAILED minnow : i686 : gcc : 4.5.4 : ar_vanilla : build : 512 FAILED minnow : i686 : gcc : 4.5.4 : so_dbg : build : 512 FAILED minnow : i686 : gcc : 4.5.4 : so_rel : build : 512 FAILED minnow : i686 : gcc : 4.5.4 : ar_prof : build : 512 FAILED minnow : i686 : gcc : 4.5.4 : ar_cov : build : 512 FAILED minnow : i686 : gcc : 4.5.4 : ar_dbg : build : 512 FAILED minnow : i686 : gcc : 4.5.4 : so_prof : build : 512 FAILED minnow : i686 : gcc : 4.5.4 : so_vanilla : build : 512 FAILED minnow : i686 : gcc : 4.5.4 : ar_rel : build : 512 FAILED ci20 : mipsel : gcc : 5.1.0 : ar_vanilla : build : 512 FAILED ci20 : mipsel : gcc : 5.1.0 : so_dbg : build : 512 FAILED ci20 : mipsel : gcc : 5.1.0 : so_rel : build : 512 FAILED ci20 : mipsel : gcc : 5.1.0 : ar_prof : build : 512 FAILED ci20 : mipsel : gcc : 5.1.0 : ar_cov : build : 512 FAILED ci20 : mipsel : gcc : 5.1.0 : ar_dbg : build : 512 FAILED ci20 : mipsel : gcc : 5.1.0 : so_prof : build : 512 FAILED ci20 : mipsel : gcc : 5.1.0 : so_vanilla : build : 512 FAILED ci20 : mipsel : gcc : 5.1.0 : ar_rel : build : 512 FAILED ci20 : mipsel : gcc : 4.8.5 : ar_vanilla : build : 512 FAILED ci20 : mipsel : gcc : 4.8.5 : so_dbg : build : 512 FAILED ci20 : mipsel : gcc : 4.8.5 : so_rel : build : 512 FAILED ci20 : mipsel : gcc : 4.8.5 : ar_prof : build : 512 FAILED ci20 : mipsel : gcc : 4.8.5 : ar_cov : build : 512 FAILED ci20 : mipsel : gcc : 4.8.5 : ar_dbg : build : 512 FAILED ci20 : mipsel : gcc : 4.8.5 : so_prof : build : 512 FAILED ci20 : mipsel : gcc : 4.8.5 : so_vanilla : build : 512 FAILED ci20 : mipsel : gcc : 4.8.5 : ar_rel : build : 512 FAILED ci20 : mipsel : gcc : 4.6.4 : ar_vanilla : build : 0 ci20 : mipsel : gcc : 4.6.4 : so_dbg : build : 0 ci20 : mipsel : gcc : 4.6.4 : so_rel : build : 0 ci20 : mipsel : gcc : 4.6.4 : ar_prof : build : 0 ci20 : mipsel : gcc : 4.6.4 : ar_cov : build : 0 ci20 : mipsel : gcc : 4.6.4 : ar_dbg : build : 0 ci20 : mipsel : gcc : 4.6.4 : so_prof : build : 0 ci20 : mipsel : gcc : 4.6.4 : so_vanilla : build : 0 ci20 : mipsel : gcc : 4.6.4 : ar_rel : build : 0 ci20 : mipsel : gcc : 4.8.0 : ar_vanilla : build : 512 FAILED ci20 : mipsel : gcc : 4.8.0 : so_dbg : build : 512 FAILED ci20 : mipsel : gcc : 4.8.0 : so_rel : build : 512 FAILED ci20 : mipsel : gcc : 4.8.0 : ar_prof : build : 512 FAILED ci20 : mipsel : gcc : 4.8.0 : ar_cov : build : 512 FAILED ci20 : mipsel : gcc : 4.8.0 : ar_dbg : build : 512 FAILED ci20 : mipsel : gcc : 4.8.0 : so_prof : build : 512 FAILED ci20 : mipsel : gcc : 4.8.0 : so_vanilla : build : 512 FAILED ci20 : mipsel : gcc : 4.8.0 : ar_rel : build : 512 FAILED ci20 : mipsel : gcc : 4.5.4 : ar_vanilla : build : 0 ci20 : mipsel : gcc : 4.5.4 : so_dbg : build : 0 ci20 : mipsel : gcc : 4.5.4 : so_rel : build : 0 ci20 : mipsel : gcc : 4.5.4 : ar_prof : build : 0 ci20 : mipsel : gcc : 4.5.4 : ar_cov : build : 0 ci20 : mipsel : gcc : 4.5.4 : ar_dbg : build : 0 ci20 : mipsel : gcc : 4.5.4 : so_prof : build : 0 ci20 : mipsel : gcc : 4.5.4 : so_vanilla : build : 0 ci20 : mipsel : gcc : 4.5.4 : ar_rel : build : 0 localhost : 154.152909 minutes raspberrypi : 136.283255 minutes pine64 : 300.401916 minutes minnow : 201.507361 minutes ci20 : 423.456168 minutes total time = 423.466951 minutes …done

2017-07-09

freelist scaling update #2

The single-threaded freelist with elimination layer is faster than spinlocks because it gets to pop/push with a single exchange, where-as spinlocks have to do two single-word CAS.

The best solution so far (for the current implementation) seems to be incrementing the push/pop EA array index on every push/pop, but if a pop is successful then setting the push EA array index to be that of the success pop EA array index to that value, and when a pop is successful setting the push EA array index to the pop value (i.e. we know we’ve just pop/pushed successfully on a given EA array index, so we can know - for a bit - that the next push/pop will be okay on that index).

freelist scaling update

So, the freelist scaling new is not, alas, as good as it seemed. I rather - but not fully - in my delight rather jumped the gun.

The work in question is that of the elimination layer. A freelist pop cancels out a freelist push, so if two threads attempting those operations can somehow “meet up”, and exchange their operations, then the freelist head point (the point of memory contention, which slows everything to a crawl as processor counts rise) is relieved of those two operations.

I’ve implemented this as an array of cache lines. Rule of thumb is one cache line per thread using the freelist, but I’ve no proof for this being right.

Each cache line stores an array of freelist element pointers. They start NULL.

When a thread pushes, it round-robin picks a cache line in the elimination array, and then iterates through it. If it finds a NULL, it attempts to exchange its freelist element pointer (for the element it wants to push) with the NULL. If it succeeds, well, then it just handed over its element and is free to go.

If it fails, and keeps failing (or the pointer are already non-NULL, i.e. in use), so that it gets to the end of the cache line without handing over its element, then it falls back to pushing onto the freelist proper.

Popping is much the same. Round robin to the cache line, iterate, find a non-NULL then try to exchange it with NULL.

Now, what happened that got me so excited was basically a fluke - I had four threads running, each in a tight pop/push loop, and each one had ended up (I wasn’t using round-robin yet, but a fixed cache line per thread) popping and pushing from its own, separate cache line. Basically, it was as if each thread had its own freelist. Result - great performance - but it’s totally unrealistic.

I then dug into it, collected cache line hit/miss stats and so on, and once I’d sorted everything out, and had the threads doing round robin, with separate round-robin counters for push and pop, then we end up being on four cores about two, two and a half times faster than without the elimination layer - but it’s not scaling - and in fact we’re only this fast because the benchmark is particularly favoured.

The benchmark is doing a pop and then a push, in a loop. Pop and push have independent counters, both start at zero. Counters are per thread. The elimination layer begins half-full. So we pop - and we get an element. We’ve made a space. We then push. There’s always a space there, because we just made a space!

In fact, if we use round-robin but add a hash mixing function to it, we then find about 10% misses, and performance is still better but only by about 25%.

There’s still a few things I do not understand (or are bugs in my code somewhere - the benchmark app prolly). On a single core, with the elimintion layer is as fast as a spin lock, and without is about 20% slower.

On two cores on the same physical core, without hash mixing function, there’s a haromic such that each thread seems to be getting an elimination layer cache line to itself, although this might just be where one physical core knows what its logical cores are up to and so can optimize the atomic operations. With has mixing, performance drops to the same as one thread on two separate physical cores.

This is making me think somewhat of others ways to achieve the same end. I read about “scalable stack” recently, which is actually a list (can’t remember the details offhand - might be deferd updates to the list, kindafing).

In fact you could imagine a btree as a freelist, where popping gets a random leaf node, and pushing pushes to a random leaf node.

A hash mixer on the address of the element being pushed would be enough to take care of balance. The problem would be detaching leaf nodes - same problem as in lists - no detaching a node which has just had an element attached to it. Harris’ delete bit would deal with this, and no need for garbage collection because it’s a freelist.

2017-07-04

Freelist now scaling

Just a bit of experimentation - and lo and behold, it is the random number generation which is killing performance.

Take it out and the freelist is scaling just like the btree.

So - more investigation required, have to see what’s up with the RNG, if I messed it up or it’s just slow.

I actually read something on this matter quite a while ago - about you can’t use modulus even in single threads because it’s so slow it kills you. You have to use shift-left/shift-right and powers of 2 only.

I think I’ve run into the same problem.

2017-06-26

Untitled

Just uncovered a stonking design flaw in the freelist elimination layer.

The idea is to have one cache line for every logical core.

What I was actually doing was having one atomic_isolation per logial core.

On CAS platforms, this is nominally one cache line (except of course Intel are now bringing over two cache lines at once, so even there it’s wrong) but on ARM where the max ERG is 2048, instead of having one cacheline I had a huge 2kb.

So what I actually need is one cache line, with atomic_isolation separation.

2017-06-25

forum and mailing list issues

So, I’ve just tried logging into both the forum and the mailing list, as admin, and neither work.

I have no clue why, and they were working last time I used them, and everything else seems to be fine, and there is as far as I can tell no logging.

I’ll fix it soon, but probably I will ditch both of the them (Dadamail was likely to go anyway). That means going back to EsoTalk for the forum, and maybe a non-GUI install of mailman for the mailing list.

Ugh. Jesus. Forums and mailing lists and open source software. Ugh.

2017-06-22

offsets rather than absolute pointers

So, bugger me, been off work for a week and a half and only now finally had time to think a bit about something which has been on my mind for agggges - using offsets rather than absolute pointers.

The idea is to make it possible to share data structure instances across processes without having to have the same virtual address base, and between the kernel and user-mode.

So, having thought it over, there’s an obvious limitation; we can only use entities (structures, for state and elements) which are in the same single contiguous memory block.

Consider; say you allocate one block of memory, for a freelist state and a hundred freelist elements.

You share this between two processes. They each now have a different virtual address (first is at say 10,000, the second and 10 million), but the whole block is contiguous from that address.

The freelist internally uses offsets; so both processes can push and pop from the freelist and everything is fine.

Now let’s say the freelist elements each contain a btree element.

We then share the btree state between the processes.

Now we pop a freelist element and we want to insert it into the btree.

The problem is the btree is also using offsets; but the offset from the btree state to the freelist element is different in each process, because the freelists have different virtual memory addresses. (Also, ptrdiff_t is only allowed in the spec to show the difference between pointers in the same block of memory - in part most likely because of situations like this!)

So we simply cannot use anything other than those things which are in the same conitiguous block of memory.

So if we had one block of memory which contained the btree state, the freelist state and the freelist elements, then we’d be fine - so it is still useful.

But one thing we do lose is the ability when a freelist is empty to do a malloc and throw some more elements on there - because they will be in a different, non-conitiguous block.

One thing to also consider is the void pointer of user data. What this is set to is entirely up to the user, but the user faces the same problems as the data structure, so they will also need to use values which make sense across processes and/or kernel/user-mode.

So I’m working now on an experimental freelist with offsets.

Pretty cool if it works - you can take an instance of a data stucture, and use it concurrently over multiple kernel threads at the same time as you use it with multiple threads in multiple different processes.

So much to kernel/user-mode isolation… =-)

Little discoveries

GCC only supports profiling on aarch64 from version 4.9.0 onwards :-)

2017-06-20

GCC 7.1.0 build time

It takes 37 hours to build GCC 7.1.0 on a Raspberry Pi :-)

2017-06-17

site status update

So!

Friday before last I asked for the VM image on the server to be replaced by a fresh Debian 8 Jessie image. It was on Wheezy and the distro-update hadn’t worked properly.

This was done, and the new root password emailed to me (I know - I’ve told them about this already, a year ago; but they’re still apart from that the best Swiss provider wholly within Switzerland).

Problem was that the email address they sent that to…

…was on the server which was wiped by the VM image replacement.

So I got the password on Monday.

I then had my final three days in my (now previous) job, which were busy - and I continue to be busy with that, in fact.

My most pressing concern was to get the mediawiki back up. This took a day and a half, because the instructions in the Apache 2.4 docs for using FastCGI with php5-fpm simply do not work and it took up a lot of time finding that out. I found a different way to configure in the end.

The nice thing now is that since I have in the end moved back to Apache, and slapped the seemingly-crazy mpm_event config into shape (I do not understand all this “we can spin up more servers” stuff - if your machine lacks the resources for high load, it won’t be able to do this anyway), and now I can install Bugzilla and Mailman, neither of which could be done with nginx (no CGI support - in fact Apache has the obvious solution to handle the problem, have a tiny extra server which you issue CGI requests to and it spawns itself).

So I’m now installing Bugzill and Mailman.

2017-06-09

Intel cache line lengths

Just found this…

We would have to extend our notion of “CPU architecture” for that to make sense. For example, Pentium Pro / II CPUs had cache line size of 32 bytes, Intel Netburst CPUs (all Pentium-4 and Xeons of the time) have / had 128 bytes, while Pentium-III, Pentium-M and later Core CPUs have 64 bytes. They are all I686_CPU in our view.

Buuuuuuuuuuuuuuuuuugger.

I assumed 32 bit Intel was 32 byte cache line, 64 bit Intel was 64 byte cache line.

See? getting that Minnowboard has already uncovered something critical.

2017-06-08

Update

I’m not doing run-time cache-line alignment after all.

As I started to get back to it, I remembered why I hadn’t done it in the first place - the instruction to get ERG length on ARM is priviledged. You can’t run it from user-mode.

facepalm

So I have my code which can try empirically to determine the ERG length, but I have no code to figure out cache-line length. Maybe I could try to think of some, but… all this empirical stuff sucks.

In other news, the x86 dev board I ordered arrived and I have successfully installed Debian and configured the board. It is now building GCC 4.8.5!

Oddly, the cache line length is marked as 64 bytes, rather than 32. My laptop is marked as 64 bytes, which is what I’d expect for an x86_64.

In other other news, this web-server server is likely to have a fresh OS install which means I’ll need to rebuild everything. That may happen over this weekend, and by the end of it I damn well intend to have Bugzilla again at last.

2017-06-06

run-time ERG/cache-line alignment

I’m going to go back to run-time alignment.

I think when I first did this ages ago I failed to realise that the ERG size would always be a positive integer mutiple of the cache-line size, and so I thought there had to be some math done to figure out the correct atomic isolation size.

Run-time alignment is necessary because of ARM.

Where the ERG size is 8 to 2048 bytes, and the code fails completely if the ERG is set too small, you basically have a problem and/or need to be pessimistic, and it’s painful to set a large ERG.

I also need people to be aware of the whole ERG issue, and I really don’t want that. I want them to be able to pick up the data structures like they’re normal and just use them.

Run-time isn’t needed on Intel, which has fixed cache line sizes - although, ha - I’m already treating them as a pessimistic case, since Intel these days usually transfers two cache lines at a time, something you can turn off in the BIOS on some machines.

Update

Converted all the lfds atomic abstraction macros to my current standard, where you always pass in the thing itself, never a pointer.

Corrected the ERG determination code - need to check it closely now though.

That leaves me with one problem before I can use the build system in anger and get it to build every variant on every GCC on every platform; and that’s setting the ERG size in the header file before building…

…which is a bit problematic seeing as you need to build to run the ERG determination code =-)

Back in the day, I did a lot of work to arrange run-time rather than compile-time support for different atomic isolation lengths. You need to use though the larger of ERG and cache line size and I recall backing all that work out because you couldn’t handle that problem in the preprocessor - something to do with needing to find the greatest common divisor, I have no idea now…

I think you can actually issue an instruction to get the ERG length, though. You don’t need to empirically determine it, as I currently do.

It would be very good to deal with this at run time, because people writing for ARM are probably writing for phones and they can’t know what core their code will be running on.

It also saves users having to even knnw about the issue.

2017-06-03

Update

So, it’s taken this whole day, but I have just now successfully written the GCC In-line asm for DWCAS on aarch64. Woot!

This means I am not dependent on libatomic.

As an aside, I also discovered I’d messed up the empirical ERG determination in the test binary - the concept works, but I messed up the implementation by making the results look wrong.

I finish my current gig in two weeks, so then I’ll have a bunch more time for liblfds.

2017-05-29

Just bought an x86 (32-bit) dev board

Only one core, but it’s hyperthreaded.

IT’s from about 2014 - the original Minnowboard.

I found a new one on ebay.

The later Minnowboards (they’re up to the third version now) are 64-bit. In fact, the only other 32-bit board I could find was AMD’s Geode, and it’s single-core, single-thread.

2017-05-28

Update

So, I’ve been slowly making progress with the build system - actually putting it through its paces.

I’ve learned so much, and revealed a number of problems; it’s been an absolute God-send. It shows once again that with software and computers nothing works until you actually do it and make it work.

The big thing has been GCC 7.1.0 and the changes to how it supports double-word CAS on 64-bit targets (which is to say, aarch64 and x86_64, the only targets which offer this functionality).

Those changes seem not viable for my use, and it’s led me to implement in the abstraction layer in-line assembly for double-word CAS on x86_64 and aarch64.

Thank God I had a build for this compiler and found out about all this before I made a release and users found out about it by it not working.

So now I get to build every build variant with every compiler version (which I can build) on every platform. I can at least see my software passes tests, runs benchmarks, etc, on my own systems. Of course, they may (well!) indeed then fail on the vast range of other systems out there - but if they failed on mine even before that, then they DEFINITELY wouldn’t be working on any of the systems out there!

I can’t wait to see if there are significant performance differences between GCC versions.

2017-05-26

GCC 7.1.0 removes -mcx16

Thank God I built the build system and thank God I spent an entire quarter figuring out how to build GCC.

Turns out GCC 7.1.0 removed -mcx16, so it no longer generates double word CAS on x86_64.

It still does on arm, aarch64 and x86 - just not x86_64.

I filed a bug.

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80878

So this means I need to use an abstraction layer with inline assembly for DWCAS on x86_64 for GCC 7.1.0 and also for GCCs earlier than when this switch was introduced (it’s not present in 4.2.4, but the 4.3.x and 4.4.x versions of GCC do not build on x86_64, so I can’t tell exactly when it turned up.

In fact, the build system right now is duplicated because os x86_64 and this switch. All the makefiles are duplicates, one with and one without. What I will do, and also allows for consistency across builds, is drop -mcx16 and always use the inline assembly.

Honestly, it’s a bit of a risk. Inline assembly in GCC is like sticking your head in a black bag and hitting the keys. It’s impossble to know if you’ve done it right, unless you’re already an assembly programmer. Also, I suspect it will optimize less well than using the intrinsics.

However, with 7.1.0 I have no choice anyway.

2017-05-20

huh

Remember I was having network connectivity problems with the PINE64? five to ten second drop outs?

Someone has just described pretty much the experience I had, but he ascribes it the Cisco switch (which I have).

I have in fact already begun to suspect the switch. Often when I issue a build on the PINE, during the file copy phase (getting GCC onto the local store), connectivity to the PINE is lost, and after that I can’t route to the PINE until I reboot the Cisco switch.

Of course, that doesn’t by any means prove it’s the switch - it could be the wireless router, or my own Linux install, or the OS on the PINE.

But given the bug reports I’m googling now, this has definitely gone up the list and I’m now looking for a new switch.

First round build results

“-march=native” only arrived on aarch64 with GCC 6.0.0, so the existing makefiles all fail on the PINE64 (as I’ve yet to build a 6.0.0 on later - I tried building 6.2.0, but the build failed with internal compiler errors and the compiler seg faultings).

(Have to decide what to do about this, because earlier versions of GCC are obviously going to be in use.)

x86_64 4.2.4 (and presumably earlier) don’t undestand -mcx16 (16 byte CAS).

arm (ARM32) 4.7.4 and 4.7.3 both fail with an internal GCC error.

So now I need to build a 6.x.x on aarch64. Thankfully, that’s the fastest board of the three - it takes only about four hours to build a GCC.

2017-05-19

Update

I’ve spent a long, long, LONG time building - or trying to build - GCC versions, on the platforms available to me.

I’ve learned quite a bit, although mainly that GCC builds are not tested before being released, and the build system is extremely complex, undocumented, buggy and depends on a number of other builds systems, which are also complex, undocumented and buggy.

Most GCC versions on most platforms do not build. x86_64 does better, and most versions build - I think only 4.3.x and 4.4.x fail to build.

On the Raspberry Pi, the first version can build is 4.7.3, because of the floating point options chosen when building the Raspbian glibc.

On PINE64 (64-bit ARM), the earliest version which can be built is 4.8.0, as that introduced aarch64.

On mipsel (MIPS32, little endian variant) building is painfully slow, and highly error prone as the Ci20 dev board freezes up a lot under high load, but I think I can build 4.5 onwards.

For now, I’ve build (or tried to build, see above!) the final point release of each minor release.

Now I’ve just started using these compilers with the build system.

I’ve discovered right away that 4.2.4 (and earlier) on x86_64 do not understand -mcx16 (16 byte CAS) and so the build fails.

The build system builds all variants, and test, and benchmark and runs both, and collects the gnuplots from benchmark.

Tomorrow, I’ll be running them through on every platform, and we’ll see what we get!

2017-05-12

About done building GCCs…

Building GCC is kinda an ever-ongoing task, because it’s so slow.

However, on all platforms except ARM, I have a compiler before and after 4.7.3.

On ARM, I can’t build anything earlier than 4.7.4 (painful irony!)

However, apt-get reveals 4.4 (and others) are available. I can use them for test, although I can’t use them for benchmark since they’re not built with the same configure as the other GCCs, so I’m covered.

Far as I can tell no GCC earlier than 4.7.4 can build on the Raspberry Pi 2.

I’ll keep building GCCs in the meantime, so I can benchmark and check makefiles, but I have enough to be getting on with, to get the next release out.

This brings me back now to getting bugzilla going. Ahhh, back to god-damn hell-smitten HTTP servers. BLEAHGAKKKK.

2017-04-14

Stuff

So…

  1. Looks like the 3.5" drive I have is broken - I held on to it to be able to reformat the 2 TB 2.5" drive I have which has all my blu-rays on. I could prolly do a bad block scan… …only it would literally take days, and I don’t want that much noise 24/7 in my room next to me while I work! Still, it’s far better THIS than the other drive, ’cause then I would have lost data. Most of the blu-rays are in storage and so not accessable.

  2. libmpfr 2.4.2, the recommended version for GCC, is broken on MIPS. Go figure. There’s a patch, I’ve applied it.

  3. I discovered after playing around with a USB voltage/amps meter that the four-port synwire USB charger I use to power my dev boards and wifi router instead of having four 2.4 amp ports, as I had thought, in fact has two 2.4 amp ports and two 1 amp ports. This is why the ci20 kept bloody crashing. I’ve ordered a decent Anker unit, with six ports. Anker are right now AFAIK the best USB equipment manufacturer.

  4. The PINE64 turns out to have major ethernet issues. I downloaded a benchmark app. It normally runs at about 90mbit (the hub is 100mbit) but every few seconds drops down to zero for three or four seconds. Googling finds a lot of people complaining about this. However, I also now find it’s just playing up completely, and right now, I can’t connect to it at all. Wierd.

  5. GMP 4.3.2 (the version recommended by GCC) has a subtle bug such that one of the GCC tests will spuriously fail. Allegedly this is for 4.8.0 and later, but I seem to have it with 4.5.4. What this means in fact is that make check on GCC ALWAYS FAILS.

I’ve been reflecting a bit about the GCC build system.

It seems to me there is a clear and fundamental difference between black box and white box systems. A black box system is operable only by its controls; you cannot look inside. A white box system can be operated by its controls, but you can also modify whats inside.

A build system should be a black box. It should be a working black box. The user operates it by the controls on the outside. The user has no need to modify - and so to have to learn HOW to modify - what’s inside the box.

If the user in fact must modify the insides of the box to make it work, then it is not a black box - in fact, the user is performing developmemt work. The system has been published in a state such that the controls on the outside are inadequate, for whatever reason, to make the system work. The user to use the system MUST learn how it works, so he can perform the necessary development work to make it work.

In the case of GCC, where the white box is extraordinarily complicated, depends on external libraries with their own issues, is barely documented and is buggy and the problems vary by platform, having to learn how to modify the system is a very high burden, in fact, almost insurmountable, and I would think often not sensible - the cost is much more than the benefit.

2017-04-13

The clanging leaden bells of computers being bloody awful

So, I spent an age figuring out which versions of GCC had which version of its depedency libraries.

Then turns out GCC is really quite conversative, and uses quite old versions of those libraries, only bumping up a version when it needs to.

So I’ve been figuring out the correct versions all over again, and although it’s clear back to 4.5.0, it’s not so clear after that - but I’m about to go out for a couple of hours, so I thought I’d kick off a 4.5.0 build on all platforms.

So I fix up the build script, fix up the source dirs (soft links in each GCC dir to its dependencies) and kick off the build.

It fails (it’s just failed on aarch64 too).

Configure bug in the libgmp GCC has used since 4.5.0 onwards, so that the check for flex fails in the presence of non-standard signal handling - such as configure being run from a Python script.

facepalm

Srsly. GCC build is a minefield. Take a step, lose a leg. Accurate description, no lie.

Then also a day or two ago I finally bought an enclosure for my external 2TB 2.5 inch drive, which is 15mm, so it was hard to find an enclosure.

Plugged it in, works, that’s great, but I need to copy all my blu-rays to an old 3.5" drive I’ve kept for this, so I can reform the 2.5 drive to veracrypt (it’s truecrypt right now, and NTFS on that, too!)

So I kick off that copy too.

Which fails. It copies about 500mb of Blade Runner and then stops copying.

Makes it look like one or other of the disks has a problem.

So now my happy hopes of having all these things buzzing along while I head off to the gym are replaced by clanging leaden bells of failure and bloody awkward problems.

(It looks like the source drive has the problem, which is a bugger - that’s the drive I intended to use and keep using. A reformat might help, maybe, but my Blade Runner blu-ray is in storage, so I don’t have it with me to re-rip).

2017-04-09

CI20 problems

Building the CI20 is problematic.

The device/OS appears unstable.

It will freeze up. It seems to do okay with earlier GCC versions, but now I’m up to 4.7.4 it’s dying during the build. I’m running “nice make -j 1” and I’ve added 1 GB of swap (1 GB of RAM), and the Pi 2 and PINE64 both make 4.7.4 fine with 1 GB of RAM and no swap.

I can reboot the device and restart the make - but because it freezes up, the file which was being written at the time of the freeze comes to exist but is truncated - which breaks the build when (typically object) file is used.

So I’m trying this now, but taking care to try to find out which file was broken by the freeze.

Update

So, building GCC and glibc.

In short, I have given up trying to build GCC and glibc.

I spent ten weeks trying. It can’t be done out-of-the-box, because the build system is much more complex than its documentation, and it may also be the build system is actually does not work out-of-the-box, and requires significant source code / build system modification to work, where those modifications most likely vary by GCC and glibc version, and are themselves undocumented.

The benefit of building glibc is that it allows the building of the various versions of pthreads, where the benchmark app benchmarks the locking mechanisms in pthreads.

I can however build GCC now, on its own, so I’ve been getting on with this. This allows the makefile to be checked (I’ve already seen I’m now using GCC options which early GCCs don’t know about) and will allow me to run test and benchmark.

Building GCC on the dev boards is quite time consuming. They only have 1 GB of RAM, so I an only run make -j 1, because the boards although they have more cores run out of memory with more parallel builds (well, at least with later GCCs, which have more complex builds; earlier GCCs get away with more).

It took twelve hours to build GCC 6.2.0 on my PINE64 :-)

I had quite a few problems with the CI20 dev board - but in part I think this was due to running out of store (I was running with -j 4, then -j 2, and now -j 1, same as the other boards) and in part I suspect because if the CPUs are running flat out, the board can freeze up - adding “nice” to the make for configure seemed to help…)

So this leaves me now building GCCs.

The baseline is a pre 4.7.3 and a post 4.7.3 on each platform. The native compiler is 4.9.2 (they’re all running debian 8, oddly enough) but on the PINE64 this compiler doens’t understand -march=native - but I want the same GCC, from the same build process, on each machine anyway.

So far, I have achieved this on x86_64 (my laptop). 4.2.0 is built, as is 4.9.2 and 5.2.0.

On the PINE64, aarch64, support for the platform arrived with GCC 4.8.0. I’ve built 4.9.2 and 6.2.0 successfully.

On the Pi 2, running arm, complete failure so far. I’ve tried building the latest point release for every GCC prior to 4.7.3 and they ALL fail, for different reasons.

4.9.2 also fails, as does 5.2.0, because of a bug in libgmp.

It looks like I’m going to have to do some real hacking on the arm platform to make a GCC, even on its own.

On the CI20, MIPS32, I’ve tried 4.2.0 and 4.2.4 and they both failed, I think due to changes in signal handling, such that later GCCs can no longer compiler these earlier versions (header file incompatibilities).

Another three builds are currently running - let’s see how it goes.

Oh - I emailed (together) the GCC and glibc help mailing lists, explaining what I wanted to do, and asked for help.

In glibc 2.25 there seems now to be a script for building glibc, which may help - but I’m too emotionally antagonistic toward this task now to continue down that route.

One other guy pointed out about NetBSD “pkgsrc”, a way to get hold of working portable source.

But that was it. No other help. People either didn’t know, or were wisely steering clear of someone else’s tar-pit which would be problematic to help with from the outside.

2017-03-26

Alright!

I left all three dev boards running overnight - the PINE64 build (of 4.9.2) worked! that’s the first successful GCC build on any of the dev boards :-)

The Pi build failed - AH! I think it ran out of resources - and this is because I, like an idiot, have left “-j 4” in the build script! (which is fine for my laptop, but NOT fine for the dev boards).

The Ci20 stopped responding - and I wonder if this is also because of that.

2017-03-25

Cable failure

That cable failure cost me about seven or eight hours of development time.

I’m just now getting the Pi back on its feet.

Amazing - just goes to show, the improbable eventually must happen

So, I was building GCCs and the Pi stopped responding.

Then a bit later, the Ci20 stopped responding.

Inserted the Pi micro SD card into the laptop and it didn’t show up.

Interesting, right? looks a bit like maybe I’m breaking the flash by writing too much.

Turns out in the end - after a bit of experimenting and swapping parts and getting things working (the SD card showed up on the laptop after a laptop reboot) the culprit was…

The ethernet cable used by the Pi board.

IT DIED!

Pi Death

My Raspberry Pi 2 just… died?

It was downloaded GCC 4.9.2 over NFS and then it just… stopped.

And now I can’t ping it.

Reboots not helping.

Hopefully rebuilding the SD card will fix it!

Building GCC, or, how to hack your way through jungle with a blunt keyboard

So, I’ve spent the last ten or so hours dealing with GCC build failures, as they’ve cropped up, on the three dev boards.

None of them have yet successfully built a GCC.

MIPS32 is trying to build 4.2.0 and it’s failing because the system GCC has sufficiently different header files to the 4.2.0 code base there’s a missing struct.

Looks like the way to deal with this is to work your way backwards from your current version, through earlier versions of GCC, until you’re compiling with a version so close to the one you want it can compile.

What this means ideally (and I shall do this) is that if your system has say 4.9.2, then you use that to build 4.9.1 and 4.9.3, and then you use those to build 4.9.0 and 4.9.4 - and so on. (Remember GCC builds itself first with the system compiler, then it builds itself again with that compiler, and then it builds itself again with that compiler - so we’re only talking here about the system compiler.)

This means though I will now need to figure out now how to build glibc. That was going to have to happen anyway, but it looks like another long, painful - no, agonizing - journey of discovery. In the same way that going to the dentist and having tooth removed is a journey of discovery.

So that’s the blocker for MIPS32.

ARM32 is currently trying also to build 4.2.0, and the problem is a missing header file relating to soft floating point. I wonder now actually if this is also a too-large-a-version-gap problem.

ARM64 has a stranger problem. The “aarch64” architecture was introduced in 4.8.0, so that’s the earliest version I can build on this platform. I run into the problem of not finding sys/cdefs.h - but I had this problem on MIPS32 and ARM32, and solved it by setting C_INCLUDE_PATH. That isn’t working now, even though the required file is under that tree. Actually I think this might be because it’s trying to compile something to do with C++ (even though it should only be doing C) and I’ve not set CPATH, only C_INCLUDE_PATH. Trying this fix now.

2017-03-24

Build system beauty

All three dev boards are concurrently running the build_gcc.py script.

Turns out running the build directly over NFS was waaaaaaay slow. I mean, I’m only on a 100 mbit ethernet anyway, let alone that it’s also got to go over wifi, over USB, and then to a hard disk rather than flash based media.

So I changed the tmp dir to be local, and then cached the current source dir being built locally, so now I’m basically just using NFS as a store for sources (which I could download from the net, so nothing vital) but also as a store for the completed binaries - and that’s like half a gig a shot for the later versions of GCC, so that is vital, because the dev boards typically have 10 GB or less of store (and I want to build clang in the future too, and glibc).

So I’ll leave them compiling overnight. They’re all doing 4.2.0 right now, the earliest (and so smallest) version which I know can compile.

Going to take a long time to compile all the GCCs, I have to say.

Of coruse I could build on my laptop using –host and –target, but I don’t trust it to work, not after the massive problems I’ve had getting anywhere anyway with GCC building.

Anyway, most people will be building with native compilers, so it’s the best choice for me for that reason as well.

2017-03-23

Build system update

Installed automake 1.15, which gives aclocal-1.15, and now GCC 6.2.0 builds.

Had a long drawn out “ahhhhhhhhhhhhhhhh” moment earlier. I had downloaded the 20GB of source which is every released version of GCC - in the /tmp dir. I had to reboot, after accidentally removing my normal user from sudo group (and so loosing access to root).

Ahhhhhhhhhhhhhhhhhhhhhh-h-h-h-h…!

The build script downloads the sources, of course. I’ll just need to run it again.

So it’s kinda looking like I can prolly build 4.2.0 up to 6.2.0, inclusive.

4.1.2 is probably going to be a headache, but we’ll see.

I expect to spend the weekend trying to build on the other platforms.

2017-03-21

Update

Friend at work suggested using NFS with the dev boards.

I’ve set it up - bit of pain but not much by Linux standards - and tonight I’ll use it to build a GCC, and see how fast it is.

I had to reflash the NAND in the Ci20 to get Debian 8, though - Debian 7 didn’t want to play with my NFS mount, and I figured this was the easiest way. It worked, too.

I’m quite happy I’ve done that too - hadn’t done it before, and the Ci20 supports Android, so I think in theory if I buy another Ci20, I can have an Android platform (although it’ll be MIPS rather than ARM). It’s a shame the Pi never got a real Android port.

I still need a case for the Ci20 :-) the only ones I’ve seen are for 3D printing and they seem to cost like 40 euro or something, which is nuts.

2017-03-19

Update

Worked the last two days till 5am. Getting to bed at a sane time tonight ’cause work tomorrow.

Worked on the script to build GCC. It’s done, except for one thing - turns out the source of every published version of GCC comes to about 20 GB of disk. Compiled it will come also to about 20 GB of binaries.

The SD cards I have for the Pi2 and PINE64 are 16 GB each!

So I need a pair of 64 GB cards for them, and another (non-micro) for the Ci20 (it only has I think 8 GB built-in store).

The latest version of GCC I’ve been able to build, so far, is 5.2.0. The later versions need aclocal-1.15, and I have 1.14. So close =-)

I’ve just built 4.2.0, which is the oldest version using make 3.81.

I want to build 4.1.2, since it’s the first version offering atomic intrinsics, but then I’ll need a new make, and I’ll prolly need to try to get it to build, too, since I failed when trying before.

I fixed up the normal build system to use update-alternatives (and set up the various sudoer permissions to let normal users use it from a script, i.e. sans root password) and built 7.2.0 using GCC 5.2.0. It built, no warnings, nice.

Building a late version GCC BTW takes quite a long time. I have four logical cores, I think for me it takes easily more than an hour. There are 52 releases of GCC which have to be built.

Building is much slower on a Pi2…

I’ve not used tried building on the Ci20 or Pi2. I’ve failed to build on the PINE64.

I’ve pretty much proven the x64 platform now and the build code for it, so the next thing to do is get GCC builds working on the other platforms. Once I’ve got a build on each of the other platforms, I can order the bigger SD cards.

Of course, once all this is done I still then need to figure out how to build glibc, so I can actually link safely and then run the test and benchmark binaries.

The payoff then though is awesome : benchmark gnuplots over platforms and over all GCC versions. I can then extend that to clang as well.

Kinda sucks I need to go back to work tomorrow!

2017-03-18

update

I’ve spent the day rewriting from scratch the python script to build all GCC versions.

It’s coming along nicely. I sorted out the problem from yesterday - it’s another (I’ve never seen anything but) spurious, meaningless error message. It was actually induced by the experimentation I’d been doing to build glibc. When I removed that, things were “fine” - I say in quoted because I have no idea if what I’m building is sane. If you run the test suite, you always get tons of errors anyway - they’re expected. Expected by the people who know what’s expected, which makes the test suite fractionally useful to the rest of us.

So the script now downloads all the source code, then makes all binutils and installs them, then makes all GCCs (using the right binutils, but the wrong glibc - uses the system glibc - because I’e not figured out (yet?) how to build glibc, since it’s even worse thn GCC, and believe me, that sayin’ something).

I’ve been building all the binutils.

It’s a bloody mess. The problem in particular is the docs. Binutils (like GCC) uses “makeinfo”, from package “texinfo”. Problem is newer texinfos don’t work with older binutils, and there’s no way to turn off doc generation.

So as a result, I cannot build 2.23.2, 2.20.1, 2.19 and 2.18. I also can’t build 2.17, because the build is actually broken.

One thing which is puzzling me is that - well, there seem to be two sources for binutils downloads. There’s ftp.gnu.org, which you’d think was canonical, only it’s missing some versions, which I have found over at ftp://sourceware.org/pub/binutils/releases/. Thing is, both of them have releases with the same versions but where there’s a second file with an “a” suffix, i.e. “2.19.1” and “2.19.1a”.

I can find no information at all as to what the “a” is supposed to mean. I suspect it may mean “we buggered up the first build, here’s the real one”, in which case “a” releases should always supersede. I think it’s not very likely this will solve the makeinfo problem though.

GCC actually suffers from the same problem, but if texinfo is not present, it doesn’t try to build the docs, so you can work around the problem (you just don’t get any docs).

2017-03-17

Maybe the end of the line for GCC

So, I’ve been running my GCC build script on ARM64, just for 4.9.2. That script works on Debian on x64. It doesn’t work on ARM64. There’s a wierd error, fairly far into the build process, that it can’t find pthreads.h (which is present, and in the usual place).

Googling just leads to a bunch of other people, over the course of many years, saying they’ve found the same problem and are just about at their wits end (because there’s no apparent cause, and so no apparent fix).

I’ve spent six weeks getting that build script to the point it’s at on x64, and now I run it on ARM64, it doesn’t work.

My line of thought now runs like this : it is not possible to build GCC.

Because GCC cannot be built, it is only possible to test code with the GCC version on the build platforms you have. You can support no other versions, because you have to access to them, so you can’t compile with them.

That’s completely intolerable. No serious software package can be presented to users in this way - where the supported compiler versions are not under the control of the package developers.

I had a look at the build instructions for clang, and they look normal and sane. Thank God for choice!

Update

So, I started writing a HTTP server. Single thread, async I/O for network and disk. Simple, right? wrong. Linux async I/O support is a fabulous mess. I think I can just about get away with it, with two threads, one for epoll and one for io_getevents (kernel AIO). I think the kernel version of AIO will work on regular files (but I’m not certain, actually).

The HTTP 1.0 spec is easy to implement - but there’s no pipelining, and pipelining matters. I looked at the 2.0 spec, and it looks complicated. One of the beautiful things about 1.0 was that it was simple. I think 1.1 allows clients to send say chunked encoding, so already implementation is a headache. So we’ll see where I go with this.

So, given that I’ve got to read the HTTP specs, what I’m actually working on now is compiling all the GCC versions on the various build platforms. It’s a lot of work - GCCs seem to come in tranches, so there’s going to be a number of separate sets of build problems to deal with.

Right now I’m compiling 4.9.2 on ARM64. Will make sure -march=native works. Then it’ll be time to build all the versions and finding out about the build problems.

And then doing it all again on ARM32 and MIPS32 (but it should be pretty easy by then, hopefully they’ll run through without any extra work).

2017-03-12

build system heaven

Absolutely bloody beautiful.

I have now two scripts, both run on Linux but one targets Linux and the other Windows. I’ve spent the day getting the Windows build working, and now it does; the VM starts up, the build iterates through all variations (IA64, x64, debug, release, coverage, debug, release, etc, etc, etc, etc), and runs the test on release builds. No benchmarks, because it’s a VM.

Beautiful.

I produced a 7.0.1 and 7.1.2 with the liblfds build updated to match the 7.2.0 build - necessary for libbenchmark to build, since it has an embedded copy of 7.0.x and 7.1.x.

The Linux version runs over all the Linux hosts - x64, MIPS32, ARM32 and ARM64, and does the same. Gnuplots made by the benchmarks are brought back to the host.

The only problem now is that the GCC on ARM64 doesn’t understand -march=native, so the make fails.

This actually touches upon me needing to compile every released version of GCC On each platform, and having the build system use them all.

That’s the next work.

After that, I need to get Bugzilla working again, which means doing something about the web-server, since nginx doesn’t support CGI.

2017-03-11

Unexpected behaviour from Gnuwin32 gnumake and tar on Windows

Gnuwin32 gnumake does not on Windows support single backlashes as path seperators when being called with -C from inside a makefile.

So - if you have a makefile, and from inside that makefile you call another makefile, and you are in that call using -C (change directory), that inner make call will fail because it does not understand the path to -C. I think it’s probably treating the single backslashes as escapes. Single forward slashes work, as do escaped backslashes.

However, if you run that inner make directly from the command line, with single backslashes, it works.

Gnuwin32 tar seems to be randomly dropping file suffixes on Windows. The tar is made on Linux, sftp’d to Windows, then if I list it, about one in ten files is missing it’s suffix, which for liblfds means usually .c or .h, which means of course that the makefile falls over because it can’t find the files.

Going to try using zip instead. Compression sucks, but hopefully it’ll work.

2017-03-08

Build system update

More good stuff.

Have implemented the python functions (using vboxmanage) to start and stop VMs (where starting means getting the guest IP and then waiting until you can see the SSH server is responding).

At this point I’ve discovered a design flaw. I had thought I could now use SSH, SFTP and make on all platforms - which is to say, including Windows (which is what I’m using the VMs for).

This is not in fact the case. Windows needs a batch file run before the C build environment is ready. What’s worse is that it takes a bunch of args which vary depending on the target processor and operating systems - and you’ll note in that I didn’t think about cross-platform builds. The build system supports processor types, but it doesn’t (currently) support multiple operating system type targets.

Windows being a complete PITA again.

So too sleepy now to do more tonight. Did what I wanted to do, which is get VM startup/shutdown going.

2017-03-05

Build system update

It’s going very well.

I had to do a fair bit of work on the library itself to get it back into fully compiling shape, for the tests and benchmark, and the two SMR methods.

So I now have a build system which will build on every Linux platform, over every build variant, run the tests and the benchmarks, and pull the gnuplots back to the originating system and convert them to PNGs.

What I need to do now is;

  1. get all the version of GCC compiled on all platforms and add support for changing GCC version (so then all the Linux verions will build over every released version of GCC)

  2. set up the Windows VMs with an SSH server, then figure out how to use vagrant to start/stop the VMs on demand, and then figure out how to get builds going on the Windows platforms

2017-03-01

Build system progress

Looking good.

Have the three dev boards hooked up and ready to roll (arm32, arm64, mips32).

The build system knows the platforms it has, and how to get files to them and build on them; and it knows the targets for liblfds720. I’ve been building successfully on arm32 but I ran into a problem on the arm64 platform, the GCC (4.9.2) there doesn’t understand “-march=native”. This was a surprise.

In fact, “native” hasn’t always been present historically, even though I expect it with 4.9.2, so it’s a problem I need to address anyway.

I think what I need to do now is build every GCC version on each platform. I haven’t yet mastered building glibc, but even if it’s every GCC with current glibc (hmm, assuming that can work) then at least I should get past this wierd (?) GCC compiler on arm64.

2017-02-26

build system progress

Happy joy!

Written platforms.json and targets.json, wrote the Python to export from SVN, make a tar.bz2, sftp to a remote host and then make; found my first bug, too! “-mcx16”, which is an Intel specific flag for GCC, throws an error as an unrecognized option when using GCC on ARM32.

Once the build system is up, I then need to get back to building every version of GCC on every platform, so I can compile with the lot.

After that, clang.

Actually the more-fun bit will be using vagrant to run VirtualBox VMs, and configuring Windows to accept SSH/SFTP.

Build system OTW

Yay!

Finally - writing a build system for liblfds.

I know there are plenty of build systems out there. I normally find trying to figure out how to make an existing build system work for your own source code is more work than writing your own build system from scratch.

It’s written in Python. There’s a “platforms.json” in the build system itself which describes all the platforms available - which is to say, the compilers they offer, which processor type, IP address, etc.

There’s a “targets.json” in each entity which is built, which describes the platforms each build directory supports (there’s one build directory for each distinct set of build files - i.e. Makefile for GCC, Makefile for MSVC, WDK 7.1 build files, etc). So this would indicate the compilers which can be used, the processors, hosted or unhosted platforms, makefile targets, etc.

It’s assumed everything has a gnumake makefile (even if it’s just a curtsey makefile, which calls a different build system) and that I can use SSH/SFTP to get files in/out and issue commands.

2017-02-22

DWCAS bug fix - “new” 7.1.1 released

If you downloaded 7.1.1 prior to 21:50 GMT+1 22nd Feb, please download it again.

One of the bug fixes was for DWCAS with GCC >= 4.1.2 and less than (I can’t type the less than symbol - wordpress in its awesome majesty doesn’t escape it, and it totally breaks all following formatting…!) 4.7.3. This platform is still not available for testing - a lot of work has gone into learning how to build GCC and glibc, to get access to all GCC versions, but that has not yet been successful.

There is a script which converts liblfds version “n.n.n” to “m.m.m”. This script was run, and then the DWCAS macro was added in… but with the 7.1.0 verson numbering, and this was not noticed.

Result - the macro doesn’t exist, so the arguments end up being a comma separated list of variable names, and of course this doesn’t work as expected!

Rather than making a whole new release for this, since the original has only been out for two days, 7.1.1 has been re-released.

This whole thing totally sucks. Obviously it’s well understood that if something isn’t tested, it doesn’t work; but there’s no obvious way to get hold of that test platform.

The work to get GCC and glibc built has to continue - but this is a nightmare task, truly one of the very worst things you could imagine, which is why after six weeks of non-stop work it still isn’t complete.

If you need to check which “version” of 7.1.1 you have, look at the file “liblfds7.1.1/inc/liblfds711/lfds711_porting_abstraction_layer_compiler”. Look at line 322. If you see “LFDS710_PAL_ATOMIC_DWCAS” you have the broken version. If you see “LFDS711_PAL_ATOMIC_DWCAS” you have the fixed version.

2017-02-20

7.1.1 is out

As subject.

If you use the unbounded/many/many queue from 7.1.0, upgrade for a bugfix. See previous post for an explanation of the bug and why it was not found by the test suite.

2017-02-13

Bug Report : 7.1.0 unbounded, many producer, many consumer queue

There is a serious bug in the 7.1.0 unbounded, many producer, many consumer queue and users absolutely should upgrade to 7.1.1 as soon as possible, which itself will be released as soon as possible (the next day or two).

The bug is not in the lock-free code, but rather in the conventional code around it which handles backoff. This code was “improved” in 7.1.0 to make it more graceful and easier to read. This introduced the bug. All other versions of liblfds are unaffected. All other data structures are unaffected.

The bug can in principle occur under any workload but the heavier the workload, the more likely it becomes to manifest. In practise, to be sure to occur, a maximum-load use case is required, i.e. threads which are busy-looping on the queue, and the queue has enough load to be continually shifting elements in and out.

The queue contains a dummy element. Even when it is empty, there is one element in the queue; this element contains no valid data. If the queue has say ten elements enqueued to it, there are eleven elements in the queue. When you dequeue, the key and value placed in the first enqueued value are placed in the dummy element, the dummy element is removed from the queue and given to the user, and the element after that becomes the new dummy element.

The bug is that if the queue was empty a the time of a dequeue attempt, or became empty during a dequeue attempt, the dummy element would have written into its key and value either NULLs, or the key and value of an element which had been in the queue (but was dequeued before this dequeue attempt completed).

Normally this is (although completely broken and wrong) harmless, because the dummy element carries no valid data.

However, a race condition can occur, whereby just before the incorrect key and value are written into the dummy element, the dummy element is REUSED, i.e. it has a REAL key and value put into it and it enqueued into a queue.

It then has its key and value overwritten - and this of course is deadly.

The relevant tests are in the test suite are;

  1. libtest_tests_queue_unbounded_manyproducer_manyconsumer_dequeuing

This test has a pre-populated queue, where one thread per logical core concurrently dequeues. The elements when dequeued are just returned to a freelist, not reused. Each thread checks the value obtained from the queue, but only dequeues once on empty (getting a return of 0 from the dequeue function causes the thread to stop working) so it’s almost impossible with that tiny window to actually induce the bug, and even if it was induced, it would do no harm, as the queue elements are not being reused.

  1. libtest_tests_queue_unbounded_manyproducer_manyconsumer_enqueuing_and_dequeuing

This test has one queue and one thread per logical core. The queue begins empty, and each thread has one queue element. The threads run a tight loop, where they enqueue and then immediately dequeue. This test fails to find the problem because the queue is never empty.

The libtest_tests_queue_unbounded_manyproducer_manyconsumer_enqueuing_and_dequeuing test has been improved to provoke the bug. The code for handling backoff has been fixed, and it is seen that the bug no longer manifests.

Release 7.1.1 will be published as soon as humanly possible.

2017-01-29

singly linked-list design

I can figure out how to make a practical ordered singly-linked list, but not a practical unordered singly-linked list. Bit of a surprise!

The key problem is iterating over the list.

Imagine you have a list, and you want to iterate over it.

You have a cursor; it points at the element you’re currently looking at, and prevents it from being deallocated. It does not - cannot - prevent it from being unlinked.

Now, when you want to move to the next element, you get the next pointer of your current element (which is to say, you point a hazard pointer at it, and then get hold of the value of the hazard pointer, this means the next element also can’t be deallocated - but it still can be unlinked.

So the problem is this : your cursor is on an element, any element, that’s fine (just assume we got there - it doesn’t change anything - we’re setting up a scenario which illustrates the problem). We get our next pointer, that’s fine. Before we move to the next element, though, someone else unlinks it.

Well, huh. So at this point, the next element we’re about to move to is unlinked - but it still points at what was its next element, so we’re still okay… (and we know the element has been unlinked, because its unlink warning bit has been set by the thread which unlinked it).

But what now happens if the element after our next element is unlinked and deallocated - which it can be, as we have no hazard pointer on it.

Because our next element has been unlinked, its next pointer is not updated by the unlink of its next element. So now the cursor is pointing at an element which has a next pointer pointing at deallocated store.

So what we see is that if we see the unlink bit is set, we have to abort the iteration.

Now, if we’re aborted the iteration, well, then what? users will often want to iterate over the whole list and look at each element just once. So we need to restart the iteration, at the point we left off.

But in an unordered list, we can have no idea where that point is, because the entire list could have been deallocated and replaced in the meantime.

We can only know where that point is if the list is ordered. Then the key held by the unlinked element which derailed us, which we still hold a hazard point to and so which cannot be deallocated, let’s us know how far we have to fast-forward over the list to get back to the point where we can recommence the iteration.

2017-01-25

singly-linked list update

So, it’s all very interesting.

You need a cursor, to iterate over the list - because you need a pair of hazard pointers to iterate. There’s a problem here though I think - when we deregister an SMR hazard pointer per-thread state, there can be allocations still in the list of allocations pending reclamation. An unusued thread state with lingering elements is always checked by the other threads; so either we can’t use it till its clear (which is awkward as hell for the user - remember, we will not look to dynamic allocation as the library performs no allocations) or when we re-use, we then rely upon the now-owning thread to run scans. Problem is, that now-owning thread is expecting to be the sole owner - he has no idea he might have gigabytes of store sitting in his pending reclamation list! so I have to find a nice solution to this.

Another problem I’m currently grappling with is that although the hazard pointers prevent any element you’re using from being deallocated, they don’t stop it from being unlinked.

If you’re unlinked, it could be the element after you is unlinked before you try to get_next with the cursor - problem then is the next pointer in your element is now pointing at a deallocated allocation because of course it’s not updated when that next element was unlinked…!

I’m vaguely thinking there needs to be a “deleted bit” IN an element, which is an immediate logical delete, which is followed then by the usual delete bit in the predecessor element, as part of the two-step unlink (which I think is still needed - but not certain).

However, this is because I’ve not got the way it all works clear yet in my head, so it could be complete garbage.

2017-01-23

Update

Have implemented the freelist and queue with hazard pointers. Will do the stack once the freelist tests are written and pass.

Now implementing - finally, after all these years! - a lock-free singly-linked list, with support for real delete =-)

Once that’s done, I’ll think about how complex it is to support delete in the unbalanced tree.

2017-01-16

English. Trying speaking it. Words have meanings, that sort of thing.

I’m joining - trying to join, as ever you have to struggle and fight to get past all the incompetence and mistakes every company makes in its desperate effort to commit suicide - Revolut, a FinTech.

They ask for four photos for proof of ID - front and back of passport, pic with yourself and passport next to your face, and then a pic of yourself.

I photo the front and the back, open the passport hold next to my face take a pic and then pic of me.

I send this off (after checking their SSL cipher suite is okay).

“When we said front and back we did not not mean the front and back of the passport; we meant the two pages (authors note - on the inside!) which have identity information.”

“Yes, we do have other people sendng us the front and back!”

2017-01-09

Using lock-free data structures in a “single-threaded mode”

I have recently implemented hazard pointers.

As with epoch-based safe memory reclamation, each thread maintains a list of allocations which are pending reclamation.

This list must support delete, and where it’s per-thread, it can be single-threaded, so no problems there.

One solution then is to provide in the library a single-threaded list.

However, there is another possible solution, which also provides useful functionality and allows the absence of this singleton single-threaded data structure; to allow the lock-free list to be operated in a single-threaded mode.

The user would need to know, a priori, that at some point the list would only be operated on by a single thread. That thread would enter single-threaded memory with a load barrier, then Do Stuff, and then finish with a store barrier and forced write to memory. Other threads wishing to use the list again in normal multi-threaded mode I think (not yet checked the code) can do so without a special effort, since they get load barriers anyway - but if not, then any thread wishing to again use that list must issue a macro (which turns into a load barrier).

Similar functionality would be useful for all of the data structures, I think; I can imagine times when they are operated on in a single-threaded mode, and then you simply do not want the overhead and costs of the atomic operations - but you DO still want to operate on the SAME data structure you will then use multi-threaded.

There are two efficiency concerns.

The first is that the data structure C-language structures often have alignment constraints on some of their members. This is fine for CAS platforms, but not necessarily for ERG platforms - the worst case on ARM is 2048 bytes, so you end up with fat structures. You would avoid this is you had a single-thread only data structure, because then you don’t care about alignment. Still - if we are arguing the use case where we want single-threaded operations on a data structure which we either before or after want to use multi-threaded, then there’s no avoiding it.

The second is to do with the type qualifier volatile. Volatile is necessary to prevent compiler optimization. The compiler can in theory put a value into a register and keep it there forever - load barriers, which could cause the cache line holding that value to change, do not cause the register to be updated, and so the compiler would continue forever to use an old value. This will break most data structures, or at least prevent forward progress :-)

One common solution is to take use a non-volatile object, take a pointer to it, cast that pointer to be volatile, and access through it.

The Standard does not support this behaviour; by the language of the Standard, the compiler decides what to do with regard to volatile based on the type qualifier of the object, not the pointer.

However, GCC has supported this behaviour for a long time. I’m not sure what MSVC does, or other compilers.

What this means is that in single-threaded mode, the lock-free data structures must retain their volatile qualifier, which make them less efficient. We can avoid atomic operations, which is great, and we can perform operations which otherwise we could not (deletes for example) - but we can’t safely avoid volatile.

The problem is that if we did remove volatile, and use casts when we wanted volatile access, but the compiler does not support it, it would lead to a fault which would be intermittant and hard to diagnose.

The issue itself is difficult to explain to users - if it were for example exposed via the abstraction layer, by making volatile a define - and it is equally difficult for users to actually find out how their version of their compiler deals with volatile.

Correctness is the first attribute of software. You cannot ever put it at risk; software which does not do as it was intended has failed.

Given that it is problematic to determine whether a compiler will honour the type qualifier of the pointer, it has to be assumed it will not.

2016-12-30

Hazard pointers have been implemented

Have to test them now, and then convert the SMR data structures to use them.

They’re much less work to implement than epoch based SMR =-)

2016-12-21

Update

So, still working on the announcement list - finishing the error and resource handling framework for the SimpleCGI server.

However, I had an idea earlier.

Once 7.2.0 is out the next big things are hazard pointers (I hate using other peoples ideas, but as far as I can see, there IS no other method) and a balanced btree with delete.

The balanced btree with delete is a big chunk of work - but it struck me I could probably do as a first step an unbalanced btree with delete. You can get pretty good balancing by hashing the key before insert; and the delete concept is pretty simple, you place a marker in the nodes you’re going to have to affect, like the Harris’ logical delete bit, before you get to work.

2016-12-17

try/except in C

Where I’ve been working on a SimpleCGI server for nginx to get a mailing list working (because every mailing list under the sun sucks like a dual-fan octo-core iCore7) I’ve for the first time in a very long time come back to some normal, user-mode software coding.

This of course in C brings you back to the problem of error checking and resource handling.

C is a beautiful - physically beautiful - language. Until you add error checking, and then it’s an appalling, unreadable mess.

This problem is compounded by the need to release in the event of error only those resources so far allocated.

I’m sure we’ve all seen the simple example of this, where a function is a series of if() statements, each calling a resource allocator, and each in its body as you go down the list of ifs() containing more and more resource releasing functions.

A long time ago - a looong time ago - I thought it over and independently came up with an approach which is semantically equivelent to try/except.

The rational is this : a program is the minimal set of instructions required to perform a task. You wouldn’t perform any instructions you did not need, because you do not need them. It is then that if ANY instruction fails, the task cannot be completed. We can of course put in error handling code, but what this would amount to would be alternative ways to perform the same work (if we still wanted to be able to complete the task). This is strange, complicated and in many cases impossible (if you can’t open a file, you can’t open a file).

If an error occurs, we are at that point in what is basically uncharted waters. It is difficult enough to write code which works when it follows and only follows the error free path, let alone also coping with all the incredible number of possible situations which can arise when we begin to consider errors.

It seems to me then that once an error occurs, what you actually want is to stop executing code. You want this because you no longer know what state you’re in, so you therefore cannot know what will actually happen if you were to execute code. However, you also still need to deallocate any resources allocated up to this point; so you need additionally to keep track of resources when they are allocated, so you can free them when things go wrong.

Also, I’d like a nice error stack to be dumped, so I know what when wrong where.

Sounds pretty much exactly like Python to me!

So a loooooooong time ago I implemented a solution to this, but I’ve not used it for a long time and how I write code now is rather different to back then, so I’ve reimplemented it.

What I have now is a thread local variable (TLV), which is called the “error and resource state”. A thread does not need to call an init function because global statics are initialized to zero. Every function has a wrapper, which as the very first thing it does is look at this TLV and if there are any errors in it, and if so, it returns. No code executes once an error has occurred.

If however there is no error, the wrapper executes. It calls the underlying function and checks for errors - so we’re now checking ALL return values; not being lazy/coding-time efficient and missing out on checking the return value from malloc, etc. If the call falls, an error is placed into the error+resource state, and the function returns the normal error value.

What we see now is that there is no longer any need to check the return values from functions. THIS IS IMPORTANT, because now we get rid of the enourmous code-noise of checking for errors.

We also see that we get an error stack; if we have a chain of function calls, when one fails, it will dump an error, and then its failure will cause its caller to dump an error, etc, right the way back up to the top.

Additionally, if the function calls allocates resource, it is noted in the error+resource state.

At the top level, when we reach the end of execution (whatever that means - will vary by programme) we dump the error stack (if there is one) and free any resources.

So we see here we also free whatever resources were allocated - but because of the wrappers returning on error, if there was an error, we will only have been allocating up to that point; but that’s fine.

The wrappers I’ve now implemented in fact as - and this moves a long way from normal C - as #defines. Since I use a TLV, the arguments don’t change. I simply “#define malloc libw_ansi_malloc”. This is a drastic change.

One problem is macros. You can’t have two conflicting values for the same macro/define, so you really do need a new name and the code using the library has to use that new name.

/****************************************************************************/
static void open_listen_socket( unsigned short int port, int *fd )
{
  struct addrinfo
    addrinfo_hints,
    *addrinfo_list;

  char
    port_string[6];

  LIBW_RETURN_ON_FAILURE();
  // TRD : port can be any value in its range
  assert( fd != NULL );

  memset( &addrinfo_hints, 0, sizeof(addrinfo_hints) );
  addrinfo_hints.ai_family = AF_INET;
  addrinfo_hints.ai_socktype = SOCK_STREAM;
  addrinfo_hints.ai_flags = AI_PASSIVE;

  sprintf( port_string, "%hu", port );
  getaddrinfo( "localhost", port_string, &addrinfo_hints, &addrinfo_list );
  *fd = socket( addrinfo_list->ai_family, addrinfo_list->ai_socktype, addrinfo_list->ai_protocol );
  fcntl( *fd, F_SETFL, O_NONBLOCK );
  bind( *fd, addrinfo_list->ai_addr, addrinfo_list->ai_addrlen );
  freeaddrinfo( addrinfo_list );
  listen( *fd, 5 );

  libw_on_error_push_error( "open_listen_socket", "failed to open listen socket" );

  return;
}

So here we note the following;

  1. the sequence of function calls is visually clear
  2. every function is checked for an error
  3. if an error occurs, no more code is executed
  4. any allocated resources are deallocated, regardless of error, at the end of main
  5. if an error does occur, it is pushed to the stack, and then this function itself pushes its error to the stack, and so on, until main dumps the error stack and returns

2016-11-29

ARM64 dev board has arrived

PINE I think gave up on the one circulating up and down the east coast of the USA and sent me a new unit from China.

I have written Debian 8 with XFCE to an SD card, booted and voila! I now have a 64-bit Linux on ARM64 dev platform.

Beautiful!

2016-11-19

Organizing a company

A few days ago I wrote a post about organizing a dev team.

It was not properly written, for it does not properly reflect my views, in part by being too brief and in part because I was in effect writing about a compromse (a dysfunctional compromise) which was in my head at the time due to the situation at work.

I need then to write properly that which I think, otherwise I look like I’m talking what I think is partially rubbish.

  1. Software engineers must be physically removed from the office. They must work at home, or in an office which has just them in. No other developers, no one else from the company, no other people at all. Distraction is death to software engineering productivity, and an office is no different to being in a disco. This is an order of magnitude effect. Developers come into the office for one day each week, to maintain relationships. One day per week is the minimum contact rate for humans to maintain close relationships.

  2. Contact with developers is either through email, real-time typing, voice, or group voice. Some conversations are best in email, others best in voice; meetings often need group voice. I have yet to see any need for people to be physically together, other than for maintain relationship (and this will be with people who are not otherwise contacted during the week).

  3. The company cannot organize itself into large teams (sales, IT, etc) - but rather forms teams, with members from each discipline. Motivation is key to productivity. When software engineers are separated from the users of their work, put into an IT team, they are removed from motivation. This is death to software engineering productivity. Moreover, in a larger sense, any work which is done without input from major components of the company (sales, for example) is fundamentally brain damaged. It’s like trying to be sentient without your right hemisphere.

  4. A second profound negative consequence of putting IT into a group and then having it control its own work is that other teams no longer care about the work being done in IT. If a non-IT team controls their own developers (which is not the situation I’m talking about here, but to explain the problem) then if those developers are doing the wrong work, that non-IT team cares, because they are wasting their resource. They incur the opportunity cost. However, people or teams or whatever can only bear an opportunity cost if they could have directed the effort involved toward something else. When all the non-IT team can do is submit tickets and someone else decided if they are done, that non-IT team no longer bears any opportunity costs, because they have no capability to redirect the effort expended to other things. If something is done for them, well, that’s nice! and because they cannot bear an opportunity cost, they are fundamentally and profoundly less interested in the work being done and ensuring it goes correctly. Bearing opporunity costs is VITAL to productivity, because it is this and this alone which makes people direct effort towards the tasks which actually matter.

  5. The closer someone is to something, the better they know it. The higher up the (management) hierarchy you go, the less they know what’s actually needed and the more oblivious they are to the unintended consequences (let alone the intended consequences!) of their actions. Small cross-discipline teams are close to the task and motivated; they are the smallest team necessary which possesses all the skills necessary to move from nothing to completion. Management as such no longer exists; rather, staff members with knowledge of the larger business environment are members on these teams. The IT work done also includes maintaining systems after they are created.

  6. All members of a given discipline should be in event-driven communication with each other. Not regular meetings - i.e. polling - it’s inefficient and needless. People know when they need something from someone else, and people know when something has happened they need to tell other people about. Regular meetings are senseless - they have a profound impact on productivity (scratch that half of the day) and they are not needed.

2016-11-17

SimpleCGI

Yay!

I now have a simple CGI server. Takes CGI style arguments, emits a page back to the browser, working with nginx.

Now I need to lash up the database stuff to actually run an announcement list.

It’s not going to be a fully-fledged mailing list (at least not to start with) as I’d need to mess about with the SMTP/POP servers and be able to read mail and that’s like having your brains slowly pulverized with a million tiny hammers; rather, it’ll be an announcement list (just a descriptive phrase I’m using here) where you can receive email from liblfds (bug reports, new releases) and where I can when necessary send out the odd functionality/design question - all replies to it will come to the liblfds admin email addy, rather than to everyone on the list.

2016-11-12

Agile considered harmful

Where I currently work has been without a product manager for about four months.

We’re a small group of devs (five of us) and we have a lightweight “agile” process - really, it means a meeting Monday morning, a meeting Friday, and JIRA, which is convenient for organizing tickets.

I’ve seen a lot of companies, and I’ve seen them do a lot of things, and I’ve generally not minded or much cared, so long as it didn’t get in the way of me getting work done.

In fact the elephant in the room for software engineers is the simple fact we’re all forced to work in offices and that this reduces productivity by a factor of ten. No one speaks about it, because we all know managers require everyone to be in the office.

The problem is the people who run companies and organize software groups are never or almost never software engineers, and so they have absolutely no idea about the requirements for software engineering productivity; in fact, I would say, in all or almost all cases, the matter simply doesn’t come to mind. It’s not thought about. It’s simply - we have an office, everyone is in the office.

So, we’re in all in an office, and then we have all this fashion about how to organize the software engineering effort, as if this was a major factor in engineering productivity. The problem is all or almost all companies are in fact gung-ho on organizing productivity but not about actual productivity - and software engineers working in an office have bugger all productivity. I do in one six hour session at home what takes a week in the office.

The loss to companies is catastrophic. Software engineering is regarded as an incredibly slow process - in fact it is not, at all, but the problem is that software engineers are basically being asked to work while in a disco.

So - this is how I would arrange a software engineering group, althoug here I only talk about the internal organization of the group itself. I’m not talking here about integration with other groups, which is vital.

  1. Everyone works at home. Engineers NEED to be PHYSICALLY REMOVED from the office, so other people cannot disrupt them. If home is not peaceful, they get an office of their own, provided by the company, AWAY from the main office.

  2. Communication happens by email, real-time chat, or VOIP (and this specifically must include group VOIP). Some conversations are best by email, but some MUST happen verbally (too subtle or complex for typing) and group chat is necessary for meetings.

  3. A product manager exists, who keeps track of all work requests, and who’s currently working on what. When an engineer finishes a task, the PM and the engineer select the next task. None of this “plan for two weeks ahead” idiocy. Why do it? when my OS switches tasks, it picks the next best job out of all available - it doesn’t pick a dozen so it’s commited for the next ten seconds.

And this will never happen, because managers want people in the office. They do not know about software engineering productivity to care about it, and as such they are in fact not qualified to run a software engineering group.

versioning

I’ve been properly re-reading Dreppers white paper about DSOs.

Where I’m working on the simple CGI server for the mailing list (crazy - I’m sitting here writing a server around epoll so I can write a CGI) and for that I need another data structure library I threw together year or three ago (never published), libstds, which is just a collection of single threaded data structures.

So I need to tart this up a bit now - bring it to the the same presentation as liblfds. Thing is, Drepper’s paper has raised the question of how I’m going about versioning.

Drepper makes a pivotal point; the reason DSOs are used is that if we distribute security or bug fixes, we update the entire system by replacing a DSO, but if we statically linked, we have to recompile every binary using the library in question.

(BTW, I can’t use DSO internal versioning at all, because it’s Solaris and Linux only).

So this means that the APIs must remain constant between versions, do the new versions work as drop-in replacements of the old versions.

This has one problems; the concurrent use of multiple versions of the library.

I want this for two reasons. Firstly, when new versions of the library are released not for needed security or bug fixes, but for new functionality, if users adopt them, then they need to revalidate their code. I would rather existing code was completely unchanged - i.e. the binary of the DSO is unchanged - as this is the only way that effort is not required. Secondly, I want to be able to benchmark multiple versions of the library, in the benchmark programme (so users can see how performance changes over time).

Concurrent use of multiple versions requires that APIs differ by version. This means DLLs cannot be used as drop-in replacements.

Right now, where the API changes on every release (as it contains the version number) we get some of the code-sharing benefit of DSOs (everyone using the same version re-uses the DSO in memory, as opposed to being just the one DSO any everyone using it) but we do not get the linking benefits of DSOs (you do need to relink to use a new version, rather than simply replacing the DSO). We note though this last behaviour is somthing explicitly eschewed, as it requires revalidation.

At a pinch, if it were needed, I could handle multiple versions concurrently in the benchmark by code manipulation; after all, the benchmark code contains a copy of each of the earlier liblfds libraries. I can modify that local copy.

It certainly is the case that users normally expect a stable API, with the DSO changing behind the scenes. The fantasy here of course is that the authors of the DSO introduce no new bugs, unexpected behaviour, etc, such that revalidtion is not required.

What we see in fact is that software being software, i.e. extremely complex and so error prone, the point of maximum validity for an application is that where all of the dependencies (DSOs, etc) have the version used at the time the test suite was running (and even this of course is only true for the OS version, the hardware revisions, etc, etc).

Of course at that point how valid the application is depends then on the quality of the test suite.

In all things, there are factors which encourage, and factors which discourage, and in the end you get what you get.

So we see in the actions we can take we move from the point of maximum validity (the systems the test suites have been run on - system here in all its glory, DSO versions, hardware, OS, etc) to points further away from maximum validity, where we can see benefits in other domains for such moves (being able to easily distribute security and bug fixes by DSO updates).

2016-11-10

Update - we’re on a road to nowhere, come on inside…

Not much happening right now.

I ordered a PINE64 back in August as a 64-bit ARM platform. Instead of being posted to Germany, it was posted to the USA, where it’s gone in postal circles since then. I first emailed PINE about this about a month ago - they are now finally sorting it out.

It doesn’t matter much now in fact, because GCC 4.6.0 introduced a 128 bit type so I can use the GCC atomic intrinsics if you’re on that version of higher and get the built-in support for ARM64 double-word CAS. Still, it’ll be great to have another dev platform to actually test on.

I’ve been trying to get a mailing list going, A G A I N. Fourth or fifth try. Failed again. The problem is that almost all mailing list software uses CGI, which is not supported by nginx. Apache is a catastrophe - bloated and it turned out, very broken out of the box (default is IPv6 only and to deny all files), lighttpd is out of the question because it’s a thumping nightmare to configure. That left dadamail as a possible, since it can use FastCGI - and this ALMOST worked - but then it turns out dada uses wierd “cgi-name in the path with more path as arguments” and I could not face trying to configure that in the HTTP server, when it could just as well have used normal CGI arguments which would have worked exactly as well.

So I’m still stuck on this. I’m totally repelled by all the existing mailing list software I’ve seen (except for dadamail, which had a viable install path, but - as above - then takes a wrong turn) and for my simple use I can roll my own much more easily than trying to install an existing mailing list. The problem is I can’t easily get the HTTP server to operate the mailing list. I looked at the FastCGI spec, thinking to write one, and it’s a monstrosity. I’ve never seen something so simple be made so complicted, MY GOD.

I’ve more or less come to a halt with building all GCCs starting with 4.1.2, and matching glibcs, and using them for compiling and building. I spent five weeks on that, and in the end, I’m doing something wrong, because glibc fails to build with my compiler, and I am at a dead end. I can’t see what’s wrong - the problem is that a call to iconv seg faults. I’d still like to get this working, but… after five weeks and now being at a complete dead end with no clues, it’s not obvious what to do.

Once the mailing list is sorted out I can then get on with fixing the SMR design.

I’ve also now been closely reading Dreppers white paper about DSOs. I have a lot of changes to make, because of that.

Once SMR is up and Drepper-changes are done, then I need to figure out what’s happening with the performance of the unbounded/single/single queue and the freelist elimination layer, to implement and test the SMR based freelist, stack and unbouded/many/many queue, modify the ringbuffer to use the improvement in the queue with regard to queue element reuse (which will mean the ringbuffer elements retain physical locality between the ringbuffer element and its queue element), and then I can either release, or implement the full (not add-only) singly-linked list.

2016-11-06

Complexity is oblivion, because you can’t use complex software

Well, I spent all of yesterday trying (again) to install (another) mailing list, and was unable to do so.

Today, I spent the whole day trying to run a server-side script from a web-server, i.e. a CGI script. Likewise, this has proved impractical.

The problem in the latter case reminds me of how HTML and CSS have evolved. In the early days, they were simple and by that accessable. As time passed, HTML became increasingly complex and then CSS came out - and the CSS spec is impenetrable unless you’re a computer scientist.

Similarly, in the early days, web-servers were simple. Anyone could easily and rapidly set them up and get stuff going. Today - it’s hopeless. Apache is a pigs breakfast to configure - I tried it today. Listens by default on IPv6 only and denies all files by default, and the installer is broken and it’s now in a state where I cannot install it again. Lighttpd I abandoned years ago because configuration is a nightmare. Nginx is okay to configure - I had it up and running in sixty seconds - but there’s no CGI support, only FastCGI and SimpleCGI. Python itself does not support FastCGI, only WSGI. What I read is that to get FastCGI running, I need an FastCGI server which talks WSGI to Python.

Seriously, I REALLY, REALLY DON’T FUCKING NEED THAT.

What I need is to be able to call a script from the web-server.

Fuck me, huh? radical!

Without a fucking metric ton of configuration, because configuration on open source projects is the kiss of death. If you have to do any significant config, forget it. Give up before you start - save the time you’d waste discovering it’s fucked.

And I mean, that’s just to run FastCGI, which is already work for me, since my current script is CGI and I’ll need to make it FastCGI.

So these servers, they’re now effectively non-existant, because they’re inaccessable. I can’t use them to do work.

I was reading the FastCGI spec and began to write a C server of my own which would just call system() to run the script I have, but oh Jesus, the FastCGI spec is written by fucking aliens. It’s the most incomprehensible garbage I’ve seen since I looked at the Git docs. It’s also bad C - they provide struct definitions which are invalid, they’re actually psuedocode, but you’d need to know it to know it.

So, I’ve given up. I’m going to run the script I have manually, when I need to run it.

All those guys - Apache, Nginx, Lighttpd - the decades of work which have gone into those projects is totally and utterly useless for me, because I can’t use what they’ve done to do work. I’m running scripts manually instead. Complexoty is death, because it makes software - especially open source, with its profound quality control, documentation and configuration issues - unusable, which is the same as non-existant.

2016-11-05

I never want to see -

“Ensure your password is no longer than [small number] of characters”.

Where “small number” for Dadamail is sixteen.

My normal default passphrase is 25 characters.

2016-10-30

Another weekend fruitlessly trying to build GCC and glibc

Well, I think I made some progress, but I can’t be sure yet.

I’ve stopped trying to build binutils as part of a combined build with GCC. The docs say you can, but they’re wrong, AFAICT. What you have to do (the docs don’t explain this and it took me the first weekend to find this out) is dump the entire contents of binutils into the GCC dir. Problem is, both have an include dir, and they share some files, and the versions differ.

I read that the GCC files take precedence, but when I tried that, it did not build.

I also tried putting the binutils dir actually in the GCC dir (rather than the contents of the binutils dir) and you can make this work with some hackery - you have to make softlinks in the GCC dir to the build results of the binutils dir (which configures and builds just fine - just it’s output is in the wrong place and you only find out you’ve done the wrong thing during the make - this is completely typical of GCC building) and the get wiped during every build stage, and a build script which is generated is built wrongly, it doesn’t know where nm is, so you need to fix it by hand - but the upshot of this binutils is that although it builds, it’s fucked; when you come to make glibc, you get freaky errors about CFI instructions, and there’s NOTHING in google about what causes that problem…

I think what’s happening is maybe the OS native binutils are being used in part during the build - so the only binutils build I’ve made work is a stand-alone build, making binutils on its own, with the OS native compiler, and then installing it in /usr/local and using update-alternatives to get it into use.

That’s been the main advance I made this weekend (two solid twelve hours days - again).

That lets me build glibc up to a point - it ends up complaining it can’t find “crt1.o”. This was a surprise, as I expected glibc wouldn’t be linking binaries, but it does. But it has already at this point made crt1.o (with the GCC and binutils I’ve made) but it’s not seeing them. However, if I tell it about the stuff it’s made (LIBRARY_PATH, LD_LIBRARY_PATH), what I find is the make seems to be calling iconv, which is then core dumping because it’s using the libc shared object the build has just made…

So, obviously, I’m messing it up somehow, but fuck me if I have any idea where. There are no meaningful docs (there is a page or two about buildin glibc; it’s like having one or two pages explaining say Egyptian hieroglyphs) and making pretty much any chance induces a range of new, bizarre, wholly unexpected build errors - and you haven’t even got ANY build going yet. Like adding “–disable-shared”, which you might think would simply things, causes the make to almost immediately fail due to a missing header file… which apparently is not a problem if you ENABLE shared. How does that even make any sense…

However, I can see that glibc builds fine with the OS native compiler and tools, so the problem is down to me somewhere in how I’m building or intalling GCC, and/or how I build glibc. It’s just that these are complex build systems, with no docs and completely meaingless error messages which are I think often massively downstream of the real problem.

I am basically now of the view that the only people who can make GCC and glibc build are the developers on those two projects.

2016-10-26

glibc (the pain continues)

Well, after building GCC, my tolerance for fucked up builds has massively increased.

I’ve built 6.2.0, 6.1.0 and 5.4.0 now and I thought it prudent to get a glibc build passing, in case there’s something amiss with my GCC builds.

glibc build is fucked, or maybe debian is fucked, but it seems - compared to my new high tolerance - to be dead simple; although I’ve yet to get it working and there’s no end of scope for totally fucked up insanity yet.

Problem is that glibc looks at /usr/include/linux/version.h, to know the verison of ther clib kernel headers, and looks like debian despite being on kernel 4.7.0 now is only shippined clib kernel headers for 3.16.36.

Not helpful.

So now off to fucking sort out the fucking fucked up fucking Linux build process once again, and indeed every fucking time I ever use it for anything, ever, amen.

2016-10-25

General update

So, basically two lines of work in the air right now.

First, which is making progress, is building every GCC starting with 4.1.2, first on x64, then ARM32, ARM64 and MIPS32. Once done, then building liblfds with every version of GCC on all those platforms, and making sure test passes and then comparing the benchmarks.

Tell ya somethin’ - GCC 6.x.x takes freaking FOREVER to build. Four core i5 with SSD, takes about two hours.

Second, which is not making much progress, is thinking over the SMR design. I’ve been trying to think up a lock-free epoch based design, which would mean not being forced to process generations sequentially - being able where necessary skip generations, until they became releasable - but I think it’s not possible in any obvious way. The information just can’t be obtained, even more so when thinking in terms of memory barriers only, which depend on the atomic op of the data structure operation to publish.

I see very clearly why now hazard pointers are so good, but I don’t just want to use someone else’s idea - but given the limits imposed by hardware capabilities, it is hard to see any other approach.

I’m still waiting for the PINE64 to arrive, which is a blocker for the next release.

I need also to sort out the mysterious performance behaviour of the unbounded/single/single queue and also try to get the elimination layer on the freelist scaling.

I have also been told (and I think it’s true - I knew, really) that casting away volatile is undefined behaviour. That sucks, because being able to do so gives me the ability to do single-threaded ops on the data structures (have them after such work with a function call flipping back to thread-safe behaviour).

Maybe I can determine behaviour for GCC and clang, and offer it on those compilers.

2016-10-20

Building GCC

I’ve improved and extended the GCC article into a general article on building (curse, spit, etc) GCC.

http://liblfds.org/mediawiki/index.php?title=Building_GCC

Matrix of GCC/dependency release dates, so you can try to figure out which versions to use, general advice, specific advice and currently explicit and tested instructions to build 4.4.3, which I will (God help me) be extending to cover all the versions of GCC which I can manage to make build.

2016-10-17

Today’s installment of GCC building disaster, insanity and catastrophe

GCC docs say this;

“If you also intend to build binutils (either to upgrade an existing installation or for use in place of the corresponding tools of your OS), unpack the binutils distribution either in the same directory or a separate one.”

And then explain about the separate dir case.

So, what do I think they mean? I think they mean put the root binutils dir in the GCC sources, because otherwise I’ll be spaffing the ton of directories in binutils into the GCC source root and that’s nuts.

Guess what?

Nuts is the order of the day.

Now that wouldn’t be too bad - well, except it is - except that if you in fact do what I did, and put binutils into the GCC source dir, GCC WILL FIND IT, CONFIGURE IT AND BUILD IT. It will ONLY complain at the very end, when it will say it can’t find “ar”, because it’s looking now - finally, despite getting it all right up till now - in the wrong directory.

But it gets worse.

You see, now, having finally worked out how this way of building GCC worked, I now simultanously find out IT DOES NOT WORK.

That’s right.

You see, binutils has an include directory, and so does GCC, and they share some files, and the files differ.

I now understand a post I read on Stackoverflow, where the poster was talking about making softlinks to all the binaries made by binutils.

Open Soure : broken out of the box and no docs.

2016-10-16

binutils is death

I’ve spent the day trying to compile old versions of GCC.

GCC itself seems okay - but binutils is a freaking catastrophe.

Binutils is basically fucked. AFAICT, all versions compile with warnings, and all versions have warnings-as-errors turned on.

Remember that I’m building binutils through GCC - just putting the binutils source dir into the GCC source dir and letting GCC do the work.

I think now that –disable-werror passed to the GCC ./configure propagates to the binutils ./configure; this has got me to the point now where the binutils (2.17) build seems to be breaking because… it’s trying to call something called “cc1obj” and it can’t - rightly so, because it’s not there - but I think cc1obj is actually the Objective C compiler

I’ve also found out GCC depends on a couple of external math libraries, which I also need to download and have GCC build, so I need to add them to the version matrix in the docs.

===

So, later…

2.27 will build, but it emits its “ar”, etc, into the a directory which is different to the directory GCC looks for them in.

I guess maybe later GCCs look in the right place, so I should stick to the chronologically matching binutils version (2.17). So I go back to 2.17. I install the Objective-C compiler and the “can’t exec cc1obj” bug is fixed. So binutils is in fact dependent on Objective fucking C. It would be nice if I could find some - ANY - documentation on this. We are however talking Linux, which means broken-out-of-the-box-with-no-docs. They say there’s no guarantees with Linux. Believe me, this isn’t true. There really is a guarantee.

So, Objective C installed and now we’re on to the next problem - which turns out to be that modern gnumake has a built-in rule for the suffix “.m”, and that built-in rule is wrong for the gprof makefile.

I mean, shit. If you’re going to fuck it up, fuck it up REAL GOOD.

===

More later. So I checked the release dates on gnumake. Sure enough, looks like bunutils 2.17 would have been built with 3.80, and 3.80 doesn’t have an implicit rule for “.m”.

So I download 3.80, make it, put it in /usr/local/bin.

Now here’s the thing; which make gives me /usr/local/bin/make.

But “make -v” gives me version 4.0.0 - the make in /usr/bin.

If I rename /usr/bin/make to /usr/bin/make.old, I get a “can’t find file error” when I do “make -v”.

In other words, there is a totally unexpected hidden extra layer masking which make you use. WHY THE FUCK DOES THIS EVEN EXIST?

Why do I even HAVE /local IF THE OS IS GOING TO HARD CODE USE OF /USR/BIN?

FUCKS SAKE.

It’s bullshit enough trying to compile binutils without the operating fucking system pulling shit like this AS WELL.

===

More later.

I think I’ve hit the end of the road with 2.17. I can’t make it compile. I think it probably it acting properly on the .m files, it’s just that one of those files is actually really broken - or anyway, broken maybe so if you somewhat could telepathically know the right config you could fix it, but that means all seven billion humans on planet Earth can’t fix it.

So I decided to have a look at version 2.17a - maybe it’s a bug fix?

Guess fucking what. When you untar it, it untars to “binutils-2.17”, not “binutils-2.17a”, thus over-writing your existing directory. FUCKING MORONS.

If this is what I can expect from binutils, then I am a fucking idiot for trying to make it compile.

===

More more later.

The earlier version I can make build is 2.20.

However, this has the same problem (at least with GCC 4.1.2, assuming GCC version is relevant) of emitting its binaries into a directory which is different to the directory GCC is looking in.

I’ll try a later GCC to see if it makes a difference.

===

So, GCC compiles and binutil compiles. I presume libgmp is compiling too, since it’s in there.

The problem now though is that the GCC docs are fucked. They won’t make.

Turns out the doc files with 4.4.3 (and prolly a bunch of older versions) won’t work with more modern versions of texinfo. Looks like there is a workaround.

Basic lesson here. If your code has a dependency on ANYTHING - A N Y T H I N G - then in a couple of years, your code will not build because of that dependency.

===

Well fuck me - the workaround does fuck all. I’m so surprised. The idea of the workaround is right though - explain to configure there’s no texinfo and not to make docs.

So I’ve uninstalled texinfo. That seems to have enabled me to move on to the next set of errors, which are that libmpfr is missing - which is a valid error, as I’ve not put that library into the GCC source tree.

I need to figure out which version to use though, and it’s bed time now - it was bed time 1.5 hours ago.

2016-10-15

Matrix of release dates for GCC, binutils, glibc and numactl

I spent today figuring out release dates for GCC, binutils, glibc and numactl, going back to the release of GCC 4.1.2, so I can build the appropriate matching versions of these packages, to build liblfds.

This is the result!

http://liblfds.org/mediawiki/index.php?title=Matrix_of_GCC,_glibc,_binutils_and_numactl_release_dates#Introduction

More on building compilers

TUrns out GCC when you build it self-bootstraps, AND if you put a binutils source tree in the root of the GCC source, will build that too!

So that leaves libc. Looks like this might be coming together… …time for some chocolate!

Updatez’n’stuff

So, two lines of work are in progress.

First, setting up every version of GCC, so I can compile, test and benchmark against them all.

Second, Safe Memory Reclamation.

With regard to GCC, as I’ve been progressing with this work, I’ve been learning more about the GCC/compiler eco-system. Stuff I vaguely knew, but which I did not particularly know, and now I am particularly learning about; there are in fact three pieces in this puzzle. There is GCC itself, then there is binutils (which provides the linker and assembler and GCC calls both when compiling C) and then there is libc. Each has their own - long - version history, with lots of releases. A canonical combination might be those versions which were available at the time a given GCC release was made - but this is by no means the and the only possible combination; I think there is a lot of scope for different vesions to be used together.

The script I’m putting together to generate all the GCC versions currently has two steps; build a given release with the local compiler, and then build with that newly build compiler itself, i.e. download 4.1.2, build with the installed GCC (4.9.2), then use the 4.1.2 I now have (which was built with 4.9.2) to build 4.1.2 again - so I have a 4.1.2 which was compiled by 4.1.2.

This means I’m using my local libc (2.19-18, compiled with GCC 4.8.4 on a Linux 3.16.7 system) and my local binutils (2.25).

I don’t actually myself care about libc, because liblfds itself does not use it; nor does libtest or libbenchmark (although they do use libpthread (huh - maybe a fourth piece in the puzzle). Only the test and benchmark veneers use libc, and they use it very lightly - printf and malloc, mainly. Now I think of it they also use libnuma.

I have something of a memory now about now mixing libc versions with different compiler versions. I need to check on this. If it’s true, then I HAVE to recompile libc for every GCC I use. That would then leave the question of whether I can use binutils across GCC versions.

So, basically, pulling on a thread here. I care most about compilation problems, since they are fatal to users, and any user compiling with a given compiler version is likely to be on a coherent system and so will have the appropriate versions of the other libraries and tools. However, I do rather care about getting a sane final compile, so I can benchmark across compiler versions. Actually, I think I also care about libc versions for benchmarking, because I benchmark locking-based mechanisms too.

So, some Googling indicates in theory you should only use a library with the compiler it was compiled with. This is because in theory each compiler has its own ABI. In practise the C ABI is very stable. Nevertheless, I actually want to compile all the different libpthread versions to see how their locking mechanisms vary in performance. (In fact, I’m using GCC 4.9 now with libc compiled by 4.8.4, which looks wrong!)

Also looks like binutils has a relationship to GCC and also libc - certain vesions needed for certain versions.

So; GCC, libc, libnuma, libpthread, binutils.

If I only care about compilation errors, I only need GCC. I don’t even need to bootstrap, really - it’s not very likely there will be compilation problems which occur only if the compiler is compiled with itself.

If I care about benchmarking, then I need the lot.

(More Googling - pthreads is part of libc, apparently - the libc compile I guess produing more than one library).

Moving on - second, Safe Memory Reclamation.

I’ve been trying to get my head around the core implementation of hazard pointers as presented by McKenney, here;

http://queue.acm.org/detail.cfm?id=2488549

The three core functions are provided, and they’re only a few lines of code each.

I’ve seen the white paper, of course, from Magel. For me, it is utterly impenetrable. I understand - or think I understand - the concept of hazard pointers, and the concept is as simple and straightforward as the white paper is impenetrable. I don’t think much of the white paper.

The code itself - I didn’t get it. Probably part of the problem has been it’s out of context; when you’re dealing with memory barriers and so on, you often need to see what all the code is doing, to be able to follow the paths of execution, to see what gets flushed to memory when, and so on.

However, a day or so ago, I had an insight.

The code itself only issues memory barriers, so I couldn’t understand how it could work. When other threads came to check to see if the per-thread hazard pointers were pointing at something, how could they be guaranteed to have seen the values set by other threads?

Then it came to me - or at least, I think it came to me :-)

The code is using the atomic operations performed BY THE DATA STRUCTURE to flush its writes to memory.

In my epoch-based SMR, on the entry to a read section, I’m issuing my own exchange to guarantee my status flag change it pushed to memory. In fact I need to find a way to use the atomic op performed by the data structure to do that job.

Oh - and there’s a third thing.

I read a post by Drepper, about static linking. He said - never do it. Always used shared objects - and he provided arguments which convinced me; indeed, there is one simple argument which is by itself enough. What happens if you have to issue a security fix? with a shared object, you replace the shared object. With static linking, you have to recompile all the dependent programmes.

With this thought in mind, it seems to me now I am going about versioning in the wrong way. When I release a bugfix, I bump the API name prefix (7.1.0 to 7.1.1), i.e. I never in fact release fixes to any already released libraries. That WAS the idea, in fact - but I’m going about it in the wrong way, because this way forces recompilation of the dependent programmes.

2016-10-11

buildtastic

Working on the build system.

Writing a script which downloads every release of GCC from the latest back to 4.1.2, building the version in question and then using that build to build itself again (i.e. so I have the given version of the compiler used to build the given version of the compiler, just as in the official releases).

I’m then going to build, test and benchmark against all versions, for every release.

I need to do the same for clang, and that’s more pressing, because the test app goes into a permanent loop with clang 3.8.0 in one the elimination layer freelist tests. It might be a compiler issue, or it might be an EA bug.

Using multiple compilers is a Bloody Good Thing.

2016-10-09

Got it

I’ve worked out the SMR bug.

Laying in bed at 23:40, taking what I had learned today about the problem and thinking again about the algorithm itself - and there it was. It’s the entry/exit macros for the lock-free sections. They’re reverting the SMR thread state generation counter. I’ve not tested it to prove it, but I am certain.

Have to think how to modify the design now.

What a marvellous and wonderful relief!

clang

I’ve just compiled everything with clang.

Almost effortless - there’s one GCC argument I’m using which is not supported.

I have found however it’s only with the VERY latest clang (2nd Sep 2016 - about a month ago!) that the __atomic* GCC intrinsics are supported. With the version I have with Debian Jessie, 3.8, I only get __sync*. I note the GNUC versions set by clang are 4.1.2, which is exactly right for the __sync* stuff - that’s the version it was introduced. The latest clang (with __atomic*) is 3.9.0.

I’ve not figured out the SMR bug yet. It’s wierd shit. I can read the value before the CAS, get a 1 from the CAS (CAS happened) read the value immediately after and see it’s correct - and then one or two lines later, when I read it again - IN THE SAME THREAD - it’s reverted to the previous value.

As far as I can tell from logging, no other thread has set the value, and also no other thread according to the logic of the code COULD set the value.

I’ve tried with GCC 6.2.0 and I get the same problem. About to try now with clang…

Ah, one other thing, my final comment in the previous post was wrong. I do not need to move on from GCC 4.1.2 - I simply have to write the abstraction layer for the compiler such that I have one for DWCAS for 4.1.2 to 4.6.0 (using inline assembly) and then from 4.6.0 to 4.7.3 I can use __sync* with __int128 and then with 4.7.3 and greater I use __atomic* with __int128.

Either way, I have ARM64 support now, for GCC 4.6.0 and later.

Oh, I also looked at downloading and building all the formally released GCC versions from 4.1.2 onwards. It looks pretty straightforward, except I have to see how much the configure options may have changed over time.

So I expect to end with a script to set up the build environment, which downloads, builds and installs every GCC version. Benchmarking across versions will be very interesting!

2016-10-08

Update

I’ve been working on SMR.

There’s a bug, and it’s maddening, and I’ve been working it and it alone for a week now. I mean, every spare hour, including all Monday (public holiday).

I’ve finally narrowed it down to this a CAS sometimes (after a few seconds of 100% CPU with four cores) seemingly return 1 for success but not actually changing the target. Yes, really.

This seemed to indicate it was my mistake - I had mis-understood __ATOMIC_RELAXED, and the lack of a compiler barrier might be the cause. However, changing over to __ATOMIC_ACQ_REL didn’t fix the problem.

Now I’m googling for GCC bugs - and I found something unrelated but which finally answers an ages old question of mine as to GCC support for 16-byte CAS on x64.

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=46031

The bug is a docs bug, and the plantiff says “the docs don’t say a word about 16 byte CAS being supported”. He’s right, too, they don’t. However, this is only half the problem - the GCC atomic intrinsics work on types, not arrays, so you need a 128 bit type. The GCC docs for this are even worse;

https://gcc.gnu.org/onlinedocs/gcc/_005f_005fint128.html

Reading that, I come away thinking I need native support for 128 bit types. This is as I have now discovered not the case. x64 has __int128 just fine, and with “-march=native” you can compile a 16 byte GCC atomic CAS just fine.

Niiiiiiiiiiiiiiiiiiice. So all the arrays can go away - except - it’s GCC 4.6.0 and later and what about Microsoft? MS do not have a native 128 bit type.

However, even with keeping the arrays, I can use the GCC atomic CAS for DWCAS on x64 and ARM64 - so I can remove the inline assembly on both platforms (the inline assembly which works for x64 but where on ARM64 I’ve had a first pass at creating it, but not yet having an ARM64 to test on, it doesn’t work).

So I could do that… GCC 4.1.2 was released 13th Feb 2007, 4.6.0 was released March 25, 2011. So it would move the minimum compiler version forward by four years.

2016-10-04

Valve and Steam - country change is a one-way process

I was wondering how the Black Mesa mod was getting on - if they’d published Xen yet. I googled, went to their site - no, but Black Mesa is now on Steam, 20 euro.

Sounds alright to me. I liked what they did, I love Half-life, I’d buy it.

I go to Steam. It’s selling for 14.99 GBP, not Euro.

Ah, I think. They think I’m in the UK. I’ll change it to Germany so I can pay in euros.

I change to Germany. No problem.

Then I think - ah, wait. The German version is censored, right? I google. Yes, it is.

Okay, no problem, also 20 euro is a bit more than 15 GBP, I’ll change it back to the UK.

Here’s the punch-line, folks!

I CANNOT CHANGE THE COUNTRY AGAIN.

Steam is telling me they will only accept my country as being Germany (presumably based on IP lookup, so if I was still going to purchase, I’d run Steam through Tor with a UK exit node selected).

Important lesson here. One I have already learned with regard to banks and which I now know I need to apply to other organizations - probably all. NEVER TELL ORGANIZATIONS WHERE YOU LIVE. In fact, in general, tell them NOTHING. If you tell a bank you’re in a different country, for example, they will usually go bonkers in some bizzare and totally crazy ways - ways which you could never predict, because they make no sense whatsoever. Just don’t do it.

So I have a UK accout, I want to buy the UK version, etc, etc, etc - buttttttttttttttttttt no. Steam and Valve know better! I told them ONCE I live in Germany, so it MUST BE TRUE. And now I can only change it back when I physically return to the UK and a nice UK IP address.

Reminds me of Skype. One day years ago the money I had in the account disappeared. Only about five quid. I contacted Skype and said I’ve change my password, but there’s been fraud, what do you do?

Their reply was tha they had locked my account until I change my password and provided a copy of my passport or ID to prove who I am (facepalm) and that since it was fraud, it was my fault, not theirs, and they do not give refunds.

So because I said it was fraud, it was absolutely and definitely fraud. And not say, a bug in their accounting software. Total unmitigated fuckwits. This was of course also roughly around the time they stopped being peer-to-peer and became server based, so the NSA could record all the calls, so I had what was probably a lucky escape, as I - as you can imagine given their response - certainly never went to the risk and trouble of sending them a copy of my ID after they needlessly locked the account. In fact I read about that time when I was googling of people who’d had auto-topup on, and had lost their sizeable chunks of their current accounts to fraud. I had never given my password to anyone, of course - it was either a brute force attack which Skype never picked up on, or Skype were hacked.

Back to Valve being fuckwits. I mean, I understand it, I think - I’m sure this is forced on them by Governments. But it means Valve/Steam are now in the catagory of “major bank”, i.e. major fucking morons due to utterly insane behviour from totally unexpected causes, so you can’t trust them with anything. Achievement unlocked.

IN other news, I’m still waiting for my volume unlocked iPod shuffle from the USA, to get around the EU regulation which sharply limits maximum volume.

Pertinent aside : I pay about 6000 euros a month, in total, to the German State, to live here. This is part of what I get.

2016-10-02

SMR update

I’ve pinned down the SMR bug.

A thread would miss an SMR generation and by that end up two generations behind, and the code wasn’t coping with this.

Performance hit from SMR is about 50%.

This is appalling - I suspect hazard pointers are about free - but hazard pointers are someone elses invention and I’d need permission to use them. The SMR I have now is purely my own work.

First unbounded/single/single queue benchmark

Disappointing.

liblfds720_queue_uss_enqueue_and_dequeue_Core i5

Well, maybe disappointing.

The benchmark has two threads (naturally enough) and we see when they run on seperate physical cores we get about 8.8m ops (the producer thread enqueues 8.8m elements, the consumer thread dequeues 8.8m elements).

This is about the same as the unbounded/many/many running two threads on two physical cores (although the benchmark there is a bit different - there’s one queue, and each thread does an enqueue followed by a dequeue, so one op is an enqueue and a dequeue, and there we get about 5m ops on one core and about 8m on the other.

What I’m thinking though is that single/single will scale, where many/many does not. Many/many are the core counts go up dives into a deep hole in the ground. I think single/single might scale linearly - there will be many queues, inherently, but each one will still manage the 8.8m no matter how many of them are running.

The benchmark needs more enhancement to test this though.

M&S queue API improvement - solves the consequences of the dummy element awkwardnesses

I’ve made a small but important improvement to the unbounded/many/many and unbounded/single/single queue APIs.

The queue elements now have a user_state, which you can get and set.

Those of you (both of you ;-) who have used the unbounded/many/many queue (the single/single is in 7.2.0, which isn’t out yet) will know that the dummy element is a pain in the ass.

When you dequeue, you get a queue element and you get a key/value pair. Problem is, the queue element you’re given is what was the dummy element in the queue; you can reuse it, for sure, but often what you’ll want to do now is put it on a freelist, and for that you need a freelist element. So you may well have defined a struct of your own which is a queue element and a freelist element - only now you have a problem; you just dequeued, fine, you have a queue element, fine, you have a value, fine, the value is your struct with the freelist element and queue element, fine… only it’s not fine. The struct of yours which you have is NOT for the queue element you’ve been handed by the dequeue call - it’s for the next element. So you can use the freelist element in there, but now you’re physically separating the freelist element and the queue element it’s putting on the freelist. This is bad for performance - you get a cache line miss.

Now though, we have a solution. We set the user state for the queue element to be the struct it is in. Bingo. We dequeue, we get the value (which is what we need for the queue to be correct) but we ALSO get back the correct freelist/queue struct for the queue element the dequeue function just gave us.

Problem solved. I need to update the ringbuffer now with this, too, it’ll improve performance - shame there’s no benchmark yet for the ringbuffer; I might need to make one now to see how much difference this makes.

2016-09-27

API design experimentation

I’ve been toying with the freelist header file, seeing how to present two ideas I’ve had for a long time.

First is to add support for single-threaded use. This means you can flip the freelist into singlethreaded mode, from which point onwards only the thread which made the flip can use the freelist, until that thread flips it back to multithreaded mode, and then everyone else can join in again.

Singlethreaded mode is at least an order of magnitude faster than multithreaded mode used by a single thread; if you’re doing performance work, you simply cannot use a lock-free freelist in a single thread - it’s insane - but currently you’d have to, because if you did build up a single-threaded freelist, how would you get those elements into the lock-free freelist? (think also about stacks, queues, etc)

It also means the freelist can in general be used as a single-threaded freelist, which is often required. It also then provides support for scenarios like one thread building up a freelist and then throwing it over to a set of other threads (okay - not something you’d do so much with a freelist, but imagine a stack, or queue, etc, all of which should get the same treatment).

Providing a fully single-threaded mode provides the necessary functionality for the benchmark programme’s benchmark for the unbounded single/single queue.

Second is being able to form freelist elements up into a chain of freelist elements, and then pushing the chain to the freelist, where that push regardless of the chain length occurs as a single atomic operation. So we’re offering write combining in the API.

2016-09-25

I’ve done some actual like work!

Shock, horror, I’ve done some real work.

For two months now I’ve been working mainly on the re-write of a back-end system at work. It’s taken forever because it’s an office job, rather than working from home. It should have taken a week.

So this weekend I’ve been working on getting the benchmark back into operation. I’ve needed to modify the code so that the thread functions are stored on a per-thread basis, rather than on a per-benchmark basis, because I’ve introduced a benchmark for a single/single data structure - so I have now an enqueue thread and a dequeue thread, i.e. different thread functions - whereas before the threads all ran the same function.

I’ve done the code for this now (I can make it compile now, but I haven’t just yet) but it’s become clear I now need a single threaded freelist, so the enqueue thread in the queue callback function where it liberates emptied queue elements from the queue can return those elements to the freelist for the main queue thread to use.

This lines up with my long, long time wish to add single threaded functionality in general to the data structures. The reason for this is that it permits amalgamation of operations by a single thread - e.e. if a thread has a number of elements to push, it can combine them into a single local chain, and then push that - only one atomic operation.

In general, elimination (e.g. a push and a pop cancel each other out) removes load from the lock-free data structure, and combination acts to reduce load. Both are desireable.

So when this is done I’ll have a benchmark and so a gunplot for the unbounded, single reader/single writer queue. THis is an important data structure, because its performance is so very great.

2016-08-24

Pasting with styling

When I use a plain text editor, and I paste, I get text.

When I use Word, AbiWord, Google (at work only, don’t worry, I’ve not gone crazy), when I paste, I always get styling. The font is specified, bold, font size, etc.

Do you know how often I’ve wanted paste with styling, rather than just the text?

I mean, in like, the last twenty years since people starting doing this shit?

NOT ONCE.

NOT ONE FUCKING TIME, EVER.

I’m not kidding. In my entire life, I have never, NOT ONCE, needed or wanted this, and so EVERY TIME I’ve needed to paste, I’ve had to go through this farcical song and dance via a text editor. Often I then have a second fucking song and dance trying to get the stupid fucking WYSIWYG editor to also STOP USING THE FORMATTING FROM THE PASTE, which it desperately doesn’t want to do…

You guys who do this by default? you’re IDIOTS. Please stop being involved in any software which has a user interface.

Disconnected

I’ve just called one of the two Dublin registry offices, as I’m trying now to chase up the birth certificate of what I believe is an Irish grandfather.

So I phone.

Shortish message, then “press 0 for all other enquiries”.

I press 0.

I wait.

After a while -

“We could not connect you. We are putting you through to the operator. This extention does not exist. There is no mailbox for this extention.”

Followed by disconnection.

facepalm

2016-08-10

64 bit ARM

Turns out it is impossible to run a 64-bit kernel on a Pi3 because the necessary firmware has not been released by the Foundation.

I have now ordered a PINE64, which can run a 64-bit kernel. Two week lead time, and then postage from the US, so probably most of a month till it arrives.

C’est la vie.

2016-08-04

Raspberry Pi 3 ordered

ARM64 platform.

No 64-bit Raspbian yet though - I’ll need to install full-fat Fedora, with a monitor and keyboard, and then configure it to headless.

2016-07-31

SMR Update

The SMR versions of the freelist, queue (unbounded many many) and stack now compile.

I have to make tests for them now, from the non-SMR test code - that’s quite a lot of work.

I’m going to make a benchmark for the freelist first, I really want to see how much impact SMR has.

The way I’ve implemented SMR involved one CAS per operation, which is a lot of work. The freelist however now only needs CAS, not DWCAS, so that gives a 50% or so performance improvement. So we’re now two CAS rather than one DWCAS - but we also have the overhead of the SMR clean/release work.

I also need to fix the freelist - which is to say, make the elimination layer perform as I think it should, rather than how it is!

2016-07-30

Update

Currently adding back in the SMR versions of freelist, queue (unbounded, many, many) and stack.

An observation by a colleague regarding IA64 made me realised that the IA64 instruction which compares one word but swaps two is enough for the data structures which require contious double-word compare-and-swap. You simply compare the counter. I’ll be making the necessary changes to support this. It is unfortunate this comes after IA64 has basically died!

2016-07-26

SMR is back

SMR has had final debugging performed and the tests pass.

2016-07-21

Always provide an email address with your contact form

Advice to web-site developers.

If you are going to provide a form for people to contact you, always also provide an email address, because - believe it or not - YOU MAY IN FACT HAVE FUCKED UP THE FORM. In fact, most of you have. I speak from experience.

I have this site -> https://www.high5.com/kontakt/ -> currently in mind.

I’ve spent the last fucking twenty minutes filling in that fucking form again and again. It works about 50% of the time. I’m actually trying to pay, and I can’t, because their site thinks my Dutch and Italian IBANs are invalid. So I used the form - hit submit - it clears. No message on screen, no email, nothing.

So I send them a message to suggest they do provide some feedback on successful submission, because most on-line forms are broken, so I more or less have to assume their form is broken too, and my question was not sent.

This time - lo and behold - there’s a send confirmation.

Fucks sake. I need to pay now, so I can get to the gym. I do not need a couple of fucking days delay while I eventually figure out their fucking form is broken.

Then I discover there’s a silent character limit on the question text. You find out because you can’t type any more. Fucking idiots, time two. First for the limit, second for letting people waste their fucking time typing a meaningful message to discover it. ANYONE who does this need a fucking brain surgeon - to repair the lobotomy they clearly already had.

2016-07-16

Using glassdoor.com to select manufacturers when buying a product

I’ve just ordered a little switch, to go with the wireless router.

What I came to pick a switch, I was as is usual overwhelmed - there are so many products, so many manufacturers, how do you choose?

Normally I google for reviews, read a bunch, and that way come to make a choice - although often I find the product I want is very hard to find. Just seems to work out that way.

However, this time, I hit upon a new method; I started using glassdoor.com to look up the employee review scores for the given company. I figure in general the happier employees are, the better run the company, and the better the product.

Turns out a LOT of the ethernet switch manufacturers have really bad scores - glassdoor rates out of 5.0, and most were 2.x - which is really not good. Cisco were the best, at 3.8 out of 5.0. So I looked into their product range, and found a very suitable product - very small, physically, lightweight, five ports, dead cheap - like 25 euro. Absolutely perfect.

2016-07-14

Amazon rule because everyone else sucks at order forms

I hate, I mean I REALLY hate, ordering on-line.

I have just spent 15 very tedious minutes filling in form after form, looking up address after address, card details, fake phone number (mandatory field for something I don’t have, remember to remove all spaces because half the time forms object to spaces - which you only find out when you submit), replace the “ß” in the street name with “ss” because no clue if they support unicode, checking data entered, guessing I should use my USD card because it isn’t clear yet what Paypal will actually bill me in - I need to enter all the addresses to find this out, and if I’m wrong, go back to square one - etc, etc, etc - only to be taken to Paypal, where I had to enter the card address again, AND THEN FOUND THE SHIPPING ADDRESS WAS BROKEN BECAUSE IT NOW OMITTED THE COMPANY NAME. My name and my workplace address are not enough, because there are a ton of companies in the building. Paypal has no option to edit the shipping address.

So I had to abort, which brings me back to the very start - with all forms cleared.

This time, repeating the lot, I need to ensure I have the company name in the address field, in addition to the deadly misleading extra “company name” field.

This I have to say is par for the course. The main reason I order from Amazon whenever I can is to avoid this problem. Sadly, the product I want to order from Amazon is not shipped to Germany - so I have to order direct from the supplier.

2016-07-12

Washing Machines

Srsly.

I have for many years now found washing machines problematic. This is a partial list of problems…

  1. washing machine floods the kitchen sink, and so the kitchen
  2. washing machine blocks, and so after filling, never drains (my dressing gown and towel were locked in there for a week)
  3. washing machine has no “start” button, so you put stuff in, select the programme and temperature… …and nothing happens, so you take your stuff out (eventually - when the damn thing decides after some random but always long interval that you can now unlock the door, even though there is no water in there and never was any water in there)
  4. washing machine runs, but does not use water

All I want in a washing machine is that it starts, uses water, and drains.

IS IT SO DIFFICULT?!?!?!?!?!?!

AirBnB

AirBnB in Berlin is a catastrophe. It’s completely impossible.

I have never had so many declines, and they all happen without any message. You select dates, ask if available, and get declined. No explanations.

I just tried to book a room - just now. I had a decline within a MINUTE. No explanation. I tried booking another place last night. Also declined, no explanation.

So, I have 14 our of 14 positive recommendations on my profile. I’m pretty sure I don’t smell. What gives? I have no idea - but I can see that AirBnB isn’t functioning.

2016-07-07

Germans seem to have trouble with negotiation

So, I’ve been using AirBnB (spit, etc) to try to find a place in Berlin. It’s unlikely to work, city rent controls and direct anti-AirBnB legislation, but if it could, it’d be super useful.

So I’ve been trying.

What I’m finding is this : Germans (German culture, that is) seems to be totally unable to handle negotiation. If you attempt to negotiation, i.e. say anything which argues for a change in the deal, there is no response and the other party leaves.

They don’t talk, don’t say no, it’s just - you tried to negotiate, so the deal is off. They instantly stop responding and close down any open booking.

This is wholly and utterly different to every other country - and that’s a few now - where I’ve AirBnBed.

2016-07-06

Word of warning re AirBnB exchange rates

AirBnB are doing the Ryanair trick - silently ripping people off on exchange rates.

On 1154 euro, my bank charges about 10 USD to convert to USD.

AirBnB are charging about 50 USD.

AFAICT it’s not optional (it is on Ryanair, so AirBnB are actually worse).

2016-07-03

AirBnB search results seem borked

I’m searching on AirBnB for a place in Berlin.

Thing is this : yesterday, I found a place. Didn’t think that much of it, but there’s very little choice, so I bookedmarked it. I didn’t contact the owner.

Today when I search, it’s not there.

If I go to the bookmark, put my dates in, it’s there.

This is also true for another property I looked at and contacted yesterday.

In short : AirBnB search results, on the face of it, are at least partially fucked. They simply are not showing matching results.

In other news, AirBnB owner pricing, Jesus. People have no clue how to price their homes. I mean, I understand, how can they know, really, except maybe by looking at the non-AirBnB market, seeing normal prices, and then adding some extra to cover partial occupancy.

But I mean - seriously - people are not going ot pay 6000 euro a month FOR A ROOM. People are not going to pay 700 euro a month FOR ONE BED IN A SHARED ROOM WITH TWO OTHER PEOPLE. Come on, FFS. Get a clue. (Or fix your typing errors? should it have been 600 and 70, respectively?)

Berlin in fact a year ago introduced rent controls. People seem to be happy that rent prices have gone down. People are also fucking stupid. If you force down prices, you force down supply. Prices have indeed gone down - thus so has supply - which means the amount of unmet demand HAS RISEN. More and more people CANNOT GET A PLACE AT ALL. The number of people turning up to view every place which is available gets higher and higher.

I’m finding in AirBnB prices are much higher - about 2x - that of the local market. This reflects the real price, rather than the price the State forces owners to offer unless they want to go to jail. In fact, the political parties are forcing owners to make involuntary contributions to their electoral success.

Another aspect of this is that salaries are priced to rent controlled rents, which makes taking an AirBnB prohibitively expensive. Additionally, the city has passed a law which states that people can only offer, without obtaining a permit, rooms on AirBnB if it is 50% of less of their own property. Anything more, or rooms not in your own property, or a property of your own which you wish to let in full - you need to apply for and be granted a permit; and I have no idea what that involves, how sane it is, how much it costs, if there’s a limit on how many are granted, etc. (I think I read something like the city intends to refuse almost all of them).

As an aside, there’s another peculiar things going on with AirBnB. Firstly, AirBnB appear superficially to have lots of properties - try searching without dates, you’ll see so much stuff.

However, if you actually look at any of them, almost all of them are completely unavailable. Their calendars are fully booked forever. Perhaps they’re on AirBnB, but the owners only rent them out once in a long while. However, when you search, AirBnB always says something like “only 1% of all listings are available! BOOK NOW!!!!” I think that 1% (or whatever number it comes ot be) is including all these properties which are not and would never be available to you, i.e. completely and utterly fake and there simply to deceive you into renting.

I’ve also run into a proper with Iceweasel, the Firefox rebrand for Debian. Apart from the usual appalling performance problems Firefox runs into when it’s been running for more than ten minutes with Google Maps and AirBnB (I’m not even kidding), what I’ve found is that after a little while, I cannot correctly type in text areas any more. Typing producing sometimes the letter I’ve pressed, sometimes a semi-random letter, usually a “h” or an “r”. Seriously. Backspace produces an “r”.

I have to compose anything I wish to type in a text editor, and then, with some care, ctrl-a and delete (doesn’t always work; sometimes produces a “h”) anything I’ve typed so far and replace it with my message.

THis of course is an ongoing theme in my life : software simply doesn’t work. Even the most basic, fundamental, jesus-christ-SURELY-you-cannot-get-THIS-wrong functionality is broken.

Turning back to how Berlin is fucking up its rental market (and so, indirectly, its labour market) we see in addition that tenants have massive protection under law. The result of this is that landlords - naturally enough - are absolutely paranoid about who they let to. Three months deposit is the norm, tons of documentation, proof of income, good character, you name it.

The result is that if you’re an outsider, you cannot rent from an owner. It is impossible for you to meet the criteria. Also, even if you’re an insider, God help you if you’re less than perfect…

To protect you as a tenant, we had to make so it so you could not be a tenant.

As an outsider, you must sub-let. Problem with this is there’s so much unmet demand (see rent controls) that every letting has tons of people wanting it - so the subletter wants to meet them all, see who he likes, perhaps who is offering the best extras on the side (“that huge box of chocolate with 500 euros in is for me? how kind!”), and then pick.

If you’re an outsider, outside of the city, can’t turn up? forget it. It is actually impossible for you to sub-let.

This leaves, finally, renting a room, and even this faces the same - albeit less intense - problem of taking a place cold.

Great, huh? Berlin. AirBnB has been fucked, you can’t rent a place directly, sub-letting is problematic and renting a room very difficult. The labour market is of course strangled; people can’t get in.

This is however pretty much normal for most European cities.

Qsort

Would you believe after 25 years of C programming, I am now finally implementing (and so having to understand) qsort :-)

The Standard Llibrary has done well - although at the same time, where their implementation always has been available, I’ve never learned this algorithm.

OTOH, it was a choice. I could have chosen to learn it at any time; I simply never needed to.

(And where’s the first place I’ll NEVER go to find out about quick sort? the wikipedia page, of course! ALL of their algorithm pages are UTTERLY AWFUL OMG I DON’T EVEN. I have never seen such appalling failures - they aren’t even attempts to explain - all they are, are literal descriptions, in the most abstruse, alien and unfriendly possible ways, and so are useful and only useful to people who already know the algorithm, where those people have no need whatsoever to EVER visit the page. Cataclysmically catastrophic).

2016-06-29

Update

I always knew AirBnB was weird.

Now I really know.

If I MOVE THE MAP, the pricing of an apartment changes, from 1147 to 1151.

In other news, I believe one of my grandparents was Irish and so through him I will be able to claim Irisih citizenship, which will get me back in the EU, thank Christ.

I’ve not touched the library for a bit - been making a web-site for a friend.

My current thought is to get bsearch and qsort out of test, so it’s bare C89 (plus threads) and get SMR in and debugged (and maybe also an add+delete singly linked list). The unbounded single/single queue is in already. Then publish 7.2.0.

2016-06-18

unbounded, single/single queue implemented

Seems to work.

Tests pass. Need to do more test though.

It’s the M&S queue, with atomics removed, and it’s “odd” in that although the dequeuer gets key/value pairs as he dequeues, it’s actually the enqueue thread which gets the dequeued queue elements out of the queue for reuse/free (when you call enqueue, or if you explicitly flush - there’s a function call for it) the emptied (i.e. dequeued) queue elements, which are at that point still in the queue, come back to the user via a callback).

Samba update is blocking

I’ve issued a full package upgrade of my Linux system through Synaptic Package Manager.

It’s been taking a LONG time.

Eventually, I go over to it and expand the “details” option.

The (supposedly) automated Samba installer displays a help text which requires the user to scroll to the end and hit “q”. It’s blocked tne entire update process.

FACEPALM

2016-06-05

Unbounded, single producer, single consumer queue idea

Chatting with a friend online about queue use and an idea struct me.

There is a well known bounded single producer single consumer queue. The Linux kernel uses it, there’s an implementation in liblfds.

I think thought it should be possible to make an unbounded single producer single consumer queue.

What’s odd about it is that the writer thread is the thread which is responsible for removing dequeued elements from the queue.

So we have a normal looking queue, elements with next pointers, an enqueue and a dequeue pointer.

The reader thread, once it’s done with an element, marks the element as read - it is however the only write to that flag. The writer is the only reader from that flag.

So we imagine the queue is empty, enqueue and dequeue both NULL. Writer writes; he is given an element (no memory allocations, remember), he sets the user data, sets next to NULL, store barrier, modifies the dequeue pointer.

Reader thread later comes to read, we assume the writes have propogated (we’ll see the user data first, so we’re safe), we read the dequeue pointer, get the element, get the user data, now set the “done with it” flag.

The writer when he nexts writes adds the element as before, but also scans from the dequeue pointer, finding dequeued elements and unlinking them.

Have to work through all the details to see if it can work.

2016-06-04

Mediawiki / Firefox hell

I’m finally fixing up the “White Papers” page on the wiki.

It is, frankly, a descent into hell.

The problem is that the filenames for the white papers are like this;

[Counter] - [Aspnes, Herlihy, Shavit] - Counting Networks.pdf

See those square backets? and the spaces?

It’s like I’ve just tapped directly into every combined neurotic design flaw of Medawiki and Firefox.

Mediawiki can’t have square brackes in URLs, or spaces. Okay, I’ll URL encode. Doesn’t work. Mediakwiki does not recognize a URL encoded string as a URL - not unless it begins with the “http://” - unencoded.

Firefox doesn’t recognize either the fully encoded URL, or the bastardized version beginning with “http://”.

It turns out that URL encoding seems to have changed?

Using http://meyerweb.com/eric/tools/dencoder/ gives this;

http%3A%2F%2Fwww.liblfds.org%2Fdownloads%2Fwhite%20papers%2F%5BCounter%5D%20-%20%5BAspnes%2C%20Herlihy%2C%20Shavit%5D%20-%20Counting%20Networks.pdf

It doesn’t work. Paste that into Firefox and it’ll prepend “http://” (FOR CHRISTS SAKE DON’T DO THAT) and then tell you it can’t find the server “http%3A%2F%2Fwww.liblfds.org%2Fdownloads%2Fwhite%20papers%2F%5BCounter%5D%20-%20%5BAspnes%2C%20Herlihy%2C%20Shavit%5D%20-%20Counting%20Networks.pdf”. Genius. facepalm.

Bastardizing it in the way Medaiwiki requires (unencoded “http://”) makes no difference.

However, I guessed that if I enter the original unencoded URL into Firefox, if I copy’n’pasted from its URL bar I’d get the encoded version - and I do, which is also FACEPALM, because what you’re SEEING is not what you’re GETTING. WRONG.

So Firefox gives me this;

http://www.liblfds.org/downloads/white%20papers/%5BCounter%5D%20-%20%5BAspnes,%20Herlihy,%20Shavit%5D%20-%20Counting%20Networks.pdf

Firefox seems to not encode the path, not encode commas, but does encode square brackets and spaces.

So, like, what the HELL? I thought URL encoding was URL encoding. All the reserved characters became percent encoded and that was it.

So, like, what the hell is going on? Multiple variants of URL encoding? the HELL? if that’s so, can you imagine anything more likely to lead to disaster?

So it’s taken an hour to get a link working in a mediawiki page. I’m also wondering if it’ll even work in other browsers. Maybe Firefox has it’s own unique bizzare version of URL encoding.

2016-05-31

7.1.0 is out

Finally, I can get some sleep :-)

And a haircut.

Some exercise!

A social life.

And I can start applying for jobs.

2016-05-28

benchmarking earlier liblfds releases

So, problem.

Consider - as time goes by, liblfds supports more platforms. 7.1.0 supports MIPS. 6.1.1 did not. If benchmark benchmarks all version of liblfds, well, then it will try to include the earlier version’s header file and it will try to link to its library.

The header file is fine - it will work, and it can be modified (I can make bugfix releases for earlier versions) to make public which data structures are available. The library file isn’t fine, because right now it has to be hard coded in the makefile…!

It’s the libnuma problem all over again. With libnuma, I have a second build type. Adopting that solution for liblfds versions would mean one of two things, depending on whether the assumption is made platform support only increases over time. If as releases go by, platform support extends, then we’d end up with one extra build variant per release, i.e.;

gcc_gnumake_liblfds611_liblfds700_liblfds711 gcc_gnumake_liblfds700_liblfds711 gcc_gnumake_liblfds711

This would be doubled, because of libnuma.

However, if platform support can simply vary, then this approach becomes awkward.

I am however strongly inclined to the view it will only increase over time.

However however, this then leaves the user with what on the face of it is an awkward problem - when the user comes to build, he sees these build variant directories, and to select the correct variant, he has to know what releases of liblfds he can build.

OTOH that’s not so hard - he can just try to build them, and see if they build okay.

Update / benchmarking 7.0.0

Documentation first-pass finished.

No missing articles.

I need to fix up the “enum flag” type use in the codebase - there’s a type in liblfds itself, and another in the test_and_benchmark code, and they’re intermixed in that code. It needs to be one or the other.

Changing subject, the code for each release of liblfds is wholly indpendent and occupies different namespaces (by means of prefixes to the names of all public entities). As such, every version of the library can be compiled against and linked to, concurrently.

As such, the benchmark app can benchmark the different versions of the same data structure.

I’ve just spent an hour adding in a benchmark for the 7.0.0 btree!

The performance is really bad, though - and I never remembered it being like this; it was also pretty good. So I’m wondering if I’ve flubbed up the implementation somewhere along the line.

2016-05-27

Update

Public APIs which are too complex or too big to be documented are totally worthless.

When you come to write your docs, you have to rewrite all that code.

I’ve spent the last half-day rewriting the libbenchmark abstraction API for enumerating processer/memory topology.

The problem has been that the function was directly using a bunch of topology_node API stuff, which then would all needed to be documented.

I’ve written a small set of helper functions, which mask all of the topology_node stuff.

2016-05-26

Getting there!

One more set of API function docs to write - about a dozen or so pages.

Then a bunch of pre-release prep, then release!

2016-05-25

Update

So, read the spec, return with an expression from void is a warning/error.

I fixed it by doing something I’ve thought for quite a while I should do - not use brackets with return. It’s not a function, don’t use brackets. Turns out now to matter, since it allows me to mask windows kernel threads in a readable way.

So, the code now compiles on WDK, all platforms.

This means I now have successful compilation on all platforms with all build files sets - all twenty-one of them…!

I"m not going to go round for the second pass and make sure everything still compiles on everything else until I’ve done the docs, since they will prolly lead to changes.

I’m now writing the docs.

Learned something new

So, Windows kernel has no return type for its thread functions.

To abstract this, I have a macro, which is for Windows kernel defined like this;

#define LIBSHARED_THREAD_RETURN_TYPE( return_value )

So at the end of the thread function when I come to return, I have this;

return( LIBSHARED_THREAD_RETURN_TYPE(return_value) );

(The type of return_value is “int” for Windows kernel, just so the assignments in the code compile).

So the code ends up post-pre-processor like this;

return();

Which I thought would be fine. Return is not a function call, it’s a keyword, so the brackets just disappear.

Guess what?

Of COURSE it doesn’t work.

The compiler doesn’t like it. “error C2059: syntax error : ‘)’”

2016-05-24

Linux kernel source code

Just found out Linux kernel source code base has lower case #defines.

I found out ’cause they’re colliding with my VARIABLE NAMES…

Linux may not be the super-awesome-power code base we’re thinking it is =-)

Going nuts

Been working non-stop, mininal sleep, to get the release out.

There’s SO MUCH WORK to get builds working across what in fact in the end is 17 different sets of build files, which run on six different plaforms, especially when you’ve largely rewritten most of them.

I in fact hadn’t consciously realised it, but I had not implemented some of the abstraction layers - I’ve just implemented (really a re-implementation, mainly, I’d done a lot of in a long time ago, but removed the code since then) the Windows kernel abstraction layer and I’ve just right now been implementing the Linux kernel abstraction layer for libshared…

…and, now, finally, after all this time, I have discovered the Linux kernel does not offer a “wait for thread to terminate” function, which totally and utterly fucks the entire abstraction mechanism for threads.

truly -epic- facepalm

Linux does has a function to create threads in the kernel and to put them on a given node and CPU, but you have to manually implement signalling between the thread(s) and the issuing thread, to sync between them.

This means I now need to implement this style of mechanism across all platforms, which means rewriting a metric fucking ton of code. It also means making an abstraction layer for an inter-thread communication mechanism. Jesus, headache, headache, headache. WHY NOT JUST OFFER WAIT-ON-THREAD-HANDLE FFS EVERYONE ELSE DOES.

It also means 7.1.0 is going to be released without Linux kernel support for test and benchmark. You make your choices, you get what you get. Linux made its choice, and so it doesn’t get test and benchmark.

2016-05-23

makefile whack-a-mole

I finally found the gnumake recommended practises documentation and I’ve been making the makefiles comformant.

When you have fourteen makefiles, over four platforms, it takes a while to get all of them happy everywhere…

2016-05-21

Update

Wierd shit be going down.

So, we have the lock-free freelist.

Fine.

Performs like crap. The problem is contention. Threads keep running into each other.

backoff[0] = 371608 backoff[1] = 1798761 backoff[2] = 212273 backoff[3] = 401016 backoff[4] = 92713 backoff[5] = 265962 backoff[6] = 59579 backoff[7] = 96049 backoff[8] = 35300 backoff[9] = 58019

That list there is for four threads (two cores), on the benchmark. The index is how many times a given push operation collided, before it managed to succeed. So 371,608 operations went through without colliding - then 1,798,761 had one collisions, 213,273 had three, etc.

So We add backoff. We look at index 0 and index 1, and aim for a ratio of 100:1, adjusting the backoff up or down accordingly.

Woohoo! 5x improvement. The collision array looks like this now;

backoff[0] = 70565880 backoff[1] = 391154 backoff[2] = 7050 backoff[3] = 663 backoff[4] = 208 backoff[5] = 51 backoff[6] = 22 backoff[7] = 11 backoff[8] = 16 backoff[9] = 6

Notice first how much higher the numbers are (we’re getting a lot more done) and of course notice how heavily skewed we are now to index 0.

Great.

But we want to improvement performance some more. The basic problem now is every thread is trying to hit the freelist head point. So we add an elimination layer. Basically, it’s a set of cache lines, which are filled with freelist element pointers, and when we come to push, we randomly choose a line and then look for a free slot (NULL) and if we find one, atomic exchange our element into that slot and we’re done; and popping, we randomly pick a line and search for a non-NULL and if we fine one, we’re done.

This means we’re now distributing the freelist memory load over multiple cache lines, not just the one.

So what happens when we have this?

Well we get this;

backoff[0] = 3674707 backoff[1] = 334781 backoff[2] = 8646 backoff[3] = 3982 backoff[4] = 2058 backoff[5] = 1046 backoff[6] = 465 backoff[7] = 204 backoff[8] = 64 backoff[9] = 20

Index 0 has gone down by about a factor of 20. We’re REALLY offloading from the freelist…

…but what’s wierd, really freakingly wierd, is that index 1 is basically UNCHANGED.

And this is throwing the backoff autotuner off, because it’s trying to maintain a 100:1 ratio for backoff. So now it’s continually trying to raise the backoff metric.

I do not understand why index 1 is unchanged.

Index 2 is unchanged as well, but after that, we see big (5x, 10x) drops.

2016-05-19

Freelist scaling

I added an elimination layer in front of the freelist.

Works like this; you have an array of freelist element pointers. Cache line aligned, and you have n cache lines worth of array. All these pointers start NULL.

When a thread come to push, it randomly selects one of the cache lines and scans it from left to right. The first NULL it finds, it atomic exchanges the pointer to the freelist element it wants to push. If the original value returned by the exchange is NULL, that’s it! the pusher can make a run for it. No need to hit the main freelist at all. If the original value of the exchange is actually a pointer, another pusher exchanged onto that pointer before us; so we’ve got rid of our element, but only to get hold of someone elses, so we’re not done - we keep scanning the cache line of pointers to try to find another NULL.

If we can’t find a NULL, then we push to the main freelist as normal.

For popping, when a thread comes to pop, it likewise randomly selects a line from the array and scans left to right, looking for non-NULL values. If it finds one, it tries to exchange with NULL. If the original value returned is a pointer, then bingo! the thread has got hold of an available freelist element. If the original value is a NULL, another popper grabbed this element before us and so we keep canning. If we can’t find a non-NULL, then we pop as normal from the main freelist.

So the upshot of all this is that we offload memory accesses from the single freelist head pointer, over a range of cache lines - as many or as few as we want - in the elimination layer.

So I thought this would help a lot.

It’s so far a big fat non-event. It’s helped a bit, I dunno, maybe 10%, something like that? but I was expecting far, far more.

I’m trying to figure out why this is happening. One thought is the absence of back-off. Obviously we expect a lot of cache line contention between threads, but if there are enough cache lines in the elimination array, compared to the number of threads, I’m thinking it shouldn’t be that much of a problem…

Experimentation continues.

2016-05-17

Progress

Benchmark (and so topology) works on Win32 with NUMA.

Need to run it on a big Linux machine now which actually has more than one NUMA node.

GetLogicalProcessorInformation / GetLogicalProcessorInformationEx

I think I’ve figured it out.

VirtualBox is not at fault, if I’m right.

The original version of this function, GetLogicalProcessorInformation() returns an array of SYSTEM_LOGICAL_PROCESSOR_INFORMATION. They contain a union, but in C, the union is sized to its largest member, so the size of the struct is fixed and indeed, you know how many you have by dividing the size of the returned data by the size of the struct.

The later version, GetLogicalProcessorInformationEx() also - according to the docs - returns an array, but it’s now SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX. The docs actually say “array”. However, this new struct has a new member - “Size”.

I now suspect it returns a packed “array” - not an array, because you can’t index into it - of these structs, and you move to the next one by casting your pointer to an unsigned char and then adding the size of the current element to it.

THIS IS NOWHERE IN THE DOCUMENTATION. THERE IS NO EXAMPLE CODE. THE ONLY WAY YOU CAN KNOW IS TO GUESS BECAUSE THERE IS NOW A SIZE MEMBER IN THE STRUCT.

lols

So, I’m giving KVM a try.

I came across a page of KVM setup instructions so complex that I thought I was reading advanced hypermathamtics in ancient Greek but then later came across a different page of instructions which involved three commands - and which worked.

So I came to the point where I was to create a guest. I thought I’d try bringing over the existing VirtualBox Win7 (with SDK) guest, as an experiment - Windows IME hates having the machine change under it, and that might screw up the topology stuff by itself anyway, but I’d like to see KVM work in the first place, and it might work anyway, and it should be pretty much instant - so all in all, good first test.

VirtualBox uses its .vdi format, KVM uses the .qcow format (quad cow? I hope so :-) you can export from VB to a raw format, and import in KVM from raw.

So I issue th command to VB to export the Win7 VM to raw.

It starts - “0%…”

I wait. Wait. Wait. Start doing other things - well, it’s a 25GB file, it’s got quite a bit to do. It’s reading from USB3 and writing to a local SSD.

Linux interestingly turns out not to be very good at coping with lots of disk I/O - at least, not on my system. The whole system regularly becomes unresponsive for a few seconds at time. Linux is much better than Windows at handling intense CPU work (in that situation, Windows regularly becomes unresponsive for a few seconds at a time) but it seems the opposite for disk.

Anyways - I start cooking dinner. I’ve seen VB behave like this before - it shows it’s started, takes forever, and then in about half a second the progress bar completes.

I get on with cooking. I try to browse a bit, but it’s awkward, with the freezes. Then - wait! what’s that!! ACTION! VB has printed…

10%!

AHHHHHHHHHHHHHHHH!!!!! it really IS going to take hours!!!

Well, bugger. Well, I can get to the gym, anyway, and it’ll be done when I get back.

I start eating dinner.

Then VB goes 20/30/40/50/60/70/80/90/100 in about half a second and completes :-)

Update

Need to make benchmark work on Windows with NUMA.

This is (as previously blogged) a problem, because VirtualBox (up to and including the very recently released version 5) return broken data from the Windows topology API.

I looked at using Xen, in the hope a different VM would do the trick, but Xen setup is, ah, let’s say - it’s complex enough that I am absolutely, completely, totally and utterly certain from years of experience with Linux that there isn’t a chance in hell of me being able to make it run.

So either I look around for some more VMs (VMware, maybe? but I vaguely think it’s commerical), or I get hold of a Windows machine (I looked at this, with Amazon, but the problem is - Windows expects a GUI; there are instructions for installing Windows so that you get remote VNC-like access, but they too are WAY WAY past the point of viable complexity - I know from years of experience blah blah etc no way in HELL I could ever make it work - people keep writing all this software which is so complex it can’t be made to work, which is exactly the same as not writing it at all), or I simply say for this release that it’s been compiled on Windows and ought to work but the code hasn’t been run. Which sucks, but it’s not obvious what the alternative is.

The other bit of work to be done is to run all the code on a NUMA Linux machine. Amazon can help here (for a pretty penny). That’s the next job. Nap first.

2016-05-15

ARM #4

Btree on ARM now 3x faster than next best.

That’s a 30x improvement by being sensible about cache line use.

ARM #3

I think I’ve made a big mistake in the lock-free btree structs. The element struct looks like this;

struct lfds710_btree_au_element
{
  struct lfds710_btree_au_element LFDS710_PAL_ALIGN(LFDS710_PAL_ATOMIC_ISOLATION_IN_BYTES)
    *volatile left,
    *volatile right,
    *volatile up;

  void LFDS710_PAL_ALIGN(LFDS710_PAL_ATOMIC_ISOLATION_IN_BYTES)
    *volatile value;

  void LFDS710_PAL_ALIGN(LFDS710_PAL_ATOMIC_ISOLATION_IN_BYTES)
    *key;
};

But all those volatile/aligned members, they’re all given those properties because they can be subject to an atomic operation, the thing is, ONLY ONE OF THEM CAN BE OPERATED ON AT A TIME.

So it’s not necessary for EACH MEMBER to be so aligned - all that’s needed is that the STRUCT is so aligned.

In a fully read-write btree, especially balanced where we see plenty of atomic opts all over the place on an ongoing basis, the alignment may pay off. In this simple tree, add-only, each pointer element is only ever written once anyway, no matter what! so it’s okay to invalidate all the other pointers in the element; the cost of doing so once is profoundly less and on an on-going basis than the cost of the multiple cache-line loads from tree traversal.

The add-only linked lists are going to be experiencing the same problem. No benchmarks for them yet though.

ARM #2

The problem at least in major part is the alignment of the variables in the btree struct.

Adding matching atomic-isolation alignment (64 bytes) to the GCC atomic struct halves performance and in fact makes it equal on a single core to the lock-free btree.

Without the alignment, the entire btree element fits in a single cache line.

With it, it’s two caches line PER ALIGNED MEMBER OF THE STRUCT… ahhhkkkkk…

ARM

So, the benchmark runs fine now on MIPS and ARM.

The results however are far from fine.

Now, these are only little dev boards and I suspect the hardware has a big part of play in the relative performance of the locking vs lock-free data structures - in particular the lock-free btree has a lot of memory accessess compared to the locking btree.

However, what I see is this; on MIPS, lock-free wins, but either by not much or only 2x.

On ARM, I can’t remember the queue/freelist results offhand because I’m staggered by the btree result, and it’s that I am currently investigating.

The btree on ARM (well, a Raspberry Pi 2 Model B) is TEN TIMES SLOWER THAN USING SPINLOCKS.

On Intel, it’s ten times faster.

So I’m trying to figure this out now. Collosal blunder somewhere? I hope so…

One thing I have just found, which really surprised me, is how much difference even small changes can make. In the btree compare function, the code currently is like this;

static int key_compare_function( void const *new_key, void const *existing_key )
{
  int
    cr = 0;

  struct libbenchmark_benchmark_btree_au_liblfds_lockfree_readn_writen_benchmark_element
    *new_benchmark_element,
    *existing_benchmark_element;

  LFDS710_PAL_ASSERT( new_key != NULL );
  LFDS710_PAL_ASSERT( existing_key != NULL );

  new_benchmark_element = (struct libbenchmark_benchmark_btree_au_liblfds_lockfree_readn_writen_benchmark_element *) new_key;
  existing_benchmark_element = (struct libbenchmark_benchmark_btree_au_liblfds_lockfree_readn_writen_benchmark_element *) existing_key;

  if( new_benchmark_element->datum < existing_benchmark_element->datum )
    cr = -1;

  if( new_benchmark_element->datum > existing_benchmark_element->datum )
    cr = 1;

  return( cr );
}

Change it to this;

static int key_compare_function( void const *new_key, void const *existing_key )
{
  struct libbenchmark_benchmark_btree_au_liblfds_lockfree_readn_writen_benchmark_element
    *new_benchmark_element,
    *existing_benchmark_element;

  LFDS710_PAL_ASSERT( new_key != NULL );
  LFDS710_PAL_ASSERT( existing_key != NULL );

  new_benchmark_element = (struct libbenchmark_benchmark_btree_au_liblfds_lockfree_readn_writen_benchmark_element *) new_key;
  existing_benchmark_element = (struct libbenchmark_benchmark_btree_au_liblfds_lockfree_readn_writen_benchmark_element *) existing_key;

  if( new_benchmark_element->datum < existing_benchmark_element->datum )
    return( -1 );

  if( new_benchmark_element->datum > existing_benchmark_element->datum )
    return( 1 );

  return( 0 );
}

And that actually gives a 1.01% speedup - over five seconds an extra 12,000 operations.

2016-05-14

ERG code done

Results on a Cortex A7, where the value is the number of successful LL/SC operations (out of 1024 - we expect an odd failure due to thread swapping);

ERG 8 bytes : 0
ERG 16 bytes : 0
ERG 32 bytes : 0
ERG 64 bytes : 1023
ERG 128 bytes : 1024
ERG 256 bytes : 1023
ERG 512 bytes : 1024
ERG 1024 bytes : 1024
ERG 2048 bytes : 10

So the ERG size looks like 64 bytes. I don’t know why the 2048 byte size fails so much!

Docs say this;

“Exclusive reservation granule size is 16 words.”

Which is indeed 64 bytes.

Determining the ERG

So I’ve been banging away on this code, and remembering some things I’d forgotten - like a given core I think can only have one LDREX open at a time. This constrains implementation, because if you say start a thread, it’ll for sure performing some atomic work, and bang - your LDREX fails automatically.

So I have to have one thread doing the ldrex/strex on the first word of the ERG length we’re testing, while the other threads write to the test word which is just inside the ERG length we’re testing, and the first thread has to KNOW the other threads have written, without using atomic operations.

It’s not that hard, but I did have to think a bit! assuming I have it right, of course :-)

However, while doing this, I thought - hang on, there’s a register in the chip which knows the ERG length. Why don’t I just write a bit of assembly and read it? IDIOT!

So I google a bit, and yup sure enough there it is, and a trivial bit of code to read it, so I write the code, and hey presto it doesn’t work. Illegal instruction.

After an hour or two of investigation, the code to find the ERG length can only be run from supervisor mode, and I can’t get to supervisor mode from user mode, so it’s absolutely no bloody use to me at all.

What I actually need, if there’s any milage in this at all, is for the OS to publish the ERG value to me, in user-mode. Far as I can tell, that doesn’t exist.

So back to my empirical code :-)

2016-05-13

ERG

Been writing the ERG finder.

Spent all day making it not work.

Eventually found out - there’s a local monitor and a global monitor. The local monitor doesn’t do much, and if your write ops all exist inside the same core, it’s the only monitor involved. You must have another core write, to involve the global monitor. As such, the code to determine ERG has to be multi-threaded.

In other news, the best mangos in Greece cost about four times as much as in the UK, but the best cherries cost about a quarter.

In every country you go to, you must adjust your diet.

2016-05-12

ARM ERG

Finding out the ERG for ARM (or indeed any platform) is problematic. So many different models, so hard to get such specific abstruse technical information.

I’m going to write a bit of code - will all have to be platform specific, so it’ll be ARM only to start with - which empirically determines the ERG.

Whack-a-mole with GCC

Starting to feel like getting code to compile with multiple versions of GCC is like playing whack-a-mole.

Fix a problem on one platform, you’ll produce a new problem on another platform.

Are we having fun yet?

Utter GCC frustration

Type fucking punning, jesus christ on a fucking stick.

So, I have pointer-and-counter pairs. I use a double-word CAS to atomically modify them. As a pair, they’re arranged as an array of two elements. On a 32-bit systems, that’s two 32-bit unsigned ints. To DWCAS, I pass them to GCC’s atomic instrinsic, and it MUST have the type as an “int long long unsigned”, so I pass in the address of the first element and cast it to that.

Doesn’t work, breaks type punning of course.

Problem is, there’s NO FUCKING WAY to FIX type punning, short - and this is a theory only - of rewriting the code base to use a union instead of an array.

I’ve spent twelve fucking hours on this now.

There’s an attribute, may_alias, which SIMPLY DOES NOT FUCKING WORK AT ALL EVER NO MATTER WHAT YOU DO. Google for it. Almost no hits, and those which do exist are “how do I make this work? anyone have a mininal code example where it does work? at all?” followed by “I used a union in the end”.

The only way I can see out of this is to fully disable strict aliasing both for libfds and for the test library, since it calls the header file code for atomic ops from liblfds, and so will show the same problems when compiling.

GCC does not support make uninstall

“Please note that GCC does not support ‘make uninstall’ and probably won’t do so in the near future as this would open a can of worms.”

facepalm

This means back in Feb I actually made a one-way install of GCC 6.0…

So I can manually delete the binaries, but then I’ve got to hunt down the libraries. Without breaking my system…

Damned if you do, damned if you don’t

Getting thoroughly sick of type-punning.

If I omit a particular cast, GCC throws a warning - you’re disgarding the volatile qualifier.

If I put the case in to explicitly indicate I mean to do so, GCC throws another fucking warning, you might break type-punning.

The particular function I’m calling is an atomic intrinsic. The argument being passed is expected by the instrinct to be non-volatile, but linked lists being what they are, I have to be passing in the next pointer of the previous element, which has to be volatile.

may_alias is an alias for will_go_horribly_wrong

So, I’ve been thinking over the use of a union for the pointer-and-counter pairs.

It’s a better representation - it’s more showing things to be what they really are - but it means some rewriting, and more to the point, pretty ugly code, physically ugly, as I have to use BIG_LONG_DEFINES to access the pointer and counter.

So I decided to use may_alias on those pointer-and-counter pairs, for now.

Know what happens?

GCC internal compiler error.

staggeringly vast facepalm

What I said? about everything being fucked? totally and utterly? you can’t rely on anything, at all, ever, because it’s all fucked?

Right.

Works okay on the Pi, with it’s moderately older compiler.

So I think I actually have to fully disable strict aliasing.

I need a build system which has ever major release of GCC on it, and I need to compile on that. Oh - and for every CPU architecture I can get my hands on.

2016-05-11

Update

Whewf.

So, atomic exchange. Currently, the code doesn’t exchange. It only does a set. That means we need to throw away the unwanted original value. Two problems with this. First, you can’t test set. Think about it - you have a function, it does an atomic set, you don’t know the original value. How do check it works? you can test exchange just fine. Second, type-fucking-punning. Why the hell is it called punning? the only meaning I know for the word pun is “joke”. So the problem is that to disgard the type, we have to declare a variable, set it to the value we want to set, and pass the address of that variable into the exchange - but we can’t know the type unless the user passes it in.

So what I’ve done is kept exchange, and it’s test, and added set as well. Exchange is not used - but people making a port can write code for exchange and test it. Making set them means taking that exchange code and just throwing away the return value.

So that was one issue.

Second issue, type-fucking-punning, again. The problem turns up with some versions of GCC and not others, which worries me. The basic issue is that I’m using an array for pointer-and-counter. The GCC atomic instrincs are typeless - which means on 32 bit platforms to get double-word compare-and-swap I have an array of to 32-bit elements, which I was casting to an int long long unsigned… and which breaks type-punning. I’ve just experimented, and far as I can see, GCC doesn’t do atomic ops on arrays, so I HAVE to use the int long long unsigned type - which means converting all the pointer-and-counter arrays to that type and casting the first half of it to a pointer… which I’m worried will also throw type-punning errors.

I understand why the linux kernel has strict aliasing off!

This is only showing up as a problem on 32 bit GCC platforms, because on 64-bit I’ve got to use some inline assembly anyway (there being no native 128 bit type). I don’t want to use inline assembly unless I have to, because I have to write it for every platform.

In fact, this is a pain in the ass. On 64-bit platforms, there’s no native 128 bit type, so I HAVE to use an array of two elements. The code has to work with this - so obviously I want to use the same array of two on 32 bit platforms - only, ha-ha-ha, type-punning kicks me in the ass.

In fact, I can’t see a way around this. If I have arrays, type-punning bitches. If I have an int long long unsigned for 32 bit, I can’t compile for 64 bit, because there’s no native 128 bit type.

What concerns me is that I only see this problem on the Raspberry Pi, not on the Ci20… ah, now, the Pi is using the new atomic instrincts, the Ci20 the old. That might have something to do with it too, although it shouldn’t. On my laptop, I’m 64 bit, so I’m not using the GCC atominc intrinsics, I’m using the inline assembley.

GCC has an attribute may_alias, which I think I’m going to have to apply to the arrays.

That or use a union. Thinking.

Update

Getting the final coding done, making the library compile on all platforms.

I’ve realised I want to change atomic exchange into atomic set (i.e. an exchange, but throw away the original value).

Problem is you can’t test atomic set.

2016-05-08

Update

1am. Finished the first draft of the API docs (the left-hand column).

Tomorrow will pick up some new computer kit, including a Syncwire four-port USB charger which the dev boards will run off of, which will be a marvellous help with getting the liblfds ports testing done.

Basically, I think, two days work to go. One day to finish the docs (the right-hand column - all the build and porting guides) and one day to finish the testing work on the code.

Doccing

Writing the 7.1.0 docs! :-)

2016-05-06

Win7 topology reporting under VirtualBox

So, the Ex() functions are totally fucked. They return complete garbage. I think the first record is right, and then it goes rapidly down into 0xcdcdcdcdcd.

The old-style, pre-processor-group API, that works fine except for caches - it only reports data caches. No instruction caches, no unified caches.

I had assumed when I went over to Linux I could continue to support Windows by means of a VM.

Looks like it’s time to try something other than VirtualBox, which is a shame, I’ve used it for a long time and it’s familiar and in every other way has been fine.

Broken topology info reporting for Windows 7 in VirtualBox under Linux

GetLogicalProcessorInformationEx() on Windows 7 on VirtualBox on Linux returns partially garbage results.

As such, I cannot enumerate topology, as such, I cannot develop the benchmark app on this VM.

TBH, I’m not surprised this happens, given how appallingly messed up the Windows topology API is. It’s impossible to use it correctly - implementing it correctly must be twice as hard.

MS build problems

So, I’m getting the port to Windows back into shape.

I’m only supporting Windows Platform SDK for Windows 7 - it’s the very last release of stand-alone command line compilers, that I can find, from MS. I’m using this with gnumake.

I have however run into what seems to be a strange and novel problem. I’m using the latest version of the SDK, 7.1 (before I used 7.0). I recall with 7.0 there was a command line offered from the start menu for each build target (XP, 2000, Win7, etc) and I used them all.

Now though there’s only a command line offered for Windows 7.

So I fire up a normal command line, then run setenv and target XP.

Problem is, it’s not compilting like it’s targetting XP. NTDDI_VERSION is set for Windows 7 (the host OS). I was expect this and _WIN32_WINNT and so on to end up being set for XP. They’re not.

So how do I target XP?

The only thing I find setenv doing is setting an env-var, “TARGET_PLATFORM”.

I’ve also found out, far as I can tell, there’s no support in MSVC for dumping the compiler macros from the command line, as there is in GCC.

So, WTH, you know?

I have a command line option in setenv to target specific Windows versions, which simply does not work, or so it seems. I have no way of finding out what the compiler has set, and so the only thing I can see to do is that in MY code, I look at the values for TARGET_PLATFORM (whatsever they are) and then MYSELF set _WIN32_WINNT.

Which is absolutely freaking insane and can’t be right - but there’s nothing I can find anywhere about what is right, and what I can see is that setenv targetting for a given Windows versions simply does not work.

So I’m going to run up another VM and install 7.0 - about 30 minutes work - and then see if it will compile XP properly.

Ha, in other news, DHL failed to deliver a package today, so I have to go pick it up from their depot Monday. They failed to deliver because the intercom on the AirBnB I’m in does not work - so they couldn’t call me from the door.

2016-05-04

Code complete

Development work is complete.

Now to sort out build configuration, run test and benchmark on all platforms, bring the 7.0.0 docs over and update them to 7.1.0, then release.

2016-05-03

Backoff auto-tune successful

Has been a success.

It works well, and removes the need to specify backoff values.

I’ve moved over fully to it now, and removed all the CAS/DCAS setting code in the benchmark app.

2016-05-01

auto-setting backoff

So, auto-setting backoff.

There are a number of important advantages.

As it is, it’s become clear that the backoff value varies not just by CAS/DWCAS, but by data structure and indeed by operation in each data structure.

It also varies, I expect and think I’ve now seen (I’ve not been looking for it yet) by the level of contention - the more threads banging away at once, the ideal backoff value changes (as you’d expect).

It will I am sure also vary by CPU topology (which also relates in part to how many threads are banging away at once).

So it’s basically freaking impossible to get right ahead of time, and it matters a LOT for performance (although one saving grace is that the window of good performance seems pretty wide).

What I have in mind for a method is to keep track of the backoff iteration reached for each operation, and then every n operatioin, decide based on the ratio between backoff iteration count for 0 and the count for 1. We need to know the previous ratio, to compare it to the current ratio, so we can know if what we did last time (increase or decrease) helped or hindered.

A problem here is where we keep this info. In a perfect world, it would be retained per thread and per data structure instance and per-operation state (i.e. separate state for queue enqueue and dequeue, freelist pop and freelist push, etc), which the user passes in via an argument to every liblfds lock-free operation. This is a huge PITA for a user.

We could reduce this to per-thread, per-operation state, which would amalgamte auto-setting across all data structures. This isn’t right, since different instances will have different numbers of threads using them. At least it takes topology into account.

Ideally, we avoid user-visible state entirely.

This would implies per data structure instance state, which is therefore valid for all threads using that instance, and will also be per-operation. The problem is then this would need atomic increments - splat, performance hit. We might find however that non-atomic increments work well enough. The loss of increments will of course be in proportion to how often a given counter is increments, so it will tend to bias the ratio we conpute - but it might be just fine in practise.

More M&S Queue Performance Tuning / Analysis

I realised that I had missed in the M&S queue a place where backoff needs to occur.

I had backoff where-ever a CAS or DWCAS occurs. However, backoff is actually needed where-ever an operation can fail due to contention with other threads.

In the M&S, such an operation exists - it’s not CAS or DWCAS, it’s just reading variables, then a load barrier, then a check the variables are unchanged. It needs backoff, didn’t have it.

I had high hopes this might be the cause of the mysterious missing performance on two threads (one per core) - but, alas, no.

It does add about 15% on four threads (two per core) so it’s worth having, but it’s the not the key issue (if there is one!)

I have instrumented the queue code to record in an per-thread array the backoff iteration number reached for a dequeue or an enqueue, and I now print these out from the benchmark.

They are very interesting.

Here’s the output for two threads, one per core. En for enqueue, Dn for dequeue, backoff iteration begins at 0 (and a count for zero means the queue operation went through first time) and a count for a higher number means we were on attempt n to perform that given operation.

This is for a backoff quantum of 8 (ranges from 0 to whatever you want - the higher, the more backoff, but the more backoff, the more unfair you become - the usual tradeoffs, etc). Eight is a pretty good value for most data structures on my platform.

============ LP 3 : E0 : 7684462 LP 3 : E1 : 6042450 LP 3 : E2 : 356540 LP 3 : E3 : 67853 LP 3 : E4 : 47549 LP 3 : E5 : 42962 LP 3 : E6 : 41005 LP 3 : E7 : 39853 LP 3 : E8 : 40438 LP 3 : E9 : 39311 LP 3 : D0 : 10008606 LP 3 : D1 : 649547 LP 3 : D2 : 40764 LP 3 : D3 : 7992 LP 3 : D4 : 2092 LP 3 : D5 : 1234 LP 3 : D6 : 512 LP 3 : D7 : 266 LP 3 : D8 : 194 LP 3 : D9 : 120 ============ LP 2 : E0 : 10859024 LP 2 : E1 : 7284726 LP 2 : E2 : 388366 LP 2 : E3 : 15056 LP 2 : E4 : 3982 LP 2 : E5 : 1748 LP 2 : E6 : 1137 LP 2 : E7 : 942 LP 2 : E8 : 970 LP 2 : E9 : 806 LP 2 : D0 : 13080513 LP 2 : D1 : 776180 LP 2 : D2 : 6417 LP 2 : D3 : 384 LP 2 : D4 : 51 LP 2 : D5 : 15 LP 2 : D6 : 5 LP 2 : D7 : 1 LP 2 : D8 : 1 LP 2 : D9 : 2

There are many things to see.

Dequeue basically has an easier time of it. The count for 0 is TWO orders of magnitude greater than the count for 1, and the higher counts are almost 0.

Enqueue OTOH is having a hard time.

What this suggests to me is the possibility of auto-tuning backoff. Have the user pass in a per-thread array for keeping track of backoff iteration numbers reached, and a per-thread (and per data structure operation - enqueue being different to dequeue, etc), and then every n operations, if E0 is not the highest count, increase backoff by one. Need a mechanism to decrease though - perhaps aiming for E0 and E1 to be equal.

2016-04-30

Performing tuning

I’ve been spending some time poring over the M&S queue.

If I look at the benchmark for the freelist, it goes ballistic on one thread on each of two cores.

The queue just doesn’t. It goes at the same speed at the normal locking stuff.

It’s driving me nuts - I need to figure out why, so I can know it’s real and not just me messing up the implementation.

Relating to this, but it didn’t make a difference, I found out today by default on Intel when a cache line is fetched, the following cache lins is also fetched. I tried doubling the atomic isolation aligned to be two times the cache line width, but it made no difference to anything except the btree, which slowed down by about 25%.

One thing I noticed was that I had some store barriers in the dequeue/enqueue code which were absolutely unnecessary - they were being used on counter fields, which would be pushed out anyway by a following DWCAS.

I noticed also I had an inefficient store barrier in the freelist/stack push - I was causing two fields to get pushed by a DWCAS, when in fact one of them was going to be pushed out anyway in the DWCAS. I reordered them, and the freelist/stack sped up by about 10% in the single-thread case (which is the clearest measure of the effect of such a change).

However, the change I made to the queue, where I removed the unnecessary stores, has made it about 50% faster with one thread on each of two physical cores, but noticably SLOWER when one thread on each of four logical cores (i.e. two threads on each of two physical cores) - and this I do not understand.

Update

Last test to write on the new queue.

I’ve had a bit of rename. Everything used to be alphabetic, i.e.

list_addonly_ordered_singlylinked

However, thinking of Orwell’s comment “ignore all of above” I’ve decided to be consistent in ordering within each data structure type. I’ve also needed to rename lfds710_queue, because it needs to be clear it’s MPMC.

I had a bit of an insight earlier, in the shower.

I think I can modify the M&S queue to be bounded, by giving it an array of pointers to elements. You can’t use an actual array directly, because it constrains the order in which dequeues must occur for other threads to be able to progress. So it has to be pointers.

However, I’m not going to do that now - I’m moving to release now.

I may do the benchmark for the new queue, but that’s the only extra dev work I’ll do.

In other news, this is my first year with two Easters. Late March in Malta, late April in Athens!

2016-04-29

Ringbuffer disappointment

The ringbuffer uses the M&S queue and so needs a dummy element.

This disfigures the API.

I implemented Dmitry Vyukov’s bounded MPMC queue, to use that instead.

However, having implemented and now coming to adjust the ringbuffer, I realise it’s no use.

The problem is that it’s a soft queue and also that it runs from an array. By soft I mean that although all enqueue and dequeue operations occur, they are not necessarily visible to all other cores by the time the enqueue/dequeue function returns.

If we imagine a queue as a ringbuffer, then what it means is that if we try to enqueue and we cannot, because the queue is full, we dequeue, and then enqueue - throwing away one element.

The problem is that when we come to dequeue, someone else may dequeue just before us; our dequeue will succeed but if the other thread is first, then until that other thread’s dequeue becomes visible to us, we can’t continue, because we need the next element in the array, the one just dequeued, to become visible to us as dequeued - we can’t enqueue until it is available, regardless of the success of our own dequeue.

What’s more, we can’t just say “well, we did a dequeue, so we’ll get something sooner or later” because other threads could be genuinely enqueuing more stuff. So we can’t know whether we need to re-issue the dequeue.

The basic issue is that the queue is blocked by any one thread performing a dequeue where that thread is slow (to be clear, though, the queue was never meant to be otherwise - it’s just I’m really appreciating the impact of this now).

It can be solved by forcing a store at the end of the dequeue, so everyone has visibility. This halves the speed of the data structure (currently one CAS for enqueue and one for dequeue). Also, we still are exposed to the problem of a thread performing a dequeue being idled by the OS when it’s halfway - it’s done the first CAS, so the dequeue has occurred, bu it’s not yet made the element usable (adjusting the sequence number). During this period, an idled thread blocks the data structure.

2016-04-23

anti-aging news

About seven months ago a woman in the US, a normal woman, not ill, flew to Colombia - to evade the restrictions placed upon her freedom by the FDA - and underwent a gene therapy treatment to help address two of the declines which come with age, loss or muscle mass and telomere shortening.

This news finally hit slashdot, and so I finally read about it - I’m right on the cusp of getting strongly involved in this field, so I’m not yet well read.

The comments on slashdot reflect in part the staggering lack of imagination and abudance of banality which humans can possess.

This technology is on a par with the invention of fire, and there are a non-negligible number of respondants along the lines of “death is death, retards”. I can only hope for timely automobile collisions ;-)

One of my thoughts with regard to a longer or open-ended lifespan is that it will give people time to mature and become wiser. Some people become wise and considerate in twenty years; others need forty, others still sixty or eight. If we can live for hundreds, or thousands, or hundreds of thousands of years, perhaps we might all become wise enough to have a decent planet - and more than one planet - to live on.

2016-04-18

Christ, finally

All the benchmarks are running again.

Adding NUMA support took SOOO long, OMG I don’t even etc.

(So the benchmarks can now run SMP, NUMA or NUMA unused, where the benchmark admin data is NUMAed but the data which is actually liblfds data is only one the NUMA node which has the largest number of logical cores in the current thread set).

Need to fix up the gnuplots now, add a benchmark duration argument, some other tidying up.

Then I can make the docs, run the tests, then publish 7.1.0 - and then I can have snazzy glittery gnuplots on the home page!

2016-04-16

It’s Friday, it must be Helsinki

If there’s one thing the Nordics really do get right, it’s pear cider.

2016-04-12

Update

Test is finally back on its feet after rewriting to not use the standard library - all passes on release, valgrind clean on debug.

Unfortunately, it’s not QUITE free of the standard library…

One test uses qsort and bsearch, and a lot of tests use time(), to ensure they run for a reasonable period.

I need to rewrite those tests to run for enough iterations, so time isn’t used.

However, back to the benchmark now.

2016-04-05

Update

Still working away on the benchmark app.

Added NUMA support.

This means if you have no NUMA, or one NUMA node, you get an SMP benchmark.

If you have two or more NUMA nodes, the benchmark allocates NUMA aware - so for example, the btree benchmark, which has 1024 elements per thread, allocates from the NUMA node of the thread.

There is however a second NUMA mode, for comparison purposes, where NUMA is not used. This is different to SMP or a single NUMA node sysem, however. Benchmarks themselves sometimes have significant admin work to do in the backround. As such, for any given iteration of the benchmark there might be say 20 memory accesses, but only 5 are actually by liblfds. As such, if we were to compare NUMA with non-NUMA simply by in the latter case putting all allocs in the same NUMA, we would not be comparing apples with apples - we would be seeing a MUCH larger decrease in performance, but where most of it is due to all the work the benchmark itself is doing.

As such, when testing non-NUMA, we need to ensure ONLY the memory accesses performed by liblfds are non-NUMA, so we need to ensure all the admin work is going to the local NUMA node. So that mode exists as well.

I’m thinking once this is done of quickly knocking out a bounded MCMP queue, so I can simplify the ringbuffer API and improve its performance.

2016-03-27

BTree (add-only, unbalanced) benchmark gnuplot

liblfds710_btree_readn_then_writen

Benchmark app coming along nicelly :-)

2016-03-24

M&S Queue benchmark experiment

The benchmark code is coming along nicely.

I’ve added a btree benchmark - lock-free beats everything else by 5x to 10x, ATM, although I think I can imrpove the non-lock-free performance by 2x.

The queue benchmark is also back up.

I was able to perform an experiment I’ve had in my mind for a bit - there is a CAs at the end of enqueue, which updates the enqueue pointer to point at the newly enqueued element. It’s “optional”, in that the dequeue will move the enqueue pointer if it’s out of place. So I took it out and re-ran the benchmark.

Performance dropped by about 20%.

2016-03-19

Not every release from now on will come with MSVC solution files

I hate to do this, because I want to support platforms, but the impact of supporting Visual Studio is massively retarding the rate at which I write software in general for the library - that’s the real problem.

I am strongly motivated by finishing work. So for example right now I’m working on the benchmark app. It’ll be fantastic and unbelieveably useful and I can’t wait to get it done - that excites me, and so that motivates me.

Problem is, when I get it done, it’s not done. See, I need to release it. Now, for Linux, release and test is trivial. It takes minutes. Adjust the makefiles, build, run.

It could not be a more different story under Windows, when using Visual Studio.

See, there are two problems. First, I have Windows 7 - not licensed, but it doesn’t expire; but I only have a 90 day trial version of Windows 8. Every 90 days, when I want to use MSVC 2013, which requires Windows 8, I have to install Windows 8 from scratch, and install MSVC 2013 from scratch.

I then also need to install the kernel development kit from scratch.

Going back to Windows 7, it doesn’t expire, but I only have a trial version of MSVC 2012. That does expire, so I have to install that from scratch, and the kernel development kit from scratch - making VMs for each of these installs, since you can’t co-install these various versions of MSVC.

So; I want to make a release. Linux? run a batch file. Builds all builds, runs all test suites. One command, then wait for a bit. Done.

Windows? copy the Windws 7 VM twice (once for 2012 without WDK, once for with), make a new VM for Windows 8, install Windows 8 from scratch, install MSVC2013 from scratch, clone the VM, install the WDK on the clone.

That’s just the beginning, though. All I’ve done so far is get working tools.

At this point I need to make any new solution files which are required.

There are currently three solutions files per combination of MS tools. So that’s three for MSVC2012, three for MSVC2012+WDK, three for MSVC2013, three more for MSVC2013+WDK (Intel) and three more for MSVC2013+WDK (ARM).

I need to add another two, so that’s another two for each platform.

Setting up a new solution file is an ordeal. It takes hours and hours and hours - literally - of adjusting hundreds and hundreds of settings, click after click after click after click. The mouse is not a suitable interface for this kind of work.

It is unbelieveably tedius and fiddly and this itself makes it hard to get the solution files right. It’s like trying to line up a thousand different pins, all of which are inside a haystack.

It takes a minute, tops, under Linux, with a makefile. I just change the filenames in the makefile.

I think I have found a way to clone and rename solution files, but I’m not 100% sure it’s legit.

Furthermore, for the kernel solutions, I don’t actually know if I’ve set them up correctly. I can find no documentation on doing so - everything seems to rely on you following the wizards, but the wizards make no sense to me in what they come out with. I want a LIB Or DLL - I can’t see how to get it - but I know how to get it manually for non-kernel builds. I’ve tried to do the same for the kernel builds. Is it right? of course not.

So the problem is this - I am motivating by finishing. Right now, my motivation is ruined by knowing I have this appalling, awful, hideous lumphammer of work ahead of me. No matter what I do now, I’m not finished - I’m miles from finished.

Because of this, I’m just not getting much done.

So what I’m thinking to do is keep supporting MS, but only with the command line compilers under Windows 7 and gnumake. MS have stopped providing command line compilers, so I’ll be used old software - but liblfds is platform independent. All it really needs is threads, atomic ops and a bare C compiler - so that shouldn’t be an issue.

This also means I’ll keep supporting WDK 7.1, the obsolete WDK for Windows XP, as this is command line based. It’s crude as hell, but it basically has something like a makefile, so I configure it as I would under Linux - I adjust a file by typing, and it’s easy.

I am thinking that now and then I will construct the solutions files for MSVC and release them - i.e. port a build to MSVC by providing the build files - but I’m not going to do this as I have done till now for every release.

2016-03-09

Test refactored

Oouuf.

That was quite a bit of work, and I thought it would be.

I’ve refactored the test application so that it no longer uses the standard library or performs memory allocation.

It still needs threads, though.

The test app is now almost completely a library, with a convenience command line wrapper provided.

The test suite is performed by calling basically one function, and you get back the results of which tests passed and which failed (and why).

All you have to do as the caller is pass in a block of memory (for the tests) and implement the threads abstraction layer, which is already done for Linux user-mode and Windows user-mode. You can also pass in callbacks for text output if you want to see results as they come. I think I’ve got code for Windows kernel-mode. I’ll need to see about Linux kernel-mode.

There is still one fundamental shortcoming though. One use case for the library is on embedded single-threaded cores. The use case is that the lock-free data structure instances are safe to use both inside and outside of interrupt handlers. The test application has no way of running in that environment since it uses threads.

2016-03-07

Lock-free PRNG

With vital assistance from Sebastiano Vigna, of PRNG shootout fame;

http://xorshift.di.unimi.it/

I have rewritten the liblfds PRNG code to be lock-free.

The existing code provided two PRNGs - a xorshift1024* (with a spinlock!) to provide high quality seed values for a xorshift32 or xorshift64* (depending on 32/64 bit platform), where the latter ran on single-threaded PRNG states.

What exists now is a single PRNG, with a 32 bit and 64 bit version (the SplitMix PRNG), which is lock-free, and so can be used by any number of threads in parallel, blah, the usual - and, critically, is now in keeping with the rest of the library and can in fact be offered as a lock-free ‘data structure’, along with all the rest.

I can however think of only two reasons for using a lock-free PRNG.

First, convenience. Per-thread state requires, well, per-thread state. A single PRNG state which is thread-safe removes that problem.

Second, is if seed generation is a problem. If there is no source of seed entropy, then one seed must be provided per thread. If the number of threads is variable, then… well, then you need to have two PRNGs, one to generate seeds from a single original seed, and another to run from those seeds - which brings you back to needing a spinlock on the original PRNG.

2016-03-06

Test work

I’ve refactored the test code into a library, plus a thin wrapper command line executable.

The library offers the test functionality in a platform independet way - in a Standard Library independent way, not using stdout, malloc, etc, so it can easily be run on embedded platforms, in kernels etc.

The overall work is done, I’ve got two tests running, now I need to bring over all the tests to the new standard (they’re passed a big block of memory which they use for everything they need, where-as before, they internally called malloc).

Once I’ve done that, then it’s back to the benchmark app.

2016-03-04

Updatez

Finally had a full day coding.

Got the new topology code working.

Have realised both the benchmark and test both need actually to be libraries, with all the functionality operated by what is ideally one function call, and with a trivial wrapper binary provided for command line use on command line supporting platforms.

The reason for this of course is that many platforms do not have command lines, or stdout (or malloc) and so all the functionality needs to be in a library, with a porting abstraction layer.

Benchmark, got to now figure out how to generate thread sets, and then what to do about NUMA mallocs in tests.

Test, I gotta take a look at it and see what’s involved in moving it to a library.

2016-02-26

WIndows topology API seems to have a design flaw

I may be wrong, but I am really starting to think now that the extended MS API for getting system topology is actually broken - you can’t figure out the actual system topology from the information it gives you.

The problem is that processor groups can span NUMA nodes.

As such, processor groups can also span level three caches, because as a typical example on my Intel, the level 3 cache spans all logical processors in one socket, and that socket has one NUMA node. If a processor group can span NUMA nodes, it can span level three caches.

Information about NUMA nodes is returned with a single group affinity member - so a NUMA node which has more than one processor group will have more than one record coming back from the Windows topology API. However, NUMA nodes also have an ID in their info structure, so I can tie together these multiple records and know they’re the same NUMA node.

HOWEVER! cache records also only have a single group affinity member - BUT THEY HAVE NO UNIQUE ID.

So a level three cache with more than one processor group will return multiple records - but I will have no way of knowing they are records for the same cache.

That means I cannot actually know the topology of the system - I can’t properly know caches - and I care about that, because caches are fundamental to memory behaviour and so the selection of thread sets to benchmark performance.

I think the same issue may exist for level one and two caches. L1 and L2 are per physical processor, but a processor group is made up of logical cores. If a physical processor with two logical cores has one logical core in group 0 and the other in group 1, then the L1 and L2 caches for that physical processor also will be in two processor groups.

Oh, processor groups. What a fantastic bloody idea not.

I am not surprised this issue exists. The API to get topology info is appallingly complex and inadequately documented for its complexity. The processor group concept raised the complexity of the data by a power of two - and it’s complex enough to begin with.

I will need to think more, but if I can’t figure something more out, then the benchmark application cannot support processor groups on Windows due to flaws in the Windows topology information API.

Christ, it gets worse.

Check this;

https://blogs.msdn.microsoft.com/saponsqlserver/2011/10/08/uneven-windows-processor-groups/

Windows (as I know) tries to minimize the number of processor groups, by making them as large as possible (up to their 64 core limit - 64 cores, 640kb RAM, you think they’d notice). However, naturally, if the number of logical cores in the system isn’t divisible by 64, you end up with uneven groups. (It also implies a processor group, which is the basic scheduling entity, can have multiple NUMA nodes, which implies scheduling is not actually NUMA aware, but only processor group aware - and that’s insane).

Intel bought out a 10 core CPU (bloody obvious, given the relatively slow rate of higher core numbers) with 20 logical cores, which induces this.

So there’s now a hotfix for Windows which modifies how processor groups are formed up, to ensure even groups. So some systems will have this, and some not…

Bloody Microsoft

I’ve been rewriting the topology code.

This code is partially an abstraction layer (and so that part must be friendly to users, easy to understand and implement). It has the job of representing the system processor topology in a btree, i.e. NUMA nodes, sockets, caches, physical cores, logical cores.

Under Linux, it’s easy.

Under Windows, OMG I don’t even

The problem is Windows has added into the mix a completely redundent, unnecessary and complicating concept called a “processor group”. Actual logical core IDs only go up to 64 - the largest number of logical cores in one processor group. So to identify a core, you must identify the processor group, too. Processor groups SPAN NUMA NODES, so the members are potentially HETEROGENEOUS.

Because the processor group must be specified, when you start using the Windows API for enumerating topology, you can have MULTIPLE entries for the SAME entity, where each entry lists a set of logical cores for the same processor group. So a given socket might have say four entries, all the logical procesors in processor group 0, then all those in group 1, etc.

Now, remember - I’m representing the topology in a btree. To link an element, I need in fact to know its full set of logical processors, so I can sort it to the correct location in the tree. In Windows, I can only KNOW that I know this BY FULLY ENUMERATING THE ENTIRE TOPOLOGY, i.e. I actually have to iterate over the entire topology for EVERYTHING I FIND, to ensure I have every logical processor which belongs to it.

The only reason for this madness is processor groups, which I’m going to utterly ignore, always (except I need to know them to be able to start threads on the logical cores I want).

Test and benchmark

I’ve been thinking quite a bit.

I’m currently (re-re-re-re-)writing the benchmark app.

That’s fine. I’ve gone back to a using a library for as much stuff as possible, because I find it easier to think and lay out code properly. When writing libraries these days, I look to avoid memory allocation - I have the user pass in allocations. Problem is when you come to something where the size of the allocation cannot reasonably be known - it’s the result of some complex work inside the library, so the user can’t know beforehand how much store to allocate.

One simple, inefficient solution is to ask the user to pass in worst-case allocations. For smaller allocations, where the worst-case can easily be calculated, this can be okay, and I’m pretty sure I can use this approach for the benchmark app, in its current form - although this is because the benchmark app makes no large per-NUMA node allocations; all the per-NUMA stuff can be allocated on the stack, in each benchmark thread, and so naturally (normally - OS decides but this is how Windows and Linux work) goes on the NUMA node for that thread.

If the benchmark did make large per-NUMA node allocations, the user would have to make them and hand them over…

…which is exactly how things are with the test app. This does make large per-NUMA node allocations.

In fact, what ends up emerging from all this is that the benchmark and test both become libaries, and the apps are just stdlib main()-type binaries which call the very high level benchmark/test call (singular), handing over the necessary memory, and getting results back.

This way embedded users who cannot malloc simply reserve heap space and pass it in.

(Abstraction layer for I/O, where the output is going into a line buffer, which is passed to a user provided callback - both the normal output and the gnuplots going to this interface, which on the Windows/Linux stuff means to stdout - the user pipes to disk).

This almost suggests test and benchmark become integral in the liblfds library - but this isn’t so, for two reasons; firstly, it makes the library bigger, where test and benchmark only need to run for particular reasons rather than being generally available and secondly, test requires a thread-starter/waiter abstraction and benchmark requires a thread-starter/waiter and topology abstraction.

The test app generally right now needs to be rewritten from scratch to be something really decent.

The benchmark app is now in its design really decent, but I’m at the point where I need to choose between a malloc or non-malloc approach.

2016-02-24

.onion

I currently have the Ci20 board doing a brute-force on Tor .onion ‘domain names’ to give me a vanity name which starts with ‘liblfds’ and then is followed by a number.

Once I have this, I’ll move liblfds.org fully to the .onion site, and leave a placeholder on the liblfds.org domain, which explains where the site has gone.

2016-02-21

.onion endpoint up

I have create a .onion endpoint for the site.

http://k263wv5uwidihxl4.onion:8080/

The blog doesn’t work as wordpress redirects itself to a URL it is configured to think of as its home, so it can’t exist on two URLs at the same time - it’s not using relative URLs all the time. Have to think about what to do about this.

2016-02-13

Update

Just added per-data structure CAS/DWCAS backoff values. Removed the PRNG part of the backoff, but I think I said that earlier.

Been working on benchmark. Starting pretty much from scratch, but with the right ideas this time - btree for benchmarks, btree for results, abstraction layer for the locks.

The benchmark app has been a tar pit, because I’ve kept NOT starting from scratch, and so been mentally constrained in my thought my the code which already exists - which meant I never was able to break away from its design flaws.

I think the benchmark will be done, and done PROPERLY AT LAST FUCK ME in a week.

That thing has taken up an order of magnitude more time than it should have. Live and learn - tar pits.

Once benchmark is done, and I’ve sorted out power for the Pi and Ci20, I need to write a build and test system. I can’t keep manually making releases, it’s way too time consuming (and error prone).

Jesus, that reminds me, I’ll need to reinstall the Windows 8 trial to get the MSVC 2013 dev environment up… that whole process is so costly, in time and effort and mental agony. I literally dread doing it. It’s a plague upon the library and my personal happiness. I need to find a better way.

2016-02-12

Four core gnuplot

freelist_4core

From my Core i5.

2016-02-09

First gnuplot

ops_per_lp_one_chart_per_lps_per_benchmark_one_datastructure_36cores_dwcas10only

ABsolutely fascenating. When placed in graphcal form, behaviours otherwise obscured in the mass of numbers become visible to the eye. This particular machine has dual sockets, with a total of 36 logical cores. That’s a strange number I suspect for a hypercube, and so I suspect some of the cores are disadvantaged with regard to the others when it comes to memory access - and so we see a slow core…

This of course was playing merry hell with the standard deviation numbers.

2016-02-08

PRNG ha!

Adding an ABA counter to each queue state doesn’t solve the problem because they all init to 0, so if we have elements bouncing between queues, all those queues to begin with are going to have similar ABA values, i.e. the problem isn’t fixed.

So I need to keep the PRNG code so I can init each per-queue ABA counter to a different value!

loling here :-)

At least all that PRNG code isn’t wasted!

Removing PRNG

As subject.

A downside is that PRNG was being used to control the initial counter value for the next pointer in queue elements.

Now I have to use an atomic add, which will I think be the ONLY use of atomic add in the code base, and it’ll mean a bottleneck on that counter in the queue state.

Nothing else for it, except per-thread state, and I can’t justify per-thread state to avoid one atomic add.

2016-02-07

Permitting greater exponentiation

When a thread collides, it backs off. Each successive backoff doubles the wait period. In all the testing so far there’s a maximum of 10 backoffs.

I tried raising it to 30.

A section of freelist result is below (no PRNG);

  1   1 28832804,2883280,339468,Lock-Free (DWCAS 0),15616601(2),13216203(3)
  1   1 124087964,12408796,589467,Lock-Free (DWCAS 1),59959900(2),64128064(3)
  1   1 124029906,12402991,17540194,Lock-Free (DWCAS 2),1001(2),124028905(3)
  1   1 124090967,12409097,17548830,Lock-Free (DWCAS 3),1001(2),124089966(3)
  1   1 124090967,12409097,17548830,Lock-Free (DWCAS 4),1001(2),124089966(3)
  1   1 124097974,12409797,17549821,Lock-Free (DWCAS 5),1001(2),124096973(3)
  1   1 124118995,12411900,17552793,Lock-Free (DWCAS 6),124117994(2),1001(3)
  1   1 124067944,12406794,17545574,Lock-Free (DWCAS 7),1001(2),124066943(3)
  1   1 124106983,12410698,17551095,Lock-Free (DWCAS 8),124105982(2),1001(3)
  1   1 124119996,12412000,17552935,Lock-Free (DWCAS 9),124118995(2),1001(3)
  1   1 124126002,12412600,17553784,Lock-Free (DWCAS 10),124125001(2),1001(3)
  1   1 124070947,12407095,17545998,Lock-Free (DWCAS 11),124069946(2),1001(3)
  1   1 124089966,12408997,17548688,Lock-Free (DWCAS 12),1001(2),124088965(3)
  1   1 124096973,12409697,17549679,Lock-Free (DWCAS 13),124095972(2),1001(3)
  1   1 124078955,12407896,17547131,Lock-Free (DWCAS 14),124077954(2),1001(3)
  1   1 124061938,12406194,17544724,Lock-Free (DWCAS 15),124060937(2),1001(3)
  1   1 124087964,12408796,17548405,Lock-Free (DWCAS 16),1001(2),124086963(3)
  1   1 123936813,12393681,17527029,Lock-Free (DWCAS 17),1001(2),123935812(3)
  1   1 124076953,12407695,17546848,Lock-Free (DWCAS 18),1001(2),124075952(3)
  1   1 124051928,12405193,17543309,Lock-Free (DWCAS 19),1001(2),124050927(3)
  1   1 124061938,12406194,17544724,Lock-Free (DWCAS 20),1001(2),124060937(3)

Interestin’.

Normal on 0 and 1, but above that and the loosing thread is consigned to backoff limbo.

So I’m getting the feeling there’s a balance here with backoff exponentiation. Too little, and you can’t climb rapidly enough to usefully long backoff periods (see the results for non-expoential backoff). Too much, and threads go into limbo.

And prolly optimal/near-optimal values vary by platform.

Scylla and Chablis anyone?

Very large back-off values

1 1 1 1 93031939,4651597,16112911,Lock-Free (DWCAS 1000000),1001(0),93028936(1),1001(2),1001(3)

Cute, huh?

I’ve had a partial theory for this - basically, with backoff, one thread will successfully DWCAS, and then everyone else who also was trying then will fail. Those who failed backoff. The thread who succeeded immediately goes again, and again, and again… and so when the thread who have backed-off finally restart, the chances are the other thread who won earlier is already in the middle of an operation, and so they will fail again.

So here we see with a very large backoff value, one thread does all the work and the others almost nothing.

Question is though, how did they even get to do that little bit? because once they win an operation, they ought to become the dominating thread.

Hyperthreading

With and without hyperthreading (with PRNG) on my Core i5.

Freelist Push One Pop One

   M   
   N   
   S   
  L3U  
L2U L2U
L1D L1D
L1I L1I
 P   P 
 L   L  total ops,mean ops/sec/core,std dev/sec/core,lock type,per-thread total ops
 1      159281122,31856224,0,GCC Spinlock (atomic),159281122(0)
 1      159582423,31916485,0,GCC Spinlock (sync),159582423(0)
 1      134044911,26808982,0,Lock-Free (DWCAS 0),134044911(0)
 1      134774640,26954928,0,Lock-Free (DWCAS 1),134774640(0)
 1      134800666,26960133,0,Lock-Free (DWCAS 2),134800666(0)
 1      134797663,26959533,0,Lock-Free (DWCAS 3),134797663(0)
 1      134815681,26963136,0,Lock-Free (DWCAS 4),134815681(0)
 1      134804670,26960934,0,Lock-Free (DWCAS 5),134804670(0)
 1      134762628,26952526,0,Lock-Free (DWCAS 6),134762628(0)
 1      134807673,26961535,0,Lock-Free (DWCAS 7),134807673(0)
 1      134810676,26962135,0,Lock-Free (DWCAS 8),134810676(0)
 1      134793659,26958732,0,Lock-Free (DWCAS 9),134793659(0)
 1      134819685,26963937,0,Lock-Free (DWCAS 10),134819685(0)
 1      97466369,19493274,0,PThread Mutex,97466369(0)
 1      183412229,36682446,0,PThread Spinlock (private),183412229(0)
 1      183308125,36661625,0,PThread Spinlock (shared),183308125(0)
 1  1   18018000,1801800,152322,GCC Spinlock (atomic),9547538(0),8470462(1)
 1  1   17106089,1710609,114807,GCC Spinlock (sync),8958950(0),8147139(1)
 1  1   32827795,3282780,62712,Lock-Free (DWCAS 0),16635619(0),16192176(1)
 1  1   32523491,3252349,22508,Lock-Free (DWCAS 1),16341325(0),16182166(1)
 1  1   63638575,6363858,846404,Lock-Free (DWCAS 2),34811777(0),28826798(1)
 1  1   78243165,7824316,2103481,Lock-Free (DWCAS 3),31684653(0),46558512(1)
 1  1   85629544,8562954,2075593,Lock-Free (DWCAS 4),50153103(0),35476441(1)
 1  1   93085993,9308599,1993912,Lock-Free (DWCAS 5),39493454(0),53592539(1)
 1  1   97589492,9758949,3382784,Lock-Free (DWCAS 6),60754694(0),36834798(1)
 1  1   101232131,10123213,1778170,Lock-Free (DWCAS 7),44329285(0),56902846(1)
 1  1   104002899,10400290,3151612,Lock-Free (DWCAS 8),63144081(0),40858818(1)
 1  1   106612506,10661251,2264721,Lock-Free (DWCAS 9),45299254(0),61313252(1)
 1  1   108466358,10846636,3882218,Lock-Free (DWCAS 10),67958891(0),40507467(1)
 1  1   13366353,1336635,147650,PThread Mutex,6161155(0),7205198(1)
 1  1   21487466,2148747,2562569,PThread Spinlock (private),1683682(0),19803784(1)
 1  1   21140119,2114012,2167468,PThread Spinlock (shared),18233215(0),2906904(1)
Freelist Push One Pop One

   M   
   N   
   S   
  L3U  
L2U L2U
L1D L1D
L1I L1I
 P   P 
L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type,per-thread total ops
  1     159535376,31907075,0,GCC Spinlock (atomic),159535376(2)
  1     159678519,31935704,0,GCC Spinlock (sync),159678519(2)
  1     134826692,26965338,0,Lock-Free (DWCAS 0),134826692(2)
  1     134753619,26950724,0,Lock-Free (DWCAS 1),134753619(2)
  1     134825691,26965138,0,Lock-Free (DWCAS 2),134825691(2)
  1     134782648,26956530,0,Lock-Free (DWCAS 3),134782648(2)
  1     134794660,26958932,0,Lock-Free (DWCAS 4),134794660(2)
  1     134813679,26962736,0,Lock-Free (DWCAS 5),134813679(2)
  1     134813679,26962736,0,Lock-Free (DWCAS 6),134813679(2)
  1     134808674,26961735,0,Lock-Free (DWCAS 7),134808674(2)
  1     134767633,26953527,0,Lock-Free (DWCAS 8),134767633(2)
  1     134806672,26961334,0,Lock-Free (DWCAS 9),134806672(2)
  1     134809675,26961935,0,Lock-Free (DWCAS 10),134809675(2)
  1     96996900,19399380,0,PThread Mutex,96996900(2)
  1     183458275,36691655,0,PThread Spinlock (private),183458275(2)
  1     183468285,36693657,0,PThread Spinlock (shared),183468285(2)
  1   1 18229211,1822921,4388,GCC Spinlock (atomic),9130121(2),9099090(3)
  1   1 17092075,1709208,27038,GCC Spinlock (sync),8641633(2),8450442(3)
  1   1 32482450,3248245,22650,Lock-Free (DWCAS 0),16321305(2),16161145(3)
  1   1 44506462,4450646,2955548,Lock-Free (DWCAS 1),32702670(2),11803792(3)
  1   1 32506474,3250647,52661,Lock-Free (DWCAS 2),16439423(2),16067051(3)
  1   1 85209124,8520912,10768964,Lock-Free (DWCAS 3),80678598(2),4530526(3)
  1   1 85710625,8571062,4895382,Lock-Free (DWCAS 4),60163103(2),25547522(3)
  1   1 38030993,3803099,753256,Lock-Free (DWCAS 5),21678657(2),16352336(3)
  1   1 103950847,10395085,12435016,Lock-Free (DWCAS 6),95939844(2),8011003(3)
  1   1 100723623,10072362,5632641,Lock-Free (DWCAS 7),70276206(2),30447417(3)
  1   1 104477373,10447737,6747590,Lock-Free (DWCAS 8),76095019(2),28382354(3)
  1   1 88730642,8873064,5639861,Lock-Free (DWCAS 9),64305241(2),24425401(3)
  1   1 108837729,10883773,7286378,Lock-Free (DWCAS 10),80180100(2),28657629(3)
  1   1 11494483,1149448,31002,PThread Mutex,5637632(2),5856851(3)
  1   1 20757737,2075774,2678509,PThread Spinlock (private),908908(2),19848829(3)
  1   1 19484465,1948446,2098385,PThread Spinlock (shared),17161144(2),2323321(3)
1 1     75932857,7593286,26472,GCC Spinlock (atomic),37872835(0),38060022(2)
1 1     75178103,7517810,124717,GCC Spinlock (sync),38029992(0),37148111(2)
1 1     102600498,10260050,123160,Lock-Free (DWCAS 0),50864814(0),51735684(2)
1 1     103328225,10332822,954558,Lock-Free (DWCAS 1),48289241(0),55038984(2)
1 1     102682580,10268258,824462,Lock-Free (DWCAS 2),48426378(0),54256202(2)
1 1     102457355,10245736,828567,Lock-Free (DWCAS 3),48299251(0),54158104(2)
1 1     102325223,10232522,1054218,Lock-Free (DWCAS 4),47435388(0),54889835(2)
1 1     102181079,10218108,635192,Lock-Free (DWCAS 5),48844796(0),53336283(2)
1 1     102107005,10210700,720979,Lock-Free (DWCAS 6),48504456(0),53602549(2)
1 1     101282181,10128218,850651,Lock-Free (DWCAS 7),47633586(0),53648595(2)
1 1     102011910,10201191,629954,Lock-Free (DWCAS 8),48778730(0),53233180(2)
1 1     101982881,10198288,701444,Lock-Free (DWCAS 9),48511463(0),53471418(2)
1 1     101952851,10195285,743912,Lock-Free (DWCAS 10),48346298(0),53606553(2)
1 1     39919880,3991988,72480,PThread Mutex,19703684(0),20216196(2)
1 1     115713598,11571360,18969,PThread Spinlock (private),57923866(0),57789732(2)
1 1     115773658,11577366,104190,PThread Spinlock (shared),58255197(0),57518461(2)
1 1 1 1 13546533,677327,148017,GCC Spinlock (atomic),3727724(0),3126123(1),3770767(2),2921919(3)
1 1 1 1 13681668,684083,174502,GCC Spinlock (sync),3843840(0),2938936(1),3866863(2),3032029(3)
1 1 1 1 17080063,854003,22305,Lock-Free (DWCAS 0),4310306(0),4339335(1),4214210(2),4216212(3)
1 1 1 1 28626598,1431330,91867,Lock-Free (DWCAS 1),7144137(0),6860854(1),7505498(2),7116109(3)
1 1 1 1 48258210,2412910,441860,Lock-Free (DWCAS 2),12450438(0),10648638(1),13627614(2),11531520(3)
1 1 1 1 58631573,2931579,766001,Lock-Free (DWCAS 3),15346331(0),12356344(1),17413396(2),13515502(3)
1 1 1 1 66423357,3321168,344238,Lock-Free (DWCAS 4),15815800(0),15679664(1),17526509(2),17401384(3)
1 1 1 1 70735665,3536783,572737,Lock-Free (DWCAS 5),17946929(0),15792777(1),19768749(2),17227210(3)
1 1 1 1 74159085,3707954,845888,Lock-Free (DWCAS 6),19045026(0),19142123(1),20871851(2),15100085(3)
1 1 1 1 77335258,3866763,302714,Lock-Free (DWCAS 7),18595577(0),18562544(1),20165145(2),20011992(3)
1 1 1 1 80018939,4000947,393073,Lock-Free (DWCAS 8),18754736(0),19400381(1),20603583(2),21260239(3)
1 1 1 1 80867787,4043389,317851,Lock-Free (DWCAS 9),19298279(0),19557538(1),21036015(2),20975955(3)
1 1 1 1 82673591,4133680,619225,Lock-Free (DWCAS 10),18531513(0),19952933(1),22563541(2),21625604(3)
1 1 1 1 15739724,786986,18710,PThread Mutex,3987984(0),3887884(1),3974971(2),3888885(3)
1 1 1 1 18699681,934984,86032,PThread Spinlock (private),4585581(0),4424420(1),5013008(2),4676672(3)
1 1 1 1 19945926,997296,158641,PThread Spinlock (shared),4492488(0),4872868(1),4983979(2),5596591(3)

The results are just another page in this tome of madness.

If you look at the equivelent with/without results for DWCAS 10, you have these two;

 1  1   108466358,10846636,3882218,Lock-Free (DWCAS 10),67958891(0),40507467(1)
  1   1 108837729,10883773,7286378,Lock-Free (DWCAS 10),80180100(2),28657629(3)

Fine. No worries there. In this particular test without seems a lot more fair but it’s a one-off; the next time I ran that same test on with-hyperthreading I saw this;

  1   1 108644536,10864454,2586069,Lock-Free (DWCAS 10),45179134(2),63465402(3)

So basically the results are give-or-take identical. This is what we would expect.

However… go check the results for DWCAS 2, 5 and 9, on “with”.

Huge fucking dips in performance.

Which do not show up with hyperthreading turned off.

And these dips GO AWAY if you run with all four logical cores, rather than just two.

What the holy jesus christ good god I don’t even

2016-02-06

Results round two

So, wow, stuff, and another 15 bucks of AWS time :-)

Current result is that on a single NUMA node, lock-free wins, but as soon as we go over multiple NUMA nodes, pthreads mutex wins.

I’ve been reading up on the mutex implementation and looking at the source code. My preliminary understanding is that the mutex works by having a queue of waiting threads, which are sleeping in the kernel, and when the thread currently holding the mutex goes to sleep, it goes and hands the mutex to the next thread (this is why it’s so fair).

The basic upshot is that the lock is inherently, by its design, acting to transform contention on a single memory location (the lock). This doesn’t win, if we’re on a single NUMA node - but as soon as we have a single thread on the second NUMA node, lock-free loses about 30% performance and mutex gains about 30% - and at that point, begins to win, and the more threads we have on the second NUMA node, the bigger the win.

The lock-free stuff shows some wierd-ass behaviour though over multiple NUMA nodes. For example, when we add the first logical core from the second NUMA node, all the threads on the first NUMA node go from like 3m ops each to about 400k ops each, but the single thread on the second NUMA node does 24m!

My current feeling is that something isn’t right with the way the chip or chipset is mediating cache line contention over NUMA nodes, and that’s basically destroying lock-free performance over multiple NUMA nodes. If it wasn’t for that, I think lock-free would still be beating mutex.

Regarding PRNG vs non-PRNG, well, for all considerations now we have to consider the one-NUMA-node scenarion vs the many-NUMA-nodes-scenario - right now, I think many-NUMA is highly questionable, so basing decisions on it is just not possible - so, regrding PRNG vs non-PRNG, for one NUMA node, well, it’s not quite clear yet. I think I need a little bit more testing - I say this because looking at the results, a lot of performance was still being gained in the step from DWCAS 9 to 10 - which means the backoff values were actually too low. Also, with PRNG basically means halving the DWCAS backoff value, so PRNG DWCAS 10 is the same as without DWCAS 5 - I think I need to run the test on the big machine again, but with a wider range of DWCAS values.

I can try such tests now though on an AWS instance which is half the size, since I’m sticking for now to one NUMA node, until I figure out more what’s going on with multiple nodes.

Here are the results with PRNG

[ec2-user@ip-172-30-0-46 gcc_and_gnumake]$ ../../bin/benchmark -d 0-10 -r

Freelist Push One Pop One

                                   M                                   
                 N                                   N                 
                 S                                   S                 
                L3U                                 L3U                
L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U
L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D
L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I
 P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P 
L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type,per-thread total ops
  1                                                                     156960804,31392161,0,GCC Spinlock (atomic),156960804(18)
  1                                                                     168123956,33624791,0,GCC Spinlock (sync),168123956(18)
  1                                                                     173099927,34619985,0,Lock-Free (DWCAS 0),173099927(18)
  1                                                                     173000828,34600166,0,Lock-Free (DWCAS 1),173000828(18)
  1                                                                     173060888,34612178,0,Lock-Free (DWCAS 2),173060888(18)
  1                                                                     173020848,34604170,0,Lock-Free (DWCAS 3),173020848(18)
  1                                                                     172976804,34595361,0,Lock-Free (DWCAS 4),172976804(18)
  1                                                                     173138966,34627793,0,Lock-Free (DWCAS 5),173138966(18)
  1                                                                     173159987,34631997,0,Lock-Free (DWCAS 6),173159987(18)
  1                                                                     173150978,34630196,0,Lock-Free (DWCAS 7),173150978(18)
  1                                                                     173078906,34615781,0,Lock-Free (DWCAS 8),173078906(18)
  1                                                                     173072900,34614580,0,Lock-Free (DWCAS 9),173072900(18)
  1                                                                     173050878,34610176,0,Lock-Free (DWCAS 10),173050878(18)
  1                                                                     142818676,28563735,0,PThread Mutex,142818676(18)
  1                                                                     216405189,43281038,0,PThread Spinlock (private),216405189(18)
  1                                                                     222680458,44536092,0,PThread Spinlock (shared),222680458(18)
  1   1                                                                 26420394,2642039,10759,GCC Spinlock (atomic),13248235(18),13172159(19)
  1   1                                                                 26110084,2611008,66818,GCC Spinlock (sync),13291278(18),12818806(19)
  1   1                                                                 35428393,3542839,12316,Lock-Free (DWCAS 0),17757740(18),17670653(19)
  1   1                                                                 67176109,6717611,7305630,Lock-Free (DWCAS 1),59417358(18),7758751(19)
  1   1                                                                 106434328,10643433,14059732,Lock-Free (DWCAS 2),102925823(18),3508505(19)
  1   1                                                                 121674553,12167455,16405002,Lock-Free (DWCAS 3),118837719(18),2836834(19)
  1   1                                                                 116573457,11657346,321772,Lock-Free (DWCAS 4),57149092(18),59424365(19)
  1   1                                                                 135623488,13562349,2088617,Lock-Free (DWCAS 5),60427367(18),75196121(19)
  1   1                                                                 139891752,13989175,2907983,Lock-Free (DWCAS 6),59664605(18),80227147(19)
  1   1                                                                 135640505,13564050,256370,Lock-Free (DWCAS 7),66913847(18),68726658(19)
  1   1                                                                 142388246,14238825,1420158,Lock-Free (DWCAS 8),66173107(18),76215139(19)
  1   1                                                                 145101957,14510196,456823,Lock-Free (DWCAS 9),70935865(18),74166092(19)
  1   1                                                                 150821671,15082167,1429359,Lock-Free (DWCAS 10),70357287(18),80464384(19)
  1   1                                                                 24684660,2468466,118063,PThread Mutex,11924913(18),12759747(19)
  1   1                                                                 46714668,4671467,582956,PThread Spinlock (private),25418393(18),21296275(19)
  1   1                                                                 46091045,4609104,542893,PThread Spinlock (shared),24964940(18),21126105(19)
  1   1   1                                                             21969948,1464663,410830,GCC Spinlock (atomic),8518510(18),7744737(19),5706701(20)
  1   1   1                                                             21135114,1409008,1196701,GCC Spinlock (sync),7098091(18),11249238(19),2787785(20)
  1   1   1                                                             20162142,1344143,297335,Lock-Free (DWCAS 0),6317311(18),7913906(19),5930925(20)
  1   1   1                                                             41969928,2797995,1843247,Lock-Free (DWCAS 1),20545525(18),13911898(19),7512505(20)
  1   1   1                                                             57953896,3863593,4669683,Lock-Free (DWCAS 2),36755719(18),3926923(19),17271254(20)
  1   1   1                                                             78185107,5212340,8689918,Lock-Free (DWCAS 3),60892832(18),2812810(19),14479465(20)
  1   1   1                                                             89778689,5985246,8557577,Lock-Free (DWCAS 4),62078016(18),2014012(19),25686661(20)
  1   1   1                                                             86935849,5795723,3326296,Lock-Free (DWCAS 5),35261226(18),36263227(19),15411396(20)
  1   1   1                                                             106000895,7066726,1846473,Lock-Free (DWCAS 6),28187159(18),36829793(19),40983943(20)
  1   1   1                                                             100361261,6690751,2722580,Lock-Free (DWCAS 7),38807769(18),39212173(19),22341319(20)
  1   1   1                                                             97405308,6493687,797022,Lock-Free (DWCAS 8),29274245(18),34602568(19),33528495(20)
  1   1   1                                                             102199097,6813273,1178875,Lock-Free (DWCAS 9),29555526(18),34868834(19),37774737(20)
  1   1   1                                                             109101993,7273466,1868965,Lock-Free (DWCAS 10),29430401(18),37084047(19),42587545(20)
  1   1   1                                                             13495482,899699,74601,PThread Mutex,4617613(18),4196192(19),4681677(20)
  1   1   1                                                             37062025,2470802,127169,PThread Spinlock (private),12542530(18),12678666(19),11840829(20)
  1   1   1                                                             37215178,2481012,129331,PThread Spinlock (shared),12714702(18),12620608(19),11879868(20)
  1   1   1   1                                                         19408389,970419,1248933,GCC Spinlock (atomic),4180176(18),8038030(19),7147140(20),43043(21)
  1   1   1   1                                                         17036019,851801,993008,GCC Spinlock (sync),5036031(18),13013(19),6029023(20),5957952(21)
  1   1   1   1                                                         20811791,1040590,71456,Lock-Free (DWCAS 0),5243238(18),5218213(19),5424419(20),4925921(21)
  1   1   1   1                                                         19609590,980480,34580,Lock-Free (DWCAS 1),4908904(18),5041036(19),4836832(20),4822818(21)
  1   1   1   1                                                         32441409,1622070,978665,Lock-Free (DWCAS 2),11034023(18),4244240(19),8635627(20),8527519(21)
  1   1   1   1                                                         46338292,2316915,2677073,Lock-Free (DWCAS 3),2926924(18),9916907(19),11841830(20),21652631(21)
  1   1   1   1                                                         41339298,2066965,140906,Lock-Free (DWCAS 4),10460450(18),9784775(19),10337327(20),10756746(21)
  1   1   1   1                                                         51128077,2556404,618348,Lock-Free (DWCAS 5),12416404(18),10458448(19),13673660(20),14579565(21)
  1   1   1   1                                                         58999941,2949997,551752,Lock-Free (DWCAS 6),13101088(18),14001988(19),16802786(20),15094079(21)
  1   1   1   1                                                         86262176,4313109,4646966,Lock-Free (DWCAS 7),1545544(18),27193166(19),30143113(20),27380353(21)
  1   1   1   1                                                         75204129,3760206,300554,Lock-Free (DWCAS 8),19829810(18),19206187(19),18022004(20),18146128(21)
  1   1   1   1                                                         103590487,5179524,5772004,Lock-Free (DWCAS 9),40425385(18),28347319(19),2051049(20),32766734(21)
  1   1   1   1                                                         110892782,5544639,6258282,Lock-Free (DWCAS 10),32554522(18),28701673(19),46474428(20),3162159(21)
  1   1   1   1                                                         25613588,1280679,69039,PThread Mutex,6364358(18),6577571(19),6533527(20),6138132(21)
  1   1   1   1                                                         33778745,1688937,643684,PThread Spinlock (private),6642636(18),7435428(19),8815807(20),10884874(21)
  1   1   1   1                                                         33741708,1687085,669487,PThread Spinlock (shared),6633627(18),7277270(19),8857849(20),10972962(21)
  1   1   1   1   1                                                     13366353,534654,249575,GCC Spinlock (atomic),2082080(18),2106104(19),2568566(20),3108105(21),3501498(22)
  1   1   1   1   1                                                     12596584,503863,191824,GCC Spinlock (sync),1994993(18),2022020(19),2752750(20),2785783(21),3041038(22)
  1   1   1   1   1                                                     19071052,762842,73280,Lock-Free (DWCAS 0),3865862(18),3909906(19),3491488(20),3939936(21),3863860(22)
  1   1   1   1   1                                                     17463446,698538,35839,Lock-Free (DWCAS 1),3581578(18),3566563(19),3392389(20),3403400(21),3519516(22)
  1   1   1   1   1                                                     18877859,755114,42649,Lock-Free (DWCAS 2),3674671(18),3679676(19),3794791(20),3793790(21),3934931(22)
  1   1   1   1   1                                                     22464442,898578,44389,Lock-Free (DWCAS 3),4340336(18),4501497(19),4652648(20),4496492(21),4473469(22)
  1   1   1   1   1                                                     47299252,1891970,3358650,Lock-Free (DWCAS 4),23929906(18),6277271(19),2071069(20),7118111(21),7902895(22)
  1   1   1   1   1                                                     37445408,1497816,448987,Lock-Free (DWCAS 5),8963955(18),5880875(19),7596589(20),7137130(21),7866859(22)
  1   1   1   1   1                                                     47970923,1918837,730385,Lock-Free (DWCAS 6),7290283(18),8686678(19),11936925(20),10846836(21),9210201(22)
  1   1   1   1   1                                                     50668618,2026745,688371,Lock-Free (DWCAS 7),7909902(18),9479470(19),12383371(20),11227216(21),9668659(22)
  1   1   1   1   1                                                     76475399,3059016,3343326,Lock-Free (DWCAS 8),24031007(18),1488487(19),17922905(20),15372357(21),17660643(22)
  1   1   1   1   1                                                     70566496,2822660,784189,Lock-Free (DWCAS 9),15750735(18),10882872(19),15401386(20),13740727(21),14790776(22)
  1   1   1   1   1                                                     74372298,2974892,256642,Lock-Free (DWCAS 10),14227213(18),14339325(19),15554539(20),14705691(21),15545530(22)
  1   1   1   1   1                                                     24406382,976255,113666,PThread Mutex,5350345(18),4637633(19),4816812(20),4915911(21),4685681(22)
  1   1   1   1   1                                                     29500471,1180019,579824,PThread Spinlock (private),7664657(18),7102095(19),4720716(20),4351347(21),5661656(22)
  1   1   1   1   1                                                     29771742,1190870,250703,PThread Spinlock (shared),6307301(18),6805799(19),5628623(20),5176171(21),5853848(22)
  1   1   1   1   1   1                                                 11784773,392826,262934,GCC Spinlock (atomic),2018016(18),2427425(19),2071069(20),2191189(21),2275273(22),801801(23)
  1   1   1   1   1   1                                                 11212201,373740,339386,GCC Spinlock (sync),1470469(18),2455453(19),1920919(20),536536(21),2371369(22),2457455(23)
  1   1   1   1   1   1                                                 18025007,600834,14996,Lock-Free (DWCAS 0),3001999(18),2955953(19),3031028(20),3046043(21),3013010(22),2976974(23)
  1   1   1   1   1   1                                                 17746729,591558,15095,Lock-Free (DWCAS 1),2982980(18),2962960(19),2932930(20),2962960(21),2998996(22),2905903(23)
  1   1   1   1   1   1                                                 19007989,633600,230976,Lock-Free (DWCAS 2),3406403(18),3361358(19),3406403(20),3338335(21),3380377(22),2115113(23)
  1   1   1   1   1   1                                                 20378358,679279,284127,Lock-Free (DWCAS 3),3676673(18),3607604(19),3690687(20),3630627(21),3671668(22),2101099(23)
  1   1   1   1   1   1                                                 28124096,937470,460122,Lock-Free (DWCAS 4),4908904(18),4652648(19),2664662(20),5197192(21),5272267(22),5428423(23)
  1   1   1   1   1   1                                                 28454426,948481,191239,Lock-Free (DWCAS 5),4455451(18),4581577(19),4667663(20),4545541(21),4600596(22),5603598(23)
  1   1   1   1   1   1                                                 42612570,1420419,2269869,Lock-Free (DWCAS 6),4484480(18),5084079(19),5765760(20),5099094(21),4753749(22),17425408(23)
  1   1   1   1   1   1                                                 49387338,1646245,2724952,Lock-Free (DWCAS 7),5208203(18),6144138(19),6344338(20),5829824(21),5228223(22),20632612(23)
  1   1   1   1   1   1                                                 52943891,1764796,2907446,Lock-Free (DWCAS 8),4875871(18),5733728(19),7678671(20),6728722(21),5973968(22),21952931(23)
  1   1   1   1   1   1                                                 59521462,1984049,2798960,Lock-Free (DWCAS 9),6000995(18),7050043(19),8827819(20),8003996(21),7093086(22),22545523(23)
  1   1   1   1   1   1                                                 66248182,2208273,2686738,Lock-Free (DWCAS 10),7331324(18),8556548(19),9911902(20),8942934(21),8321313(22),23184161(23)
  1   1   1   1   1   1                                                 23829806,794327,101261,PThread Mutex,4263259(18),4156152(19),3797794(20),3645642(21),3998995(22),3967964(23)
  1   1   1   1   1   1                                                 26452426,881748,486082,PThread Spinlock (private),4881877(18),4786782(19),4810806(20),5440435(21),4189185(22),2343341(23)
  1   1   1   1   1   1                                                 25528503,850950,131665,PThread Spinlock (shared),4444440(18),4349345(19),4255251(20),4577573(21),4174170(22),3727724(23)
  1   1   1   1   1   1   1                                             10085075,288145,402941,GCC Spinlock (atomic),964964(18),1124123(19),1476475(20),1868867(21),1649648(22),178178(23),2822820(24)
  1   1   1   1   1   1   1                                             9243234,264092,313662,GCC Spinlock (sync),379379(18),1813812(19),1949948(20),1954953(21),1502501(22),833833(23),808808(24)
  1   1   1   1   1   1   1                                             17166149,490461,102723,Lock-Free (DWCAS 0),2458456(18),2068066(19),2455453(20),2470468(21),2350348(22),2690688(23),2672670(24)
  1   1   1   1   1   1   1                                             16244228,464121,55648,Lock-Free (DWCAS 1),2385383(18),2091089(19),2372370(20),2368366(21),2245243(22),2394392(23),2387385(24)
  1   1   1   1   1   1   1                                             17235218,492435,93576,Lock-Free (DWCAS 2),2537535(18),2064062(19),2512510(20),2469467(21),2412410(22),2626624(23),2612610(24)
  1   1   1   1   1   1   1                                             18610592,531731,119618,Lock-Free (DWCAS 3),2747745(18),2150148(19),2734732(20),2639637(21),2613611(22),2858856(23),2865863(24)
  1   1   1   1   1   1   1                                             20398378,582811,156858,Lock-Free (DWCAS 4),3049046(18),2258256(19),2983981(20),2854852(21),2867865(22),3164161(23),3220217(24)
  1   1   1   1   1   1   1                                             25382357,725210,305508,Lock-Free (DWCAS 5),3678675(18),2283281(19),3849846(20),3626623(21),3732729(22),4050046(23),4161157(24)
  1   1   1   1   1   1   1                                             33765732,964735,784974,Lock-Free (DWCAS 6),6750744(18),1920919(19),4467463(20),4310306(21),4371367(22),5848843(23),6096090(24)
  1   1   1   1   1   1   1                                             39487448,1128213,1177867,Lock-Free (DWCAS 7),7676669(18),1601600(19),4968964(20),4425421(21),4740736(22),8005998(23),8068060(24)
  1   1   1   1   1   1   1                                             47934887,1369568,2005582,Lock-Free (DWCAS 8),6985979(18),1216215(19),5518513(20),4723719(21),4948944(22),12519507(23),12022010(24)
  1   1   1   1   1   1   1                                             53918865,1540539,2082923,Lock-Free (DWCAS 9),9287278(18),1286285(19),6480474(20),5306301(21),5804799(22),13324311(23),12429417(24)
  1   1   1   1   1   1   1                                             60462402,1727497,2092119,Lock-Free (DWCAS 10),9616607(18),1387386(19),8468460(20),6757751(21),6996990(22),13767754(23),13467454(24)
  1   1   1   1   1   1   1                                             17366349,496181,27552,PThread Mutex,2572570(18),2536534(19),2438436(20),2465463(21),2490488(22),2446444(23),2416414(24)
  1   1   1   1   1   1   1                                             21907886,625940,375978,PThread Spinlock (private),2829827(18),2884882(19),3055052(20),2895893(21),2729727(22),4846842(23),2665663(24)
  1   1   1   1   1   1   1                                             22831809,652337,235845,PThread Spinlock (shared),2732730(18),3224221(19),3207204(20),3547544(21),3620617(22),3918915(23),2580578(24)
  1   1   1   1   1   1   1   1                                         8757749,218944,208169,GCC Spinlock (atomic),604604(18),638638(19),822822(20),996996(21),1161160(22),1462461(23),1643642(24),1427426(25)
  1   1   1   1   1   1   1   1                                         8408400,210210,287906,GCC Spinlock (sync),517517(18),455455(19),890890(20),773773(21),761761(22),1803802(23),1413412(24),1791790(25)
  1   1   1   1   1   1   1   1                                         15731716,393293,45750,Lock-Free (DWCAS 0),1971970(18),1949948(19),1998997(20),1769768(21),2061059(22),1981980(23),1976975(24),2021019(25)
  1   1   1   1   1   1   1   1                                         15864849,396621,49696,Lock-Free (DWCAS 1),1964963(18),2003001(19),2052050(20),1770769(21),2086084(22),1999998(23),1988987(24),1998997(25)
  1   1   1   1   1   1   1   1                                         16542526,413563,60842,Lock-Free (DWCAS 2),1991990(18),2123121(19),2159157(20),1812811(21),2151149(22),2104102(23),2103101(24),2097095(25)
  1   1   1   1   1   1   1   1                                         18436418,460910,106690,Lock-Free (DWCAS 3),2196194(18),2329327(19),2370368(20),1847846(21),2384382(22),2445443(23),2452450(24),2410408(25)
  1   1   1   1   1   1   1   1                                         19832813,495820,133765,Lock-Free (DWCAS 4),2393391(18),2483481(19),2510508(20),1906905(21),2542540(22),2682680(23),2695693(24),2617615(25)
  1   1   1   1   1   1   1   1                                         21933912,548348,161699,Lock-Free (DWCAS 5),2598596(18),2704702(19),2861859(20),2056054(21),2955953(22),2874872(23),2986984(24),2894892(25)
  1   1   1   1   1   1   1   1                                         27065038,676626,322041,Lock-Free (DWCAS 6),3250247(18),3337334(19),3657654(20),1966965(21),3777774(22),3549546(23),3863860(24),3661658(25)
  1   1   1   1   1   1   1   1                                         33357324,833933,567039,Lock-Free (DWCAS 7),3912909(18),3946943(19),5287282(20),1835834(21),5104099(22),4097093(23),4607603(24),4565561(25)
  1   1   1   1   1   1   1   1                                         41735694,1043392,1040077,Lock-Free (DWCAS 8),4330326(18),3819816(19),6942936(20),1341340(21),6338332(22),5386381(23),6585579(24),6990984(25)
  1   1   1   1   1   1   1   1                                         47892845,1197321,1283487,Lock-Free (DWCAS 9),4730726(18),4521517(19),9152143(20),1273272(21),7385378(22),6427421(23),6953947(24),7448441(25)
  1   1   1   1   1   1   1   1                                         53519466,1337987,1369591,Lock-Free (DWCAS 10),5410405(18),5088083(19),9225216(20),1406405(21),7983976(22),7687680(23),8127119(24),8590582(25)
  1   1   1   1   1   1   1   1                                         20803783,520095,45815,PThread Mutex,2557555(18),2458456(19),2603601(20),2563561(21),2545543(22),2665663(23),2697695(24),2711709(25)
  1   1   1   1   1   1   1   1                                         22167145,554179,233554,PThread Spinlock (private),2761759(18),3110107(19),3339336(20),2504502(21),3359356(22),2282280(23),2432430(24),2377375(25)
  1   1   1   1   1   1   1   1                                         20683663,517092,405894,PThread Spinlock (shared),1890889(18),1757756(19),2301299(20),2098096(21),2406404(22),3092089(23),4022018(24),3115112(25)
  1   1   1   1   1   1   1   1   1                                     7857850,174619,437136,GCC Spinlock (atomic),1138137(18),1705704(19),1824823(20),780780(21),1847846(22),141141(23),124124(24),148148(25),147147(26)
  1   1   1   1   1   1   1   1   1                                     7360353,163563,529996,GCC Spinlock (sync),3003(18),1675674(19),1911910(20),1735734(21),1886885(22),38038(23),38038(24),35035(25),36036(26)
  1   1   1   1   1   1   1   1   1                                     16292276,362051,104871,Lock-Free (DWCAS 0),1919918(18),1959958(19),1873872(20),1848847(21),1855854(22),1811810(23),1841840(24),1330329(25),1849848(26)
  1   1   1   1   1   1   1   1   1                                     15430415,342898,88522,Lock-Free (DWCAS 1),1722721(18),1832831(19),1773772(20),1772771(21),1784783(22),1728727(23),1753752(24),1306305(25),1754753(26)
  1   1   1   1   1   1   1   1   1                                     16277261,361717,105162,Lock-Free (DWCAS 2),1747746(18),1895894(19),1885884(20),1874873(21),1913912(22),1874873(23),1868867(24),1329328(25),1885884(26)
  1   1   1   1   1   1   1   1   1                                     17083066,379624,122863,Lock-Free (DWCAS 3),1939938(18),1966965(19),1953952(20),1947946(21),1982981(22),1985984(23),1986985(24),1321320(25),1996995(26)
  1   1   1   1   1   1   1   1   1                                     17726709,393927,139122,Lock-Free (DWCAS 4),2035033(18),2061059(19),2012010(20),2004002(21),2036034(22),2082080(23),2088086(24),1319318(25),2089087(26)
  1   1   1   1   1   1   1   1   1                                     19248229,427738,174084,Lock-Free (DWCAS 5),2201199(18),2227225(19),2243241(20),2216214(21),2258256(22),2274272(23),2248246(24),1320319(25),2259257(26)
  1   1   1   1   1   1   1   1   1                                     21519498,478211,228463,Lock-Free (DWCAS 6),2436434(18),2507505(19),2446444(20),2426424(21),2456454(22),2638636(23),2621619(24),1341340(25),2644642(26)
  1   1   1   1   1   1   1   1   1                                     24911887,553597,326183,Lock-Free (DWCAS 7),2754752(18),2835833(19),2834832(20),2806804(21),2801799(22),3184181(23),3157154(24),1313312(25),3223220(26)
  1   1   1   1   1   1   1   1   1                                     30754724,683438,655835,Lock-Free (DWCAS 8),2921919(18),3046043(19),3140137(20),3060057(21),3069066(22),4652648(23),4791787(24),1256255(25),4816812(26)
  1   1   1   1   1   1   1   1   1                                     38971933,866043,1521724,Lock-Free (DWCAS 9),2662660(18),2822820(19),3122119(20),2944942(21),2875873(22),7706699(23),7811804(24),1066065(25),7958951(26)
  1   1   1   1   1   1   1   1   1                                     46413367,1031408,1838093,Lock-Free (DWCAS 10),3012009(18),3308305(19),4002999(20),3601598(21),3404401(22),9150141(23),9251242(24),1049048(25),9633624(26)
  1   1   1   1   1   1   1   1   1                                     22390368,497564,58408,PThread Mutex,2534532(18),2595593(19),2576574(20),2576574(21),2534532(22),2423421(23),2338336(24),2323321(25),2487485(26)
  1   1   1   1   1   1   1   1   1                                     20367347,452608,435150,PThread Spinlock (private),3601598(18),3580577(19),2085083(20),1967966(21),2026024(22),1755754(23),1684683(24),2019017(25),1646645(26)
  1   1   1   1   1   1   1   1   1                                     19444425,432098,190509,PThread Spinlock (shared),1885884(18),2198196(19),2012010(20),1926925(21),1860859(22),2266264(23),2199197(24),2966964(25),2128126(26)
  1   1   1   1   1   1   1   1   1   1                                 7195188,143904,898033,GCC Spinlock (atomic),235235(18),228228(19),258258(20),266266(21),270270(22),306306(23),121121(24),260260(25),272272(26),4976972(27)
  1   1   1   1   1   1   1   1   1   1                                 11663652,233273,1840312,GCC Spinlock (sync),126126(18),118118(19),232232(20),243243(21),234234(22),191191(23),206206(24),209209(25),208208(26),9894885(27)
  1   1   1   1   1   1   1   1   1   1                                 13924911,278498,1189077,Lock-Free (DWCAS 0),769769(18),774774(19),647647(20),718718(21),770770(22),799799(23),796796(24),811811(25),803803(26),7031024(27)
  1   1   1   1   1   1   1   1   1   1                                 21598577,431972,2597670,Lock-Free (DWCAS 1),748748(18),756756(19),771771(20),803803(21),782782(22),801801(23),803803(24),820820(25),826826(26),14481467(27)
  1   1   1   1   1   1   1   1   1   1                                 17872855,357457,2315134,Lock-Free (DWCAS 2),545545(18),565565(19),573573(20),529529(21),541541(22),592592(23),578578(24),586586(25),590590(26),12768756(27)
  1   1   1   1   1   1   1   1   1   1                                 20793773,415875,2799048,Lock-Free (DWCAS 3),600600(18),609609(19),561561(20),602602(21),595595(22),613613(23),614614(24),619619(25),619619(26),15356341(27)
  1   1   1   1   1   1   1   1   1   1                                 18923905,378478,2543880,Lock-Free (DWCAS 4),505505(18),559559(19),550550(20),559559(21),551551(22),564564(23),534534(24),572572(25),566566(26),13958945(27)
  1   1   1   1   1   1   1   1   1   1                                 15798783,315976,1152428,Lock-Free (DWCAS 5),1009008(18),993993(19),993993(20),1003002(21),1028027(22),969969(23),987987(24),789789(25),979979(26),7043036(27)
  1   1   1   1   1   1   1   1   1   1                                 21967946,439359,3109138,Lock-Free (DWCAS 6),568568(18),584584(19),589589(20),600600(21),597597(22),548548(23),554554(24),566566(25),413413(26),16943927(27)
  1   1   1   1   1   1   1   1   1   1                                 26851825,537036,4372088,Lock-Free (DWCAS 7),390390(18),399399(19),402402(20),410410(21),398398(22),391391(23),251251(24),396396(25),388388(26),23423400(27)
  1   1   1   1   1   1   1   1   1   1                                 27162135,543243,4409245,Lock-Free (DWCAS 8),414414(18),416416(19),417417(20),424424(21),410410(22),398398(23),252252(24),406406(25),391391(26),23630607(27)
  1   1   1   1   1   1   1   1   1   1                                 26936910,538738,4369452,Lock-Free (DWCAS 9),391391(18),401401(19),402402(20),400400(21),395395(22),428428(23),263263(24),422422(25),412412(26),23419396(27)
  1   1   1   1   1   1   1   1   1   1                                 27468441,549369,4451751,Lock-Free (DWCAS 10),408408(18),406406(19),403403(20),402402(21),405405(22),442442(23),262262(24),452452(25),422422(26),23862839(27)
  1   1   1   1   1   1   1   1   1   1                                 31185154,623703,59317,PThread Mutex,3161158(18),3130127(19),3177174(20),3186183(21),3182179(22),3272269(23),2941939(24),3004001(25),3077074(26),3053050(27)
  1   1   1   1   1   1   1   1   1   1                                 10474464,209489,1359024,PThread Spinlock (private),223223(18),232232(19),285285(20),285285(21),288288(22),362362(23),576576(24),375375(25),358358(26),7487480(27)
  1   1   1   1   1   1   1   1   1   1                                 11768757,235375,329178,PThread Spinlock (shared),866866(18),941941(19),1053052(20),1077076(21),1143142(22),1479478(23),2249247(24),1413412(25),1445444(26),99099(27)
  1   1   1   1   1   1   1   1   1   1   1                             3660657,66557,154915,GCC Spinlock (atomic),206206(18),264264(19),246246(20),268268(21),260260(22),271271(23),254254(24),193193(25),334334(26),1062061(27),300300(28)
  1   1   1   1   1   1   1   1   1   1   1                             5585580,101556,450794,GCC Spinlock (sync),191191(18),170170(19),187187(20),184184(21),187187(22),176176(23),169169(24),227227(25),197197(26),2011009(27),1884883(28)
  1   1   1   1   1   1   1   1   1   1   1                             20543523,373519,2271624,Lock-Free (DWCAS 0),232232(18),244244(19),247247(20),261261(21),238238(22),268268(23),270270(24),268268(25),265265(26),9503494(27),8744736(28)
  1   1   1   1   1   1   1   1   1   1   1                             19685666,357921,2230520,Lock-Free (DWCAS 1),201201(18),205205(19),207207(20),212212(21),198198(22),210210(23),206206(24),207207(25),206206(26),9263254(27),8568560(28)
  1   1   1   1   1   1   1   1   1   1   1                             21707686,394685,2429060,Lock-Free (DWCAS 2),233233(18),255255(19),260260(20),265265(21),226226(22),242242(23),246246(24),253253(25),258258(26),10119109(27),9348339(28)
  1   1   1   1   1   1   1   1   1   1   1                             22340318,406188,2492727,Lock-Free (DWCAS 3),233233(18),248248(19),254254(20),268268(21),226226(22),278278(23),283283(24),280280(25),278278(26),10380370(27),9609600(28)
  1   1   1   1   1   1   1   1   1   1   1                             17978961,326890,2036293,Lock-Free (DWCAS 4),186186(18),198198(19),205205(20),213213(21),208208(22),192192(23),169169(24),193193(25),190190(26),8855847(27),7367360(28)
  1   1   1   1   1   1   1   1   1   1   1                             19913894,362071,2178247,Lock-Free (DWCAS 5),252252(18),297297(19),282282(20),282282(21),271271(22),253253(23),221221(24),252252(25),250250(26),8869861(27),8681673(28)
  1   1   1   1   1   1   1   1   1   1   1                             19281262,350568,2147839,Lock-Free (DWCAS 6),222222(18),231231(19),231231(20),236236(21),235235(22),234234(23),195195(24),228228(25),224224(26),8614606(27),8628620(28)
  1   1   1   1   1   1   1   1   1   1   1                             19660641,357466,2185076,Lock-Free (DWCAS 7),232232(18),255255(19),243243(20),244244(21),243243(22),234234(23),195195(24),237237(25),227227(26),8897889(27),8650642(28)
  1   1   1   1   1   1   1   1   1   1   1                             19652633,357321,2174948,Lock-Free (DWCAS 8),245245(18),255255(19),254254(20),254254(21),250250(22),246246(23),188188(24),243243(25),233233(26),8855847(27),8626618(28)
  1   1   1   1   1   1   1   1   1   1   1                             20734714,376995,2261888,Lock-Free (DWCAS 9),302302(18),316316(19),294294(20),292292(21),287287(22),276276(23),197197(24),275275(25),257257(26),9167158(27),9069060(28)
  1   1   1   1   1   1   1   1   1   1   1                             19946927,362671,2204888,Lock-Free (DWCAS 10),232232(18),258258(19),245245(20),246246(21),246246(22),272272(23),190190(24),267267(25),261261(26),8966958(27),8760752(28)
  1   1   1   1   1   1   1   1   1   1   1                             31559528,573810,121398,PThread Mutex,2554552(18),2835833(19),2839837(20),2817815(21),2804802(22),2850848(23),2802800(24),2762760(25),2852850(26),3217214(27),3220217(28)
  1   1   1   1   1   1   1   1   1   1   1                             11276265,205023,1400836,PThread Spinlock (private),35035(18),34034(19),50050(20),43043(21),37037(22),37037(23),30030(24),24024(25),24024(26),4968964(27),5992987(28)
  1   1   1   1   1   1   1   1   1   1   1                             11390379,207098,719467,PThread Spinlock (shared),355355(18),367367(19),417417(20),424424(21),467467(22),597597(23),850850(24),668668(25),635635(26),3027024(27),3578575(28)
  1   1   1   1   1   1   1   1   1   1   1   1                         5545540,92426,356083,GCC Spinlock (atomic),162162(18),153153(19),149149(20),157157(21),160160(22),181181(23),176176(24),179179(25),177177(26),1324323(27),1447446(28),1278277(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         4978974,82983,288755,GCC Spinlock (sync),180180(18),170170(19),175175(20),160160(21),163163(22),190190(23),169169(24),188188(25),173173(26),1121120(27),1163162(28),1125124(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         16977961,282966,1403438,Lock-Free (DWCAS 0),245245(18),253253(19),251251(20),256256(21),254254(22),242242(23),236236(24),239239(25),233233(26),4820816(27),5065060(28),4880876(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         15401386,256690,1332742,Lock-Free (DWCAS 1),171171(18),182182(19),177177(20),184184(21),179179(22),167167(23),164164(24),168168(25),166166(26),4621617(27),4743739(28),4476472(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17078061,284634,1444900,Lock-Free (DWCAS 2),231231(18),237237(19),229229(20),229229(21),224224(22),208208(23),203203(24),207207(25),202202(26),5025020(27),5042037(28),5039034(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17039022,283984,1449423,Lock-Free (DWCAS 3),220220(18),230230(19),221221(20),222222(21),216216(22),199199(23),195195(24),203203(25),201201(26),5014009(27),5042037(28),5074069(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17332315,288872,1480101,Lock-Free (DWCAS 4),221221(18),232232(19),223223(20),223223(21),219219(22),196196(23),191191(24),198198(25),194194(26),5118113(27),5134129(28),5181176(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17273256,287888,1477375,Lock-Free (DWCAS 5),222222(18),231231(19),218218(20),221221(21),213213(22),195195(23),188188(24),193193(25),192192(26),5125120(27),5126121(28),5147142(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         15936921,265615,1392485,Lock-Free (DWCAS 6),165165(18),173173(19),172172(20),182182(21),176176(22),159159(23),155155(24),166166(25),160160(26),4786782(27),4857853(28),4782778(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         15729714,262162,1374562,Lock-Free (DWCAS 7),168168(18),175175(19),175175(20),181181(21),173173(22),158158(23),148148(24),157157(25),152152(26),4742738(27),4785781(28),4712708(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         16549533,275826,1431861,Lock-Free (DWCAS 8),194194(18),201201(19),197197(20),203203(21),197197(22),170170(23),163163(24),175175(25),172172(26),4956952(27),4995991(28),4922918(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17083066,284718,1474288,Lock-Free (DWCAS 9),226226(18),230230(19),209209(20),211211(21),202202(22),173173(23),163163(24),173173(25),167167(26),5090085(27),5115110(28),5122117(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         16027011,267117,1410121,Lock-Free (DWCAS 10),155155(18),172172(19),168168(20),172172(21),156156(22),157157(23),147147(24),162162(25),154154(26),4863859(27),4869865(28),4848844(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         29041012,484017,117689,PThread Mutex,2181179(18),2203201(19),2422420(20),2385383(21),2406404(22),2349347(23),2348346(24),2331329(25),2347345(26),2670668(27),2681679(28),2713711(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         12267255,204454,1178537,PThread Spinlock (private),70070(18),104104(19),72072(20),90090(21),23023(22),69069(23),88088(24),76076(25),68068(26),5109104(27),3246243(28),3251248(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         12526514,208775,784796,PThread Spinlock (shared),758758(18),819819(19),961961(20),1015014(21),816816(22),336336(23),336336(24),342342(25),362362(26),4231227(27),51051(28),2494492(29)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     5163158,79433,264850,GCC Spinlock (atomic),147147(18),140140(19),138138(20),140140(21),145145(22),168168(23),163163(24),167167(25),165165(26),963963(27),992992(28),915915(29),915915(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     4702698,72349,216675,GCC Spinlock (sync),164164(18),158158(19),162162(20),150150(21),150150(22),175175(23),159159(24),173173(25),163163(26),802802(27),775775(28),820820(29),847847(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     16121105,248017,1058873,Lock-Free (DWCAS 0),266266(18),275275(19),269269(20),275275(21),265265(22),248248(23),252252(24),254254(25),252252(26),3274271(27),3584581(28),3429426(29),3474471(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     15354339,236221,375396,Lock-Free (DWCAS 1),785785(18),811811(19),799799(20),820820(21),828828(22),892892(23),863863(24),854854(25),859859(26),1906905(27),1886885(28),1989988(29),2052050(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     17020003,261846,1142959,Lock-Free (DWCAS 2),270270(18),277277(19),266266(20),264264(21),255255(22),238238(23),235235(24),234234(25),233233(26),3625622(27),3728725(28),3699696(29),3691688(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     15638623,240594,1087225,Lock-Free (DWCAS 3),206206(18),205205(19),212212(20),217217(21),211211(22),200200(23),196196(24),151151(25),185185(26),3414411(27),3370367(28),3491488(29),3577574(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     16744728,257611,1133133,Lock-Free (DWCAS 4),259259(18),270270(19),254254(20),249249(21),245245(22),223223(23),221221(24),221221(25),222222(26),3566563(27),3636633(28),3679676(29),3695692(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     16425409,252699,1119462,Lock-Free (DWCAS 5),245245(18),244244(19),249249(20),244244(21),244244(22),223223(23),220220(24),172172(25),224224(26),3499496(27),3452449(28),3630627(29),3775772(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     15359344,236298,1057327,Lock-Free (DWCAS 6),209209(18),222222(19),215215(20),215215(21),209209(22),193193(23),190190(24),191191(25),191191(26),3327324(27),3422419(28),3390387(29),3382379(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     15266251,234865,1061525,Lock-Free (DWCAS 7),197197(18),199199(19),209209(20),218218(21),211211(22),194194(23),193193(24),141141(25),177177(26),3314311(27),3324321(28),3383380(29),3503500(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     14999985,230769,1025934,Lock-Free (DWCAS 8),218218(18),221221(19),219219(20),219219(21),211211(22),190190(23),190190(24),191191(25),188188(26),3259256(27),3308305(28),3281278(29),3302299(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     14590576,224470,1035628,Lock-Free (DWCAS 9),168168(18),163163(19),173173(20),182182(21),174174(22),166166(23),168168(24),131131(25),164164(26),3208205(27),3193190(28),3262259(29),3436433(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     12150138,186925,75913,Lock-Free (DWCAS 10),760760(18),802802(19),878878(20),890890(21),856856(22),914914(23),919919(24),935935(25),928928(26),1048047(27),976976(28),1078077(29),1157156(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     30067037,462570,130458,PThread Mutex,2248246(18),2227225(19),2207205(20),2196194(21),2217215(22),2178176(23),2131129(24),2185183(25),2176174(26),2618616(27),2605603(28),2619617(29),2456454(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     12042030,185262,500770,PThread Spinlock (private),374374(18),474474(19),610610(20),507507(21),586586(22),428428(23),432432(24),449449(25),433433(26),1548547(27),1778777(28),2258256(29),2159157(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     11841830,182182,445970,PThread Spinlock (shared),1048047(18),1229228(19),1792791(20),1355354(21),1659658(22),1148147(23),1106105(24),1147146(25),1217216(26),39039(27),28028(28),32032(29),39039(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 4864860,69498,204825,GCC Spinlock (atomic),142142(18),134134(19),133133(20),133133(21),134134(22),155155(23),152152(24),155155(25),154154(26),685685(27),736736(28),710710(29),722722(30),715715(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 4935931,70513,143475,GCC Spinlock (sync),244244(18),251251(19),251251(20),257257(21),246246(22),258258(23),256256(24),255255(25),258258(26),512512(27),976976(28),432432(29),328328(30),407407(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 12143131,173473,128186,Lock-Free (DWCAS 0),899899(18),896896(19),988988(20),998998(21),1007006(22),1034033(23),1030029(24),1031030(25),1026025(26),640640(27),583583(28),677677(29),680680(30),647647(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 15591576,222737,861120,Lock-Free (DWCAS 1),262262(18),270270(19),267267(20),266266(21),264264(22),245245(23),242242(24),245245(25),246246(26),2562560(27),2695693(28),2610608(29),2645643(30),2767765(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14346332,204948,790912,Lock-Free (DWCAS 2),217217(18),222222(19),237237(20),245245(21),240240(22),246246(23),244244(24),246246(25),243243(26),2304302(27),2365363(28),2504502(29),2491489(30),2538536(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 13806793,197240,237233,Lock-Free (DWCAS 3),698698(18),712712(19),745745(20),746746(21),740740(22),785785(23),757757(24),789789(25),780780(26),1419418(27),1369368(28),1444443(29),1436435(30),1378377(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 11751740,167882,205374,Lock-Free (DWCAS 4),654654(18),679679(19),664664(20),666666(21),646646(22),613613(23),581581(24),619619(25),597597(26),1210209(27),1248247(28),1209208(29),1186185(30),1173172(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 11501490,164307,118709,Lock-Free (DWCAS 5),824824(18),870870(19),938938(20),944944(21),911911(22),972972(23),957957(24),986986(25),994994(26),575575(27),561561(28),635635(29),651651(30),672672(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14887873,212684,844694,Lock-Free (DWCAS 6),243243(18),260260(19),238238(20),235235(21),227227(22),217217(23),157157(24),213213(25),210210(26),2608606(27),2590588(28),2602600(29),2587585(30),2496494(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 17145128,244930,1008798,Lock-Free (DWCAS 7),209209(18),206206(19),203203(20),220220(21),198198(22),236236(23),234234(24),239239(25),235235(26),3035032(27),2994992(28),2962960(29),3130127(30),3040037(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 11765754,168082,240066,Lock-Free (DWCAS 8),547547(18),581581(19),598598(20),601601(21),588588(22),617617(23),608608(24),634634(25),639639(26),1237236(27),1249248(28),1281280(29),1300299(30),1279278(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 12998986,185700,274764,Lock-Free (DWCAS 9),625625(18),625625(19),663663(20),653653(21),658658(22),671671(23),664664(24),673673(25),659659(26),1401400(27),1384383(28),1439438(29),1443442(30),1433432(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 15213198,217331,243442,Lock-Free (DWCAS 10),1224223(18),1278277(19),1343342(20),1352351(21),1329328(22),1349348(23),1353352(24),1365364(25),1353352(26),668668(27),652652(28),653653(29),657657(30),631631(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 27483456,392621,79654,PThread Mutex,1921920(18),1906905(19),1918917(20),1908907(21),1942941(22),1819818(23),1954953(24),1812811(25),1832831(26),2135133(27),2095093(28),2080078(29),2107105(30),2046044(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 10483473,149764,761069,PThread Spinlock (private),2002(18),2002(19),2002(20),3003(21),3003(22),3003(23),3003(24),3003(25),4004(26),1675674(27),1782781(28),2272270(29),2417415(30),2310308(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 10917907,155970,309953,PThread Spinlock (shared),455455(18),457457(19),555555(20),585585(21),491491(22),483483(23),474474(24),453453(25),453453(26),1043042(27),995995(28),1482481(29),1507506(30),1478477(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             3173170,42309,51747,GCC Spinlock (atomic),297297(18),311311(19),221221(20),225225(21),224224(22),40040(23),155155(24),156156(25),147147(26),222222(27),217217(28),215215(29),215215(30),218218(31),307307(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             2145143,28602,41176,GCC Spinlock (sync),97097(18),99099(19),99099(20),102102(21),100100(22),100100(23),104104(24),89089(25),115115(26),220220(27),215215(28),218218(29),207207(30),207207(31),171171(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             15706691,209423,85729,Lock-Free (DWCAS 0),949949(18),967967(19),971971(20),964964(21),966966(22),957957(23),940940(24),955955(25),937937(26),1181180(27),1171170(28),1200199(29),1188187(30),1177176(31),1174173(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             15799784,210664,135440,Lock-Free (DWCAS 1),882882(18),896896(19),906906(20),920920(21),919919(22),921921(23),933933(24),920920(25),909909(26),1263262(27),1261260(28),1275274(29),1288287(30),1321320(31),1176175(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             13919906,185599,244274,Lock-Free (DWCAS 2),1144143(18),1154153(19),1147146(20),1203202(21),1204203(22),1235234(23),1181180(24),1230229(25),1161160(26),547547(27),541541(28),550550(29),550550(30),556556(31),512512(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             15044029,200587,710548,Lock-Free (DWCAS 3),250250(18),255255(19),260260(20),266266(21),261261(22),255255(23),248248(24),242242(25),248248(26),2110108(27),2121119(28),2158156(29),2152150(30),2148146(31),2067065(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             14478464,193046,676011,Lock-Free (DWCAS 4),230230(18),242242(19),247247(20),247247(21),245245(22),266266(23),270270(24),266266(25),263263(26),1999998(27),2078076(28),2075073(29),2054052(30),2052050(31),1940939(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             14664650,195529,126310,Lock-Free (DWCAS 5),739739(18),756756(19),819819(20),805805(21),797797(22),966966(23),935935(24),966966(25),941941(26),1152151(27),1156155(28),1194193(29),1187186(30),1055054(31),1188187(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             13560547,180807,642060,Lock-Free (DWCAS 6),225225(18),231231(19),232232(20),234234(21),234234(22),228228(23),224224(24),216216(25),222222(26),1924923(27),1923922(28),1936935(29),1924923(30),1964963(31),1836835(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             11837826,157838,108649,Lock-Free (DWCAS 7),667667(18),683683(19),683683(20),690690(21),684684(22),674674(23),663663(24),665665(25),659659(26),961961(27),955955(28),963963(29),949949(30),966966(31),964964(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             10946936,145959,150733,Lock-Free (DWCAS 8),614614(18),624624(19),595595(20),608608(21),602602(22),519519(23),542542(24),512512(25),545545(26),981981(27),983983(28),982982(29),977977(30),963963(31),889889(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             12113101,161508,140304,Lock-Free (DWCAS 9),641641(18),646646(19),652652(20),655655(21),656656(22),675675(23),677677(24),671671(25),662662(26),1031030(27),1029028(28),1040039(29),1007006(30),1009008(31),1056055(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             12676664,169022,607897,Lock-Free (DWCAS 10),200200(18),196196(19),189189(20),212212(21),205205(22),223223(23),211211(24),205205(25),202202(26),1810809(27),1763762(28),1742741(29),1810809(30),1788787(31),1914913(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             25661636,342155,78844,PThread Mutex,1795794(18),1797796(19),1783782(20),1787786(21),1805804(22),1793792(23),1806805(24),1794793(25),1768767(26),1588587(27),1575574(28),1612611(29),1593592(30),1546545(31),1609608(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             10250240,136670,654824,PThread Spinlock (private),4004(18),3003(19),10010(20),5005(21),5005(22),10010(23),28028(24),19019(25),11011(26),1371370(27),1211210(28),1758757(29),1880879(30),1894893(31),2038036(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             10402392,138699,246824,PThread Spinlock (shared),289289(18),330330(19),472472(20),422422(21),331331(22),590590(23),579579(24),672672(25),512512(26),804804(27),744744(28),1082081(29),1102101(30),1213212(31),1254253(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         2134132,26677,23619,GCC Spinlock (atomic),180180(18),144144(19),118118(20),128128(21),116116(22),197197(23),186186(24),154154(25),136136(26),105105(27),109109(28),110110(29),111111(30),110110(31),120120(32),108108(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         2644642,33058,118320,GCC Spinlock (sync),102102(18),146146(19),141141(20),95095(21),81081(22),417417(23),493493(24),244244(25),456456(26),67067(27),81081(28),67067(29),83083(30),78078(31),71071(32),20020(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         14682668,183533,576632,Lock-Free (DWCAS 0),286286(18),282282(19),283283(20),289289(21),289289(22),292292(23),285285(24),276276(25),256256(26),1802801(27),1744743(28),1713712(29),1727726(30),1734733(31),1718717(32),1699698(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         11702691,146284,25355,Lock-Free (DWCAS 1),695695(18),696696(19),723723(20),735735(21),725725(22),706706(23),707707(24),705705(25),706706(26),724724(27),715715(28),750750(29),750750(30),756756(31),798798(32),800800(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         15480465,193506,639793,Lock-Free (DWCAS 2),257257(18),257257(19),267267(20),271271(21),269269(22),273273(23),272272(24),251251(25),243243(26),1840839(27),1849848(28),1874873(29),1925924(30),1907906(31),1840839(32),1877876(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         13348335,166854,546911,Lock-Free (DWCAS 3),232232(18),232232(19),232232(20),243243(21),241241(22),219219(23),234234(24),225225(25),223223(26),1640639(27),1625624(28),1604603(29),1608607(30),1596595(31),1593592(32),1595594(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         12535523,156694,497532,Lock-Free (DWCAS 4),218218(18),193193(19),240240(20),248248(21),242242(22),251251(23),251251(24),242242(25),242242(26),1404403(27),1390389(28),1481480(29),1477476(30),1498497(31),1575574(32),1578577(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         11336325,141704,247295,Lock-Free (DWCAS 5),936936(18),965965(19),1011010(20),1020019(21),1002001(22),978978(23),970970(24),970970(25),967967(26),355355(27),344344(28),343343(29),353353(30),356356(31),378378(32),380380(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         13861848,173273,571907,Lock-Free (DWCAS 6),258258(18),263263(19),252252(20),255255(21),256256(22),166166(23),224224(24),230230(25),221221(26),1677676(27),1691690(28),1672671(29),1642641(30),1643642(31),1713712(32),1692691(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         11961950,149524,462117,Lock-Free (DWCAS 7),222222(18),200200(19),237237(20),251251(21),245245(22),256256(23),244244(24),248248(25),246246(26),1337336(27),1331330(28),1410409(29),1411410(30),1412411(31),1461460(32),1446445(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         12547535,156844,268193,Lock-Free (DWCAS 8),1012011(18),1079078(19),1160159(20),1139138(21),1146145(22),1058057(23),1024023(24),1056055(25),1024023(26),413413(27),399399(28),392392(29),394394(30),403403(31),422422(32),423423(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         12342330,154279,514800,Lock-Free (DWCAS 9),212212(18),220220(19),220220(20),225225(21),221221(22),135135(23),200200(24),201201(25),202202(26),1500499(27),1521520(28),1500499(29),1491490(30),1479478(31),1491490(32),1519518(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         12248236,153103,474894,Lock-Free (DWCAS 10),216216(18),193193(19),245245(20),256256(21),256256(22),260260(23),257257(24),255255(25),248248(26),1369368(27),1374373(28),1435434(29),1413412(30),1445444(31),1520519(32),1501500(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         29792763,372410,106127,PThread Mutex,2015013(18),2022020(19),2004002(20),2005003(21),2009007(22),1849848(23),1866865(24),2060058(25),1815814(26),1778777(27),1770769(28),1760759(29),1771770(30),1737736(31),1673672(32),1651650(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         11438427,142980,321941,PThread Spinlock (private),252252(18),272272(19),309309(20),316316(21),363363(22),407407(23),461461(24),489489(25),455455(26),1082081(27),1118117(28),1275274(29),1336335(30),1181180(31),1111110(32),1007006(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         10629619,132870,499288,PThread Spinlock (shared),696696(18),800800(19),971971(20),1011010(21),1215214(22),1268267(23),1555554(24),1553552(25),1510509(26),5005(27),5005(28),7007(29),4004(30),7007(31),8008(32),10010(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     3641638,42843,50574,GCC Spinlock (atomic),244244(18),240240(19),240240(20),254254(21),244244(22),304304(23),253253(24),287287(25),243243(26),252252(27),201201(28),181181(29),201201(30),189189(31),66066(32),122122(33),117117(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     3774771,44409,37542,GCC Spinlock (sync),212212(18),213213(19),230230(20),224224(21),222222(22),291291(23),304304(24),296296(25),303303(26),193193(27),186186(28),178178(29),182182(30),183183(31),184184(32),182182(33),188188(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     12599587,148230,47904,Lock-Free (DWCAS 0),811811(18),834834(19),811811(20),810810(21),799799(22),763763(23),732732(24),765765(25),761761(26),711711(27),717717(28),708708(29),704704(30),697697(31),668668(32),630630(33),666666(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     12278266,144450,8182,Lock-Free (DWCAS 1),716716(18),716716(19),734734(20),737737(21),746746(22),723723(23),715715(24),707707(25),707707(26),717717(27),712712(28),726726(29),721721(30),720720(31),725725(32),721721(33),723723(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     13921908,163787,52558,Lock-Free (DWCAS 2),851851(18),856856(19),873873(20),894894(21),887887(22),889889(23),885885(24),880880(25),870870(26),733733(27),715715(28),759759(29),757757(30),765765(31),773773(32),772772(33),749749(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     13072059,153789,33202,Lock-Free (DWCAS 3),809809(18),828828(19),813813(20),812812(21),805805(22),797797(23),792792(24),782782(25),786786(26),704704(27),706706(28),732732(29),722722(30),728728(31),753753(32),726726(33),764764(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     13711698,161314,54218,Lock-Free (DWCAS 4),748748(18),803803(19),959959(20),917917(21),912912(22),833833(23),822822(24),827827(25),809809(26),728728(27),731731(28),756756(29),754754(30),752752(31),782782(32),777777(33),788788(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     11745734,138185,46840,Lock-Free (DWCAS 5),755755(18),778778(19),745745(20),749749(21),731731(22),722722(23),731731(24),728728(25),721721(26),662662(27),655655(28),646646(29),637637(30),650650(31),583583(32),618618(33),623623(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     12680668,149184,18725,Lock-Free (DWCAS 6),701701(18),712712(19),757757(20),762762(21),751751(22),772772(23),770770(24),775775(25),768768(26),731731(27),726726(28),759759(29),754754(30),753753(31),716716(32),743743(33),718718(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     11441430,134605,25858,Lock-Free (DWCAS 7),691691(18),706706(19),719719(20),724724(21),724724(22),693693(23),674674(24),684684(25),656656(26),645645(27),639639(28),658658(29),653653(30),660660(31),635635(32),633633(33),636636(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     11877866,139740,309747,Lock-Free (DWCAS 8),1025024(18),1035034(19),1027026(20),1142141(21),1155154(22),1010009(23),1029028(24),1009008(25),1026025(26),301301(27),290290(28),299299(29),292292(30),307307(31),305305(32),312312(33),311311(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     13458445,158335,53026,Lock-Free (DWCAS 9),771771(18),788788(19),867867(20),813813(21),818818(22),897897(23),858858(24),897897(25),877877(26),747747(27),744744(28),739739(29),737737(30),730730(31),720720(32),727727(33),715715(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     13121108,154366,73118,Lock-Free (DWCAS 10),886886(18),780780(19),808808(20),816816(21),814814(22),893893(23),872872(24),899899(25),868868(26),679679(27),666666(28),684684(29),686686(30),689689(31),712712(32),711711(33),645645(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     30285255,356297,113631,PThread Mutex,1639638(18),1666665(19),1718717(20),1642641(21),1662661(22),1629628(23),1637636(24),1638637(25),1652651(26),1924923(27),1958957(28),1976975(29),1908907(30),1887886(31),1930929(32),1878877(33),1928927(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     10707697,125973,188100,PThread Spinlock (private),285285(18),326326(19),445445(20),419419(21),370370(22),603603(23),675675(24),522522(25),662662(26),1083082(27),1072071(28),850850(29),800800(30),797797(31),630630(32),563563(33),597597(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     10602592,124736,539531,PThread Spinlock (shared),715715(18),745745(19),975975(20),948948(21),829829(22),1552551(23),1723722(24),1326325(25),1771770(26),1001(27),1001(28),1001(29),2002(30),1001(31),2002(32),2002(33),2002(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 3937934,43755,28867,GCC Spinlock (atomic),189189(18),195195(19),193193(20),188188(21),191191(22),177177(23),199199(24),174174(25),208208(26),280280(27),293293(28),247247(29),262262(30),239239(31),217217(32),237237(33),224224(34),221221(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 1799798,19998,8220,GCC Spinlock (sync),105105(18),108108(19),111111(20),109109(21),111111(22),110110(23),110110(24),109109(25),112112(26),90090(27),90090(28),92092(29),90090(30),92092(31),89089(32),90090(33),90090(34),90090(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 13784771,153164,384351,Lock-Free (DWCAS 0),302302(18),279279(19),314314(20),319319(21),318318(22),328328(23),326326(24),325325(25),318318(26),1175174(27),1168167(28),1210209(29),1106105(30),1218217(31),1267266(32),1268267(33),1273272(34),1266265(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 12067055,134078,334518,Lock-Free (DWCAS 1),260260(18),241241(19),278278(20),288288(21),284284(22),291291(23),287287(24),289289(25),288288(26),955955(27),966966(28),1054053(29),1053052(30),1050049(31),1111110(32),1119118(33),1127126(34),1121120(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 12745733,141619,63204,Lock-Free (DWCAS 2),798798(18),781781(19),798798(20),789789(21),812812(22),770770(23),774774(24),755755(25),745745(26),635635(27),637637(28),631631(29),617617(30),638638(31),633633(32),639639(33),638638(34),643643(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 14745731,163841,93955,Lock-Free (DWCAS 3),893893(18),903903(19),930930(20),962962(21),951951(22),929929(23),935935(24),929929(25),919919(26),704704(27),690690(28),709709(29),718718(30),719719(31),716716(32),717717(33),706706(34),701701(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 13297284,147748,414032,Lock-Free (DWCAS 4),203203(18),220220(19),255255(20),260260(21),261261(22),265265(23),269269(24),265265(25),264264(26),1187186(27),1183182(28),1216215(29),1191190(30),1221220(31),1249248(32),1244243(33),1268267(34),1272271(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 11619608,129107,354888,Lock-Free (DWCAS 5),213213(18),216216(19),221221(20),223223(21),223223(22),240240(23),241241(24),234234(25),234234(26),1073072(27),1086085(28),1073072(29),1046045(30),1064063(31),1049048(32),1049048(33),1061060(34),1071070(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 11016005,122400,326952,Lock-Free (DWCAS 6),223223(18),221221(19),222222(20),229229(21),230230(22),236236(23),232232(24),227227(25),219219(26),1005004(27),1012011(28),1007006(29),985985(30),972972(31),998998(32),993993(33),998998(34),999999(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 13922909,154699,436001,Lock-Free (DWCAS 7),240240(18),243243(19),257257(20),265265(21),266266(22),272272(23),272272(24),267267(25),263263(26),1286285(27),1231230(28),1214213(29),1260259(30),1250249(31),1340339(32),1356355(33),1310309(34),1326325(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 11974963,133055,365915,Lock-Free (DWCAS 8),217217(18),220220(19),220220(20),229229(21),225225(22),247247(23),251251(24),250250(25),247247(26),1097096(27),1102101(28),1114113(29),1070069(30),1109108(31),1091090(32),1087086(33),1096095(34),1100099(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 11530519,128117,47081,Lock-Free (DWCAS 9),682682(18),712712(19),722722(20),710710(21),694694(22),697697(23),663663(24),696696(25),661661(26),594594(27),603603(28),601601(29),591591(30),586586(31),568568(32),575575(33),581581(34),583583(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 12341329,137126,99386,Lock-Free (DWCAS 10),750750(18),773773(19),786786(20),794794(21),789789(22),781781(23),828828(24),833833(25),861861(26),565565(27),563563(28),585585(29),561561(30),553553(31),574574(32),581581(33),581581(34),571571(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 28145117,312724,123451,PThread Mutex,1391390(18),1422421(19),1431430(20),1429428(21),1443442(22),1413412(23),1416415(24),1413412(25),1411410(26),1715714(27),1727726(28),1743742(29),1724723(30),1695694(31),1699698(32),1671670(33),1697696(34),1695694(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 11021010,122456,486902,PThread Spinlock (private),98098(18),105105(19),134134(20),146146(21),137137(22),94094(23),105105(24),115115(25),120120(26),1137136(27),1132131(28),1025024(29),1067066(30),2216214(31),873873(32),868868(33),821821(34),823823(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 10990980,122122,487843,PThread Spinlock (shared),88088(18),107107(19),132132(20),143143(21),124124(22),88088(23),100100(24),113113(25),111111(26),1191190(27),1125124(28),1042041(29),1078077(30),2188186(31),834834(32),883883(33),807807(34),832832(35)
1 1                                                                     88010923,8801092,86778,GCC Spinlock (atomic),43698655(0),44312268(18)
1 1                                                                     92522430,9252243,1416,GCC Spinlock (sync),46256210(0),46266220(18)
1 1                                                                     123809686,12380969,849660,Lock-Free (DWCAS 0),64908844(0),58900842(18)
1 1                                                                     127818691,12781869,1084229,Lock-Free (DWCAS 1),67742675(0),60076016(18)
1 1                                                                     126819693,12681969,906993,Lock-Free (DWCAS 2),66616550(0),60203143(18)
1 1                                                                     125655530,12565553,818799,Lock-Free (DWCAS 3),65722657(0),59932873(18)
1 1                                                                     125283158,12528316,786523,Lock-Free (DWCAS 4),65422357(0),59860801(18)
1 1                                                                     125360235,12536024,795441,Lock-Free (DWCAS 5),65492427(0),59867808(18)
1 1                                                                     124909785,12490978,681342,Lock-Free (DWCAS 6),64863799(0),60045986(18)
1 1                                                                     124743619,12474362,671149,Lock-Free (DWCAS 7),64744680(0),59998939(18)
1 1                                                                     124664540,12466454,732163,Lock-Free (DWCAS 8),64920856(0),59743684(18)
1 1                                                                     124670546,12467055,631087,Lock-Free (DWCAS 9),64566502(0),60104044(18)
1 1                                                                     124613489,12461349,633493,Lock-Free (DWCAS 10),64546482(0),60067007(18)
1 1                                                                     30746716,3074672,305209,PThread Mutex,16452436(0),14294280(18)
1 1                                                                     143422279,14342228,672565,PThread Spinlock (private),74089015(0),69333264(18)
1 1                                                                     144085942,14408594,485843,PThread Spinlock (shared),73760687(0),70325255(18)
1 1 1 1                                                                 20274254,1013713,24285,GCC Spinlock (atomic),5128123(0),5014009(1),5130125(18),5001997(19)
1 1 1 1                                                                 18948930,947446,55587,GCC Spinlock (sync),4946942(0),4624620(1),4777773(18),4599595(19)
1 1 1 1                                                                 21317296,1065865,470589,Lock-Free (DWCAS 0),4266262(0),6592586(1),4048044(18),6410404(19)
1 1 1 1                                                                 36887851,1844393,106543,Lock-Free (DWCAS 1),9558549(0),9074065(1),9383374(18),8871863(19)
1 1 1 1                                                                 52907855,2645393,573258,Lock-Free (DWCAS 2),14867853(0),11965954(1),14426412(18),11647636(19)
1 1 1 1                                                                 61546485,3077324,677510,Lock-Free (DWCAS 3),17289272(0),13907894(1),16844828(18),13504491(19)
1 1 1 1                                                                 72286214,3614311,1582769,Lock-Free (DWCAS 4),22441419(0),14392378(1),21583562(18),13868855(19)
1 1 1 1                                                                 88265177,4413259,5249903,Lock-Free (DWCAS 5),9141132(0),36250214(1),8787779(18),34086052(19)
1 1 1 1                                                                 88153065,4407653,1601852,Lock-Free (DWCAS 6),26599573(0),18395377(1),25429404(18),17728711(19)
1 1 1 1                                                                 92225133,4611257,218825,Lock-Free (DWCAS 7),23355332(0),23753730(1),22308286(18),22807785(19)
1 1 1 1                                                                 95680585,4784029,1497357,Lock-Free (DWCAS 8),28285257(0),20786766(1),26938912(18),19669650(19)
1 1 1 1                                                                 98871773,4943589,1467297,Lock-Free (DWCAS 9),29016988(0),21562541(1),27662635(18),20629609(19)
1 1 1 1                                                                 102867765,5143388,1444625,Lock-Free (DWCAS 10),29946917(0),22568546(1),28624596(18),21727706(19)
1 1 1 1                                                                 29506477,1475324,569093,PThread Mutex,5280275(0),8754746(1),6856850(18),8614606(19)
1 1 1 1                                                                 36559523,1827976,96693,PThread Spinlock (private),8962954(0),9397388(1),8841833(18),9357348(19)
1 1 1 1                                                                 36565529,1828276,118018,PThread Spinlock (shared),8859851(0),9456447(1),8833825(18),9415406(19)
1 1 1 1 1 1                                                             14239225,474641,49797,GCC Spinlock (atomic),2499497(0),2387385(1),2253251(2),2491489(18),2366364(19),2241239(20)
1 1 1 1 1 1                                                             13684671,456156,41237,GCC Spinlock (sync),2401399(0),2222220(1),2300298(2),2374372(18),2188186(19),2198196(20)
1 1 1 1 1 1                                                             17510493,583683,36908,Lock-Free (DWCAS 0),2975973(0),2899897(1),3036033(2),2871869(18),2798796(19),2927925(20)
1 1 1 1 1 1                                                             20313293,677110,23550,Lock-Free (DWCAS 1),3395392(0),3351348(1),3459456(2),3364361(18),3315312(19),3427424(20)
1 1 1 1 1 1                                                             26524498,884150,124739,Lock-Free (DWCAS 2),4122118(0),4451447(1),4747743(2),4089085(18),4407403(19),4706702(20)
1 1 1 1 1 1                                                             37215178,1240506,248561,Lock-Free (DWCAS 3),6421415(0),5498493(1),6677671(2),6493487(18),5491486(19),6632626(20)
1 1 1 1 1 1                                                             42834792,1427826,189285,Lock-Free (DWCAS 4),7555548(0),6633627(1),7247240(2),7549542(18),6612606(19),7236229(20)
1 1 1 1 1 1                                                             49915866,1663862,167379,Lock-Free (DWCAS 5),8905897(0),8128120(1),8104096(2),8677669(18),8048040(19),8052044(20)
1 1 1 1 1 1                                                             58618560,1953952,156495,Lock-Free (DWCAS 6),10259249(0),9712703(1),9613604(2),10113103(18),9592583(19),9327318(20)
1 1 1 1 1 1                                                             67081014,2236034,198351,Lock-Free (DWCAS 7),11821810(0),11073062(1),10894884(2),11644633(18),10888878(19),10757747(20)
1 1 1 1 1 1                                                             74088014,2469600,344575,Lock-Free (DWCAS 8),13307294(0),12195183(1),11708697(2),13249236(18),12155143(19),11472461(20)
1 1 1 1 1 1                                                             79423344,2647445,296950,Lock-Free (DWCAS 9),14111097(0),13188175(1),12678666(2),13932919(18),13056043(19),12456444(20)
1 1 1 1 1 1                                                             83374291,2779143,350641,Lock-Free (DWCAS 10),14957943(0),13847834(1),13192179(2),14674660(18),13702689(19),12998986(20)
1 1 1 1 1 1                                                             21442421,714747,222134,PThread Mutex,2870868(0),3282279(1),4254250(2),3922919(18),3370367(19),3741738(20)
1 1 1 1 1 1                                                             29946917,998231,343687,PThread Spinlock (private),4557553(0),4380376(1),5997992(2),4536532(18),4512508(19),5961956(20)
1 1 1 1 1 1                                                             29807778,993593,322325,PThread Spinlock (shared),4505501(0),4544540(1),5909904(2),4485481(18),4476472(19),5885880(20)
1 1 1 1 1 1 1 1                                                         11470459,286761,26087,GCC Spinlock (atomic),1505504(0),1430429(1),1434433(2),1363362(3),1486485(18),1448447(19),1430429(20),1371370(21)
1 1 1 1 1 1 1 1                                                         11551540,288788,40815,GCC Spinlock (sync),1568567(0),1389388(1),1421420(2),1335334(3),1491490(18),1523522(19),1416415(20),1405404(21)
1 1 1 1 1 1 1 1                                                         17663646,441591,453723,Lock-Free (DWCAS 0),2917915(0),2586584(1),840840(2),2576574(3),2846844(18),2531529(19),836836(20),2526524(21)
1 1 1 1 1 1 1 1                                                         17623606,440590,405876,Lock-Free (DWCAS 1),2697695(0),2557555(1),965965(2),2624622(3),2681679(18),2533531(19),960960(20),2601599(21)
1 1 1 1 1 1 1 1                                                         21064043,526601,482782,Lock-Free (DWCAS 2),3286283(0),3024021(1),1170169(2),3113110(3),3251248(18),2988986(19),1158157(20),3072069(21)
1 1 1 1 1 1 1 1                                                         30220190,755505,778295,Lock-Free (DWCAS 3),4978974(0),4152148(1),1458457(2),4637633(3),4884880(18),4093089(19),1437436(20),4577573(21)
1 1 1 1 1 1 1 1                                                         36511475,912787,1069599,Lock-Free (DWCAS 4),6486480(0),4727723(1),1470469(2),5651646(3),6447441(18),4652648(19),1480479(20),5594589(21)
1 1 1 1 1 1 1 1                                                         41596555,1039914,1132291,Lock-Free (DWCAS 5),7038031(0),5350345(1),1906905(2),6514508(3),7206199(18),5259254(19),1936935(20),6384378(21)
1 1 1 1 1 1 1 1                                                         47935888,1198397,1312920,Lock-Free (DWCAS 6),8593585(0),6378372(1),2205203(2),7061054(3),8364356(18),6246240(19),2219217(20),6867861(21)
1 1 1 1 1 1 1 1                                                         54827773,1370694,1479470,Lock-Free (DWCAS 7),9824815(0),7468461(1),2610608(2),7947940(3),9517508(18),7238231(19),2561559(20),7658651(21)
1 1 1 1 1 1 1 1                                                         61934873,1548372,1695659,Lock-Free (DWCAS 8),11143132(0),8406398(1),2887885(2),8985977(3),10813803(18),8211203(19),2817815(20),8668660(21)
1 1 1 1 1 1 1 1                                                         68955887,1723897,1896254,Lock-Free (DWCAS 9),12364352(0),9404395(1),3152149(2),10083073(3),11960949(18),9186177(19),3093090(20),9711702(21)
1 1 1 1 1 1 1 1                                                         72516444,1812911,1915144,Lock-Free (DWCAS 10),12923911(0),9956947(1),3606603(2),10321311(3),12555543(18),9699690(19),3477474(20),9974965(21)
1 1 1 1 1 1 1 1                                                         17590573,439764,95632,PThread Mutex,1884883(0),2112110(1),2392390(2),2220218(3),2253251(18),2095093(19),2463461(20),2169167(21)
1 1 1 1 1 1 1 1                                                         24094070,602352,581317,PThread Spinlock (private),2048046(0),2116114(1),3331328(2),4556552(3),2040038(18),2118116(19),3327324(20),4556552(21)
1 1 1 1 1 1 1 1                                                         24124100,603102,332058,PThread Spinlock (shared),2251249(0),2649647(1),3685682(2),3482479(3),2252250(18),2646644(19),3677674(20),3478475(21)
1 1 1 1 1 1 1 1 1 1                                                     9473464,189469,111932,GCC Spinlock (atomic),1300299(0),866866(1),836836(2),845845(3),883883(4),1299298(18),884884(19),837837(20),848848(21),868868(22)
1 1 1 1 1 1 1 1 1 1                                                     9396387,187928,118701,GCC Spinlock (sync),1306305(0),832832(1),817817(2),784784(3),876876(4),1309308(18),922922(19),821821(20),880880(21),842842(22)
1 1 1 1 1 1 1 1 1 1                                                     16224208,324484,360087,Lock-Free (DWCAS 0),2049047(0),1857856(1),492492(2),1855854(3),1961960(4),1988987(18),1814813(19),493493(20),1811810(21),1897896(22)
1 1 1 1 1 1 1 1 1 1                                                     16082066,321641,312378,Lock-Free (DWCAS 1),1946945(0),1823822(1),625625(2),1810809(3),1855854(4),1937936(18),1817816(19),624624(20),1794793(21),1843842(22)
1 1 1 1 1 1 1 1 1 1                                                     17439422,348788,302541,Lock-Free (DWCAS 2),2071069(0),1958957(1),794794(2),1944943(3),1977976(4),2058056(18),1945944(19),787787(20),1935934(21),1963962(22)
1 1 1 1 1 1 1 1 1 1                                                     20840820,416816,343505,Lock-Free (DWCAS 3),2486484(0),2290288(1),1014013(2),2399397(3),2286284(4),2465463(18),2269267(19),1003002(20),2370368(21),2256254(22)
1 1 1 1 1 1 1 1 1 1                                                     25714689,514294,424124,Lock-Free (DWCAS 4),1234233(0),3042039(1),2812810(2),2866864(3),2950948(4),1245244(18),3018015(19),2788786(20),2829827(21),2925923(22)
1 1 1 1 1 1 1 1 1 1                                                     30637607,612752,566029,Lock-Free (DWCAS 5),1496495(0),2642640(1),3665662(2),3616613(3),3944941(4),1510509(18),2626624(19),3597594(20),3609606(21),3926923(22)
1 1 1 1 1 1 1 1 1 1                                                     34575541,691511,573713,Lock-Free (DWCAS 6),1677676(0),4280276(1),3698695(2),3709706(3),3967964(4),1700699(18),4213209(19),3706703(20),3681678(21),3938935(22)
1 1 1 1 1 1 1 1 1 1                                                     40837797,816756,684763,Lock-Free (DWCAS 7),4451447(0),4435431(1),4825821(2),4883879(3),1947946(4),4407403(18),4359355(19),4758754(20),4814810(21),1952951(22)
1 1 1 1 1 1 1 1 1 1                                                     44968924,899378,725635,Lock-Free (DWCAS 8),2240238(0),5289284(1),4904900(2),4949945(3),5286281(4),2212210(18),5200195(19),4799795(20),4891887(21),5194189(22)
1 1 1 1 1 1 1 1 1 1                                                     53558505,1071170,908835,Lock-Free (DWCAS 9),5971966(0),5901896(1),6290284(2),6332326(3),2526524(4),5880875(18),5837832(19),6182176(20),6160154(21),2474472(22)
1 1 1 1 1 1 1 1 1 1                                                     58268210,1165364,959634,Lock-Free (DWCAS 10),2840838(0),6885879(1),6449443(2),6451445(3),6842836(4),2786784(18),6652646(19),6349343(20),6332326(21),6676670(22)
1 1 1 1 1 1 1 1 1 1                                                     17423406,348468,49471,PThread Mutex,1565564(0),1687686(1),1815814(2),1790789(3),1711710(4),1791790(18),1695694(19),1857856(20),1758757(21),1747746(22)
1 1 1 1 1 1 1 1 1 1                                                     21968947,439379,345486,PThread Spinlock (private),3213210(0),2157155(1),1659658(2),1794793(3),2161159(4),3217214(18),2155153(19),1658657(20),1791790(21),2160158(22)
1 1 1 1 1 1 1 1 1 1                                                     21764743,435295,303099,PThread Spinlock (shared),2585583(0),1879878(1),1660659(2),1863862(3),2900898(4),2585583(18),1875874(19),1654653(20),1858857(21),2898896(22)
1 1 1 1 1 1 1 1 1 1 1 1                                                 7940933,132349,44970,GCC Spinlock (atomic),627627(0),610610(1),613613(2),780780(3),612612(4),717717(5),630630(18),631631(19),605605(20),785785(21),615615(22),708708(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 8454446,140907,19350,GCC Spinlock (sync),715715(0),673673(1),720720(2),706706(3),710710(4),665665(5),712712(18),763763(19),688688(20),721721(21),716716(22),657657(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 14766752,246113,179200,Lock-Free (DWCAS 0),1408407(0),776776(1),1421420(2),1399398(3),990990(4),1464463(5),1382381(18),763763(19),1394393(20),1371370(21),974974(22),1418417(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 14701687,245028,229053,Lock-Free (DWCAS 1),1380379(0),1333332(1),1360359(2),1339338(3),491491(4),1461460(5),1373372(18),1328327(19),1354353(20),1331330(21),492492(22),1455454(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 14561547,242692,13862,Lock-Free (DWCAS 2),1189188(0),1193192(1),1231230(2),1235234(3),1219218(4),1238237(5),1183182(18),1184183(19),1225224(20),1220219(21),1209208(22),1233232(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 15961946,266032,137967,Lock-Free (DWCAS 3),993993(0),1140139(1),1437436(2),1420419(3),1444443(4),1567566(5),987987(18),1131130(19),1430429(20),1412411(21),1435434(22),1560559(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 18682664,311378,146932,Lock-Free (DWCAS 4),1615614(0),1560559(1),1629628(2),1608607(3),1126125(4),1827826(5),1601600(18),1550549(19),1618617(20),1603602(21),1119118(22),1820819(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 23272249,387871,226819,Lock-Free (DWCAS 5),1915914(0),1879878(1),2082080(2),2058056(3),1310309(4),2397395(5),1921920(18),1866865(19),2086084(20),2055053(21),1308307(22),2390388(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 26681655,444694,256348,Lock-Free (DWCAS 6),2308306(0),2235233(1),2621619(2),1664663(3),2655653(4),1826825(5),2327325(18),2245243(19),2637635(20),1677676(21),2652650(22),1828827(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 31452421,524207,266319,Lock-Free (DWCAS 7),2576574(0),2534532(1),3080077(2),1953952(3),2431429(4),3079076(5),2626624(18),2594592(19),3084081(20),1991990(21),2419417(22),3080077(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 33550517,559175,304065,Lock-Free (DWCAS 8),3219216(0),2040038(1),2825823(2),2583581(3),2719717(4),3390387(5),3213210(18),2019017(19),2813811(20),2644642(21),2697695(22),3383380(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 40080040,668001,528823,Lock-Free (DWCAS 9),3536533(0),3067064(1),2344342(2),3137134(3),3149146(4),4875871(5),3530527(18),3078075(19),2314312(20),3090087(21),3137134(22),4819815(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 45430385,757173,217043,Lock-Free (DWCAS 10),4247243(0),3914911(1),3878875(2),3762759(3),3878875(4),3180177(5),4163159(18),3870867(19),3844841(20),3709706(21),3827824(22),3151148(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 18086068,301434,31651,PThread Mutex,1428427(0),1470469(1),1496495(2),1590589(3),1499498(4),1482481(5),1566565(18),1481480(19),1511510(20),1574573(21),1508507(22),1475474(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 19781762,329696,197385,PThread Spinlock (private),1252251(0),1458457(1),1920919(2),2103101(3),1550549(4),1593592(5),1252251(18),1458457(19),1921920(20),2107105(21),1570569(22),1592591(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 19978959,332983,303650,PThread Spinlock (shared),1223222(0),1445444(1),1889888(2),2477475(3),1755754(4),1224223(5),1223222(18),1441440(19),1887886(20),2474472(21),1713712(22),1222221(23)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             7380373,105434,53808,GCC Spinlock (atomic),511511(0),700700(1),488488(2),491491(3),486486(4),507507(5),501501(6),511511(18),703703(19),489489(20),492492(21),492492(22),502502(23),500500(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             7182175,102602,76885,GCC Spinlock (sync),461461(0),460460(1),468468(2),762762(3),443443(4),479479(5),473473(6),480480(18),482482(19),472472(20),762762(21),501501(22),465465(23),467467(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             13397384,191391,88344,Lock-Free (DWCAS 0),699699(0),969969(1),985985(2),979979(3),977977(4),1087086(5),1092091(6),683683(18),947947(19),960960(20),956956(21),956956(22),1046045(23),1052051(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             12795783,182797,193071,Lock-Free (DWCAS 1),1024023(0),1027026(1),1026025(2),1030029(3),1024023(4),1006005(5),283283(6),1016015(18),1021020(19),1020019(20),1018017(21),1018017(22),1001000(23),281281(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             13773760,196768,10410,Lock-Free (DWCAS 2),970970(0),978978(1),1006005(2),1003002(3),991991(4),973973(5),987987(6),960960(18),971971(19),996996(20),998998(21),986986(22),963963(23),980980(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             14229215,203274,149087,Lock-Free (DWCAS 3),535535(0),1096095(1),1069068(2),1055054(3),1086085(4),1139138(5),1148147(6),533533(18),1089088(19),1065064(20),1052051(21),1082081(22),1136135(23),1142141(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             15582567,222608,102921,Lock-Free (DWCAS 4),1161160(0),1157156(1),1168167(2),1166165(3),1165164(4),1218217(5),782782(6),1154153(18),1151150(19),1164163(20),1152151(21),1161160(22),1205204(23),775775(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             19289270,275561,195454,Lock-Free (DWCAS 5),1408407(0),1331330(1),1444443(2),1438437(3),794794(4),1618617(5),1641640(6),1396395(18),1320319(19),1429428(20),1431430(21),788788(22),1609608(23),1635634(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             21128107,301830,211212,Lock-Free (DWCAS 6),844844(0),1673672(1),1504503(2),1523522(3),1616615(4),1685684(5),1717716(6),841841(18),1660659(19),1500499(20),1523522(21),1618617(22),1689688(23),1726725(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             23853830,340769,191234,Lock-Free (DWCAS 7),1462461(0),1598597(1),1676675(2),1589588(3),1517516(4),1775774(5),2289287(6),1467466(18),1600599(19),1686685(20),1593592(21),1525524(22),1791790(23),2278276(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             29035006,414786,394261,Lock-Free (DWCAS 8),2093091(0),1971970(1),1572571(2),2184182(3),1205204(4),2691689(5),2785783(6),2075073(18),1972971(19),1574573(20),2180178(21),1206205(22),2733731(23),2787785(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             32047015,457814,236241,Lock-Free (DWCAS 9),2068066(0),2302300(1),2291289(2),2143141(3),1962961(4),2288286(5),3035032(6),2044042(18),2303301(19),2285283(20),2132130(21),1961960(22),2255253(23),2973971(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             34989955,499856,347250,Lock-Free (DWCAS 10),1437436(0),2683681(1),2463461(2),2520518(3),2651649(4),2883881(5),2921919(6),1423422(18),2623621(19),2464462(20),2504502(21),2625623(22),2864862(23),2920918(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             16096080,229944,28150,PThread Mutex,1076075(0),1159158(1),1203202(2),1147146(3),1158157(4),1175174(5),1059058(6),1161160(18),1154153(19),1185184(20),1159158(21),1139138(22),1178177(23),1141140(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             17358341,247976,138146,PThread Spinlock (private),1660659(0),1321320(1),1165164(2),1176175(3),1124123(4),1101100(5),1127126(6),1661660(18),1321320(19),1164163(20),1177176(21),1133132(22),1098097(23),1127126(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             17386369,248377,104642,PThread Spinlock (shared),1074073(0),1083082(1),1290289(2),1249248(3),1141140(4),1410409(5),1450449(6),1078077(18),1078077(19),1290289(20),1250249(21),1138137(22),1404403(23),1448447(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         6359353,79492,35842,GCC Spinlock (atomic),458458(0),372372(1),373373(2),484484(3),361361(4),378378(5),374374(6),367367(7),460460(18),373373(19),368368(20),491491(21),377377(22),375375(23),374374(24),368368(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         6207201,77590,35062,GCC Spinlock (sync),363363(0),360360(1),372372(2),362362(3),344344(4),346346(5),428428(6),481481(7),364364(18),381381(19),373373(20),382382(21),403403(22),333333(23),428428(24),481481(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         12356344,154454,168585,Lock-Free (DWCAS 0),226226(0),827827(1),824824(2),818818(3),828828(4),912912(5),919919(6),910910(7),224224(18),807807(19),803803(20),800800(21),804804(22),880880(23),885885(24),877877(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         12433421,155418,165523,Lock-Free (DWCAS 1),869869(0),876876(1),860860(2),864864(3),873873(4),826826(5),829829(6),230230(7),866866(18),871871(19),856856(20),856856(21),866866(22),824824(23),822822(24),233233(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         12523511,156544,44936,Lock-Free (DWCAS 2),741741(0),755755(1),740740(2),734734(3),734734(4),849849(5),856856(6),863863(7),735735(18),749749(19),737737(20),728728(21),735735(22),847847(23),850850(24),858858(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         12924912,161561,122805,Lock-Free (DWCAS 3),409409(0),853853(1),839839(2),832832(3),842842(4),898898(5),904904(6),900900(7),407407(18),845845(19),835835(20),825825(21),840840(22),892892(23),898898(24),893893(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         14268254,178353,147480,Lock-Free (DWCAS 4),945945(0),955955(1),956956(2),968968(3),967967(4),967967(5),984984(6),404404(7),937937(18),952952(19),954954(20),959959(21),961961(22),962962(23),978978(24),405405(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         15381366,192267,39939,Lock-Free (DWCAS 5),952952(0),923923(1),913913(2),904904(3),954954(4),1035034(5),1030029(6),1010009(7),948948(18),919919(19),905905(20),896896(21),928928(22),1030029(23),1025024(24),999999(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         16951935,211899,134958,Lock-Free (DWCAS 6),626626(0),1105104(1),1069068(2),1083082(3),1117116(4),1171170(5),1183182(6),1153152(7),623623(18),1094093(19),1061060(20),1073072(21),1109108(22),1164163(23),1178177(24),1140139(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         20343323,254292,232559,Lock-Free (DWCAS 7),1208207(0),1257256(1),1272271(2),1259258(3),1270269(4),1579578(5),1691690(6),631631(7),1213212(18),1252251(19),1281280(20),1270269(21),1281280(22),1549548(23),1692691(24),632632(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         21893872,273673,61138,Lock-Free (DWCAS 8),1436435(0),1357356(1),1263262(2),1246245(3),1355354(4),1455454(5),1458457(6),1374373(7),1426425(18),1353352(19),1267266(20),1245244(21),1358357(22),1458457(23),1466465(24),1371370(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         24179155,302239,160517,Lock-Free (DWCAS 9),1009008(0),1647646(1),1471470(2),1493492(3),1577576(4),1636635(5),1661660(6),1576575(7),1011010(18),1646645(19),1459458(20),1504503(21),1576575(22),1655654(23),1655654(24),1595594(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         30966936,387087,447407,Lock-Free (DWCAS 10),1810809(0),1895894(1),1901900(2),1851850(3),1843842(4),2546544(5),2866864(6),814814(7),1796795(18),1893892(19),1884883(20),1840839(21),1835834(22),2535533(23),2834832(24),811811(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         21826805,272835,47390,PThread Mutex,1331330(0),1406405(1),1382381(2),1376375(3),1418417(4),1395394(5),1203202(6),1320319(7),1394393(18),1407406(19),1375374(20),1392391(21),1430429(22),1404403(23),1266265(24),1322321(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         16896880,211211,242342,PThread Spinlock (private),736736(0),1157156(1),1535534(2),1299298(3),1356355(4),766766(5),794794(6),782782(7),734734(18),1158157(19),1538537(20),1346345(21),1353352(22),764764(23),793793(24),777777(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         16281265,203516,123181,PThread Spinlock (shared),695695(0),987987(1),1198197(2),1077076(3),1083082(4),939939(5),958958(6),1205204(7),693693(18),988988(19),1198197(20),1077076(21),1081080(22),935935(23),958958(24),1201200(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     5998993,66655,23655,GCC Spinlock (atomic),340340(0),321321(1),319319(2),319319(3),307307(4),318318(5),326326(6),329329(7),409409(8),346346(18),327327(19),327327(20),314314(21),316316(22),315315(23),324324(24),330330(25),406406(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     5710705,63452,51827,GCC Spinlock (sync),289289(0),306306(1),271271(2),295295(3),283283(4),297297(5),302302(6),486486(7),307307(8),311311(18),323323(19),298298(20),271271(21),295295(22),293293(23),299299(24),486486(25),293293(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     12143131,134924,156625,Lock-Free (DWCAS 0),750750(0),738738(1),776776(2),775775(3),748748(4),752752(5),759759(6),156156(7),753753(8),715715(18),702702(19),740740(20),736736(21),712712(22),716716(23),725725(24),155155(25),723723(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     11748737,130542,127433,Lock-Free (DWCAS 1),681681(0),655655(1),698698(2),233233(3),721721(4),716716(5),718718(6),732732(7),728728(8),680680(18),654654(19),699699(20),232232(21),716716(22),712712(23),719719(24),719719(25),724724(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     11711700,130130,75188,Lock-Free (DWCAS 2),459459(0),700700(1),686686(2),683683(3),671671(4),713713(5),523523(6),718718(7),718718(8),456456(18),692692(19),681681(20),678678(21),670670(22),707707(23),519519(24),714714(25),712712(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     12638626,140429,125560,Lock-Free (DWCAS 3),752752(0),757757(1),756756(2),762762(3),759759(4),747747(5),759759(6),283283(7),754754(8),748748(18),751751(19),751751(20),754754(21),758758(22),746746(23),754754(24),284284(25),751751(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     12736724,141519,75780,Lock-Free (DWCAS 4),599599(0),513513(1),718718(2),706706(3),710710(4),787787(5),789789(6),773773(7),780780(8),597597(18),512512(19),716716(20),702702(21),707707(22),785785(23),786786(24),768768(25),776776(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     14539525,161550,125890,Lock-Free (DWCAS 5),862862(0),856856(1),872872(2),872872(3),878878(4),902902(5),402402(6),761761(7),883883(8),854854(18),849849(19),867867(20),867867(21),868868(22),899899(23),401401(24),756756(25),876876(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     15993978,177711,115035,Lock-Free (DWCAS 6),896896(0),859859(1),900900(2),904904(3),527527(4),980980(5),993993(6),975975(7),978978(8),897897(18),856856(19),894894(20),894894(21),525525(22),974974(23),984984(24),966966(25),976976(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     16394378,182160,102620,Lock-Free (DWCAS 7),577577(0),969969(1),905905(2),921921(3),950950(4),978978(5),991991(6),958958(7),962962(8),575575(18),960960(19),901901(20),912912(21),945945(22),975975(23),987987(24),953953(25),959959(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     19718699,219097,194273,Lock-Free (DWCAS 8),1038037(0),1011010(1),1066065(2),1055054(3),1088087(4),1373372(5),585585(6),1418417(7),1229228(8),1043042(18),1011010(19),1059058(20),1058057(21),1085084(22),1369368(23),581581(24),1411410(25),1235234(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     21976955,244188,113656,Lock-Free (DWCAS 9),1190189(0),1160159(1),1229228(2),1027026(3),990990(4),1357356(5),1380379(6),1314313(7),1340339(8),1184183(18),1154153(19),1228227(20),1025024(21),998998(22),1363362(23),1372371(24),1323322(25),1337336(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     22416394,249071,112945,Lock-Free (DWCAS 10),889889(0),1349348(1),1215214(2),1235234(3),1291290(4),1328327(5),1346345(6),1281280(7),1256255(8),890890(18),1334333(19),1214213(20),1245244(21),1296295(22),1337336(23),1359358(24),1277276(25),1268267(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     22422400,249138,26188,PThread Mutex,1226225(0),1278277(1),1264263(2),1208207(3),1274273(4),1262261(5),1177176(6),1212211(7),1228227(8),1272271(18),1280279(19),1260259(20),1276275(21),1269268(22),1276275(23),1215214(24),1217216(25),1224223(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     15004990,166722,162601,PThread Spinlock (private),937937(0),974974(1),686686(2),699699(3),750750(4),685685(5),1291290(6),728728(7),737737(8),938938(18),976976(19),687687(20),701701(21),752752(22),684684(23),1296295(24),729729(25),742742(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     15414399,171271,254407,PThread Spinlock (shared),1394393(0),1400399(1),789789(2),807807(3),802802(4),576576(5),586586(6),665665(7),683683(8),1394393(18),1395394(19),790790(20),808808(21),802802(22),578578(23),586586(24),662662(25),686686(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 5702697,57027,600519,GCC Spinlock (atomic),57057(0),56056(1),67067(2),66066(3),65065(4),59059(5),66066(6),59059(7),58058(8),2304302(9),57057(18),56056(19),66066(20),65065(21),63063(22),58058(23),67067(24),59059(25),59059(26),2294292(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 4078074,40781,341089,GCC Spinlock (sync),71071(0),69069(1),76076(2),74074(3),84084(4),81081(5),75075(6),84084(7),76076(8),1348347(9),70070(18),68068(19),76076(20),74074(21),85085(22),82082(23),75075(24),85085(25),76076(26),1347346(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 16653637,166536,1364064,Lock-Free (DWCAS 0),333333(0),311311(1),325325(2),313313(3),334334(4),341341(5),339339(6),331331(7),345345(8),5500495(9),323323(18),304304(19),320320(20),305305(21),326326(22),332332(23),326326(24),319319(25),307307(26),5313308(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 16165149,161651,1342915,Lock-Free (DWCAS 1),304304(0),311311(1),316316(2),318318(3),316316(4),308308(5),303303(6),311311(7),290290(8),5353348(9),302302(18),311311(19),313313(20),314314(21),310310(22),304304(23),306306(24),309309(25),289289(26),5271266(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 12554542,125545,805941,Lock-Free (DWCAS 2),341341(0),345345(1),346346(2),346346(3),339339(4),314314(5),320320(6),282282(7),323323(8),3342339(9),336336(18),341341(19),341341(20),344344(21),337337(22),315315(23),315315(24),280280(25),323323(26),3318315(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 17946929,179469,2105929,Lock-Free (DWCAS 3),114114(0),115115(1),111111(2),81081(3),112112(4),125125(5),117117(6),118118(7),118118(8),8073065(9),111111(18),113113(19),113113(20),81081(21),117117(22),122122(23),119119(24),120120(25),118118(26),7846839(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 19898879,198989,2358146,Lock-Free (DWCAS 4),108108(0),107107(1),110110(2),107107(3),110110(4),132132(5),124124(6),124124(7),121121(8),9034025(9),108108(18),109109(19),109109(20),108108(21),109109(22),127127(23),123123(24),128128(25),126126(26),8772764(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 15605590,156056,1438250,Lock-Free (DWCAS 5),255255(0),254254(1),247247(2),247247(3),234234(4),246246(5),248248(6),225225(7),244244(8),5644639(9),250250(18),251251(19),250250(20),246246(21),236236(22),244244(23),246246(24),223223(25),247247(26),5563558(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 16254238,162542,1393646,Lock-Free (DWCAS 6),306306(0),315315(1),310310(2),307307(3),305305(4),286286(5),283283(6),291291(7),242242(8),5540535(9),303303(18),310310(19),304304(20),308308(21),305305(22),282282(23),286286(24),293293(25),240240(26),5432427(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 13184171,131842,859209,Lock-Free (DWCAS 7),354354(0),347347(1),346346(2),349349(3),348348(4),340340(5),343343(6),288288(7),346346(8),3559556(9),349349(18),340340(19),345345(20),344344(21),345345(22),337337(23),343343(24),286286(25),347347(26),3521518(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 21233212,212332,2464911,Lock-Free (DWCAS 8),140140(0),135135(1),140140(2),141141(3),106106(4),160160(5),153153(6),159159(7),156156(8),9399390(9),134134(18),133133(19),135135(20),139139(21),107107(22),160160(23),158158(24),159159(25),158158(26),9258249(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 20775755,207758,2380545,Lock-Free (DWCAS 9),160160(0),168168(1),162162(2),160160(3),160160(4),155155(5),151151(6),161161(7),90090(8),9127118(9),159159(18),164164(19),156156(20),169169(21),159159(22),153153(23),155155(24),155155(25),91091(26),8917909(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 17157140,171571,1494724,Lock-Free (DWCAS 10),305305(0),313313(1),307307(2),287287(3),309309(4),309309(5),323323(6),237237(7),322322(8),5943938(9),305305(18),314314(19),307307(20),289289(21),303303(22),308308(23),314314(24),239239(25),320320(26),5796791(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 27176149,271761,73566,PThread Mutex,1310309(0),1356355(1),1340339(2),1354353(3),1344343(4),1309308(5),1326325(6),1316315(7),1293292(8),1573572(9),1345344(18),1350349(19),1346345(20),1356355(21),1356355(22),1314313(23),1338337(24),1322321(25),1300299(26),1621620(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 9038029,90380,1057171,PThread Spinlock (private),43043(0),41041(1),51051(2),49049(3),46046(4),70070(5),59059(6),80080(7),78078(8),4013009(9),43043(18),41041(19),52052(20),50050(21),47047(22),71071(23),60060(24),81081(25),80080(26),3981978(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 9441432,94414,748802,PThread Spinlock (shared),145145(0),135135(1),166166(2),159159(3),141141(4),251251(5),235235(6),242242(7),229229(8),2980978(9),155155(18),139139(19),170170(20),163163(21),145145(22),259259(23),248248(24),254254(25),242242(26),2978976(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             2238236,20348,66091,GCC Spinlock (atomic),69069(0),69069(1),73073(2),100100(3),81081(4),60060(5),54054(6),57057(7),64064(8),249249(9),248248(10),69069(18),69069(19),72072(20),99099(21),77077(22),61061(23),55055(24),58058(25),54054(26),249249(27),249249(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             3649646,33179,224667,GCC Spinlock (sync),51051(0),52052(1),52052(2),50050(3),51051(4),53053(5),57057(6),53053(7),59059(8),655655(9),699699(10),51051(18),51051(19),51051(20),51051(21),51051(22),53053(23),56056(24),53053(25),59059(26),660660(27),678678(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             17697680,160888,1325116,Lock-Free (DWCAS 0),150150(0),129129(1),112112(2),113113(3),151151(4),156156(5),156156(6),147147(7),143143(8),3800797(9),3859856(10),145145(18),127127(19),109109(20),112112(21),149149(22),157157(23),151151(24),144144(25),142142(26),3736733(27),3804801(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             15882867,144390,1255867,Lock-Free (DWCAS 1),80080(0),84084(1),83083(2),89089(3),79079(4),100100(5),104104(6),102102(7),98098(8),3598595(9),3609606(10),79079(18),81081(19),82082(20),91091(21),80080(22),100100(23),104104(24),98098(25),101101(26),3511508(27),3526523(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             11188177,101711,185346,Lock-Free (DWCAS 2),407407(0),414414(1),417417(2),401401(3),405405(4),431431(5),426426(6),430430(7),423423(8),931931(9),921921(10),403403(18),406406(19),415415(20),399399(21),402402(22),427427(23),422422(24),424424(25),420420(26),931931(27),922922(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             14279265,129812,1112437,Lock-Free (DWCAS 3),89089(0),88088(1),84084(2),76076(3),94094(4),98098(5),103103(6),96096(7),91091(8),3134131(9),3254251(10),89089(18),87087(19),78078(20),74074(21),94094(22),100100(23),99099(24),92092(25),90090(26),3078075(27),3189186(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             15035020,136682,1189079,Lock-Free (DWCAS 4),77077(0),79079(1),81081(2),81081(3),71071(4),101101(5),103103(6),97097(7),95095(8),3380377(9),3441438(10),75075(18),76076(19),80080(20),79079(21),72072(22),93093(23),97097(24),94094(25),95095(26),3302299(27),3363360(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             13387374,121703,629449,Lock-Free (DWCAS 5),289289(0),293293(1),294294(2),280280(3),283283(4),292292(5),302302(6),304304(7),296296(8),2040038(9),2049047(10),284284(18),288288(19),287287(20),279279(21),283283(22),302302(23),299299(24),303303(25),297297(26),2021019(27),2017015(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             11445434,104049,238188,Lock-Free (DWCAS 6),391391(0),405405(1),396396(2),375375(3),395395(4),416416(5),420420(6),415415(7),417417(8),1027026(9),1087086(10),383383(18),392392(19),395395(20),369369(21),394394(22),407407(23),416416(24),410410(25),413413(26),1022021(27),1093092(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             15976961,145245,1238865,Lock-Free (DWCAS 7),90090(0),91091(1),95095(2),98098(3),86086(4),116116(5),117117(6),119119(7),116116(8),3513510(9),3596593(10),90090(18),92092(19),97097(20),98098(21),87087(22),121121(23),116116(24),120120(25),117117(26),3464461(27),3534531(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             14773759,134307,1162883,Lock-Free (DWCAS 8),78078(0),81081(1),81081(2),89089(3),71071(4),98098(5),98098(6),97097(7),98098(8),3296293(9),3361358(10),78078(18),77077(19),80080(20),86086(21),72072(22),96096(23),99099(24),96096(25),94094(26),3231228(27),3314311(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             13050037,118637,646730,Lock-Free (DWCAS 9),262262(0),276276(1),273273(2),275275(3),265265(4),259259(5),271271(6),273273(7),273273(8),1973972(9),2163161(10),265265(18),271271(19),270270(20),271271(21),266266(22),258258(23),264264(24),269269(25),272272(26),1942941(27),2132130(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             11371360,103376,327276,Lock-Free (DWCAS 10),360360(0),356356(1),322322(2),353353(3),353353(4),358358(5),363363(6),365365(7),361361(8),1295294(9),1216215(10),355355(18),354354(19),319319(20),350350(21),347347(22),354354(23),359359(24),354354(25),359359(26),1294293(27),1217216(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             26439413,240358,89257,PThread Mutex,1139138(0),1169168(1),1176175(2),1170169(3),1173172(4),1155154(5),1120119(6),1088087(7),1112111(8),1385384(9),1396395(10),1175174(18),1186185(19),1178177(20),1176175(21),1191190(22),1168167(23),1160159(24),1166165(25),1147146(26),1399398(27),1406405(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             10143133,92210,934967,PThread Spinlock (private),2002(0),3003(1),3003(2),2002(3),3003(4),3003(5),2002(6),3003(7),2002(8),3088085(9),1965964(10),2002(18),3003(19),3003(20),2002(21),3003(22),3003(23),3003(24),2002(25),2002(26),2975973(27),2067065(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             10112102,91928,952509,PThread Spinlock (shared),4004(0),4004(1),4004(2),4004(3),4004(4),3003(5),4004(6),4004(7),4004(8),2966964(9),1683682(10),3003(18),4004(19),4004(20),4004(21),4004(22),3003(23),4004(24),4004(25),4004(26),3455452(27),1936935(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         2237235,18644,57289,GCC Spinlock (atomic),51051(0),54054(1),57057(2),56056(3),54054(4),54054(5),52052(6),90090(7),73073(8),191191(9),214214(10),181181(11),51051(18),54054(19),58058(20),56056(21),55055(22),54054(23),53053(24),89089(25),72072(26),182182(27),206206(28),178178(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         3159156,26326,126675,GCC Spinlock (sync),62062(0),63063(1),58058(2),53053(3),64064(4),50050(5),60060(6),50050(7),61061(8),335335(9),328328(10),398398(11),62062(18),63063(19),58058(20),52052(21),64064(22),50050(23),60060(24),49049(25),57057(26),334334(27),326326(28),399399(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         17797780,148315,1038253,Lock-Free (DWCAS 0),136136(0),125125(1),131131(2),141141(3),144144(4),133133(5),132132(6),125125(7),110110(8),2631629(9),2641639(10),2563561(11),133133(18),123123(19),130130(20),138138(21),142142(22),131131(23),129129(24),124124(25),110110(26),2561559(27),2567565(28),2492490(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11563552,96363,20286,Lock-Free (DWCAS 1),491491(0),483483(1),455455(2),465465(3),463463(4),476476(5),483483(6),478478(7),480480(8),518518(9),520520(10),504504(11),486486(18),471471(19),448448(20),457457(21),459459(22),470470(23),472472(24),470470(25),471471(26),514514(27),516516(28),502502(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         13284271,110702,826817,Lock-Free (DWCAS 2),72072(0),72072(1),67067(2),72072(3),73073(4),67067(5),65065(6),61061(7),52052(8),2057055(9),2064062(10),1983982(11),72072(18),68068(19),66066(20),72072(21),74074(22),68068(23),63063(24),60060(25),51051(26),2010008(27),2025023(28),1947946(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11741730,97848,324683,Lock-Free (DWCAS 3),301301(0),294294(1),287287(2),297297(3),296296(4),310310(5),313313(6),307307(7),308308(8),1108107(9),1054053(10),1045044(11),299299(18),286286(19),284284(20),294294(21),272272(22),303303(23),304304(24),303303(25),303303(26),1087086(27),1042041(28),1039038(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12588576,104905,785467,Lock-Free (DWCAS 4),66066(0),64064(1),66066(2),66066(3),66066(4),63063(5),63063(6),58058(7),50050(8),1958957(9),1956955(10),1876875(11),65065(18),65065(19),61061(20),66066(21),66066(22),62062(23),60060(24),56056(25),49049(26),1919918(27),1916915(28),1845844(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12770758,106423,750541,Lock-Free (DWCAS 5),84084(0),80080(1),80080(2),88088(3),87087(4),98098(5),104104(6),100100(7),98098(8),1974973(9),1830829(10),1811810(11),86086(18),77077(19),79079(20),85085(21),88088(22),99099(23),100100(24),96096(25),96096(26),1938937(27),1800799(28),1786785(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11939928,99499,335145,Lock-Free (DWCAS 6),315315(0),311311(1),312312(2),315315(3),308308(4),294294(5),289289(6),294294(7),283283(8),1102101(9),1108107(10),1094093(11),305305(18),307307(19),309309(20),310310(21),304304(22),292292(23),280280(24),287287(25),282282(26),1076075(27),1083082(28),1074073(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         10849839,90415,375867,Lock-Free (DWCAS 7),224224(0),222222(1),233233(2),235235(3),233233(4),233233(5),235235(6),234234(7),231231(8),1126125(9),1124123(10),1121120(11),221221(18),220220(19),231231(20),235235(21),232232(22),232232(23),231231(24),232232(25),233233(26),1105104(27),1110109(28),1112111(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12312300,102602,754849,Lock-Free (DWCAS 8),75075(0),80080(1),74074(2),72072(3),71071(4),63063(5),62062(6),63063(7),60060(8),1862861(9),1922921(10),1802801(11),76076(18),77077(19),72072(20),68068(21),73073(22),61061(23),60060(24),62062(25),62062(26),1838837(27),1880879(28),1771770(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         13140127,109501,794096,Lock-Free (DWCAS 9),87087(0),91091(1),84084(2),88088(3),86086(4),72072(5),70070(6),72072(7),70070(8),1973972(9),2018016(10),1898897(11),89089(18),89089(19),83083(20),86086(21),85085(22),71071(23),68068(24),70070(25),74074(26),1944943(27),1985984(28),1881880(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         10818808,90157,394273,Lock-Free (DWCAS 10),225225(0),223223(1),210210(2),219219(3),214214(4),222222(5),219219(6),220220(7),223223(8),1130129(9),1182181(10),1149148(11),224224(18),222222(19),208208(20),213213(21),216216(22),219219(23),215215(24),220220(25),218218(26),1119118(27),1167166(28),1137136(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         26107081,217559,33254,PThread Mutex,1077076(0),1141140(1),1073072(2),1072071(3),1065064(4),1053052(5),1034033(6),1071070(7),1053052(8),1101100(9),1146145(10),1126125(11),1089088(18),1152151(19),1070069(20),1082081(21),1073072(22),1066065(23),1040039(24),1077076(25),1062061(26),1123122(27),1136135(28),1123122(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         9736727,81139,545390,PThread Spinlock (private),74074(0),68068(1),78078(2),74074(3),73073(4),110110(5),108108(6),107107(7),107107(8),1626625(9),1239238(10),1202201(11),75075(18),70070(19),78078(20),75075(21),75075(22),111111(23),110110(24),109109(25),111111(26),1637636(27),1270269(28),1146145(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         7980973,66508,151366,PThread Spinlock (shared),211211(0),194194(1),219219(2),207207(3),205205(4),299299(5),294294(6),291291(7),290290(8),671671(9),538538(10),534534(11),214214(18),196196(19),218218(20),211211(21),208208(22),308308(23),300300(24),299299(25),300300(26),680680(27),545545(28),541541(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     2355353,18118,50814,GCC Spinlock (atomic),57057(0),53053(1),51051(2),50050(3),49049(4),51051(5),51051(6),139139(7),52052(8),153153(9),162162(10),160160(11),148148(12),57057(18),52052(19),52052(20),50050(21),49049(22),51051(23),50050(24),126126(25),51051(26),158158(27),172172(28),155155(29),154154(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     2739737,21075,139231,GCC Spinlock (sync),15015(0),15015(1),15015(2),15015(3),15015(4),15015(5),15015(6),16016(7),14014(8),338338(9),282282(10),335335(11),286286(12),15015(18),16016(19),14014(20),15015(21),15015(22),15015(23),15015(24),15015(25),14014(26),337337(27),272272(28),336336(29),282282(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     14521507,111704,258000,Lock-Free (DWCAS 0),399399(0),399399(1),396396(2),396396(3),395395(4),389389(5),389389(6),391391(7),389389(8),962962(9),958958(10),926926(11),938938(12),393393(18),391391(19),386386(20),390390(21),387387(22),380380(23),379379(24),380380(25),384384(26),939939(27),939939(28),911911(29),921921(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     11421410,87857,209023,Lock-Free (DWCAS 1),291291(0),298298(1),300300(2),299299(3),298298(4),315315(5),313313(6),313313(7),311311(8),749749(9),749749(10),748748(11),760760(12),289289(18),291291(19),297297(20),297297(21),297297(22),310310(23),308308(24),309309(25),308308(26),736736(27),736736(28),740740(29),748748(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     11778767,90606,208169,Lock-Free (DWCAS 2),334334(0),334334(1),327327(2),328328(3),328328(4),308308(5),302302(6),306306(7),298298(8),761761(9),776776(10),754754(11),756756(12),330330(18),331331(19),322322(20),327327(21),326326(22),307307(23),299299(24),305305(25),292292(26),756756(27),766766(28),747747(29),747747(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10696686,82282,160324,Lock-Free (DWCAS 3),320320(0),319319(1),317317(2),316316(3),312312(4),288288(5),309309(6),291291(7),307307(8),651651(9),643643(10),646646(11),650650(12),314314(18),314314(19),313313(20),311311(21),310310(22),283283(23),303303(24),288288(25),302302(26),648648(27),638638(28),640640(29),653653(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     12453441,95796,606209,Lock-Free (DWCAS 4),75075(0),72072(1),72072(2),77077(3),74074(4),97097(5),96096(6),95095(7),94094(8),1447446(9),1413412(10),1370369(11),1393392(12),75075(18),70070(19),72072(20),77077(21),75075(22),96096(23),95095(24),94094(25),94094(26),1220219(27),1391390(28),1350349(29),1365364(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10131121,77932,205769,Lock-Free (DWCAS 5),258258(0),260260(1),256256(2),255255(3),250250(4),260260(5),256256(6),251251(7),257257(8),712712(9),701701(10),677677(11),694694(12),257257(18),258258(19),255255(20),254254(21),248248(22),255255(23),252252(24),251251(25),257257(26),703703(27),693693(28),666666(29),685685(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10457447,80442,47034,Lock-Free (DWCAS 6),439439(0),430430(1),418418(2),424424(3),423423(4),445445(5),453453(6),440440(7),448448(8),336336(9),331331(10),330330(11),340340(12),434434(18),424424(19),407407(20),417417(21),419419(22),439439(23),436436(24),434434(25),441441(26),334334(27),330330(28),328328(29),347347(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10379369,79841,195753,Lock-Free (DWCAS 7),262262(0),264264(1),267267(2),264264(3),264264(4),279279(5),284284(6),281281(7),281281(8),706706(9),684684(10),687687(11),678678(12),264264(18),262262(19),263263(20),263263(21),264264(22),278278(23),280280(24),278278(25),282282(26),699699(27),673673(28),681681(29),681681(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     8652644,66559,17474,Lock-Free (DWCAS 8),332332(0),327327(1),310310(2),321321(3),320320(4),326326(5),327327(6),327327(7),325325(8),359359(9),353353(10),355355(11),346346(12),330330(18),321321(19),311311(20),321321(21),317317(22),320320(23),319319(24),319319(25),319319(26),358358(27),354354(28),356356(29),371371(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10564554,81266,498898,Lock-Free (DWCAS 9),80080(0),72072(1),73073(2),73073(3),79079(4),87087(5),89089(6),86086(7),86086(8),1201200(9),1145144(10),1124123(11),1121120(12),79079(18),71071(19),70070(20),78078(21),76076(22),88088(23),86086(24),87087(25),86086(26),1178177(27),1125124(28),1105104(29),1117116(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10959949,84307,201576,Lock-Free (DWCAS 10),311311(0),310310(1),301301(2),301301(3),295295(4),263263(5),287287(6),268268(7),288288(8),729729(9),720720(10),710710(11),717717(12),302302(18),304304(19),301301(20),298298(21),292292(22),262262(23),279279(24),271271(25),283283(26),724724(27),720720(28),702702(29),711711(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     24408384,187757,34162,PThread Mutex,939939(0),953953(1),942942(2),937937(3),944944(4),894894(5),866866(6),991991(7),879879(8),949949(9),963963(10),962962(11),963963(12),946946(18),945945(19),939939(20),937937(21),941941(22),912912(23),873873(24),1002001(25),883883(26),949949(27),956956(28),955955(29),965965(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10070060,77462,496741,PThread Spinlock (private),67067(0),82082(1),68068(2),69069(3),65065(4),67067(5),66066(6),66066(7),65065(8),1320319(9),1194193(10),1139138(11),824824(12),67067(18),83083(19),69069(20),71071(21),66066(22),68068(23),66066(24),68068(25),67067(26),1245244(27),1176175(28),1108107(29),820820(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     8694686,66882,235519,PThread Spinlock (shared),176176(0),219219(1),181181(2),184184(3),173173(4),180180(5),176176(6),176176(7),175175(8),699699(9),792792(10),608608(11),586586(12),178178(18),221221(19),183183(20),187187(21),177177(22),181181(23),178178(24),179179(25),178178(26),702702(27),796796(28),612612(29),589589(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 2055053,14679,18931,GCC Spinlock (atomic),97097(0),64064(1),62062(2),77077(3),68068(4),44044(5),52052(6),50050(7),61061(8),82082(9),85085(10),92092(11),95095(12),101101(13),91091(18),65065(19),65065(20),71071(21),69069(22),44044(23),51051(24),51051(25),60060(26),88088(27),80080(28),95095(29),95095(30),98098(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 2098096,14986,87580,GCC Spinlock (sync),14014(0),12012(1),14014(2),15015(3),13013(4),15015(5),15015(6),16016(7),51051(8),229229(9),191191(10),236236(11),94094(12),139139(13),14014(18),11011(19),14014(20),15015(21),13013(22),14014(23),16016(24),16016(25),52052(26),226226(27),188188(28),228228(29),96096(30),139139(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 14401387,102867,509353,Lock-Free (DWCAS 0),164164(0),162162(1),163163(2),164164(3),162162(4),152152(5),149149(6),145145(7),146146(8),1165164(9),1189188(10),1180179(11),1157156(12),1165164(13),162162(18),161161(19),161161(20),165165(21),161161(22),148148(23),148148(24),142142(25),145145(26),1141140(27),1167166(28),1160159(29),1135134(30),1138137(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 12707695,90769,490019,Lock-Free (DWCAS 1),125125(0),123123(1),118118(2),116116(3),120120(4),97097(5),96096(6),94094(7),92092(8),1087086(9),1103102(10),1084083(11),1067066(12),1075074(13),124124(18),121121(19),115115(20),119119(21),123123(22),96096(23),95095(24),93093(25),91091(26),1066065(27),1089088(28),1069068(29),1052051(30),1055054(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10790780,77077,418408,Lock-Free (DWCAS 2),100100(0),101101(1),96096(2),98098(3),98098(4),83083(5),85085(6),77077(7),82082(8),916916(9),944944(10),924924(11),907907(12),909909(13),99099(18),96096(19),95095(20),99099(21),97097(22),85085(23),82082(24),78078(25),82082(26),904904(27),934934(28),911911(29),900900(30),898898(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9469460,67639,107456,Lock-Free (DWCAS 3),277277(0),278278(1),269269(2),278278(3),265265(4),258258(5),251251(6),254254(7),247247(8),468468(9),480480(10),478478(11),474474(12),478478(13),271271(18),273273(19),266266(20),271271(21),265265(22),252252(23),249249(24),255255(25),247247(26),466466(27),477477(28),475475(29),472472(30),466466(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10896886,77835,454112,Lock-Free (DWCAS 4),72072(0),68068(1),61061(2),65065(3),50050(4),75075(5),80080(6),79079(7),79079(8),972972(9),985985(10),965965(11),970970(12),947947(13),70070(18),67067(19),61061(20),64064(21),52052(22),76076(23),77077(24),78078(25),75075(26),959959(27),985985(28),956956(29),963963(30),935935(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9845836,70327,407996,Lock-Free (DWCAS 5),65065(0),66066(1),57057(2),60060(3),48048(4),71071(5),73073(6),71071(7),71071(8),875875(9),895895(10),866866(11),875875(12),850850(13),65065(18),63063(19),57057(20),58058(21),51051(22),72072(23),72072(24),70070(25),68068(26),861861(27),885885(28),863863(29),866866(30),842842(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9722713,69448,311591,Lock-Free (DWCAS 6),119119(0),121121(1),125125(2),130130(3),121121(4),136136(5),138138(6),131131(7),136136(8),753753(9),732732(10),748748(11),763763(12),728728(13),119119(18),116116(19),123123(20),127127(21),122122(22),134134(23),135135(24),133133(25),134134(26),747747(27),730730(28),739739(29),754754(30),719719(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9859850,70428,116595,Lock-Free (DWCAS 7),259259(0),267267(1),269269(2),268268(3),268268(4),278278(5),276276(6),276276(7),280280(8),495495(9),498498(10),490490(11),514514(12),507507(13),260260(18),268268(19),266266(20),257257(21),269269(22),273273(23),275275(24),275275(25),275275(26),488488(27),494494(28),491491(29),515515(30),499499(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9691682,69226,136595,Lock-Free (DWCAS 8),241241(0),242242(1),246246(2),247247(3),242242(4),258258(5),260260(6),258258(7),258258(8),517517(9),520520(10),520520(11),540540(12),509509(13),239239(18),245245(19),245245(20),245245(21),241241(22),256256(23),260260(24),257257(25),258258(26),512512(27),510510(28),513513(29),533533(30),510510(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9119110,65136,80443,Lock-Free (DWCAS 9),399399(0),400400(1),393393(2),396396(3),404404(4),364364(5),354354(6),363363(7),350350(8),219219(9),220220(10),225225(11),228228(12),237237(13),405405(18),404404(19),397397(20),401401(21),397397(22),362362(23),353353(24),358358(25),346346(26),220220(27),224224(28),227227(29),230230(30),234234(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10003994,71457,305531,Lock-Free (DWCAS 10),138138(0),138138(1),134134(2),139139(3),140140(4),151151(5),153153(6),143143(7),147147(8),762762(9),752752(10),718718(11),763763(12),743743(13),137137(18),137137(19),136136(20),138138(21),138138(22),148148(23),147147(24),145145(25),149149(26),754754(27),742742(28),713713(29),755755(30),734734(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 23807784,170056,54321,PThread Mutex,808808(0),816816(1),823823(2),828828(3),818818(4),808808(5),773773(6),788788(7),852852(8),914914(9),917917(10),915915(11),916916(12),925925(13),814814(18),817817(19),814814(20),819819(21),818818(22),812812(23),782782(24),789789(25),868868(26),907907(27),903903(28),926926(29),911911(30),903903(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10702692,76448,347654,PThread Spinlock (private),127127(0),119119(1),254254(2),138138(3),144144(4),139139(5),137137(6),142142(7),144144(8),665665(9),584584(10),882882(11),777777(12),1110109(13),130130(18),120120(19),257257(20),140140(21),145145(22),141141(23),138138(24),147147(25),145145(26),681681(27),593593(28),859859(29),788788(30),1048047(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9675666,69112,220444,PThread Spinlock (shared),188188(0),170170(1),158158(2),201201(3),191191(4),197197(5),201201(6),214214(7),219219(8),602602(9),530530(10),542542(11),690690(12),711711(13),193193(18),170170(19),159159(20),200200(21),192192(22),200200(23),204204(24),216216(25),221221(26),606606(27),534534(28),546546(29),696696(30),715715(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             2020018,13467,48979,GCC Spinlock (atomic),28028(0),29029(1),29029(2),32032(3),30030(4),40040(5),34034(6),39039(7),34034(8),104104(9),109109(10),144144(11),129129(12),100100(13),119119(14),29029(18),29029(19),29029(20),31031(21),30030(22),39039(23),34034(24),39039(25),34034(26),104104(27),103103(28),174174(29),136136(30),94094(31),113113(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             1454453,9696,21981,GCC Spinlock (sync),23023(0),50050(1),61061(2),77077(3),81081(4),29029(5),61061(6),55055(7),83083(8),31031(9),30030(10),34034(11),28028(12),49049(13),29029(14),25025(18),52052(19),61061(20),79079(21),81081(22),29029(23),61061(24),54054(25),83083(26),31031(27),32032(28),35035(29),29029(30),50050(31),30030(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             13969956,93133,442516,Lock-Free (DWCAS 0),107107(0),113113(1),134134(2),136136(3),132132(4),153153(5),150150(6),151151(7),154154(8),958958(9),983983(10),970970(11),975975(12),961961(13),964964(14),107107(18),109109(19),134134(20),134134(21),132132(22),151151(23),148148(24),151151(25),151151(26),938938(27),966966(28),956956(29),964964(30),936936(31),938938(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             10904894,72699,353718,Lock-Free (DWCAS 1),113113(0),110110(1),106106(2),107107(3),112112(4),93093(5),94094(6),86086(7),87087(8),780780(9),775775(10),761761(11),770770(12),771771(13),721721(14),113113(18),109109(19),102102(20),107107(21),111111(22),92092(23),89089(24),85085(25),85085(26),767767(27),765765(28),756756(29),762762(30),758758(31),707707(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             9269260,61795,100582,Lock-Free (DWCAS 2),367367(0),367367(1),382382(2),387387(3),384384(4),394394(5),396396(6),395395(7),394394(8),186186(9),177177(10),196196(11),205205(12),202202(13),222222(14),366366(18),364364(19),379379(20),380380(21),381381(22),391391(23),391391(24),389389(25),386386(26),185185(27),177177(28),196196(29),202202(30),203203(31),216216(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             9273264,61822,228163,Lock-Free (DWCAS 3),147147(0),143143(1),133133(2),136136(3),144144(4),144144(5),143143(6),137137(7),134134(8),560560(9),573573(10),563563(11),561561(12),556556(13),588588(14),146146(18),141141(19),133133(20),135135(21),143143(22),137137(23),138138(24),135135(25),133133(26),556556(27),563563(28),562562(29),553553(30),557557(31),570570(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             11029018,73527,74575,Lock-Free (DWCAS 4),328328(0),327327(1),327327(2),327327(3),322322(4),294294(5),307307(6),297297(7),304304(8),456456(9),453453(10),461461(11),469469(12),454454(13),411411(14),323323(18),326326(19),323323(20),325325(21),324324(22),289289(23),302302(24),294294(25),301301(26),442442(27),454454(28),461461(29),465465(30),446446(31),406406(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             8788780,58592,62112,Lock-Free (DWCAS 5),233233(0),234234(1),246246(2),249249(3),245245(4),251251(5),252252(6),249249(7),248248(8),360360(9),354354(10),362362(11),374374(12),371371(13),358358(14),239239(18),242242(19),250250(20),252252(21),251251(22),251251(23),249249(24),249249(25),251251(26),358358(27),354354(28),364364(29),370370(30),366366(31),348348(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             9532523,63550,62734,Lock-Free (DWCAS 6),285285(0),289289(1),288288(2),289289(3),285285(4),262262(5),257257(6),260260(7),252252(8),385385(9),388388(10),398398(11),400400(12),394394(13),366366(14),278278(18),286286(19),281281(20),284284(21),284284(22),259259(23),254254(24),258258(25),247247(26),379379(27),385385(28),391391(29),395395(30),387387(31),357357(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             10115105,67434,354819,Lock-Free (DWCAS 7),76076(0),74074(1),76076(2),79079(3),79079(4),69069(5),73073(6),71071(7),60060(8),737737(9),748748(10),758758(11),763763(12),742742(13),691691(14),76076(18),74074(19),76076(20),79079(21),80080(22),71071(23),69069(24),71071(25),61061(26),722722(27),741741(28),741741(29),749749(30),730730(31),669669(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             8098090,53987,44609,Lock-Free (DWCAS 8),235235(0),241241(1),237237(2),237237(3),227227(4),237237(5),240240(6),242242(7),243243(8),320320(9),320320(10),314314(11),318318(12),317317(13),329329(14),235235(18),239239(19),233233(20),237237(21),227227(22),234234(23),239239(24),237237(25),240240(26),323323(27),324324(28),312312(29),318318(30),311311(31),324324(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             9067058,60447,88537,Lock-Free (DWCAS 9),236236(0),232232(1),228228(2),232232(3),234234(4),240240(5),237237(6),240240(7),237237(8),418418(9),372372(10),397397(11),406406(12),402402(13),397397(14),242242(18),240240(19),230230(20),236236(21),240240(22),243243(23),231231(24),239239(25),238238(26),409409(27),421421(28),391391(29),406406(30),393393(31),391391(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             9034025,60227,60994,Lock-Free (DWCAS 10),261261(0),264264(1),264264(2),265265(3),270270(4),250250(5),246246(6),251251(7),243243(8),363363(9),364364(10),371371(11),375375(12),375375(13),371371(14),262262(18),259259(19),260260(20),261261(21),262262(22),253253(23),244244(24),248248(25),242242(26),361361(27),360360(28),373373(29),375375(30),371371(31),361361(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             22960938,153073,80548,PThread Mutex,712712(0),706706(1),705705(2),718718(3),714714(4),670670(5),692692(6),712712(7),703703(8),868868(9),859859(10),853853(11),848848(12),851851(13),839839(14),706706(18),704704(19),701701(20),717717(21),705705(22),706706(23),694694(24),722722(25),708708(26),861861(27),864864(28),865865(29),856856(30),841841(31),838838(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             11332321,75549,178849,PThread Spinlock (private),392392(0),360360(1),479479(2),358358(3),669669(4),500500(5),577577(6),499499(7),627627(8),191191(9),179179(10),206206(11),184184(12),213213(13),243243(14),398398(18),369369(19),462462(20),361361(21),607607(22),499499(23),590590(24),507507(25),628628(26),193193(27),181181(28),205205(29),185185(30),212212(31),247247(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             10847837,72319,335413,PThread Spinlock (shared),440440(0),375375(1),577577(2),338338(3),899899(4),522522(5),803803(6),454454(7),773773(8),32032(9),34034(10),42042(11),34034(12),38038(13),30030(14),461461(18),414414(19),571571(20),361361(21),888888(22),392392(23),842842(24),492492(25),814814(26),32032(27),34034(28),42042(29),34034(30),39039(31),30030(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         1324323,8277,30004,GCC Spinlock (atomic),43043(0),44044(1),59059(2),52052(3),46046(4),42042(5),43043(6),100100(7),105105(8),18018(9),19019(10),18018(11),19019(12),18018(13),20020(14),18018(15),43043(18),42042(19),56056(20),56056(21),45045(22),42042(23),45045(24),94094(25),105105(26),18018(27),19019(28),19019(29),20020(30),17017(31),19019(32),19019(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         1259258,7870,24785,GCC Spinlock (sync),67067(0),61061(1),66066(2),54054(3),50050(4),48048(5),61061(6),51051(7),61061(8),15015(9),13013(10),14014(11),13013(12),16016(13),18018(14),18018(15),66066(18),64064(19),66066(20),56056(21),51051(22),48048(23),61061(24),54054(25),61061(26),15015(27),14014(28),14014(29),14014(30),15015(31),16016(32),17017(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         13365352,83533,25822,Lock-Free (DWCAS 0),403403(0),396396(1),400400(2),405405(3),408408(4),397397(5),410410(6),410410(7),410410(8),463463(9),448448(10),439439(11),449449(12),453453(13),406406(14),418418(15),427427(18),420420(19),413413(20),419419(21),413413(22),386386(23),397397(24),359359(25),399399(26),451451(27),444444(28),430430(29),439439(30),440440(31),393393(32),407407(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         10728718,67054,213830,Lock-Free (DWCAS 1),484484(0),487487(1),497497(2),497497(3),499499(4),510510(5),512512(6),512512(7),514514(8),102102(9),101101(10),122122(11),122122(12),124124(13),137137(14),146146(15),494494(18),501501(19),500500(20),502502(21),491491(22),500500(23),506506(24),506506(25),508508(26),96096(27),101101(28),126126(29),123123(30),120120(31),133133(32),145145(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         9697688,60611,24648,Lock-Free (DWCAS 2),264264(0),263263(1),279279(2),279279(3),283283(4),303303(5),300300(6),300300(7),297297(8),311311(9),305305(10),324324(11),323323(12),322322(13),344344(14),346346(15),280280(18),275275(19),283283(20),286286(21),289289(22),297297(23),297297(24),294294(25),296296(26),308308(27),306306(28),323323(29),317317(30),320320(31),336336(32),338338(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         9809800,61311,148397,Lock-Free (DWCAS 3),441441(0),441441(1),436436(2),433433(3),435435(4),402402(5),412412(6),399399(7),415415(8),165165(9),162162(10),158158(11),166166(12),170170(13),145145(14),142142(15),437437(18),434434(19),431431(20),432432(21),429429(22),398398(23),403403(24),397397(25),406406(26),162162(27),163163(28),164164(29),169169(30),167167(31),143143(32),143143(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         8709701,54436,9999,Lock-Free (DWCAS 4),283283(0),289289(1),286286(2),280280(3),281281(4),279279(5),261261(6),280280(7),271271(8),266266(9),266266(10),271271(11),269269(12),266266(13),273273(14),255255(15),278278(18),281281(19),280280(20),281281(21),279279(22),272272(23),259259(24),275275(25),263263(26),263263(27),272272(28),271271(29),267267(30),264264(31),266266(32),254254(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         8768760,54805,147832,Lock-Free (DWCAS 5),394394(0),391391(1),389389(2),376376(3),379379(4),398398(5),395395(6),399399(7),390390(8),128128(9),120120(10),115115(11),114114(12),126126(13),139139(14),140140(15),389389(18),387387(19),390390(20),376376(21),376376(22),392392(23),389389(24),397397(25),389389(26),128128(27),120120(28),118118(29),118118(30),128128(31),133133(32),137137(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         8992984,56206,175002,Lock-Free (DWCAS 6),439439(0),441441(1),436436(2),434434(3),425425(4),412412(5),383383(6),415415(7),393393(8),108108(9),108108(10),112112(11),113113(12),113113(13),113113(14),79079(15),433433(18),434434(19),428428(20),427427(21),422422(22),406406(23),377377(24),405405(25),382382(26),110110(27),110110(28),113113(29),115115(30),110110(31),105105(32),83083(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         9230221,57689,136491,Lock-Free (DWCAS 7),420420(0),416416(1),406406(2),406406(3),407407(4),372372(5),378378(6),368368(7),378378(8),156156(9),158158(10),156156(11),155155(12),164164(13),143143(14),141141(15),415415(18),415415(19),407407(20),404404(21),404404(22),372372(23),373373(24),364364(25),379379(26),159159(27),158158(28),155155(29),159159(30),161161(31),133133(32),139139(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         7674667,47967,118814,Lock-Free (DWCAS 8),317317(0),323323(1),331331(2),326326(3),326326(4),340340(5),345345(6),343343(7),341341(8),108108(9),108108(10),119119(11),122122(12),123123(13),134134(14),135135(15),314314(18),323323(19),328328(20),327327(21),324324(22),338338(23),340340(24),339339(25),346346(26),108108(27),107107(28),121121(29),125125(30),123123(31),128128(32),135135(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         9018009,56363,5939,Lock-Free (DWCAS 9),283283(0),284284(1),282282(2),275275(3),273273(4),278278(5),280280(6),284284(7),288288(8),291291(9),290290(10),285285(11),284284(12),276276(13),281281(14),285285(15),278278(18),282282(19),273273(20),276276(21),276276(22),278278(23),279279(24),278278(25),284284(26),292292(27),290290(28),286286(29),285285(30),275275(31),276276(32),282282(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         7812805,48830,202675,Lock-Free (DWCAS 10),94094(0),96096(1),90090(2),90090(3),91091(4),84084(5),81081(6),78078(7),81081(8),465465(9),469469(10),463463(11),458458(12),462462(13),402402(14),419419(15),91091(18),95095(19),92092(20),91091(21),90090(22),83083(23),79079(24),78078(25),78078(26),463463(27),466466(28),458458(29),453453(30),452452(31),399399(32),414414(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         24458434,152865,24978,PThread Mutex,761761(0),765765(1),780780(2),778778(3),809809(4),774774(5),752752(6),771771(7),762762(8),740740(9),731731(10),740740(11),744744(12),778778(13),736736(14),734734(15),786786(18),781781(19),784784(20),791791(21),813813(22),775775(23),763763(24),781781(25),769769(26),735735(27),745745(28),754754(29),743743(30),783783(31),744744(32),732732(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         8499491,53122,160640,PThread Spinlock (private),123123(0),135135(1),135135(2),141141(3),167167(4),150150(5),177177(6),183183(7),184184(8),533533(9),470470(10),404404(11),405405(12),477477(13),219219(14),297297(15),125125(18),137137(19),137137(20),144144(21),170170(22),153153(23),181181(24),185185(25),187187(26),542542(27),492492(28),414414(29),411411(30),482482(31),228228(32),303303(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         8555547,53472,124699,PThread Spinlock (shared),152152(0),155155(1),170170(2),173173(3),172172(4),170170(5),191191(6),191191(7),188188(8),423423(9),395395(10),389389(11),402402(12),426426(13),287287(14),341341(15),154154(18),158158(19),170170(20),173173(21),173173(22),173173(23),193193(24),196196(25),190190(26),438438(27),414414(28),401401(29),410410(30),438438(31),293293(32),348348(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     1386385,8155,39521,GCC Spinlock (atomic),135135(0),53053(1),60060(2),82082(3),60060(4),56056(5),65065(6),54054(7),54054(8),10010(9),10010(10),11011(11),11011(12),11011(13),11011(14),10010(15),10010(16),128128(18),48048(19),51051(20),95095(21),59059(22),53053(23),61061(24),51051(25),50050(26),11011(27),10010(28),11011(29),11011(30),12012(31),10010(32),10010(33),11011(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     1516515,8921,14562,GCC Spinlock (sync),31031(0),32032(1),34034(2),33033(3),32032(4),33033(5),39039(6),34034(7),29029(8),56056(9),55055(10),59059(11),58058(12),57057(13),51051(14),56056(15),66066(16),31031(18),33033(19),34034(20),34034(21),32032(22),34034(23),40040(24),34034(25),29029(26),57057(27),55055(28),59059(29),57057(30),57057(31),52052(32),56056(33),66066(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     10323313,60725,161996,Lock-Free (DWCAS 0),447447(0),452452(1),451451(2),453453(3),446446(4),426426(5),418418(6),422422(7),419419(8),158158(9),161161(10),163163(11),163163(12),163163(13),154154(14),150150(15),148148(16),444444(18),445445(19),442442(20),446446(21),443443(22),417417(23),408408(24),418418(25),409409(26),157157(27),159159(28),164164(29),163163(30),159159(31),150150(32),148148(33),147147(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     10170160,59824,219545,Lock-Free (DWCAS 1),493493(0),492492(1),493493(2),489489(3),492492(4),457457(5),468468(6),454454(7),473473(8),98098(9),94094(10),106106(11),106106(12),116116(13),103103(14),99099(15),82082(16),484484(18),486486(19),484484(20),486486(21),486486(22),451451(23),461461(24),449449(25),465465(26),99099(27),95095(28),106106(29),108108(30),107107(31),98098(32),101101(33),79079(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     10775765,63387,235020,Lock-Free (DWCAS 2),113113(0),108108(1),119119(2),126126(3),127127(4),141141(5),141141(6),136136(7),137137(8),512512(9),517517(10),534534(11),532532(12),538538(13),547547(14),543543(15),543543(16),112112(18),106106(19),120120(20),125125(21),126126(22),137137(23),140140(24),138138(25),136136(26),511511(27),510510(28),527527(29),532532(30),528528(31),532532(32),537537(33),534534(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     11265254,66266,257114,Lock-Free (DWCAS 3),549549(0),541541(1),536536(2),559559(3),552552(4),553553(5),508508(6),548548(7),510510(8),103103(9),106106(10),102102(11),107107(12),110110(13),98098(14),66066(15),95095(16),561561(18),560560(19),558558(20),546546(21),543543(22),530530(23),493493(24),534534(25),503503(26),102102(27),106106(28),104104(29),111111(30),110110(31),93093(32),68068(33),89089(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     9662653,56839,242460,Lock-Free (DWCAS 4),98098(0),84084(1),76076(2),86086(3),87087(4),97097(5),97097(6),90090(7),91091(8),512512(9),502502(10),490490(11),500500(12),501501(13),514514(14),520520(15),511511(16),89089(18),81081(19),72072(20),84084(21),87087(22),95095(23),95095(24),89089(25),90090(26),509509(27),500500(28),488488(29),498498(30),499499(31),506506(32),511511(33),504504(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     9483474,55785,209440,Lock-Free (DWCAS 5),472472(0),471471(1),467467(2),465465(3),451451(4),417417(5),443443(6),423423(7),445445(8),94094(9),93093(10),95095(11),98098(12),97097(13),64064(14),89089(15),87087(16),456456(18),471471(19),462462(20),455455(21),450450(22),410410(23),435435(24),419419(25),436436(26),93093(27),94094(28),95095(29),98098(30),96096(31),57057(32),88088(33),88088(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     8940932,52594,222370,Lock-Free (DWCAS 6),91091(0),93093(1),89089(2),93093(3),92092(4),70070(5),77077(6),73073(7),74074(8),477477(9),486486(10),487487(11),485485(12),479479(13),423423(14),452452(15),440440(16),95095(18),91091(19),89089(20),93093(21),90090(22),69069(23),76076(24),78078(25),76076(26),470470(27),482482(28),487487(29),481481(30),473473(31),424424(32),443443(33),434434(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     9698689,57051,195200,Lock-Free (DWCAS 7),469469(0),472472(1),466466(2),460460(3),450450(4),408408(5),433433(6),414414(7),433433(8),119119(9),118118(10),116116(11),117117(12),123123(13),92092(14),92092(15),89089(16),466466(18),465465(19),455455(20),455455(21),445445(22),402402(23),420420(24),410410(25),425425(26),123123(27),123123(28),119119(29),121121(30),118118(31),86086(32),96096(33),89089(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     7950943,46770,140868,Lock-Free (DWCAS 8),354354(0),351351(1),347347(2),337337(3),341341(4),349349(5),358358(6),358358(7),348348(8),99099(9),98098(10),106106(11),99099(12),102102(13),119119(14),111111(15),109109(16),348348(18),347347(19),344344(20),335335(21),336336(22),347347(23),347347(24),354354(25),349349(26),100100(27),95095(28),106106(29),105105(30),107107(31),110110(32),115115(33),112112(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     7988981,46994,150352,Lock-Free (DWCAS 9),358358(0),359359(1),355355(2),356356(3),343343(4),360360(5),361361(6),360360(7),364364(8),92092(9),98098(10),94094(11),96096(12),83083(13),109109(14),106106(15),106106(16),350350(18),355355(19),355355(20),353353(21),347347(22),357357(23),354354(24),361361(25),360360(26),93093(27),96096(28),96096(29),99099(30),83083(31),109109(32),109109(33),104104(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     9224215,54260,184495,Lock-Free (DWCAS 10),425425(0),424424(1),438438(2),437437(3),435435(4),397397(5),411411(6),389389(7),409409(8),107107(9),103103(10),104104(11),112112(12),118118(13),105105(14),103103(15),90090(16),450450(18),451451(19),436436(20),436436(21),434434(22),390390(23),393393(24),385385(25),406406(26),104104(27),102102(28),108108(29),110110(30),114114(31),104104(32),102102(33),83083(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     25563538,150374,25508,PThread Mutex,769769(0),774774(1),777777(2),768768(3),772772(4),763763(5),756756(6),771771(7),760760(8),740740(9),730730(10),720720(11),732732(12),739739(13),730730(14),720720(15),720720(16),782782(18),774774(19),780780(20),770770(21),774774(22),766766(23),767767(24),772772(25),772772(26),742742(27),738738(28),730730(29),736736(30),738738(31),727727(32),718718(33),711711(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     9862853,58017,117951,PThread Spinlock (private),402402(0),391391(1),390390(2),369369(3),361361(4),374374(5),370370(6),372372(7),376376(8),180180(9),152152(10),156156(11),159159(12),152152(13),224224(14),225225(15),227227(16),410410(18),398398(19),398398(20),376376(21),368368(22),380380(23),378378(24),381381(25),384384(26),177177(27),155155(28),157157(29),161161(30),157157(31),227227(32),231231(33),235235(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     9609600,56527,166420,PThread Spinlock (shared),518518(0),508508(1),376376(2),357357(3),370370(4),376376(5),343343(6),379379(7),357357(8),136136(9),120120(10),122122(11),122122(12),123123(13),166166(14),157157(15),174174(16),547547(18),552552(19),390390(20),375375(21),389389(22),390390(23),353353(24),391391(25),367367(26),137137(27),121121(28),124124(29),126126(30),124124(31),171171(32),162162(33),177177(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1390389,7724,55671,GCC Spinlock (atomic),13013(0),12012(1),12012(2),11011(3),11011(4),11011(5),10010(6),10010(7),10010(8),55055(9),64064(10),70070(11),68068(12),205205(13),34034(14),34034(15),27027(16),28028(17),12012(18),12012(19),11011(20),11011(21),11011(22),11011(23),10010(24),11011(25),11011(26),59059(27),70070(28),65065(29),85085(30),207207(31),31031(32),33033(33),28028(34),26026(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1397396,7763,25333,GCC Spinlock (sync),17017(0),17017(1),18018(2),18018(3),17017(4),18018(5),19019(6),19019(7),20020(8),61061(9),70070(10),60060(11),49049(12),61061(13),64064(14),60060(15),59059(16),57057(17),17017(18),17017(19),18018(20),18018(21),17017(22),18018(23),19019(24),18018(25),20020(26),54054(27),66066(28),60060(29),47047(30),63063(31),65065(32),60060(33),59059(34),56056(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 12548536,69714,267154,Lock-Free (DWCAS 0),574574(0),571571(1),577577(2),576576(3),567567(4),582582(5),581581(6),584584(7),582582(8),118118(9),119119(10),111111(11),120120(12),97097(13),146146(14),148148(15),140140(16),146146(17),560560(18),557557(19),564564(20),563563(21),555555(22),566566(23),565565(24),572572(25),568568(26),118118(27),116116(28),111111(29),121121(30),94094(31),140140(32),143143(33),139139(34),145145(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 9889880,54944,217153,Lock-Free (DWCAS 1),109109(0),108108(1),101101(2),102102(3),102102(4),83083(5),81081(6),82082(7),82082(8),471471(9),474474(10),470470(11),467467(12),470470(13),451451(14),427427(15),447447(16),434434(17),106106(18),104104(19),100100(20),104104(21),102102(22),84084(23),80080(24),83083(25),83083(26),466466(27),469469(28),465465(29),469469(30),465465(31),442442(32),425425(33),442442(34),430430(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 11519508,63997,282386,Lock-Free (DWCAS 2),583583(0),587587(1),575575(2),572572(3),568568(4),564564(5),520520(6),566566(7),526526(8),93093(9),91091(10),94094(11),94094(12),91091(13),85085(14),58058(15),79079(16),83083(17),567567(18),569569(19),553553(20),558558(21),559559(22),546546(23),502502(24),549549(25),508508(26),92092(27),96096(28),95095(29),94094(30),92092(31),82082(32),57057(33),79079(34),81081(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 9199190,51107,125950,Lock-Free (DWCAS 3),374374(0),378378(1),371371(2),372372(3),376376(4),342342(5),350350(6),337337(7),351351(8),155155(9),155155(10),156156(11),160160(12),164164(13),148148(14),148148(15),133133(16),151151(17),376376(18),373373(19),370370(20),371371(21),366366(22),338338(23),344344(24),332332(25),347347(26),159159(27),159159(28),158158(29),158158(30),158158(31),142142(32),139139(33),131131(34),148148(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 9033024,50183,198586,Lock-Free (DWCAS 4),417417(0),424424(1),430430(2),424424(3),414414(4),390390(5),413413(6),395395(7),409409(8),94094(9),94094(10),92092(11),96096(12),97097(13),71071(14),77077(15),74074(16),78078(17),440440(18),445445(19),437437(20),432432(21),424424(22),382382(23),399399(24),394394(25),407407(26),97097(27),94094(28),97097(29),98098(30),95095(31),67067(32),77077(33),74074(34),76076(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 8915907,49533,173939,Lock-Free (DWCAS 5),111111(0),109109(1),105105(2),109109(3),109109(4),100100(5),96096(6),94094(7),91091(8),408408(9),413413(10),402402(11),407407(12),413413(13),381381(14),368368(15),379379(16),367367(17),115115(18),110110(19),108108(20),111111(21),110110(22),98098(23),93093(24),97097(25),94094(26),408408(27),402402(28),408408(29),413413(30),405405(31),373373(32),367367(33),369369(34),364364(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 10462452,58125,250868,Lock-Free (DWCAS 6),524524(0),525525(1),519519(2),518518(3),512512(4),504504(5),468468(6),503503(7),470470(8),83083(9),85085(10),87087(11),90090(12),93093(13),86086(14),55055(15),77077(16),82082(17),514514(18),514514(19),506506(20),504504(21),501501(22),484484(23),453453(24),491491(25),463463(26),82082(27),84084(28),89089(29),93093(30),93093(31),83083(32),57057(33),78078(34),82082(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 9147138,50817,165974,Lock-Free (DWCAS 7),97097(0),95095(1),108108(2),114114(3),114114(4),130130(5),132132(6),129129(7),125125(8),377377(9),380380(10),375375(11),397397(12),397397(13),408408(14),410410(15),384384(16),412412(17),100100(18),96096(19),109109(20),116116(21),118118(22),127127(23),128128(24),129129(25),126126(26),377377(27),376376(28),372372(29),397397(30),395395(31),400400(32),406406(33),377377(34),405405(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 7890883,43838,185851,Lock-Free (DWCAS 8),367367(0),373373(1),378378(2),374374(3),370370(4),376376(5),385385(6),379379(7),380380(8),58058(9),58058(10),63063(11),62062(12),65065(13),73073(14),69069(15),66066(16),70070(17),362362(18),367367(19),374374(20),371371(21),368368(22),369369(23),375375(24),376376(25),381381(26),59059(27),59059(28),61061(29),63063(30),63063(31),67067(32),70070(33),65065(34),67067(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 7669662,42609,109582,Lock-Free (DWCAS 9),117117(0),117117(1),120120(2),119119(3),118118(4),131131(5),129129(6),128128(7),126126(8),297297(9),302302(10),302302(11),302302(12),295295(13),310310(14),311311(15),309309(16),309309(17),117117(18),114114(19),115115(20),118118(21),118118(22),128128(23),125125(24),127127(25),125125(26),304304(27),301301(28),301301(29),301301(30),290290(31),307307(32),307307(33),310310(34),312312(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 7449442,41386,134934,Lock-Free (DWCAS 10),335335(0),338338(1),331331(2),335335(3),331331(4),304304(5),300300(6),308308(7),293293(8),100100(9),94094(10),93093(11),100100(12),103103(13),97097(14),93093(15),86086(16),81081(17),332332(18),335335(19),326326(20),329329(21),330330(22),302302(23),296296(24),308308(25),298298(26),99099(27),98098(28),102102(29),106106(30),100100(31),91091(32),93093(33),89089(34),86086(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 25055030,139195,37908,PThread Mutex,736736(0),731731(1),730730(2),726726(3),731731(4),704704(5),688688(6),738738(7),695695(8),695695(9),682682(10),677677(11),683683(12),667667(13),656656(14),653653(15),702702(16),637637(17),741741(18),728728(19),727727(20),740740(21),724724(22),678678(23),699699(24),748748(25),694694(26),683683(27),677677(28),674674(29),674674(30),672672(31),653653(32),644644(33),701701(34),642642(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 8906898,49483,62424,PThread Spinlock (private),249249(0),234234(1),276276(2),268268(3),252252(4),325325(5),323323(6),257257(7),314314(8),242242(9),214214(10),222222(11),206206(12),186186(13),257257(14),247247(15),99099(16),238238(17),255255(18),239239(19),282282(20),273273(21),256256(22),331331(23),330330(24),261261(25),321321(26),246246(27),217217(28),228228(29),210210(30),187187(31),261261(32),249249(33),99099(34),244244(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 8952944,49739,67670,PThread Spinlock (shared),269269(0),241241(1),282282(2),275275(3),256256(4),338338(5),336336(6),272272(7),326326(8),234234(9),207207(10),219219(11),200200(12),181181(13),252252(14),241241(15),100100(16),233233(17),272272(18),242242(19),285285(20),276276(21),256256(22),339339(23),337337(24),273273(25),327327(26),232232(27),206206(28),219219(29),200200(30),179179(31),256256(32),244244(33),101101(34),238238(35)

And here without PRNG;

[ec2-user@ip-172-30-0-46 gcc_and_gnumake]$ ../../bin/benchmark -d 0-10 -r

Freelist Push One Pop One

                                   M                                   
                 N                                   N                 
                 S                                   S                 
                L3U                                 L3U                
L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U
L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D
L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I
 P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P 
L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type,per-thread total ops
  1                                                                     159353194,31870639,0,GCC Spinlock (atomic),159353194(18)
  1                                                                     170825655,34165131,0,GCC Spinlock (sync),170825655(18)
  1                                                                     171897726,34379545,0,Lock-Free (DWCAS 0),171897726(18)
  1                                                                     171906735,34381347,0,Lock-Free (DWCAS 1),171906735(18)
  1                                                                     171954783,34390957,0,Lock-Free (DWCAS 2),171954783(18)
  1                                                                     171945774,34389155,0,Lock-Free (DWCAS 3),171945774(18)
  1                                                                     171934763,34386953,0,Lock-Free (DWCAS 4),171934763(18)
  1                                                                     171916745,34383349,0,Lock-Free (DWCAS 5),171916745(18)
  1                                                                     171883712,34376742,0,Lock-Free (DWCAS 6),171883712(18)
  1                                                                     171950779,34390156,0,Lock-Free (DWCAS 7),171950779(18)
  1                                                                     171892721,34378544,0,Lock-Free (DWCAS 8),171892721(18)
  1                                                                     171914743,34382949,0,Lock-Free (DWCAS 9),171914743(18)
  1                                                                     171860689,34372138,0,Lock-Free (DWCAS 10),171860689(18)
  1                                                                     145204059,29040812,0,PThread Mutex,145204059(18)
  1                                                                     220741521,44148304,0,PThread Spinlock (private),220741521(18)
  1                                                                     226439213,45287843,0,PThread Spinlock (shared),226439213(18)
  1   1                                                                 31953922,3195392,2281426,GCC Spinlock (atomic),7910903(18),24043019(19)
  1   1                                                                 31521490,3152149,579558,GCC Spinlock (sync),13711698(18),17809792(19)
  1   1                                                                 44544500,4454450,2563419,Lock-Free (DWCAS 0),13209196(18),31335304(19)
  1   1                                                                 89986897,8998690,11006081,Lock-Free (DWCAS 1),6081075(18),83905822(19)
  1   1                                                                 126685559,12668556,17111118,Lock-Free (DWCAS 2),2845843(18),123839716(19)
  1   1                                                                 138460322,13846032,19056049,Lock-Free (DWCAS 3),1856855(18),136603467(19)
  1   1                                                                 138594456,13859446,1139863,Lock-Free (DWCAS 4),73327254(18),65267202(19)
  1   1                                                                 147240093,14724009,25623,Lock-Free (DWCAS 5),73710637(18),73529456(19)
  1   1                                                                 147724577,14772458,1014297,Lock-Free (DWCAS 6),70276206(18),77448371(19)
  1   1                                                                 150123974,15012397,1652887,Lock-Free (DWCAS 7),80905825(18),69218149(19)
  1   1                                                                 155754599,15575460,2120752,Lock-Free (DWCAS 8),85375290(18),70379309(19)
  1   1                                                                 153856703,15385670,127265,Lock-Free (DWCAS 9),77378301(18),76478402(19)
  1   1                                                                 156158002,15615800,1088618,Lock-Free (DWCAS 10),81927846(18),74230156(19)
  1   1                                                                 25019995,2502000,87627,PThread Mutex,12200188(18),12819807(19)
  1   1                                                                 47934887,4793489,142554,PThread Spinlock (private),23463440(18),24471447(19)
  1   1                                                                 47088041,4708804,3307331,PThread Spinlock (shared),35237202(18),11850839(19)
  1   1   1                                                             24043019,1602868,2056743,GCC Spinlock (atomic),14853839(18),376376(19),8812804(20)
  1   1   1                                                             24676652,1645110,1962949,GCC Spinlock (sync),11824813(18),225225(19),12626614(20)
  1   1   1                                                             20559539,1370636,576711,Lock-Free (DWCAS 0),8411403(18),7602595(19),4545541(20)
  1   1   1                                                             57865808,3857721,5049215,Lock-Free (DWCAS 1),2743741(18),16912896(19),38209171(20)
  1   1   1                                                             86830744,5788716,9684425,Lock-Free (DWCAS 2),67643576(18),2587585(19),16599583(20)
  1   1   1                                                             111794683,7452979,10762330,Lock-Free (DWCAS 3),77047971(18),1223222(19),33523490(20)
  1   1   1                                                             122826704,8188447,11446941,Lock-Free (DWCAS 4),82196114(18),1302301(19),39328289(20)
  1   1   1                                                             132003872,8800258,10805150,Lock-Free (DWCAS 5),78218140(18),2782780(19),51002952(20)
  1   1   1                                                             135096962,9006464,10453529,Lock-Free (DWCAS 6),60780720(18),2807805(19),71508437(20)
  1   1   1                                                             134488354,8965890,10656941,Lock-Free (DWCAS 7),77438361(18),3582579(19),53467414(20)
  1   1   1                                                             143708565,9580571,11388106,Lock-Free (DWCAS 8),81545464(18),3292289(19),58870812(20)
  1   1   1                                                             147464317,9830954,11781153,Lock-Free (DWCAS 9),86144058(18),4037033(19),57283226(20)
  1   1   1                                                             149618469,9974565,10930394,Lock-Free (DWCAS 10),84242158(18),8041033(19),57335278(20)
  1   1   1                                                             15484469,1032298,160894,PThread Mutex,4728724(18),4949945(19),5805800(20)
  1   1   1                                                             38028991,2535266,203403,PThread Spinlock (private),12565553(18),12019007(19),13444431(20)
  1   1   1                                                             37939902,2529327,175113,PThread Spinlock (shared),12645633(18),12028016(19),13266253(20)
  1   1   1   1                                                         19890871,994544,1711222,GCC Spinlock (atomic),1473472(18),8473465(19),37037(20),9906897(21)
  1   1   1   1                                                         13661648,683082,410699,GCC Spinlock (sync),2389387(18),2420418(19),4682678(20),4169165(21)
  1   1   1   1                                                         23916893,1195845,316494,Lock-Free (DWCAS 0),6618612(18),6362356(19),4623619(20),6312306(21)
  1   1   1   1                                                         28808780,1440439,676589,Lock-Free (DWCAS 1),8337329(18),7990983(19),4280276(20),8200192(21)
  1   1   1   1                                                         40742702,2037135,386837,Lock-Free (DWCAS 2),8741733(18),9989980(19),10635625(20),11375364(21)
  1   1   1   1                                                         71357286,3567864,2619523,Lock-Free (DWCAS 3),11655644(18),28492464(19),13387374(20),17821804(21)
  1   1   1   1                                                         86960874,4348044,1057832,Lock-Free (DWCAS 4),17651634(18),24272248(19),21170149(20),23866843(21)
  1   1   1   1                                                         107035929,5351796,674515,Lock-Free (DWCAS 5),26232206(18),25625600(19),25535510(20),29642613(21)
  1   1   1   1                                                         105233128,5261656,509374,Lock-Free (DWCAS 6),25018994(18),25051026(19),27605578(20),27557530(21)
  1   1   1   1                                                         114580466,5729023,525608,Lock-Free (DWCAS 7),29332303(18),28588560(19),30095065(20),26564538(21)
  1   1   1   1                                                         130185055,6509253,6728925,Lock-Free (DWCAS 8),3411408(18),42172130(19),42014973(20),42586544(21)
  1   1   1   1                                                         135844709,6792235,631674,Lock-Free (DWCAS 9),33717684(18),31895864(19),33893860(20),36337301(21)
  1   1   1   1                                                         138985847,6949292,7030521,Lock-Free (DWCAS 10),4417413(18),46829783(19),45172127(20),42566524(21)
  1   1   1   1                                                         23692669,1184633,85988,PThread Mutex,5588583(18),5882877(19),6088082(20),6133127(21)
  1   1   1   1                                                         33789756,1689488,354289,PThread Spinlock (private),7289282(18),8378370(19),9781772(20),8340332(21)
  1   1   1   1                                                         33702669,1685133,373421,PThread Spinlock (shared),7302295(18),8032024(19),9861852(20),8506498(21)
  1   1   1   1   1                                                     13271258,530850,218202,GCC Spinlock (atomic),2246244(18),2010008(19),2607605(20),3166163(21),3241238(22)
  1   1   1   1   1                                                     12527515,501101,192593,GCC Spinlock (sync),2031029(18),1937936(19),2836834(20),2954952(21),2766764(22)
  1   1   1   1   1                                                     20808788,832352,198998,Lock-Free (DWCAS 0),4410406(18),3274271(19),4428424(20),4357353(21),4338334(22)
  1   1   1   1   1                                                     20212192,808488,57369,Lock-Free (DWCAS 1),4106102(18),4249245(19),4035031(20),3890887(21),3930927(22)
  1   1   1   1   1                                                     31021991,1240880,80572,Lock-Free (DWCAS 2),5987982(18),6392386(19),6439433(20),6143137(21),6059053(22)
  1   1   1   1   1                                                     46957911,1878316,382012,Lock-Free (DWCAS 3),8029021(18),9105096(19),10670660(20),9627618(21),9525516(22)
  1   1   1   1   1                                                     63615552,2544622,640989,Lock-Free (DWCAS 4),10711701(18),11784773(19),14305291(20),14383369(21),12430418(22)
  1   1   1   1   1                                                     76857781,3074311,626539,Lock-Free (DWCAS 5),13317304(18),15132117(19),17350333(20),16415399(21),14642628(22)
  1   1   1   1   1                                                     95455360,3818214,648625,Lock-Free (DWCAS 6),16884868(18),18412394(19),21054033(20),20227207(21),18876858(22)
  1   1   1   1   1                                                     101000900,4040036,515466,Lock-Free (DWCAS 7),18551533(18),20178158(19),21581560(20),21338317(21),19351332(22)
  1   1   1   1   1                                                     120952832,4838113,1092288,Lock-Free (DWCAS 8),27626599(18),25480455(19),23420397(20),20220200(21),24205181(22)
  1   1   1   1   1                                                     116426310,4657052,1044437,Lock-Free (DWCAS 9),19870851(18),21545524(19),25984959(20),25581556(21),23443420(22)
  1   1   1   1   1                                                     124621497,4984860,1045682,Lock-Free (DWCAS 10),21525504(18),24032008(19),28452424(20),26366340(21),24245221(22)
  1   1   1   1   1                                                     25318293,1012732,124508,PThread Mutex,4675671(18),5524519(19),4988984(20),5162157(21),4966962(22)
  1   1   1   1   1                                                     26296270,1051851,207055,PThread Spinlock (private),5455450(18),5887882(19),5433428(20),4992988(21),4526522(22)
  1   1   1   1   1                                                     26401375,1056055,192530,PThread Spinlock (shared),5422417(18),5861856(19),5467462(20),5068063(21),4581577(22)
  1   1   1   1   1   1                                                 12389377,412979,482213,GCC Spinlock (atomic),2605603(18),2551549(19),2470468(20),12012(21),2971969(22),1777776(23)
  1   1   1   1   1   1                                                 10875865,362529,194419,GCC Spinlock (sync),987987(18),2066064(19),2183181(20),2051049(21),1847846(22),1739738(23)
  1   1   1   1   1   1                                                 21098077,703269,219753,Lock-Free (DWCAS 0),3630627(18),3740737(19),3713710(20),2517515(21),3738735(22),3756753(23)
  1   1   1   1   1   1                                                 20154134,671804,334608,Lock-Free (DWCAS 1),3763760(18),3710707(19),3610607(20),3579576(21),3651648(22),1837836(23)
  1   1   1   1   1   1                                                 25356331,845211,383953,Lock-Free (DWCAS 2),4652648(18),4291287(19),2589587(20),4286282(21),4429425(22),5107102(23)
  1   1   1   1   1   1                                                 44339295,1477976,2081555,Lock-Free (DWCAS 3),13520507(18),5356351(19),1735734(20),5196191(21),5889884(22),12640628(23)
  1   1   1   1   1   1                                                 61727666,2057589,2980098,Lock-Free (DWCAS 4),5812807(18),6198192(19),17174157(20),1337336(21),14812798(22),16392376(23)
  1   1   1   1   1   1                                                 81183102,2706103,3267638,Lock-Free (DWCAS 5),14207193(18),12904892(19),14215201(20),14185171(21),1341340(22),24329305(23)
  1   1   1   1   1   1                                                 94153059,3138435,3546548,Lock-Free (DWCAS 6),17208191(18),14977963(19),16562546(20),17011995(21),1853852(22),26538512(23)
  1   1   1   1   1   1                                                 104243139,3474771,3658893,Lock-Free (DWCAS 7),19734715(18),16670654(19),19333314(20),19496477(21),2179177(22),26828802(23)
  1   1   1   1   1   1                                                 111462351,3715412,4125071,Lock-Free (DWCAS 8),19370351(18),16791775(19),21410389(20),21676655(21),2111109(22),30102072(23)
  1   1   1   1   1   1                                                 120040921,4001364,3979380,Lock-Free (DWCAS 9),21841820(18),19745726(19),23836813(20),24504480(21),2635633(22),27476449(23)
  1   1   1   1   1   1                                                 125416291,4180543,4266763,Lock-Free (DWCAS 10),22976954(18),20154134(19),23120097(20),24965941(21),2958956(22),31240209(23)
  1   1   1   1   1   1                                                 26873847,895795,136817,PThread Mutex,4309305(18),4189185(19),4440436(20),4431427(21),4433429(22),5070065(23)
  1   1   1   1   1   1                                                 24330306,811010,149358,PThread Spinlock (private),4126122(18),3739736(19),4402398(20),4433429(21),3622619(22),4006002(23)
  1   1   1   1   1   1                                                 24287263,809575,170885,PThread Spinlock (shared),4216212(18),3775772(19),4428424(20),4507503(21),3664661(22),3694691(23)
  1   1   1   1   1   1   1                                             9976967,285056,305717,GCC Spinlock (atomic),1219218(18),1335334(19),1698697(20),1828827(21),1807806(22),1940939(23),146146(24)
  1   1   1   1   1   1   1                                             9296287,265608,253848,GCC Spinlock (sync),1493492(18),643643(19),2033031(20),1873872(21),1390389(22),952952(23),908908(24)
  1   1   1   1   1   1   1                                             19890871,568311,196444,Lock-Free (DWCAS 0),2938936(18),1976975(19),2916914(20),2921919(21),2827825(22),3151148(23),3157154(24)
  1   1   1   1   1   1   1                                             18048030,515658,131297,Lock-Free (DWCAS 1),2679677(18),1995994(19),2650648(20),2638636(21),2547545(22),2766764(23),2768766(24)
  1   1   1   1   1   1   1                                             20681661,590905,212530,Lock-Free (DWCAS 2),2966964(18),2100098(19),3013010(20),2866864(21),2945943(22),3373370(23),3415412(24)
  1   1   1   1   1   1   1                                             27665638,790447,443367,Lock-Free (DWCAS 3),4254250(18),2155153(19),3987984(20),3712709(21),3943940(22),4608604(23),5002998(24)
  1   1   1   1   1   1   1                                             46310264,1323150,2384145,Lock-Free (DWCAS 4),7969962(18),1228227(19),4040036(20),4015011(21),4498494(22),8457449(23),16101085(24)
  1   1   1   1   1   1   1                                             63041979,1801199,2695829,Lock-Free (DWCAS 5),8633625(18),1141140(19),7178171(20),6681675(21),6849843(22),15771756(23),16785769(24)
  1   1   1   1   1   1   1                                             77555478,2215871,3124345,Lock-Free (DWCAS 6),11069058(18),1448447(19),9403394(20),8143135(21),8895887(22),19321302(23),19274255(24)
  1   1   1   1   1   1   1                                             89130041,2546573,3129803,Lock-Free (DWCAS 7),13912899(18),1904903(19),11373362(20),10159149(21),11171160(22),20891871(23),19716697(24)
  1   1   1   1   1   1   1                                             97985888,2799597,3435384,Lock-Free (DWCAS 8),15678663(18),1906905(19),12824812(20),11333322(21),11923912(22),22301279(23),22016995(24)
  1   1   1   1   1   1   1                                             106850744,3052878,3156698,Lock-Free (DWCAS 9),19308289(18),2356354(19),15024009(20),13957944(21),14412398(22),20556536(23),21235214(24)
  1   1   1   1   1   1   1                                             115794679,3308419,3258068,Lock-Free (DWCAS 10),20688668(18),2785783(19),16652636(20),15968953(21),15838823(22),21767746(23),22092070(24)
  1   1   1   1   1   1   1                                             18063045,516087,53475,PThread Mutex,2561559(18),2627625(19),2694692(20),2672670(21),2586584(22),2555553(23),2364362(24)
  1   1   1   1   1   1   1                                             21702681,620077,56985,PThread Spinlock (private),3009006(18),3292289(19),3185182(20),3124121(21),3015012(22),3120117(23),2956954(24)
  1   1   1   1   1   1   1                                             21533512,615243,65360,PThread Spinlock (shared),3055052(18),3340337(19),3087084(20),3102099(21),2960958(22),3061058(23),2926924(24)
  1   1   1   1   1   1   1   1                                         8816808,220420,256700,GCC Spinlock (atomic),1016015(18),682682(19),1297296(20),1435434(21),1533532(22),1135134(23),1568567(24),148148(25)
  1   1   1   1   1   1   1   1                                         8615607,215390,294634,GCC Spinlock (sync),738738(18),658658(19),1404403(20),1227226(21),1140139(22),1799798(23),1563562(24),83083(25)
  1   1   1   1   1   1   1   1                                         18258240,456456,43330,Lock-Free (DWCAS 0),2366364(18),2379377(19),2313311(20),2290288(21),2340338(22),2196194(23),2177175(24),2195193(25)
  1   1   1   1   1   1   1   1                                         17678661,441967,65866,Lock-Free (DWCAS 1),2354352(18),2357355(19),2267265(20),2220218(21),2258256(22),2022020(23),2084082(24),2115113(25)
  1   1   1   1   1   1   1   1                                         18958940,473974,37108,Lock-Free (DWCAS 2),2398396(18),2476474(19),2418416(20),2323321(21),2358356(22),2239237(23),2356354(24),2388386(25)
  1   1   1   1   1   1   1   1                                         25419394,635485,95905,Lock-Free (DWCAS 3),3013010(18),3207204(19),3242239(20),3124121(21),3051048(22),2941939(23),3365362(24),3474471(25)
  1   1   1   1   1   1   1   1                                         37294257,932356,1022325,Lock-Free (DWCAS 4),3392389(18),3666663(19),3642639(20),3632629(21),3415412(22),4035031(23),7336329(24),8173165(25)
  1   1   1   1   1   1   1   1                                         51821770,1295544,1171545,Lock-Free (DWCAS 5),4820816(18),5261256(19),5435430(20),5349344(21),4762758(22),6230224(23),9680671(24),10281271(25)
  1   1   1   1   1   1   1   1                                         68386318,1709658,1306265,Lock-Free (DWCAS 6),6481475(18),6965959(19),7486479(20),7340333(21),6709703(22),8591583(23),12123111(24),12687675(25)
  1   1   1   1   1   1   1   1                                         78869791,1971745,1551235,Lock-Free (DWCAS 7),7139132(18),7822815(19),8742734(20),8549541(21),7608601(22),10337327(23),13950937(24),14718704(25)
  1   1   1   1   1   1   1   1                                         88041954,2201049,1485621,Lock-Free (DWCAS 8),8214206(18),8883875(19),10249239(20),9885876(21),9004996(22),11192181(23),15170155(24),15441426(25)
  1   1   1   1   1   1   1   1                                         97621524,2440538,1803703,Lock-Free (DWCAS 9),9156147(18),9773764(19),10363353(20),10137127(21),10273263(22),13133120(23),17236219(24),17548531(25)
  1   1   1   1   1   1   1   1                                         105457352,2636434,1763291,Lock-Free (DWCAS 10),9741732(18),10789779(19),11788777(20),11781770(21),10852842(22),14149135(23),18086068(24),18267249(25)
  1   1   1   1   1   1   1   1                                         21327306,533183,45365,PThread Mutex,2580578(18),2654652(19),2524522(20),2697695(21),2631629(22),2769767(23),2763761(24),2704702(25)
  1   1   1   1   1   1   1   1                                         20522502,513063,495797,PThread Spinlock (private),1928927(18),1396395(19),2109107(20),2128126(21),2318316(22),4365361(23),3045042(24),3231228(25)
  1   1   1   1   1   1   1   1                                         22317295,557932,340276,PThread Spinlock (shared),2020018(18),3641638(19),2423421(20),2789787(21),3877874(22),2524522(23),2374372(24),2665663(25)
  1   1   1   1   1   1   1   1   1                                     7581574,168479,343271,GCC Spinlock (atomic),1181180(18),7007(19),1433432(20),1594593(21),1563562(22),294294(23),602602(24),318318(25),586586(26)
  1   1   1   1   1   1   1   1   1                                     7483476,166299,291408,GCC Spinlock (sync),1107106(18),4004(19),1262261(20),1360359(21),1258257(22),263263(23),983983(24),247247(25),996996(26)
  1   1   1   1   1   1   1   1   1                                     17859842,396885,122712,Lock-Free (DWCAS 0),1953952(18),1968967(19),2054052(20),2076074(21),1429428(22),2119117(23),2142140(24),2067065(25),2049047(26)
  1   1   1   1   1   1   1   1   1                                     17527510,389500,125009,Lock-Free (DWCAS 1),1931930(18),1875874(19),2024022(20),2029027(21),1389388(22),2091089(23),2091089(24),2042040(25),2053051(26)
  1   1   1   1   1   1   1   1   1                                     18873855,419419,126165,Lock-Free (DWCAS 2),2101099(18),2014012(19),2176174(20),2165163(21),1533532(22),2211209(23),2203201(24),2221219(25),2248246(26)
  1   1   1   1   1   1   1   1   1                                     21616595,480369,177461,Lock-Free (DWCAS 3),2410408(18),2366364(19),2447445(20),2380378(21),1613612(22),2545543(23),2587585(24),2617615(25),2647645(26)
  1   1   1   1   1   1   1   1   1                                     31602571,702279,587943,Lock-Free (DWCAS 4),2602600(18),2984982(19),3590587(20),3215212(21),1505504(22),4285281(23),4649645(24),4348344(25),4420416(26)
  1   1   1   1   1   1   1   1   1                                     46545499,1034344,1476254,Lock-Free (DWCAS 5),2762760(18),2659657(19),4627623(20),4895891(21),1010009(22),7676669(23),7895888(24),7682675(25),7334327(26)
  1   1   1   1   1   1   1   1   1                                     59398339,1319963,1627105,Lock-Free (DWCAS 6),5151146(18),4766762(19),5729724(20),5774769(21),1073072(22),8697689(23),8696688(24),9906897(25),9601592(26)
  1   1   1   1   1   1   1   1   1                                     72229157,1605092,1815653,Lock-Free (DWCAS 7),6798792(18),6276270(19),7248241(20),6835829(21),1499498(22),10440430(23),10809799(24),11214203(25),11106095(26)
  1   1   1   1   1   1   1   1   1                                     82456374,1832364,2052421,Lock-Free (DWCAS 8),7702695(18),6956950(19),8365357(20),8623615(21),1578577(22),11837826(23),12367355(24),12570558(25),12453441(26)
  1   1   1   1   1   1   1   1   1                                     93857764,2085728,2123708,Lock-Free (DWCAS 9),9647638(18),8475467(19),10438428(20),10272262(21),1804803(22),13525512(23),12512500(24),13638625(25),13542529(26)
  1   1   1   1   1   1   1   1   1                                     103606503,2302367,2203382,Lock-Free (DWCAS 10),10668658(18),9602593(19),12249237(20),12520508(21),2217215(22),14833819(23),14403389(24),12744732(25),14366352(26)
  1   1   1   1   1   1   1   1   1                                     23032009,511822,127008,PThread Mutex,2743741(18),2816814(19),2716714(20),2711709(21),2658656(22),2254252(23),2558556(24),2251249(25),2320318(26)
  1   1   1   1   1   1   1   1   1                                     20910890,464686,356424,PThread Spinlock (private),1828827(18),2241239(19),3286283(20),3472469(21),2345343(22),1965964(23),1855854(24),2134132(25),1780779(26)
  1   1   1   1   1   1   1   1   1                                     19434415,431876,189918,PThread Spinlock (shared),1892891(18),2209207(19),2011009(20),1913912(21),1855854(22),2266264(23),2202200(24),2958956(25),2124122(26)
  1   1   1   1   1   1   1   1   1   1                                 10622612,212452,1634190,GCC Spinlock (atomic),183183(18),201201(19),195195(20),202202(21),197197(22),228228(23),191191(24),220220(25),190190(26),8813805(27)
  1   1   1   1   1   1   1   1   1   1                                 5056051,101121,580362,GCC Spinlock (sync),204204(18),174174(19),202202(20),221221(21),183183(22),199199(23),209209(24),200200(25),204204(26),3258255(27)
  1   1   1   1   1   1   1   1   1   1                                 27843816,556876,4298032,Lock-Free (DWCAS 0),491491(18),388388(19),494494(20),515515(21),525525(22),567567(23),568568(24),560560(25),560560(26),23171148(27)
  1   1   1   1   1   1   1   1   1   1                                 28830802,576616,4560866,Lock-Free (DWCAS 1),463463(18),330330(19),464464(20),474474(21),468468(22),525525(23),531531(24),527527(25),528528(26),24516492(27)
  1   1   1   1   1   1   1   1   1   1                                 27561534,551231,4537536,Lock-Free (DWCAS 2),332332(18),263263(19),360360(20),370370(21),371371(22),390390(23),395395(24),398398(25),400400(26),24279255(27)
  1   1   1   1   1   1   1   1   1   1                                 28321293,566426,4609981,Lock-Free (DWCAS 3),369369(18),276276(19),391391(20),400400(21),397397(22),442442(23),448448(24),445445(25),451451(26),24698674(27)
  1   1   1   1   1   1   1   1   1   1                                 29115086,582302,4650248,Lock-Free (DWCAS 4),415415(18),326326(19),449449(20),453453(21),455455(22),499499(23),519519(24),512512(25),514514(26),24968944(27)
  1   1   1   1   1   1   1   1   1   1                                 29972943,599459,4771649,Lock-Free (DWCAS 5),452452(18),343343(19),470470(20),475475(21),475475(22),515515(23),540540(24),527527(25),541541(26),25630605(27)
  1   1   1   1   1   1   1   1   1   1                                 30941911,618838,4881901,Lock-Free (DWCAS 6),506506(18),373373(19),494494(20),499499(21),467467(22),580580(23),598598(24),574574(25),596596(26),26250224(27)
  1   1   1   1   1   1   1   1   1   1                                 33611578,672232,5196091,Lock-Free (DWCAS 7),600600(18),422422(19),587587(20),572572(21),593593(22),715715(23),733733(24),658658(25),719719(26),28006979(27)
  1   1   1   1   1   1   1   1   1   1                                 38129091,762582,5883086,Lock-Free (DWCAS 8),669669(18),448448(19),686686(20),658658(21),648648(22),825825(23),853853(24),775775(25),844844(26),31716685(27)
  1   1   1   1   1   1   1   1   1   1                                 42361319,847226,6056749,Lock-Free (DWCAS 9),1081080(18),557557(19),1020019(20),952952(21),954954(22),1207206(23),1288287(24),1129128(25),1210209(26),32959927(27)
  1   1   1   1   1   1   1   1   1   1                                 52590538,1051811,7435022,Lock-Free (DWCAS 10),1400399(18),655655(19),1245244(20),1186185(21),1250249(22),1592591(23),1697696(24),1449448(25),1596595(26),40516476(27)
  1   1   1   1   1   1   1   1   1   1                                 36253217,725064,214097,PThread Mutex,3876873(18),3757754(19),3809806(20),3821818(21),3807804(22),3671668(23),3533530(24),3663660(25),3657654(26),2652650(27)
  1   1   1   1   1   1   1   1   1   1                                 10731721,214634,962628,PThread Spinlock (private),470470(18),508508(19),795795(20),702702(21),661661(22),485485(23),460460(24),482482(25),536536(26),5627622(27)
  1   1   1   1   1   1   1   1   1   1                                 13533520,270670,229987,PThread Spinlock (shared),1142141(18),1268267(19),2013011(20),1803802(21),1603602(22),1255254(23),1191190(24),1311310(25),1320319(26),624624(27)
  1   1   1   1   1   1   1   1   1   1   1                             5539534,100719,444317,GCC Spinlock (atomic),167167(18),163163(19),165165(20),184184(21),187187(22),153153(23),227227(24),217217(25),228228(26),1902901(27),1943942(28)
  1   1   1   1   1   1   1   1   1   1   1                             7358351,133788,712608,GCC Spinlock (sync),174174(18),173173(19),152152(20),188188(21),201201(22),117117(23),152152(24),157157(25),151151(26),2854852(27),3037034(28)
  1   1   1   1   1   1   1   1   1   1   1                             24355331,442824,2636934,Lock-Free (DWCAS 0),338338(18),322322(19),325325(20),354354(21),346346(22),349349(23),345345(24),343343(25),338338(26),10782772(27),10509499(28)
  1   1   1   1   1   1   1   1   1   1   1                             22519497,409445,2516540,Lock-Free (DWCAS 1),251251(18),244244(19),243243(20),264264(21),262262(22),267267(23),265265(24),267267(25),265265(26),10198188(27),9990981(28)
  1   1   1   1   1   1   1   1   1   1   1                             21244223,386259,2401286,Lock-Free (DWCAS 2),220220(18),223223(19),207207(20),228228(21),227227(22),234234(23),233233(24),227227(25),223223(26),9708699(27),9511502(28)
  1   1   1   1   1   1   1   1   1   1   1                             22993971,418072,2543972,Lock-Free (DWCAS 3),281281(18),271271(19),252252(20),287287(21),290290(22),301301(23),298298(24),287287(25),275275(26),10382372(27),10067057(28)
  1   1   1   1   1   1   1   1   1   1   1                             22732710,413322,2511522,Lock-Free (DWCAS 4),289289(18),271271(19),237237(20),286286(21),284284(22),302302(23),306306(24),287287(25),276276(26),10309299(27),9882873(28)
  1   1   1   1   1   1   1   1   1   1   1                             22933911,416980,2538733,Lock-Free (DWCAS 5),275275(18),273273(19),234234(20),291291(21),281281(22),298298(23),295295(24),295295(25),284284(26),10345335(27),10060050(28)
  1   1   1   1   1   1   1   1   1   1   1                             22631609,411484,2472037,Lock-Free (DWCAS 6),300300(18),293293(19),242242(20),300300(21),287287(22),330330(23),320320(24),322322(25),310310(26),10053043(27),9871862(28)
  1   1   1   1   1   1   1   1   1   1   1                             25570545,464919,2749602,Lock-Free (DWCAS 7),370370(18),351351(19),278278(20),384384(21),354354(22),406406(23),409409(24),392392(25),398398(26),11438427(27),10786776(28)
  1   1   1   1   1   1   1   1   1   1   1                             28351323,515479,3035195,Lock-Free (DWCAS 8),427427(18),414414(19),313313(20),443443(21),407407(22),465465(23),450450(24),443443(25),436436(26),12733721(27),11815804(28)
  1   1   1   1   1   1   1   1   1   1   1                             33048015,600873,3504638,Lock-Free (DWCAS 9),539539(18),511511(19),355355(20),536536(21),502502(22),545545(23),563563(24),541541(25),542542(26),14641627(27),13767754(28)
  1   1   1   1   1   1   1   1   1   1   1                             39972933,726781,4260486,Lock-Free (DWCAS 10),654654(18),597597(19),384384(20),610610(21),579579(22),682682(23),666666(24),657657(25),638638(26),17758741(27),16741725(28)
  1   1   1   1   1   1   1   1   1   1   1                             26866840,488488,156583,PThread Mutex,2261259(18),2297295(19),2292290(20),2275273(21),2261259(22),2386384(23),2407405(24),2405403(25),2429427(26),2965963(27),2884882(28)
  1   1   1   1   1   1   1   1   1   1   1                             10695685,194467,680038,PThread Spinlock (private),256256(18),306306(19),381381(20),390390(21),305305(22),669669(23),672672(24),723723(25),759759(26),3134131(27),3096093(28)
  1   1   1   1   1   1   1   1   1   1   1                             11577566,210501,441886,PThread Spinlock (shared),676676(18),785785(19),972972(20),925925(21),802802(22),1724723(23),1805804(24),1795794(25),2020018(26),33033(27),34034(28)
  1   1   1   1   1   1   1   1   1   1   1   1                         5152147,85869,323139,GCC Spinlock (atomic),149149(18),147147(19),145145(20),158158(21),160160(22),133133(23),189189(24),183183(25),196196(26),1151150(27),1144143(28),1395394(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         10377367,172956,1011754,GCC Spinlock (sync),107107(18),104104(19),84084(20),110110(21),115115(22),68068(23),77077(24),80080(25),78078(26),2236234(27),2493491(28),4823819(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         20184164,336403,1692707,Lock-Free (DWCAS 0),279279(18),268268(19),277277(20),290290(21),287287(22),289289(23),287287(24),285285(25),278278(26),6264258(27),6359353(28),5018013(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17446429,290774,1525922,Lock-Free (DWCAS 1),195195(18),192192(19),191191(20),200200(21),197197(22),203203(23),199199(24),188188(25),171171(26),5548543(27),5727722(28),4432428(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         18413395,306890,1601221,Lock-Free (DWCAS 2),207207(18),202202(19),200200(20),214214(21),216216(22),216216(23),217217(24),213213(25),209209(26),5810805(27),6013007(28),4693689(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         18909891,315165,1642162,Lock-Free (DWCAS 3),223223(18),210210(19),211211(20),226226(21),228228(22),235235(23),231231(24),224224(25),206206(26),5996991(27),6239233(28),4677673(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         18655637,310927,1629899,Lock-Free (DWCAS 4),215215(18),200200(19),199199(20),217217(21),212212(22),218218(23),217217(24),211211(25),195195(26),5926921(27),6166160(28),4676672(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17666649,294444,1567259,Lock-Free (DWCAS 5),166166(18),172172(19),167167(20),181181(21),174174(22),179179(23),189189(24),176176(25),175175(26),5582577(27),5888883(28),4614610(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         18782764,313046,1661400,Lock-Free (DWCAS 6),189189(18),198198(19),187187(20),205205(21),195195(22),211211(23),211211(24),209209(25),205205(26),6099093(27),6369363(28),4502498(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         20755735,345929,1828679,Lock-Free (DWCAS 7),240240(18),240240(19),215215(20),243243(21),230230(22),249249(23),244244(24),241241(25),233233(26),6860854(27),7062055(28),4695691(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         22517495,375292,1982052,Lock-Free (DWCAS 8),262262(18),268268(19),238238(20),281281(21),267267(22),284284(23),280280(24),277277(25),274274(26),7791784(27),7477470(28),4814810(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         26083057,434718,2271824,Lock-Free (DWCAS 9),344344(18),341341(19),273273(20),357357(21),331331(22),371371(23),361361(24),355355(25),354354(26),8659651(27),9030021(28),5303298(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         31261230,521020,2706446,Lock-Free (DWCAS 10),460460(18),440440(19),313313(20),454454(21),417417(22),478478(23),473473(24),471471(25),467467(26),10670660(27),10642632(28),5970965(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         28653625,477560,109553,PThread Mutex,2248246(18),2284282(19),2339337(20),2333331(21),2388386(22),2408406(23),2212210(24),2223221(25),2286284(26),2643641(27),2638636(28),2647645(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         11969958,199499,632566,PThread Spinlock (private),846846(18),1092091(19),717717(20),851851(21),950950(22),92092(23),89089(24),97097(25),104104(26),1986985(27),3157154(28),1983982(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         11935924,198932,723337,PThread Spinlock (shared),2061059(18),2686684(19),2090088(20),2053051(21),2184182(22),165165(23),175175(24),174174(25),188188(26),44044(27),63063(28),51051(29)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     4816812,74105,243295,GCC Spinlock (atomic),145145(18),142142(19),135135(20),145145(21),148148(22),117117(23),174174(24),165165(25),152152(26),803803(27),807807(28),943943(29),936936(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     8322314,128036,628272,GCC Spinlock (sync),100100(18),99099(19),80080(20),100100(21),104104(22),63063(23),70070(24),73073(25),71071(26),1482481(27),1584583(28),2647645(29),1846845(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     15711696,241718,1051241,Lock-Free (DWCAS 0),238238(18),237237(19),238238(20),247247(21),246246(22),245245(23),246246(24),236236(25),233233(26),3694691(27),3548545(28),3103100(29),3197194(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     17817800,274120,1227463,Lock-Free (DWCAS 1),243243(18),237237(19),244244(20),257257(21),256256(22),255255(23),254254(24),243243(25),233233(26),4587583(27),3435432(28),3657654(29),3912909(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     16697681,256887,1160424,Lock-Free (DWCAS 2),212212(18),205205(19),209209(20),220220(21),221221(22),229229(23),225225(24),217217(25),218218(26),4031027(27),3911908(28),3266263(29),3530527(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     16733717,257442,1164650,Lock-Free (DWCAS 3),218218(18),213213(19),213213(20),227227(21),226226(22),232232(23),226226(24),210210(25),200200(26),4059055(27),4001998(28),3204201(29),3501498(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     15560545,239393,1091440,Lock-Free (DWCAS 4),188188(18),202202(19),199199(20),203203(21),203203(22),178178(23),176176(24),170170(25),174174(26),3401398(27),3494491(28),3570567(29),3399396(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     18468450,284130,1301608,Lock-Free (DWCAS 5),228228(18),223223(19),228228(20),240240(21),241241(22),242242(23),234234(24),211211(25),190190(26),4498494(27),4489485(28),3565562(29),3875872(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     14982968,230507,1058582,Lock-Free (DWCAS 6),169169(18),186186(19),182182(20),184184(21),179179(22),176176(23),159159(24),163163(25),167167(26),3352349(27),3435432(28),3306303(29),3322319(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     18820802,289551,1329538,Lock-Free (DWCAS 7),236236(18),242242(19),218218(20),245245(21),240240(22),257257(23),256256(24),235235(25),246246(26),4807803(27),4745741(28),3280277(29),3809806(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     17263246,265588,1188980,Lock-Free (DWCAS 8),235235(18),256256(19),247247(20),248248(21),241241(22),221221(23),189189(24),209209(25),213213(26),3744741(27),3738735(28),3863860(29),3854851(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     22265243,342542,1555093,Lock-Free (DWCAS 9),314314(18),320320(19),265265(20),332332(21),306306(22),344344(23),328328(24),314314(25),326326(26),5630625(27),5592587(28),3332329(29),4857853(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     26997971,415353,1885519,Lock-Free (DWCAS 10),412412(18),397397(19),296296(20),402402(21),382382(22),425425(23),444444(24),407407(25),432432(26),6876870(27),6710704(28),3669666(29),6140134(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     29753724,457750,62408,PThread Mutex,2306304(18),2332330(19),2332330(20),2346344(21),2368366(22),2499497(23),2148146(24),2193191(25),2261259(26),2256254(27),2243241(28),2222220(29),2244242(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     11728717,180442,458331,PThread Spinlock (private),508508(18),524524(19),659659(20),729729(21),556556(22),22022(23),565565(24),522522(25),489489(26),1379378(27),1601600(28),2208206(29),1960959(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     12618606,194132,463072,PThread Spinlock (shared),1306305(18),1234233(19),1615614(20),1703702(21),1408407(22),1327326(23),1340339(24),1291290(25),1286285(26),25025(27),21021(28),33033(29),26026(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 1566565,22380,10541,GCC Spinlock (atomic),106106(18),117117(19),138138(20),133133(21),131131(22),100100(23),92092(24),100100(25),90090(26),112112(27),117117(28),111111(29),106106(30),112112(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 7452445,106464,481850,GCC Spinlock (sync),84084(18),84084(19),67067(20),85085(21),91091(22),53053(23),61061(24),63063(25),61061(26),1139138(27),1124123(28),1953952(29),1318317(30),1267266(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 15019004,214557,245502,Lock-Free (DWCAS 0),818818(18),831831(19),815815(20),833833(21),839839(22),823823(23),828828(24),836836(25),825825(26),1531530(27),1505504(28),1502501(29),1527526(30),1496495(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 16396380,234234,293563,Lock-Free (DWCAS 1),851851(18),855855(19),940940(20),894894(21),929929(22),880880(23),858858(24),866866(25),838838(26),1638637(27),1701700(28),1682681(29),1708707(30),1745744(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14753739,210768,257942,Lock-Free (DWCAS 2),1264263(18),1301300(19),1308307(20),1304303(21),1297296(22),1345344(23),1326325(24),1319318(25),1314313(26),515515(27),523523(28),635635(29),643643(30),654654(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14090076,201287,809807,Lock-Free (DWCAS 3),188188(18),188188(19),196196(20),207207(21),203203(22),207207(23),201201(24),208208(25),203203(26),2405403(27),2575573(28),2431429(29),2448446(30),2426424(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 12702690,181467,154382,Lock-Free (DWCAS 4),1036035(18),1050049(19),1048047(20),1050049(21),1042041(22),1088087(23),1099098(24),1063062(25),1067066(26),634634(27),609609(28),616616(29),632632(30),665665(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 16920904,241727,996554,Lock-Free (DWCAS 5),150150(18),180180(19),230230(20),233233(21),237237(22),230230(23),241241(24),240240(25),239239(26),2604602(27),3009006(28),3110107(29),3175172(30),3040037(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 12497485,178536,112455,Lock-Free (DWCAS 6),865865(18),988988(19),989989(20),1007006(21),967967(22),1027026(23),1024023(24),1035034(25),1071070(26),630630(27),656656(28),739739(29),756756(30),736736(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 15144129,216345,881039,Lock-Free (DWCAS 7),167167(18),187187(19),207207(20),209209(21),208208(22),220220(23),231231(24),231231(25),229229(26),2237235(27),2612610(28),2837835(29),2867865(30),2697695(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 15972957,228185,274393,Lock-Free (DWCAS 8),806806(18),838838(19),864864(20),860860(21),865865(22),896896(23),943943(24),806806(25),941941(26),1621620(27),1574573(28),1620619(29),1635634(30),1693692(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 21204183,302917,272203,Lock-Free (DWCAS 9),1250249(18),1286285(19),1323322(20),831831(21),1283282(22),1354353(23),1392391(24),1402401(25),1371370(26),1555554(27),2006004(28),2062060(29),2048046(30),2037035(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 27656629,395095,582972,Lock-Free (DWCAS 10),1341340(18),2460458(19),2491489(20),2614612(21),2488486(22),2667665(23),2795793(24),2758756(25),2825823(26),791791(27),1093092(28),1084083(29),1125124(30),1118117(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 21993972,314200,108968,PThread Mutex,1444443(18),1436435(19),1476475(20),1465464(21),1449448(22),1472471(23),1435434(24),1496495(25),1493492(26),1770769(27),1763762(28),1779778(29),1759758(30),1749748(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 10711701,153024,307811,PThread Spinlock (private),251251(18),348348(19),445445(20),446446(21),345345(22),620620(23),650650(24),701701(25),558558(26),986986(27),1073072(28),1381380(29),1504503(30),1397396(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 10953943,156485,544187,PThread Spinlock (shared),741741(18),36036(19),1200199(20),1195194(21),988988(22),1804803(23),1692691(24),1834833(25),1444443(26),3003(27),3003(28),3003(29),3003(30),3003(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             4257253,56763,71477,GCC Spinlock (atomic),399399(18),372372(19),361361(20),357357(21),355355(22),343343(23),340340(24),349349(25),345345(26),187187(27),164164(28),173173(29),171171(30),163163(31),174174(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             5153148,68709,115628,GCC Spinlock (sync),210210(18),216216(19),207207(20),219219(21),215215(22),265265(23),290290(24),255255(25),266266(26),455455(27),438438(28),739739(29),491491(30),502502(31),380380(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             13904891,185399,229161,Lock-Free (DWCAS 0),1258257(18),1263262(19),1198197(20),1224223(21),1222221(22),1110109(23),1033032(24),1119118(25),1031030(26),600600(27),589589(28),565565(29),567567(30),576576(31),545545(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             12706694,169423,149919,Lock-Free (DWCAS 1),624624(18),679679(19),706706(20),716716(21),679679(22),693693(23),699699(24),694694(25),718718(26),1055054(27),1064063(28),1107106(29),1109108(30),1100099(31),1057056(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             13996983,186626,325833,Lock-Free (DWCAS 2),1180179(18),1232231(19),1232231(20),1319318(21),1406405(22),1297296(23),1316315(24),1252251(25),1231230(26),415415(27),412412(28),415415(29),436436(30),409409(31),440440(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             12785773,170477,599749,Lock-Free (DWCAS 3),196196(18),200200(19),209209(20),218218(21),213213(22),235235(23),234234(24),239239(25),237237(26),1825824(27),1817816(28),1796795(29),1798797(30),1779778(31),1783782(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             12167155,162229,146204,Lock-Free (DWCAS 4),647647(18),672672(19),674674(20),679679(21),663663(22),662662(23),626626(24),675675(25),621621(26),1057056(27),1071070(28),1045044(29),1016015(30),987987(31),1065064(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             14167153,188895,237328,Lock-Free (DWCAS 5),1101100(18),1185184(19),1243242(20),1240239(21),1219218(22),1196195(23),1164163(24),1206205(25),1183182(26),570570(27),578578(28),558558(29),569569(30),553553(31),597597(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             16265249,216870,70524,Lock-Free (DWCAS 6),952952(18),983983(19),1009008(20),1043042(21),1090089(22),1071070(23),1027026(24),1002001(25),1005004(26),1147146(27),1157156(28),1169168(29),1159158(30),1147146(31),1301300(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             14410396,192139,200298,Lock-Free (DWCAS 7),1184183(18),1179178(19),1208207(20),1186185(21),1167166(22),1130129(23),1163162(24),1179178(25),1132131(26),606606(27),585585(28),695695(29),654654(30),712712(31),625625(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             13702689,182703,242149,Lock-Free (DWCAS 8),1107106(18),1131130(19),1151150(20),1152151(21),1159158(22),1084083(23),1255254(24),1223222(25),1215214(26),589589(27),580580(28),561561(29),547547(30),549549(31),395395(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             16493477,219913,162083,Lock-Free (DWCAS 9),961961(18),970970(19),803803(20),969969(21),952952(22),943943(23),914914(24),932932(25),957957(26),1372371(27),1384383(28),1360359(29),1382381(30),1368367(31),1216215(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             19969950,266266,352620,Lock-Free (DWCAS 10),1593592(18),1674673(19),1744743(20),1747746(21),1696695(22),1773772(23),1821820(24),1924923(25),1101100(26),817817(27),820820(28),823823(29),822822(30),842842(31),762762(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             27148121,361975,108003,PThread Mutex,1678677(18),1700699(19),1719718(20),1695694(21),1703702(22),1688687(23),1686685(24),1698697(25),1694693(26),1972971(27),1984983(28),1999998(29),1978977(30),1970969(31),1972971(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             11102091,148028,225863,PThread Spinlock (private),434434(18),519519(19),486486(20),735735(21),605605(22),480480(23),462462(24),440440(25),545545(26),748748(27),1063062(28),1094093(29),1114113(30),1108107(31),1263262(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1             12265253,163537,517613,PThread Spinlock (shared),1152151(18),1278277(19),1333332(20),1864863(21),1530529(22),1220219(23),1175174(24),1233232(25),1331330(26),18018(27),11011(28),9009(29),35035(30),41041(31),32032(32)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         3515512,43944,186213,GCC Spinlock (atomic),67067(18),83083(19),64064(20),66066(21),66066(22),74074(23),74074(24),74074(25),74074(26),684684(27),675675(28),182182(29),188188(30),193193(31),710710(32),238238(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         3068065,38351,106641,GCC Spinlock (sync),63063(18),30030(19),110110(20),70070(21),96096(22),90090(23),103103(24),79079(25),110110(26),324324(27),399399(28),427427(29),211211(30),241241(31),365365(32),347347(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         12675663,158446,38590,Lock-Free (DWCAS 0),680680(18),742742(19),782782(20),778778(21),753753(22),789789(23),783783(24),808808(25),801801(26),730730(27),788788(28),858858(29),856856(30),811811(31),852852(32),852852(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         16357341,204467,398066,Lock-Free (DWCAS 1),1387386(18),1411410(19),1351350(20),1398397(21),1384383(22),1552551(23),1506505(24),1641640(25),1479478(26),480480(27),473473(28),473473(29),469469(30),466466(31),440440(32),440440(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         13971958,174649,33882,Lock-Free (DWCAS 2),831831(18),849849(19),844844(20),847847(21),861861(22),811811(23),841841(24),815815(25),847847(26),898898(27),915915(28),932932(29),929929(30),917917(31),879879(32),942942(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         13317304,166466,44676,Lock-Free (DWCAS 3),778778(18),777777(19),798798(20),794794(21),796796(22),790790(23),799799(24),760760(25),772772(26),897897(27),878878(28),919919(29),870870(30),930930(31),871871(32),875875(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         10645635,133070,215805,Lock-Free (DWCAS 4),892892(18),920920(19),902902(20),837837(21),830830(22),947947(23),922922(24),942942(25),916916(26),369369(27),351351(28),357357(29),358358(30),362362(31),365365(32),365365(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         14741727,184272,45543,Lock-Free (DWCAS 5),831831(18),852852(19),908908(20),889889(21),880880(22),986986(23),846846(24),1009008(25),836836(26),973973(27),991991(28),965965(29),942942(30),954954(31),930930(32),936936(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         13648635,170608,334710,Lock-Free (DWCAS 6),1154153(18),1216215(19),1210209(20),1230229(21),1241240(22),1243242(23),1248247(24),1227226(25),1223222(26),374374(27),376376(28),385385(29),389389(30),358358(31),380380(32),390390(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         12210198,152627,273301,Lock-Free (DWCAS 7),1003002(18),1057056(19),1020019(20),1033032(21),1055054(22),1059058(23),1113112(24),1117116(25),1100099(26),412412(27),408408(28),405405(29),401401(30),399399(31),263263(32),362362(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         12952940,161912,67106,Lock-Free (DWCAS 8),747747(18),772772(19),753753(20),657657(21),695695(22),790790(23),769769(24),791791(25),760760(26),956956(27),936936(28),794794(29),838838(30),852852(31),908908(32),922922(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         15942927,199287,121948,Lock-Free (DWCAS 9),889889(18),877877(19),878878(20),885885(21),888888(22),886886(23),876876(24),891891(25),882882(26),1163162(27),1110109(28),932932(29),1053052(30),1102101(31),1280279(32),1341340(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         21348327,266854,638883,Lock-Free (DWCAS 10),1969968(18),1980979(19),1966965(20),1970969(21),1327326(22),2189187(23),2189187(24),2288286(25),2249247(26),461461(27),452452(28),458458(29),447447(30),385385(31),497497(32),513513(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         27141114,339264,91574,PThread Mutex,1593592(18),1611610(19),1609608(20),1638637(21),1624623(22),1569568(23),1567566(24),1624623(25),1551550(26),1851850(27),1826825(28),1817816(29),1867866(30),1823822(31),1805804(32),1755754(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         10277267,128466,508073,PThread Spinlock (private),51051(18),65065(19),76076(20),89089(21),66066(22),136136(23),128128(24),117117(25),135135(26),1041040(27),1065064(28),1294293(29),1397396(30),1439438(31),1566565(32),1609608(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1         10661651,133271,516863,PThread Spinlock (shared),742742(18),776776(19),1063062(20),955955(21),882882(22),1496495(23),1608607(24),1341340(25),1782781(26),1001(27),1001(28),2002(29),2002(30),1001(31),2002(32),2002(33)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     2774772,32644,102450,GCC Spinlock (atomic),43043(18),277277(19),46046(20),48048(21),47047(22),37037(23),35035(24),36036(25),32032(26),408408(27),237237(28),233233(29),257257(30),221221(31),354354(32),244244(33),217217(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     1548547,18218,42009,GCC Spinlock (sync),140140(18),157157(19),191191(20),140140(21),134134(22),112112(23),111111(24),95095(25),138138(26),42042(27),44044(28),42042(29),43043(30),44044(31),36036(32),39039(33),39039(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     16001986,188259,29480,Lock-Free (DWCAS 0),961961(18),986986(19),943943(20),911911(21),895895(22),988988(23),963963(24),990990(25),955955(26),907907(27),915915(28),910910(29),921921(30),910910(31),901901(32),1011010(33),920920(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     16705689,196538,60818,Lock-Free (DWCAS 1),988988(18),995995(19),1018017(20),1087086(21),1086085(22),1091090(23),1071070(24),1045044(25),1022021(26),881881(27),887887(28),883883(29),948948(30),915915(31),939939(32),935935(33),905905(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     12444432,146405,30250,Lock-Free (DWCAS 2),754754(18),773773(19),791791(20),807807(21),777777(22),723723(23),733733(24),727727(25),717717(26),698698(27),701701(28),727727(29),727727(30),711711(31),690690(32),666666(33),710710(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     13434421,158052,31458,Lock-Free (DWCAS 3),826826(18),837837(19),845845(20),855855(21),838838(22),811811(23),793793(24),786786(25),788788(26),752752(27),756756(28),770770(29),769769(30),770770(31),730730(32),755755(33),740740(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     11543532,135806,33257,Lock-Free (DWCAS 4),706706(18),731731(19),708708(20),729729(21),736736(22),718718(23),700700(24),700700(25),702702(26),649649(27),648648(28),637637(29),639639(30),630630(31),641641(32),612612(33),646646(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     12294282,144639,35858,Lock-Free (DWCAS 5),739739(18),736736(19),757757(20),749749(21),798798(22),763763(23),752752(24),757757(25),753753(26),694694(27),688688(28),669669(29),639639(30),636636(31),718718(32),718718(33),716716(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     14283269,168038,37724,Lock-Free (DWCAS 6),908908(18),875875(19),904904(20),894894(21),871871(22),858858(23),862862(24),882882(25),860860(26),814814(27),817817(28),780780(29),801801(30),807807(31),778778(32),782782(33),776776(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     13987974,164564,396148,Lock-Free (DWCAS 7),1051050(18),1278277(19),1266265(20),1261260(21),1258257(22),1354353(23),1331330(24),1313312(25),1330329(26),267267(27),268268(28),326326(29),331331(30),336336(31),334334(32),342342(33),337337(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     14190176,166943,44869,Lock-Free (DWCAS 8),895895(18),880880(19),776776(20),826826(21),849849(22),903903(23),908908(24),905905(25),895895(26),805805(27),796796(28),777777(29),798798(30),793793(31),831831(32),720720(33),819819(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     13117104,154319,36294,Lock-Free (DWCAS 9),802802(18),830830(19),828828(20),796796(21),746746(22),779779(23),817817(24),815815(25),826826(26),720720(27),728728(28),719719(29),730730(30),743743(31),688688(32),780780(33),757757(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     15737722,185150,67814,Lock-Free (DWCAS 10),919919(18),938938(19),1007006(20),980980(21),995995(22),998998(23),1058057(24),823823(25),1030029(26),886886(27),903903(28),922922(29),904904(30),895895(31),716716(32),921921(33),830830(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     22050028,259412,96886,PThread Mutex,1195194(18),1185184(19),1209208(20),1192191(21),1201200(22),1136135(23),1192191(24),1187186(25),1191190(26),1429428(27),1420419(28),1445444(29),1434433(30),1430429(31),1401400(32),1384383(33),1414413(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     10463453,123099,190836,PThread Spinlock (private),213213(18),264264(19),372372(20),366366(21),307307(22),626626(23),658658(24),569569(25),678678(26),679679(27),595595(28),736736(29),767767(30),805805(31),886886(32),995995(33),937937(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1     10618608,124925,527973,PThread Spinlock (shared),732732(18),758758(19),1106105(20),1043042(21),804804(22),1562561(23),1589588(24),1367366(25),1640639(26),1001(27),2002(28),2002(29),1001(30),1001(31),2002(32),2002(33),2002(34)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 1325324,14726,15909,GCC Spinlock (atomic),42042(18),44044(19),70070(20),65065(21),69069(22),66066(23),64064(24),44044(25),53053(26),98098(27),91091(28),93093(29),69069(30),93093(31),87087(32),94094(33),89089(34),93093(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 2883881,32043,89415,GCC Spinlock (sync),52052(18),54054(19),85085(20),65065(21),68068(22),86086(23),42042(24),108108(25),42042(26),287287(27),307307(28),324324(29),187187(30),178178(31),197197(32),340340(33),165165(34),294294(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 14923909,165821,430511,Lock-Free (DWCAS 0),1348347(18),1487486(19),1307306(20),1382381(21),1415414(22),1271270(23),1273272(24),1262261(25),1254253(26),322322(27),317317(28),315315(29),315315(30),323323(31),327327(32),331331(33),333333(34),336336(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 14984970,166500,96385,Lock-Free (DWCAS 1),922922(18),929929(19),944944(20),922922(21),1006005(22),949949(23),929929(24),956956(25),925925(26),700700(27),706706(28),730730(29),728728(30),710710(31),758758(32),702702(33),766766(34),689689(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 15816801,175742,524765,Lock-Free (DWCAS 2),1357356(18),1397396(19),1411410(20),1420419(21),1394393(22),1429428(23),1657656(24),1599598(25),1742741(26),282282(27),284284(28),281281(29),288288(30),285285(31),241241(32),254254(33),247247(34),242242(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 12450438,138338,394091,Lock-Free (DWCAS 3),234234(18),242242(19),235235(20),248248(21),244244(22),212212(23),220220(24),222222(25),209209(26),1195194(27),1219218(28),1212211(29),1207206(30),1160159(31),1018017(32),1150149(33),1055054(34),1165164(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 10857847,120643,324556,Lock-Free (DWCAS 4),958958(18),962962(19),972972(20),1002001(21),996996(22),979979(23),996996(24),993993(25),1004003(26),209209(27),206206(28),208208(29),210210(30),215215(31),231231(32),237237(33),235235(34),236236(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 12799787,142220,234701,Lock-Free (DWCAS 5),982982(18),1024023(19),1007006(20),905905(21),896896(22),1052051(23),983983(24),1030029(25),984984(26),429429(27),418418(28),436436(29),436436(30),432432(31),457457(32),433433(33),450450(34),437437(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 12691679,141019,97715,Lock-Free (DWCAS 6),761761(18),788788(19),786786(20),809809(21),804804(22),784784(23),877877(24),829829(25),891891(26),589589(27),611611(28),635635(29),611611(30),615615(31),586586(32),568568(33),581581(34),554554(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 11275264,125281,73291,Lock-Free (DWCAS 7),696696(18),722722(19),728728(20),732732(21),713713(22),708708(23),681681(24),693693(25),721721(26),545545(27),551551(28),556556(29),547547(30),553553(31),512512(32),549549(33),508508(34),549549(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 13552539,150584,64620,Lock-Free (DWCAS 8),836836(18),864864(19),832832(20),847847(21),840840(22),801801(23),807807(24),802802(25),805805(26),672672(27),687687(28),649649(29),663663(30),674674(31),688688(32),697697(33),688688(34),687687(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 13499486,149994,423891,Lock-Free (DWCAS 9),1292291(18),1332331(19),1290289(20),1013012(21),1092091(22),1335334(23),1252251(24),1349348(25),1234233(26),258258(27),252252(28),253253(29),250250(30),262262(31),259259(32),262262(33),256256(34),254254(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 15953938,177266,130287,Lock-Free (DWCAS 10),924924(18),1022021(19),1034033(20),1028027(21),984984(22),1064063(23),1080079(24),1087086(25),1087086(26),732732(27),743743(28),727727(29),678678(30),739739(31),752752(32),763763(33),745745(34),756756(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 30122092,334690,90801,PThread Mutex,1808807(18),1785784(19),1783782(20),1805804(21),1801800(22),1749748(23),1671670(24),1656655(25),1828827(26),1606605(27),1614613(28),1616615(29),1605604(30),1602601(31),1581580(32),1496495(33),1485484(34),1619618(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 12565553,139617,284110,PThread Spinlock (private),553553(18),558558(19),509509(20),1094093(21),572572(22),593593(23),506506(24),504504(25),509509(26),834834(27),1535534(28),1372371(29),932932(30),912912(31),364364(32),416416(33),378378(34),415415(35)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1 12638626,140429,435354,PThread Spinlock (shared),893893(18),830830(19),828828(20),2307305(21),1011010(22),739739(23),749749(24),697697(25),665665(26),272272(27),269269(28),1518517(29),317317(30),449449(31),256256(32),288288(33),270270(34),272272(35)
1 1                                                                     88063976,8806398,83805,GCC Spinlock (atomic),43735692(0),44328284(18)
1 1                                                                     92227135,9222714,1274,GCC Spinlock (sync),46118072(0),46109063(18)
1 1                                                                     127195068,12719507,531144,Lock-Free (DWCAS 0),65475410(0),61719658(18)
1 1                                                                     124446322,12444632,1566534,Lock-Free (DWCAS 1),67761694(0),56684628(18)
1 1                                                                     124742618,12474262,935730,Lock-Free (DWCAS 2),65679614(0),59063004(18)
1 1                                                                     124651527,12465153,628397,Lock-Free (DWCAS 3),64547483(0),60104044(18)
1 1                                                                     124605481,12460548,581965,Lock-Free (DWCAS 4),64360296(0),60245185(18)
1 1                                                                     124464340,12446434,486976,Lock-Free (DWCAS 5),63953890(0),60510450(18)
1 1                                                                     124641517,12464152,381229,Lock-Free (DWCAS 6),63668605(0),60972912(18)
1 1                                                                     124774650,12477465,452435,Lock-Free (DWCAS 7),63986923(0),60787727(18)
1 1                                                                     124558434,12455843,544734,Lock-Free (DWCAS 8),64205141(0),60353293(18)
1 1                                                                     124547423,12454742,242780,Lock-Free (DWCAS 9),63132069(0),61415354(18)
1 1                                                                     124660536,12466054,416761,Lock-Free (DWCAS 10),63803740(0),60856796(18)
1 1                                                                     38054016,3805402,129955,PThread Mutex,19486467(0),18567549(18)
1 1                                                                     145265120,14526512,185447,PThread Spinlock (private),73288215(0),71976905(18)
1 1                                                                     145142998,14514300,61721,PThread Spinlock (shared),72789717(0),72353281(18)
1 1 1 1                                                                 22541519,1127076,111918,GCC Spinlock (atomic),5364359(0),5929924(1),5347342(18),5899894(19)
1 1 1 1                                                                 20686666,1034333,65723,GCC Spinlock (sync),5263258(0),4988984(1),5393388(18),5041036(19)
1 1 1 1                                                                 24870846,1243542,92407,Lock-Free (DWCAS 0),6459453(0),5998993(1),6437431(18),5974969(19)
1 1 1 1                                                                 57302245,2865112,4404223,Lock-Free (DWCAS 1),3378375(0),26460434(1),3312309(18),24151127(19)
1 1 1 1                                                                 82602520,4130126,7260638,Lock-Free (DWCAS 2),40424384(0),2534532(1),37104067(18),2539537(19)
1 1 1 1                                                                 80055976,4002799,214303,Lock-Free (DWCAS 3),20105085(0),20781761(1),19283264(18),19885866(19)
1 1 1 1                                                                 93143050,4657152,847050,Lock-Free (DWCAS 4),25821796(0),21631610(1),24891867(18),20797777(19)
1 1 1 1                                                                 105925820,5296291,5843675,Lock-Free (DWCAS 5),12035023(0),41922881(1),11734723(18),40233193(19)
1 1 1 1                                                                 108299191,5414960,5657392,Lock-Free (DWCAS 6),42039998(0),13075062(1),40371331(18),12812800(19)
1 1 1 1                                                                 109011903,5450595,139774,Lock-Free (DWCAS 7),27446419(0),27671644(1),27157130(18),26736710(19)
1 1 1 1                                                                 111966855,5598343,469531,Lock-Free (DWCAS 8),29384355(0),26963937(1),28915887(18),26702676(19)
1 1 1 1                                                                 114150036,5707502,5047686,Lock-Free (DWCAS 9),16166150(0),41801760(1),15689674(18),40492452(19)
1 1 1 1                                                                 115444329,5772216,5144694,Lock-Free (DWCAS 10),41960919(0),16036020(1),41482441(18),15964949(19)
1 1 1 1                                                                 28516488,1425824,307374,PThread Mutex,5823818(0),7631624(1),7326319(18),7734727(19)
1 1 1 1                                                                 37512475,1875624,117788,PThread Spinlock (private),9120111(0),9717708(1),9053044(18),9621612(19)
1 1 1 1                                                                 37443406,1872170,153191,PThread Spinlock (shared),9018009(0),9791782(1),8942934(18),9690681(19)
1 1 1 1 1 1                                                             14124110,470804,22877,GCC Spinlock (atomic),2398396(0),2388386(1),2301299(2),2388386(18),2369367(19),2278276(20)
1 1 1 1 1 1                                                             14151137,471705,55457,GCC Spinlock (sync),2352350(0),2206204(1),2473471(2),2330328(18),2258256(19),2530528(20)
1 1 1 1 1 1                                                             20349329,678311,42425,Lock-Free (DWCAS 0),3509506(0),3302299(1),3361358(2),3508505(18),3303300(19),3364361(20)
1 1 1 1 1 1                                                             24623599,820787,186736,Lock-Free (DWCAS 1),3638635(0),4304300(1),4552548(2),3543540(18),4172168(19),4412408(20)
1 1 1 1 1 1                                                             40605565,1353519,385555,Lock-Free (DWCAS 2),7142135(0),6372366(1),5835830(2),6876870(18),6144138(19),8234226(20)
1 1 1 1 1 1                                                             56020965,1867366,424207,Lock-Free (DWCAS 3),9163154(0),8545537(1),10667657(2),8997989(18),8334326(19),10312302(20)
1 1 1 1 1 1                                                             71041971,2368066,486310,Lock-Free (DWCAS 4),11381370(0),11244233(1),13440427(2),11037026(18),10942932(19),12995983(20)
1 1 1 1 1 1                                                             86816730,2893891,528689,Lock-Free (DWCAS 5),14329315(0),13565552(1),16072056(2),14008995(18),13123110(19),15717702(20)
1 1 1 1 1 1                                                             94273179,3142439,363477,Lock-Free (DWCAS 6),16020004(0),14869855(1),16745729(2),15513498(18),14741727(19),16382366(20)
1 1 1 1 1 1                                                             98106008,3270200,222576,Lock-Free (DWCAS 7),16565549(0),16011996(1),17023006(2),16202186(18),15639624(19),16663647(20)
1 1 1 1 1 1                                                             102112010,3403734,260778,Lock-Free (DWCAS 8),17517500(0),16494478(1),17501484(2),17257240(18),16103087(19),17238221(20)
1 1 1 1 1 1                                                             103529426,3450981,233156,Lock-Free (DWCAS 9),17514497(0),16731715(1),17799782(2),17358341(18),16498482(19),17626609(20)
1 1 1 1 1 1                                                             105258153,3508605,318266,Lock-Free (DWCAS 10),18057039(0),16666650(1),18152134(2),17946929(18),16603587(19),17831814(20)
1 1 1 1 1 1                                                             21251230,708374,170426,PThread Mutex,2899897(0),3445442(1),3920917(2),3883880(18),3402399(19),3698695(20)
1 1 1 1 1 1                                                             31164133,1038804,383686,PThread Spinlock (private),5466461(0),4143139(1),6012006(2),5442437(18),4120116(19),5979974(20)
1 1 1 1 1 1                                                             30257227,1008574,401994,PThread Spinlock (shared),4784780(0),4221217(1),6183177(2),4745741(18),4191187(19),6131125(20)
1 1 1 1 1 1 1 1                                                         10598588,264965,76159,GCC Spinlock (atomic),1271270(0),1553552(1),1206205(2),1280279(3),1254253(18),1553552(19),1208207(20),1271270(21)
1 1 1 1 1 1 1 1                                                         10574564,264364,83292,GCC Spinlock (sync),1276275(0),1567566(1),1144143(2),1259258(3),1229228(18),1567566(19),1257256(20),1273272(21)
1 1 1 1 1 1 1 1                                                         16013998,400350,23333,Lock-Free (DWCAS 0),2068066(0),2006004(1),1955954(2),1972971(3),2065063(18),2000999(19),1955954(20),1988987(21)
1 1 1 1 1 1 1 1                                                         17979962,449499,32946,Lock-Free (DWCAS 1),2312310(0),2215213(1),2309307(2),2315313(3),2232230(18),2135133(19),2227225(20),2233231(21)
1 1 1 1 1 1 1 1                                                         25951926,648798,77280,Lock-Free (DWCAS 2),3494491(0),3134131(1),3237234(2),3253250(3),3423420(18),3066063(19),3176173(20),3167164(21)
1 1 1 1 1 1 1 1                                                         38299261,957482,247333,Lock-Free (DWCAS 3),5433428(0),4217213(1),4887883(2),4747743(3),5391386(18),4162158(19),4809805(20),4649645(21)
1 1 1 1 1 1 1 1                                                         52369317,1309233,478125,Lock-Free (DWCAS 4),7627620(0),6609603(1),6555549(2),6454448(3),7545538(18),6533527(19),4674670(20),6368362(21)
1 1 1 1 1 1 1 1                                                         68791723,1719793,151642,Lock-Free (DWCAS 5),9052043(0),8326318(1),8619611(2),8447439(3),9004996(18),8322314(19),8594586(20),8424416(21)
1 1 1 1 1 1 1 1                                                         79311232,1982781,197776,Lock-Free (DWCAS 6),10521511(0),9663654(1),9745736(2),9729720(3),10494484(18),9690681(19),9857848(20),9607598(21)
1 1 1 1 1 1 1 1                                                         85947862,2148697,175353,Lock-Free (DWCAS 7),11305294(0),10734724(1),10539529(2),10507497(3),11222211(18),10626616(19),10499489(20),10512502(21)
1 1 1 1 1 1 1 1                                                         90631541,2265789,234322,Lock-Free (DWCAS 8),11954943(0),11556545(1),11137126(2),10850840(3),11890879(18),11394383(19),11008998(20),10837827(21)
1 1 1 1 1 1 1 1                                                         93554461,2338862,312801,Lock-Free (DWCAS 9),12593581(0),11168157(1),11397386(2),11287276(3),12586574(18),11875864(19),11351340(20),11294283(21)
1 1 1 1 1 1 1 1                                                         96760664,2419017,279363,Lock-Free (DWCAS 10),12739727(0),12333321(1),11651640(2),11662651(3),12791779(18),12404392(19),11610599(20),11566555(21)
1 1 1 1 1 1 1 1                                                         17744727,443618,67272,PThread Mutex,2089087(0),2106104(1),2233231(2),2233231(3),2460458(18),2116114(19),2330328(20),2176174(21)
1 1 1 1 1 1 1 1                                                         24772748,619319,218686,PThread Spinlock (private),2721719(0),3739736(1),2976974(2),2954952(3),2713711(18),3746743(19),2967965(20),2950948(21)
1 1 1 1 1 1 1 1                                                         24080056,602001,761740,PThread Spinlock (shared),2999997(0),5203198(1),1830829(2),2018016(3),2988986(18),5219214(19),1809808(20),2010008(21)
1 1 1 1 1 1 1 1 1 1                                                     10086076,201722,29935,GCC Spinlock (atomic),1059058(0),1035034(1),929929(2),976976(3),1045044(4),1058057(18),1031030(19),933933(20),975975(21),1041040(22)
1 1 1 1 1 1 1 1 1 1                                                     9719710,194394,19429,GCC Spinlock (sync),995995(0),954954(1),909909(2),943943(3),974974(4),972972(18),994994(19),1017016(20),1003002(21),951951(22)
1 1 1 1 1 1 1 1 1 1                                                     16304288,326086,352442,Lock-Free (DWCAS 0),517517(0),1868867(1),1940939(2),1855854(3),1964963(4),520520(18),1871870(19),1942941(20),1854853(21),1965964(22)
1 1 1 1 1 1 1 1 1 1                                                     17100083,342002,300133,Lock-Free (DWCAS 1),765765(0),1926925(1),1961960(2),1986985(3),2006004(4),760760(18),1884883(19),1909908(20),1937936(21),1958957(22)
1 1 1 1 1 1 1 1 1 1                                                     21938917,438778,348619,Lock-Free (DWCAS 2),1100099(0),2467465(1),2420418(2),2541539(3),2537535(4),1092091(18),2420418(19),2371369(20),2494492(21),2493491(22)
1 1 1 1 1 1 1 1 1 1                                                     33131098,662622,679326,Lock-Free (DWCAS 3),1204203(0),4253249(1),3633630(2),3685682(3),3930927(4),1215214(18),4165161(19),3571568(20),3610607(21),3860857(22)
1 1 1 1 1 1 1 1 1 1                                                     42823781,856476,774787,Lock-Free (DWCAS 4),1904903(0),5388383(1),4642638(2),4689685(3),4969965(4),1876875(18),5291286(19),4552548(20),4609605(21),4897893(22)
1 1 1 1 1 1 1 1 1 1                                                     59474415,1189488,997979,Lock-Free (DWCAS 5),2854852(0),7213206(1),6541535(2),6444438(3),6881875(4),2820818(18),7106099(19),6429423(20),6390384(21),6791785(22)
1 1 1 1 1 1 1 1 1 1                                                     72295223,1445904,1309395,Lock-Free (DWCAS 6),3128125(0),8411403(1),8183175(2),8046038(3),8612604(4),3086083(18),8356348(19),8082074(20),7941934(21),8447439(22)
1 1 1 1 1 1 1 1 1 1                                                     78386308,1567726,1339326,Lock-Free (DWCAS 7),3627624(0),8912904(1),9020011(2),8673665(3),9188179(4),3608605(18),8750742(19),8922914(20),8581573(21),9100091(22)
1 1 1 1 1 1 1 1 1 1                                                     84987903,1699758,1497822,Lock-Free (DWCAS 8),3837834(0),9776767(1),9764755(2),9400391(3),10077067(4),3738735(18),9641632(19),9594585(20),9173164(21),9982973(22)
1 1 1 1 1 1 1 1 1 1                                                     88369281,1767386,1519725,Lock-Free (DWCAS 9),4089085(0),9996987(1),10074064(2),9686677(3),10515505(4),4033029(18),9844835(19),10099089(20),9615606(21),10414404(22)
1 1 1 1 1 1 1 1 1 1                                                     92364272,1847285,1603714,Lock-Free (DWCAS 10),4227223(0),10238228(1),10590580(2),10145135(3),10892882(4),4157153(18),10612602(19),10657647(20),10049039(21),10793783(22)
1 1 1 1 1 1 1 1 1 1                                                     18974956,379499,38878,PThread Mutex,1840839(0),1853852(1),1881880(2),1873872(3),1916915(4),2053051(18),1836835(19),1888887(20),1875874(21),1952951(22)
1 1 1 1 1 1 1 1 1 1                                                     22018997,440380,131381,PThread Spinlock (private),2587585(0),2083081(1),2026024(2),2098096(3),2191189(4),2618616(18),2114112(19),2019017(20),2093091(21),2188186(22)
1 1 1 1 1 1 1 1 1 1                                                     21937916,438758,193730,PThread Spinlock (shared),1693692(0),2057055(1),2516514(2),2502500(3),2210208(4),1686685(18),2055053(19),2511509(20),2497495(21),2207205(22)
1 1 1 1 1 1 1 1 1 1 1 1                                                 8518510,141975,16165,GCC Spinlock (atomic),727727(0),704704(1),719719(2),719719(3),723723(4),662662(5),732732(18),702702(19),727727(20),717717(21),719719(22),659659(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 8440432,140674,20885,GCC Spinlock (sync),711711(0),694694(1),678678(2),708708(3),720720(4),632632(5),730730(18),723723(19),747747(20),721721(21),702702(22),666666(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 15184169,253069,269585,Lock-Free (DWCAS 0),396396(0),1417416(1),1436435(2),1424423(3),1421420(4),1489488(5),397397(18),1420419(19),1440439(20),1425424(21),1425424(22),1489488(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 15198183,253303,220597,Lock-Free (DWCAS 1),561561(0),1409408(1),1338337(2),1400399(3),1440439(4),1525524(5),569569(18),1379378(19),1311310(20),1370369(21),1406405(22),1485484(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 17668651,294478,221761,Lock-Free (DWCAS 2),766766(0),1604603(1),1568567(2),1620619(3),1647646(4),1714713(5),761761(18),1566565(19),1540539(20),1585584(21),1613612(22),1677676(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 25646621,427444,383468,Lock-Free (DWCAS 3),941941(0),2436434(1),2204202(2),2250248(3),2390388(4),2635633(5),933933(18),2419417(19),2189187(20),2250248(21),2384382(22),2610608(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 32567535,542792,471811,Lock-Free (DWCAS 4),1256255(0),3184181(1),2752750(2),2815813(3),3005002(4),3357354(5),1267266(18),3122119(19),2725723(20),2777775(21),2975973(22),3327324(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 47056009,784267,607389,Lock-Free (DWCAS 5),2053051(0),4555551(1),4011007(2),4091087(3),4360356(4),4647643(5),2005003(18),4484480(19),3971968(20),4041037(21),4224220(22),4610606(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 58963905,982732,837750,Lock-Free (DWCAS 6),2315313(0),5372367(1),5166161(2),5197192(3),5485480(4),6131125(5),2288286(18),5268263(19),5127122(20),5150145(21),5436431(22),6026020(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 68826758,1147113,1007886,Lock-Free (DWCAS 7),2587585(0),6307301(1),6132126(2),6091085(3),6372366(4),7116109(5),2559557(18),6201195(19),6078072(20),6013007(21),6319313(22),7049042(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 74945871,1249098,1095353,Lock-Free (DWCAS 8),2935933(0),6770764(1),6620614(2),6515509(3),6575569(4),8030022(5),2880878(18),6596590(19),6558552(20),6477471(21),6964958(22),8019011(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 79542463,1325708,1148929,Lock-Free (DWCAS 9),3138135(0),7150143(1),7009002(2),6891885(3),7375368(4),8479471(5),3095092(18),6985979(19),6938932(20),6787781(21),7274267(22),8416408(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 84729645,1412161,1268180,Lock-Free (DWCAS 10),3327324(0),7766759(1),7646639(2),7633626(3),7919912(4),9052043(5),3259256(18),7803796(19),7571564(20),5988983(21),7878871(22),8880872(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 18872854,314548,52712,PThread Mutex,1501500(0),1618617(1),1606605(2),1615614(3),1600599(4),1427426(5),1646645(18),1615614(19),1609608(20),1610609(21),1608607(22),1411410(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 19146127,319102,248123,PThread Spinlock (private),1206205(0),1239238(1),1509508(2),1733732(3),1609608(4),2283281(5),1205204(18),1238237(19),1506505(20),1737736(21),1608607(22),2268266(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 19953934,332566,284679,PThread Spinlock (shared),1230229(0),1459458(1),1888887(2),2399397(3),1757756(4),1234233(5),1233232(18),1462461(19),1886885(20),2404402(21),1755754(22),1241240(23)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             6960954,99442,67496,GCC Spinlock (atomic),456456(0),469469(1),465465(2),461461(3),454454(4),456456(5),717717(6),453453(18),470470(19),467467(20),460460(21),456456(22),453453(23),717717(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             6859853,97998,68856,GCC Spinlock (sync),456456(0),461461(1),447447(2),463463(3),454454(4),440440(5),714714(6),451451(18),479479(19),460460(20),442442(21),437437(22),437437(23),712712(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             13586573,194094,204822,Lock-Free (DWCAS 0),327327(0),1009008(1),1020019(2),1015014(3),1016015(4),1195194(5),1196195(6),329329(18),1009008(19),1040039(20),1014013(21),1018017(22),1198197(23),1199198(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             13741728,196310,167786,Lock-Free (DWCAS 1),443443(0),1058057(1),1049048(2),1040039(3),1060059(4),1145144(5),1149148(6),440440(18),1038037(19),1026025(20),1020019(21),1038037(22),1116115(23),1118117(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             15570555,222436,168740,Lock-Free (DWCAS 2),565565(0),1185184(1),1176175(2),1180179(3),1212211(4),1262261(5),1269268(6),568568(18),1167166(19),1150149(20),1161160(21),1190189(22),1239238(23),1243242(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             19930911,284727,210776,Lock-Free (DWCAS 3),752752(0),1523522(1),1450449(2),1495494(3),1536535(4),1617616(5),1650649(6),751751(18),1502501(19),1430429(20),1472471(21),1515514(22),1598597(23),1632631(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             25959934,370856,291788,Lock-Free (DWCAS 4),938938(0),2107105(1),1849848(2),1871870(3),2002000(4),2122120(5),2139137(6),933933(18),2087085(19),1845844(20),1852851(21),1985984(22),2094092(23),2129127(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             36031996,514743,370799,Lock-Free (DWCAS 5),1406405(0),2816814(1),2577575(2),2617615(3),2762760(4),2935933(5),2962960(6),1406405(18),2766764(19),2549547(20),2612610(21),2740738(22),2937935(23),2937935(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             48806758,697239,546102,Lock-Free (DWCAS 6),1775774(0),3816813(1),3517514(2),3529526(3),3733730(4),4030026(5),4061057(6),1765764(18),3787784(19),3490487(20),3518515(21),3673670(22),4033029(23),4073069(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             58664606,838066,698625,Lock-Free (DWCAS 7),2048046(0),4462458(1),4212208(2),4208204(3),4473469(4),5029024(5),5061056(6),2037035(18),4418414(19),4192188(20),4163159(21),4387383(22),4957953(23),5014009(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             66072006,943886,816642,Lock-Free (DWCAS 8),2212210(0),4951947(1),4848844(2),4740736(3),5007002(4),5670665(5),5755750(6),2194192(18),4889885(19),4816812(20),4684680(21),4980976(22),5623618(23),5694689(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             71904833,1027212,882892,Lock-Free (DWCAS 9),2432430(0),5464459(1),5243238(2),5114109(3),5455450(4),6148142(5),6229223(6),2408406(18),5400395(19),5171166(20),5100095(21),5388383(22),6135129(23),6214208(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             77935858,1113369,968763,Lock-Free (DWCAS 10),2590588(0),5841836(1),5702697(2),5499494(3),5888883(4),6730724(5),6714708(6),2564562(18),5840835(19),5692687(20),5525520(21),6003998(22),6675669(23),6663657(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             17608591,251551,19621,PThread Mutex,1221220(0),1290289(1),1256255(2),1257256(3),1265264(4),1225224(5),1207206(6),1295294(18),1296295(19),1264263(20),1267266(21),1257256(22),1237236(23),1268267(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             16944928,242070,136068,PThread Spinlock (private),998998(0),1012011(1),1283282(2),1234233(3),1044043(4),1416415(5),1480479(6),1002001(18),1013012(19),1286285(20),1232231(21),1047046(22),1414413(23),1480479(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             16850834,240726,132454,PThread Spinlock (shared),1012011(0),1010009(1),1271270(2),1234233(3),1031030(4),1405404(5),1470469(6),1012011(18),1010009(19),1268267(20),1231230(21),1029028(22),1398397(23),1467466(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         6231225,77890,53082,GCC Spinlock (atomic),359359(0),353353(1),396396(2),386386(3),363363(4),350350(5),559559(6),348348(7),358358(18),352352(19),397397(20),385385(21),363363(22),347347(23),559559(24),350350(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         6185179,77315,55150,GCC Spinlock (sync),367367(0),355355(1),377377(2),376376(3),358358(4),341341(5),564564(6),342342(7),352352(18),364364(19),392392(20),383383(21),361361(22),341341(23),564564(24),342342(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         12794782,159935,185378,Lock-Free (DWCAS 0),214214(0),820820(1),829829(2),830830(3),801801(4),959959(5),974974(6),963963(7),213213(18),818818(19),829829(20),830830(21),803803(22),960960(23),975975(24),964964(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         12634622,157933,144410,Lock-Free (DWCAS 1),333333(0),821821(1),819819(2),815815(3),805805(4),925925(5),936936(6),927927(7),332332(18),805805(19),798798(20),797797(21),791791(22),904904(23),912912(24),902902(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         13847834,173098,132110,Lock-Free (DWCAS 2),438438(0),918918(1),897897(2),896896(3),913913(4),971971(5),974974(6),968968(7),434434(18),903903(19),883883(20),881881(21),898898(22),950950(23),957957(24),953953(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         16452436,205655,137346,Lock-Free (DWCAS 3),581581(0),1091090(1),1049048(2),1064063(3),1091090(4),1136135(5),1142141(6),1114113(7),580580(18),1076075(19),1038037(20),1057056(21),1080079(22),1125124(23),1127126(24),1099098(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         21310289,266379,194064,Lock-Free (DWCAS 4),709709(0),1468467(1),1328327(2),1343342(3),1426425(4),1476475(5),1502501(6),1426425(7),709709(18),1472471(19),1318317(20),1334333(21),1411410(22),1467466(23),1504503(24),1410409(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         27768741,347109,217068,Lock-Free (DWCAS 5),1045044(0),1882881(1),1720719(2),1756755(3),1833832(4),1922921(5),1939938(6),1825824(7),1039038(18),1859858(19),1705704(20),1752751(21),1823822(22),1913912(23),1922921(24),1822821(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         38601563,482520,345013,Lock-Free (DWCAS 6),1362361(0),2659657(1),2392390(2),2445443(3),2516514(4),2783781(5),2794792(6),2642640(7),1346345(18),2223221(19),2383381(20),2419417(21),2501499(22),2747745(23),2773771(24),2608606(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         49355306,616941,478624,Lock-Free (DWCAS 7),1615614(0),3236233(1),3015012(2),3059056(3),3199196(4),3575572(5),3610607(6),3454451(7),1591590(18),3186183(19),3011008(20),3057054(21),3151148(22),3575572(23),3614611(24),3402399(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         57665608,720820,590220,Lock-Free (DWCAS 8),1808807(0),3684681(1),3557554(2),3549546(3),3679676(4),4251247(5),4323319(6),4114110(7),1803802(18),3655652(19),3520517(20),3528525(21),3645642(22),4198194(23),4261257(24),4083079(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         64277213,803465,669543,Lock-Free (DWCAS 9),2014012(0),4175171(1),4041037(2),4033029(3),3762759(4),4705701(5),4811807(6),4616612(7),1992991(18),4177173(19),4065061(20),4007003(21),3753750(22),4753749(23),4765761(24),4601597(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         70805735,885072,731138,Lock-Free (DWCAS 10),2167165(0),4594590(1),4465461(2),4299295(3),4554550(4),5168163(5),5223218(6),4971967(7),2167165(18),4569565(19),4400396(20),4281277(21),4518514(22),5151146(23),5250245(24),5023018(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         21226205,265328,24829,PThread Mutex,1322321(0),1343342(1),1336335(2),1331330(3),1343342(4),1291290(5),1266265(6),1315314(7),1391390(18),1349348(19),1331330(20),1343342(21),1333332(22),1318317(23),1262261(24),1347346(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         16252236,203153,210348,PThread Spinlock (private),1511510(0),1358357(1),950950(2),887887(3),1073072(4),770770(5),793793(6),770770(7),1509508(18),1357356(19),948948(20),903903(21),1078077(22),768768(23),797797(24),770770(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         16088072,201101,248466,PThread Spinlock (shared),1700699(0),1277276(1),910910(2),914914(3),992992(4),774774(5),775775(6),712712(7),1699698(18),1274273(19),909909(20),913913(21),994994(22),747747(23),774774(24),712712(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     5770765,64120,51055,GCC Spinlock (atomic),313313(0),295295(1),290290(2),283283(3),281281(4),316316(5),486486(6),317317(7),300300(8),314314(18),296296(19),293293(20),282282(21),283283(22),312312(23),487487(24),319319(25),298298(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     5699694,63330,53464,GCC Spinlock (sync),305305(0),287287(1),280280(2),294294(3),273273(4),326326(5),489489(6),289289(7),310310(8),308308(18),299299(19),299299(20),275275(21),291291(22),280280(23),489489(24),325325(25),275275(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     12183171,135369,152974,Lock-Free (DWCAS 0),174174(0),759759(1),708708(2),705705(3),676676(4),742742(5),756756(6),773773(7),783783(8),177177(18),760760(19),708708(20),705705(21),680680(22),745745(23),759759(24),775775(25),786786(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     11851840,131687,123824,Lock-Free (DWCAS 1),261261(0),707707(1),659659(2),683683(3),659659(4),743743(5),752752(6),757757(7),763763(8),259259(18),693693(19),644644(20),669669(21),649649(22),726726(23),733733(24),740740(25),743743(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     12724712,141386,112676,Lock-Free (DWCAS 2),345345(0),734734(1),720720(2),713713(3),714714(4),793793(5),802802(6),795795(7),792792(8),345345(18),720720(19),708708(20),701701(21),705705(22),777777(23),786786(24),783783(25),779779(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     14470456,160783,108350,Lock-Free (DWCAS 3),451451(0),844844(1),807807(2),809809(3),839839(4),884884(5),888888(6),876876(7),874874(8),452452(18),828828(19),799799(20),802802(21),829829(22),872872(23),876876(24),865865(25),861861(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     18013996,200156,138421,Lock-Free (DWCAS 4),548548(0),1062061(1),999999(2),1019018(3),1058057(4),1099098(5),1112111(6),1066065(7),1066065(8),549549(18),1050049(19),993993(20),1014013(21),1047046(22),1092091(23),1111110(24),1063062(25),1062061(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     22303281,247814,138874,Lock-Free (DWCAS 5),790790(0),1340339(1),1235234(2),1258257(3),1300299(4),1343342(5),1351350(6),1288287(7),1258257(8),792792(18),1334333(19),1224223(20),1245244(21),1297296(22),1349348(23),1358357(24),1285284(25),1250249(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     30671641,340796,213087,Lock-Free (DWCAS 6),1022021(0),1801800(1),1676675(2),1725724(3),1762761(4),1901900(5),1912911(6),1801800(7),1768767(8),1025024(18),1782781(19),1667666(20),1707706(21),1737736(22),1886885(23),1902901(24),1810809(25),1775774(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     40771731,453019,308349,Lock-Free (DWCAS 7),1285284(0),2387385(1),2236234(2),2276274(3),2304302(4),2529527(5),2567565(6),2423421(7),2408406(8),1277276(18),2360358(19),2220218(20),2263261(21),2304302(22),2534532(23),2554552(24),2424422(25),2414412(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     49785736,553175,405865,Lock-Free (DWCAS 8),1493492(0),2865863(1),2691689(2),2732730(3),2806804(4),3116113(5),3199196(6),3021018(7),3017014(8),1497496(18),2842840(19),2679677(20),2726724(21),2778776(22),3128125(23),3186183(24),3005002(25),2996994(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     56518462,627983,486807,Lock-Free (DWCAS 9),1683682(0),3189186(1),3103100(2),3102099(3),2702700(4),3569566(5),3631628(6),3504501(7),3541538(8),1669668(18),3166163(19),3091088(20),3091088(21),3248245(22),3574571(23),3648645(24),3487484(25),3513510(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     64049986,711667,556023,Lock-Free (DWCAS 10),1825824(0),3556553(1),3497494(2),3448445(3),3591588(4),4023019(5),4140136(6),3925922(7),3985982(8),1827826(18),3654651(19),3523520(20),3447444(21),3581578(22),4046042(23),4103099(24),3911908(25),3958955(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     21210189,235669,14131,PThread Mutex,1121120(0),1179178(1),1180179(2),1174173(3),1178177(4),1186185(5),1181180(6),1186185(7),1175174(8),1168167(18),1177176(19),1169168(20),1177176(21),1175174(22),1203202(23),1189188(24),1201200(25),1188187(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     15513498,172372,161221,PThread Spinlock (private),703703(0),761761(1),1067066(2),1084083(3),1126125(4),671671(5),700700(6),641641(7),994994(8),704704(18),761761(19),1064063(20),1084083(21),1132131(22),671671(23),705705(24),641641(25),995995(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     15035020,167056,238531,PThread Spinlock (shared),724724(0),707707(1),815815(2),794794(3),658658(4),683683(5),781781(6),739739(7),1617616(8),725725(18),704704(19),813813(20),793793(21),655655(22),680680(23),780780(24),736736(25),1618617(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 1929928,19299,82466,GCC Spinlock (atomic),48048(0),49049(1),51051(2),56056(3),56056(4),58058(5),196196(6),54054(7),52052(8),340340(9),48048(18),48048(19),50050(20),54054(21),54054(22),54054(23),199199(24),57057(25),63063(26),341341(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 1786785,17868,58369,GCC Spinlock (sync),60060(0),63063(1),64064(2),59059(3),59059(4),55055(5),108108(6),73073(7),68068(8),279279(9),59059(18),63063(19),64064(20),59059(21),58058(22),60060(23),114114(24),73073(25),67067(26),280280(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 20791771,207918,2395224,Lock-Free (DWCAS 0),88088(0),139139(1),143143(2),145145(3),147147(4),163163(5),168168(6),164164(7),167167(8),9173164(9),86086(18),137137(19),143143(20),147147(21),147147(22),163163(23),166166(24),163163(25),168168(26),8971963(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 19623604,196236,2302593,Lock-Free (DWCAS 1),84084(0),119119(1),121121(2),123123(3),123123(4),141141(5),143143(6),131131(7),141141(8),9031022(9),82082(18),117117(19),120120(20),119119(21),123123(22),137137(23),138138(24),132132(25),132132(26),8364356(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 20131111,201311,2359992,Lock-Free (DWCAS 2),87087(0),123123(1),124124(2),125125(3),127127(4),142142(5),147147(6),139139(7),144144(8),9154145(9),83083(18),118118(19),120120(20),129129(21),127127(22),140140(23),141141(24),137137(25),138138(26),8683675(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 20904884,209049,2444591,Lock-Free (DWCAS 3),92092(0),128128(1),133133(2),138138(3),138138(4),146146(5),150150(6),143143(7),147147(8),9485476(9),89089(18),126126(19),131131(20),135135(21),138138(22),145145(23),148148(24),143143(25),150150(26),8996988(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 21722701,217227,2538261,Lock-Free (DWCAS 4),95095(0),134134(1),141141(2),144144(3),143143(4),154154(5),153153(6),147147(7),150150(8),9791782(9),95095(18),137137(19),136136(20),140140(21),150150(22),152152(23),152152(24),147147(25),155155(26),9403394(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 22701679,227017,2619376,Lock-Free (DWCAS 5),105105(0),172172(1),157157(2),167167(3),165165(4),170170(5),174174(6),165165(7),167167(8),10069059(9),106106(18),156156(19),154154(20),159159(21),161161(22),172172(23),173173(24),167167(25),170170(26),9769760(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 22598576,225986,2659807,Lock-Free (DWCAS 6),95095(0),148148(1),132132(2),142142(3),144144(4),154154(5),148148(6),143143(7),148148(8),10223213(9),90090(18),143143(19),137137(20),141141(21),143143(22),151151(23),147147(24),146146(25),145145(26),9875866(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 23925902,239259,2812119,Lock-Free (DWCAS 7),110110(0),148148(1),154154(2),148148(3),154154(4),155155(5),161161(6),154154(7),156156(8),10816806(9),110110(18),147147(19),146146(20),148148(21),151151(22),158158(23),153153(24),156156(25),161161(26),10436426(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 25695670,256957,3025745,Lock-Free (DWCAS 8),113113(0),157157(1),154154(2),156156(3),161161(4),169169(5),168168(6),167167(7),167167(8),11664653(9),120120(18),155155(19),151151(20),162162(21),158158(22),164164(23),171171(24),163163(25),175175(26),11197186(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 27547520,275475,3230661,Lock-Free (DWCAS 9),141141(0),183183(1),173173(2),167167(3),176176(4),189189(5),192192(6),182182(7),182182(8),12405393(9),131131(18),180180(19),166166(20),177177(21),172172(22),183183(23),178178(24),168168(25),181181(26),12018006(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 30096066,300961,3516965,Lock-Free (DWCAS 10),150150(0),209209(1),204204(2),197197(3),198198(4),196196(5),204204(6),204204(7),202202(8),13607594(9),143143(18),196196(19),195195(20),197197(21),193193(22),203203(23),205205(24),198198(25),204204(26),12986974(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 27483456,274835,89822,PThread Mutex,1326325(0),1343342(1),1355354(2),1376375(3),1366365(4),1353352(5),1264263(6),1391390(7),1279278(8),1624623(9),1359358(18),1343342(19),1361360(20),1365364(21),1378377(22),1361360(23),1270269(24),1391390(25),1291290(26),1680679(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 8738730,87387,687139,PThread Spinlock (private),155155(0),152152(1),165165(2),153153(3),151151(4),210210(5),209209(6),195195(7),220220(8),2733731(9),151151(18),155155(19),168168(20),156156(21),157157(22),216216(23),214214(24),201201(25),227227(26),2746744(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 7611604,76116,175788,PThread Spinlock (shared),292292(0),276276(1),294294(2),269269(3),268268(4),359359(5),353353(6),342342(7),346346(8),956956(9),294294(18),279279(19),292292(20),274274(21),275275(22),377377(23),370370(24),363363(25),365365(26),960960(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             1846845,16790,57817,GCC Spinlock (atomic),41041(0),38038(1),45045(2),51051(3),48048(4),49049(5),207207(6),50050(7),49049(8),177177(9),171171(10),39039(18),51051(19),43043(20),47047(21),51051(22),49049(23),199199(24),45045(25),48048(26),178178(27),169169(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             1611610,14651,40039,GCC Spinlock (sync),49049(0),49049(1),52052(2),50050(3),44044(4),47047(5),179179(6),55055(7),49049(8),115115(9),113113(10),49049(18),48048(19),51051(20),46046(21),48048(22),45045(23),186186(24),56056(25),50050(26),116116(27),113113(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             18294276,166312,1347134,Lock-Free (DWCAS 0),115115(0),130130(1),153153(2),160160(3),159159(4),168168(5),176176(6),171171(7),170170(8),4045041(9),3714711(10),114114(18),127127(19),150150(20),159159(21),162162(22),172172(23),170170(24),170170(25),169169(26),4027023(27),3709706(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             16184168,147129,1224182,Lock-Free (DWCAS 1),87087(0),105105(1),121121(2),128128(3),123123(4),135135(5),141141(6),137137(7),139139(8),3693690(9),3440437(10),82082(18),99099(19),115115(20),122122(21),121121(22),129129(23),131131(24),132132(25),132132(26),3559556(27),3309306(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             15426411,140240,1178245,Lock-Free (DWCAS 2),73073(0),91091(1),107107(2),113113(3),110110(4),127127(5),129129(6),125125(7),130130(8),3550547(9),3282279(10),73073(18),86086(19),102102(20),110110(21),111111(22),123123(23),123123(24),119119(25),122122(26),3420417(27),3197194(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             13970957,127009,1091884,Lock-Free (DWCAS 3),64064(0),80080(1),88088(2),88088(3),84084(4),99099(5),97097(6),95095(7),97097(8),3285282(9),3018015(10),61061(18),75075(19),84084(20),88088(21),88088(22),96096(23),93093(24),94094(25),95095(26),3176173(27),2923921(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             14514500,131950,1119141,Lock-Free (DWCAS 4),66066(0),89089(1),103103(2),103103(3),101101(4),111111(5),108108(6),108108(7),109109(8),3352349(9),3111108(10),62062(18),83083(19),97097(20),103103(21),103103(22),103103(23),96096(24),107107(25),111111(26),3276273(27),3010007(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             15195180,138138,1160979,Lock-Free (DWCAS 5),81081(0),107107(1),102102(2),108108(3),112112(4),117117(5),124124(6),122122(7),119119(8),3570567(9),3118115(10),80080(18),104104(19),99099(20),107107(21),110110(22),119119(23),114114(24),116116(25),119119(26),3482479(27),3062059(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             16059043,145991,1224418,Lock-Free (DWCAS 6),81081(0),113113(1),111111(2),118118(3),119119(4),125125(5),126126(6),122122(7),128128(8),3701698(9),3345342(10),81081(18),114114(19),113113(20),114114(21),121121(22),122122(23),128128(24),122122(25),123123(26),3636633(27),3292289(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             16705689,151870,1312013,Lock-Free (DWCAS 7),78078(0),104104(1),106106(2),108108(3),103103(4),104104(5),104104(6),107107(7),104104(8),3953950(9),3534531(10),82082(18),96096(19),101101(20),104104(21),97097(22),107107(23),107107(24),107107(25),103103(26),3891888(27),3501498(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             18292274,166293,1450837,Lock-Free (DWCAS 8),81081(0),100100(1),104104(2),107107(3),97097(4),105105(5),112112(6),107107(7),111111(8),4307303(9),3969966(10),76076(18),101101(19),103103(20),110110(21),103103(22),110110(23),107107(24),107107(25),114114(26),4234230(27),3923920(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             20185165,183502,1598560,Lock-Free (DWCAS 9),90090(0),121121(1),115115(2),111111(3),121121(4),122122(5),121121(6),126126(7),122122(8),4744740(9),4398394(10),86086(18),112112(19),113113(20),111111(21),115115(22),125125(23),121121(24),120120(25),117117(26),4668664(27),4302298(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             22429407,203904,1754649,Lock-Free (DWCAS 10),107107(0),140140(1),133133(2),140140(3),144144(4),151151(5),145145(6),143143(7),145145(8),5169164(9),4912908(10),108108(18),140140(19),138138(20),142142(21),136136(22),147147(23),141141(24),141141(25),145145(26),5062057(27),4796792(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             23741718,215834,95127,PThread Mutex,1016015(0),1044043(1),1039038(2),1016015(3),1019018(4),1040039(5),1013012(6),1047046(7),1026025(8),1254253(9),1318317(10),1044043(18),1049048(19),1038037(20),1020019(21),1030029(22),1055054(23),1007006(24),1039038(25),1033032(26),1287286(27),1306305(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             13221208,120193,196103,PThread Spinlock (private),447447(0),475475(1),559559(2),549549(3),499499(4),504504(5),493493(6),492492(7),470470(8),943943(9),1106105(10),521521(18),482482(19),571571(20),551551(21),502502(22),505505(23),494494(24),491491(25),471471(26),966966(27),1119118(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             12760748,116007,66635,PThread Spinlock (shared),594594(0),567567(1),579579(2),495495(3),425425(4),597597(5),615615(6),647647(7),648648(8),558558(9),655655(10),621621(18),526526(19),539539(20),477477(21),421421(22),646646(23),639639(24),631631(25),617617(26),579579(27),672672(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         1713712,14281,56381,GCC Spinlock (atomic),32032(0),35035(1),39039(2),41041(3),40040(4),40040(5),251251(6),42042(7),40040(8),106106(9),103103(10),104104(11),33033(18),34034(19),36036(20),39039(21),43043(22),36036(23),221221(24),40040(25),40040(26),106106(27),103103(28),108108(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         1467466,12229,50539,GCC Spinlock (sync),39039(0),31031(1),40040(2),40040(3),39039(4),38038(5),225225(6),46046(7),41041(8),62062(9),69069(10),57057(11),39039(18),36036(19),40040(20),39039(21),40040(22),41041(23),232232(24),46046(25),40040(26),61061(27),68068(28),57057(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         16169153,134743,924368,Lock-Free (DWCAS 0),93093(0),100100(1),118118(2),128128(3),133133(4),150150(5),152152(6),147147(7),146146(8),2422420(9),2265263(10),2242240(11),94094(18),99099(19),119119(20),127127(21),133133(22),150150(23),149149(24),147147(25),146146(26),2418416(27),2251249(28),2236234(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         14474460,120620,849806,Lock-Free (DWCAS 1),73073(0),80080(1),102102(2),105105(3),107107(4),117117(5),122122(6),119119(7),117117(8),2217215(9),2116114(10),2074072(11),71071(18),79079(19),98098(20),101101(21),102102(22),112112(23),114114(24),115115(25),114114(26),2147145(27),2050048(28),2020018(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12789777,106581,766995,Lock-Free (DWCAS 2),62062(0),67067(1),79079(2),84084(3),85085(4),86086(5),95095(6),93093(7),92092(8),1992991(9),1901900(10),1864863(11),58058(18),64064(19),77077(20),81081(21),84084(22),84084(23),92092(24),90090(25),90090(26),1931930(27),1832831(28),1800799(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12179167,101493,727436,Lock-Free (DWCAS 3),54054(0),62062(1),73073(2),81081(3),81081(4),92092(5),93093(6),91091(7),92092(8),1890889(9),1790789(10),1767766(11),53053(18),61061(19),72072(20),78078(21),79079(22),91091(23),92092(24),90090(25),89089(26),1837836(27),1744743(28),1721720(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11923912,99366,721692,Lock-Free (DWCAS 4),53053(0),61061(1),70070(2),77077(3),72072(4),76076(5),83083(6),82082(7),77077(8),1868867(9),1756755(10),1739738(11),54054(18),59059(19),70070(20),75075(21),71071(22),77077(23),81081(24),79079(25),76076(26),1825824(27),1722721(28),1715714(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11432421,95270,694099,Lock-Free (DWCAS 5),57057(0),58058(1),65065(2),70070(3),65065(4),75075(5),75075(6),77077(7),72072(8),1787786(9),1681680(10),1680679(11),53053(18),57057(19),65065(20),68068(21),66066(22),73073(23),72072(24),75075(25),73073(26),1753752(27),1652651(28),1658657(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         10811801,90098,144723,Lock-Free (DWCAS 6),351351(0),326326(1),373373(2),367367(3),364364(4),379379(5),378378(6),380380(7),387387(8),733733(9),649649(10),727727(11),350350(18),324324(19),367367(20),365365(21),363363(22),376376(23),379379(24),384384(25),375375(26),727727(27),649649(28),728728(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11542531,96188,131998,Lock-Free (DWCAS 7),326326(0),405405(1),407407(2),419419(3),402402(4),416416(5),428428(6),427427(7),428428(8),677677(9),685685(10),758758(11),324324(18),400400(19),407407(20),414414(21),403403(22),419419(23),421421(24),419419(25),423423(26),682682(27),683683(28),758758(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12854842,107124,393329,Lock-Free (DWCAS 8),326326(0),315315(1),311311(2),314314(3),316316(4),327327(5),204204(6),331331(7),301301(8),1256255(9),1220219(10),1223222(11),320320(18),316316(19),319319(20),320320(21),311311(22),323323(23),199199(24),322322(25),303303(26),1243242(27),1215214(28),1213212(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         14682668,122356,436219,Lock-Free (DWCAS 9),383383(0),357357(1),262262(2),356356(3),359359(4),381381(5),382382(6),372372(7),378378(8),1401400(9),1452451(10),1314313(11),379379(18),353353(19),262262(20),353353(21),349349(22),342342(23),382382(24),375375(25),373373(26),1388387(27),1415414(28),1306305(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         16986970,141558,426497,Lock-Free (DWCAS 10),449449(0),453453(1),471471(2),323323(3),468468(4),484484(5),498498(6),483483(7),480480(8),1478477(9),1468467(10),1454453(11),470470(18),453453(19),475475(20),323323(21),458458(22),489489(23),501501(24),471471(25),482482(26),1463462(27),1447446(28),1435434(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         25600575,213338,35625,PThread Mutex,1047046(0),1067066(1),1063062(2),1062061(3),1083082(4),1010009(5),1080079(6),1020019(7),995995(8),1103102(9),1128127(10),1114113(11),1065064(18),1068067(19),1065064(20),1065064(21),1084083(22),1020019(23),1078077(24),1022021(25),1021020(26),1116115(27),1107106(28),1115114(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         10653643,88780,756375,PThread Spinlock (private),2002(0),1001(1),1001(2),1001(3),1001(4),1001(5),1001(6),1001(7),1001(8),1992991(9),1524523(10),1881880(11),2002(18),1001(19),1001(20),1001(21),1001(22),1001(23),1001(24),1001(25),1001(26),1908907(27),1559558(28),1765764(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         9539530,79496,534286,PThread Spinlock (shared),90090(0),93093(1),89089(2),86086(3),94094(4),83083(5),79079(6),82082(7),84084(8),1649648(9),1263262(10),1210209(11),93093(18),97097(19),89089(20),87087(21),95095(22),84084(23),82082(24),84084(25),87087(26),1537536(27),1143142(28),1156155(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     2347345,18056,35970,GCC Spinlock (atomic),70070(0),75075(1),75075(2),64064(3),73073(4),58058(5),58058(6),61061(7),71071(8),138138(9),135135(10),146146(11),147147(12),72072(18),75075(19),74074(20),66066(21),73073(22),56056(23),58058(24),60060(25),70070(26),138138(27),130130(28),149149(29),153153(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     2838836,21837,167260,GCC Spinlock (sync),6006(0),6006(1),6006(2),7007(3),6006(4),6006(5),6006(6),6006(7),6006(8),202202(9),440440(10),310310(11),388388(12),6006(18),6006(19),6006(20),6006(21),7007(22),6006(23),6006(24),6006(25),6006(26),200200(27),492492(28),310310(29),384384(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     12970958,99777,220910,Lock-Free (DWCAS 0),337337(0),346346(1),356356(2),358358(3),351351(4),360360(5),363363(6),362362(7),362362(8),808808(9),808808(10),838838(11),832832(12),338338(18),347347(19),355355(20),355355(21),351351(22),357357(23),360360(24),358358(25),361361(26),809809(27),808808(28),839839(29),839839(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     13344331,102649,223086,Lock-Free (DWCAS 1),387387(0),394394(1),383383(2),386386(3),380380(4),370370(5),339339(6),372372(7),357357(8),852852(9),870870(10),842842(11),847847(12),374374(18),380380(19),370370(20),371371(21),371371(22),358358(23),326326(24),356356(25),341341(26),819819(27),841841(28),819819(29),826826(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     12468456,95911,539779,Lock-Free (DWCAS 2),111111(0),109109(1),123123(2),129129(3),127127(4),137137(5),138138(6),140140(7),137137(8),1267266(9),1269268(10),1313312(11),1312311(12),110110(18),110110(19),121121(20),125125(21),126126(22),136136(23),133133(24),135135(25),135135(26),1236235(27),1226225(28),1279278(29),1280279(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     11893882,91491,592134,Lock-Free (DWCAS 3),72072(0),76076(1),77077(2),81081(3),74074(4),70070(5),48048(6),70070(7),69069(8),1329328(9),1369368(10),1331330(11),1345344(12),72072(18),74074(19),77077(20),78078(21),74074(22),67067(23),50050(24),68068(25),71071(26),1292291(27),1354353(28),1298297(29),1304303(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10602592,81558,27475,Lock-Free (DWCAS 4),436436(0),442442(1),446446(2),440440(3),435435(4),397397(5),389389(6),396396(7),386386(8),403403(9),411411(10),349349(11),413413(12),430430(18),432432(19),428428(20),437437(21),427427(22),386386(23),378378(24),391391(25),380380(26),399399(27),405405(28),346346(29),410410(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     12005994,92354,599187,Lock-Free (DWCAS 5),70070(0),76076(1),77077(2),77077(3),76076(4),70070(5),53053(6),67067(7),66066(8),1344343(9),1388387(10),1337336(11),1348347(12),71071(18),71071(19),73073(20),78078(21),75075(22),70070(23),52052(24),70070(25),70070(26),1323322(27),1364363(28),1312311(29),1324323(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     12511499,96242,622939,Lock-Free (DWCAS 6),76076(0),78078(1),80080(2),84084(3),81081(4),73073(5),56056(6),73073(7),71071(8),1219218(9),1459458(10),1402401(11),1425424(12),75075(18),80080(19),81081(20),83083(21),79079(22),76076(23),56056(24),72072(25),72072(26),1444443(27),1435434(28),1381380(29),1396395(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     11549538,88843,574519,Lock-Free (DWCAS 7),68068(0),72072(1),75075(2),75075(3),73073(4),70070(5),52052(6),68068(7),70070(8),1288287(9),1330329(10),1274273(11),1284283(12),69069(18),72072(19),71071(20),76076(21),71071(22),70070(23),51051(24),67067(25),66066(26),1273272(27),1314313(28),1264263(29),1283282(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     11448437,88065,253656,Lock-Free (DWCAS 8),281281(0),277277(1),280280(2),226226(3),277277(4),292292(5),286286(6),282282(7),275275(8),836836(9),808808(10),811811(11),800800(12),274274(18),273273(19),282282(20),231231(21),274274(22),289289(23),282282(24),284284(25),277277(26),822822(27),814814(28),804804(29),800800(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     11902891,91561,615131,Lock-Free (DWCAS 9),56056(0),57057(1),55055(2),58058(3),57057(4),60060(5),59059(6),46046(7),57057(8),1385384(9),1360359(10),1363362(11),1378377(12),57057(18),55055(19),56056(20),59059(21),56056(22),53053(23),57057(24),48048(25),56056(26),1372371(27),1344343(28),1339338(29),1356355(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     12842830,98791,628150,Lock-Free (DWCAS 10),83083(0),81081(1),82082(2),81081(3),89089(4),83083(5),88088(6),73073(7),89089(8),1446445(9),1416415(10),1400399(11),1447446(12),80080(18),84084(19),83083(20),87087(21),86086(22),84084(23),91091(24),75075(25),81081(26),1429428(27),1401400(28),1375374(29),1424423(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     23051028,177316,46934,PThread Mutex,861861(0),869869(1),869869(2),865865(3),874874(4),829829(5),863863(6),859859(7),807807(8),942942(9),948948(10),945945(11),967967(12),877877(18),866866(19),872872(20),874874(21),869869(22),829829(23),865865(24),862862(25),821821(26),950950(27),943943(28),953953(29),949949(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     9567558,73597,253797,PThread Spinlock (private),166166(0),178178(1),172172(2),180180(3),213213(4),198198(5),241241(6),247247(7),245245(8),754754(9),857857(10),638638(11),643643(12),169169(18),181181(19),174174(20),184184(21),216216(22),202202(23),245245(24),252252(25),249249(26),768768(27),873873(28),653653(29),660660(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     9738729,74913,220508,PThread Spinlock (shared),187187(0),197197(1),199199(2),213213(3),241241(4),228228(5),276276(6),280280(7),284284(8),662662(9),745745(10),627627(11),614614(12),187187(18),198198(19),199199(20),207207(21),242242(22),228228(23),276276(24),281281(25),286286(26),730730(27),829829(28),659659(29),654654(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 1984983,14178,35944,GCC Spinlock (atomic),42042(0),41041(1),43043(2),45045(3),77077(4),49049(5),42042(6),46046(7),40040(8),98098(9),101101(10),140140(11),122122(12),93093(13),42042(18),42042(19),41041(20),43043(21),87087(22),49049(23),42042(24),46046(25),50050(26),98098(27),98098(28),145145(29),127127(30),94094(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 1909908,13642,43828,GCC Spinlock (sync),32032(0),36036(1),34034(2),31031(3),32032(4),34034(5),97097(6),35035(7),32032(8),102102(9),107107(10),113113(11),135135(12),132132(13),32032(18),36036(19),34034(20),31031(21),32032(22),34034(23),100100(24),35035(25),32032(26),101101(27),108108(28),114114(29),130130(30),137137(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 15684669,112033,597560,Lock-Free (DWCAS 0),137137(0),136136(1),130130(2),139139(3),104104(4),153153(5),155155(6),150150(7),153153(8),1304303(9),1320319(10),1348347(11),1306305(12),1315314(13),137137(18),134134(19),131131(20),139139(21),103103(22),151151(23),155155(24),151151(25),150150(26),1297296(27),1324323(28),1346345(29),1303302(30),1308307(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 11559548,82568,470811,Lock-Free (DWCAS 1),77077(0),78078(1),75075(2),85085(3),55055(4),92092(5),94094(6),94094(7),94094(8),1002001(9),1033032(10),1047046(11),1020019(12),1020019(13),73073(18),75075(19),72072(20),79079(21),54054(22),90090(23),94094(24),92092(25),92092(26),971971(27),1002001(28),1017016(29),990990(30),988988(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10186176,72758,31227,Lock-Free (DWCAS 2),346346(0),340340(1),344344(2),347347(3),341341(4),346346(5),355355(6),357357(7),355355(8),388388(9),374374(10),414414(11),422422(12),419419(13),333333(18),328328(19),339339(20),337337(21),340340(22),339339(23),345345(24),350350(25),349349(26),378378(27),361361(28),405405(29),416416(30),408408(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10727717,76627,95424,Lock-Free (DWCAS 3),318318(0),315315(1),318318(2),308308(3),314314(4),327327(5),325325(6),324324(7),324324(8),508508(9),499499(10),497497(11),504504(12),523523(13),311311(18),308308(19),308308(20),304304(21),309309(22),322322(23),319319(24),315315(25),317317(26),503503(27),488488(28),488488(29),506506(30),515515(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10893883,77813,81935,Lock-Free (DWCAS 4),329329(0),331331(1),342342(2),342342(3),341341(4),338338(5),315315(6),343343(7),323323(8),487487(9),486486(10),493493(11),515515(12),492492(13),335335(18),331331(19),339339(20),339339(21),339339(22),330330(23),306306(24),333333(25),313313(26),477477(27),479479(28),488488(29),510510(30),487487(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 8626618,61619,32847,Lock-Free (DWCAS 5),344344(0),347347(1),343343(2),345345(3),345345(4),315315(5),310310(6),302302(7),308308(8),261261(9),267267(10),271271(11),272272(12),280280(13),339339(18),341341(19),341341(20),350350(21),341341(22),312312(23),308308(24),313313(25),303303(26),265265(27),268268(28),269269(29),280280(30),278278(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 8782774,62734,263191,Lock-Free (DWCAS 6),137137(0),135135(1),137137(2),137137(3),132132(4),124124(5),117117(6),119119(7),120120(8),661661(9),672672(10),631631(11),633633(12),648648(13),132132(18),137137(19),133133(20),134134(21),132132(22),126126(23),119119(24),120120(25),119119(26),652652(27),659659(28),629629(29),643643(30),636636(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10130120,72358,164199,Lock-Free (DWCAS 7),261261(0),266266(1),267267(2),247247(3),256256(4),219219(5),226226(6),231231(7),239239(8),577577(9),584584(10),563563(11),572572(12),549549(13),263263(18),266266(19),266266(20),247247(21),258258(22),223223(23),228228(24),230230(25),243243(26),573573(27),585585(28),562562(29),569569(30),550550(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9779770,69856,364996,Lock-Free (DWCAS 8),89089(0),87087(1),82082(2),88088(3),91091(4),97097(5),102102(6),97097(7),98098(8),851851(9),838838(10),778778(11),814814(12),782782(13),92092(18),86086(19),81081(20),89089(21),91091(22),98098(23),102102(24),97097(25),98098(26),845845(27),834834(28),778778(29),819819(30),766766(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10471461,74796,417275,Lock-Free (DWCAS 9),78078(0),76076(1),69069(2),74074(3),75075(4),97097(5),92092(6),88088(7),83083(8),776776(9),978978(10),924924(11),952952(12),899899(13),79079(18),76076(19),69069(20),78078(21),77077(22),91091(23),93093(24),90090(25),86086(26),765765(27),966966(28),909909(29),938938(30),883883(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 11129118,79494,447197,Lock-Free (DWCAS 10),83083(0),84084(1),76076(2),82082(3),77077(4),89089(5),87087(6),85085(7),83083(8),1004003(9),998998(10),932932(11),977977(12),930930(13),80080(18),80080(19),77077(20),84084(21),76076(22),84084(23),86086(24),89089(25),88088(26),998998(27),989989(28),923923(29),962962(30),916916(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 23673650,169098,28386,PThread Mutex,841841(0),854854(1),853853(2),860860(3),861861(4),786786(5),808808(6),903903(7),802802(8),844844(9),840840(10),849849(11),843843(12),858858(13),866866(18),856856(19),853853(20),853853(21),855855(22),825825(23),803803(24),911911(25),806806(26),833833(27),842842(28),859859(29),843843(30),843843(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9510501,67932,131940,PThread Spinlock (private),232232(0),224224(1),254254(2),245245(3),236236(4),279279(5),278278(6),276276(7),273273(8),576576(9),422422(10),566566(11),515515(12),331331(13),233233(18),227227(19),257257(20),251251(21),239239(22),285285(23),283283(24),284284(25),276276(26),586586(27),434434(28),576576(29),524524(30),339339(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 8575567,61254,137060,PThread Spinlock (shared),185185(0),174174(1),189189(2),184184(3),178178(4),251251(5),250250(6),247247(7),248248(8),570570(9),426426(10),463463(11),456456(12),421421(13),186186(18),177177(19),192192(20),188188(21),180180(22),263263(23),261261(24),259259(25),260260(26),575575(27),430430(28),468468(29),461461(30),425425(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             1447446,9650,20981,GCC Spinlock (atomic),66066(0),61061(1),77077(2),65065(3),67067(4),65065(5),79079(6),48048(7),52052(8),27027(9),30030(10),24024(11),23023(12),27027(13),27027(14),65065(18),59059(19),76076(20),65065(21),66066(22),65065(23),53053(24),48048(25),51051(26),27027(27),30030(28),26026(29),23023(30),27027(31),27027(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             1603602,10691,14716,GCC Spinlock (sync),83083(0),72072(1),47047(2),69069(3),76076(4),47047(5),49049(6),53053(7),43043(8),45045(9),46046(10),44044(11),44044(12),43043(13),44044(14),82082(18),72072(19),47047(20),69069(21),76076(22),46046(23),49049(24),50050(25),41041(26),45045(27),46046(28),43043(29),45045(30),43043(31),43043(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             12039027,80260,372195,Lock-Free (DWCAS 0),123123(0),107107(1),111111(2),119119(3),123123(4),133133(5),137137(6),131131(7),135135(8),827827(9),808808(10),798798(11),809809(12),831831(13),832832(14),123123(18),108108(19),111111(20),117117(21),124124(22),131131(23),135135(24),131131(25),131131(26),809809(27),810810(28),803803(29),814814(30),828828(31),828828(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             10090080,67267,45945,Lock-Free (DWCAS 1),289289(0),297297(1),308308(2),309309(3),305305(4),311311(5),314314(6),316316(7),318318(8),377377(9),376376(10),403403(11),394394(12),397397(13),400400(14),283283(18),286286(19),298298(20),297297(21),298298(22),303303(23),303303(24),308308(25),309309(26),365365(27),368368(28),388388(29),386386(30),387387(31),387387(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             11019008,73460,61112,Lock-Free (DWCAS 2),317317(0),322322(1),324324(2),323323(3),323323(4),333333(5),334334(6),332332(7),333333(8),438438(9),437437(10),446446(11),435435(12),439439(13),455455(14),312312(18),312312(19),312312(20),312312(21),314314(22),324324(23),322322(24),323323(25),323323(26),423423(27),420420(28),430430(29),430430(30),423423(31),437437(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             10037027,66914,48976,Lock-Free (DWCAS 3),311311(0),312312(1),304304(2),303303(3),302302(4),304304(5),286286(6),305305(7),289289(8),393393(9),398398(10),391391(11),393393(12),388388(13),386386(14),307307(18),304304(19),298298(20),298298(21),298298(22),292292(23),280280(24),296296(25),281281(26),385385(27),393393(28),383383(29),385385(30),382382(31),380380(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             9074065,60494,62597,Lock-Free (DWCAS 4),262262(0),264264(1),261261(2),252252(3),253253(4),258258(5),258258(6),262262(7),258258(8),382382(9),385385(10),377377(11),371371(12),377377(13),355355(14),258258(18),261261(19),255255(20),245245(21),247247(22),253253(23),252252(24),257257(25),251251(26),371371(27),375375(28),376376(29),372372(30),367367(31),350350(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             8551543,57010,88644,Lock-Free (DWCAS 5),222222(0),224224(1),229229(2),226226(3),235235(4),216216(5),204204(6),213213(7),203203(8),389389(9),369369(10),391391(11),393393(12),387387(13),363363(14),235235(18),232232(19),231231(20),230230(21),229229(22),211211(23),199199(24),210210(25),202202(26),387387(27),397397(28),384384(29),392392(30),383383(31),357357(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             8531523,56877,65031,Lock-Free (DWCAS 6),228228(0),229229(1),234234(2),236236(3),229229(4),239239(5),247247(6),249249(7),246246(8),337337(9),349349(10),363363(11),361361(12),360360(13),369369(14),224224(18),228228(19),234234(20),227227(21),228228(22),242242(23),244244(24),244244(25),244244(26),339339(27),347347(28),360360(29),362362(30),357357(31),367367(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             9063054,60420,283183,Lock-Free (DWCAS 7),73073(0),79079(1),87087(2),92092(3),92092(4),100100(5),102102(6),99099(7),100100(8),597597(9),620620(10),624624(11),633633(12),623623(13),627627(14),73073(18),79079(19),88088(20),89089(21),93093(22),96096(23),100100(24),100100(25),98098(26),591591(27),617617(28),617617(29),631631(30),615615(31),619619(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             8663655,57758,48533,Lock-Free (DWCAS 8),343343(0),337337(1),332332(2),329329(3),332332(4),309309(5),305305(6),310310(7),288288(8),239239(9),239239(10),241241(11),239239(12),250250(13),219219(14),349349(18),351351(19),340340(20),333333(21),341341(22),305305(23),303303(24),305305(25),283283(26),239239(27),241241(28),244244(29),243243(30),245245(31),221221(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             9646637,64311,245773,Lock-Free (DWCAS 9),137137(0),132132(1),125125(2),138138(3),124124(4),151151(5),151151(6),150150(7),147147(8),621621(9),608608(10),589589(11),601601(12),581581(13),593593(14),131131(18),130130(19),124124(20),130130(21),123123(22),148148(23),152152(24),151151(25),149149(26),614614(27),605605(28),581581(29),589589(30),573573(31),589589(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             10572562,70484,55696,Lock-Free (DWCAS 10),325325(0),330330(1),320320(2),319319(3),317317(4),320320(5),330330(6),249249(7),331331(8),421421(9),410410(10),396396(11),412412(12),398398(13),418418(14),329329(18),322322(19),319319(20),314314(21),322322(22),309309(23),326326(24),240240(25),333333(26),423423(27),411411(28),391391(29),409409(30),403403(31),415415(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             24303279,162022,19870,PThread Mutex,829829(0),823823(1),821821(2),827827(3),830830(4),818818(5),819819(6),827827(7),814814(8),787787(9),781781(10),794794(11),803803(12),793793(13),784784(14),838838(18),817817(19),789789(20),835835(21),826826(22),821821(23),802802(24),832832(25),821821(26),790790(27),779779(28),793793(29),802802(30),800800(31),784784(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             10582572,70550,204598,PThread Spinlock (private),698698(0),734734(1),410410(2),540540(3),496496(4),390390(5),351351(6),364364(7),423423(8),162162(9),148148(10),176176(11),183183(12),126126(13),158158(14),630630(18),717717(19),408408(20),521521(21),496496(22),370370(23),347347(24),353353(25),404404(26),165165(27),151151(28),179179(29),185185(30),126126(31),161161(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1             10281271,68542,437142,PThread Spinlock (shared),1236235(0),1281280(1),313313(2),538538(3),484484(4),310310(5),244244(6),237237(7),397397(8),9009(9),11011(10),12012(11),12012(12),12012(13),14014(14),1236235(18),1242241(19),324324(20),566566(21),495495(22),323323(23),270270(24),246246(25),393393(26),9009(27),11011(28),12012(29),12012(30),12012(31),14014(32)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         1630629,10191,9022,GCC Spinlock (atomic),48048(0),55055(1),58058(2),55055(3),57057(4),62062(5),64064(6),57057(7),54054(8),51051(9),43043(10),39039(11),41041(12),43043(13),42042(14),43043(15),48048(18),52052(19),56056(20),57057(21),56056(22),63063(23),65065(24),57057(25),60060(26),51051(27),44044(28),39039(29),42042(30),42042(31),42042(32),43043(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         1479478,9247,17373,GCC Spinlock (sync),55055(0),57057(1),62062(2),63063(3),62062(4),67067(5),56056(6),53053(7),63063(8),31031(9),29029(10),27027(11),28028(12),28028(13),30030(14),31031(15),54054(18),57057(19),63063(20),61061(21),62062(22),65065(23),55055(24),53053(25),61061(26),32032(27),29029(28),27027(29),28028(30),28028(31),30030(32),31031(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         12001990,75012,198576,Lock-Free (DWCAS 0),543543(0),539539(1),539539(2),535535(3),531531(4),505505(5),532532(6),513513(7),528528(8),190190(9),190190(10),193193(11),193193(12),195195(13),111111(14),175175(15),541541(18),537537(19),533533(20),538538(21),529529(22),504504(23),524524(24),511511(25),526526(26),190190(27),191191(28),192192(29),191191(30),191191(31),107107(32),173173(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         12338326,77115,26290,Lock-Free (DWCAS 1),391391(0),392392(1),395395(2),390390(3),387387(4),358358(5),363363(6),364364(7),382382(8),415415(9),420420(10),422422(11),422422(12),425425(13),359359(14),388388(15),377377(18),382382(19),380380(20),378378(21),375375(22),348348(23),351351(24),351351(25),362362(26),399399(27),408408(28),410410(29),411411(30),400400(31),348348(32),373373(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         12023011,75144,360237,Lock-Free (DWCAS 2),104104(0),106106(1),103103(2),109109(3),107107(4),96096(5),64064(6),91091(7),94094(8),771771(9),779779(10),764764(11),763763(12),750750(13),729729(14),685685(15),100100(18),100100(19),99099(20),106106(21),104104(22),92092(23),63063(24),89089(25),93093(26),740740(27),748748(28),738738(29),737737(30),725725(31),695695(32),667667(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         10414404,65090,175265,Lock-Free (DWCAS 3),472472(0),472472(1),475475(2),478478(3),473473(4),457457(5),443443(6),467467(7),449449(8),157157(9),159159(10),158158(11),158158(12),160160(13),136136(14),127127(15),468468(18),471471(19),472472(20),468468(21),463463(22),443443(23),433433(24),455455(25),441441(26),157157(27),155155(28),160160(29),161161(30),158158(31),131131(32),127127(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         8941933,55887,253992,Lock-Free (DWCAS 4),94094(0),90090(1),90090(2),92092(3),91091(4),68068(5),74074(6),77077(7),70070(8),559559(9),528528(10),557557(11),550550(12),546546(13),484484(14),517517(15),94094(18),91091(19),86086(20),91091(21),89089(22),65065(23),75075(24),72072(25),69069(26),549549(27),563563(28),548548(29),544544(30),533533(31),474474(32),503503(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         9467458,59172,172068,Lock-Free (DWCAS 5),461461(0),470470(1),455455(2),451451(3),450450(4),412412(5),385385(6),421421(7),390390(8),131131(9),132132(10),131131(11),134134(12),135135(13),127127(14),96096(15),451451(18),455455(19),448448(20),445445(21),439439(22),402402(23),372372(24),411411(25),383383(26),131131(27),132132(28),131131(29),135135(30),132132(31),117117(32),93093(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         7412405,46328,39239,Lock-Free (DWCAS 6),195195(0),191191(1),203203(2),206206(3),205205(4),205205(5),204204(6),205205(7),204204(8),274274(9),270270(10),276276(11),277277(12),280280(13),264264(14),258258(15),194194(18),193193(19),207207(20),204204(21),203203(22),203203(23),200200(24),201201(25),200200(26),270270(27),267267(28),276276(29),278278(30),271271(31),261261(32),260260(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         8195187,51220,90698,Lock-Free (DWCAS 7),341341(0),336336(1),310310(2),320320(3),322322(4),328328(5),329329(6),329329(7),328328(8),170170(9),158158(10),150150(11),165165(12),165165(13),175175(14),174174(15),343343(18),331331(19),314314(20),318318(21),316316(22),328328(23),321321(24),329329(25),327327(26),171171(27),162162(28),152152(29),167167(30),165165(31),172172(32),171171(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         7977970,49862,40402,Lock-Free (DWCAS 8),243243(0),210210(1),239239(2),239239(3),231231(4),217217(5),207207(6),223223(7),217217(8),299299(9),311311(10),304304(11),306306(12),237237(13),270270(14),256256(15),245245(18),204204(19),235235(20),243243(21),231231(22),213213(23),199199(24),217217(25),206206(26),298298(27),301301(28),306306(29),303303(30),241241(31),266266(32),253253(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         8452444,52828,206572,Lock-Free (DWCAS 9),91091(0),96096(1),102102(2),106106(3),102102(4),109109(5),112112(6),108108(7),107107(8),467467(9),465465(10),475475(11),466466(12),470470(13),474474(14),488488(15),92092(18),91091(19),99099(20),105105(21),102102(22),109109(23),108108(24),108108(25),109109(26),465465(27),461461(28),469469(29),469469(30),470470(31),474474(32),475475(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         8610602,53816,226443,Lock-Free (DWCAS 10),91091(0),88088(1),92092(2),92092(3),92092(4),98098(5),95095(6),95095(7),97097(8),487487(9),494494(10),499499(11),493493(12),499499(13),506506(14),509509(15),86086(18),88088(19),90090(20),88088(21),89089(22),95095(23),99099(24),95095(25),96096(26),487487(27),483483(28),497497(29),485485(30),492492(31),496496(32),509509(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         23068045,144175,46288,PThread Mutex,680680(0),686686(1),685685(2),682682(3),719719(4),685685(5),687687(6),687687(7),670670(8),738738(9),760760(10),768768(11),765765(12),769769(13),766766(14),773773(15),688688(18),679679(19),673673(20),680680(21),717717(22),686686(23),677677(24),685685(25),673673(26),769769(27),765765(28),772772(29),761761(30),777777(31),768768(32),755755(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         10921911,68262,142594,PThread Spinlock (private),469469(0),450450(1),463463(2),437437(3),421421(4),442442(5),443443(6),444444(7),441441(8),200200(9),178178(10),163163(11),166166(12),172172(13),248248(14),250250(15),477477(18),458458(19),472472(20),447447(21),429429(22),453453(23),451451(24),453453(25),447447(26),199199(27),182182(28),167167(29),206206(30),177177(31),254254(32),252252(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1         10119109,63244,34303,PThread Spinlock (shared),353353(0),339339(1),360360(2),346346(3),316316(4),333333(5),336336(6),327327(7),327327(8),283283(9),264264(10),275275(11),287287(12),270270(13),306306(14),308308(15),356356(18),341341(19),364364(20),350350(21),318318(22),337337(23),342342(24),329329(25),332332(26),285285(27),266266(28),277277(29),289289(30),270270(31),311311(32),312312(33)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     1560559,9180,16094,GCC Spinlock (atomic),56056(0),60060(1),62062(2),73073(3),71071(4),48048(5),47047(6),48048(7),45045(8),33033(9),32032(10),34034(11),32032(12),32032(13),35035(14),37037(15),34034(16),64064(18),57057(19),62062(20),69069(21),73073(22),47047(23),47047(24),48048(25),47047(26),33033(27),33033(28),34034(29),33033(30),31031(31),35035(32),37037(33),30030(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     1464463,8614,46857,GCC Spinlock (sync),6006(0),6006(1),5005(2),6006(3),6006(4),6006(5),6006(6),5005(7),6006(8),83083(9),65065(10),93093(11),91091(12),92092(13),71071(14),93093(15),90090(16),6006(18),6006(19),6006(20),6006(21),6006(22),5005(23),6006(24),6006(25),6006(26),85085(27),62062(28),94094(29),89089(30),94094(31),71071(32),94094(33),91091(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     11964953,70382,16536,Lock-Free (DWCAS 0),367367(0),372372(1),370370(2),369369(3),367367(4),360360(5),355355(6),359359(7),354354(8),342342(9),341341(10),346346(11),346346(12),346346(13),331331(14),332332(15),329329(16),367367(18),371371(19),367367(20),371371(21),369369(22),359359(23),350350(24),359359(25),352352(26),339339(27),339339(28),346346(29),347347(30),341341(31),329329(32),332332(33),329329(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     10644634,62615,188396,Lock-Free (DWCAS 1),467467(0),468468(1),471471(2),461461(3),457457(4),483483(5),481481(6),482482(7),477477(8),135135(9),135135(10),139139(11),141141(12),142142(13),155155(14),153153(15),150150(16),454454(18),454454(19),454454(20),449449(21),449449(22),465465(23),461461(24),468468(25),463463(26),132132(27),131131(28),137137(29),135135(30),138138(31),148148(32),151151(33),148148(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     10988978,64641,251831,Lock-Free (DWCAS 2),118118(0),110110(1),109109(2),113113(3),117117(4),133133(5),132132(6),129129(7),128128(8),568568(9),559559(10),547547(11),561561(12),561561(13),561561(14),562562(15),553553(16),115115(18),109109(19),107107(20),113113(21),115115(22),129129(23),130130(24),122122(25),125125(26),550550(27),542542(28),534534(29),546546(30),547547(31),544544(32),549549(33),540540(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     10013003,58900,171098,Lock-Free (DWCAS 3),448448(0),452452(1),448448(2),451451(3),446446(4),425425(5),420420(6),427427(7),414414(8),141141(9),141141(10),144144(11),147147(12),153153(13),138138(14),136136(15),130130(16),438438(18),439439(19),438438(20),439439(21),441441(22),416416(23),408408(24),417417(25),408408(26),139139(27),140140(28),142142(29),147147(30),144144(31),129129(32),132132(33),125125(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     9145136,53795,233237,Lock-Free (DWCAS 4),87087(0),80080(1),79079(2),84084(3),88088(4),82082(5),85085(6),76076(7),65065(8),505505(9),504504(10),499499(11),501501(12),507507(13),455455(14),451451(15),455455(16),88088(18),81081(19),82082(20),89089(21),87087(22),83083(23),81081(24),75075(25),67067(26),494494(27),495495(28),489489(29),498498(30),491491(31),448448(32),441441(33),444444(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     8822814,51899,167438,Lock-Free (DWCAS 5),419419(0),415415(1),405405(2),400400(3),410410(4),365365(5),374374(6),365365(7),379379(8),111111(9),106106(10),111111(11),113113(12),122122(13),109109(14),109109(15),89089(16),428428(18),426426(19),410410(20),403403(21),407407(22),366366(23),374374(24),362362(25),374374(26),114114(27),105105(28),110110(29),118118(30),120120(31),104104(32),106106(33),85085(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     7415408,43620,115652,Lock-Free (DWCAS 6),300300(0),308308(1),314314(2),320320(3),311311(4),299299(5),308308(6),321321(7),328328(8),93093(9),101101(10),111111(11),118118(12),115115(13),128128(14),127127(15),118118(16),296296(18),302302(19),310310(20),310310(21),310310(22),304304(23),305305(24),320320(25),328328(26),90090(27),99099(28),116116(29),117117(30),111111(31),125125(32),125125(33),120120(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     7442435,43779,7365,Lock-Free (DWCAS 7),221221(0),217217(1),215215(2),208208(3),214214(4),226226(5),225225(6),225225(7),222222(8),225225(9),219219(10),216216(11),216216(12),224224(13),219219(14),209209(15),208208(16),225225(18),226226(19),220220(20),214214(21),218218(22),226226(23),207207(24),221221(25),217217(26),225225(27),224224(28),222222(29),221221(30),227227(31),210210(32),219219(33),204204(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     7692685,45251,108243,Lock-Free (DWCAS 8),316316(0),318318(1),313313(2),310310(3),293293(4),314314(5),319319(6),318318(7),324324(8),126126(9),127127(10),123123(11),123123(12),114114(13),137137(14),139139(15),138138(16),309309(18),317317(19),315315(20),309309(21),294294(22),310310(23),316316(24),319319(25),322322(26),127127(27),131131(28),128128(29),128128(30),108108(31),128128(32),134134(33),138138(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     8977969,52812,170305,Lock-Free (DWCAS 9),445445(0),453453(1),434434(2),382382(3),383383(4),395395(5),353353(6),398398(7),370370(8),114114(9),116116(10),115115(11),118118(12),121121(13),114114(14),92092(15),106106(16),436436(18),442442(19),425425(20),373373(21),389389(22),394394(23),352352(24),398398(25),370370(26),114114(27),112112(28),119119(29),121121(30),108108(31),109109(32),93093(33),105105(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     8594586,50556,192362,Lock-Free (DWCAS 10),90090(0),96096(1),96096(2),96096(3),96096(4),102102(5),100100(6),102102(7),102102(8),431431(9),433433(10),428428(11),399399(12),423423(13),440440(14),434434(15),435435(16),87087(18),96096(19),94094(20),93093(21),97097(22),102102(23),102102(24),103103(25),99099(26),432432(27),427427(28),429429(29),402402(30),412412(31),436436(32),437437(33),435435(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     25397372,149396,23624,PThread Mutex,729729(0),734734(1),766766(2),725725(3),733733(4),718718(5),728728(6),730730(7),722722(8),757757(9),759759(10),796796(11),748748(12),759759(13),753753(14),764764(15),758758(16),729729(18),729729(19),756756(20),736736(21),733733(22),732732(23),716716(24),731731(25),720720(26),760760(27),766766(28),797797(29),764764(30),763763(31),750750(32),748748(33),763763(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     10743733,63198,426505,PThread Spinlock (private),2002(0),3003(1),2002(2),3003(3),2002(4),2002(5),2002(6),2002(7),2002(8),1063062(9),902902(10),707707(11),413413(12),355355(13),705705(14),792792(15),763763(16),2002(18),3003(19),2002(20),3003(21),2002(22),2002(23),2002(24),2002(25),2002(26),954954(27),850850(28),580580(29),328328(30),299299(31),715715(32),610610(33),658658(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1     10727717,63104,467287,PThread Spinlock (shared),2002(0),3003(1),2002(2),3003(3),3003(4),2002(5),3003(6),2002(7),2002(8),1077076(9),812812(10),12012(11),315315(12),245245(13),802802(14),804804(15),930930(16),3003(18),3003(19),3003(20),3003(21),3003(22),2002(23),3003(24),2002(25),2002(26),1144143(27),792792(28),707707(29),292292(30),215215(31),850850(32),800800(33),876876(34)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1531530,8508,16889,GCC Spinlock (atomic),51051(0),52052(1),59059(2),40040(3),42042(4),38038(5),39039(6),40040(7),39039(8),33033(9),35035(10),36036(11),35035(12),35035(13),39039(14),35035(15),33033(16),108108(17),50050(18),49049(19),42042(20),44044(21),43043(22),38038(23),36036(24),45045(25),38038(26),32032(27),33033(28),37037(29),37037(30),37037(31),35035(32),33033(33),35035(34),77077(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1380379,7669,29273,GCC Spinlock (sync),15015(0),14014(1),17017(2),16016(3),14014(4),15015(5),16016(6),17017(7),17017(8),72072(9),58058(10),80080(11),60060(12),80080(13),45045(14),57057(15),44044(16),57057(17),15015(18),14014(19),17017(20),16016(21),14014(22),16016(23),16016(24),16016(25),17017(26),72072(27),60060(28),81081(29),54054(30),78078(31),44044(32),55055(33),45045(34),55055(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 11706695,65037,34181,Lock-Free (DWCAS 0),349349(0),344344(1),352352(2),352352(3),351351(4),356356(5),356356(6),348348(7),357357(8),298298(9),292292(10),298298(11),298298(12),299299(13),294294(14),299299(15),292292(16),300300(17),358358(18),357357(19),356356(20),357357(21),350350(22),356356(23),354354(24),347347(25),356356(26),297297(27),298298(28),296296(29),298298(30),297297(31),293293(32),299299(33),292292(34),299299(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 12266254,68146,172554,Lock-Free (DWCAS 1),475475(0),467467(1),464464(2),505505(3),504504(4),494494(5),469469(6),497497(7),468468(8),209209(9),207207(10),208208(11),207207(12),209209(13),202202(14),171171(15),195195(16),195195(17),510510(18),510510(19),503503(20),484484(21),486486(22),477477(23),452452(24),477477(25),456456(26),201201(27),203203(28),203203(29),204204(30),201201(31),193193(32),167167(33),190190(34),191191(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 9344335,51913,212953,Lock-Free (DWCAS 2),380380(0),383383(1),380380(2),376376(3),421421(4),458458(5),463463(6),466466(7),458458(8),81081(9),78078(10),74074(11),80080(12),67067(13),94094(14),97097(15),95095(16),94094(17),456456(18),454454(19),457457(20),452452(21),431431(22),448448(23),444444(24),453453(25),451451(26),79079(27),80080(28),75075(29),77077(30),63063(31),92092(32),93093(33),92092(34),93093(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 9497488,52764,188087,Lock-Free (DWCAS 3),96096(0),83083(1),100100(2),105105(3),112112(4),123123(5),121121(6),116116(7),112112(8),416416(9),410410(10),426426(11),422422(12),425425(13),432432(14),431431(15),426426(16),426426(17),100100(18),81081(19),103103(20),109109(21),115115(22),121121(23),116116(24),109109(25),109109(26),410410(27),404404(28),411411(29),418418(30),418418(31),418418(32),422422(33),417417(34),425425(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 8107099,45039,168198,Lock-Free (DWCAS 4),251251(0),385385(1),388388(2),389389(3),384384(4),353353(5),357357(6),348348(7),359359(8),90090(9),91091(10),90090(11),94094(12),101101(13),85085(14),87087(15),69069(16),87087(17),408408(18),380380(19),385385(20),383383(21),378378(22),343343(23),349349(24),342342(25),350350(26),91091(27),89089(28),93093(29),89089(30),96096(31),82082(32),83083(33),64064(34),86086(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 7875868,43755,97505,Lock-Free (DWCAS 5),265265(0),276276(1),276276(2),278278(3),312312(4),301301(5),272272(6),303303(7),294294(8),138138(9),143143(10),140140(11),144144(12),144144(13),137137(14),133133(15),134134(16),139139(17),325325(18),325325(19),327327(20),328328(21),320320(22),297297(23),283283(24),303303(25),286286(26),135135(27),142142(28),145145(29),142142(30),142142(31),134134(32),134134(33),132132(34),139139(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 8228220,45712,160073,Lock-Free (DWCAS 6),83083(0),82082(1),90090(2),97097(3),95095(4),105105(5),102102(6),104104(7),102102(8),348348(9),352352(10),362362(11),364364(12),362362(13),371371(14),366366(15),353353(16),378378(17),82082(18),82082(19),93093(20),96096(21),92092(22),104104(23),99099(24),103103(25),105105(26),343343(27),357357(28),362362(29),367367(30),355355(31),364364(32),364364(33),367367(34),369369(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 7221214,40118,126960,Lock-Free (DWCAS 7),84084(0),85085(1),92092(2),92092(3),95095(4),101101(5),106106(6),101101(7),102102(8),295295(9),298298(10),314314(11),305305(12),304304(13),308308(14),308308(15),312312(16),319319(17),86086(18),85085(19),93093(20),95095(21),93093(22),101101(23),98098(24),99099(25),101101(26),288288(27),302302(28),307307(29),302302(30),296296(31),307307(32),308308(33),315315(34),317317(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 7495488,41642,128651,Lock-Free (DWCAS 8),92092(0),93093(1),100100(2),103103(3),96096(4),105105(5),110110(6),107107(7),109109(8),298298(9),302302(10),316316(11),319319(12),311311(13),322322(14),320320(15),323323(16),330330(17),90090(18),89089(19),101101(20),102102(21),100100(22),105105(23),108108(24),104104(25),107107(26),302302(27),313313(28),321321(29),312312(30),304304(31),312312(32),317317(33),323323(34),322322(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 8386378,46591,160860,Lock-Free (DWCAS 9),396396(0),401401(1),383383(2),387387(3),384384(4),343343(5),336336(6),345345(7),327327(8),98098(9),99099(10),99099(11),104104(12),109109(13),107107(14),100100(15),99099(16),85085(17),397397(18),390390(19),376376(20),380380(21),385385(22),340340(23),335335(24),343343(25),327327(26),101101(27),99099(28),108108(29),100100(30),103103(31),101101(32),103103(33),100100(34),88088(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 8170162,45390,145243,Lock-Free (DWCAS 10),107107(0),100100(1),104104(2),109109(3),106106(4),106106(5),106106(6),110110(7),107107(8),342342(9),330330(10),347347(11),345345(12),356356(13),357357(14),361361(15),351351(16),356356(17),106106(18),100100(19),105105(20),111111(21),104104(22),107107(23),105105(24),110110(25),105105(26),335335(27),326326(28),348348(29),342342(30),350350(31),352352(32),354354(33),349349(34),353353(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 24176152,134312,37751,PThread Mutex,632632(0),637637(1),639639(2),658658(3),636636(4),638638(5),641641(6),650650(7),641641(8),699699(9),698698(10),697697(11),725725(12),698698(13),706706(14),696696(15),692692(16),697697(17),640640(18),632632(19),630630(20),663663(21),632632(22),642642(23),632632(24),649649(25),650650(26),688688(27),675675(28),705705(29),723723(30),708708(31),700700(32),690690(33),702702(34),711711(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 9872863,54849,235326,PThread Spinlock (private),62062(0),59059(1),73073(2),70070(3),63063(4),105105(5),105105(6),98098(7),100100(8),425425(9),403403(10),436436(11),531531(12),467467(13),491491(14),372372(15),434434(16),573573(17),63063(18),62062(19),75075(20),71071(21),64064(22),108108(23),108108(24),101101(25),102102(26),432432(27),407407(28),480480(29),540540(30),489489(31),505505(32),403403(33),430430(34),556556(35)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 8951943,49733,82044,PThread Spinlock (shared),213213(0),205205(1),243243(2),228228(3),201201(4),363363(5),357357(6),345345(7),335335(8),176176(9),189189(10),213213(11),222222(12),201201(13),210210(14),211211(15),214214(16),216216(17),230230(18),221221(19),260260(20),247247(21),211211(22),403403(23),406406(24),381381(25),378378(26),188188(27),189189(28),209209(29),223223(30),200200(31),211211(32),212212(33),215215(34),217217(35)

All bets are off

It may be that all the results on the 36 core machine are invalid.

I’ve been looking into the malformed logical processor sets.

There’s a bug in how benchmark processes NUMA node cpumaps and it ended up with a mixed-up set of logical processors to NUMA nodes - God knows what effect this had on the thread distributions.

2016-02-05

One or two notes

The problem with the logical processor sets occurs when the sets move over into another NUMA node.

I’ve copied the appropriate /proc dirs so I can reproduce without paying 2 USD an hour :-)

One note - the VM I used for those test was on a dedidcated machine. Just me, no-one else.

Results without PRNG

Without PRNG.

I need to fix the logical processor set generator and stripe the freelist elements over the NUMA nodes.

I suspect it won’t change the results though; pthread mutex wins when the number of cores is high.

Question is, how and why? I have two thoughts - firstly, maybe I need the backoff algorithm to be that the backoff value continues to increase for a run of the same result, i.e. as one thread keeps having successes, his backoff increases, and also as he keeps havings failures, too. It only resets to 1 on the swap from one state to the other.

The other thought is to add the scalable overlay, the hand-off which masks the freelist. I would have thought though this will help the mutex just as much as the lock-free approach - but it might well not be so.

Have to read the white paper and see how it works, too. I know the rough idea, but I’m not sure how the data structures are arranged.

Freelist Push One Pop One

                                   M                                   
                 N                                   N                 
                 S                                   S                 
                L3U                                 L3U                
L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U
L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D
L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I
 P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P 
L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type,per-thread total ops
  1                                                                     159323164,31864633,0,GCC Spinlock (atomic),159323164(18)
  1                                                                     170799629,34159926,0,GCC Spinlock (sync),170799629(18)
  1                                                                     171929758,34385952,0,Lock-Free (DWCAS 0),171929758(18)
  1                                                                     172027856,34405571,0,Lock-Free (DWCAS 1),172027856(18)
  1                                                                     171970799,34394160,0,Lock-Free (DWCAS 2),171970799(18)
  1                                                                     171857686,34371537,0,Lock-Free (DWCAS 3),171857686(18)
  1                                                                     171902731,34380546,0,Lock-Free (DWCAS 4),171902731(18)
  1                                                                     172131960,34426392,0,Lock-Free (DWCAS 5),172131960(18)
  1                                                                     172241069,34448214,0,Lock-Free (DWCAS 6),172241069(18)
  1                                                                     172304132,34460826,0,Lock-Free (DWCAS 7),172304132(18)
  1                                                                     172269097,34453819,0,Lock-Free (DWCAS 8),172269097(18)
  1                                                                     172279107,34455821,0,Lock-Free (DWCAS 9),172279107(18)
  1                                                                     172285113,34457023,0,Lock-Free (DWCAS 10),172285113(18)
  1                                                                     145639494,29127899,0,PThread Mutex,145639494(18)
  1                                                                     220792572,44158514,0,PThread Spinlock (private),220792572(18)
  1                                                                     221813592,44362718,0,PThread Spinlock (shared),221813592(18)
  1   1                                                                 25511486,2551149,125708,GCC Spinlock (atomic),13200187(18),12311299(19)
  1   1                                                                 25259234,2525923,13307,GCC Spinlock (sync),12582570(18),12676664(19)
  1   1                                                                 30452422,3045242,4197619,Lock-Free (DWCAS 0),385385(18),30067037(19)
  1   1                                                                 101719618,10171962,13268962,Lock-Free (DWCAS 1),3946943(18),97772675(19)
  1   1                                                                 133995862,13399586,18825584,Lock-Free (DWCAS 2),439439(18),133556423(19)
  1   1                                                                 141888747,14188875,19739938,Lock-Free (DWCAS 3),1153152(18),140735595(19)
  1   1                                                                 145957812,14595781,20008200,Lock-Free (DWCAS 4),2239237(18),143718575(19)
  1   1                                                                 150902752,15090275,19548687,Lock-Free (DWCAS 5),6336330(18),144566422(19)
  1   1                                                                 151047897,15104790,20582520,Lock-Free (DWCAS 6),2753751(18),148294146(19)
  1   1                                                                 154623469,15462347,20947186,Lock-Free (DWCAS 7),3252249(18),151371220(19)
  1   1                                                                 155962807,15596281,16967856,Lock-Free (DWCAS 8),17990973(18),137971834(19)
  1   1                                                                 158733575,15873358,20795147,Lock-Free (DWCAS 9),5844839(18),152888736(19)
  1   1                                                                 156987831,15698783,20738522,Lock-Free (DWCAS 10),5172167(18),151815664(19)
  1   1                                                                 25071046,2507105,23499,PThread Mutex,12452440(18),12618606(19)
  1   1                                                                 54440386,5444039,779445,PThread Spinlock (private),24464440(18),29975946(19)
  1   1                                                                 53693640,5369364,3281708,PThread Spinlock (shared),15244229(18),38449411(19)
  1   1   1                                                             19868849,1324590,389421,GCC Spinlock (atomic),5643638(18),6028022(19),8197189(20)
  1   1   1                                                             19685666,1312378,621659,GCC Spinlock (sync),4676672(18),6033027(19),8975967(20)
  1   1   1                                                             28179151,1878610,569724,Lock-Free (DWCAS 0),7068061(18),10611601(19),10499489(20)
  1   1   1                                                             50664614,3377641,3438518,Lock-Free (DWCAS 1),4179175(18),18080062(19),28405377(20)
  1   1   1                                                             89203114,5946874,12057920,Lock-Free (DWCAS 2),2470468(18),78861783(19),7870863(20)
  1   1   1                                                             107616509,7174434,10285023,Lock-Free (DWCAS 3),1419418(18),73883810(19),32313281(20)
  1   1   1                                                             124851727,8323448,10464628,Lock-Free (DWCAS 4),1282281(18),73977904(19),49591542(20)
  1   1   1                                                             131802671,8786845,10399627,Lock-Free (DWCAS 5),2578576(18),72929857(19),56294238(20)
  1   1   1                                                             137030894,9135393,10502520,Lock-Free (DWCAS 6),3440437(18),73186113(19),60404344(20)
  1   1   1                                                             140915775,9394385,10504754,Lock-Free (DWCAS 7),4838834(18),74964890(19),61112051(20)
  1   1   1                                                             143558415,9570561,11135147,Lock-Free (DWCAS 8),3896893(18),79870791(19),59790731(20)
  1   1   1                                                             146848702,9789913,11145639,Lock-Free (DWCAS 9),4793789(18),80541461(19),61513452(20)
  1   1   1                                                             149612463,9974164,11103168,Lock-Free (DWCAS 10),6124118(18),82023942(19),61464403(20)
  1   1   1                                                             21239218,1415948,222524,PThread Mutex,7899892(18),6331325(19),7008001(20)
  1   1   1                                                             36969933,2464662,237119,PThread Spinlock (private),13163150(18),11486475(19),12320308(20)
  1   1   1                                                             37668631,2511242,248845,PThread Spinlock (shared),13474461(18),12473461(19),11720709(20)
  1   1   1   1                                                         15589574,779479,330710,GCC Spinlock (atomic),2912910(18),3258255(19),4847843(20),4570566(21)
  1   1   1   1                                                         15249234,762462,447937,GCC Spinlock (sync),2353351(18),3229226(19),5314309(20),4352348(21)
  1   1   1   1                                                         23868845,1193442,308605,Lock-Free (DWCAS 0),4635631(18),6334328(19),6386380(20),6512506(21)
  1   1   1   1                                                         27919892,1395995,599933,Lock-Free (DWCAS 1),4471467(18),8340332(19),7241234(20),7866859(21)
  1   1   1   1                                                         37020984,1851049,121192,Lock-Free (DWCAS 2),8954946(18),9000992(19),9361352(20),9703694(21)
  1   1   1   1                                                         57578521,2878926,589722,Lock-Free (DWCAS 3),12768756(18),13089076(19),15702687(20),16018002(21)
  1   1   1   1                                                         74207133,3710357,239697,Lock-Free (DWCAS 4),17528511(18),18831813(19),19055036(20),18791773(21)
  1   1   1   1                                                         94801707,4740085,888146,Lock-Free (DWCAS 5),20313293(18),23114091(19),25618593(20),25755730(21)
  1   1   1   1                                                         116113998,5805700,684311,Lock-Free (DWCAS 6),31909878(18),28455427(19),27420393(20),28328300(21)
  1   1   1   1                                                         122855733,6142787,1095322,Lock-Free (DWCAS 7),35113078(18),30419389(19),27629602(20),29693664(21)
  1   1   1   1                                                         132277145,6613857,6888754,Lock-Free (DWCAS 8),4547543(18),49967918(19),42024983(20),35736701(21)
  1   1   1   1                                                         135613478,6780674,6617698,Lock-Free (DWCAS 9),6434428(18),50339289(19),41576535(20),37263226(21)
  1   1   1   1                                                         140753613,7037681,6638221,Lock-Free (DWCAS 10),42817775(18),37230193(19),52629577(20),8076068(21)
  1   1   1   1                                                         19297278,964864,60836,PThread Mutex,4905901(18),4700696(19),4658654(20),5032027(21)
  1   1   1   1                                                         29811782,1490589,142261,PThread Spinlock (private),7398391(18),7057050(19),7328321(20),8028020(21)
  1   1   1   1                                                         30216186,1510809,130785,PThread Spinlock (shared),7537530(18),7304297(19),7281274(20),8093085(21)
  1   1   1   1   1                                                     12769757,510790,570925,GCC Spinlock (atomic),16016(18),2933931(19),3347344(20),3274271(21),3198195(22)
  1   1   1   1   1                                                     12581569,503263,172298,GCC Spinlock (sync),1972971(18),2219217(19),3031028(20),2821819(21),2536534(22)
  1   1   1   1   1                                                     23403380,936135,26891,Lock-Free (DWCAS 0),4769765(18),4616612(19),4710706(20),4610606(21),4695691(22)
  1   1   1   1   1                                                     22586564,903463,222452,Lock-Free (DWCAS 1),4471467(18),4945941(19),4732728(20),4860856(21),3575572(22)
  1   1   1   1   1                                                     39417378,1576695,1477545,Lock-Free (DWCAS 2),6126120(18),10842832(19),7798791(20),11912901(21),2736734(22)
  1   1   1   1   1                                                     62493431,2499737,3678086,Lock-Free (DWCAS 3),4232228(18),22160138(19),14853839(20),19677658(21),1569568(22)
  1   1   1   1   1                                                     58733675,2349347,124820,Lock-Free (DWCAS 4),11334323(18),11747736(19),12213201(20),11706695(21),11731720(22)
  1   1   1   1   1                                                     84282198,3371288,528605,Lock-Free (DWCAS 5),14721707(18),17043026(19),18347329(20),17267250(21),16902886(22)
  1   1   1   1   1                                                     93460367,3738415,718795,Lock-Free (DWCAS 6),15851836(18),19114095(19),20842822(20),18896878(21),18754736(22)
  1   1   1   1   1                                                     99685586,3987423,534631,Lock-Free (DWCAS 7),18077059(18),19937918(19),21642621(20),20632612(21),19395376(22)
  1   1   1   1   1                                                     108674566,4346983,503455,Lock-Free (DWCAS 8),21090069(18),20600580(19),23490467(20),22627605(21),20865845(22)
  1   1   1   1   1                                                     113802689,4552108,778599,Lock-Free (DWCAS 9),20221201(18),22541519(19),25693668(20),22815793(21),22530508(22)
  1   1   1   1   1                                                     126774648,5070986,843848,Lock-Free (DWCAS 10),22574552(18),24200176(19),28187159(20),26139113(21),25673648(22)
  1   1   1   1   1                                                     23586563,943463,47135,PThread Mutex,4570566(18),4722718(19),4640636(20),4872868(21),4779775(22)
  1   1   1   1   1                                                     30861831,1234473,1600080,PThread Spinlock (private),13263250(18),5089084(19),4708704(20),4108104(21),3692689(22)
  1   1   1   1   1                                                     30595565,1223823,1352912,PThread Spinlock (shared),12064052(18),5494489(19),4922918(20),4271267(21),3842839(22)
  1   1   1   1   1   1                                                 11860849,395362,40905,GCC Spinlock (atomic),1843842(18),2031029(19),1954953(20),2030028(21),1908907(22),2092090(23)
  1   1   1   1   1   1                                                 11500489,383350,35204,GCC Spinlock (sync),1805804(18),1994993(19),2004002(20),1891890(21),1945944(22),1857856(23)
  1   1   1   1   1   1                                                 20156136,671871,10590,Lock-Free (DWCAS 0),3379376(18),3370367(19),3319316(20),3347344(21),3382379(22),3357354(23)
  1   1   1   1   1   1                                                 19217198,640573,44799,Lock-Free (DWCAS 1),3050047(18),3103100(19),3246243(20),3271268(21),3259256(22),3287284(23)
  1   1   1   1   1   1                                                 22292270,743076,26714,Lock-Free (DWCAS 2),3631628(18),3760757(19),3723720(20),3657654(21),3731728(22),3786783(23)
  1   1   1   1   1   1                                                 30558528,1018618,74157,Lock-Free (DWCAS 3),4847843(18),4990986(19),5092087(20),5121116(21),5167162(22),5339334(23)
  1   1   1   1   1   1                                                 43712669,1457089,232455,Lock-Free (DWCAS 4),6712706(18),6754748(19),7213206(20),7249242(21),7904897(22),7877870(23)
  1   1   1   1   1   1                                                 63123060,2104102,555193,Lock-Free (DWCAS 5),8994986(18),9299290(19),10529519(20),10471461(21),11883872(22),11943932(23)
  1   1   1   1   1   1                                                 75004930,2500164,513167,Lock-Free (DWCAS 6),10813803(18),11848837(19),12376364(20),12400388(21),13786773(22),13778765(23)
  1   1   1   1   1   1                                                 86499413,2883314,784163,Lock-Free (DWCAS 7),11929918(18),12852840(19),14646632(20),14600586(21),16083067(22),16386370(23)
  1   1   1   1   1   1                                                 94898804,3163293,727521,Lock-Free (DWCAS 8),13186173(18),14877863(19),16117101(20),15817802(21),17395378(22),17504487(23)
  1   1   1   1   1   1                                                 103272169,3442406,899421,Lock-Free (DWCAS 9),14488474(18),16331315(19),17114097(20),16671655(21),18165147(22),20501481(23)
  1   1   1   1   1   1                                                 115405290,3846843,1075632,Lock-Free (DWCAS 10),15971956(18),16555539(19),20388368(20),20168148(21),20300280(22),22020999(23)
  1   1   1   1   1   1                                                 23978955,799298,127848,PThread Mutex,4028024(18),4054050(19),3764761(20),4516512(21),3740737(22),3874871(23)
  1   1   1   1   1   1                                                 23910887,797030,268375,PThread Spinlock (private),4672668(18),3655652(19),3448445(20),3278275(21),4287283(22),4568564(23)
  1   1   1   1   1   1                                                 24116092,803870,277648,PThread Spinlock (shared),4777773(18),3683680(19),3472469(20),3278275(21),4360356(22),4543539(23)
  1   1   1   1   1   1   1                                             9450441,270013,549107,GCC Spinlock (atomic),762762(18),665665(19),930930(20),1099098(21),1024023(22),1104103(23),3863860(24)
  1   1   1   1   1   1   1                                             8147139,232775,762997,GCC Spinlock (sync),405405(18),377377(19),483483(20),849849(21),491491(22),873873(23),4665661(24)
  1   1   1   1   1   1   1                                             20214194,577548,132613,Lock-Free (DWCAS 0),2986984(18),2961959(19),3011008(20),2278276(21),3007004(22),3033030(23),2935933(24)
  1   1   1   1   1   1   1                                             20175155,576433,179313,Lock-Free (DWCAS 1),3093090(18),2953951(19),3028025(20),2062060(21),2951949(22),2999997(23),3086083(24)
  1   1   1   1   1   1   1                                             22066044,630458,175524,Lock-Free (DWCAS 2),3353350(18),3115112(19),3352349(20),2363361(21),3234231(22),3338335(23),3309306(24)
  1   1   1   1   1   1   1                                             33117084,946202,562656,Lock-Free (DWCAS 3),5470465(18),4336332(19),5644639(20),2361359(21),5114109(22),5513508(23),4676672(24)
  1   1   1   1   1   1   1                                             51396345,1468467,1614947,Lock-Free (DWCAS 4),11469458(18),4818814(19),8311303(20),1296295(21),8376368(22),8200192(23),8923915(24)
  1   1   1   1   1   1   1                                             67696629,1934189,2051027,Lock-Free (DWCAS 5),12389377(18),7340333(19),13880867(20),1344343(21),11574563(22),10604594(23),10562552(24)
  1   1   1   1   1   1   1                                             81179098,2319403,2387421,Lock-Free (DWCAS 6),14461447(18),8925917(19),15915900(20),1668667(21),13713700(22),13190177(23),13303290(24)
  1   1   1   1   1   1   1                                             92725633,2649304,2619908,Lock-Free (DWCAS 7),16917901(18),10597587(19),17637620(20),2244242(21),15337322(22),15370355(23),14620606(24)
  1   1   1   1   1   1   1                                             102016915,2914769,2925288,Lock-Free (DWCAS 8),16995979(18),11592581(19),20185165(20),2397395(21),17998981(22),17076059(23),15770755(24)
  1   1   1   1   1   1   1                                             110738628,3163961,3244424,Lock-Free (DWCAS 9),18616598(18),12151139(19),22133111(20),2555553(21),18943925(22),19793774(23),16544528(24)
  1   1   1   1   1   1   1                                             118838720,3395392,3304029,Lock-Free (DWCAS 10),18641623(18),14295281(19),22930908(20),3150147(21),21004984(22),21442421(23),17373356(24)
  1   1   1   1   1   1   1                                             20815795,594737,75646,PThread Mutex,2993991(18),2998996(19),2790788(20),3212209(21),2822820(22),2880878(23),3116113(24)
  1   1   1   1   1   1   1                                             24681657,705190,396415,PThread Spinlock (private),2536534(18),3482479(19),4281277(20),3464461(21),4480476(22),4016012(23),2420418(24)
  1   1   1   1   1   1   1                                             24574550,702130,393656,PThread Spinlock (shared),2620618(18),3470467(19),4293289(20),3200197(21),4435431(22),4116112(23),2438436(24)
  1   1   1   1   1   1   1   1                                         8355347,208884,302196,GCC Spinlock (atomic),1005004(18),1618617(19),1413412(20),1466465(21),9009(22),1545544(23),671671(24),625625(25)
  1   1   1   1   1   1   1   1                                         8268260,206706,294109,GCC Spinlock (sync),973973(18),1502501(19),1368367(20),1445444(21),9009(22),1622621(23),693693(24),652652(25)
  1   1   1   1   1   1   1   1                                         19133114,478328,216374,Lock-Free (DWCAS 0),2547545(18),2589587(19),2553551(20),2548546(21),2516514(22),2526524(23),1383382(24),2467465(25)
  1   1   1   1   1   1   1   1                                         18179161,454479,216321,Lock-Free (DWCAS 1),2428426(18),2471469(19),2436434(20),2426424(21),2419417(22),2410408(23),1266265(24),2320318(25)
  1   1   1   1   1   1   1   1                                         19471452,486786,116947,Lock-Free (DWCAS 2),2475473(18),2440438(19),2522520(20),1906905(21),2449447(22),2492490(23),2571569(24),2612610(25)
  1   1   1   1   1   1   1   1                                         22431409,560785,192857,Lock-Free (DWCAS 3),1932931(18),3071068(19),2884882(20),2858856(21),2879877(22),2794792(23),2959957(24),3049046(25)
  1   1   1   1   1   1   1   1                                         35670635,891766,1051698,Lock-Free (DWCAS 4),1498497(18),8633625(19),3943940(20),4131127(21),4298294(22),3787784(23),4186182(24),5191186(25)
  1   1   1   1   1   1   1   1                                         51755704,1293893,1571690,Lock-Free (DWCAS 5),1096095(18),8854846(19),5731726(20),5163158(21),6161155(22),5293288(23),8671663(24),10783773(25)
  1   1   1   1   1   1   1   1                                         64413349,1610334,1944541,Lock-Free (DWCAS 6),1322321(18),9860851(19),6815809(20),6670664(21),7722715(22),7217210(23),11007997(24),13795782(25)
  1   1   1   1   1   1   1   1                                         77491414,1937285,2211561,Lock-Free (DWCAS 7),1866865(18),10747737(19),8391383(20),8194186(21),9357348(22),9200191(23),13846833(24),15886871(25)
  1   1   1   1   1   1   1   1                                         86661575,2166539,2488393,Lock-Free (DWCAS 8),2011009(18),13074061(19),9382373(20),9010001(21),10224214(22),10007998(23),15530515(24),17421404(25)
  1   1   1   1   1   1   1   1                                         97548451,2438711,2491623,Lock-Free (DWCAS 9),2593591(18),16306290(19),11045034(20),10675665(21),11822811(22),11781770(23),15595580(24),17727710(25)
  1   1   1   1   1   1   1   1                                         106773667,2669342,2526584,Lock-Free (DWCAS 10),2947945(18),17114097(19),12487475(20),12457445(21),13254241(22),13572559(23),16555539(24),18384366(25)
  1   1   1   1   1   1   1   1                                         16723707,418093,84878,PThread Mutex,2156154(18),2160158(19),2080078(20),2068066(21),2078076(22),2053051(23),2353351(24),1774773(25)
  1   1   1   1   1   1   1   1                                         19972953,499324,479676,PThread Spinlock (private),1751750(18),1628627(19),2135133(20),2127125(21),2276274(22),2264262(23),3608605(24),4181177(25)
  1   1   1   1   1   1   1   1                                         19856837,496421,419742,PThread Spinlock (shared),1758757(18),1646645(19),2182180(20),2192190(21),2343341(22),2334332(23),3739736(24),3659656(25)
  1   1   1   1   1   1   1   1   1                                     8235227,183005,224683,GCC Spinlock (atomic),926926(18),1190189(19),5005(20),1322321(21),1239238(22),1129128(23),804804(24),865865(25),751751(26)
  1   1   1   1   1   1   1   1   1                                     6930924,154021,255278,GCC Spinlock (sync),749749(18),808808(19),1134133(20),1235234(21),1206205(22),1161160(23),208208(24),199199(25),228228(26)
  1   1   1   1   1   1   1   1   1                                     18282264,406273,182252,Lock-Free (DWCAS 0),2190188(18),2191189(19),2187185(20),2148146(21),2140138(22),2135133(23),1184183(24),2068066(25),2038036(26)
  1   1   1   1   1   1   1   1   1                                     17138121,380847,173493,Lock-Free (DWCAS 1),2044042(18),2071069(19),2058056(20),2030028(21),2017015(22),2013011(23),1104103(24),1920919(25),1879878(26)
  1   1   1   1   1   1   1   1   1                                     18578560,412857,197604,Lock-Free (DWCAS 2),2193191(18),2253251(19),2225223(20),2198196(21),2209207(22),2206204(23),1150149(24),2111109(25),2032030(26)
  1   1   1   1   1   1   1   1   1                                     20788768,461973,236559,Lock-Free (DWCAS 3),2368366(18),2479477(19),2499497(20),2493491(21),2503501(22),2509507(23),1211210(24),2422420(25),2301299(26)
  1   1   1   1   1   1   1   1   1                                     31275244,695005,437433,Lock-Free (DWCAS 4),3108105(18),3062059(19),3745742(20),3663660(21),4125121(22),1688687(23),3791788(24),4099095(25),3990987(26)
  1   1   1   1   1   1   1   1   1                                     42616574,947035,1538628,Lock-Free (DWCAS 5),3698695(18),3632629(19),4119115(20),4100096(21),4381377(22),4412408(23),942942(24),10968958(25),6360354(26)
  1   1   1   1   1   1   1   1   1                                     59708649,1326859,1523180,Lock-Free (DWCAS 6),5771766(18),5184179(19),5825820(20),5812807(21),7290283(22),1304303(23),9114105(24),9639630(25),9765756(26)
  1   1   1   1   1   1   1   1   1                                     65524459,1456099,2078864,Lock-Free (DWCAS 7),5949944(18),6152146(19),6775769(20),6712706(21),7230223(22),7087080(23),1251250(24),15342327(25),9023014(26)
  1   1   1   1   1   1   1   1   1                                     82152070,1825602,1897320,Lock-Free (DWCAS 8),8172164(18),7332325(19),8497489(20),8595587(21),10515505(22),1938937(23),12108096(24),12472460(25),12519507(26)
  1   1   1   1   1   1   1   1   1                                     86677591,1926169,2885626,Lock-Free (DWCAS 9),7606599(18),8009001(19),8079071(20),8543535(21),9354345(22),9511502(23),1790789(24),20819799(25),12962950(26)
  1   1   1   1   1   1   1   1   1                                     103146043,2292134,2189130,Lock-Free (DWCAS 10),10222212(18),9510501(19),11404393(20),11645634(21),13731718(22),2611609(23),14708694(24),14610596(25),14700686(26)
  1   1   1   1   1   1   1   1   1                                     16248232,361072,56963,PThread Mutex,1741740(18),1734733(19),1750749(20),1756755(21),1712711(22),1736735(23),1922921(24),1952951(25),1938937(26)
  1   1   1   1   1   1   1   1   1                                     20290270,450895,203218,PThread Spinlock (private),1904903(18),2128126(19),2616614(20),2325323(21),2660658(22),2684682(23),1749748(24),1873872(25),2346344(26)
  1   1   1   1   1   1   1   1   1                                     21677656,481726,557420,PThread Spinlock (shared),1574573(18),2063061(19),3554551(20),2414412(21),3660657(22),3767764(23),1564563(24),1543542(25),1534533(26)
  1   1   1   1   1   1   1   1   1   1                                 19091072,381821,3488724,GCC Spinlock (atomic),111111(18),98098(19),74074(20),22022(21),72072(22),66066(23),70070(24),57057(25),63063(26),18457439(27)
  1   1   1   1   1   1   1   1   1   1                                 16040024,320800,2619687,GCC Spinlock (sync),205205(18),209209(19),229229(20),210210(21),222222(22),198198(23),193193(24),276276(25),266266(26),14030016(27)
  1   1   1   1   1   1   1   1   1   1                                 24668644,493373,2681738,Lock-Free (DWCAS 0),1043042(18),1068067(19),1075074(20),1069068(21),1088087(22),1073072(23),1049048(24),979979(25),1036035(26),15187172(27)
  1   1   1   1   1   1   1   1   1   1                                 17088071,341761,1417056,Lock-Free (DWCAS 1),966966(18),979979(19),1020019(20),1020019(21),1015014(22),1001000(23),899899(24),907907(25),848848(26),8428420(27)
  1   1   1   1   1   1   1   1   1   1                                 27641614,552832,4490120,Lock-Free (DWCAS 2),409409(18),407407(19),422422(20),430430(21),434434(22),431431(23),400400(24),405405(25),238238(26),24062038(27)
  1   1   1   1   1   1   1   1   1   1                                 27248221,544964,4342308,Lock-Free (DWCAS 3),457457(18),477477(19),473473(20),467467(21),478478(22),465465(23),431431(24),252252(25),423423(26),23321298(27)
  1   1   1   1   1   1   1   1   1   1                                 22678656,453573,2628486,Lock-Free (DWCAS 4),893893(18),912912(19),912912(20),905905(21),919919(22),922922(23),837837(24),908908(25),728728(26),14734720(27)
  1   1   1   1   1   1   1   1   1   1                                 28723695,574474,4538906,Lock-Free (DWCAS 5),480480(18),498498(19),508508(20),492492(21),506506(22),496496(23),475475(24),567567(25),296296(26),24401377(27)
  1   1   1   1   1   1   1   1   1   1                                 30769739,615395,4652977,Lock-Free (DWCAS 6),604604(18),635635(19),639639(20),628628(21),630630(22),623623(23),805805(24),318318(25),737737(26),25145120(27)
  1   1   1   1   1   1   1   1   1   1                                 36246210,724924,5519239,Lock-Free (DWCAS 7),632632(18),667667(19),672672(20),643643(21),665665(22),700700(23),797797(24),830830(25),830830(26),29803774(27)
  1   1   1   1   1   1   1   1   1   1                                 36514478,730290,5255374,Lock-Free (DWCAS 8),876876(18),927927(19),926926(20),933933(21),893893(22),886886(23),920920(24),1189188(25),384384(26),28573545(27)
  1   1   1   1   1   1   1   1   1   1                                 44634590,892692,5097503,Lock-Free (DWCAS 9),1626625(18),1692691(19),1742741(20),1692691(21),1718717(22),1750749(23),2739737(24),622622(25),2456454(26),28591563(27)
  1   1   1   1   1   1   1   1   1   1                                 56425369,1128507,7435764,Lock-Free (DWCAS 10),1569568(18),1617616(19),1550549(20),1547546(21),1646645(22),1683682(23),1985984(24),1972971(25),1940939(26),40909869(27)
  1   1   1   1   1   1   1   1   1   1                                 34747713,694954,176992,PThread Mutex,3739736(18),3564561(19),3581578(20),3571568(21),3528525(22),3593590(23),3668665(24),3355352(25),3453450(26),2690688(27)
  1   1   1   1   1   1   1   1   1   1                                 11549538,230991,1054380,PThread Spinlock (private),771771(18),803803(19),617617(20),551551(21),581581(22),553553(23),503503(24),511511(25),507507(26),6147141(27)
  1   1   1   1   1   1   1   1   1   1                                 13900887,278018,243418,PThread Spinlock (shared),2015013(18),1709708(19),1435434(20),1427426(21),1412411(22),1454453(23),1350349(24),1374373(25),1318317(26),403403(27)
  1   1   1   1   1   1   1   1   1   1   1                             5679674,103267,455378,GCC Spinlock (atomic),203203(18),199199(19),187187(20),191191(21),188188(22),165165(23),196196(24),201201(25),203203(26),1975974(27),1968967(28)
  1   1   1   1   1   1   1   1   1   1   1                             5344339,97170,78067,GCC Spinlock (sync),424424(18),439439(19),426426(20),439439(21),438438(22),436436(23),423423(24),427427(25),419419(26),719719(27),749749(28)
  1   1   1   1   1   1   1   1   1   1   1                             22459437,408353,2445187,Lock-Free (DWCAS 0),266266(18),269269(19),310310(20),310310(21),312312(22),310310(23),314314(24),323323(25),321321(26),9757748(27),9963954(28)
  1   1   1   1   1   1   1   1   1   1   1                             21269248,386714,2309894,Lock-Free (DWCAS 1),283283(18),282282(19),305305(20),307307(21),309309(22),315315(23),295295(24),295295(25),235235(26),9379370(27),9261252(28)
  1   1   1   1   1   1   1   1   1   1   1                             18450432,335462,1230743,Lock-Free (DWCAS 2),776776(18),786786(19),789789(20),800800(21),872872(22),805805(23),791791(24),799799(25),800800(26),5557552(27),5667662(28)
  1   1   1   1   1   1   1   1   1   1   1                             18220202,331276,1190783,Lock-Free (DWCAS 3),764764(18),767767(19),809809(20),809809(21),801801(22),811811(23),832832(24),845845(25),848848(26),5542537(27),5384379(28)
  1   1   1   1   1   1   1   1   1   1   1                             14339325,260715,511447,Lock-Free (DWCAS 4),876876(18),832832(19),973973(20),951951(21),948948(22),930930(23),975975(24),979979(25),995995(26),2974972(27),2896894(28)
  1   1   1   1   1   1   1   1   1   1   1                             23410387,425643,2595558,Lock-Free (DWCAS 5),256256(18),293293(19),288288(20),291291(21),239239(22),287287(23),300300(24),303303(25),297297(26),10234224(27),10619609(28)
  1   1   1   1   1   1   1   1   1   1   1                             23376353,425025,2545169,Lock-Free (DWCAS 6),297297(18),248248(19),332332(20),317317(21),333333(22),311311(23),352352(24),378378(25),361361(26),11136125(27),9308299(28)
  1   1   1   1   1   1   1   1   1   1   1                             24727703,449595,1492075,Lock-Free (DWCAS 7),1075074(18),1160159(19),1160159(20),1127126(21),1126125(22),1220219(23),1269268(24),1277276(25),1277276(26),6970964(27),7064057(28)
  1   1   1   1   1   1   1   1   1   1   1                             33048015,600873,1164954,Lock-Free (DWCAS 8),2193191(18),1008007(19),2163161(20),2063061(21),2085083(22),2130128(23),2725723(24),2736734(25),2745743(26),6717711(27),6479473(28)
  1   1   1   1   1   1   1   1   1   1   1                             35242207,640767,1391861,Lock-Free (DWCAS 9),2198196(18),2256254(19),2382380(20),2403401(21),2350348(22),2347345(23),2456454(24),2829827(25),914914(26),7516509(27),7586579(28)
  1   1   1   1   1   1   1   1   1   1   1                             45150105,820911,1544153,Lock-Free (DWCAS 10),2782780(18),2970968(19),2894892(20),2764762(21),2872870(22),2932930(23),3310307(24),3455452(25),3117114(26),9005997(27),9042033(28)
  1   1   1   1   1   1   1   1   1   1   1                             30421391,553116,79754,PThread Mutex,2600598(18),2634632(19),2693691(20),2742740(21),2771769(22),2779777(23),2773771(24),2794792(25),2662660(26),2949947(27),3017014(28)
  1   1   1   1   1   1   1   1   1   1   1                             10851841,197306,725618,PThread Spinlock (private),331331(18),342342(19),387387(20),409409(21),455455(22),488488(23),735735(24),597597(25),516516(26),3379376(27),3208205(28)
  1   1   1   1   1   1   1   1   1   1   1                             11589578,210720,376567,PThread Spinlock (shared),844844(18),869869(19),1120119(20),1175174(21),1267266(22),1346345(23),1887886(24),1531530(25),1523522(26),12012(27),11011(28)
  1   1   1   1   1   1   1   1   1   1   1   1                         5408403,90140,149596,GCC Spinlock (atomic),291291(18),319319(19),332332(20),337337(21),335335(22),351351(23),377377(24),306306(25),297297(26),889889(27),774774(28),795795(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         4146142,69102,61924,GCC Spinlock (sync),614614(18),261261(19),357357(20),322322(21),281281(22),400400(23),300300(24),340340(25),269269(26),340340(27),336336(28),322322(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         16138122,268969,33689,Lock-Free (DWCAS 0),1359358(18),1377376(19),1325324(20),1333332(21),1354353(22),1323322(23),1260259(24),1292291(25),1294293(26),1419418(27),1431430(28),1367366(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         16621605,277027,678283,Lock-Free (DWCAS 1),726726(18),754754(19),849849(20),850850(21),842842(22),856856(23),816816(24),838838(25),852852(26),3003000(27),3003000(28),3225222(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         16779763,279663,733499,Lock-Free (DWCAS 2),769769(18),776776(19),812812(20),834834(21),832832(22),825825(23),749749(24),763763(25),723723(26),3250247(27),3124121(28),3315312(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         15631616,260527,687620,Lock-Free (DWCAS 3),739739(18),764764(19),736736(20),739739(21),738738(22),732732(23),704704(24),699699(25),712712(26),2941939(27),3083080(28),3037034(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         14416402,240273,696344,Lock-Free (DWCAS 4),598598(18),621621(19),632632(20),633633(21),608608(22),631631(23),611611(24),626626(25),627627(26),3024021(27),2929927(28),2869867(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17140123,285669,812771,Lock-Free (DWCAS 5),718718(18),728728(19),741741(20),747747(21),754754(22),752752(23),771771(24),783783(25),761761(26),3390387(27),3531528(28),3456453(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         16400384,273340,755594,Lock-Free (DWCAS 6),798798(18),750750(19),796796(20),640640(21),793793(22),775775(23),812812(24),823823(25),463463(26),3277274(27),3289286(28),3177174(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         18893875,314898,789642,Lock-Free (DWCAS 7),627627(18),871871(19),927927(20),915915(21),948948(22),918918(23),1016015(24),1032031(25),1014013(26),3447444(27),3586583(28),3586583(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         21660639,361011,821277,Lock-Free (DWCAS 8),1112111(18),1113112(19),1205204(20),1184183(21),1206205(22),1175174(23),1385384(24),752752(25),997997(26),3769766(27),3912909(28),3845842(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         27941914,465699,785402,Lock-Free (DWCAS 9),1625624(18),1660659(19),1774773(20),1739738(21),1783782(22),1786785(23),864864(24),2165163(25),1855854(26),4139135(27),4331327(28),4214210(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         37012976,616883,943906,Lock-Free (DWCAS 10),2308306(18),2288286(19),2348346(20),2380378(21),2392390(22),1173172(23),2614612(24),2766764(25),2709707(26),5265260(27),5588583(28),5177172(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         31988957,533149,94673,PThread Mutex,2656654(18),2645643(19),2899897(20),2756754(21),2736734(22),2771769(23),2695693(24),2694692(25),2745743(26),2462460(27),2386384(28),2536534(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         11642631,194044,665552,PThread Spinlock (private),558558(18),475475(19),435435(20),409409(21),434434(22),406406(23),334334(24),334334(25),364364(26),2659657(27),2534532(28),2695693(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         11961950,199366,408150,PThread Spinlock (shared),1812811(18),1576575(19),1466465(20),1388387(21),1394393(22),1405404(23),784784(24),974974(25),847847(26),135135(27),76076(28),99099(29)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     4921917,75722,390675,GCC Spinlock (atomic),363363(18),262262(19),179179(20),173173(21),171171(22),172172(23),144144(24),166166(25),149149(26),682682(27),2187185(28),131131(29),140140(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     4336332,66713,152873,GCC Spinlock (sync),321321(18),767767(19),437437(20),445445(21),386386(22),492492(23),401401(24),502502(25),361361(26),57057(27),58058(28),51051(29),54054(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     17645628,271471,408139,Lock-Free (DWCAS 0),959959(18),960960(19),988988(20),1018017(21),993993(22),1008007(23),955955(24),977977(25),958958(26),2192190(27),2179177(28),2215213(29),2236234(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     13932919,214353,156784,Lock-Free (DWCAS 1),1200199(18),1195194(19),649649(20),1220219(21),1217216(22),1256255(23),1257256(24),1270269(25),1270269(26),779779(27),793793(28),900900(29),921921(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     14637623,225194,396152,Lock-Free (DWCAS 2),739739(18),752752(19),771771(20),769769(21),779779(22),776776(23),760760(24),751751(25),739739(26),1933932(27),1878877(28),1958957(29),2023021(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     13392379,206037,51488,Lock-Free (DWCAS 3),904904(18),912912(19),1012011(20),1003002(21),1074073(22),1159158(23),1082081(24),1086085(25),1100099(26),1021020(27),952952(28),1033032(29),1051050(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     18016999,277185,1250008,Lock-Free (DWCAS 4),233233(18),218218(19),224224(20),224224(21),239239(22),237237(23),242242(24),240240(25),220220(26),4135131(27),3905902(28),4039035(29),3857854(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     11848837,182290,66473,Lock-Free (DWCAS 5),794794(18),790790(19),860860(20),854854(21),869869(22),875875(23),900900(24),892892(25),866866(26),1033032(27),969969(28),1029028(29),1109108(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     14311297,220174,456876,Lock-Free (DWCAS 6),596596(18),674674(19),680680(20),674674(21),680680(22),679679(23),710710(24),709709(25),708708(26),1973972(27),1993992(28),2116114(29),2111109(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     16158142,248587,449604,Lock-Free (DWCAS 7),765765(18),780780(19),817817(20),804804(21),820820(22),823823(23),806806(24),912912(25),921921(26),2130128(27),2171169(28),2189187(29),2212210(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     17231214,265096,483166,Lock-Free (DWCAS 8),812812(18),860860(19),876876(20),869869(21),887887(22),893893(23),907907(24),897897(25),912912(26),2230228(27),2265263(28),2425423(29),2389387(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     23704681,364687,467524,Lock-Free (DWCAS 9),817817(18),1537536(19),1423422(20),1369368(21),1446445(22),1453452(23),1604603(24),1467466(25),1589588(26),2523521(27),2852850(28),2768766(29),2849847(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     30023994,461908,549011,Lock-Free (DWCAS 10),1966965(18),1047046(19),1922921(20),1777776(21),1829828(22),1806805(23),2100098(24),2140138(25),2164162(26),3852849(27),3185182(28),3544541(29),2685683(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     33804771,520073,87463,PThread Mutex,2648646(18),2708706(19),2634632(20),2788786(21),2666664(22),2693691(23),2653651(24),2619617(25),2662660(26),2438436(27),2365363(28),2445443(29),2478476(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     11031020,169708,909385,PThread Spinlock (private),20020(18),18018(19),20020(20),20020(21),17017(22),18018(23),18018(24),16016(25),20020(26),2852850(27),3225222(28),2532530(29),2253251(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     11123112,171125,389785,PThread Spinlock (shared),343343(18),431431(19),526526(20),532532(21),486486(22),462462(23),615615(24),642642(25),563563(26),1713712(27),2009007(28),1466465(29),1329328(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 3609606,51566,64787,GCC Spinlock (atomic),291291(18),389389(19),348348(20),317317(21),356356(22),292292(23),307307(24),307307(25),253253(26),143143(27),144144(28),156156(29),151151(30),152152(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 5295290,75647,212954,GCC Spinlock (sync),951951(18),684684(19),530530(20),659659(21),617617(22),588588(23),283283(24),358358(25),295295(26),70070(27),67067(28),62062(29),66066(30),60060(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 15029014,214700,254971,Lock-Free (DWCAS 0),857857(18),857857(19),857857(20),862862(21),852852(22),849849(23),784784(24),727727(25),741741(26),1504503(27),1525524(28),1536535(29),1541540(30),1527526(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14605591,208651,201973,Lock-Free (DWCAS 1),1150149(18),1180179(19),1234233(20),1327326(21),1285284(22),1352351(23),1212211(24),1216215(25),1198197(26),784784(27),657657(28),657657(29),671671(30),677677(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 13850837,197869,255622,Lock-Free (DWCAS 2),728728(18),751751(19),720720(20),719719(21),735735(22),735735(23),741741(24),741741(25),737737(26),1455454(27),1446445(28),1434433(29),1461460(30),1439438(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 15457442,220821,280769,Lock-Free (DWCAS 3),828828(18),849849(19),846846(20),836836(21),837837(22),839839(23),792792(24),817817(25),773773(26),1605604(27),1599598(28),1625624(29),1623622(30),1578577(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 11767756,168111,257618,Lock-Free (DWCAS 4),550550(18),572572(19),610610(20),608608(21),606606(22),584584(23),564564(24),579579(25),581581(26),1276275(27),1285284(28),1311310(29),1327326(30),1308307(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 13770757,196725,309896,Lock-Free (DWCAS 5),612612(18),657657(19),690690(20),687687(21),697697(22),681681(23),675675(24),696696(25),682682(26),1482481(27),1497496(28),1542541(29),1590589(30),1574573(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 15425410,220363,167779,Lock-Free (DWCAS 6),1182181(18),1239238(19),1271270(20),1327326(21),1323322(22),1326325(23),1224223(24),1254253(25),1231230(26),922922(27),778778(28),777777(29),775775(30),790790(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 15968953,228128,315402,Lock-Free (DWCAS 7),813813(18),829829(19),845845(20),841841(21),851851(22),842842(23),803803(24),813813(25),807807(26),1665664(27),1611610(28),1692691(29),1761760(30),1785784(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14100086,201430,47163,Lock-Free (DWCAS 8),928928(18),847847(19),1002001(20),992992(21),981981(22),1004003(23),1062061(24),1071070(25),1064063(26),1021020(27),942942(28),1065064(29),1053052(30),1063062(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 17895878,255655,261133,Lock-Free (DWCAS 9),1001000(18),1030029(19),1069068(20),1065064(21),1059058(22),1028027(23),1126125(24),754754(25),1097096(26),1698697(27),1748747(28),1746745(29),1745744(30),1725724(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 21193172,302760,262202,Lock-Free (DWCAS 10),1251250(18),1269268(19),1287286(20),1307306(21),1315314(22),1295294(23),1475474(24),828828(25),1439438(26),1912911(27),1909908(28),1983982(29),1953952(30),1962961(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 30841811,440597,80042,PThread Mutex,2306304(18),2283281(19),2293291(20),2281279(21),2257255(22),2373371(23),2242240(24),2215213(25),2251249(26),2094092(27),2050048(28),2062060(29),2075073(30),2057055(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 10951941,156456,789009,PThread Spinlock (private),17017(18),27027(19),16016(20),13013(21),11011(22),12012(23),6006(24),5005(25),5005(26),2615613(27),2588586(28),1884883(29),1879878(30),1870869(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 11068057,158115,343546,PThread Spinlock (shared),481481(18),696696(19),465465(20),461461(21),443443(22),435435(23),394394(24),433433(25),371371(26),1576575(27),1668667(28),1230229(29),1194193(30),1215214(31)
1 1                                                                     81913832,8191383,10759,GCC Spinlock (atomic),40918878(0),40994954(18)
1 1                                                                     90262172,9026217,21234,GCC Spinlock (sync),45206161(0),45056011(18)
1 1                                                                     122899777,12289978,550538,Lock-Free (DWCAS 0),63396333(0),59503444(18)
1 1                                                                     123899776,12389978,1422423,Lock-Free (DWCAS 1),66978912(0),56920864(18)
1 1                                                                     125165040,12516504,877972,Lock-Free (DWCAS 2),65686621(0),59478419(18)
1 1                                                                     125031907,12503191,452010,Lock-Free (DWCAS 3),64114050(0),60917857(18)
1 1                                                                     125075951,12507595,617072,Lock-Free (DWCAS 4),64719655(0),60356296(18)
1 1                                                                     125056932,12505693,405436,Lock-Free (DWCAS 5),63961898(0),61095034(18)
1 1                                                                     125096972,12509697,361834,Lock-Free (DWCAS 6),63827764(0),61269208(18)
1 1                                                                     125018894,12501889,404303,Lock-Free (DWCAS 7),63938875(0),61080019(18)
1 1                                                                     124951827,12495183,279303,Lock-Free (DWCAS 8),63463400(0),61488427(18)
1 1                                                                     125059935,12505994,111127,Lock-Free (DWCAS 9),62922860(0),62137075(18)
1 1                                                                     124926802,12492680,87769,Lock-Free (DWCAS 10),62773711(0),62153091(18)
1 1                                                                     42087045,4208704,66676,PThread Mutex,21279258(0),20807787(18)
1 1                                                                     147000854,14700085,1018403,PThread Spinlock (private),77101024(0),69899830(18)
1 1                                                                     142638496,14263850,952434,PThread Spinlock (shared),74686612(0),67951884(18)
1 1 1 1                                                                 19652633,982632,22162,GCC Spinlock (atomic),4861857(0),4970966(1),4853849(18),4965961(19)
1 1 1 1                                                                 19663644,983182,84833,GCC Spinlock (sync),5144139(0),4710706(1),5111106(18),4697693(19)
1 1 1 1                                                                 27772745,1388637,1605977,Lock-Free (DWCAS 0),2917915(0),11011000(1),2938936(18),10904894(19)
1 1 1 1                                                                 47484437,2374222,262917,Lock-Free (DWCAS 1),11398387(0),12690678(1),11076065(18),12319307(19)
1 1 1 1                                                                 62881819,3144091,248474,Lock-Free (DWCAS 2),16599583(0),15705690(1),15733718(18),14842828(19)
1 1 1 1                                                                 83133050,4156652,143359,Lock-Free (DWCAS 3),20866846(0),21316295(1),20347327(18),20602582(19)
1 1 1 1                                                                 95543448,4777172,622381,Lock-Free (DWCAS 4),22595573(0),25842817(1),22144122(18),24960936(19)
1 1 1 1                                                                 106559453,5327973,3591863,Lock-Free (DWCAS 5),17774757(0),36318282(1),17574557(18),34891857(19)
1 1 1 1                                                                 108081974,5404099,364860,Lock-Free (DWCAS 6),26286260(0),28164136(1),25979954(18),27651624(19)
1 1 1 1                                                                 110346236,5517312,326401,Lock-Free (DWCAS 7),27041014(0),28761733(1),26644618(18),27898871(19)
1 1 1 1                                                                 113866753,5693338,6607955,Lock-Free (DWCAS 8),11810799(0),43338295(1),12162150(18),46555509(19)
1 1 1 1                                                                 112588476,5629424,180157,Lock-Free (DWCAS 9),27776749(0),28640612(1),27625598(18),28545517(19)
1 1 1 1                                                                 113826713,5691336,476450,Lock-Free (DWCAS 10),27080053(0),29526497(1),27472445(18),29747718(19)
1 1 1 1                                                                 26237211,1311861,289370,PThread Mutex,5313308(0),7083076(1),6866860(18),6973967(19)
1 1 1 1                                                                 37336299,1866815,311977,PThread Spinlock (private),8582574(0),10136126(1),8526518(18),10091081(19)
1 1 1 1                                                                 37071034,1853552,194095,PThread Spinlock (shared),8789781(0),9773764(1),8775767(18),9731722(19)
1 1 1 1 1 1                                                             13939926,464664,52331,GCC Spinlock (atomic),2363361(0),2425423(1),2177175(2),2382380(18),2418416(19),2173171(20)
1 1 1 1 1 1                                                             15147132,504904,48891,GCC Spinlock (sync),2612610(0),2536534(1),2559557(2),2639637(18),2454452(19),2344342(20)
1 1 1 1 1 1                                                             19842823,661427,657474,Lock-Free (DWCAS 0),1410409(0),4284280(1),4237233(2),1408407(18),4278274(19),4224220(20)
1 1 1 1 1 1                                                             23652629,788421,97010,Lock-Free (DWCAS 1),3823820(0),3928925(1),4264260(2),3690687(18),3810807(19),4134130(20)
1 1 1 1 1 1                                                             39108069,1303602,289110,Lock-Free (DWCAS 2),6937931(0),5756751(1),7140133(2),6711705(18),5649644(19),6911905(20)
1 1 1 1 1 1                                                             59684625,1989488,1388710,Lock-Free (DWCAS 3),6168162(0),13092079(1),10989979(2),6088082(18),12698686(19),10647637(20)
1 1 1 1 1 1                                                             75125050,2504168,3010221,Lock-Free (DWCAS 4),16779763(0),17642625(1),3896893(2),16110094(18),16884868(19),3810807(20)
1 1 1 1 1 1                                                             86720634,2890688,2231252,Lock-Free (DWCAS 5),8895887(0),19615596(1),12798786(2),8742734(18),19189170(19),17478461(20)
1 1 1 1 1 1                                                             95987892,3199596,411667,Lock-Free (DWCAS 6),16969953(0),16481465(1),15030015(2),16655639(18),16144128(19),14706692(20)
1 1 1 1 1 1                                                             98183085,3272770,292799,Lock-Free (DWCAS 7),16701685(0),16997981(1),15633618(2),16420404(18),16937921(19),15491476(20)
1 1 1 1 1 1                                                             102873771,3429126,3348276,Lock-Free (DWCAS 8),22789767(0),7570563(1),21616595(2),22228206(18),7438431(19),21230209(20)
1 1 1 1 1 1                                                             102985883,3432863,2305656,Lock-Free (DWCAS 9),20233213(0),20990970(1),9436427(2),19802783(18),20762742(19),11759748(20)
1 1 1 1 1 1                                                             105332227,3511074,907371,Lock-Free (DWCAS 10),19900881(0),15384369(1),17341324(2),19811792(18),15269254(19),17624607(20)
1 1 1 1 1 1                                                             22509487,750316,144817,PThread Mutex,3144141(0),4056052(1),3956953(2),3721718(18),3890887(19),3739736(20)
1 1 1 1 1 1                                                             29881852,996062,497439,PThread Spinlock (private),4171167(0),4368364(1),6418412(2),4164160(18),4354350(19),6405399(20)
1 1 1 1 1 1                                                             29595566,986519,423815,PThread Spinlock (shared),4378374(0),4298294(1),6187181(2),4348344(18),4261257(19),6122116(20)
1 1 1 1 1 1 1 1                                                         11813802,295345,27209,GCC Spinlock (atomic),1479478(0),1541540(1),1456455(2),1416415(3),1486485(18),1557556(19),1455454(20),1420419(21)
1 1 1 1 1 1 1 1                                                         11989978,299749,31796,GCC Spinlock (sync),1476475(0),1407406(1),1569568(2),1526525(3),1531530(18),1534533(19),1413412(20),1530529(21)
1 1 1 1 1 1 1 1                                                         17896879,447422,295174,Lock-Free (DWCAS 0),2666664(0),2486484(1),2456454(2),1343342(3),2665663(18),2481479(19),2451449(20),1345344(21)
1 1 1 1 1 1 1 1                                                         19119100,477978,30462,Lock-Free (DWCAS 1),2387385(0),2409407(1),2480478(2),2443441(3),2306304(18),2327325(19),2401399(20),2363361(21)
1 1 1 1 1 1 1 1                                                         27920893,698022,79470,Lock-Free (DWCAS 2),3332329(0),3459456(1),3717714(2),3570567(3),3286283(18),3406403(19),3648645(20),3499496(21)
1 1 1 1 1 1 1 1                                                         39926887,998172,143257,Lock-Free (DWCAS 3),4786782(0),5211206(1),5317312(2),4792788(3),4705701(18),5173168(19),5254249(20),4685681(21)
1 1 1 1 1 1 1 1                                                         55129074,1378227,268017,Lock-Free (DWCAS 4),6611605(0),7392385(1),7403396(2),6345339(3),6525519(18),7333326(19),7279272(20),6238232(21)
1 1 1 1 1 1 1 1                                                         71959888,1798997,328270,Lock-Free (DWCAS 5),8744736(0),8941933(1),9736727(2),8299291(3),8661653(18),9662653(19),9675666(20),8237229(21)
1 1 1 1 1 1 1 1                                                         82315233,2057881,337554,Lock-Free (DWCAS 6),10036026(0),10889879(1),10809799(2),9529520(3),9906897(18),10953943(19),10769759(20),9419410(21)
1 1 1 1 1 1 1 1                                                         87754667,2193867,285810,Lock-Free (DWCAS 7),10802792(0),11441430(1),11382371(2),10143133(3),10982972(18),11489478(19),11293282(20),10219209(21)
1 1 1 1 1 1 1 1                                                         92166074,2304152,263128,Lock-Free (DWCAS 8),11517506(0),12064052(1),11862851(2),10847837(3),11413402(18),11897886(19),11827816(20),10734724(21)
1 1 1 1 1 1 1 1                                                         94470376,2361759,285326,Lock-Free (DWCAS 9),11821810(0),12403391(1),12076064(2),11057046(3),11805794(18),12381369(19),11950939(20),10973963(21)
1 1 1 1 1 1 1 1                                                         98667569,2466689,316847,Lock-Free (DWCAS 10),12222210(0),12994982(1),12738726(2),11546535(3),12220208(18),12956944(19),12561549(20),11426415(21)
1 1 1 1 1 1 1 1                                                         18326308,458158,90878,PThread Mutex,2023021(0),2496494(1),2446444(2),2143141(3),2353351(18),2425423(19),2303301(20),2135133(21)
1 1 1 1 1 1 1 1                                                         24394370,609859,295472,PThread Spinlock (private),3293290(0),3764761(1),2684682(2),2437435(3),3347344(18),3755752(19),2674672(20),2436434(21)
1 1 1 1 1 1 1 1                                                         24107083,602677,144318,PThread Spinlock (shared),2711709(0),2824822(1),3252249(2),3289286(3),2695693(18),2816814(19),3231228(20),3285282(21)
1 1 1 1 1 1 1 1 1 1                                                     9736727,194735,16673,GCC Spinlock (atomic),998998(0),1003002(1),931931(2),949949(3),988988(4),1001000(18),985985(19),931931(20),960960(21),983983(22)
1 1 1 1 1 1 1 1 1 1                                                     9938929,198779,24330,GCC Spinlock (sync),1010009(0),1078077(1),989989(2),936936(3),1011010(4),991991(18),1015014(19),964964(20),997997(21),942942(22)
1 1 1 1 1 1 1 1 1 1                                                     15340325,306806,25878,Lock-Free (DWCAS 0),1560559(0),1550549(1),1473472(2),1549548(3),1565564(4),1555554(18),1545544(19),1436435(20),1543542(21),1559558(22)
1 1 1 1 1 1 1 1 1 1                                                     17879862,357597,339923,Lock-Free (DWCAS 1),2014012(0),2227225(1),2014012(2),2055053(3),726726(4),1968967(18),2169167(19),1971970(20),2010008(21),722722(22)
1 1 1 1 1 1 1 1 1 1                                                     19600581,392012,42045,Lock-Free (DWCAS 2),1907906(0),1914913(1),1984983(2),2010008(3),2083081(4),1870869(18),1874873(19),1948947(20),1968967(21),2036034(22)
1 1 1 1 1 1 1 1 1 1                                                     34615581,692312,827839,Lock-Free (DWCAS 3),3215212(0),4832828(1),3868865(2),4423419(3),1075074(4),3180177(18),4787783(19),3810807(20),4341337(21),1080079(22)
1 1 1 1 1 1 1 1 1 1                                                     44403359,888067,987975,Lock-Free (DWCAS 4),4296292(0),6133127(1),4951947(2),5461456(3),1569568(4),4223219(18),6050044(19),4850846(20),5322317(21),1544543(22)
1 1 1 1 1 1 1 1 1 1                                                     62719657,1254393,1308887,Lock-Free (DWCAS 5),5963958(0),8348340(1),7116109(2),7787780(3),2463461(4),5875870(18),8190182(19),6996990(20),7562555(21),2414412(22)
1 1 1 1 1 1 1 1 1 1                                                     73118045,1462361,1511946,Lock-Free (DWCAS 6),7414407(0),9789780(1),8071063(2),8781773(3),2835833(4),7280273(18),9650641(19),7917910(20),8613605(21),2762760(22)
1 1 1 1 1 1 1 1 1 1                                                     80845765,1616915,1674913,Lock-Free (DWCAS 7),8321313(0),10781771(1),8891883(2),9693684(3),3062059(4),8308300(18),10642632(19),8676668(20),9438429(21),3029026(22)
1 1 1 1 1 1 1 1 1 1                                                     85095010,1701900,1698016,Lock-Free (DWCAS 8),8873865(0),11310299(1),9292283(2),9926917(3),3417414(4),8790782(18),11191180(19),9123114(20),9785776(21),3383380(22)
1 1 1 1 1 1 1 1 1 1                                                     90428338,1808567,1823637,Lock-Free (DWCAS 9),9156147(0),11543532(1),10121111(2),10979969(3),3529526(4),9158149(18),11622611(19),9919910(20),10894884(21),3502499(22)
1 1 1 1 1 1 1 1 1 1                                                     93892799,1877856,1881954,Lock-Free (DWCAS 10),9353344(0),11979968(1),10288278(2),11225214(3),3745742(4),9572563(18),12293281(19),10397387(20),11347336(21),3689686(22)
1 1 1 1 1 1 1 1 1 1                                                     17260243,345205,47780,PThread Mutex,1540539(0),1816815(1),1760759(2),1691690(3),1761760(4),1761760(18),1813812(19),1719718(20),1693692(21),1699698(22)
1 1 1 1 1 1 1 1 1 1                                                     22206184,444124,363285,PThread Spinlock (private),1588587(0),1685684(1),3180177(2),2440438(3),2223221(4),1585584(18),1685684(19),3175172(20),2430428(21),2211209(22)
1 1 1 1 1 1 1 1 1 1                                                     22101079,442022,293689,PThread Spinlock (shared),1616615(0),1651650(1),2773771(2),2438436(3),2544542(4),1610609(18),1756755(19),2759757(20),2431429(21),2517515(22)
1 1 1 1 1 1 1 1 1 1 1 1                                                 8296288,138271,101135,GCC Spinlock (atomic),651651(0),1019018(1),619619(2),634634(3),624624(4),608608(5),632632(18),1014013(19),618618(20),629629(21),640640(22),602602(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 8242234,137371,120504,GCC Spinlock (sync),631631(0),1072071(1),645645(2),631631(3),597597(4),596596(5),608608(18),1073072(19),561561(20),606606(21),631631(22),585585(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 16087071,268118,312575,Lock-Free (DWCAS 0),1502501(0),1714713(1),1460459(2),1504503(3),348348(4),1500499(5),1506505(18),1719718(19),1467466(20),1512511(21),349349(22),1500499(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 16407391,273457,262886,Lock-Free (DWCAS 1),1494493(0),1663662(1),1515514(2),1550549(3),528528(4),1541540(5),1464463(18),1619618(19),1478477(20),1515514(21),526526(22),1508507(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 19184165,319736,263473,Lock-Free (DWCAS 2),1689688(0),1868867(1),1749748(2),1806805(3),759759(4),1796795(5),1660659(18),1837836(19),1714713(20),1776775(21),755755(22),1766765(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 28213185,470220,482234,Lock-Free (DWCAS 3),2265263(0),2961959(1),2542540(2),2843841(3),873873(4),2670668(5),2256254(18),2955953(19),2521519(20),2813811(21),876876(22),2630628(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 35828793,597147,595825,Lock-Free (DWCAS 4),2807805(0),3800797(1),3255252(2),3639636(3),1184183(4),3346343(5),2802800(18),3735732(19),3172169(20),3588585(21),1194193(22),3301298(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 52799747,879996,833778,Lock-Free (DWCAS 5),4156152(0),5521516(1),4765761(2),5291286(3),1904903(4),4920916(5),4099095(18),5450445(19),4708704(20),5249244(21),1867866(22),4863859(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 62818756,1046979,990775,Lock-Free (DWCAS 6),5269264(0),6782776(1),5618613(2),6112106(3),2216214(4),5650645(5),5219214(18),6692686(19),5487482(20),6014008(21),2225223(22),5530525(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 70909839,1181831,1138228,Lock-Free (DWCAS 7),6134128(0),7748741(1),6235229(2),6746740(3),2456454(4),6294288(5),6081075(18),7693686(19),6078072(20),6743737(21),2442440(22),6255249(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 78883805,1314730,1274647,Lock-Free (DWCAS 8),6776770(0),8530522(1),6976970(2),7660653(3),2687685(4),6997991(5),6681675(18),8498490(19),6868862(20),7563556(21),2676674(22),6963957(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 83650567,1394176,1320038,Lock-Free (DWCAS 9),6991985(0),8699691(1),7413406(2),8236228(3),2899897(4),7606599(5),6987981(18),8662654(19),7488481(20),8255247(21),2882880(22),7525518(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 88196108,1469935,1415145,Lock-Free (DWCAS 10),7458451(0),9361352(1),7886879(2),8657649(3),3009006(4),7904897(5),7437430(18),9294285(19),7773766(20),8592584(21),2978976(22),7840833(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 15931916,265532,33666,PThread Mutex,1189188(0),1304303(1),1374373(2),1346345(3),1363362(4),1286285(5),1336335(18),1316315(19),1359358(20),1349348(21),1360359(22),1346345(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 19349330,322489,174970,PThread Spinlock (private),2139137(0),1686685(1),1480479(2),1439438(3),1414413(4),1504503(5),2143141(18),1695694(19),1480479(20),1443442(21),1417416(22),1504503(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 18817799,313630,118603,PThread Spinlock (shared),1365364(0),1361360(1),1520519(2),1560559(3),1724723(4),1891890(5),1380379(18),1382381(19),1543542(20),1592591(21),1724723(22),1769768(23)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             7370363,105291,91966,GCC Spinlock (atomic),498498(0),825825(1),470470(2),459459(3),463463(4),470470(5),498498(6),497497(18),824824(19),457457(20),473473(21),464464(22),467467(23),498498(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             7247240,103532,101137,GCC Spinlock (sync),477477(0),844844(1),471471(2),443443(3),444444(4),467467(5),509509(6),486486(18),845845(19),432432(20),465465(21),455455(22),442442(23),460460(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             13961948,199456,205927,Lock-Free (DWCAS 0),1066065(0),1215214(1),1065064(2),1093092(3),335335(4),1071070(5),1135134(6),1067066(18),1215214(19),1065064(20),1095094(21),333333(22),1071070(23),1134133(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             14751737,210739,187173,Lock-Free (DWCAS 1),1115114(0),1240239(1),1142141(2),1170169(3),449449(4),1154153(5),1182181(6),1094093(18),1207206(19),1120119(20),1146145(21),445445(22),1132131(23),1153152(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             16791775,239882,194707,Lock-Free (DWCAS 2),1256255(0),1369368(1),1284283(2),1332331(3),569569(4),1326325(5),1323322(6),1237236(18),1343342(19),1264263(20),1309308(21),565565(22),1307306(23),1303302(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             22709687,324424,272453,Lock-Free (DWCAS 3),1622621(0),1911910(1),1719718(2),1857856(3),761761(4),1810809(5),1729728(6),1593592(18),1897896(19),1709708(20),1839838(21),754754(22),1784783(23),1714713(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             28814786,411640,363488,Lock-Free (DWCAS 4),1956955(0),2484482(1),2184182(2),2430428(3),932932(4),2281279(5),2199197(6),1964963(18),2443441(19),2158156(20),2401399(21),927927(22),2263261(23),2186184(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             40771731,582453,487401,Lock-Free (DWCAS 5),2803801(0),3570567(1),3087084(2),3349346(3),1409408(4),3105102(5),3167164(6),2777775(18),3497494(19),3050047(20),3332329(21),1403402(22),3083080(23),3135132(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             54102048,772886,690450,Lock-Free (DWCAS 6),3823820(0),4846842(1),4046042(2),4469465(3),1735734(4),4140136(5),4175171(6),3790787(18),4779775(19),3997994(20),4392388(21),1718717(22),4082078(23),4103099(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             63212149,903031,825736,Lock-Free (DWCAS 7),4536532(0),5696691(1),4684680(2),5102097(3),1945944(4),4805801(5),4972968(6),4488484(18),5613608(19),4673669(20),5036031(21),1939938(22),4783779(23),4931927(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             70636566,1009094,923316,Lock-Free (DWCAS 8),5074069(0),6355349(1),5289284(2),5783778(3),2181179(4),5337332(5),5497492(6),5013008(18),6269263(19),5210205(20),5699694(21),2166164(22),5257252(23),5502497(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             75263188,1075188,962511,Lock-Free (DWCAS 9),5405400(0),6680674(1),5594589(2),6048042(3),2388386(4),5737732(5),6073067(6),5170165(18),6658652(19),5465460(20),6007001(21),2392390(22),5710705(23),5930925(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             81198117,1159973,1067396,Lock-Free (DWCAS 10),5820815(0),7353346(1),6022016(2),6559553(3),2517515(4),6193187(5),6323317(6),5798793(18),7181174(19),6017011(20),6540534(21),2427425(22),6160154(23),6283277(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             21447426,306392,32254,PThread Mutex,1442441(0),1540539(1),1536535(2),1522521(3),1621620(4),1521520(5),1496495(6),1530529(18),1531530(19),1540539(20),1520519(21),1616615(22),1525524(23),1500499(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             17414397,248777,72574,PThread Spinlock (private),1240239(0),1445444(1),1126125(2),1169168(3),1217216(4),1298297(5),1209208(6),1241240(18),1449448(19),1126125(20),1169168(21),1216215(22),1298297(23),1208207(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             17531514,250450,255310,PThread Spinlock (shared),1433432(0),1985984(1),1067066(2),1136135(3),1088087(4),1224223(5),857857(6),1429428(18),1989988(19),1036035(20),1130129(21),1078077(22),1221220(23),853853(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         6510504,81381,68422,GCC Spinlock (atomic),419419(0),627627(1),353353(2),363363(3),368368(4),370370(5),373373(6),382382(7),429429(18),625625(19),363363(20),361361(21),354354(22),359359(23),380380(24),378378(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         6386380,79830,73400,GCC Spinlock (sync),414414(0),633633(1),349349(2),356356(3),380380(4),371371(5),340340(6),381381(7),400400(18),635635(19),355355(20),353353(21),328328(22),343343(23),389389(24),353353(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         13306293,166329,188806,Lock-Free (DWCAS 0),892892(0),1001000(1),895895(2),876876(3),219219(4),851851(5),951951(6),960960(7),890890(18),1002001(19),894894(20),879879(21),219219(22),854854(23),951951(24),961961(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         13527514,169094,150621,Lock-Free (DWCAS 1),898898(0),996996(1),904904(2),914914(3),354354(4),905905(5),945945(6),912912(7),881881(18),968968(19),888888(20),893893(21),353353(22),885885(23),926926(24),892892(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         15163148,189539,151258,Lock-Free (DWCAS 2),982982(0),1063062(1),995995(2),1028027(3),453453(4),1028027(5),1045044(6),1048047(7),963963(18),1045044(19),976976(20),1012011(21),451451(22),1009008(23),1025024(24),1035034(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         18494476,231181,171057,Lock-Free (DWCAS 3),1190189(0),1306305(1),1190189(2),1264263(3),601601(4),1244243(5),1245244(6),1262261(7),1176175(18),1289288(19),1183182(20),1245244(21),594594(22),1226225(23),1230229(24),1245244(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         23942919,299286,239893,Lock-Free (DWCAS 4),1439438(0),1713712(1),1554553(2),1698697(3),734734(4),1633632(5),1604603(6),1625624(7),1440439(18),1705704(19),1544543(20),1679678(21),726726(22),1619618(23),1605604(24),1615614(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         32223191,402790,302454,Lock-Free (DWCAS 5),1983982(0),2378376(1),2033031(2),2205203(3),1067066(4),2116114(5),2172170(6),2227225(7),1966965(18),2364362(19),2023021(20),2185183(21),1054053(22),2081079(23),2155153(24),2210208(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         44465421,555818,446404,Lock-Free (DWCAS 6),2677675(0),3300297(1),2834832(2),3106103(3),1387386(4),2957955(5),3006003(6),3078075(7),2686684(18),3270267(19),2787785(20),3077074(21),1361360(22),2904902(23),2964962(24),3064061(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         54296242,678703,595462,Lock-Free (DWCAS 7),3379376(0),4222218(1),3417414(2),3723720(3),1554553(4),3515512(5),3686683(6),3781778(7),3359356(18),4209205(19),3393390(20),3674671(21),1525524(22),3447444(23),3650647(24),3754751(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         62764702,784559,708849,Lock-Free (DWCAS 8),3961958(0),4996992(1),4087083(2),4464460(3),1818817(4),3470467(5),3852849(6),4496492(7),3960957(18),4935931(19),4029025(20),4395391(21),1804803(22),4191187(23),3834831(24),4463459(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         68766698,859584,749172,Lock-Free (DWCAS 9),4247243(0),5260255(1),4334330(2),4714710(3),1956955(4),4461457(5),4662658(6),4789785(7),4196192(18),5220215(19),4318314(20),4711707(21),1938937(22),4459455(23),4650646(24),4843839(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         74973899,937174,828611,Lock-Free (DWCAS 10),4619615(0),5779774(1),4835831(2),5236231(3),2087085(4),4909905(5),4963959(6),5145140(7),4675671(18),5789784(19),4779775(20),5196191(21),2081079(22),4814810(23),4927923(24),5131126(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         20748728,259359,36167,PThread Mutex,1178177(0),1324323(1),1282281(2),1316315(3),1294293(4),1302301(5),1331330(6),1324323(7),1198197(18),1346345(19),1282281(20),1314313(21),1287286(22),1303302(23),1334333(24),1329328(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         16067051,200838,219933,PThread Spinlock (private),1617616(0),1252251(1),966966(2),883883(3),893893(4),926926(5),728728(6),756756(7),1615614(18),1246245(19),965965(20),882882(21),890890(22),950950(23),729729(24),757757(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         16425409,205318,138841,PThread Spinlock (shared),1308307(0),1036035(1),1100099(2),994994(3),1125124(4),1128127(5),760760(6),766766(7),1303302(18),1035034(19),1092091(20),994994(21),1121120(22),1128127(23),757757(24),772772(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     5815810,64620,51435,GCC Spinlock (atomic),324324(0),488488(1),283283(2),290290(3),288288(4),285285(5),314314(6),320320(7),308308(8),336336(18),488488(19),282282(20),280280(21),289289(22),297297(23),315315(24),315315(25),308308(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     5762757,64031,58467,GCC Spinlock (sync),280280(0),504504(1),281281(2),290290(3),303303(4),278278(5),312312(6),329329(7),309309(8),362362(18),505505(19),278278(20),272272(21),268268(22),299299(23),301301(24),287287(25),299299(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     13133120,145924,168743,Lock-Free (DWCAS 0),755755(0),860860(1),819819(2),795795(3),175175(4),765765(5),799799(6),807807(7),779779(8),748748(18),873873(19),819819(20),797797(21),173173(22),767767(23),800800(24),809809(25),780780(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     12660648,140674,129323,Lock-Free (DWCAS 1),730730(0),813813(1),762762(2),753753(3),278278(4),738738(5),771771(6),778778(7),765765(8),714714(18),791791(19),748748(20),741741(21),276276(22),722722(23),756756(24),762762(25),750750(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     13813800,153487,120781,Lock-Free (DWCAS 2),777777(0),852852(1),809809(2),818818(3),371371(4),811811(5),835835(6),839839(7),839839(8),767767(18),837837(19),795795(20),809809(21),367367(22),800800(23),821821(24),825825(25),828828(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     16079063,178656,128754,Lock-Free (DWCAS 3),897897(0),976976(1),902902(2),957957(3),472472(4),946946(5),961961(6),966966(7),989989(8),887887(18),964964(19),912912(20),949949(21),470470(22),936936(23),944944(24),956956(25),979979(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     20231211,224791,170356,Lock-Free (DWCAS 4),1092091(0),1254253(1),1131130(2),1224223(3),573573(4),1198197(5),1197196(6),1220219(7),1233232(8),1086085(18),1258257(19),1127126(20),1219218(21),573573(22),1200199(23),1197196(24),1211210(25),1234233(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     25652627,285029,193072,Lock-Free (DWCAS 5),1386385(0),1619618(1),1421420(2),1543542(3),812812(4),1493492(5),1514513(6),1536535(7),1535534(8),1380379(18),1607606(19),1417416(20),1530529(21),802802(22),1480479(23),1505504(24),1542541(25),1521520(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     35623588,395818,300540,Lock-Free (DWCAS 6),1934933(0),2341339(1),1992991(2),2164162(3),1053052(4),2048046(5),2154152(6),2186184(7),2181179(8),1926925(18),2334332(19),1959958(20),2135133(21),1037036(22),2029027(23),2134132(24),2155153(25),1855854(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     45255210,502836,411995,Lock-Free (DWCAS 7),2492490(0),3040037(1),2486484(2),2698696(3),1231230(4),2519517(5),2759757(6),2790788(7),2728726(8),2455453(18),3041038(19),2436434(20),2650648(21),1228227(22),2500498(23),2703701(24),2753751(25),2737735(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     54809755,608997,505319,Lock-Free (DWCAS 8),3001999(0),3708705(1),3033030(2),3341338(3),1471470(4),3071068(5),3244241(6),3315312(7),3317314(8),2981979(18),3695692(19),3022019(20),3264261(21),1447446(22),3073070(23),3222219(24),3292289(25),3306303(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     61921860,688021,574454,Lock-Free (DWCAS 9),3362359(0),4170166(1),3479476(2),3735732(3),1633632(4),3555552(5),3639636(6),3724721(7),3760757(8),3336333(18),4139135(19),3432429(20),3778775(21),1623622(22),3478475(23),3585582(24),3710707(25),3774771(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     68404336,760048,641276,Lock-Free (DWCAS 10),3734731(0),4705701(1),3918915(2),4184180(3),1772771(4),3915912(5),4075071(6),4208204(7),4247243(8),3681678(18),3803800(19),3853850(20),4219215(21),1761760(22),3871868(23),4079075(24),4151147(25),4219215(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     19727708,219197,28052,PThread Mutex,1020019(0),1062061(1),1087086(2),1092091(3),1091090(4),1089088(5),1146145(6),1158157(7),1088087(8),1075074(18),1070069(19),1095094(20),1087086(21),1097096(22),1089088(23),1136135(24),1153152(25),1091090(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     15456441,171738,157736,PThread Spinlock (private),728728(0),738738(1),859859(2),924924(3),920920(4),937937(5),1292291(6),696696(7),626626(8),729729(18),741741(19),858858(20),927927(21),921921(22),936936(23),1287286(24),696696(25),628628(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     16511495,183461,260312,PThread Spinlock (shared),710710(0),790790(1),1225224(2),1356355(3),1187186(4),1226225(5),656656(6),599599(7),504504(8),709709(18),788788(19),1217216(20),1358357(21),1182181(22),1225224(23),654654(24),611611(25),506506(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 1596595,15966,34564,GCC Spinlock (atomic),51051(0),102102(1),68068(2),55055(3),92092(4),180180(5),60060(6),42042(7),54054(8),81081(9),54054(18),102102(19),70070(20),90090(21),92092(22),181181(23),42042(24),45045(25),54054(26),80080(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 1524523,15245,41088,GCC Spinlock (sync),109109(0),190190(1),106106(2),72072(3),73073(4),72072(5),29029(6),35035(7),54054(8),28028(9),92092(18),188188(19),107107(20),75075(21),74074(22),73073(23),29029(24),36036(25),53053(26),28028(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 22586564,225866,2597236,Lock-Free (DWCAS 0),152152(0),173173(1),156156(2),159159(3),114114(4),168168(5),173173(6),182182(7),174174(8),9905896(9),154154(18),173173(19),156156(20),158158(21),114114(22),166166(23),172172(24),182182(25),177177(26),9774765(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 20177157,201772,2365193,Lock-Free (DWCAS 1),123123(0),143143(1),128128(2),130130(3),90090(4),131131(5),138138(6),140140(7),140140(8),9231222(9),122122(18),137137(19),124124(20),129129(21),89089(22),130130(23),132132(24),136136(25),139139(26),8642634(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 20160140,201601,2354975,Lock-Free (DWCAS 2),125125(0),138138(1),135135(2),133133(3),95095(4),134134(5),143143(6),140140(7),141141(8),9127118(9),122122(18),141141(19),131131(20),135135(21),94094(22),132132(23),135135(24),139139(25),137137(26),8680672(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 21099078,210991,2474693,Lock-Free (DWCAS 3),125125(0),142142(1),132132(2),137137(3),96096(4),135135(5),140140(6),147147(7),150150(8),9582573(9),123123(18),139139(19),132132(20),136136(21),95095(22),132132(23),138138(24),148148(25),145145(26),9122113(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 22167145,221671,2592374,Lock-Free (DWCAS 4),131131(0),157157(1),150150(2),151151(3),99099(4),146146(5),143143(6),152152(7),151151(8),9971962(9),134134(18),161161(19),147147(20),153153(21),92092(22),145145(23),141141(24),155155(25),153153(26),9631622(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 22872850,228728,2631971,Lock-Free (DWCAS 5),150150(0),178178(1),171171(2),184184(3),108108(4),168168(5),167167(6),169169(7),167167(8),10102092(9),153153(18),177177(19),168168(20),178178(21),109109(22),169169(23),167167(24),172172(25),174174(26),9838829(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 22890868,228909,2674559,Lock-Free (DWCAS 6),136136(0),164164(1),153153(2),159159(3),92092(4),153153(5),159159(6),161161(7),160160(8),10335325(9),140140(18),157157(19),152152(20),156156(21),93093(22),149149(23),154154(24),161161(25),164164(26),9889880(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 23802779,238028,2756688,Lock-Free (DWCAS 7),154154(0),170170(1),166166(2),172172(3),122122(4),169169(5),168168(6),177177(7),181181(8),10626616(9),149149(18),173173(19),160160(20),169169(21),117117(22),162162(23),171171(24),180180(25),171171(26),10242232(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 26249223,262492,3080508,Lock-Free (DWCAS 8),161161(0),172172(1),162162(2),176176(3),124124(4),162162(5),173173(6),180180(7),175175(8),11831820(9),160160(18),181181(19),155155(20),172172(21),117117(22),164164(23),175175(24),172172(25),179179(26),11454443(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 28018991,280190,3248736,Lock-Free (DWCAS 9),177177(0),202202(1),191191(2),206206(3),146146(4),197197(5),197197(6),201201(7),202202(8),12494482(9),177177(18),196196(19),201201(20),200200(21),140140(22),193193(23),191191(24),204204(25),203203(26),12097085(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 31192161,311922,3658208,Lock-Free (DWCAS 10),182182(0),208208(1),206206(2),201201(3),147147(4),201201(5),204204(6),209209(7),212212(8),14006993(9),185185(18),214214(19),200200(20),209209(21),146146(22),194194(23),196196(24),209209(25),209209(26),13649636(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 32158126,321581,39867,PThread Mutex,1635634(0),1595594(1),1633632(2),1615614(3),1661660(4),1626625(5),1602601(6),1590589(7),1585584(8),1495494(9),1667666(18),1611610(19),1625624(20),1602601(21),1675674(22),1626625(23),1600599(24),1607606(25),1600599(26),1496495(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 9322313,93223,1262080,PThread Spinlock (private),2002(0),1001(1),3003(2),2002(3),3003(4),2002(5),2002(6),2002(7),3003(8),5375370(9),2002(18),2002(19),2002(20),2002(21),2002(22),2002(23),2002(24),2002(25),3003(26),3907904(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 9372363,93724,864855,PThread Spinlock (shared),117117(0),237237(1),157157(2),160160(3),122122(4),123123(5),132132(6),149149(7),136136(8),3768765(9),120120(18),245245(19),162162(20),157157(21),118118(22),130130(23),136136(24),150150(25),141141(26),2908906(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             1575574,14323,36372,GCC Spinlock (atomic),47047(0),90090(1),49049(2),67067(3),79079(4),180180(5),48048(6),43043(7),51051(8),53053(9),50050(10),50050(18),86086(19),99099(20),67067(21),92092(22),183183(23),47047(24),42042(25),50050(26),52052(27),49049(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             1478477,13441,44582,GCC Spinlock (sync),100100(0),184184(1),106106(2),73073(3),66066(4),73073(5),23023(6),31031(7),49049(8),16016(9),17017(10),97097(18),183183(19),106106(20),72072(21),71071(22),73073(23),24024(24),30030(25),50050(26),16016(27),17017(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             18714696,170134,1416803,Lock-Free (DWCAS 0),139139(0),143143(1),113113(2),126126(3),111111(4),140140(5),161161(6),164164(7),158158(8),3998995(9),4126122(10),137137(18),144144(19),111111(20),123123(21),113113(22),137137(23),158158(24),165165(25),154154(26),3979976(27),4110106(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             16036020,145782,1248284,Lock-Free (DWCAS 1),97097(0),109109(1),97097(2),106106(3),85085(4),105105(5),108108(6),109109(7),109109(8),3562559(9),3671668(10),95095(18),111111(19),96096(20),100100(21),88088(22),100100(23),103103(24),105105(25),109109(26),3424421(27),3543540(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             14633619,133033,1166227,Lock-Free (DWCAS 2),77077(0),86086(1),71071(2),76076(3),65065(4),80080(5),87087(6),88088(7),87087(8),3297294(9),3438435(10),75075(18),85085(19),72072(20),74074(21),65065(22),81081(23),85085(24),84084(25),90090(26),3180177(27),3288285(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             14768754,134261,1144335,Lock-Free (DWCAS 3),88088(0),105105(1),98098(2),99099(3),81081(4),100100(5),104104(6),111111(7),107107(8),3035032(9),3562559(10),88088(18),106106(19),99099(20),98098(21),84084(22),96096(23),98098(24),105105(25),107107(26),2950948(27),3444441(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             15190175,138092,1174235,Lock-Free (DWCAS 4),97097(0),116116(1),101101(2),104104(3),75075(4),99099(5),106106(6),109109(7),109109(8),3303300(9),3478475(10),98098(18),108108(19),96096(20),100100(21),76076(22),104104(23),100100(24),104104(25),109109(26),3220217(27),3375372(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             15361346,139649,1182574,Lock-Free (DWCAS 5),105105(0),108108(1),108108(2),107107(3),78078(4),105105(5),113113(6),117117(7),114114(8),3264261(9),3562559(10),97097(18),112112(19),100100(20),110110(21),79079(22),103103(23),106106(24),110110(25),111111(26),3197194(27),3452449(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             16675659,151597,1278825,Lock-Free (DWCAS 6),108108(0),136136(1),114114(2),118118(3),85085(4),115115(5),125125(6),122122(7),121121(8),3532529(9),3853850(10),109109(18),125125(19),119119(20),118118(21),89089(22),116116(23),120120(24),127127(25),122122(26),3455452(27),3742739(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             16805789,152780,1336138,Lock-Free (DWCAS 7),89089(0),99099(1),91091(2),98098(3),76076(4),96096(5),99099(6),102102(7),95095(8),3677674(9),3969966(10),90090(18),95095(19),89089(20),94094(21),79079(22),91091(23),95095(24),99099(25),98098(26),3598595(27),3882879(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             18344326,166767,1477151,Lock-Free (DWCAS 8),89089(0),94094(1),96096(2),95095(3),77077(4),97097(5),97097(6),101101(7),98098(8),4036032(9),4386382(10),86086(18),91091(19),90090(20),92092(21),75075(22),95095(23),92092(24),99099(25),97097(26),3965962(27),4293289(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             20051031,182282,1622366,Lock-Free (DWCAS 9),88088(0),101101(1),95095(2),105105(3),81081(4),92092(5),102102(6),106106(7),107107(8),4439435(9),4847843(10),93093(18),99099(19),91091(20),103103(21),77077(22),95095(23),101101(24),105105(25),106106(26),4334330(27),4680676(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             22162140,201474,1775323,Lock-Free (DWCAS 10),112112(0),124124(1),120120(2),117117(3),99099(4),113113(5),110110(6),122122(7),122122(8),4873869(9),5316311(10),102102(18),121121(19),122122(20),125125(21),99099(22),113113(23),120120(24),124124(25),128128(26),4737733(27),5139134(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             24972948,227027,25141,PThread Mutex,1123122(0),1098097(1),1122121(2),1118117(3),1124123(4),1131130(5),1125124(6),1128127(7),1113112(8),1217216(9),1159158(10),1146145(18),1110109(19),1129128(20),1116115(21),1125124(22),1136135(23),1124123(24),1136135(25),1130129(26),1192191(27),1168167(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             10612602,96478,388753,PThread Spinlock (private),272272(0),270270(1),251251(2),270270(3),282282(4),307307(5),353353(6),246246(7),363363(8),1155154(9),1540539(10),275275(18),272272(19),252252(20),271271(21),286286(22),310310(23),356356(24),247247(25),363363(26),1137136(27),1528527(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             9998989,90900,369926,PThread Spinlock (shared),254254(0),259259(1),221221(2),247247(3),265265(4),304304(5),352352(6),148148(7),333333(8),1274273(9),1262261(10),265265(18),270270(19),230230(20),256256(21),277277(22),319319(23),362362(24),154154(25),345345(26),1304303(27),1292291(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         1482481,12354,61328,GCC Spinlock (atomic),36036(0),60060(1),57057(2),49049(3),68068(4),264264(5),35035(6),31031(7),36036(8),33033(9),33033(10),34034(11),38038(18),57057(19),49049(20),51051(21),82082(22),265265(23),38038(24),32032(25),36036(26),31031(27),33033(28),33033(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         1402401,11687,47773,GCC Spinlock (sync),118118(0),165165(1),116116(2),71071(3),55055(4),59059(5),15015(6),24024(7),33033(8),13013(9),12012(10),14014(11),120120(18),165165(19),118118(20),72072(21),59059(22),59059(23),16016(24),25025(25),33033(26),12012(27),13013(28),14014(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         16878862,140657,977223,Lock-Free (DWCAS 0),123123(0),134134(1),114114(2),117117(3),112112(4),128128(5),136136(6),143143(7),142142(8),2449447(9),2484482(10),2377375(11),123123(18),132132(19),112112(20),118118(21),110110(22),128128(23),136136(24),144144(25),143143(26),2437435(27),2469467(28),2363361(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         13188175,109901,812955,Lock-Free (DWCAS 1),69069(0),77077(1),65065(2),68068(3),66066(4),73073(5),75075(6),77077(7),77077(8),2031029(9),2071069(10),1948947(11),67067(18),77077(19),61061(20),68068(21),61061(22),70070(23),73073(24),74074(25),75075(26),1966965(27),2011009(28),1884883(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12766754,106390,781518,Lock-Free (DWCAS 2),68068(0),76076(1),67067(2),69069(3),63063(4),72072(5),77077(6),81081(7),79079(8),1942941(9),2010008(10),1876875(11),67067(18),75075(19),65065(20),65065(21),63063(22),70070(23),74074(24),81081(25),79079(26),1890889(27),1941940(28),1811810(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         13039026,108659,788556,Lock-Free (DWCAS 3),79079(0),87087(1),76076(2),78078(3),66066(4),74074(5),79079(6),89089(7),86086(8),1975974(9),2025023(10),1884883(11),78078(18),86086(19),76076(20),79079(21),62062(22),74074(23),77077(24),86086(25),89089(26),1911910(27),1983982(28),1834833(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12578566,104821,771100,Lock-Free (DWCAS 4),70070(0),76076(1),65065(2),66066(3),61061(4),73073(5),78078(6),79079(7),76076(8),1921920(9),1989988(10),1807806(11),65065(18),72072(19),65065(20),65065(21),57057(22),69069(23),75075(24),76076(25),76076(26),1873872(27),1949948(28),1769768(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11877866,98982,730155,Lock-Free (DWCAS 5),60060(0),64064(1),60060(2),62062(3),61061(4),67067(5),68068(6),75075(7),73073(8),1803802(9),1880879(10),1715714(11),59059(18),65065(19),59059(20),65065(21),60060(22),65065(23),66066(24),73073(25),69069(26),1774773(27),1844843(28),1685684(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12290278,102419,750942,Lock-Free (DWCAS 6),68068(0),76076(1),68068(2),66066(3),64064(4),67067(5),74074(6),76076(7),77077(8),1859858(9),1935934(10),1756755(11),66066(18),76076(19),65065(20),71071(21),60060(22),66066(23),70070(24),74074(25),78078(26),1821820(27),1924923(28),1727726(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12820808,106840,803418,Lock-Free (DWCAS 7),62062(0),68068(1),62062(2),58058(3),56056(4),60060(5),63063(6),63063(7),65065(8),1955954(9),2115113(10),1824823(11),62062(18),65065(19),60060(20),60060(21),55055(22),63063(23),63063(24),64064(25),66066(26),1943942(27),2073071(28),1791790(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         13570557,113088,878347,Lock-Free (DWCAS 8),46046(0),51051(1),46046(2),50050(3),46046(4),49049(5),50050(6),50050(7),56056(8),2153151(9),2275273(10),1941940(11),49049(18),49049(19),46046(20),48048(21),46046(22),48048(23),50050(24),56056(25),52052(26),2131129(27),2254252(28),1925924(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         15224209,126868,987678,Lock-Free (DWCAS 9),50050(0),57057(1),56056(2),52052(3),51051(4),51051(5),53053(6),57057(7),57057(8),2419417(9),2565563(10),2203201(11),49049(18),56056(19),54054(20),55055(21),52052(22),53053(23),52052(24),59059(25),55055(26),2366364(27),2522520(28),2177175(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         16960944,141341,1094309,Lock-Free (DWCAS 10),65065(0),68068(1),67067(2),64064(3),60060(4),64064(5),66066(6),69069(7),53053(8),2652650(9),2846844(10),2486484(11),59059(18),68068(19),64064(20),64064(21),59059(22),63063(23),64064(24),67067(25),52052(26),2603601(27),2776774(28),2457455(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         24971947,208100,26945,PThread Mutex,1001000(0),1039038(1),1035034(2),1032031(3),1038037(4),1038037(5),1026025(6),1032031(7),1026025(8),1096095(9),1059058(10),1111110(11),1040039(18),986986(19),1038037(20),1020019(21),1038037(22),1041040(23),1013012(24),1027026(25),1036035(26),1087086(27),1037036(28),1074073(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         8431423,70262,246031,PThread Spinlock (private),199199(0),201201(1),168168(2),212212(3),206206(4),216216(5),201201(6),204204(7),244244(8),831831(9),790790(10),718718(11),198198(18),204204(19),168168(20),216216(21),208208(22),218218(23),205205(24),206206(25),254254(26),837837(27),796796(28),723723(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         8335327,69461,239088,PThread Spinlock (shared),196196(0),198198(1),164164(2),208208(3),204204(4),206206(5),198198(6),195195(7),229229(8),815815(9),764764(10),702702(11),209209(18),211211(19),175175(20),224224(21),214214(22),225225(23),204204(24),210210(25),260260(26),826826(27),777777(28),713713(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     2846844,21899,158416,GCC Spinlock (atomic),13013(0),13013(1),16016(2),15015(3),16016(4),16016(5),15015(6),14014(7),15015(8),510510(9),276276(10),275275(11),236236(12),13013(18),13013(19),16016(20),16016(21),16016(22),15015(23),15015(24),14014(25),15015(26),521521(27),284284(28),226226(29),250250(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     2474472,19034,114511,GCC Spinlock (sync),24024(0),26026(1),20020(2),23023(3),26026(4),24024(5),18018(6),18018(7),16016(8),311311(9),246246(10),283283(11),212212(12),27027(18),26026(19),21021(20),24024(21),26026(22),26026(23),18018(24),17017(25),16016(26),311311(27),244244(28),283283(29),186186(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     15724709,120959,702491,Lock-Free (DWCAS 0),135135(0),134134(1),143143(2),144144(3),146146(4),144144(5),156156(6),156156(7),156156(8),1619618(9),1676675(10),1582581(11),1683682(12),135135(18),134134(19),141141(20),144144(21),148148(22),142142(23),153153(24),155155(25),157157(26),1607606(27),1662661(28),1575574(29),1690689(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     12298286,94602,590405,Lock-Free (DWCAS 1),85085(0),83083(1),85085(2),87087(3),85085(4),86086(5),95095(6),97097(7),94094(8),1345344(9),1386385(10),1309308(11),1406405(12),79079(18),79079(19),80080(20),84084(21),84084(22),84084(23),96096(24),95095(25),94094(26),1301300(27),1339338(28),1263262(29),1373372(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     13305292,102348,624852,Lock-Free (DWCAS 2),97097(0),95095(1),99099(2),100100(3),99099(4),100100(5),113113(6),119119(7),117117(8),1437436(9),1481480(10),1389388(11),1500499(12),93093(18),93093(19),96096(20),97097(21),101101(22),101101(23),113113(24),116116(25),116116(26),1383382(27),1429428(28),1346345(29),1470469(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     11559548,88920,554072,Lock-Free (DWCAS 3),74074(0),77077(1),78078(2),81081(3),78078(4),80080(5),93093(6),95095(7),93093(8),1260259(9),1303302(10),1219218(11),1315314(12),72072(18),72072(19),79079(20),81081(21),80080(22),76076(23),91091(24),92092(25),96096(26),1231230(27),1267266(28),1184183(29),1289288(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     12024012,92492,571656,Lock-Free (DWCAS 4),80080(0),82082(1),85085(2),87087(3),84084(4),87087(5),98098(6),102102(7),100100(8),1303302(9),1366365(10),1245244(11),1347346(12),79079(18),81081(19),82082(20),88088(21),89089(22),85085(23),97097(24),98098(25),100100(26),1275274(27),1326325(28),1221220(29),1333332(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10768758,82837,521053,Lock-Free (DWCAS 5),67067(0),72072(1),71071(2),72072(3),75075(4),73073(5),82082(6),82082(7),76076(8),1178177(9),1235234(10),1121120(11),1218217(12),65065(18),69069(19),69069(20),72072(21),72072(22),74074(23),81081(24),78078(25),80080(26),1167166(27),1212211(28),1103102(29),1202201(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     11143132,85716,533617,Lock-Free (DWCAS 6),69069(0),73073(1),75075(2),80080(3),76076(4),78078(5),85085(6),95095(7),95095(8),1200199(9),1259258(10),1160159(11),1256255(12),67067(18),69069(19),78078(20),76076(21),76076(22),78078(23),88088(24),93093(25),91091(26),1177176(27),1237236(28),1142141(29),1267266(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10815805,83198,520014,Lock-Free (DWCAS 7),72072(0),74074(1),70070(2),72072(3),70070(4),70070(5),85085(6),88088(7),88088(8),1199198(9),1233232(10),1116115(11),1202201(12),73073(18),71071(19),71071(20),73073(21),72072(22),71071(23),84084(24),87087(25),84084(26),1179178(27),1212211(28),1099098(29),1198197(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     11630619,89466,569780,Lock-Free (DWCAS 8),69069(0),72072(1),62062(2),68068(3),65065(4),69069(5),92092(6),91091(7),92092(8),1253252(9),1344343(10),1215214(11),1358357(12),71071(18),71071(19),63063(20),68068(21),65065(22),74074(23),89089(24),89089(25),89089(26),1233232(27),1320319(28),1201200(29),1344343(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     12105093,93116,619388,Lock-Free (DWCAS 9),57057(0),61061(1),59059(2),60060(3),62062(4),58058(5),64064(6),63063(7),66066(8),1351350(9),1449448(10),1310309(11),1434433(12),52052(18),57057(19),56056(20),63063(21),62062(22),60060(23),68068(24),66066(25),67067(26),1328327(27),1421420(28),1295294(29),1412411(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     13362349,102787,682582,Lock-Free (DWCAS 10),64064(0),66066(1),67067(2),72072(3),68068(4),68068(5),68068(6),72072(7),75075(8),1478477(9),1579578(10),1461460(11),1582581(12),63063(18),68068(19),65065(20),74074(21),66066(22),65065(23),67067(24),69069(25),70070(26),1463462(27),1569568(28),1437436(29),1561560(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     24869845,191306,26758,PThread Mutex,943943(0),960960(1),961961(2),957957(3),953953(4),964964(5),912912(6),976976(7),904904(8),973973(9),959959(10),990990(11),990990(12),962962(18),967967(19),914914(20),948948(21),958958(22),963963(23),899899(24),995995(25),920920(26),974974(27),941941(28),977977(29),985985(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     13818805,106298,150061,PThread Spinlock (private),577577(0),642642(1),626626(2),621621(3),623623(4),607607(5),644644(6),641641(7),615615(8),301301(9),440440(10),276276(11),248248(12),571571(18),647647(19),632632(20),626626(21),627627(22),599599(23),650650(24),648648(25),636636(26),309309(27),458458(28),286286(29),255255(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     9432423,72557,46726,PThread Spinlock (shared),387387(0),455455(1),335335(2),338338(3),387387(4),404404(5),258258(6),333333(7),340340(8),319319(9),357357(10),350350(11),381381(12),394394(18),460460(19),344344(20),346346(21),402402(22),409409(23),263263(24),346346(25),361361(26),332332(27),372372(28),358358(29),392392(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 1754753,12534,11855,GCC Spinlock (atomic),71071(0),61061(1),68068(2),77077(3),80080(4),66066(5),48048(6),41041(7),44044(8),71071(9),71071(10),60060(11),62062(12),61061(13),71071(18),61061(19),67067(20),77077(21),79079(22),61061(23),48048(24),41041(25),44044(26),70070(27),69069(28),59059(29),63063(30),62062(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 1601600,11440,13351,GCC Spinlock (sync),80080(0),73073(1),58058(2),69069(3),75075(4),70070(5),49049(6),49049(7),42042(8),50050(9),49049(10),47047(11),47047(12),47047(13),79079(18),73073(19),49049(20),69069(21),76076(22),70070(23),48048(24),48048(25),42042(26),50050(27),49049(28),47047(29),47047(30),48048(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 15663648,111883,568335,Lock-Free (DWCAS 0),149149(0),147147(1),158158(2),158158(3),160160(4),157157(5),167167(6),168168(7),172172(8),1283282(9),1306305(10),1285284(11),1295294(12),1247246(13),146146(18),145145(19),158158(20),159159(21),161161(22),154154(23),165165(24),170170(25),170170(26),1273272(27),1294293(28),1276275(29),1294293(30),1241240(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 11586575,82761,454114,Lock-Free (DWCAS 1),90090(0),90090(1),89089(2),92092(3),93093(4),92092(5),104104(6),105105(7),101101(8),1006005(9),1025024(10),996996(11),1015014(12),971971(13),85085(18),86086(19),87087(20),95095(21),90090(22),92092(23),100100(24),101101(25),101101(26),972972(27),996996(28),971971(29),986986(30),947947(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10826816,77334,431422,Lock-Free (DWCAS 2),78078(0),80080(1),80080(2),82082(3),80080(4),81081(5),96096(6),90090(7),94094(8),956956(9),971971(10),939939(11),956956(12),915915(13),73073(18),76076(19),76076(20),79079(21),78078(22),77077(23),89089(24),92092(25),92092(26),920920(27),937937(28),908908(29),929929(30),892892(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 11974963,85535,468514,Lock-Free (DWCAS 3),91091(0),91091(1),92092(2),94094(3),93093(4),94094(5),111111(6),112112(7),112112(8),1039038(9),1065064(10),1023022(11),1046045(12),989989(13),90090(18),92092(19),90090(20),95095(21),91091(22),88088(23),106106(24),109109(25),111111(26),1020019(27),1042041(28),990990(29),1026025(30),968968(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 11122111,79444,437264,Lock-Free (DWCAS 4),83083(0),86086(1),82082(2),86086(3),84084(4),84084(5),100100(6),100100(7),100100(8),983983(9),1006005(10),940940(11),971971(12),903903(13),83083(18),85085(19),86086(20),86086(21),89089(22),83083(23),97097(24),102102(25),98098(26),957957(27),992992(28),906906(29),953953(30),887887(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10058048,71843,397946,Lock-Free (DWCAS 5),72072(0),75075(1),77077(2),78078(3),77077(4),76076(5),90090(6),89089(7),91091(8),881881(9),912912(10),849849(11),878878(12),816816(13),71071(18),76076(19),72072(20),75075(21),75075(22),77077(23),85085(24),86086(25),85085(26),869869(27),903903(28),836836(29),870870(30),807807(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10084074,72029,392875,Lock-Free (DWCAS 6),79079(0),80080(1),76076(2),78078(3),80080(4),79079(5),94094(6),98098(7),97097(8),878878(9),904904(10),834834(11),884884(12),809809(13),74074(18),80080(19),77077(20),77077(21),77077(22),80080(23),95095(24),93093(25),95095(26),869869(27),893893(28),820820(29),869869(30),805805(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10547537,75340,409818,Lock-Free (DWCAS 7),82082(0),79079(1),80080(2),85085(3),83083(4),87087(5),99099(6),105105(7),104104(8),903903(9),979979(10),863863(11),915915(12),832832(13),77077(18),80080(19),83083(20),84084(21),85085(22),83083(23),103103(24),99099(25),102102(26),899899(27),961961(28),851851(29),914914(30),820820(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10591581,75654,414553,Lock-Free (DWCAS 8),81081(0),82082(1),81081(2),85085(3),83083(4),81081(5),94094(6),101101(7),97097(8),903903(9),950950(10),875875(11),956956(12),835835(13),81081(18),84084(19),79079(20),82082(21),82082(22),84084(23),95095(24),94094(25),99099(26),892892(27),948948(28),870870(29),951951(30),836836(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10586576,75618,443136,Lock-Free (DWCAS 9),61061(0),63063(1),66066(2),68068(3),67067(4),63063(5),70070(6),72072(7),77077(8),936936(9),991991(10),908908(11),987987(12),877877(13),60060(18),66066(19),67067(20),62062(21),66066(22),62062(23),67067(24),72072(25),70070(26),930930(27),988988(28),903903(29),989989(30),868868(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 11424413,81603,479196,Lock-Free (DWCAS 10),67067(0),70070(1),72072(2),76076(3),78078(4),71071(5),78078(6),65065(7),71071(8),1013012(9),1058057(10),986986(11),1085084(12),951951(13),65065(18),68068(19),72072(20),74074(21),74074(22),73073(23),73073(24),62062(25),72072(26),1005004(27),1058057(28),973973(29),1071070(30),938938(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 24014991,171536,19169,PThread Mutex,838838(0),839839(1),841841(2),866866(3),852852(4),862862(5),838838(6),845845(7),823823(8),871871(9),834834(10),881881(11),883883(12),890890(13),866866(18),845845(19),848848(20),866866(21),849849(22),856856(23),838838(24),848848(25),842842(26),873873(27),852852(28),882882(29),890890(30),873873(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10542532,75304,89073,PThread Spinlock (private),379379(0),520520(1),394394(2),402402(3),463463(4),436436(5),387387(6),303303(7),331331(8),189189(9),519519(10),345345(11),418418(12),255255(13),398398(18),442442(19),414414(20),390390(21),444444(22),387387(23),341341(24),328328(25),346346(26),189189(27),502502(28),348348(29),413413(30),249249(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 11266255,80473,321720,PThread Spinlock (shared),728728(0),654654(1),617617(2),667667(3),674674(4),740740(5),466466(6),535535(7),556556(8),2002(9),4004(10),3003(11),3003(12),2002(13),673673(18),699699(19),688688(20),618618(21),677677(22),597597(23),495495(24),579579(25),563563(26),3003(27),4004(28),3003(29),3003(30),2002(31)

Expect the unexpected - pthread mutex is the winner!

Who’da thunk it?

As long as we’re on one NUMA node, lock-free wins.

When we go over two NUMA nodes, pthread mutex wins, and the more cores we have, the more it wins by, AND it’s extremely fair.

Hmm. There seems to be a bug with the logical process ets, too - not all of them were generated or not all of them were run. Vexing!

Here’s the results with PRNG;

Freelist Push One Pop One

                                   M                                   
                 N                                   N                 
                 S                                   S                 
                L3U                                 L3U                
L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U
L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D
L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I
 P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P 
L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type,per-thread total ops
  1                                                                     158223065,31644613,0,GCC Spinlock (atomic),158223065(18)
  1                                                                     169606437,33921287,0,GCC Spinlock (sync),169606437(18)
  1                                                                     174496322,34899264,0,Lock-Free (DWCAS 0),174496322(18)
  1                                                                     174560386,34912077,0,Lock-Free (DWCAS 1),174560386(18)
  1                                                                     174746572,34949314,0,Lock-Free (DWCAS 2),174746572(18)
  1                                                                     174697523,34939505,0,Lock-Free (DWCAS 3),174697523(18)
  1                                                                     174746572,34949314,0,Lock-Free (DWCAS 4),174746572(18)
  1                                                                     174737563,34947513,0,Lock-Free (DWCAS 5),174737563(18)
  1                                                                     174779605,34955921,0,Lock-Free (DWCAS 6),174779605(18)
  1                                                                     174738564,34947713,0,Lock-Free (DWCAS 7),174738564(18)
  1                                                                     174744570,34948914,0,Lock-Free (DWCAS 8),174744570(18)
  1                                                                     174806632,34961326,0,Lock-Free (DWCAS 9),174806632(18)
  1                                                                     174793619,34958724,0,Lock-Free (DWCAS 10),174793619(18)
  1                                                                     144416272,28883254,0,PThread Mutex,144416272(18)
  1                                                                     218200983,43640197,0,PThread Spinlock (private),218200983(18)
  1                                                                     219117899,43823580,0,PThread Spinlock (shared),219117899(18)
  1   1                                                                 32548516,3254852,2628255,GCC Spinlock (atomic),6981975(18),25566541(19)
  1   1                                                                 32996964,3299696,3328707,GCC Spinlock (sync),4729725(18),28267239(19)
  1   1                                                                 25684659,2568466,749858,Lock-Free (DWCAS 0),15493478(18),10191181(19)
  1   1                                                                 42607565,4260756,57899,Lock-Free (DWCAS 1),21099078(18),21508487(19)
  1   1                                                                 99864765,9986476,420300,Lock-Free (DWCAS 2),51418367(18),48446398(19)
  1   1                                                                 115634519,11563452,572055,Lock-Free (DWCAS 3),59839780(18),55794739(19)
  1   1                                                                 85869784,8586978,264156,Lock-Free (DWCAS 4),43868825(18),42000959(19)
  1   1                                                                 130603473,13060347,546857,Lock-Free (DWCAS 5),67235168(18),63368305(19)
  1   1                                                                 141439298,14143930,273782,Lock-Free (DWCAS 6),69751682(18),71687616(19)
  1   1                                                                 141374233,14137423,618771,Lock-Free (DWCAS 7),72874802(18),68499431(19)
  1   1                                                                 149274125,14927412,923980,Lock-Free (DWCAS 8),77903826(18),71370299(19)
  1   1                                                                 127346219,12734622,161806,Lock-Free (DWCAS 9),63101038(18),64245181(19)
  1   1                                                                 153150998,15315100,924122,Lock-Free (DWCAS 10),79842763(18),73308235(19)
  1   1                                                                 24530506,2453051,155719,PThread Mutex,11714703(18),12815803(19)
  1   1                                                                 48485437,4848544,2286097,PThread Spinlock (private),32325293(18),16160144(19)
  1   1                                                                 48915867,4891587,1693232,PThread Spinlock (shared),30444414(18),18471453(19)
  1   1   1                                                             22946924,1529795,1560442,GCC Spinlock (atomic),1779778(18),12728716(19),8438430(20)
  1   1   1                                                             21394373,1426292,1548376,GCC Spinlock (sync),1500499(18),12434422(19),7459452(20)
  1   1   1                                                             24376352,1625090,63845,Lock-Free (DWCAS 0),8108100(18),8359351(19),7908901(20)
  1   1   1                                                             26786760,1785784,86665,Lock-Free (DWCAS 1),8592584(18),9001993(19),9192183(20)
  1   1   1                                                             36183147,2412210,101624,Lock-Free (DWCAS 2),12251239(18),12285273(19),11646635(20)
  1   1   1                                                             47835788,3189053,752890,Lock-Free (DWCAS 3),14260246(18),14561547(19),19013995(20)
  1   1   1                                                             81097016,5406468,371761,Lock-Free (DWCAS 4),26455429(18),26105079(19),28536508(20)
  1   1   1                                                             70610540,4707369,240393,Lock-Free (DWCAS 5),24067043(18),22556534(19),23986963(20)
  1   1   1                                                             81305224,5420348,442454,Lock-Free (DWCAS 6),27560533(18),25359334(19),28385357(20)
  1   1   1                                                             109843734,7322916,93510,Lock-Free (DWCAS 7),36723687(18),36876840(19),36243207(20)
  1   1   1                                                             97912815,6527521,628217,Lock-Free (DWCAS 8),32496464(18),30490460(19),34925891(20)
  1   1   1                                                             106760654,7117377,945930,Lock-Free (DWCAS 9),36179143(18),31985954(19),38595557(20)
  1   1   1                                                             112171059,7478071,1007422,Lock-Free (DWCAS 10),36773737(18),34177143(19),41220179(20)
  1   1   1                                                             21244223,1416282,140792,PThread Mutex,7639632(18),6683677(19),6920914(20)
  1   1   1                                                             35119084,2341272,248996,PThread Spinlock (private),10861851(18),11638627(19),12618606(20)
  1   1   1                                                             35747712,2383181,341546,PThread Spinlock (shared),10549539(18),12358346(19),12839827(20)
  1   1   1   1                                                         19341322,967066,1755795,GCC Spinlock (atomic),1112111(18),7780773(19),10431421(20),17017(21)
  1   1   1   1                                                         19661642,983082,1248555,GCC Spinlock (sync),4423419(18),7896889(19),7327320(20),14014(21)
  1   1   1   1                                                         21188167,1059408,37158,Lock-Free (DWCAS 0),5191186(18),5369364(19),5407402(20),5220215(21)
  1   1   1   1                                                         21214193,1060710,66674,Lock-Free (DWCAS 1),5302297(18),5479474(19),5396391(20),5036031(21)
  1   1   1   1                                                         33526493,1676325,975372,Lock-Free (DWCAS 2),10060050(18),8875867(19),10325315(20),4265261(21)
  1   1   1   1                                                         50917867,2545893,3220670,Lock-Free (DWCAS 3),23719696(18),7326319(19),16781765(20),3090087(21)
  1   1   1   1                                                         64334270,3216714,6092551,Lock-Free (DWCAS 4),41857816(18),2290288(19),10998988(20),9187178(21)
  1   1   1   1                                                         75672597,3783630,5734953,Lock-Free (DWCAS 5),41415374(18),1953952(19),18703685(20),13599586(21)
  1   1   1   1                                                         75375300,3768765,2814102,Lock-Free (DWCAS 6),8429421(18),27569542(19),17243226(20),22133111(21)
  1   1   1   1                                                         83066984,4153349,2989130,Lock-Free (DWCAS 7),9669660(18),30492462(19),19919900(20),22984962(21)
  1   1   1   1                                                         84158074,4207904,502333,Lock-Free (DWCAS 8),19469450(18),20211191(19),22613591(20),21863842(21)
  1   1   1   1                                                         89155066,4457753,422141,Lock-Free (DWCAS 9),21232211(18),21238217(19),23429406(20),23255232(21)
  1   1   1   1                                                         104401297,5220065,886618,Lock-Free (DWCAS 10),28814786(18),27711684(19),23530507(20),24344320(21)
  1   1   1   1                                                         24661637,1233082,139980,PThread Mutex,5613608(18),6396390(19),6526520(20),6125119(21)
  1   1   1   1                                                         31938907,1596945,356438,PThread Spinlock (private),9490481(18),7339332(19),7307300(20),7801794(21)
  1   1   1   1                                                         32472440,1623622,288893,PThread Spinlock (shared),8738730(18),7055048(19),7852845(20),8825817(21)
  1   1   1   1   1                                                     12824812,512992,573336,GCC Spinlock (atomic),18018(18),2934932(19),3301298(20),3201198(21),3369366(22)
  1   1   1   1   1                                                     12349337,493973,154234,GCC Spinlock (sync),1975974(18),2573571(19),3039036(20),2385383(21),2375373(22)
  1   1   1   1   1                                                     19866847,794674,151613,Lock-Free (DWCAS 0),3304301(18),4081077(19),4238234(20),4147143(21),4096092(22)
  1   1   1   1   1                                                     19487468,779499,37413,Lock-Free (DWCAS 1),3842839(18),3822819(19),3872869(20),3890887(21),4058054(22)
  1   1   1   1   1                                                     21724703,868988,48738,Lock-Free (DWCAS 2),4214210(18),4396392(19),4296292(20),4288284(21),4529525(22)
  1   1   1   1   1                                                     32661629,1306465,335867,Lock-Free (DWCAS 3),5617612(18),5731726(19),7038031(20),6715709(21),7558551(22)
  1   1   1   1   1                                                     46617571,1864703,2811183,Lock-Free (DWCAS 4),6104098(18),6249243(19),2139137(20),11860849(21),20264244(22)
  1   1   1   1   1                                                     52366314,2094653,1145612,Lock-Free (DWCAS 5),9966957(18),11530519(19),7687680(20),8336328(21),14844830(22)
  1   1   1   1   1                                                     57827770,2313111,1278041,Lock-Free (DWCAS 6),11025014(18),11442431(19),9398389(20),8991983(21),16969953(22)
  1   1   1   1   1                                                     62279217,2491169,1043566,Lock-Free (DWCAS 7),13396383(18),13243230(19),11132121(20),8797789(21),15709694(22)
  1   1   1   1   1                                                     71929858,2877194,1115505,Lock-Free (DWCAS 8),16692676(18),14657643(19),11548537(20),11546535(21),17484467(22)
  1   1   1   1   1                                                     76633557,3065342,994926,Lock-Free (DWCAS 9),17162145(18),14477463(19),14245231(20),12253241(21),18495477(22)
  1   1   1   1   1                                                     74507433,2980297,360527,Lock-Free (DWCAS 10),14877863(18),13834821(19),15171156(20),14389375(21),16234218(22)
  1   1   1   1   1                                                     22890868,915635,13185,PThread Mutex,4543539(18),4595591(19),4546542(20),4584580(21),4620616(22)
  1   1   1   1   1                                                     30778748,1231150,282177,PThread Spinlock (private),5610605(18),5686681(19),6188182(20),5942937(21),7350343(22)
  1   1   1   1   1                                                     30819789,1232792,291834,PThread Spinlock (shared),5624619(18),5789784(19),5688683(20),6354348(21),7362355(22)
  1   1   1   1   1   1                                                 12214202,407140,448317,GCC Spinlock (atomic),2188186(18),6006(19),2512510(20),2490488(21),2492490(22),2524522(23)
  1   1   1   1   1   1                                                 12136124,404537,445108,GCC Spinlock (sync),2214212(18),6006(19),2416414(20),2427425(21),2494492(22),2577575(23)
  1   1   1   1   1   1                                                 19441422,648047,140785,Lock-Free (DWCAS 0),3328325(18),3464461(19),3196193(20),3376373(21),2628626(22),3447444(23)
  1   1   1   1   1   1                                                 18853835,628461,101953,Lock-Free (DWCAS 1),3162159(18),3252249(19),3165162(20),3260257(21),2693691(22),3320317(23)
  1   1   1   1   1   1                                                 20411391,680380,141358,Lock-Free (DWCAS 2),3458455(18),3674671(19),3445442(20),3484481(21),2780778(22),3567564(23)
  1   1   1   1   1   1                                                 23148125,771604,218056,Lock-Free (DWCAS 3),3871868(18),4262258(19),3931928(20),4081077(21),2902900(22),4098094(23)
  1   1   1   1   1   1                                                 29790761,993025,526599,Lock-Free (DWCAS 4),4766762(18),5856851(19),5112107(20),5726721(21),2712710(22),5615610(23)
  1   1   1   1   1   1                                                 41912871,1397096,1293577,Lock-Free (DWCAS 5),5855850(18),10859849(19),7470463(20),8359351(21),2151149(22),7216209(23)
  1   1   1   1   1   1                                                 50918868,1697296,2690770,Lock-Free (DWCAS 6),5575570(18),19574555(19),7935928(20),8821813(21),1549548(22),7461454(23)
  1   1   1   1   1   1                                                 58268210,1942274,2570933,Lock-Free (DWCAS 7),6262256(18),18582564(19),10523513(20),11728717(21),1350349(22),9820811(23)
  1   1   1   1   1   1                                                 65800735,2193358,2696353,Lock-Free (DWCAS 8),7564557(18),19143124(19),12472460(20),13522509(21),1281280(22),11816805(23)
  1   1   1   1   1   1                                                 71884813,2396160,2715018,Lock-Free (DWCAS 9),9831822(18),19677658(19),13696683(20),14105091(21),1417416(22),13156143(23)
  1   1   1   1   1   1                                                 80208128,2673604,2954704,Lock-Free (DWCAS 10),11269258(18),21101080(19),16284268(20),16242226(21),1654653(22),13656643(23)
  1   1   1   1   1   1                                                 23526503,784217,45156,PThread Mutex,3911908(18),3959956(19),4104100(20),3870867(21),3848845(22),3830827(23)
  1   1   1   1   1   1                                                 23749726,791658,132988,PThread Spinlock (private),4541537(18),3769766(19),3967964(20),3810807(21),3753750(22),3905902(23)
  1   1   1   1   1   1                                                 23893870,796462,122208,PThread Spinlock (shared),4521517(18),3821818(19),3991988(20),3833830(21),3807804(22),3916913(23)
  1   1   1   1   1   1   1                                             10169159,290547,337008,GCC Spinlock (atomic),1717716(18),6006(19),1885884(20),1774773(21),1833832(22),1820819(23),1130129(24)
  1   1   1   1   1   1   1                                             9111102,260317,297365,GCC Spinlock (sync),1243242(18),8008(19),1505504(20),1532531(21),1428427(22),1461460(23),1931930(24)
  1   1   1   1   1   1   1                                             17438421,498241,47563,Lock-Free (DWCAS 0),2439437(18),2573571(19),2593591(20),2517515(21),2303301(22),2515513(23),2495493(24)
  1   1   1   1   1   1   1                                             18036018,515315,84823,Lock-Free (DWCAS 1),2523521(18),2676674(19),2685683(20),2661659(21),2206204(22),2675673(23),2606604(24)
  1   1   1   1   1   1   1                                             18523505,529243,92749,Lock-Free (DWCAS 2),2592590(18),2676674(19),2732730(20),2758756(21),2244242(22),2803801(23),2714712(24)
  1   1   1   1   1   1   1                                             20052032,572915,122323,Lock-Free (DWCAS 3),2835833(18),2991989(19),2879877(20),2952950(21),2324322(22),3033030(23),3034031(24)
  1   1   1   1   1   1   1                                             22511489,643185,197943,Lock-Free (DWCAS 4),3109106(18),3430427(19),3151148(20),3523520(21),2395393(22),3591588(23),3310307(24)
  1   1   1   1   1   1   1                                             27644617,789846,376406,Lock-Free (DWCAS 5),3954951(18),4588584(19),4047043(20),4302298(21),2275273(22),4360356(23),4116112(24)
  1   1   1   1   1   1   1                                             38202164,1091490,861048,Lock-Free (DWCAS 6),4838834(18),6515509(19),5578573(20),6935929(21),1856855(22),6807801(23),5668663(24)
  1   1   1   1   1   1   1                                             45583538,1302387,1281135,Lock-Free (DWCAS 7),4937933(18),9430421(19),6593587(20),8251243(21),1499498(22),7731724(23),7139132(24)
  1   1   1   1   1   1   1                                             53961908,1541769,1781267,Lock-Free (DWCAS 8),5581576(18),12984972(19),8144136(20),9566557(21),1176175(22),8410402(23),8098090(24)
  1   1   1   1   1   1   1                                             59265206,1693292,1859675,Lock-Free (DWCAS 9),6940934(18),13979966(19),9754745(20),9507498(21),1353352(22),8667659(23),9061052(24)
  1   1   1   1   1   1   1                                             66709643,1905990,2064706,Lock-Free (DWCAS 10),8443435(18),15500485(19),10400390(20),10726716(21),1380379(22),9668659(23),10589579(24)
  1   1   1   1   1   1   1                                             20885865,596739,61234,PThread Mutex,3087084(18),3026023(19),3067064(20),2998996(21),2984982(22),3009006(23),2712710(24)
  1   1   1   1   1   1   1                                             23622599,674931,482794,PThread Spinlock (private),4153149(18),4591587(19),2705703(20),2849847(21),3720717(22),3858855(23),1742741(24)
  1   1   1   1   1   1   1                                             23550527,672872,479991,PThread Spinlock (shared),4095091(18),4602598(19),2710708(20),2833831(21),3651648(22),3906903(23),1749748(24)
  1   1   1   1   1   1   1   1                                         8315307,207883,302651,GCC Spinlock (atomic),998998(18),1551550(19),1457456(20),1447446(21),8008(22),1581580(23),643643(24),626626(25)
  1   1   1   1   1   1   1   1                                         8221213,205530,285346,GCC Spinlock (sync),938938(18),1463462(19),1432431(20),1412411(21),8008(22),1553552(23),744744(24),667667(25)
  1   1   1   1   1   1   1   1                                         17855838,446396,177138,Lock-Free (DWCAS 0),2400398(18),2427425(19),2383381(20),2360358(21),2330328(22),2322320(23),1419418(24),2212210(25)
  1   1   1   1   1   1   1   1                                         15967952,399199,71281,Lock-Free (DWCAS 1),2023021(18),1687686(19),2029027(20),2003001(21),2029027(22),1966965(23),2111109(24),2118116(25)
  1   1   1   1   1   1   1   1                                         15802787,395070,129537,Lock-Free (DWCAS 2),2071069(18),2129127(19),2100098(20),2085083(21),2061059(22),2062060(23),1393392(24),1900899(25)
  1   1   1   1   1   1   1   1                                         18282264,457057,89471,Lock-Free (DWCAS 3),2204202(18),2308306(19),2325323(20),2356354(21),1898897(22),2391389(23),2398396(24),2399397(25)
  1   1   1   1   1   1   1   1                                         19879860,496996,118936,Lock-Free (DWCAS 4),2391389(18),2532530(19),2534532(20),2590588(21),1963962(22),2605603(23),2613611(24),2647645(25)
  1   1   1   1   1   1   1   1                                         22937915,573448,195831,Lock-Free (DWCAS 5),2756754(18),3062059(19),2873871(20),3047044(21),1997996(22),3056053(23),3049046(24),3095092(25)
  1   1   1   1   1   1   1   1                                         28449421,711236,386880,Lock-Free (DWCAS 6),3087084(18),3871868(19),3700697(20),3949946(21),1913912(22),3889886(23),3942939(24),4093089(25)
  1   1   1   1   1   1   1   1                                         35676641,891916,669385,Lock-Free (DWCAS 7),3881878(18),5149144(19),4641637(20),5662657(21),1614613(22),5017012(23),4542538(24),5167162(25)
  1   1   1   1   1   1   1   1                                         43459416,1086485,1081822,Lock-Free (DWCAS 8),4544540(18),8378370(19),5526521(20),6316310(21),1241240(22),5487482(23),5339334(24),6625619(25)
  1   1   1   1   1   1   1   1                                         48667619,1216690,1159261,Lock-Free (DWCAS 9),4753749(18),8212204(19),6777771(20),7865858(21),1300299(22),6604598(23),6545539(24),6607601(25)
  1   1   1   1   1   1   1   1                                         55524469,1388112,1438917,Lock-Free (DWCAS 10),5970965(18),10811801(19),7245238(20),7882875(21),1238237(22),6476470(23),7740733(24),8158150(25)
  1   1   1   1   1   1   1   1                                         16652636,416316,32127,PThread Mutex,2089087(18),2095093(19),2038036(20),2029027(21),2047045(22),2220218(23),2061059(24),2073071(25)
  1   1   1   1   1   1   1   1                                         22487465,562187,270822,PThread Spinlock (private),2198196(18),3209206(19),3343340(20),2541539(21),3136133(22),3410407(23),2275273(24),2373371(25)
  1   1   1   1   1   1   1   1                                         22205183,555130,402327,PThread Spinlock (shared),2797795(18),3491488(19),3862859(20),3025022(21),2773771(22),2840838(23),1704703(24),1708707(25)
  1   1   1   1   1   1   1   1   1                                     7368361,163741,200712,GCC Spinlock (atomic),864864(18),1027026(19),937937(20),1153152(21),1124123(22),75075(23),906906(24),397397(25),881881(26)
  1   1   1   1   1   1   1   1   1                                     7539532,167545,95479,GCC Spinlock (sync),744744(18),748748(19),842842(20),820820(21),800800(22),829829(23),567567(24),1032031(25),1152151(26)
  1   1   1   1   1   1   1   1   1                                     16561545,368034,106752,Lock-Free (DWCAS 0),1979978(18),1969968(19),1910909(20),1891890(21),1912911(22),1897896(23),1361360(24),1849848(25),1786785(26)
  1   1   1   1   1   1   1   1   1                                     15798783,351084,62281,Lock-Free (DWCAS 1),1802801(18),1679678(19),1836835(20),1499498(21),1826825(22),1860859(23),1757756(24),1753752(25),1780779(26)
  1   1   1   1   1   1   1   1   1                                     16271255,361583,58850,Lock-Free (DWCAS 2),1831830(18),1774773(19),1868867(20),1541540(21),1861860(22),1863862(23),1833832(24),1832831(25),1861860(26)
  1   1   1   1   1   1   1   1   1                                     17520503,389345,79054,Lock-Free (DWCAS 3),2000999(18),1943942(19),2010008(20),1580579(21),2013011(22),2020018(23),2002000(24),1994993(25),1954953(26)
  1   1   1   1   1   1   1   1   1                                     18407389,409053,89914,Lock-Free (DWCAS 4),2093091(18),2045043(19),2090088(20),1628627(21),2100098(22),2071069(23),2130128(24),2144142(25),2105103(26)
  1   1   1   1   1   1   1   1   1                                     20173153,448292,112269,Lock-Free (DWCAS 5),2352350(18),2265263(19),2305303(20),1716715(21),2295293(22),2303301(23),2309307(24),2338336(25),2287285(26)
  1   1   1   1   1   1   1   1   1                                     22790768,506462,166843,Lock-Free (DWCAS 6),2696694(18),2514512(19),2597595(20),1762761(21),2620618(22),2659657(23),2568566(24),2689687(25),2680678(26)
  1   1   1   1   1   1   1   1   1                                     28160132,625781,307874,Lock-Free (DWCAS 7),3564561(18),3068065(19),3304301(20),1750749(21),3368365(22),3515512(23),3076073(24),3301298(25),3211208(26)
  1   1   1   1   1   1   1   1   1                                     35024990,778333,559993,Lock-Free (DWCAS 8),4317313(18),3320317(19),4601597(20),1482481(21),4461457(22),4444440(23),3749746(24),4315311(25),4332328(26)
  1   1   1   1   1   1   1   1   1                                     41015975,911466,854339,Lock-Free (DWCAS 9),5441436(18),3409406(19),6306300(20),1324323(21),5619614(22),5500495(23),3868865(24),4611607(25),4933929(26)
  1   1   1   1   1   1   1   1   1                                     46750704,1038905,1082977,Lock-Free (DWCAS 10),6938932(18),3202199(19),7563556(20),1322321(21),6109103(22),5818813(23),4776772(24),5282277(25),5736731(26)
  1   1   1   1   1   1   1   1   1                                     17665648,392570,79208,PThread Mutex,1988987(18),2007005(19),1764763(20),1852851(21),1852851(22),1838837(23),2103101(24),2109107(25),2148146(26)
  1   1   1   1   1   1   1   1   1                                     22423401,498298,601857,PThread Spinlock (private),1870869(18),2093091(19),3692689(20),3938935(21),3806803(22),2639637(23),1586585(24),1464463(25),1330329(26)
  1   1   1   1   1   1   1   1   1                                     22283261,495184,598720,PThread Spinlock (shared),1874873(18),2090088(19),3694691(20),3950947(21),3824821(22),2382380(23),1617616(24),1501500(25),1346345(26)
  1   1   1   1   1   1   1   1   1   1                                 3600597,72012,89620,GCC Spinlock (atomic),349349(18),367367(19),168168(20),324324(21),337337(22),446446(23),309309(24),293293(25),271271(26),733733(27)
  1   1   1   1   1   1   1   1   1   1                                 2981979,59640,296400,GCC Spinlock (sync),154154(18),143143(19),145145(20),144144(21),142142(22),109109(23),152152(24),140140(25),148148(26),1703702(27)
  1   1   1   1   1   1   1   1   1   1                                 21975954,439519,2746484,Lock-Free (DWCAS 0),757757(18),751751(19),771771(20),741741(21),762762(22),760760(23),703703(24),749749(25),750750(26),15225210(27)
  1   1   1   1   1   1   1   1   1   1                                 29258229,585165,4897668,Lock-Free (DWCAS 1),354354(18),370370(19),372372(20),369369(21),372372(22),361361(23),218218(24),344344(25),338338(26),26157131(27)
  1   1   1   1   1   1   1   1   1   1                                 29142113,582842,4903491,Lock-Free (DWCAS 2),343343(18),357357(19),356356(20),352352(21),359359(22),352352(23),207207(24),324324(25),316316(26),26173147(27)
  1   1   1   1   1   1   1   1   1   1                                 29011983,580240,4878588,Lock-Free (DWCAS 3),341341(18),355355(19),355355(20),355355(21),360360(22),347347(23),208208(24),328328(25),318318(26),26042016(27)
  1   1   1   1   1   1   1   1   1   1                                 29928899,598578,5103642,Lock-Free (DWCAS 4),324324(18),339339(19),331331(20),326326(21),334334(22),322322(23),171171(24),290290(25),288288(26),27201174(27)
  1   1   1   1   1   1   1   1   1   1                                 28517489,570350,4833507,Lock-Free (DWCAS 5),315315(18),327327(19),329329(20),326326(21),329329(22),322322(23),185185(24),307307(25),296296(26),25778753(27)
  1   1   1   1   1   1   1   1   1   1                                 27378351,547567,4613357,Lock-Free (DWCAS 6),308308(18),320320(19),330330(20),327327(21),334334(22),328328(23),194194(24),316316(25),298298(26),24620596(27)
  1   1   1   1   1   1   1   1   1   1                                 29870841,597417,5048957,Lock-Free (DWCAS 7),333333(18),351351(19),359359(20),357357(21),358358(22),346346(23),180180(24),332332(25),316316(26),26935909(27)
  1   1   1   1   1   1   1   1   1   1                                 29448419,588968,4914364,Lock-Free (DWCAS 8),355355(18),372372(19),382382(20),381381(21),384384(22),372372(23),207207(24),380380(25),357357(26),26255229(27)
  1   1   1   1   1   1   1   1   1   1                                 29711682,594234,4974450,Lock-Free (DWCAS 9),345345(18),365365(19),375375(20),368368(21),376376(22),366366(23),199199(24),396396(25),352352(26),26566540(27)
  1   1   1   1   1   1   1   1   1   1                                 29716687,594334,4957885,Lock-Free (DWCAS 10),360360(18),374374(19),376376(20),373373(21),380380(22),372372(23),210210(24),418418(25),362362(26),26488462(27)
  1   1   1   1   1   1   1   1   1   1                                 30352322,607046,88602,PThread Mutex,3059056(18),3095092(19),3092089(20),3102099(21),3103100(22),3122119(23),3248245(24),2751749(25),2933931(26),2844842(27)
  1   1   1   1   1   1   1   1   1   1                                 11172161,223443,1040939,PThread Spinlock (private),444444(18),471471(19),632632(20),720720(21),701701(22),720720(23),505505(24),466466(25),464464(26),6044038(27)
  1   1   1   1   1   1   1   1   1   1                                 13534521,270690,295831,PThread Spinlock (shared),1208207(18),1233232(19),1639638(20),1831830(21),1814813(22),1911910(23),1289288(24),1186185(25),1187186(26),232232(27)
  1   1   1   1   1   1   1   1   1   1   1                             5632627,102411,456076,GCC Spinlock (atomic),195195(18),186186(19),191191(20),172172(21),193193(22),190190(23),188188(24),187187(25),188188(26),1986985(27),1953952(28)
  1   1   1   1   1   1   1   1   1   1   1                             5734729,104268,466926,GCC Spinlock (sync),202202(18),190190(19),189189(20),173173(21),191191(22),189189(23),188188(24),192192(25),190190(26),2013011(27),2016014(28)
  1   1   1   1   1   1   1   1   1   1   1                             21964943,399363,2424357,Lock-Free (DWCAS 0),284284(18),299299(19),298298(20),287287(21),296296(22),287287(23),181181(24),266266(25),266266(26),9661652(27),9836827(28)
  1   1   1   1   1   1   1   1   1   1   1                             22333311,406060,2481909,Lock-Free (DWCAS 1),274274(18),296296(19),287287(20),281281(21),290290(22),277277(23),184184(24),255255(25),253253(26),9893884(27),10040030(28)
  1   1   1   1   1   1   1   1   1   1   1                             22471449,408572,2519034,Lock-Free (DWCAS 2),259259(18),288288(19),254254(20),272272(21),285285(22),269269(23),156156(24),252252(25),238238(26),10015005(27),10181171(28)
  1   1   1   1   1   1   1   1   1   1   1                             20132112,366038,2224749,Lock-Free (DWCAS 3),229229(18),221221(19),255255(20),252252(21),252252(22),255255(23),260260(24),259259(25),258258(26),8852844(27),9036027(28)
  1   1   1   1   1   1   1   1   1   1   1                             21620599,393102,2473680,Lock-Free (DWCAS 4),207207(18),229229(19),227227(20),224224(21),223223(22),214214(23),135135(24),206206(25),202202(26),9796787(27),9954945(28)
  1   1   1   1   1   1   1   1   1   1   1                             21033012,382418,2308362,Lock-Free (DWCAS 5),246246(18),222222(19),271271(20),280280(21),284284(22),279279(23),289289(24),291291(25),281281(26),9213204(27),9374365(28)
  1   1   1   1   1   1   1   1   1   1   1                             21931910,398762,2477085,Lock-Free (DWCAS 6),209209(18),234234(19),255255(20),259259(21),262262(22),254254(23),147147(24),247247(25),233233(26),9829820(27),9999990(28)
  1   1   1   1   1   1   1   1   1   1   1                             20772752,377686,2308642,Lock-Free (DWCAS 7),228228(18),201201(19),250250(20),250250(21),258258(22),255255(23),261261(24),266266(25),259259(26),9221212(27),9321312(28)
  1   1   1   1   1   1   1   1   1   1   1                             21373352,388606,2436204,Lock-Free (DWCAS 8),205205(18),224224(19),224224(20),220220(21),231231(22),221221(23),133133(24),230230(25),217217(26),9624615(27),9841832(28)
  1   1   1   1   1   1   1   1   1   1   1                             22373351,406788,2452170,Lock-Free (DWCAS 9),264264(18),235235(19),291291(20),295295(21),299299(22),298298(23),316316(24),315315(25),306306(26),9874865(27),9876867(28)
  1   1   1   1   1   1   1   1   1   1   1                             23134111,420620,2607768,Lock-Free (DWCAS 10),248248(18),269269(19),268268(20),263263(21),270270(22),264264(23),124124(24),289289(25),253253(26),10354344(27),10529519(28)
  1   1   1   1   1   1   1   1   1   1   1                             27446419,499026,94314,PThread Mutex,2395393(18),2373371(19),2375373(20),2421419(21),2409407(22),2453451(23),2483481(24),2485483(25),2483481(26),2820818(27),2744742(28)
  1   1   1   1   1   1   1   1   1   1   1                             11702691,212776,796419,PThread Spinlock (private),614614(18),600600(19),467467(20),472472(21),490490(22),484484(23),436436(24),442442(25),477477(26),3627624(27),3588585(28)
  1   1   1   1   1   1   1   1   1   1   1                             12157145,221039,333790,PThread Spinlock (shared),1626625(18),1694693(19),1253252(20),1207206(21),1244243(22),1341340(23),1180179(24),1125124(25),1284283(26),95095(27),105105(28)
  1   1   1   1   1   1   1   1   1   1   1   1                         2657655,44294,71903,GCC Spinlock (atomic),140140(18),155155(19),168168(20),158158(21),165165(22),161161(23),176176(24),171171(25),161161(26),399399(27),413413(28),388388(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         5207202,86787,79670,GCC Spinlock (sync),334334(18),594594(19),495495(20),485485(21),541541(22),469469(23),218218(24),310310(25),265265(26),509509(27),468468(28),514514(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17361344,289356,1446363,Lock-Free (DWCAS 0),228228(18),234234(19),240240(20),242242(21),243243(22),238238(23),248248(24),252252(25),251251(26),4888884(27),5180175(28),5114109(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17626609,293777,1501994,Lock-Free (DWCAS 1),176176(18),191191(19),217217(20),228228(21),230230(22),229229(23),231231(24),234234(25),229229(26),4959955(27),5263258(28),5436431(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17769752,296163,1524428,Lock-Free (DWCAS 2),196196(18),204204(19),208208(20),208208(21),208208(22),206206(23),220220(24),227227(25),221221(26),5096091(27),5357352(28),5416411(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         14494480,241575,652284,Lock-Free (DWCAS 3),637637(18),668668(19),455455(20),735735(21),713713(22),701701(23),688688(24),695695(25),694694(26),2804802(27),2832830(28),2864862(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         16793777,279896,1465327,Lock-Free (DWCAS 4),162162(18),168168(19),173173(20),174174(21),181181(22),172172(23),191191(24),193193(25),194194(26),4937933(27),5216211(28),5030025(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         16468452,274474,1456222,Lock-Free (DWCAS 5),156156(18),171171(19),162162(20),168168(21),176176(22),169169(23),154154(24),124124(25),149149(26),5033028(27),5051046(28),4953949(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         16742726,279045,1460865,Lock-Free (DWCAS 6),157157(18),165165(19),177177(20),178178(21),176176(22),176176(23),189189(24),193193(25),192192(26),4889885(27),5153148(28),5095090(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17393376,289890,1507741,Lock-Free (DWCAS 7),199199(18),219219(19),216216(20),205205(21),213213(22),203203(23),178178(24),125125(25),178178(26),5198193(27),5224219(28),5233228(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         13166153,219436,202024,Lock-Free (DWCAS 8),863863(18),850850(19),925925(20),923923(21),931931(22),931931(23),991991(24),985985(25),985985(26),1626625(27),1470469(28),1676675(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         17362345,289372,1533930,Lock-Free (DWCAS 9),170170(18),192192(19),183183(20),185185(21),191191(22),186186(23),152152(24),107107(25),151151(26),5278273(27),5339334(28),5226221(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         14689675,244828,714293,Lock-Free (DWCAS 10),592592(18),591591(19),645645(20),646646(21),651651(22),641641(23),622622(24),642642(25),634634(26),2963961(27),2888886(28),3167164(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         33390357,556506,128165,PThread Mutex,2845843(18),2929927(19),2700698(20),3081078(21),2897895(22),2885883(23),2843841(24),2855853(25),2861859(26),2532530(27),2454452(28),2500498(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         12083071,201385,957461,PThread Spinlock (private),191191(18),289289(19),211211(20),201201(21),179179(22),202202(23),200200(24),204204(25),208208(26),3264261(27),3452449(28),3479476(29)
  1   1   1   1   1   1   1   1   1   1   1   1                         11761750,196029,384288,PThread Spinlock (shared),1149148(18),1912911(19),1254253(20),1282281(21),1143142(22),1175174(23),1208207(24),1197196(25),1192191(26),68068(27),98098(28),81081(29)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     5034029,77447,343552,GCC Spinlock (atomic),72072(18),84084(19),79079(20),78078(21),97097(22),87087(23),71071(24),81081(25),39039(26),1047046(27),1385384(28),950950(29),961961(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     1462461,22499,47150,GCC Spinlock (sync),138138(18),186186(19),166166(20),135135(21),142142(22),146146(23),170170(24),163163(25),149149(26),16016(27),17017(28),16016(29),17017(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     17379362,267375,450886,Lock-Free (DWCAS 0),903903(18),909909(19),910910(20),913913(21),930930(22),921921(23),973973(24),921921(25),899899(26),2193191(27),2364362(28),2279277(29),2255253(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     15344329,236067,1049839,Lock-Free (DWCAS 1),209209(18),220220(19),218218(20),221221(21),221221(22),220220(23),181181(24),199199(25),204204(26),3238235(27),3281278(28),3472469(29),3457454(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     15655640,240856,1055253,Lock-Free (DWCAS 2),223223(18),231231(19),230230(20),239239(21),244244(22),242242(23),215215(24),222222(25),212212(26),3337334(27),3458455(28),3437434(29),3362359(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     16185169,249003,107043,Lock-Free (DWCAS 3),1685684(18),1286285(19),1278277(20),1279278(21),1305304(22),1316315(23),1107106(24),1131130(25),1113112(26),1160159(27),1130129(28),1146145(29),1246245(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     18330312,282005,1197467,Lock-Free (DWCAS 4),286286(18),300300(19),323323(20),317317(21),325325(22),305305(23),284284(24),309309(25),281281(26),3759756(27),3867864(28),4040036(29),3929926(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     16707691,257041,448403,Lock-Free (DWCAS 5),1060059(18),870870(19),893893(20),862862(21),916916(22),877877(23),781781(24),801801(25),793793(26),2284282(27),2182180(28),2197195(29),2184182(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     15705690,241626,1068928,Lock-Free (DWCAS 6),211211(18),221221(19),228228(20),228228(21),233233(22),231231(23),209209(24),212212(25),210210(26),3275272(27),3498495(28),3519516(29),3427424(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     13552539,208501,919554,Lock-Free (DWCAS 7),160160(18),170170(19),189189(20),191191(21),199199(22),193193(23),216216(24),218218(25),209209(26),3067064(27),3025022(28),3007004(29),2706704(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     17568551,270285,1167834,Lock-Free (DWCAS 8),267267(18),276276(19),280280(20),277277(21),281281(22),275275(23),263263(24),275275(25),254254(26),3634631(27),3781778(28),3862859(29),3838835(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     15216201,234095,1032667,Lock-Free (DWCAS 9),179179(18),191191(19),215215(20),223223(21),231231(22),225225(23),242242(24),212212(25),235235(26),3458455(27),3378375(28),3337334(29),3087084(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     17568551,270285,1184649,Lock-Free (DWCAS 10),262262(18),278278(19),266266(20),277277(21),276276(22),270270(23),224224(24),238238(25),217217(26),3698695(27),3849846(28),3919916(29),3789786(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     29602573,455424,193156,PThread Mutex,2121119(18),2136134(19),2115113(20),2090088(21),2144142(22),2116114(23),2061059(24),2076074(25),2039037(26),2672670(27),2627625(28),2706704(29),2696694(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     10746736,165334,888430,PThread Spinlock (private),5005(18),5005(19),6006(20),6006(21),6006(22),6006(23),11011(24),12012(25),9009(26),2655653(27),2906904(28),2469467(29),2648646(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1                     10747737,165350,886876,PThread Spinlock (shared),6006(18),6006(19),8008(20),8008(21),8008(22),6006(23),11011(24),10010(25),9009(26),2719717(27),2837835(28),2535533(29),2582580(30)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 2468466,35264,100867,GCC Spinlock (atomic),99099(18),94094(19),95095(20),99099(21),95095(22),97097(23),85085(24),91091(25),94094(26),412412(27),537537(28),209209(29),250250(30),209209(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 4542538,64893,296330,GCC Spinlock (sync),47047(18),47047(19),45045(20),45045(21),45045(22),46046(23),46046(24),44044(25),51051(26),1047046(27),728728(28),641641(29),1129128(30),579579(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14482468,206892,755852,Lock-Free (DWCAS 0),243243(18),246246(19),281281(20),291291(21),291291(22),286286(23),298298(24),299299(25),303303(26),2514512(27),2329327(28),2357355(29),2358356(30),2382380(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14517503,207393,814635,Lock-Free (DWCAS 1),215215(18),217217(19),220220(20),219219(21),224224(22),221221(23),238238(24),240240(25),238238(26),2493491(27),2421419(28),2444442(29),2564562(30),2559557(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14937923,213399,818299,Lock-Free (DWCAS 2),224224(18),237237(19),245245(20),247247(21),252252(22),255255(23),268268(24),272272(25),272272(26),2645643(27),2409407(28),2524522(29),2528526(30),2555553(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 15306291,218661,874917,Lock-Free (DWCAS 3),209209(18),214214(19),219219(20),219219(21),220220(22),216216(23),231231(24),236236(25),234234(26),2685683(27),2556554(28),2695693(29),2706704(30),2661659(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 13985972,199800,240249,Lock-Free (DWCAS 4),732732(18),742742(19),749749(20),764764(21),769769(22),773773(23),818818(24),766766(25),724724(26),1387386(27),1423422(28),1450449(29),1442441(30),1438437(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 12866854,183812,751948,Lock-Free (DWCAS 5),157157(18),169169(19),163163(20),166166(21),175175(22),163163(23),177177(24),182182(25),178178(26),2279277(27),2234232(28),2257255(29),2291289(30),2273271(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14726712,210382,831215,Lock-Free (DWCAS 6),216216(18),221221(19),228228(20),234234(21),235235(22),237237(23),224224(24),230230(25),194194(26),2459457(27),2467465(28),2612610(29),2607605(30),2558556(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 15611596,223023,892449,Lock-Free (DWCAS 7),211211(18),210210(19),221221(20),221221(21),224224(22),225225(23),239239(24),243243(25),242242(26),2700698(27),2638636(28),2763761(29),2738736(30),2731729(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14665651,209509,831467,Lock-Free (DWCAS 8),215215(18),217217(19),224224(20),228228(21),233233(22),235235(23),226226(24),225225(25),174174(26),2459457(27),2469467(28),2598596(29),2589587(30),2569567(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 11269258,160989,97703,Lock-Free (DWCAS 9),926926(18),953953(19),884884(20),885885(21),893893(22),864864(23),899899(24),899899(25),896896(26),658658(27),619619(28),604604(29),646646(30),632632(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 14293279,204190,824978,Lock-Free (DWCAS 10),183183(18),193193(19),205205(20),208208(21),214214(22),216216(23),199199(24),206206(25),173173(26),2414412(27),2417415(28),2572570(29),2558556(30),2531529(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 28093065,401330,103420,PThread Mutex,1930929(18),1930929(19),1930929(20),1941940(21),1917916(22),1911910(23),1803802(24),1907906(25),1886885(26),2189187(27),2141139(28),2182180(29),2213211(30),2204202(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 11192181,159888,806291,PThread Spinlock (private),3003(18),3003(19),3003(20),3003(21),3003(22),3003(23),2002(24),2002(25),3003(26),1873872(27),2067065(28),2348346(29),2392390(30),2485483(31)
  1   1   1   1   1   1   1   1   1   1   1   1   1   1                 11213202,160189,803438,PThread Spinlock (shared),9009(18),7007(19),7007(20),8008(21),10010(22),7007(23),3003(24),3003(25),4004(26),1912911(27),2117115(28),2260258(29),2300298(30),2564562(31)
1 1                                                                     82044963,8204496,26189,GCC Spinlock (atomic),40929889(0),41115074(18)
1 1                                                                     90771681,9077168,12033,GCC Spinlock (sync),45428383(0),45343298(18)
1 1                                                                     120831711,12083171,1228057,Lock-Free (DWCAS 0),64757693(0),56074018(18)
1 1                                                                     128342214,12834221,1040486,Lock-Free (DWCAS 1),67849782(0),60492432(18)
1 1                                                                     127231104,12723110,917893,Lock-Free (DWCAS 2),66860794(0),60370310(18)
1 1                                                                     126253127,12625313,833663,Lock-Free (DWCAS 3),66074008(0),60179119(18)
1 1                                                                     125934809,12593481,727208,Lock-Free (DWCAS 4),65538473(0),60396336(18)
1 1                                                                     126001876,12600188,714892,Lock-Free (DWCAS 5),65528463(0),60473413(18)
1 1                                                                     125843718,12584372,665911,Lock-Free (DWCAS 6),65276211(0),60567507(18)
1 1                                                                     125685560,12568556,678652,Lock-Free (DWCAS 7),65242177(0),60443383(18)
1 1                                                                     125574449,12557445,581965,Lock-Free (DWCAS 8),64844780(0),60729669(18)
1 1                                                                     125745620,12574562,658550,Lock-Free (DWCAS 9),65201136(0),60544484(18)
1 1                                                                     125648523,12564852,682757,Lock-Free (DWCAS 10),65238173(0),60410350(18)
1 1                                                                     33739706,3373971,46999,PThread Mutex,16703687(0),17036019(18)
1 1                                                                     147005859,14700586,937287,PThread Spinlock (private),76816740(0),70189119(18)
1 1                                                                     142515373,14251537,655011,PThread Spinlock (shared),73573500(0),68941873(18)
1 1 1 1                                                                 21066045,1053302,128034,GCC Spinlock (atomic),5056051(0),5160155(1),5035030(18),5814809(19)
1 1 1 1                                                                 18700682,935034,10183,GCC Spinlock (sync),4665661(0),4681677(1),4641637(18),4711707(19)
1 1 1 1                                                                 26806780,1340339,1185355,Lock-Free (DWCAS 0),3740737(0),9793784(1),3738735(18),9533524(19)
1 1 1 1                                                                 36488452,1824423,466985,Lock-Free (DWCAS 1),8029021(0),10447437(1),7893886(18),10118108(19)
1 1 1 1                                                                 70663593,3533180,6086463,Lock-Free (DWCAS 2),2490488(0),34175141(1),2466464(18),31531500(19)
1 1 1 1                                                                 61981920,3099096,2099692,Lock-Free (DWCAS 3),10390380(0),21195174(1),10124114(18),20272252(19)
1 1 1 1                                                                 84773689,4238684,6557847,Lock-Free (DWCAS 4),4873869(0),38804766(1),4770766(18),36324288(19)
1 1 1 1                                                                 80564484,4028224,1843192,Lock-Free (DWCAS 5),15768753(0),25218193(1),15328313(18),24249225(19)
1 1 1 1                                                                 96587491,4829375,6666197,Lock-Free (DWCAS 6),7607600(0),41930889(1),7394387(18),39654615(19)
1 1 1 1                                                                 92843751,4642188,2014748,Lock-Free (DWCAS 7),18491473(0),28789761(1),17896879(18),27665638(19)
1 1 1 1                                                                 100947847,5047392,3458812,Lock-Free (DWCAS 8),16943927(0),34879845(1),16303287(18),32820788(19)
1 1 1 1                                                                 99067969,4953398,1974151,Lock-Free (DWCAS 9),20346326(0),30230200(1),19372353(18),29119090(19)
1 1 1 1                                                                 102897795,5144890,2036239,Lock-Free (DWCAS 10),31467436(0),21050029(1),30102072(18),20278258(19)
1 1 1 1                                                                 25049024,1252451,321203,PThread Mutex,5037032(0),7109102(1),6071065(18),6831825(19)
1 1 1 1                                                                 36935899,1846795,542503,PThread Spinlock (private),10611601(0),7896889(1),10568558(18),7858851(19)
1 1 1 1                                                                 36911875,1845594,362878,PThread Spinlock (shared),8320312(0),10147137(1),8321313(18),10123113(19)
1 1 1 1 1 1                                                             14409395,480313,25891,GCC Spinlock (atomic),2463461(0),2411409(1),2333331(2),2457455(18),2412410(19),2331329(20)
1 1 1 1 1 1                                                             15689674,522989,39579,GCC Spinlock (sync),2724722(0),2667665(1),2512510(2),2633631(18),2647645(19),2503501(20)
1 1 1 1 1 1                                                             20169149,672305,641980,Lock-Free (DWCAS 0),1513512(0),4287283(1),4412408(2),1507506(18),4201197(19),4247243(20)
1 1 1 1 1 1                                                             22596574,753219,676633,Lock-Free (DWCAS 1),4861857(0),1821820(1),4676672(2),4813809(18),1810809(19),4611607(20)
1 1 1 1 1 1                                                             35427392,1180913,1332329,Lock-Free (DWCAS 2),2123121(0),8430422(1),7402395(2),2086084(18),8182174(19),7203196(20)
1 1 1 1 1 1                                                             45421376,1514046,2036165,Lock-Free (DWCAS 3),11529518(0),1793792(1),9685676(2),11170159(18),1775774(19),9466457(20)
1 1 1 1 1 1                                                             52909857,1763662,2301585,Lock-Free (DWCAS 4),2465463(0),13928915(1),10420410(2),2470468(18),13419406(19),10205195(20)
1 1 1 1 1 1                                                             61238177,2041273,2385352,Lock-Free (DWCAS 5),14837823(0),3441438(1),12869857(2),14258244(18),3386383(19),12444432(20)
1 1 1 1 1 1                                                             67185118,2239504,2521501,Lock-Free (DWCAS 6),4147143(0),16491475(1),13534521(2),4084080(18),15844829(19),13083070(20)
1 1 1 1 1 1                                                             76730654,2557688,2944845,Lock-Free (DWCAS 7),18740722(0),4529525(1),15786771(2),18011994(18),4381377(19),15280265(20)
1 1 1 1 1 1                                                             79595516,2653184,2874453,Lock-Free (DWCAS 8),5192187(0),19127108(1),16254238(2),5069064(18),18274256(19),15678663(20)
1 1 1 1 1 1                                                             86109023,2870301,3129623,Lock-Free (DWCAS 9),20666646(0),5587582(1),17595578(2),19773754(18),5372367(19),17113096(20)
1 1 1 1 1 1                                                             89672583,2989086,3458983,Lock-Free (DWCAS 10),5397392(0),22538516(1),17868851(2),5245240(18),21494473(19),17128111(20)
1 1 1 1 1 1                                                             22099077,736636,154519,PThread Mutex,3008005(0),3910907(1),3955952(2),3712709(18),3714711(19),3796793(20)
1 1 1 1 1 1                                                             29775746,992525,539651,PThread Spinlock (private),4004000(0),4395391(1),6524518(2),3989986(18),4378374(19),6483477(20)
1 1 1 1 1 1                                                             29697668,989922,633247,PThread Spinlock (shared),3710707(0),4437433(1),6796790(2),3685682(18),4407403(19),6659653(20)
1 1 1 1 1 1 1 1                                                         11839828,295996,10422,GCC Spinlock (atomic),1485484(0),1488487(1),1447446(2),1498497(3),1481480(18),1485484(19),1452451(20),1500499(21)
1 1 1 1 1 1 1 1                                                         11545534,288638,26254,GCC Spinlock (sync),1453452(0),1517516(1),1400399(2),1396395(3),1438437(18),1490489(19),1472471(20),1376375(21)
1 1 1 1 1 1 1 1                                                         17784767,444619,427608,Lock-Free (DWCAS 0),2872870(0),2703701(1),2472470(2),936936(3),2797795(18),2646644(19),2417415(20),936936(21)
1 1 1 1 1 1 1 1                                                         17658641,441466,379249,Lock-Free (DWCAS 1),2734732(0),2565563(1),2509507(2),1057056(3),2708706(18),2544542(19),2485483(20),1053052(21)
1 1 1 1 1 1 1 1                                                         20966946,524174,427076,Lock-Free (DWCAS 2),3232229(0),2907905(1),3068065(2),1338337(3),3195192(18),2878876(19),3028025(20),1318317(21)
1 1 1 1 1 1 1 1                                                         29796767,744919,742981,Lock-Free (DWCAS 3),5088083(0),3933930(1),4438434(2),1572571(3),5000996(18),3859856(19),4350346(20),1552551(21)
1 1 1 1 1 1 1 1                                                         36287251,907181,1035902,Lock-Free (DWCAS 4),6366360(0),4337333(1),5896891(2),1635634(3),6294288(18),4301297(19),5815810(20),1639638(21)
1 1 1 1 1 1 1 1                                                         41759718,1043993,1146060,Lock-Free (DWCAS 5),7240233(0),4880876(1),6858852(2),2071069(3),7096089(18),4841837(19),6728722(20),2042040(21)
1 1 1 1 1 1 1 1                                                         48112064,1202802,1290103,Lock-Free (DWCAS 6),8425417(0),5828823(1),7640633(2),2412410(3),8246238(18),5729724(19),7430423(20),2398396(21)
1 1 1 1 1 1 1 1                                                         55128073,1378202,1482450,Lock-Free (DWCAS 7),9836827(0),6895889(1),8476468(2),2726724(3),9520511(18),6752746(19),8232224(20),2686684(21)
1 1 1 1 1 1 1 1                                                         61130069,1528252,1636621,Lock-Free (DWCAS 8),11128117(0),7678671(1),9044035(2),3111108(3),10802792(18),7490483(19),8808800(20),3066063(21)
1 1 1 1 1 1 1 1                                                         67984917,1699623,1861396,Lock-Free (DWCAS 9),12171159(0),8536528(1),10634624(2),3299296(3),11730719(18),8192184(19),10217207(20),3203200(21)
1 1 1 1 1 1 1 1                                                         73337264,1833432,1995221,Lock-Free (DWCAS 10),13192179(0),9243234(1),11155144(2),3598595(3),12887875(18),8992984(19),10753743(20),3513510(21)
1 1 1 1 1 1 1 1                                                         17264247,431606,65008,PThread Mutex,1897896(0),2286284(1),2260258(2),2110108(3),2233231(18),2194192(19),2166164(20),2116114(21)
1 1 1 1 1 1 1 1                                                         24167143,604179,244947,PThread Spinlock (private),3741738(0),2974972(1),2660658(2),2717715(3),3743740(18),2962960(19),2651649(20),2713711(21)
1 1 1 1 1 1 1 1                                                         24154130,603853,827406,PThread Spinlock (shared),5340335(0),3195192(1),1799798(2),1764763(3),5360355(18),3159156(19),1783782(20),1750749(21)
1 1 1 1 1 1 1 1 1 1                                                     9732723,194654,17229,GCC Spinlock (atomic),1010009(0),985985(1),935935(2),946946(3),973973(4),1013012(18),989989(19),937937(20),950950(21),987987(22)
1 1 1 1 1 1 1 1 1 1                                                     9350341,187007,104076,GCC Spinlock (sync),909909(0),1256255(1),821821(2),861861(3),787787(4),819819(18),1257256(19),870870(20),868868(21),895895(22)
1 1 1 1 1 1 1 1 1 1                                                     15358343,307167,22078,Lock-Free (DWCAS 0),1537536(0),1518517(1),1567566(2),1588587(3),1583582(4),1509508(18),1466465(19),1519518(20),1537536(21),1529528(22)
1 1 1 1 1 1 1 1 1 1                                                     15114099,302282,183747,Lock-Free (DWCAS 1),932932(0),1629628(1),1688687(2),1674673(3),1662661(4),930930(18),1612611(19),1676675(20),1659658(21),1645644(22)
1 1 1 1 1 1 1 1 1 1                                                     16267251,325345,181294,Lock-Free (DWCAS 2),1059058(0),1765764(1),1795794(2),1773772(3),1778777(4),1049048(18),1745744(19),1781780(20),1758757(21),1758757(22)
1 1 1 1 1 1 1 1 1 1                                                     19392373,387847,26788,Lock-Free (DWCAS 3),1882881(0),1949948(1),1961960(2),1942941(3),2011009(4),1863862(18),1922921(19),1940939(20),1923922(21),1991990(22)
1 1 1 1 1 1 1 1 1 1                                                     20664644,413293,49054,Lock-Free (DWCAS 4),1962961(0),2007005(1),2097095(2),2123121(3),2176174(4),1953952(18),1989988(19),2079077(20),2116114(21),2159157(22)
1 1 1 1 1 1 1 1 1 1                                                     25393368,507867,95184,Lock-Free (DWCAS 5),2347345(0),2380378(1),2610608(2),2679677(3),2686684(4),2333331(18),2375373(19),2604602(20),2675673(21),2699697(22)
1 1 1 1 1 1 1 1 1 1                                                     36007972,720159,686664,Lock-Free (DWCAS 6),3381378(0),4653649(1),4066062(2),4404400(3),1603602(4),3339336(18),4566562(19),4034030(20),4361357(21),1597596(22)
1 1 1 1 1 1 1 1 1 1                                                     33971938,679439,98108,Lock-Free (DWCAS 7),3215212(0),3221218(1),3437434(2),3372369(3),3669666(4),3257254(18),3273270(19),3463460(20),3419416(21),3642639(22)
1 1 1 1 1 1 1 1 1 1                                                     44280236,885605,94042,Lock-Free (DWCAS 8),4531527(0),4718714(1),4438434(2),4292288(3),4364360(4),4428424(18),4632628(19),4349345(20),4250246(21),4274270(22)
1 1 1 1 1 1 1 1 1 1                                                     54055001,1081100,1072603,Lock-Free (DWCAS 9),5393388(0),7227220(1),5997992(2),6473467(3),2247245(4),5279274(18),7041034(19),5909904(20),6283277(21),2202200(22)
1 1 1 1 1 1 1 1 1 1                                                     52869817,1057396,71892,Lock-Free (DWCAS 10),5215210(0),5381376(1),5324319(2),5150145(3),5429424(4),5201196(18),5376371(19),5235230(20),5110105(21),5446441(22)
1 1 1 1 1 1 1 1 1 1                                                     18146128,362923,61465,PThread Mutex,1604603(0),1831830(1),1973972(2),1778777(3),1815814(4),1797796(18),1799798(19),1961960(20),1793792(21),1787786(22)
1 1 1 1 1 1 1 1 1 1                                                     21926905,438538,273318,PThread Spinlock (private),1650649(0),2262260(1),2049047(2),2960958(3),2032030(4),1648647(18),2259257(19),2081079(20),2960958(21),2022020(22)
1 1 1 1 1 1 1 1 1 1                                                     21639618,432792,366602,PThread Spinlock (shared),2317315(0),3243240(1),1781780(2),1845844(3),1675674(4),2303301(18),3227224(19),1759758(20),1836835(21),1648647(22)
1 1 1 1 1 1 1 1 1 1 1 1                                                 8505497,141758,60914,GCC Spinlock (atomic),642642(0),643643(1),872872(2),776776(3),665665(4),653653(5),639639(18),645645(19),859859(20),804804(21),652652(22),647647(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 8580572,143010,19755,GCC Spinlock (sync),734734(0),736736(1),736736(2),662662(3),722722(4),695695(5),741741(18),753753(19),685685(20),736736(21),679679(22),693693(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 14784770,246413,171748,Lock-Free (DWCAS 0),1416415(0),1311310(1),1343342(2),693693(3),1357356(4),1383382(5),1364363(18),1275274(19),1303302(20),673673(21),1317316(22),1345344(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 15148133,252469,246501,Lock-Free (DWCAS 1),1567566(0),1399398(1),1380379(2),481481(3),1382381(4),1374373(5),1564563(18),1401400(19),1380379(20),481481(21),1373372(22),1361360(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 15095080,251585,207012,Lock-Free (DWCAS 2),591591(0),1415414(1),1411410(2),1387386(3),1390389(4),1375374(5),589589(18),1408407(19),1400399(20),1381380(21),1377376(22),1366365(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 16870854,281181,136788,Lock-Free (DWCAS 3),1211210(0),1535534(1),1547546(2),1542541(3),1555554(4),1062061(5),1206205(18),1532531(19),1541540(20),1535534(21),1545544(22),1055054(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 18339321,305655,19884,Lock-Free (DWCAS 4),1481480(0),1518517(1),1546545(2),1540539(3),1556555(4),1568567(5),1469468(18),1510509(19),1537536(20),1520519(21),1533532(22),1555554(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 22405383,373423,38609,Lock-Free (DWCAS 5),1798797(0),1861860(1),1818817(2),1815814(3),1913912(4),1954953(5),1832831(18),1905904(19),1816815(20),1814813(21),1920919(22),1949948(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 27547520,459125,332737,Lock-Free (DWCAS 6),2692690(0),1602601(1),2631629(2),1634633(3),2614612(4),2635633(5),2704702(18),1600599(19),2603601(20),1634633(21),2594592(22),2597595(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 27870843,464514,93861,Lock-Free (DWCAS 7),2239237(0),2392390(1),2555553(2),2336334(3),2298296(4),2111109(5),2258256(18),2394392(19),2550548(20),2341339(21),2284282(22),2109107(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 36902866,615048,333937,Lock-Free (DWCAS 8),3594591(0),2985983(1),3339336(2),2087085(3),3250247(4),3293290(5),3567564(18),2953951(19),3296293(20),2062060(21),3209206(22),3263260(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 37417380,623623,68688,Lock-Free (DWCAS 9),2978976(0),3158155(1),3309306(2),3141138(3),3148145(4),3035032(5),2972970(18),3146143(19),3259256(20),3110107(21),3139136(22),3019016(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 45506461,758441,287048,Lock-Free (DWCAS 10),3748745(0),4296292(1),3877874(2),4012008(3),2970968(4),3980977(5),3707704(18),4238234(19),3866863(20),3973970(21),2910908(22),3921918(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 19559540,325992,46580,PThread Mutex,1506505(0),1629628(1),1743742(2),1620619(3),1636635(4),1509508(5),1627626(18),1642641(19),1734733(20),1626625(21),1636635(22),1644643(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 19192173,319870,82171,PThread Spinlock (private),1601600(0),1823822(1),1437436(2),1551550(3),1541540(4),1641640(5),1599598(18),1823822(19),1436435(20),1552551(21),1538537(22),1643642(23)
1 1 1 1 1 1 1 1 1 1 1 1                                                 19739720,328995,291928,PThread Spinlock (shared),1899898(0),2480478(1),1332331(2),1491490(3),1315314(4),1400399(5),1891890(18),2468466(19),1290289(20),1482481(21),1296295(22),1390389(23)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             7494487,107064,60566,GCC Spinlock (atomic),498498(0),694694(1),625625(2),478478(3),467467(4),478478(5),497497(6),500500(18),688688(19),628628(20),480480(21),482482(22),474474(23),498498(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             7429422,106135,89345,GCC Spinlock (sync),476476(0),488488(1),478478(2),821821(3),467467(4),488488(5),469469(6),481481(18),475475(19),493493(20),822822(21),502502(22),480480(23),482482(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             13312299,190176,192997,Lock-Free (DWCAS 0),326326(0),1055054(1),1041040(2),1047046(3),1052051(4),1049048(5),1160159(6),325325(18),1032031(19),1018017(20),1031030(21),1028027(22),1027026(23),1120119(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             13343330,190619,101817,Lock-Free (DWCAS 1),994994(0),991991(1),1013012(2),1006005(3),1016015(4),623623(5),1049048(6),987987(18),983983(19),1004003(20),1001000(21),1009008(22),621621(23),1041040(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             13518505,193122,77115,Lock-Free (DWCAS 2),1002001(0),999999(1),1012011(2),1013012(3),1022021(4),1022021(5),715715(6),989989(18),991991(19),1003002(20),1007006(21),1013012(22),1014013(23),712712(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             14668654,209552,105600,Lock-Free (DWCAS 3),1113112(0),1112111(1),1149148(2),1143142(3),1162161(4),920920(5),760760(6),1105104(18),1104103(19),1142141(20),1140139(21),1151150(22),909909(23),754754(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             15391376,219877,13547,Lock-Free (DWCAS 4),1074073(0),1083082(1),1125124(2),1117116(3),1113112(4),1109108(5),1113112(6),1067066(18),1071070(19),1117116(20),1107106(21),1098097(22),1100099(23),1096095(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             18202184,260031,114166,Lock-Free (DWCAS 5),1057056(0),1232231(1),1153152(2),1407406(3),1409408(4),1408407(5),1525524(6),1047046(18),1221220(19),1140139(20),1391390(21),1311310(22),1394393(23),1503502(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             20358338,290833,265109,Lock-Free (DWCAS 6),1426425(0),1445444(1),1619618(2),1615614(3),1717716(4),1735734(5),630630(6),1415414(18),1431430(19),1611610(20),1616615(21),1717716(22),1739738(23),634634(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             24569545,350994,126677,Lock-Free (DWCAS 7),1715714(0),1723722(1),1464463(2),1795794(3),1784783(4),1735734(5),2096094(6),1701700(18),1728727(19),1474473(20),1756755(21),1774773(22),1727726(23),2089087(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             28759731,410853,223611,Lock-Free (DWCAS 8),2132130(0),1736735(1),1520519(2),2130128(3),2207205(4),2181179(5),2492490(6),2128126(18),1727726(19),1520519(20),2136134(21),2183181(22),2179177(23),2484482(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             31889858,455569,248802,Lock-Free (DWCAS 9),1693692(0),2644642(1),1893892(2),2342340(3),2420418(4),2399397(5),2619617(6),1681680(18),2596594(19),1863862(20),2345343(21),2403401(22),2375373(23),2609607(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             39600561,565722,455300,Lock-Free (DWCAS 10),2724722(0),2888886(1),1463462(2),3079076(3),3160157(4),3105102(5),3537534(6),2696694(18),2832830(19),1430429(20),3036033(21),3104101(22),3083080(23),3458455(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             20658638,295123,31791,PThread Mutex,1404403(0),1531530(1),1535534(2),1467466(3),1486485(4),1387386(5),1448447(6),1483482(18),1496495(19),1534533(20),1467466(21),1484483(22),1480479(23),1450449(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             17552535,250750,281001,PThread Spinlock (private),2083081(0),1446445(1),1063062(2),1083082(3),1080079(4),1189188(5),844844(6),2076074(18),1436435(19),1060059(20),1082081(21),1078077(22),1189188(23),840840(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1                                             17555538,250793,284479,PThread Spinlock (shared),2097095(0),1446445(1),1068067(2),1084083(3),1077076(4),1188187(5),842842(6),2088086(18),1432431(19),1057056(20),1077076(21),1074073(22),1184183(23),838838(24)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         6926920,86586,14809,GCC Spinlock (atomic),465465(0),462462(1),415415(2),421421(3),416416(4),424424(5),428428(6),428428(7),468468(18),459459(19),416416(20),417417(21),421421(22),424424(23),429429(24),427427(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         6208202,77603,32269,GCC Spinlock (sync),366366(0),375375(1),374374(2),377377(3),356356(4),360360(5),481481(6),427427(7),370370(18),362362(19),376376(20),363363(21),362362(22),356356(23),482482(24),415415(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         13035022,162938,178554,Lock-Free (DWCAS 0),936936(0),875875(1),902902(2),227227(3),895895(4),904904(5),933933(6),922922(7),902902(18),856856(19),880880(20),226226(21),873873(22),885885(23),909909(24),897897(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         12661649,158271,147633,Lock-Free (DWCAS 1),815815(0),843843(1),312312(2),827827(3),861861(4),857857(5),916916(6),911911(7),811811(18),840840(19),310310(20),821821(21),854854(22),855855(23),908908(24),908908(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         13102089,163776,92976,Lock-Free (DWCAS 2),843843(0),890890(1),581581(2),863863(3),678678(4),867867(5),916916(6),922922(7),839839(18),886886(19),576576(20),859859(21),670670(22),863863(23),915915(24),921921(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         13376363,167205,150297,Lock-Free (DWCAS 3),897897(0),903903(1),913913(2),911911(3),912912(4),911911(5),340340(6),919919(7),892892(18),893893(19),910910(20),902902(21),903903(22),906906(23),338338(24),913913(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         14694680,183684,82726,Lock-Free (DWCAS 4),956956(0),950950(1),981981(2),978978(3),993993(4),705705(5),1019018(6),794794(7),950950(18),941941(19),973973(20),965965(21),978978(22),699699(23),1013012(24),787787(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         16150134,201877,94833,Lock-Free (DWCAS 5),1091090(0),1049048(1),1072071(2),776776(3),1084083(4),1081080(5),848848(6),1105104(7),1085084(18),1041040(19),1063062(20),764764(21),1072071(22),1073072(23),843843(24),1099098(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         19847828,248098,208753,Lock-Free (DWCAS 6),918918(0),1329328(1),696696(2),1359358(3),1361360(4),1349348(5),1451450(6),1475474(7),913913(18),1326325(19),697697(20),1348347(21),1354353(22),1341340(23),1444443(24),1479478(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         20707687,258846,138342,Lock-Free (DWCAS 7),1251250(0),1251250(1),1347346(2),1339338(3),1399398(4),1153152(5),995995(6),1629628(7),1253252(18),1243242(19),1341340(20),1331330(21),1399398(22),1151150(23),995995(24),1624623(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         23167144,289589,94225,Lock-Free (DWCAS 8),1511510(0),1421420(1),1468467(2),1155154(3),1472471(4),1495494(5),1517516(6),1541540(7),1528527(18),1434433(19),1450449(20),1147146(21),1462461(22),1491490(23),1521520(24),1547546(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         24579555,307244,182661,Lock-Free (DWCAS 9),981981(0),1830829(1),1594593(2),1508507(3),1587586(4),1560559(5),1574573(6),1672671(7),981981(18),1818817(19),1590589(20),1495494(21),1585584(22),1545544(23),1588587(24),1661660(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         30188158,377352,446337,Lock-Free (DWCAS 10),1780779(0),1787786(1),1934933(2),1925924(3),2024022(4),1978977(5),756756(6),2974972(7),1760759(18),1778777(19),1912911(20),1927926(21),2004002(22),1967966(23),737737(24),2933931(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         21582561,269782,32410,PThread Mutex,1308307(0),1378377(1),1356355(2),1392391(3),1351350(4),1300299(5),1385384(6),1271270(7),1366365(18),1387386(19),1354353(20),1363362(21),1358357(22),1354353(23),1394393(24),1260259(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         15484469,193556,177520,PThread Spinlock (private),1072071(0),890890(1),825825(2),779779(3),793793(4),827827(5),1078077(6),1476475(7),1070069(18),890890(19),824824(20),774774(21),794794(22),829829(23),1077076(24),1477476(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                         16083067,201038,246552,PThread Spinlock (shared),1706705(0),1257256(1),964964(2),863863(3),883883(4),938938(5),704704(6),726726(7),1703702(18),1250249(19),956956(20),865865(21),885885(22),940940(23),701701(24),730730(25)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     5669664,62996,51740,GCC Spinlock (atomic),485485(0),316316(1),278278(2),279279(3),283283(4),277277(5),297297(6),303303(7),301301(8),484484(18),309309(19),285285(20),291291(21),295295(22),290290(23),298298(24),293293(25),300300(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     5864859,65165,34529,GCC Spinlock (sync),327327(0),330330(1),313313(2),321321(3),288288(4),300300(5),301301(6),329329(7),438438(8),323323(18),307307(19),323323(20),306306(21),329329(22),314314(23),300300(24),281281(25),429429(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     12201189,135569,96563,Lock-Free (DWCAS 0),730730(0),732732(1),754754(2),757757(3),727727(4),718718(5),708708(6),722722(7),366366(8),702702(18),704704(19),724724(20),732732(21),702702(22),690690(23),675675(24),690690(25),356356(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     11410399,126782,89673,Lock-Free (DWCAS 1),405405(0),501501(1),641641(2),650650(3),669669(4),658658(5),736736(6),743743(7),715715(8),402402(18),499499(19),636636(20),648648(21),661661(22),656656(23),733733(24),738738(25),708708(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     12108096,134534,132355,Lock-Free (DWCAS 2),734734(0),738738(1),740740(2),738738(3),739739(4),739739(5),700700(6),712712(7),233233(8),728728(18),729729(19),734734(20),734734(21),733733(22),733733(23),694694(24),705705(25),233233(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     12467455,138527,86371,Lock-Free (DWCAS 3),745745(0),749749(1),756756(2),756756(3),751751(4),748748(5),554554(6),461461(7),729729(8),741741(18),741741(19),750750(20),751751(21),745745(22),744744(23),552552(24),460460(25),722722(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     13647634,151640,77715,Lock-Free (DWCAS 4),792792(0),787787(1),815815(2),810810(3),811811(4),656656(5),815815(6),819819(7),538538(8),786786(18),783783(19),809809(20),804804(21),805805(22),653653(23),802802(24),814814(25),535535(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     14265251,158503,88616,Lock-Free (DWCAS 5),832832(0),835835(1),860860(2),856856(3),857857(4),856856(5),556556(6),851851(7),653653(8),824824(18),827827(19),850850(20),849849(21),850850(22),850850(23),553553(24),846846(25),646646(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     16546530,183850,118982,Lock-Free (DWCAS 6),923923(0),957957(1),531531(2),963963(3),954954(4),953953(5),1002001(6),1011010(7),1006005(8),918918(18),946946(19),529529(20),955955(21),945945(22),944944(23),994994(24),1002001(25),1002001(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     17698681,196652,142411,Lock-Free (DWCAS 7),1006005(0),1016015(1),1056055(2),1035034(3),1036035(4),1034033(5),1048047(6),1120119(7),515515(8),1002001(18),1016015(19),1044043(20),1031030(21),1039038(22),1029028(23),1043042(24),1111110(25),516516(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     19250231,213891,174932,Lock-Free (DWCAS 8),1013012(0),1014013(1),1089088(2),1089088(3),1147146(4),1144143(5),580580(6),1417416(7),1140139(8),1015014(18),1009008(19),1089088(20),1088087(21),1136135(22),1141140(23),580580(24),1416415(25),1140139(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     22671649,251907,139440,Lock-Free (DWCAS 9),1407406(0),1180179(1),1375374(2),825825(3),1333332(4),1327326(5),1266265(6),1314313(7),1320319(8),1412411(18),1186185(19),1358357(20),825825(21),1321320(22),1318317(23),1275274(24),1309308(25),1314313(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     25220195,280224,241188,Lock-Free (DWCAS 10),1376375(0),1499498(1),1505504(2),1453452(3),1424423(4),1386385(5),1465464(6),1839838(7),684684(8),1383382(18),1493492(19),1513512(20),1435434(21),1425424(22),1381380(23),1449448(24),1820819(25),681681(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     19729710,219219,19920,PThread Mutex,1073072(0),1110109(1),1113112(2),1108107(3),1107106(4),1053052(5),1095094(6),1054053(7),1085084(8),1127126(18),1125124(19),1117116(20),1116115(21),1114113(22),1101100(23),1089088(24),1054053(25),1087086(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     14815801,164620,153006,PThread Spinlock (private),1155154(0),1027026(1),670670(2),699699(3),715715(4),765765(5),691691(6),1027026(7),650650(8),1153152(18),1029028(19),672672(20),700700(21),714714(22),768768(23),690690(24),1028027(25),654654(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                     14512498,161250,259209,PThread Spinlock (shared),726726(0),750750(1),598598(2),619619(3),662662(4),707707(5),762762(6),1659658(7),753753(8),726726(18),757757(19),601601(20),627627(21),665665(22),715715(23),764764(24),1651650(25),758758(26)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 2057055,20571,72250,GCC Spinlock (atomic),87087(0),80080(1),70070(2),69069(3),74074(4),69069(5),81081(6),81081(7),73073(8),346346(9),86086(18),81081(19),69069(20),61061(21),73073(22),69069(23),80080(24),85085(25),79079(26),342342(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 4610606,46106,416108,GCC Spinlock (sync),71071(0),70070(1),81081(2),85085(3),78078(4),78078(5),70070(6),75075(7),72072(8),1624623(9),72072(18),70070(19),80080(20),85085(21),78078(22),79079(23),71071(24),71071(25),71071(26),1627626(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 19043024,190430,2094465,Lock-Free (DWCAS 0),193193(0),195195(1),185185(2),192192(3),195195(4),191191(5),93093(6),160160(7),151151(8),8109101(9),190190(18),190190(19),188188(20),189189(21),192192(22),188188(23),91091(24),155155(25),151151(26),7841834(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 13138125,131381,750313,Lock-Free (DWCAS 1),396396(0),382382(1),378378(2),345345(3),377377(4),377377(5),380380(6),388388(7),388388(8),3192189(9),393393(18),379379(19),377377(20),344344(21),374374(22),371371(23),380380(24),389389(25),367367(26),3154151(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 15533518,155335,1329534,Lock-Free (DWCAS 2),261261(0),282282(1),287287(2),293293(3),294294(4),284284(5),284284(6),271271(7),285285(8),5284279(9),255255(18),281281(19),285285(20),290290(21),288288(22),288288(23),282282(24),266266(25),281281(26),5187182(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 16489473,164895,1411010,Lock-Free (DWCAS 3),276276(0),279279(1),302302(2),297297(3),301301(4),299299(5),309309(6),320320(7),310310(8),5624619(9),275275(18),275275(19),296296(20),298298(21),301301(22),300300(23),307307(24),312312(25),314314(26),5488483(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 16219203,162192,1324266,Lock-Free (DWCAS 4),328328(0),326326(1),341341(2),332332(3),338338(4),332332(5),271271(6),311311(7),289289(8),5321316(9),321321(18),323323(19),336336(20),330330(21),333333(22),326326(23),265265(24),315315(25),293293(26),5182177(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 19284265,192843,2179802,Lock-Free (DWCAS 5),160160(0),166166(1),163163(2),162162(3),166166(4),162162(5),95095(6),150150(7),143143(8),8359351(9),164164(18),167167(19),168168(20),163163(21),164164(22),162162(23),89089(24),144144(25),144144(26),8190182(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 13455442,134554,817700,Lock-Free (DWCAS 6),381381(0),373373(1),384384(2),345345(3),388388(4),372372(5),373373(6),378378(7),331331(8),3431428(9),373373(18),369369(19),385385(20),340340(21),382382(22),372372(23),365365(24),377377(25),331331(26),3398395(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 16592576,165926,1474005,Lock-Free (DWCAS 7),281281(0),284284(1),292292(2),251251(3),273273(4),283283(5),289289(6),288288(7),288288(8),5821816(9),279279(18),277277(19),283283(20),252252(21),276276(22),282282(23),279279(24),292292(25),292292(26),5724719(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 16590574,165906,1462560,Lock-Free (DWCAS 8),286286(0),265265(1),293293(2),285285(3),272272(4),290290(5),287287(6),299299(7),295295(8),5787782(9),280280(18),253253(19),286286(20),286286(21),271271(22),285285(23),286286(24),301301(25),296296(26),5681676(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 17087070,170871,1453039,Lock-Free (DWCAS 9),317317(0),310310(1),327327(2),265265(3),335335(4),308308(5),315315(6),329329(7),330330(8),5795790(9),317317(18),304304(19),330330(20),262262(21),329329(22),296296(23),309309(24),320320(25),324324(26),5658653(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 17156139,171561,1520338,Lock-Free (DWCAS 10),290290(0),247247(1),296296(2),291291(3),296296(4),290290(5),308308(6),305305(7),309309(8),6028022(9),281281(18),242242(19),294294(20),288288(21),294294(22),287287(23),300300(24),313313(25),307307(26),5884879(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 27450423,274504,132500,PThread Mutex,1371370(0),1263262(1),1334333(2),1319318(3),1344343(4),1299298(5),1315314(6),1303302(7),1302301(8),1799798(9),1401400(18),1327326(19),1330329(20),1328327(21),1331330(22),1325324(23),1303302(24),1319318(25),1312311(26),1818817(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 9170161,91702,930218,PThread Spinlock (private),103103(0),114114(1),90090(2),95095(3),131131(4),133133(5),74074(6),156156(7),154154(8),4079075(9),102102(18),112112(19),91091(20),95095(21),131131(22),134134(23),75075(24),156156(25),153153(26),2989987(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                                 9003995,90040,365225,PThread Spinlock (shared),274274(0),300300(1),237237(2),249249(3),352352(4),359359(5),194194(6),418418(7),410410(8),1635634(9),282282(18),317317(19),247247(20),258258(21),367367(22),370370(23),196196(24),433433(25),424424(26),1675674(27)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             3978975,36172,277318,GCC Spinlock (atomic),46046(0),42042(1),41041(2),43043(3),43043(4),42042(5),42042(6),42042(7),42042(8),708708(9),876876(10),46046(18),42042(19),43043(20),43043(21),42042(22),41041(23),40040(24),43043(25),41041(26),735735(27),892892(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             3331328,30285,198309,GCC Spinlock (sync),51051(0),53053(1),49049(2),45045(3),46046(4),46046(5),80080(6),60060(7),59059(8),699699(9),473473(10),53053(18),52052(19),48048(20),46046(21),46046(22),46046(23),79079(24),62062(25),59059(26),701701(27),475475(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             16081065,146192,640835,Lock-Free (DWCAS 0),399399(0),400400(1),416416(2),414414(3),414414(4),408408(5),419419(6),424424(7),421421(8),2170168(9),2227225(10),392392(18),391391(19),406406(20),407407(21),407407(22),400400(23),409409(24),414414(25),414414(26),2134132(27),2187185(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             14504490,131859,598307,Lock-Free (DWCAS 1),362362(0),363363(1),363363(2),352352(3),358358(4),342342(5),366366(6),376376(7),375375(8),2069067(9),1986985(10),354354(18),353353(19),360360(20),346346(21),352352(22),334334(23),362362(24),365365(25),369369(26),2037035(27),1952951(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             15729714,142997,1224804,Lock-Free (DWCAS 2),80080(0),81081(1),104104(2),97097(3),108108(4),100100(5),109109(6),116116(7),108108(8),3459456(9),3591588(10),80080(18),78078(19),100100(20),101101(21),106106(22),101101(23),104104(24),113113(25),107107(26),3380377(27),3503500(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             12657645,115070,605581,Lock-Free (DWCAS 3),273273(0),272272(1),272272(2),263263(3),276276(4),265265(5),277277(6),281281(7),279279(8),1913912(9),2003001(10),270270(18),267267(19),267267(20),258258(21),271271(22),265265(23),268268(24),278278(25),274274(26),1895894(27),1963962(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             12831819,116653,587951,Lock-Free (DWCAS 4),290290(0),290290(1),297297(2),292292(3),300300(4),299299(5),287287(6),273273(7),279279(8),1905904(9),1950949(10),290290(18),289289(19),295295(20),288288(21),297297(22),293293(23),280280(24),268268(25),270270(26),1867866(27),1924923(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             12420408,112913,607733,Lock-Free (DWCAS 5),248248(0),245245(1),263263(2),263263(3),270270(4),262262(5),269269(6),266266(7),262262(8),1990989(9),1910909(10),244244(18),242242(19),258258(20),258258(21),264264(22),256256(23),268268(24),264264(25),261261(26),1968967(27),1881880(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             13130117,119365,632523,Lock-Free (DWCAS 6),274274(0),282282(1),274274(2),279279(3),284284(4),284284(5),284284(6),279279(7),283283(8),2048046(9),2040038(10),275275(18),278278(19),268268(20),278278(21),282282(22),276276(23),281281(24),275275(25),281281(26),2026024(27),1993992(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             11998987,109082,261983,Lock-Free (DWCAS 7),412412(0),414414(1),396396(2),419419(3),422422(4),413413(5),417417(6),425425(7),424424(8),1137136(9),1143142(10),407407(18),414414(19),395395(20),410410(21),413413(22),409409(23),415415(24),417417(25),419419(26),1135134(27),1135134(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             13378365,121622,644485,Lock-Free (DWCAS 8),278278(0),261261(1),282282(2),287287(3),286286(4),288288(5),292292(6),298298(7),296296(8),2040038(9),2125123(10),273273(18),257257(19),285285(20),281281(21),293293(22),287287(23),288288(24),292292(25),290290(26),2009007(27),2085083(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             13168155,119710,642893,Lock-Free (DWCAS 9),259259(0),271271(1),279279(2),271271(3),285285(4),282282(5),287287(6),288288(7),256256(8),2109107(9),2028026(10),256256(18),271271(19),278278(20),268268(21),287287(22),286286(23),286286(24),288288(25),258258(26),2057055(27),2013011(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             12729717,115725,631113,Lock-Free (DWCAS 10),260260(0),272272(1),266266(2),268268(3),231231(4),268268(5),266266(6),267267(7),272272(8),1972971(9),2075073(10),252252(18),270270(19),262262(20),262262(21),225225(22),263263(23),263263(24),271271(25),267267(26),1960959(27),2011009(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             25620595,232914,65881,PThread Mutex,1116115(0),1092091(1),1142141(2),1130129(3),1148147(4),1147146(5),1193192(6),1089088(7),1095094(8),1325324(9),1275274(10),1130129(18),1155154(19),1143142(20),1131130(21),1145144(22),1162161(23),1184183(24),1096095(25),1117116(26),1326325(27),1276275(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             11354343,103221,472933,PThread Spinlock (private),246246(0),252252(1),250250(2),269269(3),287287(4),321321(5),335335(6),287287(7),347347(8),1188187(9),1897896(10),249249(18),254254(19),252252(20),271271(21),288288(22),325325(23),338338(24),289289(25),350350(26),1178177(27),1874873(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                             10535525,95778,416501,PThread Spinlock (shared),232232(0),249249(1),229229(2),241241(3),286286(4),305305(5),258258(6),306306(7),343343(8),1112111(9),1579578(10),240240(18),258258(19),234234(20),248248(21),293293(22),314314(23),263263(24),315315(25),350350(26),1192191(27),1682681(28)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         2919917,24333,162460,GCC Spinlock (atomic),30030(0),29029(1),34034(2),36036(3),31031(4),35035(5),34034(6),35035(7),34034(8),585585(9),333333(10),265265(11),30030(18),30030(19),33033(20),38038(21),32032(22),40040(23),34034(24),37037(25),34034(26),546546(27),320320(28),262262(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         2967965,24733,158652,GCC Spinlock (sync),32032(0),32032(1),33033(2),33033(3),36036(4),33033(5),34034(6),36036(7),34034(8),341341(9),321321(10),517517(11),32032(18),31031(19),33033(20),35035(21),35035(22),33033(23),34034(24),36036(25),34034(26),341341(27),322322(28),517517(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         14730716,122756,359245,Lock-Free (DWCAS 0),386386(0),386386(1),413413(2),413413(3),416416(4),406406(5),410410(6),414414(7),416416(8),1182181(9),1254253(10),1339338(11),375375(18),380380(19),407407(20),405405(21),407407(22),401401(23),401401(24),405405(25),408408(26),1145144(27),1233232(28),1320319(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         14354340,119620,392765,Lock-Free (DWCAS 1),371371(0),372372(1),373373(2),373373(3),374374(4),364364(5),352352(6),376376(7),373373(8),1312311(9),1318317(10),1297296(11),367367(18),363363(19),363363(20),368368(21),369369(22),358358(23),345345(24),369369(25),365365(26),1277276(27),1280279(28),1267266(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12491479,104096,336559,Lock-Free (DWCAS 2),329329(0),331331(1),337337(2),341341(3),340340(4),337337(5),320320(6),296296(7),292292(8),1136135(9),1117116(10),1123122(11),325325(18),325325(19),332332(20),333333(21),333333(22),333333(23),309309(24),294294(25),290290(26),1110109(27),1100099(28),1102101(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11588577,96571,312429,Lock-Free (DWCAS 3),304304(0),304304(1),293293(2),304304(3),300300(4),298298(5),301301(6),303303(7),302302(8),1052051(9),1042041(10),1028027(11),297297(18),298298(19),290290(20),294294(21),297297(22),298298(23),292292(24),300300(25),298298(26),1038037(27),1035034(28),1015014(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11663652,97197,352643,Lock-Free (DWCAS 4),286286(0),287287(1),291291(2),293293(3),291291(4),293293(5),258258(6),263263(7),260260(8),1122121(9),1119118(10),1106105(11),282282(18),279279(19),284284(20),288288(21),290290(22),291291(23),254254(24),259259(25),256256(26),1108107(27),1105104(28),1093092(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         10916906,90974,356313,Lock-Free (DWCAS 5),240240(0),242242(1),251251(2),251251(3),251251(4),248248(5),239239(6),247247(7),244244(8),1089088(9),1080079(10),1109108(11),238238(18),240240(19),247247(20),247247(21),248248(22),245245(23),238238(24),248248(25),241241(26),1076075(27),1061060(28),1092091(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11489478,95746,315549,Lock-Free (DWCAS 6),298298(0),297297(1),291291(2),292292(3),291291(4),286286(5),296296(6),301301(7),301301(8),1061060(9),1073072(10),987987(11),294294(18),289289(19),288288(20),290290(21),290290(22),282282(23),293293(24),298298(25),294294(26),1046045(27),1066065(28),978978(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11563552,96363,338352,Lock-Free (DWCAS 7),271271(0),285285(1),277277(2),283283(3),283283(4),276276(5),290290(6),297297(7),299299(8),1151150(9),990990(10),1098097(11),269269(18),281281(19),276276(20),282282(21),276276(22),273273(23),291291(24),293293(25),294294(26),1142141(27),986986(28),1093092(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11291280,94094,400650,Lock-Free (DWCAS 8),219219(0),227227(1),242242(2),240240(3),243243(4),235235(5),242242(6),231231(7),239239(8),1175174(9),1188187(10),1199198(11),216216(18),226226(19),236236(20),238238(21),240240(22),236236(23),238238(24),231231(25),237237(26),1149148(27),1182181(28),1177176(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         12036024,100300,400552,Lock-Free (DWCAS 9),258258(0),267267(1),277277(2),274274(3),269269(4),267267(5),258258(6),262262(7),272272(8),1208207(9),1208207(10),1240239(11),253253(18),260260(19),269269(20),270270(21),269269(22),264264(23),257257(24),257257(25),272272(26),1190189(27),1195194(28),1214213(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         10848838,90407,350798,Lock-Free (DWCAS 10),249249(0),252252(1),258258(2),256256(3),253253(4),253253(5),236236(6),227227(7),232232(8),1065064(9),1098097(10),1072071(11),245245(18),255255(19),254254(20),255255(21),256256(22),254254(23),230230(24),222222(25),227227(26),1045044(27),1083082(28),1067066(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         24832808,206940,25033,PThread Mutex,1002001(0),1059058(1),1035034(2),1037036(3),1041040(4),1016015(5),997997(6),1051050(7),977977(8),1052051(9),1033032(10),1075074(11),1025024(18),1062061(19),1044043(20),1040039(21),1038037(22),1048047(23),986986(24),1052051(25),997997(26),1054053(27),1035034(28),1072071(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11000990,91675,467812,PThread Spinlock (private),249249(0),247247(1),181181(2),194194(3),230230(4),292292(5),140140(6),197197(7),234234(8),1031030(9),1858857(10),792792(11),214214(18),217217(19),180180(20),199199(21),229229(22),248248(23),153153(24),204204(25),208208(26),977977(27),1707706(28),812812(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                         11647636,97064,284070,PThread Spinlock (shared),810810(0),649649(1),665665(2),731731(3),653653(4),706706(5),506506(6),588588(7),483483(8),4004(9),5005(10),4004(11),751751(18),733733(19),648648(20),699699(21),681681(22),722722(23),557557(24),582582(25),444444(26),4004(27),6006(28),5005(29)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     2344342,18033,76925,GCC Spinlock (atomic),29029(0),36036(1),33033(2),34034(3),43043(4),118118(5),32032(6),27027(7),29029(8),198198(9),186186(10),206206(11),185185(12),28028(18),37037(19),32032(20),37037(21),42042(22),119119(23),31031(24),27027(25),28028(26),218218(27),191191(28),194194(29),202202(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     2157155,16594,64281,GCC Spinlock (sync),47047(0),46046(1),46046(2),45045(3),44044(4),50050(5),44044(6),47047(7),36036(8),125125(9),136136(10),177177(11),245245(12),47047(18),45045(19),46046(20),45045(21),44044(22),50050(23),44044(24),47047(25),31031(26),120120(27),134134(28),176176(29),238238(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     11931920,91784,71922,Lock-Free (DWCAS 0),502502(0),508508(1),515515(2),513513(3),513513(4),504504(5),505505(6),513513(7),516516(8),355355(9),349349(10),349349(11),361361(12),493493(18),497497(19),504504(20),505505(21),505505(22),494494(23),496496(24),505505(25),506506(26),350350(27),346346(28),351351(29),365365(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     12277265,94440,190766,Lock-Free (DWCAS 1),347347(0),345345(1),344344(2),347347(3),349349(4),350350(5),356356(6),360360(7),356356(8),765765(9),740740(10),756756(11),766766(12),340340(18),338338(19),336336(20),341341(21),343343(22),343343(23),349349(24),356356(25),351351(26),748748(27),731731(28),746746(29),762762(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     12631619,97166,133977,Lock-Free (DWCAS 2),595595(0),599599(1),595595(2),597597(3),595595(4),590590(5),508508(6),563563(7),568568(8),292292(9),285285(10),292292(11),303303(12),580580(18),584584(19),580580(20),579579(21),577577(22),574574(23),497497(24),551551(25),553553(26),288288(27),279279(28),290290(29),305305(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10732722,82559,540367,Lock-Free (DWCAS 3),58058(0),63063(1),56056(2),58058(3),49049(4),56056(5),64064(6),66066(7),67067(8),1222221(9),1232231(10),1198197(11),1203202(12),59059(18),61061(19),55055(20),56056(21),50050(22),57057(23),64064(24),68068(25),65065(26),1205204(27),1219218(28),1173172(29),1206205(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     11615604,89351,192909,Lock-Free (DWCAS 4),332332(0),331331(1),334334(2),335335(3),335335(4),324324(5),297297(6),319319(7),322322(8),737737(9),729729(10),730730(11),735735(12),322322(18),323323(19),327327(20),327327(21),326326(22),294294(23),296296(24),313313(25),313313(26),728728(27),717717(28),719719(29),739739(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10643633,81874,208993,Lock-Free (DWCAS 5),272272(0),274274(1),278278(2),277277(3),274274(4),270270(5),268268(6),274274(7),274274(8),723723(9),729729(10),706706(11),729729(12),274274(18),270270(19),274274(20),279279(21),274274(22),268268(23),267267(24),272272(25),267267(26),707707(27),710710(28),697697(29),726726(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10955945,84276,189525,Lock-Free (DWCAS 6),304304(0),301301(1),286286(2),294294(3),295295(4),299299(5),305305(6),311311(7),305305(8),717717(9),688688(10),702702(11),703703(12),297297(18),291291(19),282282(20),287287(21),289289(22),294294(23),304304(24),307307(25),301301(26),706706(27),680680(28),692692(29),705705(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10453443,80411,521559,Lock-Free (DWCAS 7),62062(0),66066(1),56056(2),57057(3),54054(4),62062(5),64064(6),66066(7),65065(8),1193192(9),1176175(10),1149148(11),1170169(12),62062(18),64064(19),59059(20),57057(21),52052(22),62062(23),60060(24),66066(25),66066(26),1175174(27),1189188(28),1138137(29),1161160(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10783773,82952,195314,Lock-Free (DWCAS 8),282282(0),283283(1),282282(2),291291(3),287287(4),288288(5),295295(6),298298(7),295295(8),695695(9),717717(10),710710(11),699699(12),278278(18),275275(19),278278(20),285285(21),287287(22),285285(23),291291(24),292292(25),292292(26),686686(27),703703(28),707707(29),692692(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10711701,82398,521829,Lock-Free (DWCAS 9),75075(0),65065(1),68068(2),64064(3),73073(4),71071(5),74074(6),77077(7),73073(8),1213212(9),1153152(10),1197196(11),1185184(12),73073(18),68068(19),64064(20),68068(21),71071(22),70070(23),75075(24),76076(25),71071(26),1190189(27),1141140(28),1176175(29),1178177(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10829819,83306,205374,Lock-Free (DWCAS 10),291291(0),283283(1),279279(2),274274(3),281281(4),272272(5),294294(6),290290(7),288288(8),732732(9),716716(10),704704(11),732732(12),283283(18),281281(19),278278(20),271271(21),278278(22),274274(23),287287(24),290290(25),284284(26),717717(27),709709(28),702702(29),729729(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     23256233,178894,15886,PThread Mutex,873873(0),901901(1),895895(2),886886(3),900900(4),885885(5),899899(6),907907(7),890890(8),891891(9),865865(10),909909(11),904904(12),901901(18),910910(19),907907(20),895895(21),900900(22),903903(23),900900(24),908908(25),855855(26),891891(27),854854(28),893893(29),911911(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     10130120,77924,505246,PThread Spinlock (private),68068(0),63063(1),73073(2),71071(3),68068(4),65065(5),95095(6),92092(7),96096(8),1050049(9),1563562(10),989989(11),853853(12),67067(18),64064(19),74074(20),71071(21),67067(22),67067(23),96096(24),95095(25),99099(26),1048047(27),1577576(28),878878(29),775775(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                     8582574,66020,180280,PThread Spinlock (shared),184184(0),170170(1),200200(2),196196(3),184184(4),182182(5),265265(6),255255(7),260260(8),665665(9),527527(10),604604(11),531531(12),192192(18),180180(19),208208(20),208208(21),192192(22),191191(23),274274(24),264264(25),280280(26),675675(27),534534(28),614614(29),539539(30)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 1460459,10432,17470,GCC Spinlock (atomic),63063(0),59059(1),59059(2),61061(3),61061(4),60060(5),68068(6),70070(7),73073(8),33033(9),29029(10),32032(11),31031(12),29029(13),63063(18),59059(19),62062(20),61061(21),59059(22),61061(23),68068(24),71071(25),74074(26),33033(27),28028(28),32032(29),31031(30),29029(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 2008006,14343,71633,GCC Spinlock (sync),25025(0),22022(1),24024(2),25025(3),26026(4),25025(5),27027(6),27027(7),28028(8),121121(9),112112(10),169169(11),133133(12),238238(13),24024(18),23023(19),25025(20),25025(21),25025(22),26026(23),26026(24),28028(25),28028(26),120120(27),115115(28),167167(29),135135(30),237237(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 14000987,100007,136185,Lock-Free (DWCAS 0),419419(0),418418(1),402402(2),415415(3),412412(4),403403(5),398398(6),406406(7),405405(8),650650(9),684684(10),674674(11),681681(12),690690(13),407407(18),410410(19),391391(20),405405(21),403403(22),395395(23),392392(24),397397(25),395395(26),642642(27),672672(28),666666(29),675675(30),680680(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 11012001,78657,115432,Lock-Free (DWCAS 1),318318(0),314314(1),309309(2),305305(3),310310(4),301301(5),324324(6),320320(7),323323(8),559559(9),541541(10),529529(11),545545(12),538538(13),315315(18),309309(19),304304(20),299299(21),304304(22),301301(23),320320(24),320320(25),319319(26),546546(27),534534(28),520520(29),542542(30),532532(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10813803,77241,111971,Lock-Free (DWCAS 2),308308(0),318318(1),315315(2),313313(3),314314(4),306306(5),301301(6),304304(7),307307(8),546546(9),539539(10),522522(11),504504(12),534534(13),300300(18),311311(19),308308(20),311311(21),312312(22),306306(23),296296(24),301301(25),302302(26),536536(27),533533(28),516516(29),501501(30),539539(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 11331320,80938,139830,Lock-Free (DWCAS 3),295295(0),304304(1),307307(2),312312(3),314314(4),312312(5),312312(6),312312(7),304304(8),556556(9),577577(10),579579(11),610610(12),598598(13),293293(18),299299(19),306306(20),309309(21),310310(22),307307(23),307307(24),308308(25),304304(26),544544(27),570570(28),569569(29),604604(30),598598(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 11053042,78950,149610,Lock-Free (DWCAS 4),525525(0),528528(1),516516(2),512512(3),517517(4),510510(5),448448(6),492492(7),492492(8),208208(9),201201(10),200200(11),210210(12),212212(13),510510(18),512512(19),503503(20),503503(21),509509(22),498498(23),438438(24),484484(25),479479(26),201201(27),205205(28),206206(29),211211(30),212212(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9447438,67482,116370,Lock-Free (DWCAS 5),247247(0),252252(1),254254(2),255255(3),253253(4),256256(5),265265(6),260260(7),266266(8),487487(9),472472(10),476476(11),484484(12),502502(13),249249(18),249249(19),247247(20),254254(21),255255(22),255255(23),257257(24),261261(25),262262(26),486486(27),471471(28),477477(29),485485(30),501501(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 8779771,62713,98652,Lock-Free (DWCAS 6),241241(0),242242(1),245245(2),248248(3),248248(4),239239(5),244244(6),245245(7),248248(8),433433(9),425425(10),440440(11),450450(12),447447(13),239239(18),244244(19),244244(20),246246(21),247247(22),238238(23),242242(24),245245(25),247247(26),426426(27),426426(28),436436(29),452452(30),444444(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9583574,68454,100461,Lock-Free (DWCAS 7),414414(0),425425(1),414414(2),417417(3),406406(4),408408(5),410410(6),418418(7),429429(8),220220(9),231231(10),202202(11),217217(12),209209(13),408408(18),420420(19),405405(20),410410(21),398398(22),402402(23),408408(24),412412(25),418418(26),215215(27),227227(28),200200(29),221221(30),210210(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 8591583,61368,38809,Lock-Free (DWCAS 8),317317(0),319319(1),336336(2),337337(3),339339(4),333333(5),343343(6),342342(7),341341(8),245245(9),243243(10),262262(11),270270(12),276276(13),314314(18),314314(19),331331(20),334334(21),337337(22),334334(23),339339(24),338338(25),337337(26),244244(27),241241(28),265265(29),276276(30),276276(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9109100,65065,105890,Lock-Free (DWCAS 9),247247(0),256256(1),252252(2),250250(3),245245(4),249249(5),235235(6),259259(7),260260(8),447447(9),451451(10),461461(11),462462(12),476476(13),245245(18),255255(19),248248(20),252252(21),247247(22),247247(23),250250(24),257257(25),259259(26),448448(27),448448(28),458458(29),461461(30),475475(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 10141131,72437,106087,Lock-Free (DWCAS 10),290290(0),292292(1),286286(2),288288(3),287287(4),281281(5),291291(6),292292(7),301301(8),523523(9),454454(10),496496(11),516516(12),492492(13),289289(18),289289(19),280280(20),285285(21),282282(22),272272(23),287287(24),298298(25),297297(26),514514(27),443443(28),495495(29),519519(30),492492(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 23505482,167896,41653,PThread Mutex,789789(0),807807(1),810810(2),812812(3),814814(4),846846(5),812812(6),804804(7),789789(8),890890(9),868868(10),894894(11),895895(12),894894(13),813813(18),806806(19),815815(20),810810(21),808808(22),869869(23),803803(24),811811(25),795795(26),888888(27),870870(28),885885(29),902902(30),883883(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 11612601,82947,76542,PThread Spinlock (private),438438(0),470470(1),391391(2),436436(3),474474(4),471471(5),397397(6),481481(7),511511(8),289289(9),276276(10),302302(11),406406(12),432432(13),445445(18),474474(19),394394(20),440440(21),474474(22),472472(23),399399(24),484484(25),515515(26),293293(27),280280(28),306306(29),412412(30),439439(31)
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1                 9737728,69555,159324,PThread Spinlock (shared),231231(0),259259(1),199199(2),205205(3),274274(4),295295(5),107107(6),309309(7),306306(8),434434(9),442442(10),518518(11),584584(12),625625(13),237237(18),272272(19),208208(20),215215(21),289289(22),299299(23),109109(24),324324(25),318318(26),446446(27),454454(28),531531(29),599599(30),639639(31)

Around halfway you’ll notice there’s a massive imbalance in per-core performance - that’s when we cross over into the second NUMA node. I think somehow the core which is in the next NUMA node gets a huge boost because it has a bunch of hardware all to itself (even though the freelist elements its using are in the other NUMA node - or maybe they’re not? the NUMA question is going to cloud these results a bit).

Check this

Key
===
M  = Memory
N  = NUMA node
S  = Socket (physical package)
Ln = Level n cache
D  = Data cache
I  = Instruction cache
U  = Unified cache
P  = Physical core
L  = Logical core

Topology
========
                                   M                                   
                 N                                   N                 
                 S                                   S                 
                L3U                                 L3U                
L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U L2U
L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D L1D
L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I L1I
 P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P   P 
L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L L

Dat’s EIGHTEEN physical cores, bro.

Wierd City

I’ve been testing PRNG exponential backoff (i.e. exponential with random selection of the backoff period within the maximum value) vs non-PRNG exponential, with one thread per logical core (as well as with one thread per physical core, as before).

Here’s one per physical core with PRNG;

  1   1 28016989,2801699,1298838,Lock-Free (DWCAS 0),18600582(2),9416407(3)
  1   1 43457414,4345741,2799545,Lock-Free (DWCAS 1),31626595(2),11830819(3)
  1   1 66663597,6666360,7463048,Lock-Free (DWCAS 2),59717658(2),6945939(3)
  1   1 77728651,7772865,5387455,Lock-Free (DWCAS 3),57911854(2),19816797(3)
  1   1 84717633,8471763,4321204,Lock-Free (DWCAS 4),57636579(2),27081054(3)
  1   1 98935837,9893584,11462480,Lock-Free (DWCAS 5),89993904(2),8941933(3)
  1   1 97963866,9796387,6052092,Lock-Free (DWCAS 6),70379309(2),27584557(3)
  1   1 100029930,10002993,6060869,Lock-Free (DWCAS 7),71443372(2),28586558(3)
  1   1 104555451,10455545,7219560,Lock-Free (DWCAS 8),77802725(2),26752726(3)
  1   1 109567458,10956746,12270095,Lock-Free (DWCAS 9),98165067(2),11402391(3)
  1   1 108824716,10882472,7428648,Lock-Free (DWCAS 10),80676596(2),28148120(3)

Here’s one per physical core without PRNG;

  1   1 29258229,2925823,210221,Lock-Free (DWCAS 0),13885872(2),15372357(3)
  1   1 42014973,4201497,688703,Lock-Free (DWCAS 1),23442419(2),18572554(3)
  1   1 85045961,8504596,6398496,Lock-Free (DWCAS 2),19900881(2),65145080(3)
  1   1 93979886,9397989,2227066,Lock-Free (DWCAS 3),54863809(2),39116077(3)
  1   1 100927827,10092783,1066676,Lock-Free (DWCAS 4),54235181(2),46692646(3)
  1   1 106403297,10640330,3351216,Lock-Free (DWCAS 5),41353312(2),65049985(3)
  1   1 110576466,11057647,6407981,Lock-Free (DWCAS 6),77943866(2),32632600(3)
  1   1 112774662,11277466,1033408,Lock-Free (DWCAS 7),60040981(2),52733681(3)
  1   1 113648535,11364854,1819790,Lock-Free (DWCAS 8),50390340(2),63258195(3)
  1   1 115484369,11548437,5934170,Lock-Free (DWCAS 9),36761725(2),78722644(3)
  1   1 115787672,11578767,3090315,Lock-Free (DWCAS 10),46967921(2),68819751(3)

The numbers in brackets after the per-thread operation counts are the logical core number - of the four logical cores on this processor, they are numbered “0 2 1 3”, so with these results we see cores 2 and 3 are in use, which is correct.

So what do we see?

We see that adding PRNG causes a great deal of unfairness. One core dominates the other. Removing PRNG ameilorates this problem.

Now for the same test, but with one thread per logical core.

Here’s with PRNG:

1 1 1 1 16891875,844594,42260,Lock-Free (DWCAS 0),4346342(0),4308304(1),4105101(2),4132128(3)
1 1 1 1 30234204,1511710,243254,Lock-Free (DWCAS 1),7863856(0),6791785(1),8377369(2),7201194(3)
1 1 1 1 51525474,2576274,1305152,Lock-Free (DWCAS 2),15116101(0),9191182(1),16993977(2),10224214(3)
1 1 1 1 57755698,2887785,435470,Lock-Free (DWCAS 3),14485471(0),12932920(1),16006991(2),14330316(3)
1 1 1 1 66340274,3317014,369968,Lock-Free (DWCAS 4),16262246(0),15346331(1),17896879(2),16834818(3)
1 1 1 1 70905835,3545292,406541,Lock-Free (DWCAS 5),17531514(0),16371355(1),19228209(2),17774757(3)
1 1 1 1 75253178,3762659,382059,Lock-Free (DWCAS 6),18508490(0),17467450(1),20076056(2),19201182(3)
1 1 1 1 77178101,3858905,422453,Lock-Free (DWCAS 7),19131112(0),17836819(1),20810790(2),19399380(3)
1 1 1 1 80003924,4000196,418052,Lock-Free (DWCAS 8),19690671(0),18569551(1),21466445(2),20277257(3)
1 1 1 1 80826746,4041337,390458,Lock-Free (DWCAS 9),20054034(0),18903885(1),21652631(2),20216196(3)
1 1 1 1 82815733,4140787,483791,Lock-Free (DWCAS 10),20185165(0),19144125(1),22446424(2),21040019(3)

And here’s without;

1 1 1 1 16811795,840590,67149,Lock-Free (DWCAS 0),4410406(0),4323319(1),4066062(2),4012008(3)
1 1 1 1 34895861,1744793,839997,Lock-Free (DWCAS 1),10458448(0),6442436(1),11151140(2),6843837(3)
1 1 1 1 66736670,3336834,5366808,Lock-Free (DWCAS 2),26307281(0),3424421(1),33419386(2),3585582(3)
1 1 1 1 73384311,3669216,3538059,Lock-Free (DWCAS 3),24524500(0),9081072(1),29485456(2),10293283(3)
1 1 1 1 80230150,4011508,3198655,Lock-Free (DWCAS 4),26693667(0),11626615(1),29293264(2),12616604(3)
1 1 1 1 83523440,4176172,3557993,Lock-Free (DWCAS 5),28376348(0),11609598(1),31063032(2),12474462(3)
1 1 1 1 86013928,4300696,3371883,Lock-Free (DWCAS 6),29064035(0),12623611(1),30746716(2),13579566(3)
1 1 1 1 86905819,4345291,3466173,Lock-Free (DWCAS 7),29241212(0),12688676(1),31461430(2),13514501(3)
1 1 1 1 88407319,4420366,3405037,Lock-Free (DWCAS 8),29808779(0),13304291(1),31378347(2),13915902(3)
1 1 1 1 88689601,4434480,3760452,Lock-Free (DWCAS 9),30868838(0),12612600(1),32251219(2),12956944(3)
1 1 1 1 89872783,4493639,3492485,Lock-Free (DWCAS 10),30561531(0),13749736(1),31814783(2),13746733(3)

Oh boy. Wierd city, dude.

Without PRNG, one physical core dominates the other. Looking at DWCAS10, logical cores 0 and 2 (both in physical processor 0) get about 30m ops each, which logical cores 1 and 3 (physical 1) get about 13m each. It’s very unfair.

But now here when we add PRNG, wow! we do about 10% less work, but we’re MUCH more fair. All cores are doing about 20m ops.

I admit it. I’m lost. Anyone care to hit me with a clue bat?

I’m going to test this all now on a big amazon machine, with tons of cores, and see what I find there.

Bleark

I have not been looking closely enough at the results. Lots of digits in each number - easy to miss exactly how many digits difference there is between two numbers - and in particular I have not looked closely enough at the standard deviation column.

The back-off testing I’ve done so far has been on ARM.

I’ve been repeating the tests now on x64.

The standard deviation values are huge - i.e. one thread is dominating, the others are doing very little work.

I’ve modified the benchmark output to actually show the number of iterations performed by each thread.

Here’s an example, the freelist;

  1   1 28060032,2806003,1295583,Lock-Free (DWCAS 0),18610592,9449440
  1   1 44278234,4427823,2881935,Lock-Free (DWCAS 1),32328296,11949938
  1   1 66740674,6674067,7405432,Lock-Free (DWCAS 2),59552493,7188181
  1   1 76710634,7671063,5774912,Lock-Free (DWCAS 3),58772714,17937920
  1   1 84710626,8471063,4498865,Lock-Free (DWCAS 4),58261203,26449423
  1   1 99004906,9900491,11592576,Lock-Free (DWCAS 5),90488398,8516508
  1   1 97875778,9787578,6058038,Lock-Free (DWCAS 6),70356286,27519492
  1   1 99880781,9988078,5948326,Lock-Free (DWCAS 7),70970900,28909881
  1   1 104587483,10458748,7230319,Lock-Free (DWCAS 8),77856779,26730704
  1   1 109813704,10981370,11987819,Lock-Free (DWCAS 9),97290193,12523511
  1   1 108797689,10879769,7387170,Lock-Free (DWCAS 10),80516436,28281253

One thread is generally doing about 70% to 80& of the work.

Now, it’s kinda interesting - very interesting in fact - to look at the values for the GCC spinlocks;

  1   1 16391375,1639138,13448,GCC Spinlock (atomic),8148140,8243235
  1   1 17053036,1705304,20385,GCC Spinlock (sync),8454446,8598590

These guys are very fair. I’m not quite sure how they’re doing it, in fact! although DWCAS 0 still is doing some work (I’ve not removed the back-off code, just set it so it’s always 0) and that might be in effect a back-off which the GCC spinlocks simply do not have.

But - fair as they are, if we compare them to all of the DWCAS values, we still see all DWCAS threads are doing more work than all of the GCC spinlock threads.

On ARM, this behaviour happens MUCH less. Here’s an example for ARM;

1 1 1 1 17640623,882031,19892,Lock-Free (DWCAS 0)
1 1 1 1 23285262,1164263,73337,Lock-Free (DWCAS 1)
1 1 1 1 26168142,1308407,84105,Lock-Free (DWCAS 2)
1 1 1 1 28152124,1407606,96889,Lock-Free (DWCAS 3)
1 1 1 1 29036007,1451800,116736,Lock-Free (DWCAS 4)
1 1 1 1 29464435,1473222,86809,Lock-Free (DWCAS 5)
1 1 1 1 29650621,1482531,95732,Lock-Free (DWCAS 6)
1 1 1 1 29559530,1477976,98744,Lock-Free (DWCAS 7)
1 1 1 1 29763734,1488187,94874,Lock-Free (DWCAS 8)
1 1 1 1 29939910,1496996,108147,Lock-Free (DWCAS 9)
1 1 1 1 30086056,1504303,62667,Lock-Free (DWCAS 10)

Now, I may be - ha, may WELL be - utterly wrong, but I suspect what’s going on here may be a combination of the difference between LL/SC and CAS, and the work the benchmark is doing.

The benchmark is simply a loop, where a thread pops and then pushes. The freelist starts with one element per thread.

Now, with CAS on Intel, as I understand it, a logical core will lock the cache line which is the target for the CAS, and then perform the operation.

So the benchmark begins, one of the threads gets to lock first, the other stalls, and then when the first is done, the second runs - and fails, because a push or a pop has occurred - and the other thread by then is probably stalling on its next pop or push, and it will again succeed, causing the second thread to fail again…

With LL/SC, there’s no stalling - every code just runs it code - and if some-one else performs the operation in question then our attempt fails.

So with CAS, it’s almost like we need to run the back-off on EVERY operation, not just a FAILED operation.

2016-02-03

Further experimental results

I modified the backoff to be non-exponential; to just be a fixed number of loop iterations.

First, here’s the one-thread-per-core result, with exponential backoff, for the freelist on ARM;

1 1 1 1 17640623,882031,19892,Lock-Free (DWCAS 0)
1 1 1 1 23285262,1164263,73337,Lock-Free (DWCAS 1)
1 1 1 1 26168142,1308407,84105,Lock-Free (DWCAS 2)
1 1 1 1 28152124,1407606,96889,Lock-Free (DWCAS 3)
1 1 1 1 29036007,1451800,116736,Lock-Free (DWCAS 4)
1 1 1 1 29464435,1473222,86809,Lock-Free (DWCAS 5)
1 1 1 1 29650621,1482531,95732,Lock-Free (DWCAS 6)
1 1 1 1 29559530,1477976,98744,Lock-Free (DWCAS 7)
1 1 1 1 29763734,1488187,94874,Lock-Free (DWCAS 8)
1 1 1 1 29939910,1496996,108147,Lock-Free (DWCAS 9)
1 1 1 1 30086056,1504303,62667,Lock-Free (DWCAS 10)

Now here’s the same, with a non-exponential backoff;

1 1 1 1 17013997,850700,14393,Lock-Free (DWCAS 0)
1 1 1 1 19076057,953803,490883,Lock-Free (DWCAS 1)
1 1 1 1 17042025,852101,14743,Lock-Free (DWCAS 2)
1 1 1 1 18177159,908858,42810,Lock-Free (DWCAS 3)
1 1 1 1 17071054,853553,45057,Lock-Free (DWCAS 4)
1 1 1 1 16705689,835284,33913,Lock-Free (DWCAS 5)
1 1 1 1 20509489,1025474,66327,Lock-Free (DWCAS 6)
1 1 1 1 17431414,871571,24032,Lock-Free (DWCAS 7)
1 1 1 1 17526509,876325,23812,Lock-Free (DWCAS 8)
1 1 1 1 18478460,923923,32485,Lock-Free (DWCAS 9)
1 1 1 1 18889871,944494,28001,Lock-Free (DWCAS 10)

Obviously, comparing these two sets of results, exponential has much better performance.

However, what exponential really means is - longer backoffs, when things get busy. This could in fact simply be approximately the same as - longer backoffs.

The exponential backoff, when set to a value of 10, has a maximum iteration count of 2^10 * 10 (10240), as the exponential part has a maximum power of 10, before it resets back to 1.

The results for a fixed period backoff of 10240-10250 are;

1 1 1 1 31359328,1567966,277086,Lock-Free (DWCAS 10240)
1 1 1 1 31350319,1567516,187042,Lock-Free (DWCAS 10241)
1 1 1 1 31350319,1567516,337291,Lock-Free (DWCAS 10242)
1 1 1 1 31367336,1568367,260849,Lock-Free (DWCAS 10243)
1 1 1 1 31372341,1568617,247379,Lock-Free (DWCAS 10244)
1 1 1 1 31375344,1568767,250752,Lock-Free (DWCAS 10245)
1 1 1 1 31363332,1568167,220210,Lock-Free (DWCAS 10246)
1 1 1 1 31349318,1567466,201058,Lock-Free (DWCAS 10247)
1 1 1 1 31353322,1567666,130502,Lock-Free (DWCAS 10248)
1 1 1 1 31353322,1567666,361582,Lock-Free (DWCAS 10249)
1 1 1 1 31351320,1567566,348364,Lock-Free (DWCAS 10250)

Well! ain’t dat interestin’. We have the same performance as with exponential - not quite as good, because the standard deviation is about 10x larger, which means the cores are not being treated as fairly; some cores are getting more, others less - but still, overall, three times faster than the original above.

At this point it is illuminating to display the results for a single thread.

1 31495464,6299093,0,Lock-Free (DWCAS 1024)
1 31495464,6299093,0,Lock-Free (DWCAS 1025)
1 31494463,6298893,0,Lock-Free (DWCAS 1026)
1 31495464,6299093,0,Lock-Free (DWCAS 1027)
1 31494463,6298893,0,Lock-Free (DWCAS 1028)
1 31495464,6299093,0,Lock-Free (DWCAS 1029)
1 31495464,6299093,0,Lock-Free (DWCAS 1030)
1 31495464,6299093,0,Lock-Free (DWCAS 1031)
1 31495464,6299093,0,Lock-Free (DWCAS 1032)
1 31495464,6299093,0,Lock-Free (DWCAS 1033)
1 31495464,6299093,0,Lock-Free (DWCAS 1034)

What we do understand from this? well, we see the total result is approximately equal to the total result for all four cores. In other words, there is a bottleneck, upstream of the cores, which determines maximum performance. (Memory bandwidth, basically).

Next I tried an outlier, with a non-exponential backoff of 4000-4010, and then another, 8000-8010.

1 1 1 1 31232201,1561610,116169,Lock-Free (DWCAS 4000)
1 1 1 1 31233202,1561660,101224,Lock-Free (DWCAS 4001)
1 1 1 1 31237206,1561860,157937,Lock-Free (DWCAS 4002)
1 1 1 1 31270239,1563512,104374,Lock-Free (DWCAS 4003)
1 1 1 1 31280249,1564012,105804,Lock-Free (DWCAS 4004)
1 1 1 1 31282251,1564113,176778,Lock-Free (DWCAS 4005)
1 1 1 1 31273242,1563662,154924,Lock-Free (DWCAS 4006)
1 1 1 1 31237206,1561860,181227,Lock-Free (DWCAS 4007)
1 1 1 1 31234203,1561710,175386,Lock-Free (DWCAS 4008)
1 1 1 1 31239208,1561960,194485,Lock-Free (DWCAS 4009)
1 1 1 1 31233202,1561660,113455,Lock-Free (DWCAS 4010)
1 1 1 1 31330299,1566515,275351,Lock-Free (DWCAS 8000)
1 1 1 1 31330299,1566515,229374,Lock-Free (DWCAS 8001)
1 1 1 1 31326295,1566315,324406,Lock-Free (DWCAS 8002)
1 1 1 1 31350319,1567516,107952,Lock-Free (DWCAS 8003)
1 1 1 1 31350319,1567516,214843,Lock-Free (DWCAS 8004)
1 1 1 1 31355324,1567766,77613,Lock-Free (DWCAS 8005)
1 1 1 1 31349318,1567466,220408,Lock-Free (DWCAS 8006)
1 1 1 1 31330299,1566515,214035,Lock-Free (DWCAS 8007)
1 1 1 1 31333302,1566665,255280,Lock-Free (DWCAS 8008)
1 1 1 1 31331300,1566565,358338,Lock-Free (DWCAS 8009)
1 1 1 1 31330299,1566515,293006,Lock-Free (DWCAS 8010)

Total throughput is the same, but the standard deviation doubles - so the 8000 backoff is worse, because the performance is the same but it’s less fair.

So we see, so far, that once the backoff is long enough, we reach the maximum performance allowed by the upstream bottleneck, but after that, we become more and more unfair.

So it would be instructive now to find the lowest non-exponential backoff which achieves maximum or nearly maximum performance (i.e. with the least unfairness).

This turns out to be about the 550 mark, if I pick about 30,000,000 as the target total ops.

1 1 1 1 30066036,1503302,123386,Lock-Free (DWCAS 550)
1 1 1 1 30075045,1503752,111128,Lock-Free (DWCAS 551)
1 1 1 1 30091061,1504553,132532,Lock-Free (DWCAS 552)
1 1 1 1 30312282,1515614,121997,Lock-Free (DWCAS 553)
1 1 1 1 30350320,1517516,130751,Lock-Free (DWCAS 554)
1 1 1 1 30357327,1517866,69512,Lock-Free (DWCAS 555)
1 1 1 1 30282252,1514113,101445,Lock-Free (DWCAS 556)
1 1 1 1 30070040,1503502,129679,Lock-Free (DWCAS 557)
1 1 1 1 30054024,1502701,97377,Lock-Free (DWCAS 558)
1 1 1 1 30051021,1502551,101635,Lock-Free (DWCAS 559)
1 1 1 1 30056026,1502801,113993,Lock-Free (DWCAS 560)

For easy reference, here are the original exponential results;

1 1 1 1 17640623,882031,19892,Lock-Free (DWCAS 0)
1 1 1 1 23285262,1164263,73337,Lock-Free (DWCAS 1)
1 1 1 1 26168142,1308407,84105,Lock-Free (DWCAS 2)
1 1 1 1 28152124,1407606,96889,Lock-Free (DWCAS 3)
1 1 1 1 29036007,1451800,116736,Lock-Free (DWCAS 4)
1 1 1 1 29464435,1473222,86809,Lock-Free (DWCAS 5)
1 1 1 1 29650621,1482531,95732,Lock-Free (DWCAS 6)
1 1 1 1 29559530,1477976,98744,Lock-Free (DWCAS 7)
1 1 1 1 29763734,1488187,94874,Lock-Free (DWCAS 8)
1 1 1 1 29939910,1496996,108147,Lock-Free (DWCAS 9)
1 1 1 1 30086056,1504303,62667,Lock-Free (DWCAS 10)

And here, with non-exponential backoff 0-10;

1 1 1 1 17013997,850700,14393,Lock-Free (DWCAS 0)
1 1 1 1 19076057,953803,490883,Lock-Free (DWCAS 1)
1 1 1 1 17042025,852101,14743,Lock-Free (DWCAS 2)
1 1 1 1 18177159,908858,42810,Lock-Free (DWCAS 3)
1 1 1 1 17071054,853553,45057,Lock-Free (DWCAS 4)
1 1 1 1 16705689,835284,33913,Lock-Free (DWCAS 5)
1 1 1 1 20509489,1025474,66327,Lock-Free (DWCAS 6)
1 1 1 1 17431414,871571,24032,Lock-Free (DWCAS 7)
1 1 1 1 17526509,876325,23812,Lock-Free (DWCAS 8)
1 1 1 1 18478460,923923,32485,Lock-Free (DWCAS 9)
1 1 1 1 18889871,944494,28001,Lock-Free (DWCAS 10)

What do we draw from all this?

First, that large variations in the non-exponential backoff are required to make a difference to performance. Exponential side-steps this problem by increasing in a non-linear fashion, where the backoff value, although fixed, is on each iteration of backoff being mutiplied by 1 - 2 - 4 - 8 - 16 - 32 - 64 - 128 - 256 - 512 and finally 1024 (before going back to 1).

So the exponential backoff of 10 gives us a non-exponential backoff of 10, 20, 40, 80, 160, 320, 640, 1280, 2560, 5120, 10240.

What also see is that the lower the non-exponential backoff, the more fair the results - the lower the standard deviation (with the strange and not obviously explicable huge value for DWCAS 1, and that result repeats - it’s not a one-off). However, we also see that the lower the non-exponential value, the lower the overall performance.

We also see exponential backoff values from 4 to 10, inclusive, all give good performance and pretty good fairness.

My general view then - for the ARM platform, for what we see here may be totally different on MIPS or Intel, etc, or with many more cores - exponential backoff is better because it makes the choice of the correct backoff value MUCH less sensitive.

Next experiments are going to be on high-core count Intel systems. I want to see if the PRNG part of the backoff matters there, and I want to see how all the above pans out on a CAS system, rather than an LL/SC system.

2016-02-02

Sixth light - ARM with backoff

Somewhat puzzling results.

So, backoff matters - for freelist and as before when crossing physical cores.

That’s fine.

Now check the single-thread queue result for lock-free. It’s deterministic! that’s totally bizzare and unexpected - this is on a live (albeit idle) Linux system. It must be a bug!

Then, similarly, for the rest of queue, back-off seems to make no difference.

Now I have to figure out what’s going on here =-)

Freelist Push One Pop One

   M   
   S   
P P P P
L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type
      1 35185150,7037030,0,GCC Spinlock (atomic)
      1 23315292,4663058,0,GCC Spinlock (sync)
      1 31497466,6299493,0,Lock-Free (DWCAS 0)
      1 31497466,6299493,0,Lock-Free (DWCAS 1)
      1 31497466,6299493,0,Lock-Free (DWCAS 2)
      1 31497466,6299493,0,Lock-Free (DWCAS 3)
      1 31498467,6299693,0,Lock-Free (DWCAS 4)
      1 31498467,6299693,0,Lock-Free (DWCAS 5)
      1 31498467,6299693,0,Lock-Free (DWCAS 6)
      1 31498467,6299693,0,Lock-Free (DWCAS 7)
      1 31498467,6299693,0,Lock-Free (DWCAS 8)
      1 31499468,6299894,0,Lock-Free (DWCAS 9)
      1 31498467,6299693,0,Lock-Free (DWCAS 10)
      1 14279265,2855853,0,PThread Mutex
      1 25433408,5086682,0,PThread Spinlock (private)
      1 25432407,5086481,0,PThread Spinlock (shared)
1 1 1 1 16087071,804354,2961,GCC Spinlock (atomic)
1 1 1 1 13944931,697247,49849,GCC Spinlock (sync)
1 1 1 1 17640623,882031,19892,Lock-Free (DWCAS 0)
1 1 1 1 23285262,1164263,73337,Lock-Free (DWCAS 1)
1 1 1 1 26168142,1308407,84105,Lock-Free (DWCAS 2)
1 1 1 1 28152124,1407606,96889,Lock-Free (DWCAS 3)
1 1 1 1 29036007,1451800,116736,Lock-Free (DWCAS 4)
1 1 1 1 29464435,1473222,86809,Lock-Free (DWCAS 5)
1 1 1 1 29650621,1482531,95732,Lock-Free (DWCAS 6)
1 1 1 1 29559530,1477976,98744,Lock-Free (DWCAS 7)
1 1 1 1 29763734,1488187,94874,Lock-Free (DWCAS 8)
1 1 1 1 29939910,1496996,108147,Lock-Free (DWCAS 9)
1 1 1 1 30086056,1504303,62667,Lock-Free (DWCAS 10)
1 1 1 1 6391385,319569,13732,PThread Mutex
1 1 1 1 10378368,518918,6813,PThread Spinlock (private)
1 1 1 1 10356346,517817,13782,PThread Spinlock (shared)
    1 1 19879860,1987986,9343,GCC Spinlock (atomic)
    1 1 13400387,1340039,4672,GCC Spinlock (sync)
    1 1 17836819,1783682,296574,Lock-Free (DWCAS 0)
    1 1 27857830,2785783,10759,Lock-Free (DWCAS 1)
    1 1 29423394,2942339,10193,Lock-Free (DWCAS 2)
    1 1 30032002,3003200,5663,Lock-Free (DWCAS 3)
    1 1 30385355,3038536,20810,Lock-Free (DWCAS 4)
    1 1 30545515,3054552,25623,Lock-Free (DWCAS 5)
    1 1 30738708,3073871,2831,Lock-Free (DWCAS 6)
    1 1 30836806,3083681,51529,Lock-Free (DWCAS 7)
    1 1 30910880,3091088,53228,Lock-Free (DWCAS 8)
    1 1 30974944,3097494,48414,Lock-Free (DWCAS 9)
    1 1 31015985,3101598,15430,Lock-Free (DWCAS 10)
    1 1 3898895,389890,1274,PThread Mutex
    1 1 11090079,1109008,6937,PThread Spinlock (private)
    1 1 11090079,1109008,12316,PThread Spinlock (shared)
  1 1 1 16413397,1094226,22509,GCC Spinlock (atomic)
  1 1 1 13315302,887687,48504,GCC Spinlock (sync)
  1 1 1 18945927,1263062,221660,Lock-Free (DWCAS 0)
  1 1 1 26529503,1768634,120754,Lock-Free (DWCAS 1)
  1 1 1 28478450,1898563,129715,Lock-Free (DWCAS 2)
  1 1 1 28676648,1911777,171176,Lock-Free (DWCAS 3)
  1 1 1 29308279,1953885,157572,Lock-Free (DWCAS 4)
  1 1 1 29695666,1979711,155581,Lock-Free (DWCAS 5)
  1 1 1 29959930,1997329,118840,Lock-Free (DWCAS 6)
  1 1 1 30145115,2009674,72812,Lock-Free (DWCAS 7)
  1 1 1 30565535,2037702,113511,Lock-Free (DWCAS 8)
  1 1 1 30658628,2043909,120734,Lock-Free (DWCAS 9)
  1 1 1 30739709,2049314,122498,Lock-Free (DWCAS 10)
  1 1 1 5842837,389522,13478,PThread Mutex
  1 1 1 11063052,737537,555199,PThread Spinlock (private)
  1 1 1 11064053,737604,561915,PThread Spinlock (shared)

Queue Enqueue One Dequeue One

   M   
   S   
P P P P
L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type
      1 31280249,6256050,0,GCC Spinlock (atomic)
      1 20549529,4109906,0,GCC Spinlock (sync)
      1 14745731,2949146,0,Lock-Free (DWCAS 0)
      1 14745731,2949146,0,Lock-Free (DWCAS 1)
      1 14745731,2949146,0,Lock-Free (DWCAS 2)
      1 14745731,2949146,0,Lock-Free (DWCAS 3)
      1 14745731,2949146,0,Lock-Free (DWCAS 4)
      1 14745731,2949146,0,Lock-Free (DWCAS 5)
      1 14745731,2949146,0,Lock-Free (DWCAS 6)
      1 14745731,2949146,0,Lock-Free (DWCAS 7)
      1 14745731,2949146,0,Lock-Free (DWCAS 8)
      1 14745731,2949146,0,Lock-Free (DWCAS 9)
      1 14745731,2949146,0,Lock-Free (DWCAS 10)
      1 13629616,2725923,0,PThread Mutex
      1 23201178,4640236,0,PThread Spinlock (private)
      1 23202179,4640436,0,PThread Spinlock (shared)
1 1 1 1 23403380,1170169,14742,GCC Spinlock (atomic)
1 1 1 1 20153133,1007657,26732,GCC Spinlock (sync)
1 1 1 1 17854837,892742,10035,Lock-Free (DWCAS 0)
1 1 1 1 18008991,900450,11774,Lock-Free (DWCAS 1)
1 1 1 1 18134116,906706,14812,Lock-Free (DWCAS 2)
1 1 1 1 18220202,911010,15063,Lock-Free (DWCAS 3)
1 1 1 1 18278260,913913,18031,Lock-Free (DWCAS 4)
1 1 1 1 18285267,914263,17856,Lock-Free (DWCAS 5)
1 1 1 1 18408390,920420,21765,Lock-Free (DWCAS 6)
1 1 1 1 18418400,920920,21361,Lock-Free (DWCAS 7)
1 1 1 1 18538520,926926,20086,Lock-Free (DWCAS 8)
1 1 1 1 18536518,926826,22936,Lock-Free (DWCAS 9)
1 1 1 1 18656638,932832,24218,Lock-Free (DWCAS 10)
1 1 1 1 8533525,426676,10860,PThread Mutex
1 1 1 1 17157140,857857,10236,PThread Spinlock (private)
1 1 1 1 17181164,859058,10352,PThread Spinlock (shared)
    1 1 26557531,2655753,708,GCC Spinlock (atomic)
    1 1 25475450,2547545,566,GCC Spinlock (sync)
    1 1 22513491,2251349,991,Lock-Free (DWCAS 0)
    1 1 22511489,2251149,991,Lock-Free (DWCAS 1)
    1 1 22514492,2251449,1133,Lock-Free (DWCAS 2)
    1 1 22511489,2251149,991,Lock-Free (DWCAS 3)
    1 1 22509487,2250949,991,Lock-Free (DWCAS 4)
    1 1 22515493,2251549,991,Lock-Free (DWCAS 5)
    1 1 22508486,2250849,849,Lock-Free (DWCAS 6)
    1 1 22510488,2251049,849,Lock-Free (DWCAS 7)
    1 1 22515493,2251549,991,Lock-Free (DWCAS 8)
    1 1 22509487,2250949,991,Lock-Free (DWCAS 9)
    1 1 22514492,2251449,1133,Lock-Free (DWCAS 10)
    1 1 5277272,527727,18686,PThread Mutex
    1 1 24609585,2460958,708,PThread Spinlock (private)
    1 1 24611587,2461159,708,PThread Spinlock (shared)
  1 1 1 24698674,1646578,18354,GCC Spinlock (atomic)
  1 1 1 19022003,1268134,8570,GCC Spinlock (sync)
  1 1 1 18665647,1244376,22695,Lock-Free (DWCAS 0)
  1 1 1 18686668,1245778,21320,Lock-Free (DWCAS 1)
  1 1 1 18689671,1245978,23144,Lock-Free (DWCAS 2)
  1 1 1 18701683,1246779,24981,Lock-Free (DWCAS 3)
  1 1 1 18705687,1247046,24622,Lock-Free (DWCAS 4)
  1 1 1 18726708,1248447,32907,Lock-Free (DWCAS 5)
  1 1 1 18776758,1251784,34281,Lock-Free (DWCAS 6)
  1 1 1 18781763,1252118,34080,Lock-Free (DWCAS 7)
  1 1 1 18871853,1258124,36373,Lock-Free (DWCAS 8)
  1 1 1 18858840,1257256,36338,Lock-Free (DWCAS 9)
  1 1 1 18945927,1263062,37976,Lock-Free (DWCAS 10)
  1 1 1 8786778,585785,6375,PThread Mutex
  1 1 1 18502484,1233499,57919,PThread Spinlock (private)
  1 1 1 18499481,1233299,57914,PThread Spinlock (shared)

Fifth light - backoff period really matters

I’ve added to the benchmark the capability to benchmark a range of DWCAS backoff values.

Performance is sensitive to the backoff value - the difference in performance can be as large as about 8x - it really matters. Also, as I suspected, the optimal backoff value varies by data structure (so I can’t have as I do now one global value).

When running a single thread the backoff value doesn’t matter - you never collide with yourself.

When all the threads running are on the same physical core (i.e. say a four hyperthread physical core, so four logical processors, but all on the same core), backoff makes no or almost no difference, regardless of data structure - the physical processor knows what’s going on across all its logical cores and arranges scheduling so there are no collisions.

When we move threads out across multiple physical cores, though, the backoff period makes a lot of difference to performance. My current (untested) thought in this case is that setting the backoff correctly for the maximum workloads is the right choice; to the extent you’re less busy than that, you’re less likely to be having collisions anyway, and so you care less and less about the backoff value being right.

I need to test this though. I need a partial load benchmark - right now I have a full load benchmark, where the threads run a tight loop simply performing pop/push or dequeue/enqueue calls. So I need a loop basically with a controllable delay between atomic ops, and I need to vary that delay.

Turning now to the results (which are getting longer and longer!), we can firstly set aside the single-thread and all-threads-on-one-physical-core thread sets, as backoff doesn’t matter.

The DWCAS range tested is 0 to 10, inclusive.

If we look then as the other two thread sets, one thread per physical core and one thread on every logical core, we see for the freelist as the DWCAS backoff increases, performance increases. We do not in fact see performance decrease, so even a backoff of 10 is too small (although the increases have become small by then).

If we look however at the queue, we see with one thread per physical core the optimal DWCAS backoff is 6. This gives a peak of 40,205,165 operations per second. If we increase or decrease backoff by one - just one! - we lose about 10,000,000 operations per second. Whooosh!

The problem is, this backoff value is only going to be right for my particualr processor with its particular clock speed.

If we then look at one-thread-on-every-logical-core, we see - awkwardly - performance still rising as we get to a backoff of 10. However, in this case, the difference is much, much smaller - going from DWCAS 0 to 10 adds about 4,000,000 operations; going from DWCAS 9 to 10 adds about 100,000 - probably a chance within the usual per-test variance.

Freelist Push One Pop One

   M   
   N   
   S   
  L3U  
L2U L2U
L1D L1D
L1I L1I
 P   P 
L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type
  1     159325166,31865033,0,GCC Spinlock (atomic)
  1     159512353,31902471,0,GCC Spinlock (sync)
  1     134521387,26904277,0,Lock-Free (DWCAS 0)
  1     134466332,26893266,0,Lock-Free (DWCAS 1)
  1     134568434,26913687,0,Lock-Free (DWCAS 2)
  1     134558424,26911685,0,Lock-Free (DWCAS 3)
  1     134549415,26909883,0,Lock-Free (DWCAS 4)
  1     134605471,26921094,0,Lock-Free (DWCAS 5)
  1     134438304,26887661,0,Lock-Free (DWCAS 6)
  1     134520386,26904077,0,Lock-Free (DWCAS 7)
  1     133647514,26729503,0,Lock-Free (DWCAS 8)
  1     134596462,26919292,0,Lock-Free (DWCAS 9)
  1     134496362,26899272,0,Lock-Free (DWCAS 10)
  1     97150053,19430011,0,PThread Mutex
  1     183086904,36617381,0,PThread Spinlock (private)
  1     183145963,36629193,0,PThread Spinlock (shared)
  1   1 16499483,1649948,10900,GCC Spinlock (atomic)
  1   1 17125108,1712511,27463,GCC Spinlock (sync)
  1   1 28201173,2820117,1271658,Lock-Free (DWCAS 0)
  1   1 42947905,4294790,2638872,Lock-Free (DWCAS 1)
  1   1 67146079,6714608,7524203,Lock-Free (DWCAS 2)
  1   1 76759683,7675968,5822052,Lock-Free (DWCAS 3)
  1   1 85787702,8578770,4353339,Lock-Free (DWCAS 4)
  1   1 98828730,9882873,11478759,Lock-Free (DWCAS 5)
  1   1 97956859,9795686,6006933,Lock-Free (DWCAS 6)
  1   1 99874775,9987478,5921146,Lock-Free (DWCAS 7)
  1   1 104545441,10454544,7179073,Lock-Free (DWCAS 8)
  1   1 109721612,10972161,12044161,Lock-Free (DWCAS 9)
  1   1 110770660,11077066,12010469,Lock-Free (DWCAS 10)
  1   1 12278266,1227827,45583,PThread Mutex
  1   1 22149127,2214913,1049122,PThread Spinlock (private)
  1   1 19243224,1924322,2330123,PThread Spinlock (shared)
1 1     74481407,7448141,47707,GCC Spinlock (atomic)
1 1     74966892,7496689,80125,GCC Spinlock (sync)
1 1     102240138,10224014,105040,Lock-Free (DWCAS 0)
1 1     103181078,10318108,888448,Lock-Free (DWCAS 1)
1 1     102488386,10248839,764722,Lock-Free (DWCAS 2)
1 1     102219117,10221912,685305,Lock-Free (DWCAS 3)
1 1     102142040,10214204,1166194,Lock-Free (DWCAS 4)
1 1     101971870,10197187,728199,Lock-Free (DWCAS 5)
1 1     101869768,10186977,646942,Lock-Free (DWCAS 6)
1 1     101861760,10186176,485560,Lock-Free (DWCAS 7)
1 1     101811710,10181171,710645,Lock-Free (DWCAS 8)
1 1     101786685,10178668,519960,Lock-Free (DWCAS 9)
1 1     101738637,10173864,568941,Lock-Free (DWCAS 10)
1 1     40219179,4021918,27888,PThread Mutex
1 1     114551437,11455144,933607,PThread Spinlock (private)
1 1     115891776,11589178,206399,PThread Spinlock (shared)
1 1 1 1 13513500,675675,119368,GCC Spinlock (atomic)
1 1 1 1 13740727,687036,212698,GCC Spinlock (sync)
1 1 1 1 17002986,850149,43669,Lock-Free (DWCAS 0)
1 1 1 1 30076046,1503802,233870,Lock-Free (DWCAS 1)
1 1 1 1 51405354,2570268,1130894,Lock-Free (DWCAS 2)
1 1 1 1 57724667,2886233,369728,Lock-Free (DWCAS 3)
1 1 1 1 66267201,3313360,392702,Lock-Free (DWCAS 4)
1 1 1 1 70794724,3539736,391461,Lock-Free (DWCAS 5)
1 1 1 1 75239164,3761958,359040,Lock-Free (DWCAS 6)
1 1 1 1 77145068,3857253,376639,Lock-Free (DWCAS 7)
1 1 1 1 80203123,4010156,497413,Lock-Free (DWCAS 8)
1 1 1 1 80796716,4039836,375427,Lock-Free (DWCAS 9)
1 1 1 1 82812730,4140636,485744,Lock-Free (DWCAS 10)
1 1 1 1 15654639,782732,5485,PThread Mutex
1 1 1 1 20225205,1011260,84782,PThread Spinlock (private)
1 1 1 1 16291275,814564,187390,PThread Spinlock (shared)

Queue Enqueue One Dequeue One

   M   
   N   
   S   
  L3U  
L2U L2U
L1D L1D
L1I L1I
 P   P 
L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type
  1     139550411,27910082,0,GCC Spinlock (atomic)
  1     139536397,27907279,0,GCC Spinlock (sync)
  1     105669564,21133913,0,Lock-Free (DWCAS 0)
  1     105723618,21144724,0,Lock-Free (DWCAS 1)
  1     105669564,21133913,0,Lock-Free (DWCAS 2)
  1     105736631,21147326,0,Lock-Free (DWCAS 3)
  1     105085981,21017196,0,Lock-Free (DWCAS 4)
  1     105662557,21132511,0,Lock-Free (DWCAS 5)
  1     105607502,21121500,0,Lock-Free (DWCAS 6)
  1     105591486,21118297,0,Lock-Free (DWCAS 7)
  1     105640535,21128107,0,Lock-Free (DWCAS 8)
  1     105569464,21113893,0,Lock-Free (DWCAS 9)
  1     105628523,21125705,0,Lock-Free (DWCAS 10)
  1     96419323,19283865,0,PThread Mutex
  1     202514312,40502862,0,PThread Spinlock (private)
  1     212104893,42420979,0,PThread Spinlock (shared)
  1   1 23690667,2369067,142,GCC Spinlock (atomic)
  1   1 23798775,2379878,142,GCC Spinlock (sync)
  1   1 28200172,2820017,484428,Lock-Free (DWCAS 0)
  1   1 28158130,2815813,17837,Lock-Free (DWCAS 1)
  1   1 29881852,2988185,705832,Lock-Free (DWCAS 2)
  1   1 28610582,2861058,265855,Lock-Free (DWCAS 3)
  1   1 35524489,3552449,2168317,Lock-Free (DWCAS 4)
  1   1 30298268,3029827,837485,Lock-Free (DWCAS 5)
  1   1 40205165,4020516,3741929,Lock-Free (DWCAS 6)
  1   1 28476448,2847645,5663,Lock-Free (DWCAS 7)
  1   1 30428398,3042840,786806,Lock-Free (DWCAS 8)
  1   1 28037009,2803701,25057,Lock-Free (DWCAS 9)
  1   1 28542514,2854251,114949,Lock-Free (DWCAS 10)
  1   1 16863847,1686385,34400,PThread Mutex
  1   1 25633608,2563361,140430,PThread Spinlock (private)
  1   1 25596571,2559657,7786,PThread Spinlock (shared)
1 1     110576466,11057647,3114,GCC Spinlock (atomic)
1 1     116036921,11603692,2973,GCC Spinlock (sync)
1 1     90363273,9036327,99802,Lock-Free (DWCAS 0)
1 1     89785696,8978570,82106,Lock-Free (DWCAS 1)
1 1     89660571,8966057,83380,Lock-Free (DWCAS 2)
1 1     89572483,8957248,100934,Lock-Free (DWCAS 3)
1 1     89570481,8957048,203426,Lock-Free (DWCAS 4)
1 1     89332243,8933224,116506,Lock-Free (DWCAS 5)
1 1     89221132,8922113,204700,Lock-Free (DWCAS 6)
1 1     89082994,8908299,92299,Lock-Free (DWCAS 7)
1 1     88771683,8877168,107729,Lock-Free (DWCAS 8)
1 1     88816728,8881673,102491,Lock-Free (DWCAS 9)
1 1     88632544,8863254,144111,Lock-Free (DWCAS 10)
1 1     76736660,7673666,9060,PThread Mutex
1 1     125234109,12523411,83097,PThread Spinlock (private)
1 1     107783676,10778368,2831,PThread Spinlock (shared)
1 1 1 1 28380352,1419018,466288,GCC Spinlock (atomic)
1 1 1 1 28051023,1402551,372684,GCC Spinlock (sync)
1 1 1 1 28151123,1407556,575764,Lock-Free (DWCAS 0)
1 1 1 1 28726698,1436335,353561,Lock-Free (DWCAS 1)
1 1 1 1 28735707,1436785,482692,Lock-Free (DWCAS 2)
1 1 1 1 29066037,1453302,382135,Lock-Free (DWCAS 3)
1 1 1 1 29338309,1466915,314677,Lock-Free (DWCAS 4)
1 1 1 1 29815786,1490789,623586,Lock-Free (DWCAS 5)
1 1 1 1 30274244,1513712,527132,Lock-Free (DWCAS 6)
1 1 1 1 30673643,1533682,467011,Lock-Free (DWCAS 7)
1 1 1 1 31248217,1562411,570384,Lock-Free (DWCAS 8)
1 1 1 1 32043011,1602151,833219,Lock-Free (DWCAS 9)
1 1 1 1 32117085,1605854,715797,Lock-Free (DWCAS 10)
1 1 1 1 21455434,1072772,4463,PThread Mutex
1 1 1 1 35506471,1775324,620979,PThread Spinlock (private)
1 1 1 1 34894860,1744743,682990,PThread Spinlock (shared)

So what do we make of it all?

If you are targetting a particular device, then you can find the optimal backoff values and use them - no problem.

If you are not, however, and so the processor model and clock speed can vary, then you could run the optimal backoff finder on an idle system of that type and use those values.

However, this may not be possible; in which case, other backoff values have to be used - and it just has to be hoped that they are reasonably correct, i.e. that backoff values don’t vary much across processor model and clock. Probably they do though - I mean, if a change of one in the queue backoff removes 25% performance, changing the clock speed by say 1 GHz is probably going to matter!

I wonder if it’s possible to build in something like automatic gain control.

Also - is the PRNG/ethernet-like random exponential backoff necessary? would a fixed backoff period work just as well, and so allow the removal of the PRNG complexity and passing around the PRNG state?

2016-02-01

Fourth light - ARM

Benchmark results from a Raspberry Pi2 Model B - a single package, four physical core, non-hyperthread ARM processor.

The results are not clearly understandable to me. All of this also has the unknown factor of how much the DWCAS backoff value of 16 is a good or bad choice - and this could be affecting results hugely.

With the freelist, pthread spinlocks seem to perform very poorly on ARM, compared to Intel. The lock-free freelist wins across the board, and by 2x or 3x - the exception being the GCC 4.7.3 or better intrinsics, which are about 10% faster. I’m guessing the pthread spinlocks are issuing load and store memory barriers - because I suspect the sync intrinsics do this, and they’re running at the same speed, and liblfds doesn’t, and it’s running at basically the same speed as the GCC atomic intrinsics.

When we come to every core running, liblfds is way out in the lead - about 2x over GCC atomics and so 3x over pthreads/sync.

The queue is a different matter. There’s quite a bit more atomic working being done and so its behaviour is really very different to the freelist. Lock-free is performing about as well, sometimes a bit better, sometimes a bit worse, as the GCC atomics and the pthread spinlocks.

Experiments with the backoff value are now required.

Freelist Push One Pop One

   M   
   S   
P P P P
L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type
      1 35310275,7062055,0,GCC Spinlock (atomic)
      1 23316293,4663259,0,GCC Spinlock (sync)
      1 31498467,6299693,0,Lock-Free
      1 14279265,2855853,0,PThread Mutex
      1 25436411,5087282,0,PThread Spinlock (private)
      1 25435410,5087082,0,PThread Spinlock (shared)
1 1 1 1 16188172,809409,3536,GCC Spinlock (atomic)
1 1 1 1 13913900,695695,49224,GCC Spinlock (sync)
1 1 1 1 30561531,1528077,104056,Lock-Free
1 1 1 1 6315309,315765,7802,PThread Mutex
1 1 1 1 10346336,517317,5497,PThread Spinlock (private)
1 1 1 1 10334324,516716,13563,PThread Spinlock (shared)
    1 1 21355334,2135533,9343,GCC Spinlock (atomic)
    1 1 13427414,1342741,12174,GCC Spinlock (sync)
    1 1 31201170,3120117,187146,Lock-Free
    1 1 3972969,397297,1557,PThread Mutex
    1 1 11071060,1107106,15572,PThread Spinlock (private)
    1 1 11065054,1106505,19819,PThread Spinlock (shared)
  1 1 1 16608592,1107239,25416,GCC Spinlock (atomic)
  1 1 1 14296282,953085,24382,GCC Spinlock (sync)
  1 1 1 30841811,2056121,65744,Lock-Free
  1 1 1 5917912,394527,7868,PThread Mutex
  1 1 1 11028017,735201,517840,PThread Spinlock (private)
  1 1 1 11028017,735201,504296,PThread Spinlock (shared)

Queue Enqueue One Dequeue One

   M   
   S   
P P P P
L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type
      1 31280249,6256050,0,GCC Spinlock (atomic)
      1 20548528,4109706,0,GCC Spinlock (sync)
      1 14745731,2949146,0,Lock-Free
      1 13629616,2725923,0,PThread Mutex
      1 23202179,4640436,0,PThread Spinlock (private)
      1 23202179,4640436,0,PThread Spinlock (shared)
1 1 1 1 23410387,1170519,14323,GCC Spinlock (atomic)
1 1 1 1 20547527,1027376,35305,GCC Spinlock (sync)
1 1 1 1 18781763,939088,25213,Lock-Free
1 1 1 1 8489481,424474,8878,PThread Mutex
1 1 1 1 17234217,861711,9866,PThread Spinlock (private)
1 1 1 1 17153136,857657,10259,PThread Spinlock (shared)
    1 1 30177147,3017715,2973,GCC Spinlock (atomic)
    1 1 23542519,2354252,10334,GCC Spinlock (sync)
    1 1 22512490,2251249,1982,Lock-Free
    1 1 4659655,465966,11750,PThread Mutex
    1 1 24581557,2458156,708,PThread Spinlock (private)
    1 1 24612588,2461259,849,PThread Spinlock (shared)
  1 1 1 25284259,1685617,19065,GCC Spinlock (atomic)
  1 1 1 18883865,1258924,4988,GCC Spinlock (sync)
  1 1 1 19091072,1272738,36525,Lock-Free
  1 1 1 8787779,585852,910,PThread Mutex
  1 1 1 18312294,1220820,58245,PThread Spinlock (private)
  1 1 1 18281263,1218751,56777,PThread Spinlock (shared)

Third light

Fixed two bugs. First, the test were running for about three times as long as they should - the performance numbers were correct in relation to each other, but were themselves incorrect. Second, I forgot to init the liblfds library, and so the PRNG was always returning 0, which totally fubared backoff! I thought about adding an assert for this in 7.1.0 but decided not to - I’m going to add it now; it’s a nasty silent failure, because for example when the PRNG is correctly initialized there’s a massive (3x) performance improvement in the freelist (when running one thread per physical core - other factors come into play in other thread combinations - mainly memory contention).

Current results (DWCAS backoff set to 16) on Linux on a Core i5 are…

Freelist Push One Pop One

   M   
   N   
   S   
  L3U  
L2U L2U
L1D L1D
L1I L1I
 P   P 
L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type
  1     158972814,31794563,0,GCC Spinlock (atomic)
  1     159383224,31876645,0,GCC Spinlock (sync)
  1     134314180,26862836,0,Lock-Free
  1     97038942,19407788,0,PThread Mutex
  1     183193010,36638602,0,PThread Spinlock (private)
  1     181957776,36391555,0,PThread Spinlock (shared)
  1   1 17720703,1772070,440968,GCC Spinlock (atomic)
  1   1 17745728,1774573,302378,GCC Spinlock (sync)
  1   1 113294181,11329418,1430492,Lock-Free
  1   1 14249235,1424924,19111,PThread Mutex
  1   1 21189168,2118917,1752830,PThread Spinlock (private)
  1   1 22103081,2210308,1183323,PThread Spinlock (shared)
1 1     75757682,7575768,13307,GCC Spinlock (atomic)
1 1     74735661,7473566,119621,GCC Spinlock (sync)
1 1     94664570,9466457,353058,Lock-Free
1 1     40270230,4027023,18969,PThread Mutex
1 1     114018905,11401890,10617,PThread Spinlock (private)
1 1     113393280,11339328,712627,PThread Spinlock (shared)
1 1 1 1 14968954,748448,128613,GCC Spinlock (atomic)
1 1 1 1 15102087,755104,310864,GCC Spinlock (sync)
1 1 1 1 86316230,4315812,300009,Lock-Free
1 1 1 1 15692677,784634,2765,PThread Mutex
1 1 1 1 18496478,924824,85572,PThread Spinlock (private)
1 1 1 1 18526508,926325,79346,PThread Spinlock (shared)

Queue Enqueue One Dequeue One

   M   
   N   
   S   
  L3U  
L2U L2U
L1D L1D
L1I L1I
 P   P 
L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type
  1     137902765,27580553,0,GCC Spinlock (atomic)
  1     149820671,29964134,0,GCC Spinlock (sync)
  1     105693588,21138718,0,Lock-Free
  1     96371275,19274255,0,PThread Mutex
  1     211975764,42395153,0,PThread Spinlock (private)
  1     200698498,40139700,0,PThread Spinlock (shared)
  1   1 26540514,2654051,4247,GCC Spinlock (atomic)
  1   1 27436409,2743641,425,GCC Spinlock (sync)
  1   1 31039008,3103901,1169309,Lock-Free
  1   1 17809792,1780979,14439,PThread Mutex
  1   1 25593568,2559357,1699,PThread Spinlock (private)
  1   1 25189164,2518916,148641,PThread Spinlock (shared)
1 1     113591478,11359148,1133,GCC Spinlock (atomic)
1 1     114401287,11440129,1274,GCC Spinlock (sync)
1 1     84650566,8465057,152888,Lock-Free
1 1     79341262,7934126,140713,PThread Mutex
1 1     107801694,10780169,3681,PThread Spinlock (private)
1 1     134627493,13462749,156710,PThread Spinlock (shared)
1 1 1 1 28101073,1405054,48162,GCC Spinlock (atomic)
1 1 1 1 26123097,1306155,39169,GCC Spinlock (sync)
1 1 1 1 34445411,1722271,304450,Lock-Free
1 1 1 1 21404383,1070219,11668,PThread Mutex
1 1 1 1 34058024,1702901,407905,PThread Spinlock (private)
1 1 1 1 35752717,1787636,595948,PThread Spinlock (shared)

The freelist result is great - when running one just one logical core, or when running on all threads on a single logical core, the pthread spinlocks win; but when moving out over multiple cores, liblfds is four to five times faster. I suspect the magnitude of the win will grow as the number of cores increases - experiments on Amazon with high core counts to follow.

The queue result is similar but the order of improvement is much smaller and indeed with one thread on every core, there is no improvement - but here I suspect the memory bus is getting saturated; but it could be related to the backoff value. More experiments to follow.

Second light

This is with DWCAS backoff set to 2 (rather than 16).

   M   
   N   
   S   
  L3U  
L2U L2U
L1D L1D
L1I L1I
 P   P 
L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type
  1     685502818,137100564,0,GCC Spinlock (atomic)
  1     684662979,136932596,0,GCC Spinlock (sync)
  1     577258682,115451736,0,Lock-Free
  1     417807390,83561478,0,PThread Mutex
  1     788132345,157626469,0,PThread Spinlock (private)
  1     787191405,157438281,0,PThread Spinlock (shared)
  1   1 75191116,7519112,1834370,GCC Spinlock (atomic)
  1   1 74801727,7480173,1167185,GCC Spinlock (sync)
  1   1 123331208,12333121,545300,Lock-Free
  1   1 60827767,6082777,860277,PThread Mutex
  1   1 84286202,8428620,9465170,PThread Spinlock (private)
  1   1 84852768,8485277,10199315,PThread Spinlock (shared)
1 1     328755427,32875543,109428,GCC Spinlock (atomic)
1 1     323336013,32333601,512882,GCC Spinlock (sync)
1 1     430760330,43076033,8492351,Lock-Free
1 1     164467303,16446730,91874,PThread Mutex
1 1     491495004,49149500,1599093,PThread Spinlock (private)
1 1     490755265,49075526,3211918,PThread Spinlock (shared)
1 1 1 1 64488424,3224421,617048,GCC Spinlock (atomic)
1 1 1 1 64559495,3227975,1185225,GCC Spinlock (sync)
1 1 1 1 71972901,3598645,65801,Lock-Free
1 1 1 1 67026960,3351348,88910,PThread Mutex
1 1 1 1 69056988,3452849,763551,PThread Spinlock (private)
1 1 1 1 68906838,3445342,739913,PThread Spinlock (shared)

There are variations on the order of 10% for the non-locking benchmarks, compared to the previous post. I think what’s happening is thermal throttling, in my laptop. It’s not a stable benchmarking platform. I need to rate limit the CPU to something sustainable and then benchmark.

(This is on a Core i5).

First light

These results are with DWCAS backoff of 16 - it may be (may well be) this is a non-optimal choice and is depressing performance.

I’m about to add code to iterate over a range of backoff values.

   M   
   N   
   S   
  L3U  
L2U L2U
L1D L1D
L1I L1I
 P   P 
L L L L total ops,mean ops/sec/core,std dev/sec/core,lock type
  1     684885201,136977040,0,GCC Spinlock (atomic)
  1     685716031,137143206,0,GCC Spinlock (sync)
  1     578266689,115653338,0,Lock-Free
  1     417751334,83550267,0,PThread Mutex
  1     787129343,157425869,0,PThread Spinlock (private)
  1     788219432,157643886,0,PThread Spinlock (shared)
  1   1 71237166,7123717,52944,GCC Spinlock (atomic)
  1   1 67975908,6797591,1416,GCC Spinlock (sync)
  1   1 122725603,12272560,2365656,Lock-Free
  1   1 62373311,6237331,671149,PThread Mutex
  1   1 83235152,8323515,9885612,PThread Spinlock (private)
  1   1 84115031,8411503,9632639,PThread Spinlock (shared)
1 1     328113786,32811379,77860,GCC Spinlock (atomic)
1 1     323700377,32370038,522225,GCC Spinlock (sync)
1 1     430896466,43089647,9112679,Lock-Free
1 1     167093927,16709393,19111,PThread Mutex
1 1     491238748,49123875,1935729,PThread Spinlock (private)
1 1     491291801,49129180,1430492,PThread Spinlock (shared)
1 1 1 1 62177115,3108856,8552,GCC Spinlock (atomic)
1 1 1 1 59761702,2988085,33801,GCC Spinlock (sync)
1 1 1 1 71814743,3590737,65118,Lock-Free
1 1 1 1 67450383,3372519,99140,PThread Mutex
1 1 1 1 69443374,3472169,773448,PThread Spinlock (private)
1 1 1 1 79839760,3991988,377803,PThread Spinlock (shared)

So with 1 thread per physical package (i.e. not hyperthreading), liblfds is WAAAAY out in front. However, when we max out - one thread per logical core - the pthread spinlock wins. What’s amazing and unexpected is that the shared pthread spinlock is substantially faster than the private spinlock!

I’m about to examine the source code for pthread spinlocks. I guess they’re doing some extra work, which makes them more efficient - and also they only have to CAS, whereas the freelist is using DWCAS. However, I think the main issue here is the DWCAS backoff in the freelist - when we go to one thread per logical core, there’s a lot more contention, and that backoff is being invoked much more often (I think!)

2016-01-31

Benchmark update

Good news!

On what is I think now the fifth attempt (over the course of about two years) I finally have the design of the benchmark programme correct.

It’s a complex beasty - you have the data structures, the benchmarks, the many different types of locks (and the lock-free as well of course), where the locks vary by platform, CAS and DWCAS backoffs need to vary, where each benchmark runs over a range of logical processor sets (e.g. say on every logical core, then on one logical core per NUMA node, etc, etc - the full meainngful set of sets), and where you want to be able to produce arbitrary gnuplots afterwards.

It used to be more complex - there were NUMA and non-NUMA variants to consider, and also before the SMR variants of data structures became a separate data structure, you also had to consider the SMR and non-SMR variants.

I remember spending two weeks in particular Tunis working on this - it’s a deadly trap. The problem is you can just about fully optimize the code layout; abstract the lock types, loop over the benchmarks, loop over the data structures, etc, etc, etc - you end up with a perfect factorization. The problem is, it’s at the limit of what you can manage… so when you come back to it, you can’t remember how it works, and, more painfully, if ANY new requirement comes along, it can’t fit - but you’re already at your limit even when you were fresh to the code and had it all in your mind.

A simpler approach was needed.

What I’ve done is basically two things - first, I’ve removed the per-lock abstraction. Each data structure now has an implementation for each lock. This was actually needed because having one template data structure which used function pointers for locks added the overhead to the locking benchmark runs of following that function pointer. Probably the cost is very small - even negligible - but it’s unwise to assume, so it would have to be investigated to be sure, and of course adding overhead to the locking benchmarks favoured liblfds. Second, I’ve used an abstraction layer, as with liblfds; the abstraction layer implements the locks - all of themm, for all platforms, dummying them up if they’re not actually available - and all the code above that is always fully compiled on all platforms.

I’m still thinking about what to do with the output though, since there can be many thousands of output records, and I want to access them arbitrarily to make gnuplots - I could run into a performance problem!

Anyways, I’ve just made the full basic structure of the benchmark programme compile. There’s a lot of code thrown in there from the previous attempts - it all needs a lot of work on quality - but it compiles and the fundamental design is correct, so we’re on the right track.

Hopefully will tomorrow have some gnuplots for freelist.

2016-01-27

My recent encounters with airport security

I want to write about my recent travel experiences with airport security.

I flew from Newark, New Jersey (EWR) to Schipol, Amsterdam (AMS) and then a second flight, a few days later, from AMS onwards.

In EWR, I as I always do declined the body scanner and asked for a pat-down.

One of the operators tried to persuade me the scanner was safe by saying it was “like an ultrasound”, which is a shocking claim - utterly untrue. An ultrasound is like sonar. It uses sound waves which pass physically into the body and bounce around. A body scanner is like an x-ray machine. It uses ionizing radiation, which rams into the body and damages cells and contributes (in what is hopefully a tiny fashion, but the research is not clear) to the risk of cancer.

No one working with these machines should EVER say that. It was disgraceful.

So then I was “patted-down”.

Except it wasn’t a pat-down. That phrase is for when you stand up and someone pats you. I was “patted down” with such physical force I was actually staggering backwards and forwards - I was unable to maintain my balance standing. This went on for about five minutes.

So that was EWR.

Then in AMS, when I departed, again, I declined the scanner and was patted-down - actually patted-down; but this time, I was also taken into a privacy booth, and asked to unbutton and lower my jeans, which I did, he visually checked the buldge in my underwear and that was it.

That hasn’t happened before. I’m wondering if there is a connection between these two (EWR and AMS) events. Has there been globally a directive to make non-scanner checks more… more, what? more effective? presumably effective? while at the same time of course making them more intrusive, more intimate, more and more unpleasent - and remember here, there’s no evidence I am hostile; these are just routine, generalized checks.

The TSA recently stated passsengers no longer have the right to decline the body scanner - they can, at the TSA’s discretion, be required to go through, or, of course, be refused their flight (and what else? then coming to the attention of the FBI? who have the power to make a warrentless entry in all kinds of situations - including, shockingly, living within one hundred miles of the US border, which includes of course all of say NYC, which is where I used to live. Congress and the Senate are useless - these kinds of powers should not exist, but they do).

So, what do I come away from this with?

If EWR pat-downs are like that normally, I am not longer going to fly through EWR. I’d have to go through EWR again to find out if it is so, and the experience was unpleasent enough I have no wish to experiment to find out - so that kind looks like EWR is now on my no-fly list.

I already no longer fly through Gatwick, not for that reason, but because of the awful, awful experience of the cameras as you queue for immigration.

If US airpot pat-downs are like this in general, then - believe it or not - I’m no longer flying to the US. I’ll see if I can get in by ship in a more peaceful manner.

What of Schipol? I don’t know what to make of that. The TSA (the American airport security organisation) being abusive I know about. They are culturally like that and it’s not being fixed - indeed, I’d say it’s getting worse. (They’re also expensive - eight billion a year - and no good; the detection rate for explosives and guns is about 8%) - but Schipol? I thought the Dutch would be better. I will give them a second chance, and see what happens.

2016-01-25

Benchmark progress

I decided on the source code layout, which is a huge issue in this programme - what’s being done (benchmarking many variations) lends itself to a highly factorized layout, but it ends up being unmaintainable, and also suffers of course inherently from inflexibility; when you come up with another test type which doesn’t fit in the factorization you have, your code is problematic.

I spent yesterday and now today so far getting the topology code back on its feet, which seems to have worked, first pass (by first pass I mean hours of compiling and fixing up the code for 7.0.0 - but first pass as it, it wasn’t broken once this was done!)

Sample output from my Core i5 on Linux;

Key
===
M  = Memory
N  = NUMA node
S  = Socket (physical package)
Ln = Level n cache
D  = Data cache
I  = Instruction cache
U  = Unified cache
P  = Physical core
L  = Logical core

Topology
========
   M   
   N   
   S   
  L3U  
L2U L2U
L1D L1D
L1I L1I
 P   P 
L L L L

I’m now going to see if I can get release 6 (six, not 6.0.0, etc) compiling reilability and consistently on Raspberry Pi - it seems to compile with some versions of GCC but not others, and the problem is the in-line assembly for DWCAS. There’s a better way to do this, which is to cast to an int long long unsigned and use the GCC instrinsic, which I hope will side-step the problem.

2016-01-23

Edward Hugh died

I’ve just found out - I was Googling to see where he’d gone; he’d not posted anything for about six months.

He died on the 29th December, 2015, his birthday.

Every hand-over-eyes-I-see-no-problem politican in Europe will breathe an involuntary sigh of relief.

2016-01-21

Benchmark

Cor, finally.

Finished settling in, more or less, and now about to actually do some real actual genuine honest-to-God coding again at last.

Next release will be 7.1.0, will be identical to 7.0.0, except it will contain the benchmark programme.

2015-12-29

7.0.0

It’s out.

Heaven help us all :-)

7.0.0 release in the morning

Windows - I got hold of an 8.1 eval, installed it (hour or two on a VM) and installed a trial 2013, copied that VM and then installed WDK 8.1 as well. Also copied my base fresh Windows 7 VM, installed VC 2012, copied that again and installed 8.0. Took a day or so, all told.

(Took me all of five minutes to write a script on Linux to build every variant and about ten minutes to run it. I’ve been watching “Yes, Minister” recently. Microsoft are the British Civil Service).

THEN found out ARM support exists in 2012.

Could not however figure out how to build an ARM library using 2013. Keeps telling me desktop apps not supported for ARM. Googling a lot didn’t help. Given up.

Building an ARM lib for the kernel with WDK 8.1 was straightforward. Will try it tomorrow with 2012.

So I pretty much know where I am. Will finish this in the morning and release, and then get on with polishing the docs, and then the next thing will be getting the benchmark app back into play.

2015-12-28

Update

Forgot to sort out the Linux kernel build. Done that.

Okaaaaaaaaaaaaaaaay.

What to to do about Windows?

2015-12-27

Updatez

I think I’m done with Linux build config.

I can’t build/test on x86 any more - Amazon no longer offer x86 machines, far as I can tell.

This leaves MS.

It’s looking like I need build files for both express and professional versions of every current Visual Studio, plus a second set for each of VS+WDK 8.0/8.1/10.0. These build files also are a screaming nightmare to produce. A billion different GUI switches which you have to click on and review - repeated each time for each build variant, which is debug/release, ARM/x86/x64, DLL/LIB, user-mode/kernel - twenty four variants - and I need to do this three times, for MS 2012, 2013 and 2015.

Microsoft, this is absolutely insane. I’m not even going to get angry because this is beyond anger. There are no words to describe how much of a problem this actually is, and this is the environment MS is offering so people can write software on their platform.

Windows 8.1

Well.

I’ve installed 8.1.

I’ve installed VS2013.

Know what?

I cannot work out how to start Visual Studio.

Srsly.

Update

Test runs valgrind clean - almost no work to get back to clean, as I’d done this some time ago.

Added another test for the new ability to free queue elements.

Shortly going to run the full build and tests on linux x64, linux x86 and, hopefully, Android MIPS32.

Update

Wrote a script which makes every build type and runs test for the debug and release builds.

This passes fully on ARM32 and MIPS32 (GCC and gnumake).

Downloaded a 90-day Windows 8.1 trial ISO and Visual Studio 2013 Professional (I’m hoping it will offer a trial install), and the 8.1 web installer (can’t find an ISO and just like ABN AMRo, THE worst bank in the world, every time I touch MS they mess something up, be it big or small - this time I’m told have to log in, to donwload - only in fact I did not have to do so).

I have to say, most profoundly, Microsoft have made the process of porting to their platform excruiatingly painful and above all TIME CONSUMING. It is SO MUCH HASSLE - and then, even once you’ve done it, there’s little scope for automation, since each WDK has to run in a different VM and I suspect now I may need to support three different WDKs, maybe even four to get Windows 10. It’s a joke. It’s totally insane and I boggle that MS have ended up offering this to developers.

On Linux, I wrote a script in about five mins which built and ran every variant.

Microsoft, it takes DAYS - that’s MULTPLE DAYS - to obtain, install and configure the build environments.

Anyways, ARM32 and MIPS32 are happy. Tomoz I’ll confirm x86 and x64 on Linux, which means all the Linux builds are in shape and ready to go.

Then it’ll be a case of deciding what to do about Windows and the MS problem.

I may for now just update the VS2012 and WDK 8.0 build files. This would mean no ARM32 support on Windows, because I need VS2013 (which means Windows 8.1) and WDK 8.1 to build for ARM. I can do those later - or I could try to do it tomorrow, install 8.1, etc.

I’ve also downloaded an Android image for the Ci20 (MIPS32)! it boots right from the SD card, so I should be able to check the library and test apps build okay on Android (even if it is MIPS and not ARM - Android for the Pi is apparently quite a bit more dicey).

2015-12-26

Update

Working on the Linux user-mode builds now.

Have a script which builds every variant and runs test for debug and release.

This script is running at this moment on ARM32 and MIPS32.

When they’re done, I’ll run on x86 and x64.

Once that’s done, Linux kernel-mode.

Looking into seeing if I can get hold of a Windows 8 ISO… sigh.

Microsoft and pure total mental agony

I hate Microsoft.

Working with MSVC is torture. Working with the web-site is torture.

It takes fucking forever to do anything and it’s either so much work to find out what you need to know, or you can’t find out at all.

So; I’m done with WDK 7.1 builds, now I’m looking at the MSVC builds.

I want to support an ARM build. First question; what’s the earlier version of MSVC which supports ARM? I can’t find out.

It looks like it’s probably MSVC 2013, given what people have posted on various forums (!)

I go to download 2013.

There are EIGHT DIFFERENT VERSIONS, AND NO INFORMATION ON HOW THEY DIFFER.

There are three “express” versions, which I think from prior knowledge are the free versions, and five non-express versions, such as “premium”, “ultimate” and “professional”.

Anyone have any ideas about the difference between premium, ultimate and professional? ’cause there’s fuck all on the download page.

Next question - I know already that the WDK 8.0 will only work with the professional version of 2012.

Is this still the case with 8.1 and 2013? I can’t find out.

Next question - will solution files made with a non-express version load into an express version? I can’t find out.

Next question - which versions of Windows are supported by the different WDKs? I can’t find out, in part because on the download page for WDKs, the link in each WDK’s section, which should according to the text go to the page about that WDK and tell you, in fact ALL go to the WDK 10 download page.

Every time MS ditch a WDK but it is the only WDK for a given OS, I have another platform to maintain - another Window VM with it’s own MSVC and WDK install and it’s own build files. I don’t have this problem on Linux, because there it’s just a matter of having the correct version of GCC and header files.

I hate Microsoft. Working with their tools is pure bloody torture - and I’ve not even spoken here about THE OBSCENE MENTAL TORTURE OF MSVC SOLUTION FILE CONFIGURATION. If it was’t for the fact I want to support people using this platformm, I wouldn’t touch it with a fucking barge pole, in exactly the same way as I wouldn’t stab myself in the eyes with forks, because, you know, IT HURTS.

Addendum - it gets worse. I have just discovered - not on the MS site, or the download page for it which makes no mention of this at all, but on the wikipedia - that 2013 requires Windows 8.1. I am not happy. I have by pure luck avoided wasting quite a bit o effort downloading the installer, setting up a W7 VM and trying to install. I do not appreciate my time being wasted by gross incompetence.

I’m impressed

I’ve been working on getting the build files up to date.

I’ve been working thi morning on the WDK 7.1 build.

I’ve made it compile for ARM and IA64 - i.e. sorted out the porting abstraction layers for these processors, which is really nice.

However, the IA64 build was failing to compile - claimed unreachable code in the ringbuffer init.

I’ve just figured out why - and I’m impressed by the compiler.

IA64 does not support DWCAS. As such, the dummy DWCAS macro is in use. The macro takes an argument, result, which normally is set to 1 or 0, but in the dummy macro, is simply set to itself to remove a compiler warning.

The ringbuffer init, inits and then pushes elements to a freelist. The lfds700_freelist_push() function calls the DWCAS macro, from the inside of a loop, where the loop only ends if result is set to 1.

The compiler noticed result would never be set to 1, and was calling - rightly - unreachable code in the ringbuffer init function!

2015-12-25

Update

I am now this moment beginning to work on bringing all the build files up to date.

I think it’s a day of work.

I want to do a thread sanitizer run too, it’s been a while since I have. That’ll take an hour or two, as well (it’s quick enough to run, but it takes a while to think through all the results).

Docs

Okay, docs are good enough for release - well, I mean, I’ve got to spend a day or two now getting all the builds working again and running test, once that’s done I think I’ll give the guide documents another look over, coming to them a bit more freshly than now.

As I appreciated before, when I documented release 6, mediawiki is in its native form wholly unsuitable for documentation. The simple lack of a global search-and-replace is enough for that. Maybe there are scripts which can do this… documentation has taken up an improperly lrge effort, in that documentation necessarily takes up a certain effort but I’ve ended up spending a lot more effort than that because of the limitations of mediawiki.

I need to make one final set of code changes now - the COUNT queries all need to be safe to use on an in-use data structure (currently they’re all singlethreaded).

2015-12-23

CODE COMPLETE

long exhalated breath…

Okay, so there is actually a certain bit of documentation to complete - second drafts of the hash, queues and lists. They’ve all had their first drafts though and I’m confident enough now that there’s no surprises in there - the APIs as they are will be unchanged after they’re documented.

So I need to do those docs, need to review all the other docs to get them in line with the changes made over the last week or three, and I need to do all the build config work (MSVC solution files, etc).

Then it’s release time.

And THEN it’s back to work - get SMR in, the SMR versions of freelist and stack, then get the benchmark app back into play. THEN it’ll be real new data structures (linked list with real delete) and RPM packaging and a ton of other stuff I can’t remember right now :-)

Ci20

So, Ci20 is fabulously fantastic. No DWCAS and GCC < 4.7.3.

Done a bunch of fixing and now everything compiles.

Going to ditch the NOP stuff, and just use a volatile counting loop - right now there needs to be a NOP per platform, so you actually need the assembly code for a platform to be able to compile!

Great - Ci20 tests just passed on release. Thankyou Imagination Technologies!

2015-12-22

Ci20… earlier GCC and barriers

The Ci20, thank God, came with an earlier version of GCC - 4.6.2 to be precise. This provide the old style atomics, and so no compiler barriers - you have to use asm to get a compiler barrier.

Problem is, asm is a block-level element, i.e. it has to end in a semi-colon. You can’t have then separated by comma operators… …and the entire code base currently is written using inline-type elements for barriers, so they can be used in macros in while() loops and so on.

AFAICT, there’s no native GCC < 4.7.3 inline-style compiler barrier. I guess I’m going to have to implement asm compiler barriers as inline functions… gaaaak. Feels risky. Wonder if the compiler is going to get it right?

Ci20 Creator is here!

The Ci20 has arrived - i.e. a genuine MIPS32 platform for test!

It’s plugged in and ready to roll.

I’m just getting the test clean under valgrind for the new queue free test, so I can run that a hundred times or so and see if it throws an error.

Linux

Linux -> no docs, no error messages. Now make it work

I’ve spent the last couple of hours failing to configure Dovecot TLS.

I’ve just set up Thunderbird on my new laptop, Debian, and I’ve disabled the insecure cipher suites.

Now Thunderbird and Dovecot won’t talk, ’cause there’s no shared suites.

I mean, there ARE shared suites. There are tons of the them.

Oh yeah - and Thunderbird doesn’t show an error. It just leaves the “Connected” message showing. It’s only when you poke around, find the error console and look at it, that you discover what’s going on. Dovecot logs one line telling you no shared suites - doesn’t list anything else, like what it thinks it has and what the client thinks it has.

I’ve configured everything to be on, and it still isn’t working. I’m starting to call bullshit on this, and just say that it’s broken and doesn’t work, flat out.

Next I’m going to have to install wireshark, and inspect the POP3 packets, to see what Thunderbird is sending, because there’s no other bloody way to find out.

SERIOUSLY. NO SOFTWARE SHOULD REQUIRE PACKET SNIFFERS TO MAKE IT WORK. WHAT THE HELL ARE YOU GUYS SMOKING?

Possible typo/bug in the Michael and Scott queue white paper psuedo-code

Okay, so, I’m about to make quite a claim - and I do not make it lightly, and I make it in full knowledge that I am extremely likely to be completely wrong. M&S are experts in the field, and I am not.

This is the dequeue psuedo-code from their white paper.

dequeue(Q: pointer to queue_t, pvalue: pointer to data type): boolean
 D1:   loop              // Keep trying until Dequeue is done
 D2:      head = Q->Head         // Read Head
 D3:      tail = Q->Tail         // Read Tail
 D4:      next = head.ptr->next      // Read Head.ptr->next
 D5:      if head == Q->Head         // Are head, tail, and next consistent?
 D6:         if head.ptr == tail.ptr // Is queue empty or Tail falling behind?
 D7:            if next.ptr == NULL  // Is queue empty?
 D8:               return FALSE      // Queue is empty, couldn't dequeue
 D9:            endif
D10:            CAS(&Q->Tail, tail, )     // Tail is falling behind.  Try to advance it
D11:         else                 // No need to deal with Tail
D12:            *pvalue = next.ptr->value // Read value before CAS Otherwise, another dequeue might free the next node
D13:            if CAS(&Q->Head, head, )  // Try to swing Head to the next node
D14:               break             // Dequeue is done.  Exit loop
D15:            endif
D16:         endif
D17:      endif
D18:   endloop
D19:   free(head.ptr)            // It is safe now to free the old node
D20:   return TRUE                   // Queue was not empty, dequeue succeeded

Now, note the free on D19. The authors are making the point, as they do in the white paper, that once you’ve dequeued, you’re in the clear - you can free the node.

The typo or bug which I think I see is on line D4.

D4:      next = head.ptr->next      // Read Head.ptr->next

The code says “next = head.ptr->next”, which is using “head”, lower-case “h”. The comment says “Head.ptr->next”, which is using “Head”, upper-case “H”, where as we see on D2, “Head” (upper-case) means Q->Head.

I may be utterly wrong, but I think if the code is used, the free on D19 is broken, because it could lead the code (not the comment - the code) on D4 to access a freed node.

The problem is that “head” (lower-case) is a copy of Q->Head. The white paper states the Q->Head will always point to a valid node (as there is a dummy node in the queue) and that’s fine - but we have taken at line D2 a copy of Q->Head, and we can imagine it points a node, where that node could be by another thread dequeued and freed at D19, before our thread gets to D4 and tries to access that node’s next pointer.

The comment however looks right to me - if we read Q->Head.ptr->next, we’d still be fine, as the if() on D5 still works - but it would mean we could now safely call free on D19.

There is a matching issue in the enqueue, on E5, E6 an E7 - but here the comment and code match up.

2015-12-21

the M&S design flaw

So, for now at any rate, I’m using the PRNG to generate an initial value for a queue element next pointer counter.

The basic problem is that in the queue, elements have a next pointer, which has a counter - because it is the subject of DWCAS - unlike the stack/freelist, where the elements only have next pointers.

Because it has a counter, when an element leaves the queue, it takes that counter with it - but it is actually only valid for the queue the element just came from - but it CAN end up being mistaken for a valid value in a new queue the element in enqueued to.

Updatez

  1. Finally have my head around the M&S queue ABA stuff.
  2. Atomic add is now no longer needed - all the data structures get ABA from their CAS operations - so it’s been removed. Performance should improve by maybe a third…!
  3. Reversed the arg order for CAS to GCC style (destination, compare, new_destination). Used to be MS style (destination, new_destination, compare) which is nuts.

Now I just need to think about this…

http://polyglotplayground.com/2015/04/30/Problem-with-Michael-Scott-Lock-Free-Queue/

Whoaz…

2015-12-20

Update

So, well, time to ’fess up.

Few days ago I was looking at the queue code, and the way the ABA counter were being handled looked like it needed to be looked over. Then I realised there was something very odd going on - I was seemingly setting (and by expensive atomic adds!) ABA counters which were later overwritten with new values before added to the queue.

Then after some time thinking about this (and getting a new laptop, which I’ve spent a day or so, so far, configuring) I realised how I was handling the ABA counters in the freelist and stack was completely bonkers - I was using an atomic add on a per-state variable, but in fact no atomic add is needed at all, as you can use the counter in the top pointer, and increment it in the DWCAS. In fact, I’d really got the wrong end of the stick…

So now the freelist and stack no longer use atomic add, and in fact their elements are a bunch smaller - their next pointer is just a pointer, no counter, and none of the varibles in it are cache line/ERG aligned/padded.

I’m now looking over the queue code to make it right too.

I’ve also spent some time now reviewing all the code for proper barrier use - and here again, I had blundered, and was thinking about barrier use in not quite the right way; now I think I am getting it right, really right, and that’s led to a bunch more load barriers in the add-only code, and also shifted around where the store barriers are.

Once the queue is sorted out, I’ve one or two more minor bit of code checking to do, then it’s back to docs.

I’ve passed the “mid-December” estimate, but it’ll be out before the end of the month.

2015-12-17

btree API renames

Changed from the whole position/direction nonmenclature to absolute position/relative position nonmenclature .

Ci20 / MIPS32

Just ordered a Ci20, a dual-core MIPS32 dev board, runs Linux.

I think I can boot it to Android too, which would give me some capability to compile and test for that platform.

2015-12-16

Update

Well, yesterday was a blow-out - I’ve ODed on docs.

Today was good though, haven’t touched the docs, been working on code.

It’s been a day’s worth of tidying up - getting enum value names right, checking all the structure aligns, realised I’d blundered with atomic isolation for I still need a “double” atomic isolation on CAS architectures, normalized the API names for adding data elements to a structure (it’s now “insert”, where-ever it makes sense - still push/pop enqueue/dequeue for freelist/stack and the queues), and so much other stuff I can’t even remember - oh, changed backoff config so the number of NOPS per timeslot is hardcoded in a #define for CAS and DWCAS. Having them configurable just didn’t make sense - you can hardcode it if you’re on one platform, but chances are your software will run on a variety of different versions of an architecure, and with different clock speeds. There’s no real use in run-time configurability. Also, by being varibles in memory, it’s possible that the backoff code might need to do a TLB lookup and memory access! which blows that whole thing out of the water.

I feel I’m very close now to actually really being code complete, with nothing else in my mind that needs to be done.

2015-12-14

new intro paragraph

I’ve written a new intro paragraph, for readers who do not know what lock-free data structures are and do. Love it :-)

Lock-free data structures are thread-safe and interrupt-safe (i.e. the same data structure instance can be safely used both inside and outside of an interrupt handler), never sleep (and so are safe for kernel use where sleeping is not permitted), operate without context switches, cannot fail (no need to handle error cases, as there are none), perform and scale literally orders of magnitude better than locking data structures, and ‘’liblfds’’ itself (as of release 7.0.0) is implemented such that it performs no allocations and compiles not just on a freestanding C implementation, but on a bare C implementation.

Update

As ever, working on the docs.

Freelist, Misc, Ringbuffer and Stack are now good enough to release.

That leaves both lists, both queues and the hash.

The porting and usage guides are good enough to release, although the porting doc for test revealed the need for some work on the test abstraction layer.

The list, queue and hash docs will be completed tomorrow.

Once the final code work is done, I can then update the build configurations. There’s this… dual convergence, going on - the docs and the code - change one and you have to change the other, so doing work on either means you need to change the other. The goal is to get to the point where you need to change neither, then you can release.

2015-12-12

Update

Amazin’ really how wrong things can be and you don’t notice until almost the last moment.

The way I had the build directories named, and the detection of OS platforms, was wrong.

I realised because I came to make a freestanding build with GCC. The build directory really is about toolchains only - it’s about getting a build going, even if the build fails (because the porting layer is missing).

The porting layer is separate and different from the build tools, i.e. GCC and gnumake will give you build on any platforms, say an RTOS with no hosted implementation - but there’s no porting layer for that platform.

Of course I’ve always known this, but it turns out it’s not actually really what had been done.

So now the build dirs are named after the toolchain/system header requirements, and there’s a new build, “gcc_gnumake”, which uses “-ffreestanding -nodefaultlibs -nostdinc -nostdlib”, i.e. the real McCoy. The hosted implementation is almost the same, in fact - all it takes is <assert.h>. I thought seriously about dropping asserts, to simplify build, but they’re just too useful for debugging.

2015-12-11

Update

Gettin’ on.

Currently focusing on the stack docs. Making them perfect, or as perfect as they can reasonably be. They’re going to be the template for the other pages. So I’m working to get them right, really right (and so also to have made all the code base changes which come from docs) and then to iterate over all the other doc pages and produce them correctly in basically one more pass.

A lot of the time editing is actually spent waiting for the mediawiki to load and save pages - to be more efficient, you really need to cut down the number of passes.

2015-12-10

Update

Getting on.

The liblfds API has been renamed misc, it’s more self-explanatory.

All the init() functions are back to being init_valid_on_current_logical_core().

User callbacks no longer receive a user state argument, rather, there is a macro for getting the user state value from the data structure state.

Key compare functions and hash functions no longer receive a user state argument - what they do is too small and atomic for this.

The key compare function (and the hash function) has the const qualifier now, so it has the same prototype as the qsort() callback.

The queue cleanup function has an extra argument, a flag, which is raised when the dummy element is given (there’s no other way for the user to know the key and value in that element are invalid).

The ringbuffer cleanup function has an extra argument, which indicates if the element is unread.

Docs are coming along nicely.

I expect to release inside a week now.

2015-12-07

Update

Huh, the mediawiki is now at 499 articles :-)

So, been a full complete long day of doc writing.

Second pass done for btree, freelist, liblfds, hash and stack.

Tomoz it’ll be the lists, the queues and the ringbuffer.

Then I guess the test porting guide.

Then third pass for everything… uuhhhhh!

Update

Let’s see…

Removed the key hash/compare function over-rides from the non-init() functions. Their use is going to be so rare they don’t carry their own weight, and people can add them very easily.

The extra set macro didn’t happen. Think about it - you can atomically store (exchange), use a store barrier, or do nothing. What does a store barrier get you? it get you ordering… BUT ONLY A PER THREAD BASIS. Writes, if/when they do go out, are in order - sure - but only with respect to writes from the same thread. Fat lot of use that is! however, I now undersstand the GCC >= 4.7.3 docs on atomic instrincs - they stuff they’re alluding to is the difference between no barriers, barriers or atomic. They’re TOTALLY TOALLY UTTERLY TOTALLY UTTERLY HUMUNGOUSLY UNCLEAR - unless you already know what they’re talking about, in which case you can figure out what they’re getting at.

Spent five hours so far today on docs, feel like I’ve got bugger all done - some new pages for btree enums, the btree query page, that bit of experimentation with a new set. Ten more APIs to go…

Need more get/set macros

Writing the btree docs.

Something I’ve had in the middle of my mind for a while - I’m going to need to write two different get-value and set-value macro pairs, one set which guarantees by the time it returns from the set all readers will be able to see the new value (i.e. set uses an atomic set, get issues a load barrier), and another which does not offer this guarantee (set issues a store barrier, get issues a load barrier).

Update

Writing quality docs takes time.

I think I can do at most two APIs per day. There’s about ten to do…

Then there’s the test porting guide.

Then I need to update all build config.

Then I can release.

2015-12-06

Update

Have finished the second pass of the liblfds porting guide.

Now the big work; all the API pages.

2015-12-05

Factorized the porting abstraction layer

I realised last night that the porting abstraction layer would only work on x86, x64 and ARM.

All the other processor types which in principle work (when using GCC this is) simply were not present in the porting layer code.

So I need to implement them - but this led to an issue; the porting abstraction layer code was unravalled, to make it easy to understand. With another four or five processors, though, where every processor needs two versions (GCC < 4.7.3 and GCC >= 4.7.3) and most of the processors have 32 and 64 bit versions - it wasn’t going to fly.

The unravelled layout is from 6/6.1.1, a long time ago (after they were released) I factorized, and it turned out to come down to processor, compiler and operating system.

So I’ve gone back to this.

So, that’s fine, I need to add some boilerplate code to perform automated checking of what the user has or has not implemented, but that’s routine. The porting guide needs to be rewritten.

I’m going to do a bunch of work on the data structure docs now though, they’re stable now and they need a bunch of work done to them.

2015-12-04

tests pass on debug and release on 32 bit ARM

pi@raspberrypi /tmp/temp/liblfds/liblfds7.0.0/test/build/linux_usermode_gcc_and_gnumake $ ../../bin/test -v
test 7.0.0 (Release) (Dec  5 2015 01:33:39)
liblfds 7.0.0 (Release, Linux (user-mode), ARM (32-bit), GCC >= 4.7.3) (Dec  5 2015 01:32:48)
pi@raspberrypi /tmp/temp/liblfds/liblfds7.0.0/test/build/linux_usermode_gcc_and_gnumake $ ../../bin/test -r

Test Iteration 01
=================

Abstraction Atomic Tests
========================
Atomic add...passed
Atomic CAS...passed
Atomic DCAS...passed
Atomic exchange...passed

Binary Tree (add-only, unbalanced) Tests
========================================
Alignment...passed
Fail and overwrite on existing key...passed
Random adds and walking (fail on existing key)...passed
Random adds and walking (overwrite on existing key)...passed

Freelist Tests
==============
Alignment...passed
Popping...passed
Pushing...passed
Pushing array...passed
Popping and pushing (5 seconds)...passed
Rapid popping and pushing (10 seconds)...passed

Hash (add-only) Tests
=====================
Fail and overwrite on existing key...passed
Random adds and get (fail on existing key)...passed
Random adds, get and iterate (overwrite on existing key)...passed
Iterate...passed

List (add-only, singly-linked) Tests
====================================
Alignment...passed
New ordered...passed
New ordered with cursor (5 seconds)...passed

List (add-only, singly-linked) Tests
====================================
Alignment...passed
New start...passed
New end...passed
New after...passed

Queue Tests
===========
Alignment...passed
Enqueuing...passed
Dequeuing...passed
Enqueuing and dequeuing (5 seconds)...passed
Rapid enqueuing and dequeuing (5 seconds)...passed

Queue (bounded, single consumer, single producer) Tests
=======================================================
Enqueuing...passed
Dequeuing...passed
Enqueuing and dequeuing (8 seconds)...passed

Ringbuffer Tests
================
Reading and writing (5 seconds)...passed

Stack Tests
===========
Alignment...passed
Popping...passed
Pushing...passed
Pushing array...passed
Popping and pushing (5 seconds)...passed
Rapid popping and pushing (5 seconds)...passed

99.9% code complete

Wheush!

I am just about code complete.

There’s one bit of code rearrangement I need to do, dependency stuff with structures, I’ve a hack in place right now - and that’s it. It!

Now I have to bring all the build configuration up to date and make test pass in debug and release on all platforms. After that, the docs need to be done. Then it’s release time.

Oh. I’d like also to add a mailing list to the site, but they’re impossible to set up.

Musing

So, I’ve kept the btree navigation code as functions. They actually usually do quite a lot of work, so it’s not so bad.

What I’m thinking about now is, well, so, the lists and btree store keys and values. You can’t change the key, but you can change the value. That’s fine.

What about the non-random(ish) access data structures? the ringbuffer, the queue, the stack, etc - should they store only values, or keys as well? they won’t use the keys, but what I’m thinking is that in an application, a user may have a structure which is being passed about through many data structures and it would be very convenient to be able to preserve the key even when it passes through queues and ringbuffers and the like.

It’s fairly unobtrusive, because in almost all cases user are passing in to data structure functions only a pointer to a data structure element, which they prepped beforehand - so can set a key if they want, but they don’t have to - so not setting a key simply means… nothing at all.

This is not the case for the ringbuffer though - users do not see ringbuffer elements, they’re always internal to the data structure; they pass in arguments (value, and then would also be key, which would always be NULL when not used).

There’s also the overhead of copying the key around, but it’ll be on the same cache line as the value, so it’ll basically come from free.

Update

I’ve done all but one of the to-do list of code changes. There are some build config changes to do, but I can’t do them until the code changes are done.

Of the data structures which allow random access to elements (the lists, the btree) they now support the user setting value at any time. The others only support setting value at the time the data structure element enters the data structure.

As such, the former sets atomically (and issues a load barrier when getting a value) and the latter sets non-atomically (but with a store barrier), where the act of linking atomically to the data structure publishes value before the data structure element enters the data structure.

So that’s all good and well and makes sense and is done.

I’ve modified the macros so that they generally take one argument and ‘return’ a vaalue - it seems more intuitive to me, this way, for new readers.

I’ve updated the test programme, it again now compiles.

The atomic operations are all still macros, and with curley braces. What I’ve done for now (to compile) is accepted that LFDS700_PAL_ATOMIC_EXCHANGE uses curley braces and so other macros which use them (which is to say, SET_VALUE for the lists or btree) cannot be used inline.

I’m still thinking what to do about this - because there is another issue which is tied up with this, and that is the btree code for navigating a tree.

In the lists (the other random(ish) access data structure) the code for navigating the data structure (GET_NEXT, etc) exists as macros. After all, all we’re doing is accessing a pointer in a structure. The idea of making a function call to do this is nutso.

The btree code though for navigation is much more complex - it has to deal with a wide range of cases and often contains while() loops (“get smallest element”, etc). I want to be able to put this code in the conditional clause of a while() loop (i.e. get_by_position_and_then_directon()) but you can’t put a while() inside the conditional clause of a while() - which means you cannot use macros - which means you MUST write functions and you MUST use inlining.

There’s no getting away from it.

2015-12-02

Update

Removed key/value from prototypes.

Since most of the data structures are now key/value, users must possess the capability to set value - and in fact, where key is fixed but value is not, value changes must be atomically written (i.e. atomic exchange) or they cannot be guaranteed to be visible to other threads.

This means the SET macros must call atomic exchange, and atomic exchange right now, as with all the other atomic macros, uses curley braces… i.e. there’s a compile error.

In fact, if we think about porting, and the use of asm with GCC, we see that asm is block-level entity; it cannot be used inside the conditional part of say a while.

So in fact those lovely atomic macros all have to go back to being inline functions, which means depending on the compiler to have an inline keyword.

I’m not very happy about this.

API changes

One of the to-do’s was to reorder the hash API arguments.

This has pulled on a mental thread and led me to remove all the key and value arguments, where-ever they’re present.

So, for example, before we might have had;

enum lfds700_btree_au_link_result lfds700_btree_au_link_element( struct lfds700_btree_au_state baus, struct lfds700_btree_au_element baue, void key, void value, int (key_compare_function)(void new_key, void existing_key, void user_state), struct lfds700_btree_au_element **existing_baue, struct lfds700_liblfds_prng_state *ps );

The key and value arguments are convenience arguments - the function sets them into *baue. However, the user can do this - and there are prototypes where the presence of those key and value arguments makes the prototypes ungainly and indeed more complicated.

So now this has been removed, and all the functions now simply deal with data structure elements, pointers to them, and the user uses macros to get/set keys and values.

C ternary operator ‘strangeness’

The code below does not compile; “the left side of the assignment operator must be an l-value” (this for the right-most assignment operator).

int cr = 1; cr == 5 ? cr = 2 : cr = 3;

The code below does compile;

int cr = 1; cr == 5 ? (cr = 2) : (cr = 3);

This is true for both MSVC and GCC.

Turns out to be an apparently common compiler issue.

http://en.cppreference.com/w/c/language/operator_precedence

However, many C compilers use non-standard expression grammar where ?: is designated higher precedence than =, which parses that expression as e = ( ((a < d) ? (a++) : a) = d ), which then fails to compile due to semantic constraints: ?: is never lvalue and = requires a modifiable lvalue on the left. This is the table presented on this page.

2015-12-01

Pulling on a thread (thread - see? geddit? see what I did there?)

Sometimes, the only thing to say is this : gaaaaaaaaaaaaaaaaaaaaaahhhhhhhhhhh!!!

So, I had an innocent little thing on my small to-do list; “lfds700_list_asu_get_start_and_then_next() should be a macro, not a function”.

See, the lists have this convenience function, for iterating over the list. It takes the list state and a pointer to a list element, which is initialized before calling the function to NULL. If the pointer to the list element is NULL, then it is set to point to the first element in the list, otherwise, it is moved to point to the element after itself.

So you use it like this;

struct lfds700_asu_element *le = NULL;

while( lfds700_list_asu_get_start_and_then_next(ls, &le) ) { // TRD : do work }

The problem of course is you’re making a function call per iteration, which is totally not okay.

Now, there exist already a pair of macros, LFDS700_LIST_ASU_GET_START and LFDS700_LIST_ASU_GET_NEXT. That function uses them.

Now, given the expected usage, inside a while loop, we cannot in the macro version of the function use curley braces.

Problem is, those two macros, they both issue a load barrier - and that load barrier, on some platforms, is an atomic exchange - and that means we need some store, two temporary variables, and to get them… we’re using curley braces.

In fact this work touches upon this larger issue - I would like to be able to use all these macros inside while() brackets.

Exchange is not the only atomic operation which currently needs store - given the normalized form I’ve selected for CAS and DCAS, some platforms need store for those ops as well.

The only way I can see to get round this is to have these macros as inline functions.

That means changing the liblfds header files to be C files, and #including them rather than the header files.

2015-11-29

Update

Been working through the small-things to-do list. Done about half.

Update

Well, just done a ton of doc work.

  1. ringbuffer APi docs first pass
  2. building guide (lfds) first pass
  3. building guide (test) first pass
  4. porting guide (lfds) first pass
  5. porting guide (test) first pass - but realised the in-page examples are too long, have to come at this in a different way

All the API docs need a second pass now to correct mistakes and make them uniform, then a third pass to actually wrote notes and content - right now it’s just prototypes and arguments, basically, the framework of the page.

Got a long list of minor code/doc fixes/improvements to make, which has built up as I’ve been going along. Have to do all those and reflect them in the docs.

Then go over the non-API docs for a second pass.

Then I can bring all the build files up to date and run test on all platforms.

Then I can release - and then immediately start working on the next release, to get the SMR code back in there and out into the field. I’d like to get the benchmark programme out too.

ringbuffer

Moved over to new API design.

Made the tests pass.

I’ve updated the ringbuffer API page to the new API design. Will write the per-API docs tomoz.

2015-11-28

ringbuffer API design

I’ve been unhappy with the ringbuffer API. It’s totally unclear how it’s supposed to be used.

The existing API looks something like this;

get_read_element() put_read_element()

get_write_element() put_write_element()

Great, huh? obvious - not.

Naively, I think the expectation is for something like this;

ringbuffer_read() ringbuffer_write()

read() get the oldest unread element, write() writes to the ringbuffer, overwriting the oldest element if there are no free elements.

The problem though, which led to the existing API, is that the ringbuffer is lock-free and so multi-reader and multi-writer; as such. if we read an element, someone else can completely over-write its contents WHILE WE’RE READING IT.

As such, the existing API acts when reading to detach the element from the ringbuffer, so no other thread can touch it, and the same when writing; we detach an element, write to it, then place it back into the ringbuffer.

In fact I’ve realised this problem/behaviour all turns upon whether or not the ringbuffer is beig used to store transient or permanent data. What I mean by this is that we arrange the ringbuffer either so that each element is pointing to some permanently allocated store for that element (like an audio buffer) or we arrange the ringbufer so that each element is holding a void pointer, which is valid for one read (so we have say a freelist of audio buffers, and we write into the ringbuffer a pointer to a filled audio buffer we’ve obtained from the freelist).

If each element has some store permanent associated with it (this being done typically when the ringbuffer is initialized) then we have the problem earlier described; if we read by just getting a pointer, which is to say obtain a pointer to a filled audio buffer, another thread could perfectly well write into that buffer as we’re still using it. So we need to detach the element from the ringbuffer, which gives us the get_read_element() / put_read_element() style semantics.

OTOH, if we have a freelist of audio buffers, and we take a buffer from there, fill it, then put a void pointer to it into the ringbuffer, then the act of reading is the act of taking that void pointer and the reading thread can then do something with it and when it’s done, put it back on the freelist. With this arrangement, we can have simply read() and write() - write will as in the previous paragraph overwrite the existing void pointer, but that’s fine; that’s not going to interfere with anyone who’s already obtained a copy of that void pointer. (One thing we do need to look out for is when a write to the ringbuffer overwrites an exiting element, where the ringbuffer is full; the writer must get back the void pointer he has overwritten, so that the user can do something with it - such as returning it to a freelist - rather than it being lost).

In the spirit of having one thing perform one task, the ringbuffer shall now have read() / write() semantics, and the user must look after his pointers.

2015-11-27

Update

liblfds and test compile again, libcommon has been deleted. Will need to update all the build configuration of course. I’ve been building up a list of small things in the code which I need to fix/improve. Will get them all done before updating the build configurations on other platforms.

The build/usage/porting doc layout is now healthy - the layout makes obvious sense (I hope anyway!) to people coming to it for the first time.

Wrote the first pass of the btree docs.

Finish first pass of the usage guides for liblfds and test.

Todo;

  1. ringbuffer docs (and possible API changes - not sure I like how it is now)
  2. finish first pass of the building and porting guides for liblfds and test
  3. implement the ‘small fixes’ list
  4. update all the build config and have test pass on all platforms
  5. second pass of all docs

and back round we go

So, I made libpal and moved the liblfds and test porting layers into it. The liblfds porting layer consists of header files only, so libpal does not need to be compiled for liblfds - but it does need to be there and that was odd.

It meant liblfds now dependend upon some header files elsewhere, so you had to make sure to copy not just the library other but this dependency.

This is not going to be expected.

I think in fact the problem was that I added libcommmon and libbenchmark. I like having them, they make it easier to code, but then I need to document well there’s test, and then there’s libcommon, and you need to build this and this for that and so on…

So what I’m going to do is make liblfds, test and benchmark independent (well, test and benchmark both require liblfds of course :-)

They will have their own fully independent porting layers, and I’ve got rid of libcommon/libbenchmark. It will mean duplicating some abstraction and utility code between test and benchmark, but it’s worth it for the simplification of documentation.

2015-11-26

thoughts

I’ve been looking at the porting documentation.

Right now it’s wrong, because it talks about porting test, but you don’t port test - test has no porting stuff in it. You need to port libcommon; it’s that which has the abstraction layer for test.

It’s called libcommon because although it’s not in this release, there’s also a benchmark programme, and there’s also a libbenchmark, which has another, fatter abstraction layer needed by the benchmark programme.

So it’s a complex mess.

What I’m thinking now is to remove the abstraction layer from liblfds, get rid of libcommon and libbenchmark and have libporting (porting abstraction layer). This will contain all of the abstraction layers - you implement as much as you need to get what you want working, i.e. there’s a minimal layer for liblfds, a bit more on top of that for test, then quite a bit more for benchmark.

libcommon and libbenchmark also contain quite a bit of utility code used by test and benchmark, but I can move that code into the programmes themselves - just to get it out of the way from the user.

Thing is, I really do NOT want to go off into major surgury land at this point. I want to get a release out.

Update

So far today;

  1. hash docs first pass
  2. first pass for both usage guides
  3. introduction second pass

Next;

  1. btree docs
  2. building guides

2015-11-25

Update

So, today;

  1. list bifuricated (library and test)
  2. first pass list docs written (for both lists)
  3. first pass liblfds porting guide written
  4. added liblfds to the API docs

Outstanding;

  1. binary tree docs
  2. hash docs
  3. liblfds docs
  4. ringbuffer docs
  5. porting guide for test
  6. complete the building guides
  7. complete the user guides
  8. bring all the build configurations up to date and run test on all platforms

List bifurication

I’ve split the list into two, one is ordered, the other is unordered.

List

I’ve just been documenting the list.

I’m finding I’m having to explain a lot about ordered vs unordered usage - I think I’m going to split the list into two, an ordered version and an unordered version.

Update

Man.

Docs take foooooooooooooooooooooooooorever.

I know this of course.

I’m just sayin’ :-)

The code is basically complete - I need to update build files for all the platforms, and then run test on them all.

It’s all doc work now.

Update

Turned out to be a test bug.

Been writing docs. Getting the filled-in template pages up for each prototype. Done about half.

2015-11-24

Inadvertantly detected race condition in ringbuffer read test

Release 7.0.0 features exponential backoff for atomic operations.

There was a bug in this code which meant the backoff loop instead of running up to 0/1/2/4/8/16/32/etc times, was running a very large number of times (billions).

This caused the ringbuffer read test to fault :-)

I’ve added now a random delay in all the tests, which is present only in debug builds (i.e. slow builds) and I’m running it through now.

2015-11-22

Raspberry Pi rocks

Raspberry Pi is up and running and currently executing the test programme.

It’s been flawless. Wrote an image of the Pi port of Debian on an SD card, this has gcc, make, nano, etc, on board. Booted perfectly, logged in, transferred the liblfds source code, compiled it all, first time I’ve build on Linux for a bit so fixed one of two bugs (and as ever always surprised that the MS compiler I’m using doesn’t complain when I used undefined enum types - yes, you read that right!)

Fabulous. Got my own tiny form factor 32-bit quad-core ARM platform, for 70 bucks all told. Couldn’t ask for more.

Raspberry Pi

The Raspberry Pi arrived yesterday.

I ordered the wrong type of SD card - d’oh. I should have ordered a micro SD card.

The local water main broke this morning - it’s just been fixed - so I can now ablute and then head out to buy a card.

The Grand Renaming

Is done.

Directories and filenames are long form, prototypes are short form.

I’ve omitted “multipleconsumer_mutipleproducer” - it’s the default. I might include it in the future, if the addition of other data structure variants would make its use beneficial. Right now it’s not needed, that level of naming complexity does not exist, so it is omitted.

Now I can finally get on with the docs, in their final, proper form.

short form chosen

Like so;

lfds700_btree_au lfds700_freelist_mm lfds700_hash_a lfds700_list_as lfds700_queue_mm lfds700_queue_bss lfds700_ringbuffer_mm lfds700_stack_mm

It’s alphabetic, with least varying parts first.

With lock-free, you basically get three forms of data structures; fully singlethreaded (which isn’t really lock-free, there are no locks), two threaded where one thread writes and the other only reads (say, single producer/consumer queue), and fully multi-threaded (any number of concurrent whatevers).

I’m toying with the idea of adding in single-threaded variants of these data structures.

The outstanding question for me now though is the long form name.

“lfds700_queue_bounded_singleconsumer_singleproducer” needs to be what it is, but do I really want to add “multipleconsumer_multipleproducer” on the end of every fully multi-threaded data structure name?

2015-11-21

ahhhhhhhh

The Raspberry Pi 2 Model B has a MICRO SD slot, not as SD slot…

Anyone want a very nice 16GB SD card?

Naming conventions

So there are data structures and variants upon them, so you can’t just say “queue”. You have to indicate variant.

The current long form versions of the names are;

lfds700_btree_addonly_unbalanced lfds700_freelist lfds700_hash_addonly lfds700_list_addonly_singlylinked lfds700_queue_mutiple_producer_mutiple_consumer lfds700_queue_single_producer_single_consumer_bounded lfds700_ringbuffer_mutiple_producer_mutiple_consumer lfds700_stack

These forms prefix on all prototypes, i.e.

lfds700_queue_single_producer_single_consumer_bounded_init() lfds700_queue_single_producer_single_consumer_bounded_cleanup() lfds700_queue_single_producer_single_consumer_bounded_enqueue() lfds700_queue_single_producer_single_consumer_bounded_dequeue() lfds700_queue_single_producer_single_consumer_bounded_query()

Obviously, so long a name is awkward.

The public headers and the per-data structure directory will retain the long form name, to aid comprehension. Possibly the filenames will retain the long form too. However, the prototype must be shortened.

Question is, to what?

These following seem to be the three options;

lfds700_ahash lfds700_aslist lfds700_aubtree lfds700_mmqueue lfds700_ssbqueue lfds700_mmringbuffer

===

lfds700_a_hash lfds700_as_list lfds700_au_btree lfds700_mm_queue lfds700_ssb_queue lfds700_mm_ringbuffer

===

lfds700_hash_a lfds700_list_as lfds700_btree_au lfds700_queue_mm lfds700_queue_ssb lfds700_ringbuffer_mm

Progress

Just finished the first pass of the API docs for queue_spscb :-) the first full set of docs for an API.

Still wrestling with one last design question - API names.

For example, we have “lfds700_addonly_singlylinked_list”. So, you know what it is from the name, but the name is long. Currently, that name is fully propagated; the directories have that name, the files have that name, the prototypes have that name.

The reason for it is so people coming to the library can immediately and inherently know what they’re looking at.

I’m thinking though (and this was how it was, until I made the full name fully propagate) I could keep the directory names long form, but change the filenames and prototypes to a shorthand, like this;

“lfds700_aslist”.

Much more compact - but now you rely on the user somewhere seeing the long name, because without it, it’s not lear what that data structure is.

mySQL leap second bug!

I’ve just experienced a leap second bug!

https://blog.mozilla.org/it/2012/06/30/mysql-and-the-leap-second-high-cpu-and-the-fix/

mySQL when it passes through a leap second goes to 100% CPU on one core.

You have to manually set the date to fix it.

Wow!

Update

First pass at getting the Windows kernel builds is done, for WDK 7.1 and 8.0.

Linux tomoz.

2015-11-20

Status update

Reinstalled VC2012 on a fresh VM and have just brought all the VC solutions back up to date.

Now making a clone of the VC2012 VM and adding WDK 8.0 to it, for that build.

After that, onto an Amazon Linux VM for Linux user-mode and kernel-mode.

2015-11-18

Amazon addendum

As per earlier post - I tried ordering from Amazon using Tor.

First attempt, password reset, order cancelled.

Second attempt, ditto but also your account is locked and you are NOT told this.

Time for the fix - one to two days.

Turns out of course it ALSO locks your AWS account.

So if you had anything expensive running - tough. You cannot turn it off.

So there’s one hell of a booby-trap here. Order twice using Tor and you can’t access all those expensive by-the-hour VMs you have.

Release incoming, believe it or not

So, I was working away at SMR, debugging the new implementation, then work became ultra busy for a long time (like, minimum twelve hour days) and I lost my mental state.

What I’ve decided to do for now is strip out the SMR stuff, and the benchmark tool, and just get a release out.

I’ve just done the necessary and the test application has just passed under debug.

I no longer have access to an ARM platform, but I’ve ordered (tried to order - Amazon foiled my best efforts) a quad-core Pi, and I’ve applied to the GCC compile farm, to get access to 64 bit ARM and POWER.

So for now, it’ll be Windows and Linux, 32 bit and 64 bit, user-mode and kernel-mode. The Linux build in theory works for Android too, but not tested - I’ll set up a build platform for that, but not yet.

So now - I need to make everything build and pass its tests on all platforms, polish the code (need a good polish - been so much work everywhere for so long) and then write the docs.

2015-09-28

SMR design

So, I wanted to write down the new SMR design.

First, an SMR state is instantiated. As usual, you can have as many as you want, they’re independent. Each thread which is using an SMR state has its own SMR thread state. That SMR thread state is associated with a single SMR state (by a function call).

Threads typically use lock-free data structure APIs, to perform their lock-free work which is using SMR. When such an API function is called, the thread passes in its SMR thread state (this contains a pointer to the SMR state it is associated with).

When a data structure begins some lock-free work (popping from a freelist, etc) it calls a macro to enter a lock-free section, and when it’s done, it calls another macro to leave the lock-free section. These macros set state in the SMR thread state. As such, we know when a thread is in a lock-free section (the entry flag is raised, the exit flag is not) and we know if the thread has been idle since we last looked at it (both flags have not changed).

The SMR API functions which perform the SMR work are manually called by the user; they are not called behind the scenes.

There are two SMR API functions for performing work. The first tried to advance the generation counter (more on this below); the second releases all releasable allocations for the calling thread.

The SMR state maintains a generation counter. This begins at 0 and wraps (unsigned int; we do the necessary math to handle when we wrap).

When an allocation is submitted to SMR (which is to say, has exited a data structure and now we need to know no threads are pointing to it), the current generation counter is recorded.

When the user calls the function to try to advance the generation counter, the function examines the SMR thread state for every thread associated with that SMR state.

If since the last examiniation every thread has either been idle, or has exited one or more lock-free sections, then we know that every allocation with an earlier generation count cannot be pointed at by any thread - as such, we advance the generation counter.

When the user has a thread call the other SMR API function, it scans the allocations submitted by the current thread to SMR and if their generation count is older than the current count, releases them.

That’s the broad overview, and it hasn’t changed.

What’s new though is that I’ve made changes to make the first SMR API functon (advancing the generation counter). This function needs to allow foward progress for any thread calling it - i.e. no matter what other threads are in this function, no matter what state it is in, when a new thread comes to it, it needs to be able to complete the operation and advance the generation counter.

To achieve this the function now has two stages; setting and clearing. In the first stage, setting, the work being done is scanning the SMR thread states to see if they have all been idle or exited a lock-free section. When this is found to be so, the generation counter is then advanced, and the function moves to the second stage, clearing, where it revisits the SMR thread states and updates the information they contain (lowers the flag for having exited a lock-free section, etc).

Part of implementing this means that the generation count and the flags are now in the same word, so they can be atomically set together; for when in the settings phase we check an SMR thread state, we need to be sure we are checking the flags for the expected (and so correct) generation in the SMR thread state.

2015-09-27

SMR

Made the new SMR compile.

There’s an outstanding design issue, which is how to handle new threads, since they will not have the correct generation count.

I know basically what I’m going to do - there will be a flag, one of the bit in the generation count / flags word, which indicates a new thread, and it’ll get special handling.

2015-09-06

SMR design flaw and improvements

So, the freelist rapid push/pop test, using SMR, revealed an SMR bug, which in turn revealed the changes I made to the SMR function for advancing the generation counter, such that that function became multi-threaded (rather than being a critical section bounded by CAS flag) were broken.

What I’ve come up with now instead is the idea that there is a “setting” phase, where threads set their SMR state flags, and then when a thread sees that the generation counter can be advanced, we then have a “clearing” phase, where threads calling the generation-advance function act not to check to see if the generation counter can be advanced, but rather they check to see if all the per-thread flags have been cleared, so that we’re then in the correct state for threads to start the work again of indicating the SMR state so we can again see if the generation counter can be advanced.

The whole point of all this is to ensure any single thread entering the check function can make forward progress - before, this was not the case. I think the design is sound, although I’ve not yet implemented, because…

…I’ve realised in the course of this there is a design flaw, and I’ve not yet resolved it. The handle idle threads, I have it so that when a thread enters a lock-free section, it sets a flag - “LOCK_FREE_IN_PROGRESS” - and lowers that flag on exit. Design flaw is that the code only uses a store barrier, so there’s no guaranteee that flag is visible to other threads (who have issued a load barrier) until an atomic operation is performed - which typically occurs in the act of performing the lock-free work being done, i.e. after we’ve read in and are using sensitive memory addresses.

Any real SMR has to support idle threads, so I have to think of a solution.

Two steps forward, one step backwards, the mantra of all lock-free design work :-)

2015-09-05

Some real actual work

Well wadda ya know - I’ve actually done some real actual more work today - about six or so hours. I’ve been working on the first real SMR test, making it work and getting a feel for how the new SMR API is to use. Found a design flaw in how SMR data structure cleanup was arranged and fixed it.

The basic use principles of the new SMR API seem to simpify out to something like; think only about your current thread, take it as read that anything you put into SMR won’t come out till you call SMR release processing, and remember that any given call to SMR release processing may release zero elements, but that sooner or later, calling SMR release processing will release elements, so you can often find the way to write code is to have your operation in a loop, which exits when the operation is successful, where in the loop you call SMR release processing if the operation failed.

2015-08-16

SMR design

So, I actually did a bit of Googling to see the literature for SMR. I wanted to see if I was missing something obvious. Probably I still am :-)

However, it looks like I might actually have something minutely novel, so I figured I’d write it up a bit here.

As an aside, I’ve also now make the generation-advancing function safely multi-threaded, so callers don’t need to worry about that anymore, and you’ll still get forward progress, etc.

So, SMR design.

It’s epoch based.

There’s a main SMR state, and there’s one state per thread.

A thread registers its state with the main state, which has an atomic add-only list of thread states (which can be in the states active, available, retired, etc - it’s add-only, so callers can try to re-use an available state in the list; each thread state knows its NUMA node number, since we care a lot on the per-thread level about NUMA appropriateness).

Each thread state has a single state variable, which is used as a bitmask, so we can atomically (single CAS) modify all the state information in one operation.

The main state has a generation counter which begins at 0.

So, we begin operations - make a main state, each thread makes a per-thread state and registers with the main state.

All the thread begin idle.

Now a thread comes to perform an operation using lock-free operations; it calls a macro, “BEGIN_LOCK_FREE”, which non-atomically sets a bit in the per-thread state which indicates a read section is in progress, and issues a store barrier.

The thread then finishes the lock-free operations, and so calls a second macro, “END_LOCK_FREE”. This non-atomically clears the “read section in progress” bit, and sets a second bit, “exited read section”.

When a thread has removed an allocation from the (say) lock-free data structure and wants to reuse it, it places the allocation in a single-threaded list which is in the per-thread state, noting the generation count in the main state.

So, now we’re humming along - threads are entering and exiting read sections, threads are submitting elements for reuse.

Now what?

Now we come to the point where the user calls the function to try to advance the generation counter in the main state.

We iterate over the list of thread states in the main state. Now, each thread has two status bits we care about - one is a flag, which is raised when the thread enters a lockfree section and lowered when it leaves, the other is a flag which is raised when a thread exit a lockfree section; the threads themselves never lower this flag - it is lowered, and in every thread state, by this function we’re in now, which is trying to advance the generation counter, if and only if the generation counter is advanced.

What we need, to advance the generation counter, is that every thread has exited a lock-free section (which means all elements queued for reuse are safe) or has been idle (hasn’t entered a lock-free section at all, since the last scan, and so all elements queued for reuse are safe).

So; if we see the exited flag is set, we know a thread has been in and has exited a read section - we’re good.

If we see the active flag is set, and the exited flag is set, we’re still good.

However, if we see the active flag is set, and the exited flag is not set, then we’re screwed - we can’t advance the counter.

So, if we can’t advance the counter, we don’t, that’s that. We return.

If we can advance the counter, we do so - but now comes one final vital point.

So - we have threads queuing up elements for reuse. The generation counter begins at 0, so these elements have a generation count of 0. When we check to advance the generation counter, we need to know that every thread has been completely idle, or has exited a read section after the element was submitted for reuse. However, when we do get round to scanning the thread states, all we can see is that the exit bit has been set… so we know all the threads HAVE exited a read section, but we don’t know WHEN. It could have been (say) right after only the very first element was submitted - and then it might be one of the threads has been stuck in a long running read section all the time since then - which would mean only the first element was actually safe for reuse.

How do we handle this?

The answer is that when a thread comes to scan its release candidate list, comparing each elements generation counter with the current main state generation counter, elements are only released when the difference is greater than TWO, not ONE.

In other words - having done this first scan (and finding all threads have been idle or have exited), we do advance the generation counter and we set the exited bit in each thread state to lowered (this is vital, remember it) - but that does not mean the previous generation (0 in this case) can now be released. It cannot - for we do not know when each thread exited, so we cannot know which elements are safe to release. However, having lowered the exit bit, when we come to scan again, if we see AGAIN all threads have been idle or have exited a read section, THEN ALL THREADS MUST HAVE EXITED AFTER THE FINAL GENERATION 0 ELEMENT WAS SUBMITTED - which means generaton zero is now safe to release.

So we’re always a generation behind on releasing.

I’m thinking I must have missed an obvious way to simplify this - but I can’t see it. We have to know if a thread had entered a lockfree section (to detect idle threads). We have to know when all the threads have exited (so we can know to advance the generation counter). I mean, basically, the design is that threads indicate they’ve exited a lockfree section, and we notice this only whenever the user calls the generation counter advance function, so we can’t know when they exited, only that they have, so we have to have two rounds of every thread having exited to know the generation before last is clear and safe to release.

Inverted SMR

So, yeah, thought about it a bit.

What stops the generation counter from advancing past a given generation? a thread which is in a read section. So when a thread enters a read section, it posts in its per-thread state the current main state generation value, and then clears that when it exits the read section. When we come to release reuse candidates, we scan the per-thread states, pick up any busy threads’ posted main state generation value, and the lowest value of them is how far up to we can release reuse candidates.

Idle threads are always permissive - no need to have any extra house-keeping to detect them - and what’s nice is because we’re now reversed, it doesn’t matter if threads when posting read an older version of the main state counter - it just makes us less efficient, rather than breaking the system.

However, it still means the main state counter has to increment every time a thread enters a read section (doing only on reuse is no good - I think you end up needing a period where no threads are in read sections, to be able to release reuse candidates, otherwise on a busy system you end up always seeing threads are in read sections) and these increments do need to be atomic - if we lost a write, a thread would think it is in an earlier generation than it really is, so we could reuse elements not yet safe to reuse.

Basically, I’m barking up the wrong tree - for performance, all information which lets a scan to advance the generation counter has to be stored and maintained in the per-thread state, with only read access to the main state. Only the scan to advance the generation counter can write the main state.

This is how the current mechanism works.

New SMR design

So! I don’t think this idea works, because to make it work the performance would be too poor, but…

You have a main state, and a per-thread state.

Each per-thread state registers with the main state.

The main state holds a counter, the “current counter”, which begins at 0. Every time a thread adds an element to its reuse candidate list, it stores in the reuse candidate the value of the main counter, and atomically increments the main counter. (On a busy system, the contention on that counter would drive performance into the ground - however, there is a scalable counter design…)

There is another counter in the main state, the “safe counter”, which also begins at 0 - it begin safe to reuse elements up to this value.

Every time a thread exits a read section, it stores the current value of that main counter in its thread state.

When we come to check to see if we can advance the safe counter, we iterate over the thread states, looking at their counter (the value of the main state current counter when they last exited a read section), and find the lowest value of them all (ignore idle threads for a moment). We then advance the safe counter to this lowest value - i.e. this is the point after which not all threads have exited a read section, and so the reuse candidates cannot yet be reused.

To deal with idle threads, we keep a flag in the thread state, which is raised when the thread enters a read section and lowered when we check to advance the safe counter. If the flag is lowered, then the thread has been idle.

In conceptual terms, ignoring actual practial performance, the design has high fidelity with regard to knowing which elements can be reused. As each element has its own generation count, and we know to which generation count we’re safe to re-use elements, we reuse every possible element we can.

What strikes me now though is that perhaps another way is to invert the paradym; rather than assuming we can’t advance, and then checking to see how far it is safe to advance (and so having trouble with idle threads, since they are silent), what about assuming we can advance (and so idle threads naturally say the right thing), with blockers in the way for the points beyond which we cannot advance?

Have to think about this, might just be crazy in the first instance, will see.

SMR Redux

So, my previous post about a design flaw in SMR, was incorrect.

Where I’d not touched that code for a while, I was not fully understanding what was going on. In fact, the code knows that a thread has at any time in the past (since the most recent generation advance) exited a read section, and so is not dependent on checking at a moment when no threads are in read sections.

So, I’ve been working on the tests, getting them to work, and I’ve finally come to a test which is really using SMR in anger, and of course this reveals to you what it’s like to actually use the API - where that API has changed, and is now no longer called every now and then when entering/exiting a read section or submitting an element, but explicitly and manually by the user.

One inherent aspect of SMR, which is visible and awkward for the developer, is that it is never possible to guarantee that an attempt to advance the generation counter will work. Another thread which is inside a read section blocks the advance of the generation counter beyond its current value. Of course, read sections are by design intended to be extremely brief, so in practise it’s not an issue - but it does mean no guarantee.

One thing which has become clear is that the function call which attempts to advance the generation counter has to be multi-threaded - it is ugly and onerous to put upon the user the burden of ensuring this is only called by a single thread at a time.

2015-08-13

SMR

So I’ve been going through the tests making them work again.

I’m currently working on SMR.

Having not touched the SMR code for some time I come back to it fresh - and I have perceived what I think is a design flaw. Not a bug, it works, but, well, maybe it doesn’t work very well when load is high.

The core issue with SMR is knowing when it’s safe to advance the generation counter. Each SMR instantiation maintains a generation counter, which begins at 0, and when an allocation is submitted to SMR (to be returned when it is safe to reuse or free, i.e. when no thread could possibly access it) it is assigned the value at that time of the generation counter.

When the generation counter has advanced by two more than the value in an allocation (I can’t remember why two, offhand - there is a vital reason for it, or there was at any rate, as I initially had it set to one, and that was a bug; I realised why and changed it to two) then it is safe to be reused.

Now, the design flaw is this : to advance the generation counter, the user calls an SMR function, which checks for certain criteria (I’ll come to that in just a mo) and if they are satisfied, the generation counter is advanced.

Remember here we’re checking for the possibility of a thread accessing an element which has already been by one thread submitted to SMR for reuse - i.e. that thread has emerged from a read section holding the element, having removed it probably from a data structure, and wants it to be re-used. The problem SMR is solving is that other threads might be engaged at that very moment in lock-free work and hold pointers to that element. We need all threads to be known to have exited their read sections (the code which does lock-free work) or to have been idle.

The critera are that since the last call to this function, all threads have either been idle (which is to say, not entered a read section - i.e. have done no lock-free work), or have entered and then exited a read section. If however any thread is currently IN a read section, then it could be it holds a pointer to this allocation.

So the problem is this - if the data structure is very busy, and there are many threads, some threads will always or almost always be in a read section. We never get to advance the generation counter!

A solution which comes to mind is this : each thread in its per-thread SMR state keeps track of the number of tiems it has entered and exited a read section. It also keeps a copy of the values of those counters from when the user last checked to see if the generation counter could be advanced.

This way even if we have lots of busy threads, we can still advance the generation counter, becuse we can see how often each thread has exited a read section. So even if many threads are currently IN a read-section, we can still know it’s safe to advance the ccounter.

So now I have more work to do - in the sense that I need to make the current SMR pass it tests again (which is itself already quite improved since the benchmark app was working), get the benchmark app running again, benchmark, then make these changes, then benchmark again.

2015-07-25

Progress

Ha. My post has the same name as a Russian spaceship.

A weekend ago I made liblfds compile again.

I’m now working on the test suite. It’s a lot of work. I’m going to release without the benchmark programme - it’ll just take too long.

So, current goal is to get test compiling.

I’d like to get it done this weekend, but we’ll see.

Managed to really bang a little toe into a metal bar, yesterday, so I’m stuck indoors today (and prolly tomorrow). There’s a Statue of Liberty kayak trip this Sunday, which by my trip up to WDC Thu/Fri I completely forgot to book in time - uber bleh :-( like the third time I’ve missed it, and it only runs every two weeks.

2015-07-07

Status

Have made the gross code changes to liblfds, now need to slap it around until it compiles.

Then need to rewrite all the tests, and also the benchmark app too.

This thing has one hell of a tail. I need an automatic code adjuster, something which understands C and adheres to my code style; but that won’t help with test or benchmark.

Moved back to WordPress.

See title.



Home Blog Forum Mailing Lists Documentation GitHub Contact

admin at liblfds dot org