181 lines
6.8 KiB
C
181 lines
6.8 KiB
C
/*
|
|
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The OpenAirInterface Software Alliance licenses this file to You under
|
|
* the OAI Public License, Version 1.0 (the "License"); you may not use this file
|
|
* except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.openairinterface.org/?page_id=698
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*-------------------------------------------------------------------------------
|
|
* For more information about the OpenAirInterface (OAI) Software Alliance:
|
|
* contact@openairinterface.org
|
|
*/
|
|
|
|
/*! \file flexran_agent_scheduler_dlsch_ue_remote.c
|
|
* \brief procedures related to remote scheduling in the DLSCH transport channel
|
|
* \author Xenofon Foukas
|
|
* \date 2016
|
|
* \email: x.foukas@sms.ed.ac.uk
|
|
* \version 0.1
|
|
* @ingroup _mac
|
|
|
|
*/
|
|
|
|
#include "flexran_agent_common_internal.h"
|
|
#include "flexran_agent_ran_api.h"
|
|
#include "flexran_agent_scheduler_dlsch_ue_remote.h"
|
|
|
|
#include "LAYER2/MAC/defs.h"
|
|
#include "LAYER2/MAC/extern.h"
|
|
|
|
struct DlMacConfigHead queue_head;
|
|
|
|
int queue_initialized = 0;
|
|
|
|
//uint32_t skip_subframe = 1;
|
|
//uint32_t period = 10;
|
|
//uint32_t sched [] = {1, 2, 3};
|
|
|
|
void flexran_schedule_ue_spec_remote(mid_t mod_id, uint32_t frame, uint32_t subframe,
|
|
int *mbsfn_flag, Protocol__FlexranMessage **dl_info) {
|
|
|
|
|
|
//if ((subframe == skip_subframe) && (frame % period == 0)) {
|
|
// LOG_I(MAC, "Will skip subframe %d %d\n", subframe, frame);
|
|
// for (int i = 0; i < 3; i++) {
|
|
// LOG_I(MAC, "%d\n", sched[i]);
|
|
// }
|
|
//}
|
|
|
|
/* if (frame == 500 && subframe == 1) { */
|
|
/* char policy[] = "rrc: \n - ul_scheduler: \n behavior : tester_function\n parameters:\n period: !!int 3\nmac: \n - dl_scheduler: \n parameters: \n period : !!int 40\n skip_subframe : !!int 3\n sched : [!!int 4, !!int 5, !!int 6]"; */
|
|
/* apply_reconfiguration_policy(mod_id, policy, strlen(policy)); */
|
|
/* } */
|
|
|
|
eNB_MAC_INST *eNB;
|
|
|
|
if (!queue_initialized) {
|
|
TAILQ_INIT(&queue_head);
|
|
queue_initialized = 1;
|
|
}
|
|
|
|
eNB = &eNB_mac_inst[mod_id];
|
|
|
|
dl_mac_config_element_t *dl_config_elem;
|
|
|
|
int diff;
|
|
LOG_D(MAC, "[TEST] Current frame and subframe %d, %d\n", frame, subframe);
|
|
// First we check to see if we have a scheduling decision for this sfn_sf already in our queue
|
|
while(queue_head.tqh_first != NULL) {
|
|
dl_config_elem = queue_head.tqh_first;
|
|
|
|
diff = get_sf_difference(mod_id, dl_config_elem->dl_info->dl_mac_config_msg->sfn_sf);
|
|
// Check if this decision is for now, for a later or a previous subframe
|
|
if ( diff == 0) { // Now
|
|
LOG_D(MAC, "Found a decision for this subframe in the queue. Let's use it!\n");
|
|
TAILQ_REMOVE(&queue_head, queue_head.tqh_first, configs);
|
|
*dl_info = dl_config_elem->dl_info;
|
|
free(dl_config_elem);
|
|
eNB->eNB_stats[mod_id].sched_decisions++;
|
|
return;
|
|
} else if (diff < 0) { //previous subframe , delete message and free memory
|
|
LOG_D(MAC, "Found a decision for a previous subframe in the queue. Let's get rid of it\n");
|
|
TAILQ_REMOVE(&queue_head, queue_head.tqh_first, configs);
|
|
flexran_agent_mac_destroy_dl_config(dl_config_elem->dl_info);
|
|
free(dl_config_elem);
|
|
eNB->eNB_stats[mod_id].sched_decisions++;
|
|
eNB->eNB_stats[mod_id].missed_deadlines++;
|
|
} else { // next subframe, nothing to do now
|
|
LOG_D(MAC, "Found a decision for a future subframe in the queue. Nothing to do now\n");
|
|
flexran_agent_mac_create_empty_dl_config(mod_id, dl_info);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//Done with the local cache. Now we need to check if something new arrived
|
|
flexran_agent_get_pending_dl_mac_config(mod_id, dl_info);
|
|
while (*dl_info != NULL) {
|
|
|
|
diff = get_sf_difference(mod_id, (*dl_info)->dl_mac_config_msg->sfn_sf);
|
|
if (diff == 0) { // Got a command for this sfn_sf
|
|
LOG_D(MAC, "Found a decision for this subframe pending. Let's use it\n");
|
|
eNB->eNB_stats[mod_id].sched_decisions++;
|
|
return;
|
|
} else if (diff < 0) {
|
|
LOG_D(MAC, "Found a decision for a previous subframe. Let's get rid of it\n");
|
|
flexran_agent_mac_destroy_dl_config(*dl_info);
|
|
*dl_info = NULL;
|
|
flexran_agent_get_pending_dl_mac_config(mod_id, dl_info);
|
|
eNB->eNB_stats[mod_id].sched_decisions++;
|
|
eNB->eNB_stats[mod_id].missed_deadlines++;
|
|
} else { // Intended for future subframe. Store it in local cache
|
|
LOG_D(MAC, "Found a decision for a future subframe in the queue. Let's store it in the cache\n");
|
|
dl_mac_config_element_t *e = malloc(sizeof(dl_mac_config_element_t));
|
|
e->dl_info = *dl_info;
|
|
TAILQ_INSERT_TAIL(&queue_head, e, configs);
|
|
flexran_agent_mac_create_empty_dl_config(mod_id, dl_info);
|
|
// No need to look for another. Messages arrive ordered
|
|
return;
|
|
}
|
|
}
|
|
|
|
// We found no pending command, so we will simply pass an empty one
|
|
flexran_agent_mac_create_empty_dl_config(mod_id, dl_info);
|
|
}
|
|
|
|
int get_sf_difference(mid_t mod_id, uint32_t sfn_sf) {
|
|
int diff_in_subframes;
|
|
|
|
uint16_t current_frame = flexran_get_current_system_frame_num(mod_id);
|
|
uint16_t current_subframe = flexran_get_current_subframe(mod_id);
|
|
uint32_t current_sfn_sf = flexran_get_sfn_sf(mod_id);
|
|
|
|
if (sfn_sf == current_sfn_sf) {
|
|
return 0;
|
|
}
|
|
|
|
uint16_t frame_mask = ((1<<12) - 1);
|
|
uint16_t frame = (sfn_sf & (frame_mask << 4)) >> 4;
|
|
|
|
uint16_t sf_mask = ((1<<4) - 1);
|
|
uint16_t subframe = (sfn_sf & sf_mask);
|
|
|
|
LOG_D(MAC, "[TEST] Target frame and subframe %d, %d\n", frame, subframe);
|
|
|
|
if (frame == current_frame) {
|
|
return subframe - current_subframe;
|
|
} else if (frame > current_frame) {
|
|
diff_in_subframes = ((frame*10)+subframe) - ((current_frame*10)+current_subframe);
|
|
|
|
// diff_in_subframes = 9 - current_subframe;
|
|
//diff_in_subframes += (subframe + 1);
|
|
//diff_in_subframes += (frame-2) * 10;
|
|
if (diff_in_subframes > SCHED_AHEAD_SUBFRAMES) {
|
|
return -1;
|
|
} else {
|
|
return 1;
|
|
}
|
|
} else { //frame < current_frame
|
|
//diff_in_subframes = 9 - current_subframe;
|
|
//diff_in_subframes += (subframe + 1);
|
|
//if (frame > 0) {
|
|
// diff_in_subframes += (frame - 1) * 10;
|
|
//}
|
|
//diff_in_subframes += (1023 - current_frame) * 10;
|
|
diff_in_subframes = 10240 - ((current_frame*10)+current_subframe) + ((frame*10)+subframe);
|
|
if (diff_in_subframes > SCHED_AHEAD_SUBFRAMES) {
|
|
return -1;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
}
|