Ejemplo n.º 1
0
void
d_waitsetDeinit(
    d_object object)
{
    d_waitset waitset;
    d_waitsetEntity we;
    d_waitsetHelper helper;

    assert(d_objectIsValid(object, D_WAITSET) == TRUE);

    if(object){
        waitset = d_waitset(object);
        waitset->terminate = TRUE;

        if(waitset->runToCompletion == TRUE){
            if(os_threadIdToInteger(waitset->thread)) {
                u_waitsetNotify(waitset->uwaitset, NULL);
                os_threadWaitExit(waitset->thread, NULL);
            }
        } else {
            if(waitset->threads){
                helper = d_waitsetHelper(c_iterTakeFirst(waitset->threads));

                while(helper){
                    helper->terminate = TRUE;
                    u_waitsetNotify(helper->userWaitset, NULL);
                    os_threadWaitExit(helper->tid, NULL);
                    u_waitsetDetach(helper->userWaitset, u_entity(helper->entity->dispatcher));
                    u_waitsetFree(helper->userWaitset);
                    os_free(helper);
                    helper = d_waitsetHelper(c_iterTakeFirst(waitset->threads));
                }
                c_iterFree(waitset->threads);
                waitset->threads = NULL;
            }
        }
        d_lockLock(d_lock(waitset));

        if(waitset->entities) {
            we = d_waitsetEntity(c_iterTakeFirst(waitset->entities));

            while(we) {
                if(waitset->runToCompletion == TRUE){
                    u_waitsetDetach(waitset->uwaitset, u_entity(we->dispatcher));
                }
                d_waitsetEntityFree(we);
                we = d_waitsetEntity(c_iterTakeFirst(waitset->entities));
            }
            c_iterFree(waitset->entities);
        }
        if(waitset->runToCompletion == TRUE){
            if(waitset->uwaitset) {
                u_waitsetFree(waitset->uwaitset);
            }
        }
        d_lockUnlock(d_lock(waitset));
    }
}
Ejemplo n.º 2
0
c_bool
d_waitsetDetach(
    d_waitset waitset,
    d_waitsetEntity we)
{
    u_result ur;
    c_bool result = FALSE;
    int i;
    d_waitsetHelper helper;

    helper = NULL;

    assert(d_objectIsValid(d_object(waitset), D_WAITSET) == TRUE);
    assert(d_objectIsValid(d_object(we), D_WAITSET_ENTITY) == TRUE);

    if(waitset && we){
        d_lockLock(d_lock(waitset));

        if(c_iterContains(waitset->entities, we) == TRUE) {
            if(waitset->runToCompletion == TRUE){
                ur = u_waitsetDetach(waitset->uwaitset, u_entity(we->dispatcher));
            } else {
                for(i=0; i<c_iterLength(waitset->threads) && !helper; i++){
                    helper = d_waitsetHelper(c_iterObject(waitset->threads, i));

                    if(helper->entity != we){
                        helper = NULL;
                    }
                }
                assert(helper);
                c_iterTake(waitset->threads, helper);
                helper->terminate = TRUE;
                u_waitsetNotify(helper->userWaitset, NULL);
                os_threadWaitExit(helper->tid, NULL);
                ur = u_waitsetDetach(helper->userWaitset, u_entity(we->dispatcher));
                u_waitsetFree(helper->userWaitset);
                os_free(helper);
            }
            if(ur == U_RESULT_OK) {
                c_iterTake(waitset->entities, we);
                we->waitset = NULL;
                result = TRUE;
            }
        }
        d_lockUnlock(d_lock(waitset));
    }
    return result;
}
Ejemplo n.º 3
0
gapi_returnCode_t
_ConditionRemoveWaitset(
    _Condition   _this,
    gapi_waitSet waitset,
    u_waitset    uWaitset)
{
    gapi_returnCode_t result = GAPI_RETCODE_OK;
    u_result uResult;

    c_iterTake(_this->waitsets, waitset);
    if ((_this->uEntity != NULL) && (uWaitset != NULL)) {
        uResult = u_waitsetDetach(uWaitset, _this->uEntity);
        if (uResult != U_RESULT_OK) {
            result = GAPI_RETCODE_ERROR;
        }
    }
    return result;
}
Ejemplo n.º 4
0
static u_result
attachAndMonitor(
    const u_participant participant,
    const struct builtin_datareader_set *drset)
{
    u_waitset waitset;
    u_dataReader dataReader;
    c_iter readers;
    u_result result;
    c_long i, length;

    result = U_RESULT_INTERNAL_ERROR;
    readers = NULL;
    length = 0;
    /*Create waitset.*/
    waitset = u_waitsetNew(participant);

    if(waitset){
        /*Set event mask of the waitset.*/
        result = u_waitsetSetEventMask(waitset, V_EVENT_DATA_AVAILABLE | V_EVENT_NEW_GROUP | V_EVENT_SERVICESTATE_CHANGED);

        if(result == U_RESULT_OK){
            result = u_dispatcherSetEventMask(
                    (u_dispatcher)participant, V_EVENT_NEW_GROUP | V_EVENT_SERVICESTATE_CHANGED);

            if(result == U_RESULT_OK){
                v_serviceFillNewGroups(service);
                result = u_waitsetAttach(
                        waitset, (u_entity)participant,
                        (u_entity)participant);

                if(result != U_RESULT_OK){
                    in_printf(IN_LEVEL_SEVERE, "Could not attach datareader to waitset.\n");
                }
            } else {
                in_printf(IN_LEVEL_SEVERE, "Could not set event mask of participant.");
            }

            if(result == U_RESULT_OK){
                readers     = c_iterNew(drset->participant_dr);
                readers     = c_iterInsert(readers, drset->publication_dr);
                readers     = c_iterInsert(readers, drset->subscription_dr);

                result     = U_RESULT_OK;
                length     = c_iterLength(readers);

                for(i=0; i<length && (result == U_RESULT_OK); i++){
                    dataReader = (u_dataReader)(c_iterObject(readers, i));

                    /*Set event mask of the datareader to trigger on available data.*/
                    result = u_dispatcherSetEventMask(
                                (u_dispatcher)dataReader, V_EVENT_DATA_AVAILABLE);

                    if(result == U_RESULT_OK){
                        /*Attach reader to the waitset.*/
                        result = u_waitsetAttach(
                                waitset, (u_entity)dataReader, (u_entity)dataReader);

                        if(result != U_RESULT_OK){
                            in_printf(IN_LEVEL_SEVERE, "Could not attach datareader to waitset.\n");
                        }
                    } else {
                        in_printf(IN_LEVEL_SEVERE, "Could not set event mask of datareader.\n");
                    }
                }
            }
        } else {
            in_printf(IN_LEVEL_SEVERE, "Could not set event mask of waitset.\n");
        }


        if(result == U_RESULT_OK){
            /*Start monitoring the creation/deletion of entities.*/
            result = startMonitoring(participant, waitset, drset);
        }
        u_waitsetDetach(waitset, u_entity(participant));

        if(readers){
            /*Detach all datareaders from the waitset.*/
            for(i=0; i<length; i++){
                u_waitsetDetach(waitset, (u_entity)(c_iterObject(readers, i)));
            }
            c_iterFree(readers);
        }
        /*Delete the waitset.*/
        result = u_waitsetFree(waitset);

        if(result != U_RESULT_OK){
            in_printf(IN_LEVEL_SEVERE, "Deletion of waitset failed.\n");
        }
    } else {
        in_printf(IN_LEVEL_SEVERE, "Could not create waitset.\n");
    }

    return result;
}
Ejemplo n.º 5
0
c_bool
d_waitsetAttach(
    d_waitset waitset,
    d_waitsetEntity we)
{
    c_bool result = FALSE;
    u_result ur;
    os_result osr;
    d_waitsetHelper helper;
    c_ulong mask;
    d_admin admin;
    d_durability durability;

    assert(d_objectIsValid(d_object(waitset), D_WAITSET) == TRUE);
    assert(d_objectIsValid(d_object(we), D_WAITSET_ENTITY) == TRUE);

    if(waitset && we){
        d_lockLock(d_lock(waitset));

        if(!we->waitset) {
            if(c_iterContains(waitset->entities, we) == FALSE) {
                waitset->entities = c_iterInsert(waitset->entities, we);
                if(waitset->runToCompletion == TRUE){
                    ur = u_waitsetAttach(waitset->uwaitset, u_entity(we->dispatcher),
                             (c_voidp)we->dispatcher);

                    if(ur == U_RESULT_OK) {
                        we->waitset = waitset;
                        result = TRUE;
                    }
                } else {
                    admin = d_subscriberGetAdmin(waitset->subscriber);
                    durability = d_adminGetDurability(admin);

                    helper = os_malloc(C_SIZEOF(d_waitsetHelper));
                    helper->waitset     = waitset;
                    helper->entity      = we;
                    helper->terminate   = FALSE;
                    helper->tid         = OS_THREAD_ID_NONE;
                    helper->userWaitset = u_waitsetNew(u_participant(d_durabilityGetService(durability)));

                    mask = V_EVENT_DATA_AVAILABLE;
                    mask |= V_EVENT_NEW_GROUP;
                    mask |= V_EVENT_HISTORY_DELETE;
                    mask |= V_EVENT_HISTORY_REQUEST;
                    mask |= V_EVENT_PERSISTENT_SNAPSHOT;
                    mask |= V_EVENT_TRIGGER;
                    u_waitsetSetEventMask(helper->userWaitset, mask);
                    ur = u_waitsetAttach(helper->userWaitset, u_entity(we->dispatcher),
                             (c_voidp)we->dispatcher);

                    if(ur != U_RESULT_OK) {
                        assert(FALSE);
                    } else {
                        result = TRUE;
                    }
                    if(result){
                        waitset->threads  = c_iterInsert(waitset->threads, helper);

                        osr = os_threadCreate(&(helper->tid), we->name, &(we->attr),
                                    d_waitsetEventHandler, helper);

                        if(osr != os_resultSuccess){
                            c_iterTake(waitset->threads, helper);
                            u_waitsetDetach(helper->userWaitset, u_entity(we->dispatcher));
                            u_waitsetFree(helper->userWaitset);
                            os_free(helper);
                            result = FALSE;
                        }
                    } else {
                        u_waitsetFree(helper->userWaitset);
                        os_free(helper);
                    }

                }
            }
        }
        d_lockUnlock(d_lock(waitset));
    }
    return result;
}