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

merge-develop-and-conflicts

Browse Source
This commit is contained in:
laurent
2022-09-20 14:03:25 +02:00
parent cfeae9560e af04fa90c1
commit 23f49bd013
319 changed files with 9920 additions and 6417 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/utils/LOG/log.c
+4
View File
@@ -48,6 +48,10 @@
// main log variables
// Fixme: a better place to be shure it is called
void read_cpu_hardware (void) __attribute__ ((constructor));
void read_cpu_hardware (void) {__builtin_cpu_init(); }
log_mem_cnt_t log_mem_d[2];
int log_mem_flag=0;
int log_mem_multi=1;
common/utils/LOG/log.h
+1
View File
@@ -366,6 +366,7 @@ typedef struct {
#define MATLAB_CSHORT_BRACKET3 15
int32_t write_file_matlab(const char *fname, const char *vname, void *data, int length, int dec, unsigned int format, int multiVec);
#define write_output(a, b, c, d, e, f) write_file_matlab(a, b, c, d, e, f, 0)
/*----------------macro definitions for reading log configuration from the config module */
#define CONFIG_STRING_LOG_PREFIX "log_config"
common/utils/T/tracer/packet-mac-lte.h
-2
View File
@@ -17,8 +17,6 @@
#ifndef __COMMON_UTILS_T_TRACER_PACKET_MAC_LTE__H__
#define __COMMON_UTILS_T_TRACER_PACKET_MAC_LTE__H__
//#include "ws_symbol_export.h"
/* radioType */
#define FDD_RADIO 1
#define TDD_RADIO 2
common/utils/nr/nr_common.c
+1
View File
@@ -724,3 +724,4 @@ void SLIV2SL(int SLIV,int *S,int *L) {
*S=13-SLIVmod14;
}
}
common/utils/nr/nr_common.h
+1 -2
View File
@@ -56,10 +56,9 @@ typedef enum frequency_range_e {
} frequency_range_t;
extern const nr_bandentry_t nr_bandtable[];
static inline int get_num_dmrs(uint16_t dmrs_mask ) {
int num_dmrs=0;
for (int i=0;i<16;i++) num_dmrs+=((dmrs_mask>>i)&1);
return(num_dmrs);
}
common/utils/ocp_itti/intertask_interface.cpp
+25 -29
View File
@@ -45,9 +45,7 @@ extern "C" {
std::vector<MessageDef *> message_queue;
std::map<long,timer_elm_t> timer_map;
uint64_t next_timer=UINT64_MAX;
struct epoll_event *events =NULL;
int nb_fd_epoll=0;
int nb_events=0;
int epoll_fd=-1;
int sem_fd=-1;
} task_list_t;
@@ -167,14 +165,14 @@ extern "C" {
struct epoll_event event;
task_list_t *t=tasks[task_id];
t->nb_fd_epoll++;
t->events = (struct epoll_event *)realloc((void *)t->events,
t->nb_fd_epoll * sizeof(struct epoll_event));
event.events = EPOLLIN | EPOLLERR;
event.data.u64 = 0;
event.data.fd = fd;
AssertFatal(epoll_ctl(t->epoll_fd, EPOLL_CTL_ADD, fd, &event) == 0,
"epoll_ctl (EPOLL_CTL_ADD) failed for task %s, fd %d: %s!\n",
itti_get_task_name(task_id), fd, strerror(errno));
eventfd_t sem_counter = 1;
AssertFatal ( sizeof(sem_counter) == write(t->sem_fd, &sem_counter, sizeof(sem_counter)), "");
}
void itti_unsubscribe_event_fd(task_id_t task_id, int fd) {
@@ -185,10 +183,10 @@ extern "C" {
t->nb_fd_epoll--;
}
static inline int itti_get_events_locked(task_id_t task_id, struct epoll_event **events) {
static inline int itti_get_events_locked(task_id_t task_id, struct epoll_event *events, int max_events) {
task_list_t *t=tasks[task_id];
uint64_t current_time=0;
int nb_events;
do {
if ( t->next_timer != UINT64_MAX ) {
struct timespec tp;
@@ -234,40 +232,41 @@ extern "C" {
pthread_mutex_unlock(&t->queue_cond_lock);
LOG_D(ITTI,"enter blocking wait for %s, timeout: %d ms\n", itti_get_task_name(task_id), epoll_timeout);
t->nb_events = epoll_wait(t->epoll_fd,t->events,t->nb_fd_epoll, epoll_timeout);
nb_events = epoll_wait(t->epoll_fd, events, max_events, epoll_timeout);
if ( t->nb_events < 0 && (errno == EINTR || errno == EAGAIN ) )
if ( nb_events < 0 && (errno == EINTR || errno == EAGAIN ) )
pthread_mutex_lock(&t->queue_cond_lock);
} while (t->nb_events < 0 && (errno == EINTR || errno == EAGAIN ) );
} while (nb_events < 0 && (errno == EINTR || errno == EAGAIN ) );
AssertFatal (t->nb_events >=0,
AssertFatal (nb_events >=0,
"epoll_wait failed for task %s, nb fds %d, timeout %lu: %s!\n",
itti_get_task_name(task_id), t->nb_fd_epoll, t->next_timer != UINT64_MAX ? t->next_timer-current_time : -1, strerror(errno));
LOG_D(ITTI,"receive on %d descriptors for %s\n", t->nb_events, itti_get_task_name(task_id));
itti_get_task_name(task_id), t->nb_fd_epoll,
t->next_timer != UINT64_MAX ? t->next_timer-current_time : -1,
strerror(errno));
LOG_D(ITTI,"receive on %d descriptors for %s\n", nb_events, itti_get_task_name(task_id));
if (t->nb_events == 0)
if (nb_events == 0)
/* No data to read -> return */
return 0;
for (int i = 0; i < t->nb_events; i++) {
for (int i = 0; i < nb_events; i++) {
/* Check if there is an event for ITTI for the event fd */
if ((t->events[i].events & EPOLLIN) &&
(t->events[i].data.fd == t->sem_fd)) {
if ((events[i].events & EPOLLIN) &&
(events[i].data.fd == t->sem_fd)) {
eventfd_t sem_counter;
/* Read will always return 1 */
AssertFatal( sizeof(sem_counter) == read (t->sem_fd, &sem_counter, sizeof(sem_counter)), "");
/* Mark that the event has been processed */
t->events[i].events &= ~EPOLLIN;
events[i].events &= ~EPOLLIN;
}
}
*events = t->events;
return t->nb_events;
return nb_events;
}
int itti_get_events(task_id_t task_id, struct epoll_event **events) {
int itti_get_events(task_id_t task_id, struct epoll_event *events, int nb_evts) {
pthread_mutex_lock(&tasks[task_id]->queue_cond_lock);
return itti_get_events_locked(task_id, events);
return itti_get_events_locked(task_id, events, nb_evts);
}
void itti_receive_msg(task_id_t task_id, MessageDef **received_msg) {
@@ -275,17 +274,14 @@ extern "C" {
task_list_t *t=tasks[task_id];
pthread_mutex_lock(&t->queue_cond_lock);
struct epoll_event events[t->nb_fd_epoll];
// Weird condition to deal with crap legacy itti interface
if ( t->nb_fd_epoll == 1 ) {
while (t->message_queue.empty()) {
itti_get_events_locked(task_id, &t->events);
pthread_mutex_lock(&t->queue_cond_lock);
}
} else {
if (t->message_queue.empty()) {
itti_get_events_locked(task_id, &t->events);
if (t->message_queue.empty()) {
do {
itti_get_events_locked(task_id, events, t->nb_fd_epoll);
pthread_mutex_lock(&t->queue_cond_lock);
}
while (t->message_queue.empty() && t->nb_fd_epoll == 1);
}
// Legacy design: we return even if we have no message
common/utils/ocp_itti/intertask_interface.h
+1 -1
View File
@@ -479,7 +479,7 @@ void itti_unsubscribe_event_fd(task_id_t task_id, int fd);
\param events events list
@returns number of events to handle
**/
int itti_get_events(task_id_t task_id, struct epoll_event **events);
int itti_get_events(task_id_t task_id, struct epoll_event *events, int nb_max_evts);
/** \brief Retrieves a message in the queue associated to task_id.
If the queue is empty, the thread is blocked till a new message arrives.
common/utils/threadPool/thread-pool.c
+13 -1
View File
@@ -111,7 +111,7 @@ void initNamedTpool(char *params,tpool_t *pool, bool performanceMeas, char *name
if (measr) {
mkfifo(measr,0666);
AssertFatal(-1 != (pool->dummyTraceFd=
AssertFatal(-1 != (pool->dummyKeepReadingTraceFd=
open(measr, O_RDONLY| O_NONBLOCK)),"");
AssertFatal(-1 != (pool->traceFd=
open(measr, O_WRONLY|O_APPEND|O_NOATIME|O_NONBLOCK)),"");
@@ -130,6 +130,7 @@ void initNamedTpool(char *params,tpool_t *pool, bool performanceMeas, char *name
int c=toupper(curptr[0]);
switch (c) {
case 'N':
pool->activated=false;
break;
@@ -161,6 +162,17 @@ void initNamedTpool(char *params,tpool_t *pool, bool performanceMeas, char *name
}
}
void initFloatingCoresTpool(int nbThreads,tpool_t *pool, bool performanceMeas, char *name) {
char threads[1024] = "n";
if (nbThreads) {
strcpy(threads,"-1");
for (int i=1; i < nbThreads; i++)
strncat(threads,",-1", sizeof(threads-1));
}
threads[sizeof(threads-1)]=0;
initNamedTpool(threads, pool, performanceMeas, name);
}
#ifdef TEST_THREAD_POOL
volatile int oai_exit=0;
common/utils/threadPool/thread-pool.h
+2 -2
View File
@@ -256,9 +256,8 @@ typedef struct thread_pool {
bool activated;
bool measurePerf;
int traceFd;
int dummyTraceFd;
int dummyKeepReadingTraceFd;
uint64_t cpuCyclesMicroSec;
uint64_t startProcessingUE;
int nbThreads;
notifiedFIFO_t incomingFifo;
struct one_thread *allthreads;
@@ -389,5 +388,6 @@ static inline int abortTpool(tpool_t *t) {
return nbRemoved;
}
void initNamedTpool(char *params,tpool_t *pool, bool performanceMeas, char *name);
void initFloatingCoresTpool(int nbThreads,tpool_t *pool, bool performanceMeas, char *name);
#define initTpool(PARAMPTR,TPOOLPTR, MEASURFLAG) initNamedTpool(PARAMPTR,TPOOLPTR, MEASURFLAG, NULL)
#endif
common/utils/time_meas.c
+8 -8
View File
@@ -39,14 +39,14 @@ notifiedFIFO_t measur_fifo;
double get_cpu_freq_GHz(void)
{
if (cpu_freq_GHz <1 ) {
time_stats_t ts = {0};
reset_meas(&ts);
ts.trials++;
ts.in = rdtsc_oai();
sleep(1);
ts.diff = (rdtsc_oai()-ts.in);
cpu_freq_GHz = (double)ts.diff/1000000000;
printf("CPU Freq is %f \n", cpu_freq_GHz);
time_stats_t ts = {0};
reset_meas(&ts);
ts.trials++;
ts.in = rdtsc_oai();
sleep(1);
ts.diff = (rdtsc_oai()-ts.in);
cpu_freq_GHz = (double)ts.diff/1000000000;
printf("CPU Freq is %f \n", cpu_freq_GHz);
}
return cpu_freq_GHz;
}
common/utils/time_stat.c
+136
View File
@@ -0,0 +1,136 @@
/*
* 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
*/
#include "time_stat.h"
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include "common/utils/LOG/log.h"
time_average_t *time_average_new(int duration, int initial_size)
{
time_average_t *ret;
/* let's only accept power of two initial_size */
if (initial_size & (initial_size - 1)) {
LOG_E(UTIL, "time_average_new: illegal initial_size %d, use power of two\n", initial_size);
exit(1);
}
ret = calloc(1, sizeof(time_average_t));
if (ret == NULL) {
LOG_E(UTIL, "out of memory\n");
exit(1);
}
ret->duration = duration;
ret->r.head = initial_size - 1;
ret->r.maxsize = initial_size;
ret->r.buffer = calloc(initial_size, sizeof(time_value_t));
if (ret->r.buffer == NULL) {
LOG_E(UTIL, "out of memory\n");
exit(1);
}
return ret;
}
void time_average_free(time_average_t *t)
{
free(t->r.buffer);
free(t);
}
void time_average_reset(time_average_t *t)
{
t->r.head = t->r.maxsize - 1;
t->r.tail = 0;
t->r.size = 0;
t->accumulated_value = 0;
}
static void remove_old(time_average_t *t, uint64_t time)
{
/* remove old events */
while (t->r.size && t->r.buffer[t->r.tail].time < time - t->duration) {
t->accumulated_value -= t->r.buffer[t->r.tail].value;
t->r.size--;
t->r.tail++;
t->r.tail %= t->r.maxsize;
}
}
void time_average_add(time_average_t *t, uint64_t time, uint64_t value)
{
remove_old(t, time);
if (t->r.size == t->r.maxsize) {
t->r.maxsize *= 2;
t->r.buffer = realloc(t->r.buffer, t->r.maxsize * sizeof(time_value_t));
if (t->r.buffer == NULL) {
LOG_E(UTIL, "out of memory\n");
exit(1);
}
if (t->r.head < t->r.tail) {
memcpy(&t->r.buffer[t->r.size], &t->r.buffer[0], (t->r.head + 1) * sizeof(time_value_t));
t->r.head += t->r.size;
}
}
t->r.head++;
t->r.head %= t->r.maxsize;
t->r.buffer[t->r.head].time = time;
t->r.buffer[t->r.head].value = value;
t->r.size++;
t->accumulated_value += value;
}
double time_average_get_average(time_average_t *t, uint64_t time)
{
remove_old(t, time);
if (t->r.size == 0)
return 0;
return (double)t->accumulated_value / t->r.size;
}
uint64_t time_average_now(void)
{
struct timespec t;
uint64_t ret;
if (clock_gettime(CLOCK_REALTIME, &t)) {
LOG_E(UTIL, "clock_gettime failed\n");
exit(1);
}
ret = (uint64_t)t.tv_sec * (uint64_t)1000000 + t.tv_nsec / 1000;
/* round up if necessary */
if (t.tv_nsec % 1000 >= 500)
ret++;
return ret;
}
common/utils/time_stat.h
+64
View File
@@ -0,0 +1,64 @@
/*
* 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
*/
#ifndef _COMMON_UTIL_TIME_STAT_H_
#define _COMMON_UTIL_TIME_STAT_H_
#include <stdint.h>
typedef struct {
uint64_t time; /* unit: microsecond */
uint64_t value; /* unit: microsecond */
} time_value_t;
typedef struct {
int head;
int tail;
time_value_t *buffer;
int maxsize;
int size;
} time_ring_t;
typedef struct {
int duration; /* unit: microsecond */
time_ring_t r;
uint64_t accumulated_value;
} time_average_t;
/* 'duration' is in unit microsecond */
time_average_t *time_average_new(int duration, int initial_size);
void time_average_free(time_average_t *t);
void time_average_reset(time_average_t *t);
/* add a value tagged with time 'time' unit microsecond (it also modifies 't',
* removing all data with time < 'time' - t->duration)
*/
void time_average_add(time_average_t *t, uint64_t time, uint64_t value);
/* get the average for time 'time' (it also modifies 't', removing all
* data with time < 'time' - t->duration)
*/
double time_average_get_average(time_average_t *t, uint64_t time);
/* unit microsecond */
uint64_t time_average_now(void);
#endif /* _COMMON_UTIL_TIME_STAT_H_ */