Method run

src/call_generation_task.cpp:92–196

}

bool CallGenerationTask::run()
{
    int calls_to_open = 0;

    if (quitting) {
        delete this;
        return false;
    }

    if (paused) {
        setPaused();
        return true;
    }

    unsigned long long current_calls = main_scenario->stats->GetStat(CStat::CPT_C_CurrentCall);
    unsigned long long total_calls = main_scenario->stats->GetStat(CStat::CPT_C_IncomingCallCreated) + main_scenario->stats->GetStat(CStat::CPT_C_OutgoingCallCreated);

    if (users >= 0) {
        calls_to_open = users - current_calls;
    } else {
        float calls_per_ms = rate/rate_period_ms;
        unsigned int ms_since_last_rate_change = clock_tick - last_rate_change_time;
        unsigned int expected_total_calls = ms_since_last_rate_change * calls_per_ms;
        calls_to_open = expected_total_calls - calls_since_last_rate_change;
    }

    if (total_calls + calls_to_open > stop_after) {
        calls_to_open = stop_after - total_calls;
    }

    /* We base our scheduling on the number of calls made since the last rate
     * change, but if we reduce the number of calls we open in order to keep
     * within the limit, that throws this calculation off and brings CPU% up to
     * 100%. To avoid this, we increment calls_since_last_rate_change here. */

    calls_since_last_rate_change += calls_to_open;

    if (open_calls_allowed && (current_calls + calls_to_open > open_calls_allowed)) {
        calls_to_open = open_calls_allowed - current_calls;
    }

    if (calls_to_open <= 0) {
        calls_to_open = 0;
    }

    unsigned int start_clock = getmilliseconds();


    while(calls_to_open--) {
        /* Associate a user with this call, if we are in users mode. */
        int userid = 0;
        if (users >= 0) {
            userid = freeUsers.back();
            freeUsers.pop_back();
        }

        // Adding a new outgoing call
        main_scenario->stats->computeStat(CStat::E_CREATE_OUTGOING_CALL);