Many detached boost threads segfault

Question

I'm creating boost threads inside a function with

while(trueNonceQueue.empty() && block.nNonce < std::numeric_limits<uint64_t>::max()){
    if ( block.nNonce % 100000 == 0 )
    {
        cout << block.nNonce << endl;
    }
    boost::thread t(CheckNonce, block);
    t.detach();
    block.nNonce++;
}
uint64 trueNonce;
while (trueNonceQueue.pop(trueNonce))
        block.nNonce = trueNonce;

trueNonceQueue was created with boost::lockfree::queue<uint64> trueNonceQueue(128); in the global scope.

This is the function being threaded

void CheckNonce(CBlock block){
    if(block.CheckBlockSilently()){
        while (!trueNonceQueue.push(block.nNonce))
            ;
    }
}

I noticed that after it crashed, my swap had grown marginally which never happens unless if I use poor technique like this after leaking memory; otherwise, my memory usage stays frequently below 2 gigs. I'm running cinnamon on ubuntu desktop with chrome and a few other small programs open. I was not using the computer at the time this was running.

The segfault occurred after the 949900000th iteration. How can this be corrected?

CheckNonce execution time

I added the same modulus to CheckNonce to see if there was any lag. So far, there is none.

I will update if the detached threads start to lag behind the spawning while.

You're creating 949900000 threads and wondering why your program segfaults? That's not many threads, that's an orbital cannon pointing down to an anthill. Every thread takes memory, it's more lightweight than a process, but even then it will have it's own stack space etc. — Zeta, Dec 21 '13 at 08:40
@JohnZwinck Thank you for looking John Zwinck! It's verifying cryptocurrency (not bitcoin) block hashes to generate a genesis block. — , Dec 21 '13 at 08:41
@Zeta Thank you too for looking Zeta! The `CheckNonce` function takes extremely little time to complete. — , Dec 21 '13 at 08:42
So you're saying that you create millions of threads, and each one takes very little time to complete? If so, you are doing it wrong. You should use a thread pool instead, to limit thread creation and teardown overhead to a small constant. — John Zwinck, Dec 21 '13 at 09:22
@JohnZwinck Thank you John Zwinck! Would you mind providing a brief example in an answer? Just enough so that I can get started on my own. Pseudo-code would be more than appreciated! Thank you so much in advance! — , Dec 21 '13 at 09:42

score 1 · Accepted Answer · edited May 23 '17 at 12:03

You should use a Thread Pool instead. This means spawning just enough threads to get work done without undue contention (for example you might spawn something like N-2 threads on an N-core machine, but perhaps more if some work may block on I/O).

There is not exactly a thread pool in Boost, but there are the parts you need to build one. See here for some ideas: boost::threadpool::pool vs.boost::thread_group

Or you can use a more ready-made solution like this (though it is a bit dated and perhaps unmaintained, not sure): http://threadpool.sourceforge.net/

Then the idea is to spawn the N threads, and then in your loop for each task, just "post" the task to the thread pool, where the next available worker thread will pick it up.

By doing this, you will avoid many problems, such as running out of thread stack space, avoiding inefficient resource contention (look up the "thundering herd problem"), and you will be able to easily tune the aggressiveness with which you use multiple cores on any system.

Thank you so much John Zwinck! I'm using `thread_group`, using all of my cores, and it's hashing at 10x the rate it was, and I'm even able to continue using my computer! I was before, but my system monitor shows 100% usage on all cores. — , Dec 22 '13 at 04:27

Many detached boost threads segfault

1 Answers1