Merge remote-tracking branch 'origin/develop' into aw2s-n41
Conflicts: executables/nr-softmodem.c openair1/PHY/NR_TRANSPORT/nr_dlsch.c openair1/PHY/NR_TRANSPORT/pucch_rx.c openair1/SIMULATION/NR_PHY/dlsim.c openair1/SIMULATION/NR_PHY/ulsim.c openair2/LAYER2/NR_MAC_gNB/config.c openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_RA.c
This commit is contained in:
Raymond Knopp
@@ -182,8 +182,8 @@ int config_cmdlineonly_get(paramdef_t *cfgoptions,int numoptions, char *prefix )
|
||||
}
|
||||
|
||||
configmodule_interface_t *load_configmodule(int argc,
|
||||
char **argv,
|
||||
uint32_t initflags)
|
||||
char **argv,
|
||||
uint32_t initflags)
|
||||
{
|
||||
char *cfgparam=NULL;
|
||||
char *modeparams=NULL;
|
||||
@@ -194,6 +194,11 @@ configmodule_interface_t *load_configmodule(int argc,
|
||||
int i;
|
||||
int OoptIdx=-1;
|
||||
|
||||
printf("CMDLINE: ");
|
||||
for (int i=0; i<argc; i++)
|
||||
printf("\"%s\" ", argv[i]);
|
||||
printf("\n");
|
||||
|
||||
/* first parse the command line to look for the -O option */
|
||||
for (i = 0; i<argc; i++) {
|
||||
if (strlen(argv[i]) < 2)
|
||||
@@ -219,11 +224,9 @@ configmodule_interface_t *load_configmodule(int argc,
|
||||
cfgparam = getenv("OAI_CONFIGMODULE");
|
||||
}
|
||||
|
||||
/* default different for UE and softmodem because UE doesn't use config file*/
|
||||
/* default different for UE and softmodem because UE may run without config file */
|
||||
/* and -O option is not mandatory for UE */
|
||||
/* phy simulators behave as UE */
|
||||
/* test of exec name would better be replaced by a parameter to the l */
|
||||
/* oad_configmodule function */
|
||||
if (cfgparam == NULL) {
|
||||
tmpflags = tmpflags | CONFIG_NOOOPT;
|
||||
|
||||
@@ -249,9 +252,14 @@ configmodule_interface_t *load_configmodule(int argc,
|
||||
}
|
||||
|
||||
cfgptr = calloc(sizeof(configmodule_interface_t),1);
|
||||
/* argv_info is used to memorize command line options which have been recognized */
|
||||
/* and to detect unrecognized command line options which might have been specified */
|
||||
cfgptr->argv_info = calloc(sizeof(int32_t), argc);
|
||||
/* argv[0] is the exec name, always Ok */
|
||||
cfgptr->argv_info[0] |= CONFIG_CMDLINEOPT_PROCESSED;
|
||||
|
||||
/* when OoptIdx is >0, -O option has been detected at position OoptIdx
|
||||
* we must memorize arv[OoptIdx is Ok */
|
||||
if (OoptIdx >= 0) {
|
||||
cfgptr->argv_info[OoptIdx] |= CONFIG_CMDLINEOPT_PROCESSED;
|
||||
cfgptr->argv_info[OoptIdx+1] |= CONFIG_CMDLINEOPT_PROCESSED;
|
||||
|
||||
@@ -122,7 +122,7 @@ int config_libconfig_get(paramdef_t *cfgoptions,int numoptions, char *prefix ) {
|
||||
|
||||
switch(cfgoptions[i].type) {
|
||||
case TYPE_STRING:
|
||||
if ( config_lookup_string(&(libconfig_privdata.cfg),cfgpath, (const char **)&str)) {
|
||||
if ( config_lookup_string(&(libconfig_privdata.cfg), cfgpath, (const char**)&str)) {
|
||||
if ( cfgoptions[i].numelt > 0 && str != NULL && strlen(str) >= cfgoptions[i].numelt ) {
|
||||
fprintf(stderr,"[LIBCONFIG] %s: %s exceeds maximum length of %i bytes, value truncated\n",
|
||||
cfgpath,str,cfgoptions[i].numelt);
|
||||
|
||||
@@ -8,7 +8,7 @@ By default, this facility is included at build-time and activated at run-time. T
|
||||
```bash
|
||||
/build_oai --disable-T-Tracer
|
||||
```
|
||||
- To use the the T-Tracer instead of the console logging facility, use the command line option *T_stdout*. *T_stdout* is a boolean option, which, when set to 0 (false) disable the console logging facility. All stdout messages are then sent to the T-Tracer.
|
||||
- To use the the T-Tracer, use the command line option *T_stdout*. When set to 0, it disables the console logging facility. All stdout messages are then sent to the T-Tracer. When set to 1 (the default), the logs are output to the linux console and no T trace is generated. When set to 2 both console logging and T traces are activated.
|
||||
|
||||
## Documentation
|
||||
|
||||
|
||||
@@ -9,7 +9,7 @@ All logging facility parameters are defined in the log_config section. Some para
|
||||
|:---:|:---:|:---:|:----|
|
||||
| `global_log_level` | `pre-defined string of char` | `info` | Allows printing of messages up to the specified level. Available levels, from lower to higher are `error`,`warn`,`info`,`debug`,`trace` |
|
||||
| `global_log_online` | `boolean` | 1 (=true) | If false, all console messages are discarded, whatever their level |
|
||||
| `global_log_options` | `list of pre-defined string of char` | | 3 options can be specified to trigger the information added in the header of the message: `nocolor`, disable color usage in log messages, usefull when redirecting logs to a file, where escape sequences used for color selection can be annoying, `level`, add a one letter level id in the message header (T,D,I,W,E for trace, debug, info, warning, error),`thread`, add the thread name in the message header|
|
||||
| `global_log_options` | `list of pre-defined string of char` | | 3 options can be specified to trigger the information added in the header of the message: `nocolor`, disable color usage in log messages, usefull when redirecting logs to a file, where escape sequences used for color selection can be annoying, `level`, add a one letter level id in the message header (T,D,I,W,E for trace, debug, info, warning, error),`thread`, add the thread name in the message header, `function`, adds the function name, `line_num`, adds the line number, `time` adds the time since process starts|
|
||||
|
||||
### Component specific parameters
|
||||
| name | type | default | description |
|
||||
|
||||
+136
-151
@@ -43,6 +43,8 @@
|
||||
#include <string.h>
|
||||
#include <linux/prctl.h>
|
||||
#include "common/config/config_userapi.h"
|
||||
#include <time.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
// main log variables
|
||||
|
||||
@@ -73,6 +75,9 @@ mapping log_options[] = {
|
||||
{"nocolor", FLAG_NOCOLOR },
|
||||
{"level", FLAG_LEVEL },
|
||||
{"thread", FLAG_THREAD },
|
||||
{"line_num", FLAG_FILE_LINE },
|
||||
{"function", FLAG_FUNCT},
|
||||
{"time", FLAG_TIME},
|
||||
{NULL,-1}
|
||||
};
|
||||
|
||||
@@ -81,6 +86,7 @@ mapping log_maskmap[] = LOG_MASKMAP_INIT;
|
||||
|
||||
char *log_level_highlight_start[] = {LOG_RED, LOG_ORANGE, "", LOG_BLUE, LOG_CYBL}; /*!< \brief Optional start-format strings for highlighting */
|
||||
char *log_level_highlight_end[] = {LOG_RESET,LOG_RESET,LOG_RESET, LOG_RESET,LOG_RESET}; /*!< \brief Optional end-format strings for highlighting */
|
||||
static void log_output_memory(log_component_t *c, const char *file, const char *func, int line, int comp, int level, const char* format,va_list args);
|
||||
|
||||
|
||||
int write_file_matlab(const char *fname,
|
||||
@@ -476,6 +482,8 @@ int logInit (void)
|
||||
register_log_component("NR_MAC","log",NR_MAC);
|
||||
register_log_component("NR_PHY","log",NR_PHY);
|
||||
register_log_component("NGAP","",NGAP);
|
||||
register_log_component("ITTI","log",ITTI);
|
||||
register_log_component("UTIL","log",UTIL);
|
||||
|
||||
for (int i=0 ; log_level_names[i].name != NULL ; i++)
|
||||
g_log->level2string[i] = toupper(log_level_names[i].name[0]); // uppercased first letter of level name
|
||||
@@ -493,84 +501,138 @@ int logInit (void)
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
char *log_getthreadname(char *threadname,
|
||||
int bufsize)
|
||||
static inline int log_header(log_component_t *c,
|
||||
char *log_buffer,
|
||||
int buffsize,
|
||||
const char *file,
|
||||
const char *func,
|
||||
int line,
|
||||
int level)
|
||||
{
|
||||
int rt = pthread_getname_np(pthread_self(), threadname,bufsize) ;
|
||||
int flag= g_log->flag | c->flag;
|
||||
|
||||
if (rt == 0) {
|
||||
return threadname;
|
||||
char threadname[64];
|
||||
if (flag & FLAG_THREAD ) {
|
||||
threadname[0]='{';
|
||||
if ( pthread_getname_np(pthread_self(), threadname+1,61) != 0)
|
||||
strcpy(threadname+1, "?thread?");
|
||||
strcat(threadname,"}");
|
||||
} else {
|
||||
return "thread?";
|
||||
threadname[0]=0;
|
||||
}
|
||||
|
||||
char l[32];
|
||||
if (flag & FLAG_FILE_LINE && flag & FLAG_FUNCT )
|
||||
snprintf(l, sizeof l," (%s:%d) ", func, line);
|
||||
else if (flag & FLAG_FILE_LINE)
|
||||
sprintf(l," (%d) ", line);
|
||||
else
|
||||
l[0]=0;
|
||||
|
||||
char timeString[32];
|
||||
if ( flag & FLAG_TIME ) {
|
||||
struct timespec t;
|
||||
clock_gettime(CLOCK_MONOTONIC, &t);
|
||||
snprintf(timeString, sizeof t,"%05.3f",t.tv_sec+t.tv_nsec/1.0e9);
|
||||
} else {
|
||||
timeString[0]=0;
|
||||
}
|
||||
return snprintf(log_buffer, buffsize, "%s%s[%s]%c%s %s ",
|
||||
timeString,
|
||||
flag & FLAG_NOCOLOR ? "" : log_level_highlight_start[level],
|
||||
c->name,
|
||||
flag & FLAG_LEVEL ? g_log->level2string[level] : ' ',
|
||||
l,
|
||||
threadname
|
||||
);
|
||||
}
|
||||
|
||||
static int log_header(char *log_buffer,
|
||||
int buffsize,
|
||||
int comp,
|
||||
int level,
|
||||
const char *format)
|
||||
#if LOG_MINIMAL
|
||||
#include <sys/syscall.h>
|
||||
void logMinimal(int comp, int level, const char *format, ...)
|
||||
{
|
||||
char threadname[PR_SET_NAME];
|
||||
return snprintf(log_buffer, buffsize, "%s%s[%s]%c %s %s%s",
|
||||
log_level_highlight_end[level],
|
||||
( (g_log->flag & FLAG_NOCOLOR)?"":log_level_highlight_start[level]),
|
||||
g_log->log_component[comp].name,
|
||||
( (g_log->flag & FLAG_LEVEL)?g_log->level2string[level]:' '),
|
||||
( (g_log->flag & FLAG_THREAD)?log_getthreadname(threadname,PR_SET_NAME+1):""),
|
||||
format,
|
||||
log_level_highlight_end[level]);
|
||||
struct timespec ts;
|
||||
if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1)
|
||||
abort();
|
||||
|
||||
char buf[MAX_LOG_TOTAL];
|
||||
int n = snprintf(buf, sizeof(buf), "%lu.%06lu %08lx [%s] %c ",
|
||||
ts.tv_sec,
|
||||
ts.tv_nsec / 1000,
|
||||
syscall(__NR_gettid),
|
||||
g_log->log_component[comp].name,
|
||||
level);
|
||||
if (n < 0 || n >= sizeof(buf))
|
||||
{
|
||||
fprintf(stderr, "%s: n=%d\n", __func__, n);
|
||||
return;
|
||||
}
|
||||
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
int m = vsnprintf(buf + n, sizeof(buf) - n, format, args);
|
||||
va_end(args);
|
||||
|
||||
if (m < 0)
|
||||
{
|
||||
fprintf(stderr, "%s: n=%d m=%d\n", __func__, n, m);
|
||||
return;
|
||||
}
|
||||
|
||||
int len = n + m;
|
||||
if (len > sizeof(buf) - 1)
|
||||
{
|
||||
len = sizeof(buf) - 1;
|
||||
}
|
||||
if (buf[len - 1] != '\n')
|
||||
{
|
||||
buf[len++] = '\n';
|
||||
}
|
||||
|
||||
__attribute__((unused))
|
||||
int unused = write(STDOUT_FILENO, buf, len);
|
||||
}
|
||||
#endif // LOG_MINIMAL
|
||||
|
||||
void logRecord_mt(const char *file,
|
||||
const char *func,
|
||||
int line,
|
||||
int comp,
|
||||
int level,
|
||||
const char *format,
|
||||
... )
|
||||
const char *func,
|
||||
int line,
|
||||
int comp,
|
||||
int level,
|
||||
const char *format,
|
||||
... )
|
||||
{
|
||||
char log_buffer[MAX_LOG_TOTAL]= {0};
|
||||
log_component_t *c = &g_log->log_component[comp];
|
||||
va_list args;
|
||||
va_start(args,format);
|
||||
if (log_mem_flag == 1) {
|
||||
log_output_memory(file,func,line,comp,level,format,args);
|
||||
} else {
|
||||
log_header(log_buffer,MAX_LOG_TOTAL,comp,level,format);
|
||||
g_log->log_component[comp].vprint(g_log->log_component[comp].stream,log_buffer,args);
|
||||
fflush(g_log->log_component[comp].stream);
|
||||
}
|
||||
log_output_memory(c, file,func,line,comp,level,format,args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
void vlogRecord_mt(const char *file,
|
||||
const char *func,
|
||||
int line,
|
||||
int comp,
|
||||
int level,
|
||||
const char *format,
|
||||
va_list args )
|
||||
const char *func,
|
||||
int line,
|
||||
int comp,
|
||||
int level,
|
||||
const char *format,
|
||||
va_list args )
|
||||
{
|
||||
char log_buffer[MAX_LOG_TOTAL];
|
||||
if (log_mem_flag == 1) {
|
||||
log_output_memory(file,func,line,comp,level, format,args);
|
||||
} else {
|
||||
log_header(log_buffer,MAX_LOG_TOTAL,comp, level,format);
|
||||
g_log->log_component[comp].vprint(g_log->log_component[comp].stream,log_buffer, args);
|
||||
}
|
||||
log_component_t *c = &g_log->log_component[comp];
|
||||
log_output_memory(c, file,func,line,comp,level, format,args);
|
||||
}
|
||||
|
||||
void log_dump(int component,
|
||||
void *buffer,
|
||||
int buffsize,
|
||||
int datatype,
|
||||
const char *format,
|
||||
... )
|
||||
void *buffer,
|
||||
int buffsize,
|
||||
int datatype,
|
||||
const char *format,
|
||||
... )
|
||||
{
|
||||
va_list args;
|
||||
char *wbuf;
|
||||
|
||||
log_component_t *c = &g_log->log_component[component];
|
||||
int flag= g_log->flag | c->flag;
|
||||
|
||||
switch(datatype) {
|
||||
case LOG_DUMP_DOUBLE:
|
||||
wbuf=malloc((buffsize * 10) + 64 + MAX_LOG_TOTAL);
|
||||
@@ -584,9 +646,8 @@ void log_dump(int component,
|
||||
|
||||
if (wbuf != NULL) {
|
||||
va_start(args, format);
|
||||
int pos=log_header(wbuf,MAX_LOG_TOTAL,component, OAILOG_INFO,"");
|
||||
int pos2=vsprintf(wbuf+pos,format, args);
|
||||
pos=pos+pos2;
|
||||
int pos=log_header(c, wbuf,MAX_LOG_TOTAL,"noFile","noFunc",0, OAILOG_INFO);
|
||||
pos+=vsprintf(wbuf+pos,format, args);
|
||||
va_end(args);
|
||||
|
||||
for (int i=0; i<buffsize; i++) {
|
||||
@@ -601,9 +662,11 @@ void log_dump(int component,
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
sprintf(wbuf+pos,"\n");
|
||||
g_log->log_component[component].print(g_log->log_component[component].stream,wbuf);
|
||||
if ( flag & FLAG_NOCOLOR )
|
||||
sprintf(wbuf+pos,"\n");
|
||||
else
|
||||
sprintf(wbuf+pos,"%s\n",log_level_highlight_end[OAILOG_INFO]);
|
||||
c->print(c->stream,wbuf);
|
||||
free(wbuf);
|
||||
}
|
||||
}
|
||||
@@ -803,13 +866,10 @@ void flush_mem_to_file(void)
|
||||
|
||||
char logmem_log_level[NUM_LOG_LEVEL]={'E','W','I','D','T'};
|
||||
|
||||
void log_output_memory(const char *file, const char *func, int line, int comp, int level, const char* format,va_list args)
|
||||
static void log_output_memory(log_component_t *c, const char *file, const char *func, int line, int comp, int level, const char* format,va_list args)
|
||||
{
|
||||
//logRecord_mt(file,func,line, pthread_self(), comp, level, format, ##args)
|
||||
int len = 0;
|
||||
log_component_t *c;
|
||||
char *log_start;
|
||||
char *log_end;
|
||||
/* The main difference with the version above is the use of this local log_buffer.
|
||||
* The other difference is the return value of snprintf which was not used
|
||||
* correctly. It was not a big problem because in practice MAX_LOG_TOTAL is
|
||||
@@ -817,92 +877,17 @@ void log_output_memory(const char *file, const char *func, int line, int comp, i
|
||||
*/
|
||||
char log_buffer[MAX_LOG_TOTAL];
|
||||
|
||||
/* for no gcc warnings */
|
||||
(void)log_start;
|
||||
(void)log_end;
|
||||
|
||||
|
||||
c = &g_log->log_component[comp];
|
||||
|
||||
//VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_LOG_RECORD, VCD_FUNCTION_IN);
|
||||
|
||||
// make sure that for log trace the extra info is only printed once, reset when the level changes
|
||||
if (level == OAILOG_TRACE) {
|
||||
log_start = log_buffer;
|
||||
len = vsnprintf(log_buffer, MAX_LOG_TOTAL, format, args);
|
||||
if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
|
||||
log_end = log_buffer + len;
|
||||
} else {
|
||||
if ( (g_log->flag & 0x001) || (c->flag & 0x001) ) {
|
||||
len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "%s",
|
||||
log_level_highlight_start[level]);
|
||||
if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
|
||||
}
|
||||
|
||||
log_start = log_buffer + len;
|
||||
|
||||
// if ( (g_log->flag & 0x004) || (c->flag & 0x004) ) {
|
||||
len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s]",
|
||||
g_log->log_component[comp].name);
|
||||
if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
|
||||
// }
|
||||
|
||||
if ( (level >= OAILOG_ERR) && (level <= OAILOG_TRACE) ) {
|
||||
len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%c]",
|
||||
logmem_log_level[level]);
|
||||
if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
|
||||
}
|
||||
|
||||
if ( (g_log->flag & FLAG_THREAD) || (c->flag & FLAG_THREAD) ) {
|
||||
# define THREAD_NAME_LEN 128
|
||||
char threadname[THREAD_NAME_LEN];
|
||||
if (pthread_getname_np(pthread_self(), threadname, THREAD_NAME_LEN) != 0)
|
||||
{
|
||||
perror("pthread_getname_np : ");
|
||||
} else {
|
||||
len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s]", threadname);
|
||||
if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
|
||||
}
|
||||
# undef THREAD_NAME_LEN
|
||||
}
|
||||
|
||||
if ( (g_log->flag & FLAG_FUNCT) || (c->flag & FLAG_FUNCT) ) {
|
||||
len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s] ",
|
||||
func);
|
||||
if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
|
||||
}
|
||||
|
||||
if ( (g_log->flag & FLAG_FILE_LINE) || (c->flag & FLAG_FILE_LINE) ) {
|
||||
len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s:%d]",
|
||||
file, line);
|
||||
if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
|
||||
}
|
||||
|
||||
/* len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%08lx]", thread_id);
|
||||
if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
|
||||
|
||||
struct timeval gettime;
|
||||
gettimeofday(&gettime,NULL);
|
||||
len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%ld.%06ld]", gettime.tv_sec, gettime.tv_usec);
|
||||
if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
|
||||
*/
|
||||
if ( (g_log->flag & FLAG_NOCOLOR) || (c->flag & FLAG_NOCOLOR) ) {
|
||||
len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "%s",
|
||||
log_level_highlight_end[level]);
|
||||
if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
|
||||
}
|
||||
|
||||
len += vsnprintf(&log_buffer[len], MAX_LOG_TOTAL - len, format, args);
|
||||
if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
|
||||
log_end = log_buffer + len;
|
||||
}
|
||||
|
||||
//va_end(args);
|
||||
|
||||
if (level < OAILOG_TRACE)
|
||||
len += log_header(c, log_buffer, MAX_LOG_TOTAL, file, func, line, level);
|
||||
len += vsnprintf(log_buffer+len, MAX_LOG_TOTAL-len, format, args);
|
||||
if ( !((g_log->flag | c->flag) & FLAG_NOCOLOR) )
|
||||
len+=snprintf(log_buffer+len, MAX_LOG_TOTAL-len, "%s", log_level_highlight_end[level]);
|
||||
|
||||
// OAI printf compatibility
|
||||
if(log_mem_flag==1){
|
||||
if(log_mem_d[log_mem_side].enable_flag==1){
|
||||
int temp_index;
|
||||
if(log_mem_flag==1){
|
||||
if(log_mem_d[log_mem_side].enable_flag==1){
|
||||
int temp_index;
|
||||
temp_index=log_mem_d[log_mem_side].buf_index;
|
||||
if(temp_index+len+1 < LOG_MEM_SIZE){
|
||||
log_mem_d[log_mem_side].buf_index+=len;
|
||||
@@ -933,9 +918,9 @@ void log_output_memory(const char *file, const char *func, int line, int comp, i
|
||||
}
|
||||
}
|
||||
}
|
||||
}else{
|
||||
fwrite(log_buffer, len, 1, stdout);
|
||||
}
|
||||
}else{
|
||||
if (write(fileno(c->stream), log_buffer, len)) {};
|
||||
}
|
||||
}
|
||||
|
||||
int logInit_log_mem (void)
|
||||
|
||||
+36
-6
@@ -54,6 +54,12 @@
|
||||
#include "T.h"
|
||||
#include <common/utils/utils.h>
|
||||
/*----------------------------------------------------------------------------*/
|
||||
#include <assert.h>
|
||||
#ifdef NDEBUG
|
||||
#warning assert is disabled
|
||||
#endif
|
||||
#define NUM_ELEMENTS(ARRAY) (sizeof(ARRAY) / sizeof(ARRAY[0]))
|
||||
#define CHECK_INDEX(ARRAY, INDEX) assert((INDEX) < NUM_ELEMENTS(ARRAY))
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
@@ -237,6 +243,8 @@ typedef enum {
|
||||
ASN,
|
||||
NFAPI_VNF,
|
||||
NFAPI_PNF,
|
||||
ITTI,
|
||||
UTIL,
|
||||
MAX_LOG_PREDEF_COMPONENTS,
|
||||
}
|
||||
comp_name_t;
|
||||
@@ -315,7 +323,6 @@ int register_log_component(char *name, char *fext, int compidx);
|
||||
#define LOG_MEM_SIZE 100*1024*1024
|
||||
#define LOG_MEM_FILE "./logmem.log"
|
||||
void flush_mem_to_file(void);
|
||||
void log_output_memory(const char *file, const char *func, int line, int comp, int level, const char* format,va_list args);
|
||||
int logInit_log_mem(void);
|
||||
void close_log_mem(void);
|
||||
|
||||
@@ -400,13 +407,33 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
|
||||
#define LOG_DUMP_DOUBLE 1
|
||||
// debugging macros
|
||||
#define LOG_F LOG_I /* because LOG_F was originaly to dump a message or buffer but is also used as a regular level...., to dump use LOG_DUMPMSG */
|
||||
|
||||
#if LOG_MINIMAL
|
||||
|
||||
void logMinimal(int component, int level, const char *format, ...) __attribute__((format(printf, 3, 4)));
|
||||
# define LOG_E(COMPONENT, ...) do if (1) logMinimal(COMPONENT, 'E', __VA_ARGS__); while (0)
|
||||
# define LOG_W(COMPONENT, ...) do if (1) logMinimal(COMPONENT, 'W', __VA_ARGS__); while (0)
|
||||
# define LOG_A(COMPONENT, ...) do if (1) logMinimal(COMPONENT, 'A', __VA_ARGS__); while (0) /* logs intended for analysis */
|
||||
# define LOG_I(COMPONENT, ...) do if (1) logMinimal(COMPONENT, 'I', __VA_ARGS__); while (0)
|
||||
# define LOG_D(COMPONENT, ...) do if (0) logMinimal(COMPONENT, 'D', __VA_ARGS__); while (0)
|
||||
# define LOG_T(COMPONENT, ...) do if (0) logMinimal(COMPONENT, 'T', __VA_ARGS__); while (0)
|
||||
|
||||
# define LOG_M(FILE, VECTOR, DATA, LEN, DEC, FORMAT) ((void) 0)
|
||||
# define LOG_DUMPFLAG(D) 0
|
||||
# define LOG_DEBUGFLAG(D) 0
|
||||
# define LOG_DUMPMSG(C, B, S, X...) ((void) 0)
|
||||
# define VLOG(C, L, F, ARGS) ((void) 0)
|
||||
|
||||
#else // LOG_MINIMAL
|
||||
|
||||
# if T_TRACER
|
||||
/* per component, level dependent macros */
|
||||
# define LOG_E(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_ERR ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_ERR, x) ;} else { T(T_LEGACY_ ## c ## _ERROR, T_PRINTF(x)) ;}} while (0)
|
||||
# define LOG_W(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_WARNING) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_WARNING, x) ;} else { T(T_LEGACY_ ## c ## _WARNING, T_PRINTF(x)) ;}} while (0)
|
||||
# define LOG_I(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_INFO ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_INFO, x) ;} else { T(T_LEGACY_ ## c ## _INFO, T_PRINTF(x)) ;}} while (0)
|
||||
# define LOG_D(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_DEBUG ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_DEBUG, x) ;} else { T(T_LEGACY_ ## c ## _DEBUG, T_PRINTF(x)) ;}} while (0)
|
||||
# define LOG_T(c, x...) do { if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_TRACE ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_TRACE, x) ;} else { T(T_LEGACY_ ## c ## _TRACE, T_PRINTF(x)) ;}} while (0)
|
||||
# define LOG_E(c, x...) do { T(T_LEGACY_ ## c ## _ERROR, T_PRINTF(x)) ; if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_ERR ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_ERR, x) ;} } while (0)
|
||||
# define LOG_W(c, x...) do { T(T_LEGACY_ ## c ## _WARNING, T_PRINTF(x)); if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_WARNING) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_WARNING, x);} } while (0)
|
||||
# define LOG_A LOG_I
|
||||
# define LOG_I(c, x...) do { T(T_LEGACY_ ## c ## _INFO, T_PRINTF(x)) ; if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_INFO ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_INFO, x) ;} } while (0)
|
||||
# define LOG_D(c, x...) do { T(T_LEGACY_ ## c ## _DEBUG, T_PRINTF(x)) ; if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_DEBUG ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_DEBUG, x) ;} } while (0)
|
||||
# define LOG_T(c, x...) do { T(T_LEGACY_ ## c ## _TRACE, T_PRINTF(x)) ; if (T_stdout) { if( g_log->log_component[c].level >= OAILOG_TRACE ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_TRACE, x) ;} } while (0)
|
||||
# define VLOG(c,l, f, args) do { if (T_stdout) { if( g_log->log_component[c].level >= l ) vlogRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, l, f, args) ;} } while (0)
|
||||
/* macro used to dump a buffer or a message as in openair2/RRC/LTE/RRC_eNB.c, replaces LOG_F macro */
|
||||
# define LOG_DUMPMSG(c, f, b, s, x...) do { if(g_log->dump_mask & f) log_dump(c, b, s, LOG_DUMP_CHAR, x) ;} while (0) /* */
|
||||
@@ -423,6 +450,7 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
|
||||
# define LOG_E(c, x...) do { if( g_log->log_component[c].level >= OAILOG_ERR ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_ERR, x) ;} while (0)
|
||||
# define LOG_W(c, x...) do { if( g_log->log_component[c].level >= OAILOG_WARNING) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_WARNING, x) ;} while (0)
|
||||
# define LOG_I(c, x...) do { if( g_log->log_component[c].level >= OAILOG_INFO ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_INFO, x) ;} while (0)
|
||||
# define LOG_A LOG_I
|
||||
# define LOG_D(c, x...) do { if( g_log->log_component[c].level >= OAILOG_DEBUG ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_DEBUG, x) ;} while (0)
|
||||
# define LOG_T(c, x...) do { if( g_log->log_component[c].level >= OAILOG_TRACE ) logRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, OAILOG_TRACE, x) ;} while (0)
|
||||
# define VLOG(c,l, f, args) do { if( g_log->log_component[c].level >= l ) vlogRecord_mt(__FILE__, __FUNCTION__, __LINE__,c, l, f, args) ; } while (0)
|
||||
@@ -436,6 +464,8 @@ int32_t write_file_matlab(const char *fname, const char *vname, void *data, int
|
||||
# define LOG_VAR(A,B) A B
|
||||
# define T_ACTIVE(a) (0)
|
||||
# endif /* T_TRACER */
|
||||
#endif // LOG_MINIMAL
|
||||
|
||||
/* avoid warnings for variables only used in LOG macro's but set outside debug section */
|
||||
#define GCC_NOTUSED __attribute__((unused))
|
||||
#define LOG_USEDINLOG_VAR(A,B) GCC_NOTUSED A B
|
||||
|
||||
+6
-1
@@ -217,6 +217,11 @@ void T_Config_Init(void) {
|
||||
sizeof(ttraceparams) / sizeof(paramdef_t),
|
||||
NULL);
|
||||
|
||||
if (T_stdout == 0)
|
||||
if (T_stdout < 0 || T_stdout > 2) {
|
||||
printf("fatal error: T_stdout = %d but only values 0, 1, or 2 are allowed\n", T_stdout);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (T_stdout == 0 || T_stdout == 2)
|
||||
T_init(T_port, 1-T_nowait, T_dont_fork);
|
||||
}
|
||||
|
||||
+2
-2
@@ -100,7 +100,7 @@ extern int T_stdout;
|
||||
20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0)(__VA_ARGS__)
|
||||
#define TN_N(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,\
|
||||
n18,n19,n20,n21,n22,n23,n24,n25,n26,n27,n28,n29,n30,n31,n32,n,...) T##n
|
||||
#define T(...) do { if (T_stdout == 0) TN(__VA_ARGS__); } while (0)
|
||||
#define T(...) do { if (T_stdout == 0 || T_stdout == 2) TN(__VA_ARGS__); } while (0)
|
||||
|
||||
/* type used to send arbitrary buffer data */
|
||||
typedef struct {
|
||||
@@ -607,7 +607,7 @@ extern int *T_active;
|
||||
{"T_port", CONFIG_HLP_TPORT, 0, iptr:&T_port, defintval:TTRACER_DEFAULT_PORTNUM, TYPE_INT, 0},\
|
||||
{"T_nowait", CONFIG_HLP_NOTWAIT, PARAMFLAG_BOOL, iptr:&T_nowait, defintval:0, TYPE_INT, 0},\
|
||||
{"T_dont_fork", CONFIG_HLP_TNOFORK, PARAMFLAG_BOOL, iptr:&T_dont_fork, defintval:0, TYPE_INT, 0},\
|
||||
{"T_stdout", CONFIG_HLP_STDOUT, PARAMFLAG_BOOL, iptr:&T_stdout, defintval:1, TYPE_INT, 0},\
|
||||
{"T_stdout", CONFIG_HLP_STDOUT, 0, iptr:&T_stdout, defintval:1, TYPE_INT, 0},\
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -155,6 +155,10 @@ ID = GNB_MAC_DL_RAR_PDU_WITH_DATA
|
||||
DESC = NR MAC downlink PDU for RAR
|
||||
GROUP = ALL:MAC:GNB:WIRESHARK
|
||||
FORMAT = int,gNB_ID : int,CC_id : int,rnti : int,frame : int,slot : int,harq_pid : buffer,data
|
||||
ID = GNB_MAC_RETRANSMISSION_DL_PDU_WITH_DATA
|
||||
DESC = NR MAC downlink retransmitted PDU for an UE
|
||||
GROUP = ALL:MAC:GNB:WIRESHARK
|
||||
FORMAT = int,gNB_ID : int,CC_id : int,rnti : int,frame : int,slot : int,harq_pid : int,round : buffer,data
|
||||
|
||||
#RLC logs
|
||||
ID = ENB_RLC_DL
|
||||
@@ -1057,6 +1061,48 @@ ID = LEGACY_NFAPI_PNF_TRACE
|
||||
DESC = NFAPI_PNF legacy logs - trace level
|
||||
GROUP = ALL:LEGACY_NFAPI_PNF:LEGACY_GROUP_TRACE:LEGACY
|
||||
FORMAT = string,log
|
||||
|
||||
ID = LEGACY_ITTI_INFO
|
||||
DESC = ITTI legacy logs - info level
|
||||
GROUP = ALL:LEGACY_ITTI:LEGACY_GROUP_INFO:LEGACY
|
||||
FORMAT = string,log
|
||||
ID = LEGACY_ITTI_ERROR
|
||||
DESC = ITTI legacy logs - error level
|
||||
GROUP = ALL:LEGACY_ITTI:LEGACY_GROUP_ERROR:LEGACY
|
||||
FORMAT = string,log
|
||||
ID = LEGACY_ITTI_WARNING
|
||||
DESC = ITTI legacy logs - warning level
|
||||
GROUP = ALL:LEGACY_ITTI:LEGACY_GROUP_WARNING:LEGACY
|
||||
FORMAT = string,log
|
||||
ID = LEGACY_ITTI_DEBUG
|
||||
DESC = ITTI legacy logs - debug level
|
||||
GROUP = ALL:LEGACY_ITTI:LEGACY_GROUP_DEBUG:LEGACY
|
||||
FORMAT = string,log
|
||||
ID = LEGACY_ITTI_TRACE
|
||||
DESC = ITTI legacy logs - trace level
|
||||
GROUP = ALL:LEGACY_ITTI:LEGACY_GROUP_TRACE:LEGACY
|
||||
FORMAT = string,log
|
||||
|
||||
ID = LEGACY_UTIL_INFO
|
||||
DESC = UTIL legacy logs - info level
|
||||
GROUP = ALL:LEGACY_UTIL:LEGACY_GROUP_INFO:LEGACY
|
||||
FORMAT = string,log
|
||||
ID = LEGACY_UTIL_ERROR
|
||||
DESC = UTIL legacy logs - error level
|
||||
GROUP = ALL:LEGACY_UTIL:LEGACY_GROUP_ERROR:LEGACY
|
||||
FORMAT = string,log
|
||||
ID = LEGACY_UTIL_WARNING
|
||||
DESC = UTIL legacy logs - warning level
|
||||
GROUP = ALL:LEGACY_UTIL:LEGACY_GROUP_WARNING:LEGACY
|
||||
FORMAT = string,log
|
||||
ID = LEGACY_UTIL_DEBUG
|
||||
DESC = UTIL legacy logs - debug level
|
||||
GROUP = ALL:LEGACY_UTIL:LEGACY_GROUP_DEBUG:LEGACY
|
||||
FORMAT = string,log
|
||||
ID = LEGACY_UTIL_TRACE
|
||||
DESC = UTIL legacy logs - trace level
|
||||
GROUP = ALL:LEGACY_UTIL:LEGACY_GROUP_TRACE:LEGACY
|
||||
FORMAT = string,log
|
||||
# this is a bad hack but I won't fix (function util_print_hex_octets
|
||||
# in openairinterface5g/openair2/LAYER2/PDCP_v10.1.0/pdcp_util.c
|
||||
# does funky things with the LOG_x macros but we work on the C pre-processor
|
||||
|
||||
@@ -59,12 +59,20 @@ typedef struct {
|
||||
int nr_ul_rnti;
|
||||
int nr_ul_frame;
|
||||
int nr_ul_slot;
|
||||
int nr_ul_harq_pid;
|
||||
int nr_ul_data;
|
||||
/* NR dl */
|
||||
int nr_dl_rnti;
|
||||
int nr_dl_frame;
|
||||
int nr_dl_slot;
|
||||
int nr_dl_harq_pid;
|
||||
int nr_dl_data;
|
||||
/* NR dl retx */
|
||||
int nr_dl_retx_rnti;
|
||||
int nr_dl_retx_frame;
|
||||
int nr_dl_retx_slot;
|
||||
int nr_dl_retx_harq_pid;
|
||||
int nr_dl_retx_data;
|
||||
/* NR mib */
|
||||
int nr_mib_frame;
|
||||
int nr_mib_slot;
|
||||
@@ -254,6 +262,7 @@ void sr(void *_d, event e)
|
||||
#define MAC_NR_PAYLOAD_TAG 0x01
|
||||
#define MAC_NR_RNTI_TAG 0x02
|
||||
#define MAC_NR_UEID_TAG 0x03
|
||||
#define MAC_NR_HARQID 0x06
|
||||
#define MAC_NR_FRAME_SLOT_TAG 0x07
|
||||
|
||||
#define NR_FDD_RADIO 1
|
||||
@@ -267,7 +276,8 @@ void sr(void *_d, event e)
|
||||
#define NR_C_RNTI 3
|
||||
|
||||
void trace_nr(ev_data *d, int direction, int rnti_type, int rnti,
|
||||
int frame, int slot, void *buf, int bufsize, int preamble)
|
||||
int frame, int slot, int harq_pid, void *buf, int bufsize,
|
||||
int preamble)
|
||||
{
|
||||
ssize_t ret;
|
||||
int i;
|
||||
@@ -307,6 +317,8 @@ void trace_nr(ev_data *d, int direction, int rnti_type, int rnti,
|
||||
PUTC(&d->buf, frame & 255);
|
||||
PUTC(&d->buf, (slot>>8) & 255);
|
||||
PUTC(&d->buf, slot & 255);
|
||||
PUTC(&d->buf, MAC_NR_HARQID);
|
||||
PUTC(&d->buf, harq_pid);
|
||||
#endif
|
||||
|
||||
PUTC(&d->buf, MAC_NR_PAYLOAD_TAG);
|
||||
@@ -326,7 +338,8 @@ void nr_ul(void *_d, event e)
|
||||
|
||||
trace_nr(d, NR_DIRECTION_UPLINK, NR_C_RNTI, e.e[d->nr_ul_rnti].i,
|
||||
e.e[d->nr_ul_frame].i, e.e[d->nr_ul_slot].i,
|
||||
e.e[d->nr_ul_data].b, e.e[d->nr_ul_data].bsize, NO_PREAMBLE);
|
||||
e.e[d->nr_ul_harq_pid].i, e.e[d->nr_ul_data].b,
|
||||
e.e[d->nr_ul_data].bsize, NO_PREAMBLE);
|
||||
}
|
||||
|
||||
void nr_dl(void *_d, event e)
|
||||
@@ -335,7 +348,18 @@ void nr_dl(void *_d, event e)
|
||||
|
||||
trace_nr(d, NR_DIRECTION_DOWNLINK, NR_C_RNTI, e.e[d->nr_dl_rnti].i,
|
||||
e.e[d->nr_dl_frame].i, e.e[d->nr_dl_slot].i,
|
||||
e.e[d->nr_dl_data].b, e.e[d->nr_dl_data].bsize, NO_PREAMBLE);
|
||||
e.e[d->nr_dl_harq_pid].i, e.e[d->nr_dl_data].b,
|
||||
e.e[d->nr_dl_data].bsize, NO_PREAMBLE);
|
||||
}
|
||||
|
||||
void nr_dl_retx(void *_d, event e)
|
||||
{
|
||||
ev_data *d = _d;
|
||||
|
||||
trace_nr(d, NR_DIRECTION_DOWNLINK, NR_C_RNTI, e.e[d->nr_dl_retx_rnti].i,
|
||||
e.e[d->nr_dl_retx_frame].i, e.e[d->nr_dl_retx_slot].i,
|
||||
e.e[d->nr_dl_retx_harq_pid].i, e.e[d->nr_dl_retx_data].b,
|
||||
e.e[d->nr_dl_retx_data].bsize, NO_PREAMBLE);
|
||||
}
|
||||
|
||||
void nr_mib(void *_d, event e)
|
||||
@@ -349,7 +373,7 @@ void nr_mib(void *_d, event e)
|
||||
d->cur_mib++;
|
||||
|
||||
trace_nr(d, NR_DIRECTION_DOWNLINK, NR_NO_RNTI, 0,
|
||||
e.e[d->nr_mib_frame].i, e.e[d->nr_mib_slot].i,
|
||||
e.e[d->nr_mib_frame].i, e.e[d->nr_mib_slot].i, 0 /* harq pid */,
|
||||
e.e[d->nr_mib_data].b, e.e[d->nr_mib_data].bsize, NO_PREAMBLE);
|
||||
}
|
||||
|
||||
@@ -358,7 +382,7 @@ void nr_rar(void *_d, event e)
|
||||
ev_data *d = _d;
|
||||
|
||||
trace_nr(d, NR_DIRECTION_DOWNLINK, NR_RA_RNTI, e.e[d->nr_rar_rnti].i,
|
||||
e.e[d->nr_rar_frame].i, e.e[d->nr_rar_slot].i,
|
||||
e.e[d->nr_rar_frame].i, e.e[d->nr_rar_slot].i, 0 /* harq pid */,
|
||||
e.e[d->nr_rar_data].b, e.e[d->nr_rar_data].bsize, NO_PREAMBLE);
|
||||
}
|
||||
|
||||
@@ -367,47 +391,55 @@ void nr_rar(void *_d, event e)
|
||||
|
||||
void setup_data(ev_data *d, void *database, int ul_id, int dl_id, int mib_id,
|
||||
int preamble_id, int rar_id, int sr_id,
|
||||
int nr_ul_id, int nr_dl_id, int nr_mib_id, int nr_rar_id)
|
||||
int nr_ul_id, int nr_dl_id, int nr_dl_retx_id, int nr_mib_id,
|
||||
int nr_rar_id)
|
||||
{
|
||||
database_event_format f;
|
||||
int i;
|
||||
d->ul_rnti = -1;
|
||||
d->ul_frame = -1;
|
||||
d->ul_subframe = -1;
|
||||
d->ul_data = -1;
|
||||
d->dl_rnti = -1;
|
||||
d->dl_frame = -1;
|
||||
d->dl_subframe = -1;
|
||||
d->dl_data = -1;
|
||||
d->mib_frame = -1;
|
||||
d->mib_subframe = -1;
|
||||
d->mib_data = -1;
|
||||
d->preamble_frame = -1;
|
||||
d->preamble_subframe = -1;
|
||||
d->preamble_preamble = -1;
|
||||
d->rar_rnti = -1;
|
||||
d->rar_frame = -1;
|
||||
d->rar_subframe = -1;
|
||||
d->rar_data = -1;
|
||||
d->sr_rnti = -1;
|
||||
d->sr_frame = -1;
|
||||
d->sr_subframe = -1;
|
||||
d->ul_rnti = -1;
|
||||
d->ul_frame = -1;
|
||||
d->ul_subframe = -1;
|
||||
d->ul_data = -1;
|
||||
d->dl_rnti = -1;
|
||||
d->dl_frame = -1;
|
||||
d->dl_subframe = -1;
|
||||
d->dl_data = -1;
|
||||
d->mib_frame = -1;
|
||||
d->mib_subframe = -1;
|
||||
d->mib_data = -1;
|
||||
d->preamble_frame = -1;
|
||||
d->preamble_subframe = -1;
|
||||
d->preamble_preamble = -1;
|
||||
d->rar_rnti = -1;
|
||||
d->rar_frame = -1;
|
||||
d->rar_subframe = -1;
|
||||
d->rar_data = -1;
|
||||
d->sr_rnti = -1;
|
||||
d->sr_frame = -1;
|
||||
d->sr_subframe = -1;
|
||||
|
||||
d->nr_ul_rnti = -1;
|
||||
d->nr_ul_frame = -1;
|
||||
d->nr_ul_slot = -1;
|
||||
d->nr_ul_data = -1;
|
||||
d->nr_dl_rnti = -1;
|
||||
d->nr_dl_frame = -1;
|
||||
d->nr_dl_slot = -1;
|
||||
d->nr_dl_data = -1;
|
||||
d->nr_mib_frame = -1;
|
||||
d->nr_mib_slot = -1;
|
||||
d->nr_mib_data = -1;
|
||||
d->nr_rar_rnti = -1;
|
||||
d->nr_rar_frame = -1;
|
||||
d->nr_rar_slot = -1;
|
||||
d->nr_rar_data = -1;
|
||||
d->nr_ul_rnti = -1;
|
||||
d->nr_ul_frame = -1;
|
||||
d->nr_ul_slot = -1;
|
||||
d->nr_ul_harq_pid = -1;
|
||||
d->nr_ul_data = -1;
|
||||
d->nr_dl_rnti = -1;
|
||||
d->nr_dl_frame = -1;
|
||||
d->nr_dl_slot = -1;
|
||||
d->nr_dl_harq_pid = -1;
|
||||
d->nr_dl_data = -1;
|
||||
d->nr_dl_retx_rnti = -1;
|
||||
d->nr_dl_retx_frame = -1;
|
||||
d->nr_dl_retx_slot = -1;
|
||||
d->nr_dl_retx_harq_pid = -1;
|
||||
d->nr_dl_retx_data = -1;
|
||||
d->nr_mib_frame = -1;
|
||||
d->nr_mib_slot = -1;
|
||||
d->nr_mib_data = -1;
|
||||
d->nr_rar_rnti = -1;
|
||||
d->nr_rar_frame = -1;
|
||||
d->nr_rar_slot = -1;
|
||||
d->nr_rar_data = -1;
|
||||
|
||||
#define G(var_name, var_type, var) \
|
||||
if (!strcmp(f.name[i], var_name)) { \
|
||||
@@ -490,32 +522,50 @@ void setup_data(ev_data *d, void *database, int ul_id, int dl_id, int mib_id,
|
||||
if (d->sr_rnti == -1 || d->sr_frame == -1 || d->sr_subframe == -1)
|
||||
goto error;
|
||||
|
||||
/* NR ul: rnti, frame, slot, data */
|
||||
/* NR ul: rnti, frame, slot, harq_pid, data */
|
||||
f = get_format(database, nr_ul_id);
|
||||
|
||||
for (i = 0; i < f.count; i++) {
|
||||
G("rnti", "int", d->nr_ul_rnti);
|
||||
G("frame", "int", d->nr_ul_frame);
|
||||
G("slot", "int", d->nr_ul_slot);
|
||||
G("data", "buffer", d->nr_ul_data);
|
||||
G("rnti", "int", d->nr_ul_rnti);
|
||||
G("frame", "int", d->nr_ul_frame);
|
||||
G("slot", "int", d->nr_ul_slot);
|
||||
G("harq_pid", "int", d->nr_ul_harq_pid);
|
||||
G("data", "buffer", d->nr_ul_data);
|
||||
}
|
||||
|
||||
if (d->nr_ul_rnti == -1 || d->nr_ul_frame == -1 || d->nr_ul_slot == -1 ||
|
||||
d->nr_ul_data == -1)
|
||||
d->nr_ul_harq_pid == -1 || d->nr_ul_data == -1)
|
||||
goto error;
|
||||
|
||||
/* NR dl: rnti, frame, slot, data */
|
||||
/* NR dl: rnti, frame, slot, harq_pid, data */
|
||||
f = get_format(database, nr_dl_id);
|
||||
|
||||
for (i = 0; i < f.count; i++) {
|
||||
G("rnti", "int", d->nr_dl_rnti);
|
||||
G("frame", "int", d->nr_dl_frame);
|
||||
G("slot", "int", d->nr_dl_slot);
|
||||
G("data", "buffer", d->nr_dl_data);
|
||||
G("rnti", "int", d->nr_dl_rnti);
|
||||
G("frame", "int", d->nr_dl_frame);
|
||||
G("slot", "int", d->nr_dl_slot);
|
||||
G("harq_pid", "int", d->nr_dl_harq_pid);
|
||||
G("data", "buffer", d->nr_dl_data);
|
||||
}
|
||||
|
||||
if (d->nr_dl_rnti == -1 || d->nr_dl_frame == -1 || d->nr_dl_slot == -1 ||
|
||||
d->nr_dl_data == -1)
|
||||
d->nr_dl_harq_pid == -1 || d->nr_dl_data == -1)
|
||||
goto error;
|
||||
|
||||
/* NR dl retx: rnti, frame, slot, harq_pid, data */
|
||||
f = get_format(database, nr_dl_retx_id);
|
||||
|
||||
for (i = 0; i < f.count; i++) {
|
||||
G("rnti", "int", d->nr_dl_retx_rnti);
|
||||
G("frame", "int", d->nr_dl_retx_frame);
|
||||
G("slot", "int", d->nr_dl_retx_slot);
|
||||
G("harq_pid", "int", d->nr_dl_retx_harq_pid);
|
||||
G("data", "buffer", d->nr_dl_retx_data);
|
||||
}
|
||||
|
||||
if (d->nr_dl_retx_rnti == -1 || d->nr_dl_retx_frame == -1 ||
|
||||
d->nr_dl_retx_slot == -1 || d->nr_dl_retx_harq_pid == -1 ||
|
||||
d->nr_dl_retx_data == -1)
|
||||
goto error;
|
||||
|
||||
/* NR MIB: frame, slot, data */
|
||||
@@ -612,7 +662,7 @@ int main(int n, char **v)
|
||||
int in;
|
||||
int i;
|
||||
int ul_id, dl_id, mib_id, preamble_id, rar_id;
|
||||
int nr_ul_id, nr_dl_id, nr_mib_id, nr_rar_id;
|
||||
int nr_ul_id, nr_dl_id, nr_dl_retx_id, nr_mib_id, nr_rar_id;
|
||||
int sr_id;
|
||||
ev_data d;
|
||||
char *ip = DEFAULT_IP;
|
||||
@@ -692,6 +742,7 @@ int main(int n, char **v)
|
||||
|
||||
on_off(database, "GNB_MAC_UL_PDU_WITH_DATA", is_on, 1);
|
||||
on_off(database, "GNB_MAC_DL_PDU_WITH_DATA", is_on, 1);
|
||||
on_off(database, "GNB_MAC_RETRANSMISSION_DL_PDU_WITH_DATA", is_on, 1);
|
||||
on_off(database, "GNB_PHY_MIB", is_on, 1);
|
||||
on_off(database, "GNB_MAC_DL_RAR_PDU_WITH_DATA", is_on, 1);
|
||||
|
||||
@@ -715,11 +766,12 @@ int main(int n, char **v)
|
||||
|
||||
nr_ul_id = event_id_from_name(database, "GNB_MAC_UL_PDU_WITH_DATA");
|
||||
nr_dl_id = event_id_from_name(database, "GNB_MAC_DL_PDU_WITH_DATA");
|
||||
nr_dl_retx_id = event_id_from_name(database, "GNB_MAC_RETRANSMISSION_DL_PDU_WITH_DATA");
|
||||
nr_mib_id = event_id_from_name(database, "GNB_PHY_MIB");
|
||||
nr_rar_id = event_id_from_name(database, "GNB_MAC_DL_RAR_PDU_WITH_DATA");
|
||||
|
||||
setup_data(&d, database, ul_id, dl_id, mib_id, preamble_id, rar_id, sr_id,
|
||||
nr_ul_id, nr_dl_id, nr_mib_id, nr_rar_id);
|
||||
nr_ul_id, nr_dl_id, nr_dl_retx_id, nr_mib_id, nr_rar_id);
|
||||
|
||||
register_handler_function(h, ul_id, ul, &d);
|
||||
register_handler_function(h, dl_id, dl, &d);
|
||||
@@ -730,6 +782,7 @@ int main(int n, char **v)
|
||||
|
||||
register_handler_function(h, nr_ul_id, nr_ul, &d);
|
||||
register_handler_function(h, nr_dl_id, nr_dl, &d);
|
||||
register_handler_function(h, nr_dl_retx_id, nr_dl_retx, &d);
|
||||
register_handler_function(h, nr_mib_id, nr_mib, &d);
|
||||
register_handler_function(h, nr_rar_id, nr_rar, &d);
|
||||
|
||||
@@ -753,10 +806,11 @@ int main(int n, char **v)
|
||||
|
||||
if (e.type == -1) break;
|
||||
|
||||
if (!(e.type == ul_id || e.type == dl_id || e.type == mib_id ||
|
||||
e.type == preamble_id || e.type == rar_id || e.type == sr_id ||
|
||||
e.type == nr_ul_id || e.type == nr_dl_id ||
|
||||
e.type == nr_mib_id || e.type == nr_rar_id)) continue;
|
||||
if (!(e.type == ul_id || e.type == dl_id || e.type == mib_id ||
|
||||
e.type == preamble_id || e.type == rar_id || e.type == sr_id ||
|
||||
e.type == nr_ul_id || e.type == nr_dl_id ||
|
||||
e.type == nr_dl_retx_id || e.type == nr_mib_id ||
|
||||
e.type == nr_rar_id)) continue;
|
||||
|
||||
handle_event(h, e);
|
||||
}
|
||||
|
||||
@@ -26,17 +26,10 @@
|
||||
#include <stdlib.h>
|
||||
#include <inttypes.h>
|
||||
#include <platform_types.h>
|
||||
#include "backtrace.h"
|
||||
|
||||
#if defined(ENB_MODE)
|
||||
# define display_backtrace()
|
||||
#else
|
||||
# include "backtrace.h"
|
||||
#endif
|
||||
|
||||
void output_log_mem(void);
|
||||
#define _Assert_Exit_ \
|
||||
fprintf(stderr, "\nExiting execution\n"); \
|
||||
display_backtrace(); \
|
||||
fflush(stdout); \
|
||||
fflush(stderr); \
|
||||
abort();
|
||||
|
||||
@@ -28,7 +28,7 @@
|
||||
#include <signal.h>
|
||||
#include <execinfo.h>
|
||||
|
||||
#include "backtrace.h"
|
||||
#include <common/utils/backtrace.h>
|
||||
|
||||
/* Obtain a backtrace and print it to stdout. */
|
||||
void display_backtrace(void) {
|
||||
@@ -49,8 +49,3 @@ void display_backtrace(void) {
|
||||
|
||||
free(strings);
|
||||
}
|
||||
|
||||
void backtrace_handle_signal(siginfo_t *info) {
|
||||
display_backtrace();
|
||||
//exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
@@ -26,10 +26,7 @@
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void display_backtrace(void);
|
||||
|
||||
void backtrace_handle_signal(siginfo_t *info);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
+60
-28
@@ -42,7 +42,7 @@ const char *duplex_mode[]={"FDD","TDD"};
|
||||
// - N_OFFs for bands from 80 to 89 and band 95 is referred to UL
|
||||
// - Frequencies are expressed in KHz
|
||||
// - col: NR_band ul_min ul_max dl_min dl_max step N_OFFs_DL deltaf_raster
|
||||
nr_bandentry_t nr_bandtable[] = {
|
||||
const nr_bandentry_t nr_bandtable[] = {
|
||||
{1, 1920000, 1980000, 2110000, 2170000, 20, 422000, 100},
|
||||
{2, 1850000, 1910000, 1930000, 1990000, 20, 386000, 100},
|
||||
{3, 1710000, 1785000, 1805000, 1880000, 20, 361000, 100},
|
||||
@@ -117,7 +117,7 @@ uint16_t get_band(uint64_t downlink_frequency, int32_t delta_duplex)
|
||||
uint64_t center_freq_diff_khz = 999999999999999999; // 2^64
|
||||
uint16_t current_band = 0;
|
||||
|
||||
for (int ind = 0; ind < nr_bandtable_size; ind++) {
|
||||
for (int ind = 0; ind < sizeofArray(nr_bandtable); ind++) {
|
||||
|
||||
if (dl_freq_khz < nr_bandtable[ind].dl_min || dl_freq_khz > nr_bandtable[ind].dl_max)
|
||||
continue;
|
||||
@@ -143,8 +143,6 @@ uint16_t get_band(uint64_t downlink_frequency, int32_t delta_duplex)
|
||||
return current_band;
|
||||
}
|
||||
|
||||
const size_t nr_bandtable_size = sizeof(nr_bandtable) / sizeof(nr_bandentry_t);
|
||||
|
||||
int NRRIV2BW(int locationAndBandwidth,int N_RB) {
|
||||
int tmp = locationAndBandwidth/N_RB;
|
||||
int tmp2 = locationAndBandwidth%N_RB;
|
||||
@@ -256,6 +254,48 @@ void get_coreset_rballoc(uint8_t *FreqDomainResource,int *n_rb,int *rb_offset) {
|
||||
*n_rb = 6*count;
|
||||
}
|
||||
|
||||
int get_nb_periods_per_frame(uint8_t tdd_period) {
|
||||
|
||||
int nb_periods_per_frame;
|
||||
switch(tdd_period) {
|
||||
case 0:
|
||||
nb_periods_per_frame = 20; // 10ms/0p5ms
|
||||
break;
|
||||
|
||||
case 1:
|
||||
nb_periods_per_frame = 16; // 10ms/0p625ms
|
||||
break;
|
||||
|
||||
case 2:
|
||||
nb_periods_per_frame = 10; // 10ms/1ms
|
||||
break;
|
||||
|
||||
case 3:
|
||||
nb_periods_per_frame = 8; // 10ms/1p25ms
|
||||
break;
|
||||
|
||||
case 4:
|
||||
nb_periods_per_frame = 5; // 10ms/2ms
|
||||
break;
|
||||
|
||||
case 5:
|
||||
nb_periods_per_frame = 4; // 10ms/2p5ms
|
||||
break;
|
||||
|
||||
case 6:
|
||||
nb_periods_per_frame = 2; // 10ms/5ms
|
||||
break;
|
||||
|
||||
case 7:
|
||||
nb_periods_per_frame = 1; // 10ms/10ms
|
||||
break;
|
||||
|
||||
default:
|
||||
AssertFatal(1==0,"Undefined tdd period %d\n", tdd_period);
|
||||
}
|
||||
return nb_periods_per_frame;
|
||||
}
|
||||
|
||||
|
||||
int get_dmrs_port(int nl, uint16_t dmrs_ports) {
|
||||
|
||||
@@ -275,14 +315,6 @@ int get_dmrs_port(int nl, uint16_t dmrs_ports) {
|
||||
return p;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
lte_frame_type_t get_frame_type(uint16_t current_band, uint8_t scs_index)
|
||||
{
|
||||
lte_frame_type_t current_type;
|
||||
@@ -424,31 +456,27 @@ uint16_t config_bandwidth(int mu, int nb_rb, int nr_band)
|
||||
|
||||
// Returns the corresponding row index of the NR table
|
||||
int get_nr_table_idx(int nr_bandP, uint8_t scs_index) {
|
||||
int i, j;
|
||||
int scs_khz = 15 << scs_index;
|
||||
int supplementary_bands[] = {29,75,76,80,81,82,83,84,86,89,95};
|
||||
size_t s = sizeof(supplementary_bands)/sizeof(supplementary_bands[0]);
|
||||
|
||||
for(j = 0; j < s; j++){
|
||||
for(int j = 0; j < sizeofArray(supplementary_bands); j++){
|
||||
if (nr_bandP == supplementary_bands[j])
|
||||
AssertFatal(0 == 1, "Band %d is a supplementary band (%d). This is not supported yet.\n", nr_bandP, supplementary_bands[j]);
|
||||
}
|
||||
|
||||
AssertFatal(nr_bandP <= nr_bandtable[nr_bandtable_size-1].band, "NR band %d exceeds NR bands table maximum limit %d\n", nr_bandP, nr_bandtable[nr_bandtable_size-1].band);
|
||||
for (i = 0; i < nr_bandtable_size && nr_bandtable[i].band != nr_bandP; i++);
|
||||
|
||||
// In frequency bands with two deltaFRaster,
|
||||
// the higher deltaFRaster applies to channels using only the SCS that is equal to or larger than the higher deltaFRaster
|
||||
// and SSB SCS is equal to the higher deltaFRaster.
|
||||
while(((i+1)<nr_bandtable_size) &&
|
||||
(nr_bandtable[i+1].band == nr_bandtable[i].band) &&
|
||||
(nr_bandtable[i].deltaf_raster != scs_khz)) {
|
||||
i++;
|
||||
int i;
|
||||
for (i = 0; i < sizeofArray(nr_bandtable); i++) {
|
||||
if ( nr_bandtable[i].band == nr_bandP && nr_bandtable[i].deltaf_raster == scs_khz )
|
||||
break;
|
||||
}
|
||||
|
||||
AssertFatal(nr_bandtable[i].band == nr_bandP, "Found band table %d does not correspond to the input one %d\n",nr_bandtable[i].band,nr_bandP);
|
||||
|
||||
if (i == sizeofArray(nr_bandtable)) {
|
||||
LOG_I(PHY, "not found same deltaf_raster == scs_khz, use only band and last deltaf_raster \n");
|
||||
for(i=sizeofArray(nr_bandtable)-1; i >=0; i--)
|
||||
if ( nr_bandtable[i].band == nr_bandP )
|
||||
break;
|
||||
}
|
||||
|
||||
AssertFatal(i > 0 && i < sizeofArray(nr_bandtable), "band is not existing: %d\n",nr_bandP);
|
||||
LOG_D(PHY, "NR band table index %d (Band %d, dl_min %lu, ul_min %lu)\n", i, nr_bandtable[i].band, nr_bandtable[i].dl_min,nr_bandtable[i].ul_min);
|
||||
|
||||
return i;
|
||||
@@ -472,6 +500,10 @@ int get_subband_size(int NPRB,int size) {
|
||||
|
||||
}
|
||||
|
||||
int get_SLIV(uint8_t S, uint8_t L) {
|
||||
return ( (uint16_t)(((L-1)<=7)? (14*(L-1)+S) : (14*(15-L)+(13-S))) );
|
||||
}
|
||||
|
||||
void SLIV2SL(int SLIV,int *S,int *L) {
|
||||
|
||||
int SLIVdiv14 = SLIV/14;
|
||||
|
||||
@@ -48,11 +48,18 @@ typedef struct nr_bandentry_s {
|
||||
uint8_t deltaf_raster;
|
||||
} nr_bandentry_t;
|
||||
|
||||
extern const size_t nr_bandtable_size;
|
||||
extern nr_bandentry_t nr_bandtable[];
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
int get_SLIV(uint8_t S, uint8_t L);
|
||||
void get_coreset_rballoc(uint8_t *FreqDomainResource,int *n_rb,int *rb_offset);
|
||||
int get_num_dmrs(uint16_t dmrs_mask);
|
||||
uint16_t config_bandwidth(int mu, int nb_rb, int nr_band);
|
||||
int get_nr_table_idx(int nr_bandP, uint8_t scs_index);
|
||||
int32_t get_delta_duplex(int nr_bandP, uint8_t scs_index);
|
||||
@@ -71,6 +78,7 @@ uint32_t nr_get_code_rate(uint8_t Imcs, uint8_t table_idx);
|
||||
int get_subband_size(int NPRB,int size);
|
||||
void SLIV2SL(int SLIV,int *S,int *L);
|
||||
int get_dmrs_port(int nl, uint16_t dmrs_ports);
|
||||
int get_nb_periods_per_frame(uint8_t tdd_period);
|
||||
|
||||
#define CEILIDIV(a,b) ((a+b-1)/b)
|
||||
#define ROUNDIDIV(a,b) (((a<<1)+b)/(b<<1))
|
||||
|
||||
@@ -136,12 +136,12 @@ extern "C" {
|
||||
LOG_E(TMR,"Queue for %s task contains %ld messages\n", itti_get_task_name(destination_task_id), s );
|
||||
|
||||
if ( s > 50 )
|
||||
LOG_I(TMR,"Queue for %s task size: %ld (last message %s)\n",itti_get_task_name(destination_task_id), s+1,ITTI_MSG_NAME(message));
|
||||
LOG_I(ITTI,"Queue for %s task size: %ld (last message %s)\n",itti_get_task_name(destination_task_id), s+1,ITTI_MSG_NAME(message));
|
||||
|
||||
t->message_queue.insert(t->message_queue.begin(), message);
|
||||
eventfd_t sem_counter = 1;
|
||||
AssertFatal ( sizeof(sem_counter) == write(t->sem_fd, &sem_counter, sizeof(sem_counter)), "");
|
||||
LOG_D(TMR,"sent messages id=%d to %s\n",message_id, t->admin.name);
|
||||
LOG_D(ITTI,"sent messages id=%d to %s\n",message_id, t->admin.name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -152,7 +152,7 @@ extern "C" {
|
||||
|
||||
while ( t->message_queue.size()>0 && t->admin.func != NULL ) {
|
||||
if (t->message_queue.size()>1)
|
||||
LOG_W(TMR,"queue in no thread mode is %ld\n", t->message_queue.size());
|
||||
LOG_W(ITTI,"queue in no thread mode is %ld\n", t->message_queue.size());
|
||||
|
||||
pthread_mutex_unlock (&t->queue_cond_lock);
|
||||
t->admin.func(NULL);
|
||||
@@ -208,7 +208,7 @@ extern "C" {
|
||||
message->ittiMsg.timer_has_expired.arg=it->second.timer_arg;
|
||||
|
||||
if (itti_send_msg_to_task_locked(task_id, it->second.instance, message) < 0) {
|
||||
LOG_W(TMR,"Failed to send msg TIMER_HAS_EXPIRED to task %u\n", task_id);
|
||||
LOG_W(ITTI,"Failed to send msg TIMER_HAS_EXPIRED to task %u\n", task_id);
|
||||
free(message);
|
||||
t->timer_map.erase(it);
|
||||
return -1;
|
||||
@@ -233,7 +233,7 @@ extern "C" {
|
||||
epoll_timeout = t->next_timer-current_time;
|
||||
|
||||
pthread_mutex_unlock(&t->queue_cond_lock);
|
||||
LOG_D(TMR,"enter blocking wait for %s\n", itti_get_task_name(task_id));
|
||||
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);
|
||||
|
||||
if ( t->nb_events < 0 && (errno == EINTR || errno == EAGAIN ) )
|
||||
@@ -243,7 +243,7 @@ extern "C" {
|
||||
AssertFatal (t->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(TMR,"receive on %d descriptors for %s\n", t->nb_events, itti_get_task_name(task_id));
|
||||
LOG_D(ITTI,"receive on %d descriptors for %s\n", t->nb_events, itti_get_task_name(task_id));
|
||||
|
||||
if (t->nb_events == 0)
|
||||
/* No data to read -> return */
|
||||
@@ -292,11 +292,11 @@ extern "C" {
|
||||
// in this case, *received_msg is NULL
|
||||
if (t->message_queue.empty()) {
|
||||
*received_msg=NULL;
|
||||
LOG_D(TMR,"task %s received even from other fd (total fds: %d), returning msg NULL\n",t->admin.name, t->nb_fd_epoll);
|
||||
LOG_D(ITTI,"task %s received even from other fd (total fds: %d), returning msg NULL\n",t->admin.name, t->nb_fd_epoll);
|
||||
} else {
|
||||
*received_msg=t->message_queue.back();
|
||||
t->message_queue.pop_back();
|
||||
LOG_D(TMR,"task %s received a message\n",t->admin.name);
|
||||
LOG_D(ITTI,"task %s received a message\n",t->admin.name);
|
||||
}
|
||||
|
||||
pthread_mutex_unlock (&t->queue_cond_lock);
|
||||
@@ -308,7 +308,7 @@ extern "C" {
|
||||
pthread_mutex_lock(&t->queue_cond_lock);
|
||||
|
||||
if (!t->message_queue.empty()) {
|
||||
LOG_D(TMR,"task %s received a message in polling mode\n",t->admin.name);
|
||||
LOG_D(ITTI,"task %s received a message in polling mode\n",t->admin.name);
|
||||
*received_msg=t->message_queue.back();
|
||||
t->message_queue.pop_back();
|
||||
} else
|
||||
@@ -322,7 +322,7 @@ extern "C" {
|
||||
void *args_p) {
|
||||
task_list_t *t=tasks[task_id];
|
||||
threadCreate (&t->thread, start_routine, args_p, (char *)itti_get_task_name(task_id),-1,OAI_PRIORITY_RT);
|
||||
LOG_I(TMR,"Created Posix thread %s\n", itti_get_task_name(task_id) );
|
||||
LOG_I(ITTI,"Created Posix thread %s\n", itti_get_task_name(task_id) );
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -344,7 +344,7 @@ extern "C" {
|
||||
tasks = new_tasks;
|
||||
tasks[newQueue]= new task_list_t;
|
||||
pthread_mutex_unlock (&lock_nb_queues);
|
||||
LOG_I(TMR,"Starting itti queue: %s as task %d\n", taskInfo->name, newQueue);
|
||||
LOG_I(ITTI,"Starting itti queue: %s as task %d\n", taskInfo->name, newQueue);
|
||||
pthread_mutex_init(&tasks[newQueue]->queue_cond_lock, NULL);
|
||||
memcpy(&tasks[newQueue]->admin, taskInfo, sizeof(task_info_t));
|
||||
AssertFatal( ( tasks[newQueue]->epoll_fd = epoll_create1(0) ) >=0, "");
|
||||
@@ -392,7 +392,7 @@ extern "C" {
|
||||
clock_gettime(CLOCK_MONOTONIC, &tp);
|
||||
|
||||
if (interval_us%1000 != 0)
|
||||
LOG_W(TMR, "Can't set timer precision below 1ms, rounding it\n");
|
||||
LOG_W(ITTI, "Can't set timer precision below 1ms, rounding it\n");
|
||||
|
||||
timer.duration = interval_sec*1000+interval_us/1000;
|
||||
timer.timeout= ((uint64_t)tp.tv_sec*1000+tp.tv_nsec/(1000*1000)+timer.duration);
|
||||
@@ -421,7 +421,7 @@ extern "C" {
|
||||
if (ret==1)
|
||||
return 0;
|
||||
else {
|
||||
LOG_W(TMR, "tried to remove a non existing timer\n");
|
||||
LOG_W(ITTI, "tried to remove a non existing timer\n");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
@@ -438,9 +438,22 @@ extern "C" {
|
||||
void itti_send_terminate_message(task_id_t task_id) {
|
||||
}
|
||||
|
||||
static volatile bool shutting_down;
|
||||
|
||||
static void catch_sigterm(int) {
|
||||
static const char msg[] = "\n** Caught SIGTERM, shutting down\n";
|
||||
__attribute__((unused))
|
||||
int unused = write(STDOUT_FILENO, msg, sizeof(msg) - 1);
|
||||
shutting_down = true;
|
||||
}
|
||||
|
||||
void itti_wait_tasks_end(void) {
|
||||
while(1)
|
||||
sleep(24*3600);
|
||||
shutting_down = false;
|
||||
signal(SIGTERM, catch_sigterm);
|
||||
while (! shutting_down)
|
||||
{
|
||||
sleep(24 * 3600);
|
||||
}
|
||||
}
|
||||
|
||||
void itti_update_lte_time(uint32_t frame, uint8_t slot) {}
|
||||
@@ -455,4 +468,42 @@ extern "C" {
|
||||
int signal_mask(void) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
void log_scheduler(const char* label)
|
||||
{
|
||||
int policy = sched_getscheduler(0);
|
||||
struct sched_param param;
|
||||
if (sched_getparam(0, ¶m) == -1)
|
||||
{
|
||||
LOG_E(HW, "sched_getparam: %s\n", strerror(errno));
|
||||
abort();
|
||||
}
|
||||
|
||||
cpu_set_t cpu_set;
|
||||
if (sched_getaffinity(0, sizeof(cpu_set), &cpu_set) == -1)
|
||||
{
|
||||
LOG_E(HW, "sched_getaffinity: %s\n", strerror(errno));
|
||||
abort();
|
||||
}
|
||||
int num_cpus = sysconf(_SC_NPROCESSORS_ONLN);
|
||||
if (num_cpus < 1)
|
||||
{
|
||||
LOG_E(HW, "sysconf(_SC_NPROCESSORS_ONLN): %s\n", strerror(errno));
|
||||
abort();
|
||||
}
|
||||
char buffer[num_cpus];
|
||||
for (int i = 0; i < num_cpus; i++)
|
||||
{
|
||||
buffer[i] = CPU_ISSET(i, &cpu_set) ? 'Y' : '-';
|
||||
}
|
||||
|
||||
LOG_A(HW, "Scheduler policy=%d priority=%d affinity=[%d]%.*s label=%s\n",
|
||||
policy,
|
||||
param.sched_priority,
|
||||
num_cpus,
|
||||
num_cpus,
|
||||
buffer,
|
||||
label);
|
||||
}
|
||||
} // extern "C"
|
||||
|
||||
|
||||
@@ -346,6 +346,8 @@ void *rrc_enb_process_msg(void *);
|
||||
TASK_DEF(TASK_DU_F1, TASK_PRIORITY_MED, 200, NULL, NULL) \
|
||||
TASK_DEF(TASK_RRC_UE_SIM, TASK_PRIORITY_MED, 200, NULL, NULL) \
|
||||
TASK_DEF(TASK_RRC_GNB_SIM, TASK_PRIORITY_MED, 200, NULL, NULL) \
|
||||
TASK_DEF(TASK_RRC_NSA_UE, TASK_PRIORITY_MED, 200, NULL, NULL) \
|
||||
TASK_DEF(TASK_RRC_NSA_NRUE, TASK_PRIORITY_MED, 200, NULL, NULL) \
|
||||
TASK_DEF(TASK_NAS_NRUE, TASK_PRIORITY_MED, 200, NULL, NULL) \
|
||||
TASK_DEF(TASK_MAX, TASK_PRIORITY_MED, 200, NULL, NULL)
|
||||
|
||||
@@ -362,6 +364,8 @@ typedef enum {
|
||||
FOREACH_TASK(TASK_ENUM)
|
||||
} task_id_t;
|
||||
|
||||
extern uint16_t ue_idx_standalone;
|
||||
extern uint16_t node_number;
|
||||
|
||||
typedef task_id_t thread_id_t;
|
||||
|
||||
@@ -586,6 +590,7 @@ int timer_remove(long timer_id);
|
||||
int signal_handle(int *end);
|
||||
int signal_mask(void);
|
||||
|
||||
void log_scheduler(const char *label);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,91 @@
|
||||
# interthread interface (ITTI)
|
||||
|
||||
A Middleware called “itti” (interthread interface) provides classical send/receive message queues between threads.
|
||||
|
||||
A simpler thread safe message queue is available in the thread-pool, as it is a required lower level feature.
|
||||
|
||||
ITTI is providing more feature, to be used as the thread event main loop.
|
||||
|
||||
It is also made for strong type definition is source code.
|
||||
|
||||
It is able to add in the managed events: external sockets, timers
|
||||
|
||||
All queues are created in .h files, as static permanent queues, nevertheless the possibility to add queues during runtime is available.
|
||||
|
||||
The queues are called tasks because it is often read in a single thread that have the same name.
|
||||
|
||||
# API definition
|
||||
|
||||
## itti_send_msg_to_task, itti_receive_msg, itti_poll_msg
|
||||
|
||||
Standard messages queues, thread safe
|
||||
The reader is responsible of freeing the message
|
||||
|
||||
## itti_subscribe_event_fd, itti_get_events
|
||||
|
||||
Add external sockets to itti based main loop
|
||||
|
||||
## timer_setup timer_remove
|
||||
|
||||
When a timer expire, it adds a message in a itti queue
|
||||
|
||||
## itti_terminate_tasks
|
||||
|
||||
Calling this function push a “terminate” message on each itti queue
|
||||
|
||||
# Example code of a thread using ITTI
|
||||
|
||||
```
|
||||
Thread_aLayer_main(void * context) {
|
||||
// initialize the layer data
|
||||
// and register in itti the external sockets (like S1AP, GTP)
|
||||
aLayer_init();
|
||||
while (1) {
|
||||
MessageDef * msg
|
||||
itti_receive_msg(TASK_aLayer, &msg);
|
||||
// itti receive released, so we have incoming data
|
||||
// Can be a itti message
|
||||
if ( msg != NULL) {
|
||||
switch(ITTI_MSG_ID(msg)) {
|
||||
case …:
|
||||
processThisMsgType1(msg);
|
||||
break;
|
||||
case …:
|
||||
processThisMsgType2(msg);
|
||||
break;
|
||||
}
|
||||
Itti_free(msg);
|
||||
}
|
||||
// or data/event on external entries (sockets)
|
||||
Struct eppol_events* events;
|
||||
int nbEvents=itti_get_events(TASK_aLayer, &events);
|
||||
if ( nbEvents > 0)
|
||||
processLayerEvents(events, nbEvents);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
```
|
||||
|
||||
# Current usage in OpenAir
|
||||
|
||||
## UDP, SCTP
|
||||
|
||||
Simple threads that interface itti internal messages to Linux
|
||||
|
||||
## GTPV1-U, S1AP
|
||||
|
||||
Threads to implement S1AP and GTP protocols
|
||||
|
||||
## PDCP
|
||||
|
||||
4G Pdcp is not following itti design pattern, but it uses itti internally , 5G PDCP uses ad hoc design
|
||||
|
||||
## RRC
|
||||
|
||||
Implements 3GPP Rrc features
|
||||
Interfaces the layer 1 and the above itti tasks
|
||||
|
||||
## X2, ENP_APP (configuration), L1L2
|
||||
|
||||
Are declared itti queues with a dedicated thread, but they are almost empty
|
||||
+149
-56
@@ -95,53 +95,16 @@ static void read_pipe(int p, char *b, int size) {
|
||||
size -= ret;
|
||||
}
|
||||
}
|
||||
|
||||
static int baseRunTimeCommand(char* cmd, size_t cmdSize) {
|
||||
FILE *fp;
|
||||
size_t retSize = 0;
|
||||
|
||||
fp = popen(cmd, "r");
|
||||
if(fp) {
|
||||
memset(cmd, 0, cmdSize);
|
||||
retSize = fread(cmd, 1, cmdSize, fp);
|
||||
fclose(fp);
|
||||
} else {
|
||||
LOG_D(HW,"%s:%d:%s: Cannot open %s\n", __FILE__, __LINE__, __FUNCTION__, cmd);
|
||||
}
|
||||
|
||||
if (retSize == 0) {
|
||||
return 0;
|
||||
}
|
||||
return atoi(cmd);
|
||||
}
|
||||
|
||||
int checkIfFedoraDistribution(void) {
|
||||
char cmd[200];
|
||||
|
||||
memset(cmd, 0, 200);
|
||||
sprintf(cmd, "cat /etc/os-release | grep ID_LIKE | grep -ic fedora || true");
|
||||
return baseRunTimeCommand(cmd, 200);
|
||||
return !system("grep -iq 'ID_LIKE.*fedora' /etc/os-release ");
|
||||
}
|
||||
|
||||
int checkIfGenericKernelOnFedora(void) {
|
||||
char cmd[200];
|
||||
|
||||
memset(cmd, 0, 200);
|
||||
sprintf(cmd, "uname -a | grep -c rt || true");
|
||||
return (1 - baseRunTimeCommand(cmd, 200));
|
||||
return system("uname -a | grep -q rt");
|
||||
}
|
||||
|
||||
int checkIfInsideContainer(void) {
|
||||
char cmd[200];
|
||||
int res = 0;
|
||||
|
||||
memset(cmd, 0, 200);
|
||||
sprintf(cmd, "cat /proc/self/cgroup | egrep -c 'libpod|podman|kubepods' || true");
|
||||
res = baseRunTimeCommand(cmd, 200);
|
||||
if (res > 0)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
return !system("egrep -q 'libpod|podman|kubepods' /proc/self/cgroup");
|
||||
}
|
||||
|
||||
/********************************************************************/
|
||||
@@ -248,6 +211,19 @@ void start_background_system(void) {
|
||||
background_system_process();
|
||||
}
|
||||
|
||||
int rt_sleep_ns (uint64_t x)
|
||||
{
|
||||
struct timespec myTime;
|
||||
clock_gettime(CLOCK_MONOTONIC, &myTime);
|
||||
myTime.tv_sec += x/1000000000ULL;
|
||||
myTime.tv_nsec = x%1000000000ULL;
|
||||
if (myTime.tv_nsec>=1000000000) {
|
||||
myTime.tv_nsec -= 1000000000;
|
||||
myTime.tv_sec++;
|
||||
}
|
||||
|
||||
return clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &myTime, NULL);
|
||||
}
|
||||
|
||||
void threadCreate(pthread_t* t, void * (*func)(void*), void * param, char* name, int affinity, int priority){
|
||||
pthread_attr_t attr;
|
||||
@@ -257,21 +233,21 @@ void threadCreate(pthread_t* t, void * (*func)(void*), void * param, char* name,
|
||||
AssertFatal(ret==0,"ret: %d, errno: %d\n",ret, errno);
|
||||
ret=pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
|
||||
AssertFatal(ret==0,"ret: %d, errno: %d\n",ret, errno);
|
||||
ret=pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
|
||||
AssertFatal(ret==0,"ret: %d, errno: %d\n",ret, errno);
|
||||
if (checkIfFedoraDistribution())
|
||||
if (checkIfGenericKernelOnFedora())
|
||||
if (checkIfInsideContainer())
|
||||
settingPriority = 0;
|
||||
|
||||
|
||||
if (system("grep -iq 'ID_LIKE.*fedora' /etc/os-release && uname -a | grep -c rt")==0)
|
||||
if (system("cat /proc/self/cgroup | egrep -c 'libpod|podman|kubepods'")==0)
|
||||
settingPriority = 0;
|
||||
|
||||
if (settingPriority) {
|
||||
ret=pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
|
||||
AssertFatal(ret==0,"ret: %d, errno: %d\n",ret, errno);
|
||||
ret=pthread_attr_setschedpolicy(&attr, SCHED_OAI);
|
||||
AssertFatal(ret==0,"ret: %d, errno: %d\n",ret, errno);
|
||||
if(priority<sched_get_priority_min(SCHED_OAI) || priority>sched_get_priority_max(SCHED_FIFO)) {
|
||||
LOG_E(TMR,"Prio not possible: %d, min is %d, max: %d, forced in the range\n",
|
||||
priority,
|
||||
sched_get_priority_min(SCHED_OAI),
|
||||
sched_get_priority_max(SCHED_OAI));
|
||||
if(priority<sched_get_priority_min(SCHED_OAI) || priority>sched_get_priority_max(SCHED_OAI)) {
|
||||
LOG_E(UTIL,"Prio not possible: %d, min is %d, max: %d, forced in the range\n",
|
||||
priority,
|
||||
sched_get_priority_min(SCHED_OAI),
|
||||
sched_get_priority_max(SCHED_OAI));
|
||||
if(priority<sched_get_priority_min(SCHED_OAI))
|
||||
priority=sched_get_priority_min(SCHED_OAI);
|
||||
if(priority>sched_get_priority_max(SCHED_OAI))
|
||||
@@ -283,10 +259,10 @@ void threadCreate(pthread_t* t, void * (*func)(void*), void * param, char* name,
|
||||
ret=pthread_attr_setschedparam(&attr, &sparam);
|
||||
AssertFatal(ret==0,"ret: %d, errno: %d\n",ret, errno);
|
||||
}
|
||||
|
||||
|
||||
ret=pthread_create(t, &attr, func, param);
|
||||
AssertFatal(ret==0,"ret: %d, errno: %d\n",ret, errno);
|
||||
|
||||
|
||||
pthread_setname_np(*t, name);
|
||||
if (affinity != -1 ) {
|
||||
cpu_set_t cpuset;
|
||||
@@ -297,11 +273,128 @@ void threadCreate(pthread_t* t, void * (*func)(void*), void * param, char* name,
|
||||
pthread_attr_destroy(&attr);
|
||||
}
|
||||
|
||||
// Legacy, pthread_create + thread_top_init() should be replaced by threadCreate
|
||||
// threadCreate encapsulates the posix pthread api
|
||||
void thread_top_init(char *thread_name,
|
||||
int affinity,
|
||||
uint64_t runtime,
|
||||
uint64_t deadline,
|
||||
uint64_t period) {
|
||||
|
||||
#ifdef DEADLINE_SCHEDULER
|
||||
struct sched_attr attr;
|
||||
|
||||
unsigned int flags = 0;
|
||||
|
||||
attr.size = sizeof(attr);
|
||||
attr.sched_flags = 0;
|
||||
attr.sched_nice = 0;
|
||||
attr.sched_priority = 0;
|
||||
|
||||
attr.sched_policy = SCHED_DEADLINE;
|
||||
attr.sched_runtime = runtime;
|
||||
attr.sched_deadline = deadline;
|
||||
attr.sched_period = period;
|
||||
|
||||
if (sched_setattr(0, &attr, flags) < 0 ) {
|
||||
perror("[SCHED] eNB tx thread: sched_setattr failed\n");
|
||||
fprintf(stderr,"sched_setattr Error = %s",strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
#else //LOW_LATENCY
|
||||
int policy, s, j;
|
||||
struct sched_param sparam;
|
||||
char cpu_affinity[1024];
|
||||
cpu_set_t cpuset;
|
||||
int settingPriority = 1;
|
||||
|
||||
/* Set affinity mask to include CPUs 2 to MAX_CPUS */
|
||||
/* CPU 0 is reserved for UHD threads */
|
||||
/* CPU 1 is reserved for all RX_TX threads */
|
||||
/* Enable CPU Affinity only if number of CPUs > 2 */
|
||||
CPU_ZERO(&cpuset);
|
||||
|
||||
#ifdef CPU_AFFINITY
|
||||
if (affinity == 0) {
|
||||
LOG_W(HW,"thread_top_init() called with affinity==0, but overruled by #ifdef CPU_AFFINITY\n");
|
||||
}
|
||||
else if (get_nprocs() > 2)
|
||||
{
|
||||
for (j = 2; j < get_nprocs(); j++)
|
||||
CPU_SET(j, &cpuset);
|
||||
s = pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
|
||||
if (s != 0)
|
||||
{
|
||||
perror( "pthread_setaffinity_np");
|
||||
exit_fun("Error setting processor affinity");
|
||||
}
|
||||
}
|
||||
#else //CPU_AFFINITY
|
||||
if (affinity) {
|
||||
LOG_W(HW,"thread_top_init() called with affinity>0, but overruled by #ifndef CPU_AFFINITY.\n");
|
||||
}
|
||||
#endif //CPU_AFFINITY
|
||||
|
||||
/* Check the actual affinity mask assigned to the thread */
|
||||
s = pthread_getaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
|
||||
if (s != 0)
|
||||
{
|
||||
perror( "pthread_getaffinity_np");
|
||||
exit_fun("Error getting processor affinity ");
|
||||
}
|
||||
memset(cpu_affinity,0,sizeof(cpu_affinity));
|
||||
for (j = 0; j < 1024; j++)
|
||||
{
|
||||
if (CPU_ISSET(j, &cpuset))
|
||||
{
|
||||
char temp[1024];
|
||||
sprintf (temp, " CPU_%d", j);
|
||||
strcat(cpu_affinity, temp);
|
||||
}
|
||||
}
|
||||
|
||||
if (checkIfFedoraDistribution())
|
||||
if (checkIfGenericKernelOnFedora())
|
||||
if (checkIfInsideContainer())
|
||||
settingPriority = 0;
|
||||
|
||||
if (settingPriority) {
|
||||
memset(&sparam, 0, sizeof(sparam));
|
||||
sparam.sched_priority = sched_get_priority_max(SCHED_FIFO);
|
||||
policy = SCHED_FIFO;
|
||||
|
||||
s = pthread_setschedparam(pthread_self(), policy, &sparam);
|
||||
if (s != 0) {
|
||||
perror("pthread_setschedparam : ");
|
||||
exit_fun("Error setting thread priority");
|
||||
}
|
||||
|
||||
s = pthread_getschedparam(pthread_self(), &policy, &sparam);
|
||||
if (s != 0) {
|
||||
perror("pthread_getschedparam : ");
|
||||
exit_fun("Error getting thread priority");
|
||||
}
|
||||
|
||||
pthread_setname_np(pthread_self(), thread_name);
|
||||
|
||||
LOG_I(HW, "[SCHED][eNB] %s started on CPU %d, sched_policy = %s , priority = %d, CPU Affinity=%s \n",thread_name,sched_getcpu(),
|
||||
(policy == SCHED_FIFO) ? "SCHED_FIFO" :
|
||||
(policy == SCHED_RR) ? "SCHED_RR" :
|
||||
(policy == SCHED_OTHER) ? "SCHED_OTHER" :
|
||||
"???",
|
||||
sparam.sched_priority, cpu_affinity );
|
||||
}
|
||||
|
||||
#endif //LOW_LATENCY
|
||||
}
|
||||
|
||||
|
||||
// Block CPU C-states deep sleep
|
||||
void configure_linux(void) {
|
||||
void set_latency_target(void) {
|
||||
int ret;
|
||||
static int latency_target_fd=-1;
|
||||
uint32_t latency_target_value=10; // in microseconds
|
||||
uint32_t latency_target_value=2; // in microseconds
|
||||
if (latency_target_fd == -1) {
|
||||
if ( (latency_target_fd = open("/dev/cpu_dma_latency", O_RDWR)) != -1 ) {
|
||||
ret = write(latency_target_fd, &latency_target_value, sizeof(latency_target_value));
|
||||
|
||||
@@ -43,10 +43,9 @@ int background_system(char *command);
|
||||
void start_background_system(void);
|
||||
|
||||
void set_latency_target(void);
|
||||
void configure_linux(void);
|
||||
|
||||
void threadCreate(pthread_t* t, void * (*func)(void*), void * param, char* name, int affinity, int priority);
|
||||
|
||||
void threadCreate(pthread_t *t, void *(*func)(void *), void *param, char *name, int affinity, int priority);
|
||||
|
||||
#define SCHED_OAI SCHED_RR
|
||||
#define OAI_PRIORITY_RT_LOW sched_get_priority_min(SCHED_OAI)
|
||||
#define OAI_PRIORITY_RT ((sched_get_priority_min(SCHED_OAI)+sched_get_priority_max(SCHED_OAI))/2)
|
||||
@@ -65,7 +64,7 @@ void thread_top_init(char *thread_name,
|
||||
int checkIfFedoraDistribution(void);
|
||||
int checkIfGenericKernelOnFedora(void);
|
||||
int checkIfInsideContainer(void);
|
||||
|
||||
int rt_sleep_ns (uint64_t x);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -51,7 +51,6 @@
|
||||
#include <dlfcn.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/resource.h>
|
||||
#include <form.h>
|
||||
#include "common/utils/load_module_shlib.h"
|
||||
#include "common/config/config_userapi.h"
|
||||
#include "common/utils/threadPool/thread-pool.h"
|
||||
|
||||
@@ -1,13 +1,3 @@
|
||||
all:
|
||||
measurement_display thread-pool-test
|
||||
|
||||
measurement_display:
|
||||
measurement_display.c thread-pool.h
|
||||
gcc measurement_display.c -I $ {OPENAIR_DIR}/ -I $ {OPENAIR_DIR}/common/utils/ -I. $ {OPENAIR_DIR}/common/utils/backtrace.c -lpthread -D TEST_THREAD_POOL -I../LOG -I../../utils/T -o
|
||||
measurement_display
|
||||
|
||||
thread-pool-test:
|
||||
thread-pool.c thread-pool.h
|
||||
gcc -g thread-pool.c -I $ {OPENAIR_DIR}/ -I $ {OPENAIR_DIR}/common/utils/ -I. $ {OPENAIR_DIR}/common/utils/backtrace.c -I $ {OPENAIR_DIR}/openair2/COMMON $ {OPENAIR_DIR}/common/utils/LOG/log.c $ {OPENAIR_DIR}/common/config/config_userapi.c
|
||||
$ {OPENAIR_DIR}/common/config/config_load_configmodule.c $ {OPENAIR_DIR}/common/config/config_cmdline.c -lpthread -ldl -D TEST_THREAD_POOL -I../LOG -I../../utils/T -o thread-pool-test
|
||||
thread-pool-test: thread-pool.c thread-pool.h
|
||||
gcc -g -O3 thread-pool.c -I ${OPENAIR_DIR}/nfapi/open-nFAPI/nfapi/public_inc -I ${OPENAIR_DIR}/ -I ${OPENAIR_DIR}/common/utils/ -I. ${OPENAIR_DIR}/common/utils/backtrace.c -I ${OPENAIR_DIR}/openair2/COMMON ${OPENAIR_DIR}/common/utils/system.c ${OPENAIR_DIR}/common/utils/LOG/log.c ${OPENAIR_DIR}/common/config/config_userapi.c ${OPENAIR_DIR}/common/config/config_load_configmodule.c ${OPENAIR_DIR}/common/config/config_cmdline.c -lpthread -ldl -D TEST_THREAD_POOL -DMAX_NUM_CCs=1 -I../LOG -I../../utils/T -o thread-pool-test
|
||||
|
||||
|
||||
@@ -155,21 +155,24 @@ void initNamedTpool(char *params,tpool_t *pool, bool performanceMeas, char *name
|
||||
}
|
||||
|
||||
#ifdef TEST_THREAD_POOL
|
||||
volatile int oai_exit=0;
|
||||
|
||||
void exit_function(const char *file, const char *function, const int line, const char *s) {
|
||||
}
|
||||
|
||||
struct testData {
|
||||
int id;
|
||||
int sleepTime;
|
||||
char txt[30];
|
||||
};
|
||||
|
||||
void processing(void *arg) {
|
||||
struct testData *in=(struct testData *)arg;
|
||||
printf("doing: %d, %s, in thr %ld\n",in->id, in->txt,pthread_self() );
|
||||
//printf("doing: %d, %s, in thr %ld\n",in->id, in->txt,pthread_self() );
|
||||
sprintf(in->txt,"Done by %ld, job %d", pthread_self(), in->id);
|
||||
usleep(rand()%100);
|
||||
printf("done: %d, %s, in thr %ld\n",in->id, in->txt,pthread_self() );
|
||||
in->sleepTime=rand()%1000;
|
||||
usleep(in->sleepTime);
|
||||
//printf("done: %d, %s, in thr %ld\n",in->id, in->txt,pthread_self() );
|
||||
}
|
||||
|
||||
int main() {
|
||||
@@ -208,11 +211,43 @@ int main() {
|
||||
} while(tmp);
|
||||
|
||||
tpool_t pool;
|
||||
char params[]="1,2,3,u";
|
||||
char params[]="1,2,3,4,5";
|
||||
initTpool(params,&pool, true);
|
||||
notifiedFIFO_t worker_back;
|
||||
initNotifiedFIFO(&worker_back);
|
||||
|
||||
sleep(1);
|
||||
int cumulProcessTime=0, cumulTime=0;
|
||||
struct timespec st,end;
|
||||
clock_gettime(CLOCK_MONOTONIC, &st);
|
||||
int nb_jobs=4;
|
||||
for (int i=0; i <1000 ; i++) {
|
||||
int parall=nb_jobs;
|
||||
for (int j=0; j <parall ; j++) {
|
||||
notifiedFIFO_elt_t *work=newNotifiedFIFO_elt(sizeof(struct testData), i, &worker_back, processing);
|
||||
struct testData *x=(struct testData *)NotifiedFifoData(work);
|
||||
x->id=i;
|
||||
pushTpool(&pool, work);
|
||||
}
|
||||
int sleepmax=0;
|
||||
while (parall) {
|
||||
tmp=pullTpool(&worker_back,&pool);
|
||||
if (tmp) {
|
||||
parall--;
|
||||
struct testData *dd=NotifiedFifoData(tmp);
|
||||
if (dd->sleepTime > sleepmax)
|
||||
sleepmax=dd->sleepTime;
|
||||
delNotifiedFIFO_elt(tmp);
|
||||
}
|
||||
}
|
||||
cumulProcessTime+=sleepmax;
|
||||
}
|
||||
clock_gettime(CLOCK_MONOTONIC, &end);
|
||||
long long dur=(end.tv_sec-st.tv_sec)*1000*1000+(end.tv_nsec-st.tv_nsec)/1000;
|
||||
printf("In µs, Total time per group of %d job:%lld, work time per job %d, overhead per job %lld\n",
|
||||
nb_jobs, dur/1000, cumulProcessTime/1000, (dur-cumulProcessTime)/(1000*nb_jobs));
|
||||
|
||||
/*
|
||||
for (int i=0; i <1000 ; i++) {
|
||||
notifiedFIFO_elt_t *work=newNotifiedFIFO_elt(sizeof(struct testData), i, &worker_back, processing);
|
||||
struct testData *x=(struct testData *)NotifiedFifoData(work);
|
||||
@@ -232,7 +267,7 @@ int main() {
|
||||
|
||||
abortTpool(&pool,510);
|
||||
} while(tmp);
|
||||
|
||||
*/
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -31,6 +31,7 @@
|
||||
#include <assertions.h>
|
||||
#include <LOG/log.h>
|
||||
#include <common/utils/system.h>
|
||||
//#include <stdatomic.h>
|
||||
|
||||
#ifdef DEBUG
|
||||
#define THREADINIT PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
|
||||
@@ -50,7 +51,7 @@
|
||||
AssertFatal(ret==0,"ret=%d\n",ret);}
|
||||
#define condbroadcast(signal) {int ret=pthread_cond_broadcast(&signal); \
|
||||
AssertFatal(ret==0,"ret=%d\n",ret);}
|
||||
#define condsignal(signal) {int ret=pthread_cond_broadcast(&signal); \
|
||||
#define condsignal(signal) {int ret=pthread_cond_signal(&signal); \
|
||||
AssertFatal(ret==0,"ret=%d\n",ret);}
|
||||
#define tpool_nbthreads(tpool) (tpool.nbThreads)
|
||||
typedef struct notifiedFIFO_elt_s {
|
||||
@@ -130,7 +131,7 @@ static inline void pushNotifiedFIFO_nothreadSafe(notifiedFIFO_t *nf, notifiedFIF
|
||||
static inline void pushNotifiedFIFO(notifiedFIFO_t *nf, notifiedFIFO_elt_t *msg) {
|
||||
mutexlock(nf->lockF);
|
||||
pushNotifiedFIFO_nothreadSafe(nf,msg);
|
||||
condbroadcast(nf->notifF);
|
||||
condsignal(nf->notifF);
|
||||
mutexunlock(nf->lockF);
|
||||
}
|
||||
|
||||
@@ -141,7 +142,7 @@ static inline notifiedFIFO_elt_t *pullNotifiedFIFO_nothreadSafe(notifiedFIFO_t
|
||||
notifiedFIFO_elt_t *ret=nf->outF;
|
||||
|
||||
if (nf->outF==nf->outF->next)
|
||||
LOG_E(TMR,"Circular list in thread pool: push several times the same buffer is forbidden\n");
|
||||
LOG_E(UTIL,"Circular list in thread pool: push several times the same buffer is forbidden\n");
|
||||
|
||||
nf->outF=nf->outF->next;
|
||||
|
||||
|
||||
+42
-15
@@ -2,25 +2,38 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <unistd.h>
|
||||
#include <sched.h>
|
||||
#include <errno.h>
|
||||
#include "utils.h"
|
||||
|
||||
void *calloc_or_fail(size_t size) {
|
||||
void *ptr = calloc(1, size);
|
||||
if (ptr == NULL) {
|
||||
fprintf(stderr, "[UE] Failed to calloc %zu bytes", size);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
return ptr;
|
||||
|
||||
|
||||
const char *hexdump(const void *data, size_t data_len, char *out, size_t out_len)
|
||||
{
|
||||
char *p = out;
|
||||
char *endp = out + out_len;
|
||||
const uint8_t *q = data;
|
||||
snprintf(p, endp - p, "[%zu]", data_len);
|
||||
p += strlen(p);
|
||||
for (size_t i = 0; i < data_len; ++i)
|
||||
{
|
||||
if (p >= endp)
|
||||
{
|
||||
static const char ellipses[] = "...";
|
||||
char *s = endp - sizeof(ellipses);
|
||||
if (s >= p)
|
||||
{
|
||||
strcpy(s, ellipses);
|
||||
}
|
||||
break;
|
||||
}
|
||||
snprintf(p, endp - p, " %02X", *q++);
|
||||
p += strlen(p);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
void *malloc_or_fail(size_t size) {
|
||||
void *ptr = malloc(size);
|
||||
if (ptr == NULL) {
|
||||
fprintf(stderr, "[UE] Failed to malloc %zu bytes", size);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
** **
|
||||
@@ -111,3 +124,17 @@ void *memcpy1(void *dst,const void *src,size_t n) {
|
||||
asm volatile("rep movsb" : "+D" (dst) : "c"(n), "S"(src) : "cc","memory");
|
||||
return(ret);
|
||||
}
|
||||
|
||||
void set_priority(int priority)
|
||||
{
|
||||
struct sched_param param =
|
||||
{
|
||||
.sched_priority = priority,
|
||||
};
|
||||
fprintf(stderr, "Calling sched_setscheduler(%d)\n", priority);
|
||||
if (sched_setscheduler(0, SCHED_RR, ¶m) == -1)
|
||||
{
|
||||
fprintf(stderr, "sched_setscheduler: %s\n", strerror(errno));
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
+103
-4
@@ -1,15 +1,113 @@
|
||||
#ifndef _UTILS_H
|
||||
#define _UTILS_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <malloc.h>
|
||||
#include <sys/types.h>
|
||||
#include <common/utils/assertions.h>
|
||||
|
||||
#ifdef MALLOC_TRACE
|
||||
#define malloc myMalloc
|
||||
#endif
|
||||
|
||||
#define sizeofArray(a) (sizeof(a)/sizeof(*(a)))
|
||||
void *calloc_or_fail(size_t size);
|
||||
void *malloc_or_fail(size_t size);
|
||||
|
||||
#define cmax(a,b) ((a>b) ? (a) : (b))
|
||||
#define cmax3(a,b,c) ((cmax(a,b)>c) ? (cmax(a,b)) : (c))
|
||||
#define cmin(a,b) ((a<b) ? (a) : (b))
|
||||
|
||||
#ifdef __cplusplus
|
||||
#ifdef min
|
||||
#undef min
|
||||
#undef max
|
||||
#endif
|
||||
#else
|
||||
#define max(a,b) cmax(a,b)
|
||||
#define min(a,b) cmin(a,b)
|
||||
#endif
|
||||
|
||||
#ifndef malloc16
|
||||
# ifdef __AVX2__
|
||||
# define malloc16(x) memalign(32,x+32)
|
||||
# else
|
||||
# define malloc16(x) memalign(16,x+16)
|
||||
# endif
|
||||
#endif
|
||||
#define free16(y,x) free(y)
|
||||
#define bigmalloc malloc
|
||||
#define bigmalloc16 malloc16
|
||||
#define openair_free(y,x) free((y))
|
||||
#define PAGE_SIZE 4096
|
||||
|
||||
#define free_and_zero(PtR) do { \
|
||||
if (PtR) { \
|
||||
free(PtR); \
|
||||
PtR = NULL; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
static inline void *malloc16_clear( size_t size ) {
|
||||
#ifdef __AVX2__
|
||||
void *ptr = memalign(32, size+32);
|
||||
#else
|
||||
void *ptr = memalign(16, size+16);
|
||||
#endif
|
||||
DevAssert(ptr);
|
||||
memset( ptr, 0, size );
|
||||
return ptr;
|
||||
}
|
||||
|
||||
|
||||
static inline void *calloc_or_fail(size_t size) {
|
||||
void *ptr = calloc(1, size);
|
||||
|
||||
if (ptr == NULL) {
|
||||
fprintf(stderr, "[UE] Failed to calloc %zu bytes", size);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
static inline void *malloc_or_fail(size_t size) {
|
||||
void *ptr = malloc(size);
|
||||
|
||||
if (ptr == NULL) {
|
||||
fprintf(stderr, "[UE] Failed to malloc %zu bytes", size);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
#if !defined (msg)
|
||||
# define msg(aRGS...) LOG_D(PHY, ##aRGS)
|
||||
#endif
|
||||
#ifndef malloc16
|
||||
# ifdef __AVX2__
|
||||
# define malloc16(x) memalign(32,x)
|
||||
# else
|
||||
# define malloc16(x) memalign(16,x)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#define free16(y,x) free(y)
|
||||
#define bigmalloc malloc
|
||||
#define bigmalloc16 malloc16
|
||||
#define openair_free(y,x) free((y))
|
||||
#define PAGE_SIZE 4096
|
||||
|
||||
#define PAGE_MASK 0xfffff000
|
||||
#define virt_to_phys(x) (x)
|
||||
|
||||
const char *hexdump(const void *data, size_t data_len, char *out, size_t out_len);
|
||||
|
||||
// Converts an hexadecimal ASCII coded digit into its value. **
|
||||
int hex_char_to_hex_value (char c);
|
||||
@@ -18,6 +116,7 @@ int hex_string_to_hex_value (uint8_t *hex_value, const char *hex_string, int siz
|
||||
|
||||
void *memcpy1(void *dst,const void *src,size_t n);
|
||||
|
||||
void set_priority(int priority);
|
||||
|
||||
char *itoa(int i);
|
||||
|
||||
|
||||
Reference in New Issue
Block a user