maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove legacy 4G RLC

Browse Source
This commit is contained in:
Robert Schmidt
2023-01-21 12:14:18 +01:00
parent 5d58645a85
commit 8fc58e2f00
99 changed files with 93 additions and 20982 deletions
Download Patch File Download Diff File Expand all files Collapse all files
openair2/UTIL/LISTS/list.c
-446
View File
@@ -1,446 +0,0 @@
/*
* 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.1 (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 list.c
* \brief list management primimtives. It includes three implementations: (1) with mem_blocks, (2) standard list implementation (mem usage 314MB) (3) Linux Queue-based implementation (mem usage 394 MB)
* \author Navid Nikaein, Mohamed Said MOSLI BOUKSIAA, Lionel GAUTHIER
* \date 2012 - 2014
* \version 0.5
* @ingroup util
*/
#define LIST_C
#define NULL 0
#include "list.h"
#include <string.h>
//-----------------------------------------------------------------------------
/*
* initialize list
*/
//-----------------------------------------------------------------------------
void
list_init (list_t * listP, char *nameP)
{
//-----------------------------------------------------------------------------
if (nameP) {
strncpy( listP->name, nameP, LIST_NAME_MAX_CHAR-1 );
listP->name[LIST_NAME_MAX_CHAR-1] = 0; // terminate string
}
listP->tail = NULL;
listP->head = NULL;
listP->nb_elements = 0;
}
//-----------------------------------------------------------------------------
void
list_free (list_t * listP)
{
//-----------------------------------------------------------------------------
mem_block_t *le;
while ((le = list_remove_head (listP))) {
free_mem_block (le, __func__);
}
}
//-----------------------------------------------------------------------------
mem_block_t *
list_get_head (list_t * listP)
{
//-----------------------------------------------------------------------------
return listP->head;
}
//-----------------------------------------------------------------------------
/*
* remove an element from head of a list
* @param pointer on targeted list
* @return pointer on removed mem_block_t
*/
mem_block_t *
list_remove_head (list_t * listP)
{
//-----------------------------------------------------------------------------
// access optimisation
mem_block_t *head;
head = listP->head;
// almost one element
if (head != NULL) {
listP->head = head->next;
listP->nb_elements = listP->nb_elements - 1;
// if only one element, update tail
if (listP->head == NULL) {
listP->tail = NULL;
} else {
head->next = NULL;
}
} else {
//msg("[MEM_MGT][WARNING] remove_head_from_list(%s) no elements\n",listP->name);
}
return head;
}
//-----------------------------------------------------------------------------
mem_block_t *
list_remove_element (mem_block_t * elementP, list_t * listP)
{
//-----------------------------------------------------------------------------
// access optimisation;
mem_block_t *head;
if (elementP != NULL) {
// test head
head = listP->head;
if (listP->head == elementP) {
// almost one element
if (head != NULL) {
listP->head = head->next;
listP->nb_elements = listP->nb_elements - 1;
// if only one element, update tail
if (listP->head == NULL) {
listP->tail = NULL;
} else {
head->next = NULL;
}
}
} else {
while (head) {
if (head->next == elementP) {
head->next = elementP->next;
listP->nb_elements = listP->nb_elements - 1;
if (listP->tail == elementP) {
listP->tail = head;
}
return elementP;
} else {
head = head->next;
}
}
}
}
return elementP;
}
//-----------------------------------------------------------------------------
/*
* add an element to the beginning of a list
* @param pointer on targeted list
* @return pointer on removed mem_block_t
*/
void
list_add_head (mem_block_t * elementP, list_t * listP)
{
//-----------------------------------------------------------------------------
// access optimisation;
mem_block_t *head;
if (elementP != NULL) {
head = listP->head;
listP->nb_elements = listP->nb_elements + 1;
// almost one element
if (head == NULL) {
listP->head = elementP;
listP->tail = elementP;
} else {
elementP->next = head;
listP->head = elementP;
}
}
}
//-----------------------------------------------------------------------------
/*
* add an element to the end of a list
* @param pointer on targeted list
* @return pointer on removed mem_block_t
*/
void
list_add_tail_eurecom (mem_block_t * elementP, list_t * listP)
{
mem_block_t *tail;
//-----------------------------------------------------------------------------
if (elementP != NULL) {
// access optimisation
listP->nb_elements = listP->nb_elements + 1;
elementP->next = NULL;
tail = listP->tail;
// almost one element
if (tail == NULL) {
listP->head = elementP;
} else {
tail->next = elementP;
}
listP->tail = elementP;
} else {
//msg("[CNT_LIST][ERROR] add_cnt_tail() element NULL\n");
}
}
//-----------------------------------------------------------------------------
void
list_add_list (list_t * sublistP, list_t * listP)
{
//-----------------------------------------------------------------------------
if (sublistP) {
if (sublistP->head) {
// access optimisation
mem_block_t *tail;
tail = listP->tail;
// almost one element
if (tail == NULL) {
listP->head = sublistP->head;
} else {
tail->next = sublistP->head;
}
listP->tail = sublistP->tail;
// clear sublist
sublistP->head = NULL;
sublistP->tail = NULL;
listP->nb_elements = listP->nb_elements + sublistP->nb_elements;
sublistP->nb_elements = 0;
}
}
}
//-----------------------------------------------------------------------------
void
list_display (list_t * listP)
{
//-----------------------------------------------------------------------------
mem_block_t *cursor;
// unsigned short nb_elements = 0;
// test lists
if (listP) {
cursor = listP->head;
if (cursor) {
// almost one element
//msg ("Display list %s %p", listP->name, listP);
// while (cursor != NULL) {
// msg ("%d:", cursor->pool_id);
// msg ("\n");
// cursor = cursor->next;
// nb_elements++;
//}
// msg (" found nb_elements %d nb_elements %d\n", nb_elements, listP->nb_elements);
}
} else {
//msg ("[SDU_MNGT][WARNING] display_cnt_list() : list is NULL\n");
}
}
#ifndef LINUX_LIST
/*! \fn void push_front(struct list* z, double val)
* \brief this function pushes front new values in a predefined list.
* \param z is the predefined list
* val is the new value to be pushed inside the list
* \return
*/
void
push_front(struct list* z, double val)
{
struct node* p = (struct node*) malloc(sizeof(struct node));
p->next = z->head;
p->val = val;
z->head = p;
z->size++;
return;
}
/*! \fn void initialize(struct list* z)
* \brief initialize a list structure.
* \param z is the list
* \return
*/
void
initialize(struct list* z)
{
z->head = NULL;
z->size = 0;
return;
}
/*! \fn void del(struct list* z)
* \brief delete a list structure.
* \param z is the list
* \return
*/
void
del(struct list* z)
{
struct node* cur;
struct node* x = z->head;
while((x != NULL) && (z->size > 0)) {
cur = x;
x = x->next;
free(cur);
z->size--;
}
z->head = NULL;
z->size = 0;
return;
}
/*! \fn void totable(double* table, struct list* v)
* \brief convert a list structure to a table.
* \param table is a pointer to double table
* v is the list to be converted
* \return
*/
void
totable(double* table, struct list* v)
{
int i = 0;
struct node* x = v->head;
while(x) {
table[i] = x->val;
i++;
x = x->next;
}
return;
}
/*! \fn int compare (const void * a, const void * b)
* \brief compare the value of two parameters
* \param a is a double, b is another double
* \return 1 if a>b, -0 if a<b
*/
int compare (const void * a, const void * b)
{
double x = *(double*)a;
double y = *(double*)b;
return ( x > y );
}
#else
// push an element to the head of the list
void push_front(struct list* z, double val)
{
struct entry* p = (struct entry*) malloc(sizeof(struct entry));
p->val = val;
LIST_INSERT_HEAD(&z->head, p, entries);
z->size++;
return;
}
// initialization
void initialize(struct list* z)
{
LIST_INIT(&z->head);
z->size = 0;
return;
}
// delete
void del(struct list* z)
{
while (z->head.lh_first != NULL) {
free(z->head.lh_first);
LIST_REMOVE(z->head.lh_first, entries);
}
z->size = 0;
return;
}
// convert the list to a table
void totable(double* table, struct list* v)
{
int i = 0;
struct entry* x;
for (x = v->head.lh_first; x != NULL; x = x->entries.le_next) {
table[i] = x->val;
i++;
}
return;
}
int compare (const void * a, const void * b)
{
double x = *(double*)a;
double y = *(double*)b;
return ( x > y );
}
#endif
/*! \fn int32_t calculate_median(struct list *loc_list)
* \brief calculate the median of a list
* \param loc_list is the list
* \return the median value
*/
int32_t calculate_median(struct list *loc_list)
{
int32_t median = 0;
if (loc_list->size > 0) {
double* table = (double*) malloc(loc_list->size * sizeof(double));
totable(table, loc_list);
/// sort the table in ascending way
qsort (table, loc_list->size, sizeof(double), &compare);
/// median is the value at middle the sorted table
/// Q1 is the value at 1/4 the sorted table
/// Q3 is the value at 3/4 the sorted table
median = table[loc_list->size/2];
free(table);
}
return median;
}
openair2/UTIL/LISTS/list.h
-146
View File
@@ -1,146 +0,0 @@
/*
* 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.1 (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 pad_list.c
* \brief list management primimtives
* \author Mohamed Said MOSLI BOUKSIAA, Lionel GAUTHIER, Navid Nikaein
* \date 2012 - 2014
* \version 0.5
* @ingroup util
*/
/*
list.h
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
***************************************************************************/
#ifndef __LIST_H__
# define __LIST_H__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#include<linux/types.h>
#include<stdlib.h>
#include<sys/queue.h>
#include <string.h>
#include "UTIL/MEM/mem_block.h"
#include <common/utils/assertions.h>
//-----------------------------------------------------------------------------
void list_init (list_t* , char *);
void list_free (list_t* listP);
mem_block_t* list_get_head (list_t*);
mem_block_t* list_remove_head (list_t* );
mem_block_t* list_remove_element (mem_block_t*, list_t*);
void list_add_head (mem_block_t* , list_t* );
void list_add_tail_eurecom (mem_block_t* , list_t* );
void list_add_list (list_t* , list_t* );
void list_display (list_t* );
//-----------------------------------------------------------------------------
void list2_init (list2_t*, char*);
void list2_free (list2_t* );
mem_block_t* list2_get_head (list2_t*);
mem_block_t* list2_get_tail (list2_t*);
mem_block_t* list2_remove_element (mem_block_t* , list2_t* );
mem_block_t* list2_remove_head (list2_t* );
mem_block_t* list2_remove_tail (list2_t* );
void list2_add_head (mem_block_t* , list2_t* );
void list2_add_tail (mem_block_t* , list2_t* );
void list2_add_list (list2_t* , list2_t* );
void list2_display (list2_t* );
//-----------------------------------------------------------------------------
/* The following lists are used for sorting numbers */
#ifndef LINUX_LIST
/*! \brief the node structure */
struct node {
struct node* next; /*!< \brief is a node pointer */
double val; /*!< \brief is a the value of a node pointer*/
};
//-----------------------------------------------------------------------------
/*! \brief the list structure */
struct list {
struct node* head; /*!< \brief is a node pointer */
ssize_t size; /*!< \brief is the list size*/
};
#else
//-----------------------------------------------------------------------------
struct entry {
double val;
LIST_ENTRY(entry) entries;
};
//-----------------------------------------------------------------------------
struct list {
LIST_HEAD(listhead, entry) head;
ssize_t size;
};
#endif
//-----------------------------------------------------------------------------
void push_front (struct list*, double);
void initialize (struct list*);
void del (struct list*);
void totable (double*, struct list*);
int compare (const void * a, const void * b);
int32_t calculate_median(struct list *loc_list);
typedef struct {
size_t size;
size_t mallocedSize;
size_t atomSize;
size_t increment;
} varArray_t;
static inline varArray_t * initVarArray(size_t increment, size_t atomSize) {
varArray_t * tmp=(varArray_t *)malloc(sizeof(varArray_t)+increment*atomSize);
tmp->size=0;
tmp->atomSize=atomSize;
tmp->mallocedSize=increment;
tmp->increment=increment;
return(tmp);
}
static inline void * dataArray(varArray_t * input) {
return input+1;
}
static inline void appendVarArray(varArray_t ** inputPtr, void* data) {
varArray_t *input=*inputPtr;
if (input->size>=input->mallocedSize) {
input->mallocedSize+=input->increment;
*inputPtr=(varArray_t *)realloc(input,sizeof(varArray_t)+input->mallocedSize*input->atomSize);
AssertFatal(*inputPtr, "no memory left");
input=*inputPtr;
}
memcpy((uint8_t*)(input+1)+input->atomSize*input->size++, data, input->atomSize);
}
static inline void freeVarArray(varArray_t * input) {
free(input);
}
#endif
openair2/UTIL/LISTS/list2.c
-338
View File
@@ -1,338 +0,0 @@
/*
* 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.1 (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 pad_list.c
* \brief list management primimtives
* \author Mohamed Said MOSLI BOUKSIAA, Lionel GAUTHIER, Navid Nikaein
* \date 2012 - 2014
* \version 0.5
* @ingroup util
*/
/***************************************************************************
list2.c - description
-------------------
-------------------
AUTHOR : Lionel GAUTHIER
COMPANY : EURECOM
EMAIL : Lionel.Gauthier@eurecom.fr
***************************************************************************/
#define LIST2_C
#include "list.h"
#include "assertions.h"
#include <string.h>
//-----------------------------------------------------------------------------
/*
* initialize list
*/
//-----------------------------------------------------------------------------
void
list2_init (list2_t * listP, char *nameP)
{
//-----------------------------------------------------------------------------
if (nameP) {
strncpy( listP->name, nameP, LIST_NAME_MAX_CHAR-1 );
listP->name[LIST_NAME_MAX_CHAR-1] = 0; // terminate string
}
listP->tail = NULL;
listP->head = NULL;
listP->nb_elements = 0;
}
//-----------------------------------------------------------------------------
void
list2_free (list2_t * listP)
{
//-----------------------------------------------------------------------------
mem_block_t *le;
while ((le = list2_remove_head (listP))) {
free_mem_block (le, __func__);
}
}
//-----------------------------------------------------------------------------
/*
* remove an element from list
* @param pointer on targeted list
* @param mem_block_t to remove
* @return pointer on removed mem_block_t
*/
mem_block_t *
list2_remove_element (mem_block_t * elementP, list2_t * listP)
{
//-----------------------------------------------------------------------------
if (elementP != NULL) {
// head of list
if (elementP == listP->head) {
listP->head = elementP->next;
if (listP->head == NULL) {
listP->tail = NULL;
} else {
elementP->next->previous = NULL;
elementP->next = NULL;
}
// tail of the list
// note : case of 1 remaining element in the list has been treated above
} else if (elementP == listP->tail) {
// so several elements in the list
listP->tail = elementP->previous;
listP->tail->next = NULL;
elementP->previous = NULL;
// in the middle of the list, after a head element and before the tail element
} else {
// link element n-1 with element n+1
elementP->previous->next = elementP->next;
elementP->next->previous = elementP->previous;
elementP->next = NULL;
elementP->previous = NULL;
}
listP->nb_elements = listP->nb_elements - 1;
}
return elementP;
}
//-----------------------------------------------------------------------------
mem_block_t *
list2_get_head (list2_t * listP)
{
//-----------------------------------------------------------------------------
return listP->head;
}
//-----------------------------------------------------------------------------
mem_block_t *
list2_get_tail (list2_t * listP)
{
//-----------------------------------------------------------------------------
return listP->tail;
}
//-----------------------------------------------------------------------------
/*
* remove an element from head of a list
* @param pointer on targeted list
* @return pointer on removed mem_block_t
*/
mem_block_t *
list2_remove_head (list2_t * listP)
{
//-----------------------------------------------------------------------------
// access optimisation
mem_block_t *head;
head = listP->head;
// almost one element
if (head != NULL) {
listP->head = head->next;
listP->nb_elements = listP->nb_elements - 1;
// if only one element, update tail
if (listP->head == NULL) {
listP->tail = NULL;
} else {
listP->head->previous = NULL;
head->next = NULL;
}
} else {
//msg("[MEM_MGT][WARNING] remove_head_from_list(%s) no elements\n",listP->name);
}
return head;
}
//-----------------------------------------------------------------------------
/*
* remove an element from tail of a list
* @param pointer on targeted list
* @return pointer on removed mem_block_t
*/
mem_block_t *
list2_remove_tail (list2_t * listP)
{
//-----------------------------------------------------------------------------
// access optimisation;
mem_block_t *tail;
tail = listP->tail;
// almost one element;
if (tail != NULL) {
listP->nb_elements = listP->nb_elements - 1;
// if only one element, update head, tail;
if (listP->head == tail) {
listP->head = NULL;
listP->tail = NULL;
} else {
listP->tail = tail->previous;
tail->previous->next = NULL;
}
tail->previous = NULL;
} else {
//msg("[MEM_MGT][WARNING] remove_head_from_list(%s) no elements\n",listP->name);
}
return tail;
}
//-----------------------------------------------------------------------------
/*
* add an element to the beginning of a list
* @param pointer on targeted list
* @return pointer on removed mem_block_t
*/
void
list2_add_head (mem_block_t * elementP, list2_t * listP)
{
//-----------------------------------------------------------------------------
// access optimisation;
mem_block_t *head;
if (elementP != NULL) {
head = listP->head;
listP->nb_elements = listP->nb_elements + 1;
// almost one element
if (head == NULL) {
elementP->previous = NULL;
elementP->next = NULL;
listP->head = elementP;
listP->tail = elementP;
} else {
elementP->next = head;
head->previous = elementP;
elementP->previous = NULL;
listP->head = elementP;
}
}
}
//-----------------------------------------------------------------------------
/*
* add an element to the end of a list
* @param pointer on targeted list
* @return pointer on removed mem_block_t
*/
void
list2_add_tail (mem_block_t * elementP, list2_t * listP)
{
mem_block_t *tail;
//-----------------------------------------------------------------------------
if (elementP != NULL) {
// access optimisation
listP->nb_elements = listP->nb_elements + 1;
elementP->next = NULL;
tail = listP->tail;
// almost one element
if (tail == NULL) {
elementP->previous = NULL;
listP->head = elementP;
} else {
tail->next = elementP;
elementP->previous = tail;
}
listP->tail = elementP;
}
}
//-----------------------------------------------------------------------------
void
list2_add_list (list2_t * sublistP, list2_t * listP)
{
//-----------------------------------------------------------------------------
if (sublistP) {
if (sublistP->head) {
// access optimisation
mem_block_t *tail;
tail = listP->tail;
// almost one element
if (tail == NULL) {
listP->head = sublistP->head;
} else {
tail->next = sublistP->head;
sublistP->head->previous = tail;
}
listP->tail = sublistP->tail;
// clear sublist
sublistP->head = NULL;
sublistP->tail = NULL;
}
listP->nb_elements = listP->nb_elements + sublistP->nb_elements;
}
}
//-----------------------------------------------------------------------------
void
list2_display (list2_t * listP)
{
//-----------------------------------------------------------------------------
/*
mem_block_t *cursor;
unsigned short nb_elements = 0;
//uint32_t nb_bytes;
// uint32_t index;
// test lists
if (listP) {
cursor = listP->head;
if (cursor) {
// almost one element
msg ("Display list %s %p", listP->name, listP);
while (cursor != NULL) {
msg ("%d:", cursor->pool_id);
//nb_bytes = (( sdu_management*)(cursor->misc))->size;
// for (index=0; index < nb_bytes; index++) {
// msg("%02X.",cursor->data[index]);
// }
msg ("\n");
cursor = cursor->next;
nb_elements++;
}
msg (" found nb_elements %d nb_elements %d\n", nb_elements, listP->nb_elements);
AssertFatal(nb_elements == listP->nb_elements, "Bad count of elements %d != %d", nb_elements, listP->nb_elements);
}
}*/
}