timemanagement.cc

certi-SHM-3.0.tar 不错的开源的分布式方针软件 大家多多支持 他是linux

            else {
                // Advance current time up to 'date_min'.
                timeAdvanceGrant(date_min, e);
                _avancee_en_cours = PAS_D_AVANCEE ;
            }
        }
        else { // date_min < _LBTS

            // Federate can't advance up to expected time but up to LBTS. Other
            // federates are informed and no TSO message are sent.
            if (_est_regulateur)
                sendNullMessage(_LBTS);
        }
    }

    else { // if federate isn't constrained.

        // In this case, federate can advance freely. Moreover, there must be no
        // message in TSO list.
        if (_est_regulateur)
            sendNullMessage(date_avancee);

        timeAdvanceGrant(date_avancee, e);

        _avancee_en_cours = PAS_D_AVANCEE ;
    }
}

// ----------------------------------------------------------------------------
void
TimeManagement::nextEventRequest(FederationTime heure_logique,
                                 TypeException &e)
{
    e = e_NO_EXCEPTION ;

    // Verifications

    if (_avancee_en_cours != PAS_D_AVANCEE)
        e = e_TimeAdvanceAlreadyInProgress ;

    if (heure_logique <= _heure_courante)
        e = e_FederationTimeAlreadyPassed ;


    if (e == e_NO_EXCEPTION) {
        _avancee_en_cours = NER ;
        date_avancee = heure_logique ;
        D.Out(pdTrace, "NextEventRequest accepted.");
    }
    else {
        D.Out(pdExcept, "NextEventRequest refused (exception = %d).", e);
    }
}

// ----------------------------------------------------------------------------
FederationTime
TimeManagement::requestFederationTime(void)
{
    if (_heure_courante < _LBTS)
        return _heure_courante ;
    else
        return _LBTS ;
}

// ----------------------------------------------------------------------------
FederationTimeDelta TimeManagement::requestLookahead(void)
{
    // BUG: C'est quoi cette salade ?

    if (_heure_courante + _lookahead_courant < lastNullMessageDate)
        return(lastNullMessageDate - _heure_courante);
    else
        return _lookahead_courant ;
}

// ----------------------------------------------------------------------------
void
TimeManagement::setLookahead(FederationTimeDelta lookahead, TypeException &e)
{
    e = e_NO_EXCEPTION ;

    // Verifications

    if (lookahead <= 0.0)
        e = e_InvalidFederationTimeDelta ;


    if (e == e_NO_EXCEPTION) {
        _lookahead_courant = lookahead ;

        // On previent les autres en leur envoyant un message nul qui contient
        // notre temps local + le Lookahead.
        if (_est_regulateur)
            sendNullMessage(_heure_courante);

        D.Out(pdRegister, "New Lookahead : %f.", _lookahead_courant);
    }
}

// ----------------------------------------------------------------------------
void TimeManagement::setTimeConstrained(Boolean etat, TypeException &e)
{
    NetworkMessage msg ;

    e = e_NO_EXCEPTION ;

    // Verifications

    if (_est_contraint == etat)
        e = e_RTIinternalError ;

    if (_avancee_en_cours != PAS_D_AVANCEE)
        e = e_RTIinternalError ;


    if (e == e_NO_EXCEPTION) {
        _est_contraint = etat ;

        msg.type = m_SET_TIME_CONSTRAINED ;
        msg.federation = fm->_numero_federation ;
        msg.federate = fm->federate ;
        msg.constrained = etat ;

        comm->sendMessage(&msg);

        D.Out(pdRegister,
              "Demande de modif de TimeConstrained envoyee(etat=%d, ", etat);
    }
    else {
        D.Out(pdExcept, "SetTimeConstrained refuse(exception = %d).", e);
    }
}

// ----------------------------------------------------------------------------
void TimeManagement::setTimeRegulating(Boolean etat, TypeException &e)
{
    NetworkMessage msg ;

    e = e_NO_EXCEPTION ;

    // Verifications

    if (_est_regulateur == etat) {
        e = e_RTIinternalError ;
        D.Out(pdRegister,
              "erreur e_RTIinternalError : federe deja regulateur");
    }

    if (_avancee_en_cours != PAS_D_AVANCEE) {
        e = e_RTIinternalError ;
        D.Out(pdRegister, "erreur e_RTIinternalError avancee_en_cours");
    }

    // Si il existe d'autres federes regulateurs plus avances
    // if ((etat == RTI_TRUE) &&
    //(lg > 0) &&
    //(_heure_courante +_lookahead_courant < _LBTS)) {
    // e = e_FederationTimeAlreadyPassed ;
    // D.Out(pdRegister, "erreur e_FederationTimeAlreadyPassed ");
    // }

    // Si aucune erreur, prevenir le RTIG et devenir regulateur.
    if (e == e_NO_EXCEPTION) {
        _est_regulateur = etat ;

        msg.type = m_SET_TIME_REGULATING ;
        msg.federation = fm->_numero_federation ;
        msg.federate = fm->federate ;
        msg.regulator = etat ;
        msg.date = _heure_courante + _lookahead_courant ;

        comm->sendMessage(&msg);

        D.Out(pdRegister,
              "Demande de modif de TimeRegulating emise(etat=%d).", etat);
    }
    else {
        D.Out(pdExcept, "SetTimeRegulating refuse(exception = %d).", e);
    }
}

// ----------------------------------------------------------------------------
/*! Federate calls either nextEventRequest or timeAdvanceRequest to determine
  which time to attain. It then calls tick() until a timeAdvanceGrant is
  made.
*/
Boolean TimeManagement::tick(TypeException &e)
{
    Boolean msg_donne = RTI_FALSE ;
    Boolean msg_restant = RTI_FALSE ;
    NetworkMessage *msg = NULL ;

    // Note: While msg_donne = RTI_FALSE, msg_restant doesn't matter.

    // 1st try, give a command message. (requestPause, etc.)
    msg = queues->giveCommandMessage(msg_donne, msg_restant);


    // 2nd try, give a FIFO message. (discoverObject, etc.)
    if (msg_donne == RTI_FALSE)
        msg = queues->giveFifoMessage(msg_donne, msg_restant);

    // If message exists, send it to federate.
    if (msg_donne == RTI_TRUE) {
        D.Out(pdDebug, "TickRequest being processed, Message to send.");
        try {
            executeFederateService(*msg);
        }
        catch (RTIinternalError &e) {
            cout << "RTIA:RTIinternalError thrown in tick (execute)." << endl ;
            throw e ;
        }
    }

    // No message: we try to send TSO messages.
    // Messages to be sent depends on asked advance type.
    else {
        D.Out(pdDebug, "TickRequest being processed, advance called.");
        try {
            advance(msg_restant, e);
        }
        catch (RTIinternalError &e) {
            cout << "RTIA:RTIinternalError thrown in tick (Advance)." << endl ;
            throw e ;
        }
    }

    delete msg ;

    return msg_restant ;
}

// ----------------------------------------------------------------------------
/*! timeAdvance is called by advance which is called by tick. This call is
  done only if request type does correspond. It delivers TSO messages to
  federate and if no messages are available, delivers a TimeAdvanceGrant.
*/
void
TimeManagement::timeAdvance(Boolean &msg_restant, TypeException &e)
{
    Boolean msg_donne ;
    FederationTime min ;
    NetworkMessage *msg ;

    msg_restant = RTI_FALSE ;

    if (_est_contraint) {
        // give a TSO message.
        D.Out(pdDebug, "Logical time : %f, LBTS : %f.", date_avancee, _LBTS);
        min = (_LBTS<date_avancee)?(_LBTS):(date_avancee);
        msg = queues->giveTsoMessage(min, msg_donne, msg_restant);

        // otherwise
        if (!msg_donne) {
            // if LBTS allows to give a timeAdvanceGrant.
            D.Out(pdDebug, "Logical time : %f, LBTS : %f, lookahead : %f.",
                  date_avancee, _LBTS, _lookahead_courant);
            if (date_avancee < _LBTS) {
                // send a timeAdvanceGrant to federate.
                timeAdvanceGrant(date_avancee, e);

                if (e != e_NO_EXCEPTION)
                    return ;

                _avancee_en_cours = PAS_D_AVANCEE ;
            }
            // otherwise nothing has to be sent to federate (empty tick).
        }
        else {
            executeFederateService(*msg);
            delete msg ;
        }
    }
    else {
        // if federate is not constrained, sent a timeAdvanceGrant to federate.
        timeAdvanceGrant(date_avancee, e);
        if (e != e_NO_EXCEPTION)
            return ;
        _avancee_en_cours = PAS_D_AVANCEE ;
    }
}

// ----------------------------------------------------------------------------
/*! Once every messages has been delivered to federate, logical time can be
  advanced and send a timeAdvanceGrant to federate.
*/
void
TimeManagement::timeAdvanceGrant(FederationTime heure_logique,
                                 TypeException &e)
{
    Message req, rep ;

    req.type = TIME_ADVANCE_GRANT ;
    req.date = heure_logique ;

    D.Out(pdRegister, "timeAdvanceGrant sent to federate (time = %f).",
          req.date);

    comm->requestFederateService(&req, &rep);

    e = rep.exception ;

    if (e == e_NO_EXCEPTION)
        _heure_courante = heure_logique ;
}

// ----------------------------------------------------------------------------
/*! Either nextEventRequest or timeAdvanceRequest is called by federate to
  to determine time to reach. It then calls tick() until a timeAdvanceGrant
  is received.
*/
void
TimeManagement::timeAdvanceRequest(FederationTime heure_logique,
                                   TypeException &e)
{
    e = e_NO_EXCEPTION ;

    // Verifications

    if (_avancee_en_cours != PAS_D_AVANCEE)
        e = e_TimeAdvanceAlreadyInProgress ;

    if (heure_logique <= _heure_courante)
        e = e_FederationTimeAlreadyPassed ;


    if (e == e_NO_EXCEPTION) {
        if (_est_regulateur)
            sendNullMessage(heure_logique);

        _avancee_en_cours = TAR ;
        date_avancee = heure_logique ;

        D.Out(pdTrace, "timeAdvanceRequest accepted (asked time=%f).",
              date_avancee);
    }
    else {
        D.Out(pdExcept, "timeAdvanceRequest refused (exception = %d).", e);
    }
}

}} // namespaces

// $Id: TimeManagement.cc,v 3.6 2003/03/21 15:06:46 breholee Exp $