Threads vs. GC

[Simn]

I've been working in threaded environments recently and the one target that I just can't get to perform well is HL. Here's an example of busy iterations that allocate strings:

import sys.thread.Semaphore;
import sys.thread.Thread;
import haxe.Timer;

final iterationsPerThread = 1000;

var racyString:String;
var racyInt = 0;

function beBusyAndAllocate() {
	var busy = 1000;
	while (busy --> 0) {
		racyInt++;
		racyString = new String(racyInt + " " + busy);
	}
}

function reset() {
	racyString = null;
	racyInt = 0;
}

function runSingleThreaded(numThreads:Int) {
	final startTime = Timer.milliseconds();
	reset();
	final numIterations = numThreads * iterationsPerThread;
	for (_ in 0...numIterations) {
		beBusyAndAllocate();
	}
	trace('single-threaded ($numThreads)', Timer.milliseconds() - startTime);
}

function runMultiThreaded(numThreads:Int) {
	final startTime = Timer.milliseconds();
	reset();
	final lock = new Semaphore(0);
	for (_ in 0...numThreads) {
		Thread.create(() -> {
			for (_ in 0...iterationsPerThread) {
				beBusyAndAllocate();
			}
			lock.release();
		});
	}
	for (_ in 0...numThreads) {
		lock.acquire();
	}
	trace('multi-threaded ($numThreads)', Timer.milliseconds() - startTime);
}

function main() {
	for (numThreads in [2, 5, 10]) {
		runSingleThreaded(numThreads);
		runMultiThreaded(numThreads);
	}
}

And some numbers (lower is better):

what	single-threaded	multi-threaded
2 threads
jvm	203	95
c++	676	356
hl	1431	1959
5 threads
jvm	391	228
c++	1701	450
hl	3445	14156
10 threads
jvm	593	362
c++	3414	569
hl	7012	49752

This isn't great.

[Simn]

Performance is actually bad even without the string allocation, i.e. this at the top of the sample:

final iterationsPerThread = 100000;
var racyInt = 0;

function beBusyAndAllocate() {
	var busy = 1000;
	while (busy-- > 0) {
		racyInt++;
	}
}

function reset() {
	racyInt = 0;
}

source/Main.hx:26: single-threaded (2), 432
source/Main.hx:44: multi-threaded (2), 1429
source/Main.hx:26: single-threaded (5), 1083
source/Main.hx:44: multi-threaded (5), 3329
source/Main.hx:26: single-threaded (10), 2196
source/Main.hx:44: multi-threaded (10), 8774

I don't know what to make of that. Is there some internal synchronization going on or is thread execution in general a problem? Even neko doesn't have this kind of performance degradation.

[ncannasse]

This is normal in HL as the threads needs to rendezvous before a GC major takes place. This means threads that are performing heavy computation without any GC allocation will starve the other threads.
You can call hl.Gc.blocking(true) then (false). Either outside of the loop or regularly inside it.

[Simn]

Like this?

function beBusyAndAllocate() {
	var busy = 1000;
	hl.Gc.blocking(true);
	while (busy-- > 0) {
		racyInt++;
	}
	hl.Gc.blocking(false);
}

That is still giving me mostly the same numbers. If anything it's a little worse:

source/Main.hx:28: single-threaded (2), 445
source/Main.hx:46: multi-threaded (2), 1238
source/Main.hx:28: single-threaded (5), 1113
source/Main.hx:46: multi-threaded (5), 3840
source/Main.hx:28: single-threaded (10), 2243
source/Main.hx:46: multi-threaded (10), 9592