[chuck-users] Stopping and restart shreds

[w31rd0]

> > > Currently in ChucK, a parent shred will terminate any child shreds
> when
> > > the parent terminates.
> >
> > The current way chuck works makes sense. But (and I don't know "the
> > prober to do this in concurrent programming) I think it would make
> more
> > sense to wait for child shreds to finish before terminating. This
way
> a
> > parent wouldn't have to worry how long the child is running, which I
> > think is none of it's business.
> >
> > I have a lot of examples in my code on me explicitly having to
handle
> > this and it both 1) looks ugly and 2) is not that robust.
> >
> > BTW: would it be possible to grab the id of the child and wait for
> that
> > is to finish, instead of my current way (chucking a sufficiently
large
> > dur to now in the parent after sporking)?
> 
> You can make your children explicitly signal they are exiting, like
> this:
> 
> 
> fun void foo( Event e )
> {
>     10::ms => now;
>     <<< "foo", "" >>>;
>     e.signal();
> }
> 
> fun void bar( Event e )
> {
>     1000::ms => now;
>     <<< "bar", "" >>>;
>     e.signal();
> }
> 
> Event e1, e2;
> 
> spork ~ foo( e1 );
> spork ~ bar( e2 );
> 
> e1 => now;
> e2 => now;
> 
> 
> Still ugly though ;(

Oops!
Discovered that this wouldn't work when "foo" is executed longer than
"bar".
Here is a slightly improved version:


public class Semaphore
{
    0 => int _counter;
    Event _event;

    public void push()
    {
        _counter++;
    }

    public void pop()
    {
        _counter--;
        if( _counter <= 0 )
        {
            _event.signal();
        }
    }

    public void wait()
    {
        _event => now;
    }
}

fun void foo( Semaphore s )
{
    s.push();
    100::ms => now;
    <<< "foo", "" >>>;
    s.pop();
}

fun void bar( Semaphore s )
{
    s.push();
    1000::ms => now;
    <<< "bar", "" >>>;
    s.pop();
}

Semaphore s;

spork ~ foo( s );
spork ~ bar( s );

s.wait();


___________________
w31rd0