events.c

模擬無線通訊論文的模擬程式, 可用此程式驗證論文方法是否正確

/* include */
#include "events.h"
#include <list>

/* namespace */
using namespace std;

/****************************************************** 
 * global variables 
 ******************************************************/
/* event list (container) */
static list<event_t> event_list[MAX_BS];
static double bss_first_time[MAX_BS];
static event_t nearest_event;
/******************************************************/

/* clean nearest event */
static void clean_nearest_event()
{
    /* clean */
    memset(&nearest_event, 0, sizeof(event_t));
    
    nearest_event.bs_location = 255; /* 255 means nearest event is not set */
}

/* initial bss */
void initialize_event_list(u8 bs_size)
{
/* loop counter */
int i;

    for(i=0; i<bs_size; ++i){
        event_list[i].clear();
        bss_first_time[i] = 0.0f;
    }
    clean_nearest_event();     
}

/* update nearest event */
static void update_nearest_event(event_t *new_event, u8 bs_size)
{
/* loop counter */     
int i;
/* nearest bs location */
u8 nearest_bs_location = 255;
/* nearest timestamp */
double nearest_timestamp = 999999999;
    
    if(new_event){
        if(nearest_event.bs_location == 255){
            /* directly add */
            memcpy(&nearest_event, new_event, sizeof(event_t));
        }else{
            /* compare */      
            if(new_event->timestamp < nearest_event.timestamp){
                memcpy(&nearest_event, new_event, sizeof(event_t));
            }
        }
    }else{
        for(i=0; i<bs_size; ++i){
            if(event_list[i].size() > 0){
                /* compare */
                if((event_list[i].front()).timestamp < nearest_timestamp){
                    /* update */                           
                    nearest_timestamp = (event_list[i].begin())->timestamp;
                    nearest_bs_location = i;
                }
            }
        }
     
        /* check index */
        if(nearest_bs_location == 255){
            clean_nearest_event();
        }else{
            memcpy(&nearest_event, &event_list[nearest_bs_location].front(), sizeof(event_t));
        }
    }
}

/* get bs arrival clock */
double get_bs_arrival_clock(u8 bs_index)
{
    return bss_first_time[bs_index];        
}

/* get nearest event */
u8 get_nearest_event(event_t *get_event, u8 bs_size)
{
    if(nearest_event.bs_location == 255){ /* check */
        return 1;  /* no event */
    }else{
        memcpy(get_event, &nearest_event, sizeof(event_t));
        event_list[nearest_event.bs_location].pop_front();
        update_nearest_event(NULL, bs_size);
        return 0;
    }
}

/* get size from list */
int get_event_list_size(u8 bs_index)
{
    return event_list[bs_index].size();    
}

/* events add */
void events_add(event_t *ins_event)
{
/* iterator */
list<event_t>::iterator pos;
/* flag */
bool flag = false;

    /* add to first */
    if(event_list[ins_event->bs_location].size() == 0){
        /* directly add */                     
        event_list[ins_event->bs_location].push_back(*ins_event);
    }else{
        /* check head, if add to head */
        if((event_list[ins_event->bs_location].begin())->timestamp > ins_event->timestamp){
            event_list[ins_event->bs_location].push_front(*ins_event);
            flag = true;   
        }else{
            /* search the smallest */
            for(pos = event_list[ins_event->bs_location].begin(); 
                pos != event_list[ins_event->bs_location].end(); ++pos){
                /* insert to before */
                if(pos->timestamp > ins_event->timestamp){
                    /* add to front */
                    event_list[ins_event->bs_location].insert(--pos, *ins_event);      
                    flag = true;
                    break; /* insert ok */
                }
            }
           
            /* add last */
            if(!flag) event_list[ins_event->bs_location].push_back(*ins_event);
        }
    }
    
    /* update new event */
    update_nearest_event(ins_event, 0);
}

/* get first event */
void get_event(event_t *get_event, u8 bs_index)
{
    if(event_list[bs_index].size() == 0) return;
    /* get event */
    memcpy(get_event, &event_list[bs_index].front(), sizeof(event_t));
    /* remove it */
    event_list[bs_index].pop_front();
}

/* print event list */
void print_event_list(u8 bs_index)
{
/* iterator */
list<event_t>::iterator pos;

    if(event_list[bs_index].size() == 0) return;
    
    printf("bs %d, ", bs_index);
    for(pos = event_list[bs_index].begin(); 
        pos != event_list[bs_index].end(); ++pos){
        printf("%s(%f, %d)[%d,%d,%d,%d,%d,%d,%d], ", 
               pos->type ? "departure" : "arrival", pos->timestamp, pos->data_rate,
               pos->code_word[0], pos->code_word[1], pos->code_word[2],
               pos->code_word[3], pos->code_word[4], pos->code_word[5],
               pos->code_word[6]);
    } 
    printf("\n");    
}


/* free all list */
void free_event_list(u8 bs_index)
{
    event_list[bs_index].clear();     
}