Threads for Rakudo Perl 6

So it has come to this. is up and running, bringing the ever-wanted threaded execution to the most popular Perl 6 implementation.

You’re looking for TL;DR, aren’t you? Here’s what it’s capable of:

use Threads;
use Semaphore;

my @elements;
my $free-slots = => 10);
my $full-slots = => 0);

sub produce($id) {
    my $i = 0;
    loop {
        @elements.push: $i;

sub consume($id) {
    loop {
        my $a = @elements.shift;

for 1..5 -> $i {
    async sub { produce($i)  }

for 5..10 -> $i {
    async sub { consume($i) }

Doesn’t look that awesome. I mean, it’s just a producer-consumer problem, what’s the big deal? Let me repeat:


So, once we’re done celebrating and dancing macarena all around, there’ll always be someone to ask “hold on, there’s gotta be a caveat. Something surely is missing, explain yourself!”

I’ll be delighted to say “nope, everything’s there!”, but that’d make me a liar. Yeah, there are missing pieces. First, those aren’t really native threads – just green threads. Native OS threads are already implemented in Parrot VM, but NQP (the language that Rakudo is based on) still doesn’t support them, so before some volunteer comes along to fix them, you’ll still have to build parrot --without-threads (which means: use green threads, not OS threads) for to work. But fear not! The API is exactly the same, so once native threads are there, both and the code you write with it should work without any changes.

But green threads are fine too! Except for one minor detail: whenever any of them blocks on IO, the entire Parrot comes to a halt. The plan is for Parrot threads scheduler to handle it nicely, but it’s not there yet, so if you expected nice and easy async IO, sorry, but you’re stuck on MuEvent :)

Yep, we’re not really there yet. But I claim it’s closer than ever. We have working threads implementation. You can write code with that, and it’s not a PITA. Go for it! There’s a lot of room to improve it. I didn’t try really hard for to follow the concurrency synopsis (in my defense, I think niecza doesn’t follow it either :)), and I think that once we unleash a wolfpack of developers which can work towards something that we’ll all love to use.


2 Comments on “Threads for Rakudo Perl 6”

  1. anj1999 says:

    So if OS threads are going to be supported, where will the mutex or other locking structure go that is necessary to protect simultaneous access to the internals of the @elements array on an SMP machine?

    If I’ve understood and the above code properly, the two semaphores only protect their count value while in the wait() or post() methods, and you have up to 10 threads all actively calling push() or shift() on the @elements array at the same time. For a green threads implementation on a single OS thread such mutex protection is not necessary, but (as someone with lots of multi-threaded coding experience) it seems to me that to try and get this code running safely on multiple OS threads is likely to need a *major* overhaul of the internals and some significant performance hit.

    • ttjjss says:

      Thanks for your comment. As far as I understand it, the way Parrot native threads currently do this is that every write access to a shared variable is done through a proxy object, described in more detail in, section “Writing to shared variables”. Seems to me that protecting the writes themselves is done without any effort from the user’s side, although I must admit to not looking into that too deeply.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s