/*
* Overloaded function to find parameter by it's ID
* @param iParamID - in, ID of the parameter to be found
* @return - true if parameter was found in internal container, false otherwise
*/
bool CConfigurationModule::IsParameterPresent(int iParamID)
{
try
{
std::string strParamName = GetParameterName(iParamID);
if (!strParamName.empty())
return IsParameterPresent(strParamName.c_str());
}
CATCH
return false;
}
void ProcessEvent(unsigned int me, simtime_t now, int event_type, event_content_type *event_content, unsigned int size, void *ptr) {
char *parameter, *value;
channel *c;
int w;
event_content_type new_event_content;
new_event_content.cell = -1;
new_event_content.channel = -1;
new_event_content.call_term_time = -1;
simtime_t handoff_time;
simtime_t timestamp = 0;
lp_state_type *state;
state = (lp_state_type*)ptr;
if(state != NULL) {
state->lvt = now;
state->executed_events++;
}
switch(event_type) {
case INIT:
// Initialize the LP's state
state = (lp_state_type *)malloc(sizeof(lp_state_type));
if (state == NULL) {
printf("Out of memory!\n");
exit(EXIT_FAILURE);
}
SetState(state);
bzero(state, sizeof(lp_state_type));
state->channel_counter = CHANNELS_PER_CELL;
// Read runtime parameters
if(IsParameterPresent(event_content, "pcs_statistics"))
pcs_statistics = true;
if(IsParameterPresent(event_content, "ta"))
state->ref_ta = state->ta = GetParameterDouble(event_content, "ta");
else
state->ref_ta = state->ta = TA;
if(IsParameterPresent(event_content, "ta_duration"))
state->ta_duration = GetParameterDouble(event_content, "ta_duration");
else
state->ta_duration = TA_DURATION;
if(IsParameterPresent(event_content, "ta_change"))
state->ta_change = GetParameterDouble(event_content, "ta_change");
else
state->ta_change = TA_CHANGE;
if(IsParameterPresent(event_content, "channels_per_cell"))
state->channels_per_cell = GetParameterInt(event_content, "channels_per_cell");
else
state->channels_per_cell = CHANNELS_PER_CELL;
if(IsParameterPresent(event_content, "complete_calls"))
complete_calls = GetParameterInt(event_content, "complete_calls");
state->fading_recheck = IsParameterPresent(event_content, "fading_recheck");
state->variable_ta = IsParameterPresent(event_content, "variable_ta");
// Show current configuration, only once
if(me == 0) {
printf("CURRENT CONFIGURATION:\ncomplete calls: %d\nTA: %f\nta_duration: %f\nta_change: %f\nchannels_per_cell: %d\nfading_recheck: %d\nvariable_ta: %d\n",
complete_calls, state->ta, state->ta_duration, state->ta_change, state->channels_per_cell, state->fading_recheck, state->variable_ta);
fflush(stdout);
}
state->channel_counter = state->channels_per_cell;
// Setup channel state
state->channel_state = malloc(sizeof(unsigned int) * 2 * (CHANNELS_PER_CELL / BITS + 1));
for (w = 0; w < state->channel_counter / (sizeof(int) * 8) + 1; w++)
state->channel_state[w] = 0;
// Start the simulation
timestamp = (simtime_t) (20 * Random());
ScheduleNewEvent(me, timestamp, START_CALL, NULL, 0);
// If needed, start the first fading recheck
// if (state->fading_recheck) {
timestamp = (simtime_t) (FADING_RECHECK_FREQUENCY * Random());
ScheduleNewEvent(me, timestamp, FADING_RECHECK, NULL, 0);
// }
break;
case START_CALL:
state->arriving_calls++;
if (state->channel_counter == 0) {
state->blocked_on_setup++;
} else {
state->channel_counter--;
new_event_content.channel = allocation(state);
new_event_content.from = me;
new_event_content.sent_at = now;
// Determine call duration
switch (DURATION_DISTRIBUTION) {
case UNIFORM:
new_event_content.call_term_time = now + (simtime_t)(state->ta_duration * Random());
break;
case EXPONENTIAL:
new_event_content.call_term_time = now + (simtime_t)(Expent(state->ta_duration));
break;
default:
new_event_content.call_term_time = now + (simtime_t) (5 * Random() );
}
// Determine whether the call will be handed-off or not
switch (CELL_CHANGE_DISTRIBUTION) {
case UNIFORM:
handoff_time = now + (simtime_t)((state->ta_change) * Random());
break;
case EXPONENTIAL:
handoff_time = now + (simtime_t)(Expent(state->ta_change));
break;
default:
handoff_time = now + (simtime_t)(5 * Random());
}
if(new_event_content.call_term_time <= handoff_time) {
ScheduleNewEvent(me, new_event_content.call_term_time, END_CALL, &new_event_content, sizeof(new_event_content));
} else {
new_event_content.cell = FindReceiver(TOPOLOGY_HEXAGON);
ScheduleNewEvent(me, handoff_time, HANDOFF_LEAVE, &new_event_content, sizeof(new_event_content));
}
}
if (state->variable_ta)
state->ta = recompute_ta(state->ref_ta, now);
// Determine the time at which a new call will be issued
switch (DISTRIBUTION) {
case UNIFORM:
timestamp= now + (simtime_t)(state->ta * Random());
break;
case EXPONENTIAL:
timestamp= now + (simtime_t)(Expent(state->ta));
break;
default:
timestamp= now + (simtime_t) (5 * Random());
}
ScheduleNewEvent(me, timestamp, START_CALL, NULL, 0);
break;
case END_CALL:
state->channel_counter++;
state->complete_calls++;
deallocation(me, state, event_content->channel, event_content, now);
break;
case HANDOFF_LEAVE:
state->channel_counter++;
state->leaving_handoffs++;
deallocation(me, state, event_content->channel, event_content, now);
new_event_content.call_term_time = event_content->call_term_time;
ScheduleNewEvent(event_content->cell, now, HANDOFF_RECV, &new_event_content, sizeof(new_event_content));
break;
case HANDOFF_RECV:
state->arriving_handoffs++;
state->arriving_calls++;
if (state->channel_counter == 0)
state->blocked_on_handoff++;
else {
state->channel_counter--;
new_event_content.channel = allocation(state);
new_event_content.call_term_time = event_content->call_term_time;
switch (CELL_CHANGE_DISTRIBUTION) {
case UNIFORM:
handoff_time = now + (simtime_t)((state->ta_change) * Random());
break;
case EXPONENTIAL:
handoff_time = now + (simtime_t)(Expent( state->ta_change ));
break;
default:
handoff_time = now+
(simtime_t) (5 * Random());
}
if(new_event_content.call_term_time < handoff_time ) {
ScheduleNewEvent(me, new_event_content.call_term_time, END_CALL, &new_event_content, sizeof(new_event_content));
} else {
new_event_content.cell = FindReceiver(TOPOLOGY_HEXAGON);
ScheduleNewEvent(me, handoff_time, HANDOFF_LEAVE, &new_event_content, sizeof(new_event_content));
}
}
break;
case FADING_RECHECK:
/*
if(state->check_fading)
state->check_fading = false;
else
state->check_fading = true;
*/
fading_recheck(state);
timestamp = now + (simtime_t) (FADING_RECHECK_FREQUENCY );
ScheduleNewEvent(me, timestamp, FADING_RECHECK, NULL, 0);
break;
default:
fprintf(stdout, "PCS: Unknown event type! (me = %d - event type = %d)\n", me, event_type);
abort();
}
}
