qt_loop_queue_run(3)

💖 qt_loop_queue_run — bestie's guide to the smart threaded loop 💖

okay so this is page qt_loop_queue_run(3) from the libqthread manual, and it's genuinely one of my faves, no cap. two functions, one chaotic-but-smart idea: let the loop figure out its own workload. let's get into it 🦋

✨ NAME ✨

qt_loop_queue_run, qt_loop_queue_run_there — an intelligent implementation of a threaded loop

like. it's a threaded loop but make it adaptive. it's giving main character energy, honestly 👑

🌸 SYNOPSIS 🌸

#include <qthread/qloop.h>

void
qt_loop_queue_run (qqloop_handle_t *loop);

void
qt_loop_queue_run_there (qqloop_handle_t *loop,
                         qthread_shepherd_id_t shep);

yes bestie, that's the whole include. qthread/qloop.h and you're in 💅

🎀 DESCRIPTION 🎀

so these functions are an adaptive implementation of a threaded loop. "adaptive" meaning the loop literally reads the room and adjusts. iconic behaviour fr fr.

For qt_loop_queue_run(): the number of threads it uses depends on how many shepherds are available — and active. so if some shepherds are off doing their own thing, the loop isn't gonna sit there waiting on them like a sad little group chat. it adapts 🧚

For qt_loop_queue_run_there(): this one spawns a single worker thread on the shepherd you specify with shep. just one. on purpose. that's the vibe.

Now, the way iterations actually get processed? In chunks. And the size of each chunk is variable</> — it's determined by the style of adaptivity selection you picked back when you created the loop handle loop. so basically you already told it how to behave, and now it's out here living its truth ✨

💀 real talk though: if a shepherd gets deactivated while the loop is processing, the worker thread assigned to that shepherd will exit, and the remaining worker threads will automatically adapt. it just handles it. no drama. periodt.

Other than all that, these functions behave somewhat similarly to qt_loop_balance() — meaning they will not return until all iterations of the loop have been completed. so like, do not expect them to come back early. they are committed. they're in a situationship with your loop and they're seeing it through to the end 🫶

One thing you absolutely cannot skip: the loop handle must be allocated by qt_loop_queue_create(). and yes, these functions will deallocate it for you. so don't go freeing it yourself afterwards, bestie, that's not your job, that's their job 😭

🌈 SEE ALSO 🌈

• qt_loop(3)
• qt_loop_balance(3)
• qt_loopaccum_balance(3)
• qt_loop_queue_create(3)
• qt_loop_queue_addworker(3)

go read qt_loop_queue_create(3) first fr, you literally need it to make the handle 💖

okay that's the whole page, you ate that, go write some parallel loops 💅✨

this was libqthread, JUNE 2010 — yeah it's an oldie but she's still slaying, iykyk 🎀🦋🌸