🚀 go-pugleaf

Bob Gonder wrote:

>GlobalButtonclickEvent is manual reset type.
>ThreadEvent is semaphore type.
>Buttonclick posts PulseEvent() to GlobalButtonclickEvent.
>Thread0 in each app is waiting for GlobalButtonclickEvent.
>Each Thread0 posts a ReleaseSemaphore() of 3, starting 3 worker
>threads.
>That would take care of how many to run. Now, how do you make sure
>that each thread runs the same number of times? (that the faster
>thread doesn't steal a cycle from a slower one).
>Each thread could have a counter.
>Thread0 keeps a count of how many times it has released 3 threads.
>If WorkerThread1 wakes up and sees that it's counter >= Thread0
>counter, then it posts a ReleaseSemaphore() of 1 (to make up for
>snagging one by mistake), sleeps a bit, the waits again.
>How big should the counter be? how many times is this cycle going to
>occur? There are other more involved methods to ensure counter doesn't
>overflow. But if this is a manual operation, the billion or so clicks
>supported by a long count should suffice.

With that in mind, a simpler method:
Still 4 threads, One CounterThread, Three WorkerThreads.

All threads wait for ManualReset type Event.

OnClick() sends PulseEvent.

CounterThread adds 1 to GlobalCount. the goes back and waits for
another event.

WorkerThreads, if not already running, start running when Event comes.
WorkerThreads check GlobalCount against their own count, and recycle
if not equal. Otherwise, they wait.

	unsigned long GlobalCount=0;
CounterThread()
{
	while( !Terminated)
	{	WaitForObject()
		++GlobalCount;
	};
}
WorkerThread()
{	unsigned long Count=0;
	while( !Terminated)
	{	if( GlobalCount==Count )
			WaitForObject()
		++Count;
		Sleep(rand());
	};
}	

CounterThread, being so short, should catch every Pulse.
If WorkerThreads miss the Pulse, they should still see a difference in
Count and run again.  There is a small race condition though.  If the
Pulse comes After the WorkerThread checks Count, and Before WaitFor is
processed, then it could miss it. But, it will make up for it the next
time.