saturnng/libChf/test04.c

/* $Id: test04.c,v 2.1 2000/05/29 13:10:38 cibrario Rel $
   Chf test program.
   General condition handling - single and multithreaded

   $Log: test04.c,v $
   Revision 2.1  2000/05/29 13:10:38  cibrario
   *** empty log message ***

*/

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <setjmp.h>

#ifdef _REENTRANT
#  include <pthread.h>
#endif

#define CHF_MODULE_ID 255
#define CHF_EXTENDED_INFO
#include "Chf.h"

struct tdata_s {
    const ChfDescriptor *d, *e;
    int phase;
};

ChfAction h1( const ChfDescriptor* c, const ChfState s, ChfPointer p )
{
    struct tdata_s* tdata_p = ( struct tdata_s* )p;
    ChfAction action;

    if ( c != tdata_p->e || ChfGetNextDescriptor( c ) != tdata_p->d ) {
        ChfCondition 10, CHF_FATAL ChfEnd;
        action = CHF_RESIGNAL;
    }

    else
        action = CHF_CONTINUE;

    return action;
}

ChfAction h2( const ChfDescriptor* c, const ChfState s, ChfPointer p )
{
    struct tdata_s* tdata_p = ( struct tdata_s* )p;
    ChfAction action;

    switch ( s ) {
        case CHF_SIGNALING:
            {
                if ( c != tdata_p->e || ChfGetNextDescriptor( c ) != tdata_p->d || ( tdata_p->phase != 2 && tdata_p->phase != 4 ) ) {
                    ChfCondition 10, CHF_FATAL ChfEnd;
                    action = CHF_RESIGNAL;
                }

                else {
                    action = ( ChfGetConditionCode( c ) != 8 ? CHF_CONTINUE : CHF_UNWIND );
                }
                break;
            }
        case CHF_UNWINDING:
            {
                if ( tdata_p->phase != 4 )
                    exit( EXIT_FAILURE );
                tdata_p->phase = 5;
                action = CHF_CONTINUE;
                break;
            }
        default:
            {
                exit( EXIT_FAILURE );
            }
    }
    return action;
}

ChfAction h3( const ChfDescriptor* c, const ChfState s, ChfPointer p )
{
    struct tdata_s* tdata_p = ( struct tdata_s* )p;
    ChfAction action;

    /* This handler must be invoked only during the first signal */
    if ( tdata_p->phase != 3 )
        exit( EXIT_FAILURE );

    switch ( s ) {
        case CHF_SIGNALING:
            {
                if ( ChfGetConditionCode( c ) != 9 || ChfGetNextDescriptor( c ) != NULL ) {
                    exit( EXIT_FAILURE );
                }

                else {
                    tdata_p->phase = 4;
                    action = CHF_CONTINUE;
                }
                break;
            }
        default:
            {
                exit( EXIT_FAILURE );
            }
    }
    return action;
}

ChfAction h4( const ChfDescriptor* c, const ChfState s, ChfPointer p )
{
    struct tdata_s* tdata_p = ( struct tdata_s* )p;
    ChfAction action;

    /* This handler must be invoked only during the first signal */
    if ( tdata_p->phase != 2 )
        exit( EXIT_FAILURE );

    switch ( s ) {
        case CHF_SIGNALING:
            {
                if ( c != tdata_p->e || ChfGetNextDescriptor( c ) != tdata_p->d ) {
                    ChfCondition 10, CHF_FATAL ChfEnd;
                    action = CHF_RESIGNAL;
                }

                else {
                    /* This generates a new group and signals it */
                    tdata_p->phase = 3;
                    ChfCondition 9, CHF_INFO ChfEnd;
                    ChfSignal();

                    if ( tdata_p->phase != 4 )
                        exit( EXIT_FAILURE );
                    tdata_p->phase = 5;

                    if ( c != tdata_p->e || ChfGetNextDescriptor( c ) != tdata_p->d ) {
                        ChfCondition 10, CHF_FATAL ChfEnd;
                        action = CHF_RESIGNAL;
                    } else
                        action = CHF_CONTINUE;
                }
                break;
            }
        default:
            {
                exit( EXIT_FAILURE );
            }
    }
    return action;
}

void* task( void* arg )
{
    volatile struct tdata_s tdata;

    /* The sleep() is here to increase contention between threads */
    sleep( 1 );

    printf( "\tThread %d\n", ( int )arg );

    /* Push the handler */
    ChfPushHandler( h1, NULL, ( ChfPointer )( &tdata ) );

    /* Generate a condition group and signal it */
    ChfCondition 6, CHF_INFO, ( int )arg ChfEnd;
    tdata.d = ChfGetTopCondition();
    ChfCondition 7, CHF_INFO, ( int )arg ChfEnd;
    tdata.e = ChfGetTopCondition();

    /* The sleep() is here to increase contention between threads */
    sleep( 1 );
    ChfSignal();

    /* Pop the handler */
    ChfPopHandler();

    /* Generate a new condition group with (apparently) wrong linkage
       and signal it; this checks that the handler has actually been
       removed.
    */
    ChfCondition 6, CHF_INFO, ( int )arg ChfEnd;
    tdata.d = NULL;
    ChfCondition 7, CHF_INFO, ( int )arg ChfEnd;
    tdata.e = NULL;
    ChfSignal();

    /* Conditional unwind test */
    {
        sigjmp_buf jb;

        tdata.phase = 0;
        if ( setjmp( jb ) == 0 ) {
            ChfPushHandler( h2, jb, ( ChfPointer )( &tdata ) );

            /* Generate a condition group and signal it */
            tdata.phase = 1;
            ChfCondition 6, CHF_INFO, ( int )arg ChfEnd;
            tdata.d = ChfGetTopCondition();
            ChfCondition 7, CHF_INFO, ( int )arg ChfEnd;
            tdata.e = ChfGetTopCondition();

            /* This does not trigger an unwind */
            tdata.phase = 2;
            ChfSignal();

            tdata.phase = 3;
            ChfCondition 6, CHF_INFO, ( int )arg ChfEnd;
            tdata.d = ChfGetTopCondition();
            ChfCondition 8, CHF_INFO, ( int )arg ChfEnd;
            tdata.e = ChfGetTopCondition();

            /* This MUST trigger an unwind */
            tdata.phase = 4;
            ChfSignal();

            exit( EXIT_FAILURE );

        } else {
            /* Unwind */
            if ( tdata.phase != 5 )
                exit( EXIT_FAILURE );

            ChfPopHandler();
        }
    }

    /* Condition generation and signal while a signal is in progress;
       this requires two handlers.
    */
    {
        tdata.phase = 0;

        ChfPushHandler( h3, NULL, ( ChfPointer )&tdata );
        ChfPushHandler( h4, NULL, ( ChfPointer )&tdata );

        tdata.phase = 1;
        ChfCondition 6, CHF_INFO, ( int )arg ChfEnd;
        tdata.d = ChfGetTopCondition();
        ChfCondition 7, CHF_INFO, ( int )arg ChfEnd;
        tdata.e = ChfGetTopCondition();

        tdata.phase = 2;
        ChfSignal();

        if ( tdata.phase != 5 )
            exit( EXIT_FAILURE );

        ChfPopHandler();
        ChfPopHandler();
    }

    return ( void* )0;
}

#define N_THREADS 50

int main( int argc, char* argv[] )
{
    int st;
    int i;
    void* ret;

#ifdef _REENTRANT
    pthread_t t[ N_THREADS ];
#endif

    puts( "test04" );

    /* Initialization */
    if ( st = ChfMsgcatInit( argv[ 0 ], CHF_DEFAULT, "./test01.cat", 50, 10, 1 ) )
        exit( st );

#ifdef _REENTRANT
    /* Create */
    for ( i = 0; i < N_THREADS; i++ )
        if ( pthread_create( &( t[ i ] ), NULL, task, ( void* )i ) ) {
            perror( "pthread_create" );
            exit( EXIT_FAILURE );
        }

    /* Join */
    for ( i = 0; i < N_THREADS; i++ )
        if ( pthread_join( t[ i ], &ret ) ) {
            perror( "pthread_join" );
            exit( EXIT_FAILURE );
        }
#else
    task( ( void* )0 );
#endif

    /* Exit Chf */
    ChfExit();
    exit( EXIT_SUCCESS );
}