Merge branch 'next' into next_novolk

master
Ismael Gomez 7 years ago
commit fd2a6f13e2

@ -42,6 +42,8 @@ include(SRSLTEPackage) #setup cpack
include(CTest) include(CTest)
set(CTEST_MEMORYCHECK_COMMAND valgrind) set(CTEST_MEMORYCHECK_COMMAND valgrind)
set(CTEST_MEMORYCHECK_COMMAND_OPTIONS "--trace-children=yes --leak-check=full" )
configure_file( configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/CTestCustom.cmake.in" "${CMAKE_CURRENT_SOURCE_DIR}/CTestCustom.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.cmake" "${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.cmake"
@ -66,7 +68,7 @@ option(ENABLE_BLADERF "Enable BladeRF" ON)
option(BUILD_STATIC "Attempt to statically link external deps" OFF) option(BUILD_STATIC "Attempt to statically link external deps" OFF)
option(RPATH "Enable RPATH" OFF) option(RPATH "Enable RPATH" OFF)
option(USE_LTE_RATES "Use standard LTE sampling rates" OFF) option(USE_LTE_RATES "Use standard LTE sampling rates" OFF)
set(GCC_ARCH native CACHE STRING "GCC compile for specific architecture.") set(GCC_ARCH native CACHE STRING "GCC compile for specific architecture.")
@ -74,28 +76,62 @@ set(GCC_ARCH native CACHE STRING "GCC compile for specific architecture.")
######################################################################## ########################################################################
# Find dependencies # Find dependencies
######################################################################## ########################################################################
# Threads
find_package(Threads REQUIRED) find_package(Threads REQUIRED)
# FFT
find_package(MKL)
if(MKL_FOUND)
include_directories(${MKL_INCLUDE_DIRS})
link_directories(${MKL_LIBRARY_DIRS})
set(FFT_LIBRARIES "${MKL_STATIC_LIBRARIES}") # Static by default
else(MKL_FOUND)
find_package(FFTW3F REQUIRED)
if(FFTW3F_FOUND)
include_directories(${FFTW3F_INCLUDE_DIRS})
link_directories(${FFTW3F_LIBRARY_DIRS})
if(BUILD_STATIC)
set(FFT_LIBRARIES "${FFTW3F_STATIC_LIBRARIES}")
else(BUILD_STATIC)
set(FFT_LIBRARIES "${FFTW3F_LIBRARIES}")
endif(BUILD_STATIC)
endif(FFTW3F_FOUND)
endif(MKL_FOUND)
# Crypto
find_package(Polarssl) find_package(Polarssl)
if (POLARSSL_FOUND) if (POLARSSL_FOUND)
set(SEC_INCLUDE_DIRS "${POLARSSL_INCLUDE_DIRS}") set(SEC_INCLUDE_DIRS "${POLARSSL_INCLUDE_DIRS}")
set(SEC_LIBRARIES "${POLARSSL_LIBRARIES}") if(BUILD_STATIC)
set(SEC_LIBRARIES "${POLARSSL_STATIC_LIBRARIES}")
else(BUILD_STATIC)
set(SEC_LIBRARIES "${POLARSSL_LIBRARIES}")
endif(BUILD_STATIC)
add_definitions(-DHAVE_POLARSSL) add_definitions(-DHAVE_POLARSSL)
else(POLARSSL_FOUND) else(POLARSSL_FOUND)
find_package(MbedTLS REQUIRED) find_package(MbedTLS REQUIRED)
if (MBEDTLS_FOUND) if (MBEDTLS_FOUND)
set(SEC_INCLUDE_DIRS "${MBEDTLS_INCLUDE_DIRS}") set(SEC_INCLUDE_DIRS "${MBEDTLS_INCLUDE_DIRS}")
set(SEC_LIBRARIES "${MBEDTLS_LIBRARIES}") if(BUILD_STATIC)
set(SEC_LIBRARIES "${MBEDTLS_STATIC_LIBRARIES}")
else(BUILD_STATIC)
set(SEC_LIBRARIES "${MBEDTLS_LIBRARIES}")
endif(BUILD_STATIC)
add_definitions(-DHAVE_MBEDTLS) add_definitions(-DHAVE_MBEDTLS)
else(MBEDTLS_FOUND)
message(FATAL_ERROR "Either polarssl or mbedtls is required to compile srsLTE")
endif (MBEDTLS_FOUND) endif (MBEDTLS_FOUND)
endif(POLARSSL_FOUND) endif(POLARSSL_FOUND)
# UHD
find_package(UHD) find_package(UHD)
if(UHD_FOUND) if(UHD_FOUND)
include_directories(${UHD_INCLUDE_DIRS}) include_directories(${UHD_INCLUDE_DIRS})
link_directories(${UHD_LIBRARY_DIRS}) link_directories(${UHD_LIBRARY_DIRS})
endif(UHD_FOUND) endif(UHD_FOUND)
# BladeRF
if(ENABLE_BLADERF) if(ENABLE_BLADERF)
find_package(bladeRF) find_package(bladeRF)
if(BLADERF_FOUND) if(BLADERF_FOUND)
@ -104,6 +140,7 @@ if(ENABLE_BLADERF)
endif(BLADERF_FOUND) endif(BLADERF_FOUND)
endif(ENABLE_BLADERF) endif(ENABLE_BLADERF)
# Soapy
find_package(SoapySDR) find_package(SoapySDR)
if(SOAPYSDR_FOUND) if(SOAPYSDR_FOUND)
include_directories(${SOAPYSDR_INCLUDE_DIRS}) include_directories(${SOAPYSDR_INCLUDE_DIRS})
@ -117,8 +154,12 @@ else(BLADERF_FOUND OR UHD_FOUND OR SOAPYSDR_FOUND)
add_definitions(-DDISABLE_RF) add_definitions(-DDISABLE_RF)
endif(BLADERF_FOUND OR UHD_FOUND OR SOAPYSDR_FOUND) endif(BLADERF_FOUND OR UHD_FOUND OR SOAPYSDR_FOUND)
# Boost
if(ENABLE_SRSUE OR ENABLE_SRSENB) if(ENABLE_SRSUE OR ENABLE_SRSENB)
# Find Boost if(BUILD_STATIC)
set(Boost_USE_STATIC_LIBS ON)
endif(BUILD_STATIC)
set(BOOST_REQUIRED_COMPONENTS set(BOOST_REQUIRED_COMPONENTS
program_options program_options
system system
@ -138,7 +179,7 @@ if(ENABLE_SRSUE OR ENABLE_SRSENB)
find_package(Boost "1.35" COMPONENTS ${BOOST_REQUIRED_COMPONENTS}) find_package(Boost "1.35" COMPONENTS ${BOOST_REQUIRED_COMPONENTS})
endif(ENABLE_SRSUE OR ENABLE_SRSENB) endif(ENABLE_SRSUE OR ENABLE_SRSENB)
# srsGUI
if(ENABLE_GUI) if(ENABLE_GUI)
find_package(SRSGUI) find_package(SRSGUI)
if(SRSGUI_FOUND) if(SRSGUI_FOUND)
@ -148,6 +189,7 @@ if(ENABLE_GUI)
endif(SRSGUI_FOUND) endif(SRSGUI_FOUND)
endif(ENABLE_GUI) endif(ENABLE_GUI)
# VOLK
include(CheckFunctionExistsMath) include(CheckFunctionExistsMath)
if(ENABLE_VOLK) if(ENABLE_VOLK)
find_package(Volk) find_package(Volk)

@ -7,7 +7,7 @@ SET(CTEST_CUSTOM_MEMCHECK_IGNORE
realplot_test realplot_test
complexplot_test complexplot_test
# Ignore these to, they take too lonk # Ignore these to, they take too long
fft_normal fft_normal
fft_extened fft_extened
chest_test_all_cellids chest_test_all_cellids

@ -81,6 +81,12 @@ Build Instructions
* lksctp: http://lksctp.sourceforge.net/ * lksctp: http://lksctp.sourceforge.net/
* config: http://www.hyperrealm.com/libconfig/ * config: http://www.hyperrealm.com/libconfig/
For example, on Ubuntu 17.04, one can install the required libraries with:
```
sudo apt-get install libfftw3-dev libmbedtls-dev libboost-all-dev libconfig++-dev libsctp-dev
```
Note that depending on your flavor and version of Linux, the actual package names may be different.
* Optional requirements: * Optional requirements:
* srsgui: https://github.com/srslte/srsgui - for real-time plotting. * srsgui: https://github.com/srslte/srsgui - for real-time plotting.
* VOLK: https://github.com/gnuradio/volk - if the VOLK library and headers are detected, they will be used to accelerate some signal processing functions. * VOLK: https://github.com/gnuradio/volk - if the VOLK library and headers are detected, they will be used to accelerate some signal processing functions.

@ -15,6 +15,12 @@ find_path(FFTW3F_INCLUDE_DIR
PATHS /usr/local/include PATHS /usr/local/include
/usr/include ) /usr/include )
find_library(FFTW3F_STATIC_LIBRARY
NAMES fftw3f.a libfftw3f.a libfftw3f-3.a
HINTS ${PC_FFTW3F_LIBDIR} ${PC_FFTW3F_LIBRARY_DIRS} $ENV{FFTW3_DIR}/lib
PATHS /usr/local/lib
/usr/lib)
find_library(FFTW3F_LIBRARY find_library(FFTW3F_LIBRARY
NAMES fftw3f libfftw3f libfftw3f-3 NAMES fftw3f libfftw3f libfftw3f-3
HINTS ${PC_FFTW3F_LIBDIR} ${PC_FFTW3F_LIBRARY_DIRS} $ENV{FFTW3_DIR}/lib HINTS ${PC_FFTW3F_LIBDIR} ${PC_FFTW3F_LIBRARY_DIRS} $ENV{FFTW3_DIR}/lib
@ -22,12 +28,17 @@ find_library(FFTW3F_LIBRARY
/usr/lib) /usr/lib)
set(FFTW3F_LIBRARIES ${FFTW3F_LIBRARY} ) set(FFTW3F_LIBRARIES ${FFTW3F_LIBRARY} )
set(FFTW3F_STATIC_LIBRARIES ${FFTW3F_STATIC_LIBRARY} )
set(FFTW3F_INCLUDE_DIRS ${FFTW3F_INCLUDE_DIR} ) set(FFTW3F_INCLUDE_DIRS ${FFTW3F_INCLUDE_DIR} )
message(STATUS "FFTW3F LIBRARIES: " ${FFTW3F_LIBRARIES})
message(STATUS "FFTW3F STATIC LIBRARIES: " ${FFTW3F_STATIC_LIBRARIES})
message(STATUS "FFTW3F INCLUDE DIRS: " ${FFTW3F_INCLUDE_DIRS})
include(FindPackageHandleStandardArgs) include(FindPackageHandleStandardArgs)
# handle the QUIETLY and REQUIRED arguments and set FFTW3F_FOUND to TRUE # handle the QUIETLY and REQUIRED arguments and set FFTW3F_FOUND to TRUE
# if all listed variables are TRUE # if all listed variables are TRUE
find_package_handle_standard_args(fftw3f DEFAULT_MSG find_package_handle_standard_args(fftw3f DEFAULT_MSG
FFTW3F_LIBRARY FFTW3F_INCLUDE_DIR) FFTW3F_LIBRARY FFTW3F_STATIC_LIBRARY FFTW3F_INCLUDE_DIR)
mark_as_advanced(FFTW3F_INCLUDE_DIR FFTW3F_LIBRARY ) mark_as_advanced(FFTW3F_INCLUDE_DIR FFTW3F_STATIC_LIBRARY FFTW3F_LIBRARY )

@ -32,9 +32,23 @@ FIND_LIBRARY(
/usr/lib64 /usr/lib64
) )
FIND_LIBRARY(
MBEDTLS_STATIC_LIBRARIES
NAMES libmbedcrypto.a
HINTS $ENV{MBEDTLS_DIR}/lib
${PC_MBEDTLS_LIBDIR}
${CMAKE_INSTALL_PREFIX}/lib
${CMAKE_INSTALL_PREFIX}/lib64
PATHS /usr/local/lib
/usr/local/lib64
/usr/lib
/usr/lib64
)
message(STATUS "MBEDTLS LIBRARIES: " ${MBEDTLS_LIBRARIES}) message(STATUS "MBEDTLS LIBRARIES: " ${MBEDTLS_LIBRARIES})
message(STATUS "MBEDTLS STATIC LIBRARIES: " ${MBEDTLS_STATIC_LIBRARIES})
message(STATUS "MBEDTLS INCLUDE DIRS: " ${MBEDTLS_INCLUDE_DIRS}) message(STATUS "MBEDTLS INCLUDE DIRS: " ${MBEDTLS_INCLUDE_DIRS})
INCLUDE(FindPackageHandleStandardArgs) INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(MBEDTLS DEFAULT_MSG MBEDTLS_LIBRARIES MBEDTLS_INCLUDE_DIRS) FIND_PACKAGE_HANDLE_STANDARD_ARGS(MBEDTLS DEFAULT_MSG MBEDTLS_LIBRARIES MBEDTLS_INCLUDE_DIRS)
MARK_AS_ADVANCED(MBEDTLS_LIBRARIES MBEDTLS_INCLUDE_DIRS) MARK_AS_ADVANCED(MBEDTLS_LIBRARIES MBEDTLS_STATIC_LIBRARIES MBEDTLS_INCLUDE_DIRS)

@ -31,9 +31,23 @@ FIND_LIBRARY(
/usr/lib64 /usr/lib64
) )
FIND_LIBRARY(
POLARSSL_STATIC_LIBRARIES
NAMES libpolarssl.a
HINTS $ENV{POLARSSL_DIR}/lib
${PC_POLARSSL_LIBDIR}
${CMAKE_INSTALL_PREFIX}/lib
${CMAKE_INSTALL_PREFIX}/lib64
PATHS /usr/local/lib
/usr/local/lib64
/usr/lib
/usr/lib64
)
message(STATUS "POLARSSL LIBRARIES: " ${POLARSSL_LIBRARIES}) message(STATUS "POLARSSL LIBRARIES: " ${POLARSSL_LIBRARIES})
message(STATUS "POLARSSL STATIC LIBRARIES: " ${POLARSSL_STATIC_LIBRARIES})
message(STATUS "POLARSSL INCLUDE DIRS: " ${POLARSSL_INCLUDE_DIRS}) message(STATUS "POLARSSL INCLUDE DIRS: " ${POLARSSL_INCLUDE_DIRS})
INCLUDE(FindPackageHandleStandardArgs) INCLUDE(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(POLARSSL DEFAULT_MSG POLARSSL_LIBRARIES POLARSSL_INCLUDE_DIRS) FIND_PACKAGE_HANDLE_STANDARD_ARGS(POLARSSL DEFAULT_MSG POLARSSL_LIBRARIES POLARSSL_INCLUDE_DIRS)
MARK_AS_ADVANCED(POLARSSL_LIBRARIES POLARSSL_INCLUDE_DIRS) MARK_AS_ADVANCED(POLARSSL_STATIC_LIBRARIES POLARSSL_LIBRARIES POLARSSL_INCLUDE_DIRS)

@ -156,6 +156,9 @@ public:
return pool->allocate(debug_name); return pool->allocate(debug_name);
} }
void deallocate(byte_buffer_t *b) { void deallocate(byte_buffer_t *b) {
if(!b) {
return;
}
b->reset(); b->reset();
pool->deallocate(b); pool->deallocate(b);
} }

@ -38,15 +38,19 @@
#include <stdarg.h> #include <stdarg.h>
#include <string> #include <string>
#include "srslte/common/log.h" #include "srslte/common/log.h"
#include "logger.h" #include "srslte/common/logger.h"
#include "srslte/common/logger_stdout.h"
namespace srslte { namespace srslte {
typedef std::string* str_ptr;
class log_filter : public srslte::log class log_filter : public srslte::log
{ {
public: public:
log_filter(); log_filter();
log_filter(std::string layer);
log_filter(std::string layer, logger *logger_, bool tti=false); log_filter(std::string layer, logger *logger_, bool tti=false);
void init(std::string layer, logger *logger_, bool tti=false); void init(std::string layer, logger *logger_, bool tti=false);
@ -71,6 +75,8 @@ private:
logger *logger_h; logger *logger_h;
bool do_tti; bool do_tti;
logger_stdout def_logger_stdout;
void all_log(srslte::LOG_LEVEL_ENUM level, uint32_t tti, char *msg); void all_log(srslte::LOG_LEVEL_ENUM level, uint32_t tti, char *msg);
void all_log(srslte::LOG_LEVEL_ENUM level, uint32_t tti, char *msg, uint8_t *hex, int size); void all_log(srslte::LOG_LEVEL_ENUM level, uint32_t tti, char *msg, uint8_t *hex, int size);
void all_log_line(srslte::LOG_LEVEL_ENUM level, uint32_t tti, std::string file, int line, char *msg); void all_log_line(srslte::LOG_LEVEL_ENUM level, uint32_t tti, std::string file, int line, char *msg);

@ -1,82 +0,0 @@
/**
*
* \section COPYRIGHT
*
* Copyright 2013-2015 Software Radio Systems Limited
*
* \section LICENSE
*
* This file is part of the srsUE library.
*
* srsUE is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* srsUE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* A copy of the GNU Affero General Public License can be found in
* the LICENSE file in the top-level directory of this distribution
* and at http://www.gnu.org/licenses/.
*
*/
/******************************************************************************
* File: log_stout.h
*
* Description: Logging service through standard output. Inherits log interface
*
* Reference:
*****************************************************************************/
#ifndef LOGSTDOUT_H
#define LOGSTDOUT_H
#include <stdarg.h>
#include <string>
#include "srslte/common/log.h"
namespace srslte {
class log_stdout : public log
{
public:
log_stdout(std::string service_name_) : log(service_name_) { }
void console(std::string message, ...);
void error(std::string message, ...);
void warning(std::string message, ...);
void info(std::string message, ...);
void debug(std::string message, ...);
// Same with hex dump
void error_hex(uint8_t *hex, int size, std::string message, ...);
void warning_hex(uint8_t *hex, int size, std::string message, ...);
void info_hex(uint8_t *hex, int size, std::string message, ...);
void debug_hex(uint8_t *hex, int size, std::string message, ...);
// Same with line and file info
void error_line(std::string file, int line, std::string message, ...);
void warning_line(std::string file, int line, std::string message, ...);
void info_line(std::string file, int line, std::string message, ...);
void debug_line(std::string file, int line, std::string message, ...);
private:
void printlog(srslte::LOG_LEVEL_ENUM level, uint32_t tti, std::string file, int line, std::string message, va_list args);
void printlog(srslte::LOG_LEVEL_ENUM level, uint32_t tti, std::string message, va_list args);
void all_log(srslte::LOG_LEVEL_ENUM level, uint32_t tti, char *msg);
void all_log(srslte::LOG_LEVEL_ENUM level, uint32_t tti, char *msg, uint8_t *hex, int size);
void all_log_line(srslte::LOG_LEVEL_ENUM level, uint32_t tti, std::string file, int line, char *msg);
std::string now_time();
std::string hex_string(uint8_t *hex, int size);
};
}
#endif

@ -26,49 +26,23 @@
/****************************************************************************** /******************************************************************************
* File: logger.h * File: logger.h
* Description: Common log object. Maintains a queue of log messages * Description: Interface for logging output
* and runs a thread to read messages and write to file.
* Multiple producers, single consumer. If full, producers
* increase queue size. If empty, consumer blocks.
*****************************************************************************/ *****************************************************************************/
#ifndef LOGGER_H #ifndef LOGGER_H
#define LOGGER_H #define LOGGER_H
#include <stdio.h> #include <stdio.h>
#include <deque>
#include <string> #include <string>
#include "srslte/common/threads.h"
namespace srslte { namespace srslte {
typedef std::string* str_ptr; class logger
class logger : public thread
{ {
public: public:
logger(); virtual void log(std::string *msg) = 0;
logger(std::string file);
~logger();
void init(std::string file);
void log(const char *msg);
void log(str_ptr msg);
private:
void run_thread();
void flush();
FILE* logfile;
bool inited;
bool not_done;
std::string filename;
pthread_cond_t not_empty;
pthread_cond_t not_full;
pthread_mutex_t mutex;
pthread_t thread;
std::deque<str_ptr> buffer;
}; };
} // namespace srsue } // namespace srslte
#endif // LOGGER_H #endif // LOGGER_H

@ -0,0 +1,76 @@
/**
*
* \section COPYRIGHT
*
* Copyright 2013-2015 Software Radio Systems Limited
*
* \section LICENSE
*
* This file is part of the srsUE library.
*
* srsUE is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* srsUE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* A copy of the GNU Affero General Public License can be found in
* the LICENSE file in the top-level directory of this distribution
* and at http://www.gnu.org/licenses/.
*
*/
/******************************************************************************
* File: logger_file.h
* Description: Common log object. Maintains a queue of log messages
* and runs a thread to read messages and write to file.
* Multiple producers, single consumer. If full, producers
* increase queue size. If empty, consumer blocks.
*****************************************************************************/
#ifndef LOGGER_FILE_H
#define LOGGER_FILE_H
#include <stdio.h>
#include <deque>
#include <string>
#include "srslte/common/logger.h"
#include "srslte/common/threads.h"
namespace srslte {
typedef std::string* str_ptr;
class logger_file : public thread, public logger
{
public:
logger_file();
logger_file(std::string file);
~logger_file();
void init(std::string file);
// Implementation of log_out
void log(str_ptr msg);
void log(const char *msg);
private:
void run_thread();
void flush();
FILE* logfile;
bool inited;
bool not_done;
std::string filename;
pthread_cond_t not_empty;
pthread_cond_t not_full;
pthread_mutex_t mutex;
pthread_t thread;
std::deque<str_ptr> buffer;
};
} // namespace srsue
#endif // LOGGER_H

@ -0,0 +1,51 @@
/**
*
* \section COPYRIGHT
*
* Copyright 2013-2015 Software Radio Systems Limited
*
* \section LICENSE
*
* This file is part of the srsUE library.
*
* srsUE is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* srsUE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* A copy of the GNU Affero General Public License can be found in
* the LICENSE file in the top-level directory of this distribution
* and at http://www.gnu.org/licenses/.
*
*/
/******************************************************************************
* File: logger_stdout.h
* Description: Interface for logging output
*****************************************************************************/
#ifndef LOGGER_STDOUT_H
#define LOGGER_STDOUT_H
#include <stdio.h>
#include <string>
#include "srslte/common/logger.h"
namespace srslte {
class logger_stdout : public logger
{
public:
void log(std::string *msg) {
fprintf(stdout, "%s", msg->c_str());
}
};
} // namespace srslte
#endif // LOGGER_H

@ -57,6 +57,8 @@ SRSLTE_API void srslte_vec_sc_prod_ccc_sse(cf_t *x, cf_t h, cf_t *z, uint32_t le
SRSLTE_API void srslte_vec_prod_ccc_sse(cf_t *x,cf_t *y, cf_t *z, uint32_t len); SRSLTE_API void srslte_vec_prod_ccc_sse(cf_t *x,cf_t *y, cf_t *z, uint32_t len);
SRSLTE_API void srslte_vec_prod_sss_sse(short *x, short *y, short *z, uint32_t len);
SRSLTE_API void srslte_vec_prod_sss_avx2(short *x, short *y, short *z, uint32_t len); SRSLTE_API void srslte_vec_prod_sss_avx2(short *x, short *y, short *z, uint32_t len);
SRSLTE_API cf_t srslte_vec_dot_prod_conj_ccc_sse(cf_t *x, cf_t *y, uint32_t len); SRSLTE_API cf_t srslte_vec_dot_prod_conj_ccc_sse(cf_t *x, cf_t *y, uint32_t len);
@ -83,6 +85,12 @@ SRSLTE_API void srslte_vec_convert_fi_sse(float *x, int16_t *z, float scale, uin
SRSLTE_API void srslte_vec_mult_scalar_cf_f_avx( cf_t *z,const cf_t *x,const float h,const uint32_t len); SRSLTE_API void srslte_vec_mult_scalar_cf_f_avx( cf_t *z,const cf_t *x,const float h,const uint32_t len);
SRSLTE_API void srslte_vec_lut_sss_sse(short *x, unsigned short *lut, short *y, uint32_t len);
SRSLTE_API void srslte_vec_convert_fi_sse(float *x, int16_t *z, float scale, uint32_t len);
SRSLTE_API void srslte_vec_sc_prod_cfc_avx(const cf_t *x,const float h,cf_t *y,const uint32_t len);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

@ -66,14 +66,13 @@ public:
void write_pdu_pcch(byte_buffer_t *sdu); void write_pdu_pcch(byte_buffer_t *sdu);
private: private:
log *pdcp_log;
pdcp_entity pdcp_array[SRSLTE_N_RADIO_BEARERS];
srsue::rlc_interface_pdcp *rlc; srsue::rlc_interface_pdcp *rlc;
srsue::rrc_interface_pdcp *rrc; srsue::rrc_interface_pdcp *rrc;
srsue::gw_interface_pdcp *gw; srsue::gw_interface_pdcp *gw;
uint8_t direction; log *pdcp_log;
pdcp_entity pdcp_array[SRSLTE_N_RADIO_BEARERS];
uint8_t direction;
bool valid_lcid(uint32_t lcid); bool valid_lcid(uint32_t lcid);
}; };

@ -40,6 +40,11 @@ log_filter::log_filter()
do_tti = false; do_tti = false;
} }
log_filter::log_filter(std::string layer)
{
init(layer, &def_logger_stdout, tti);
}
log_filter::log_filter(std::string layer, logger *logger_, bool tti) log_filter::log_filter(std::string layer, logger *logger_, bool tti)
{ {
init(layer, logger_, tti); init(layer, logger_, tti);

@ -1,290 +0,0 @@
/**
*
* \section COPYRIGHT
*
* Copyright 2013-2015 Software Radio Systems Limited
*
* \section LICENSE
*
* This file is part of the srsUE library.
*
* srsUE is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* srsUE is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* A copy of the GNU Affero General Public License can be found in
* the LICENSE file in the top-level directory of this distribution
* and at http://www.gnu.org/licenses/.
*
*/
#include <iostream>
#include <sstream>
#include <iomanip>
#include <string>
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <stdarg.h>
#include <string>
#include "srslte/common/log_stdout.h"
using namespace std;
namespace srslte {
void log_stdout::all_log(srslte::LOG_LEVEL_ENUM level,
uint32_t tti,
char *msg)
{
std::stringstream ss;
ss << now_time() << " ";
ss << "[" <<get_service_name() << "] ";
ss << log_level_text[level] << " ";
ss << "[" << std::setfill('0') << std::setw(5) << tti << "] ";
ss << msg;
cout << ss.str();
}
void log_stdout::all_log(srslte::LOG_LEVEL_ENUM level,
uint32_t tti,
char *msg,
uint8_t *hex,
int size)
{
std::stringstream ss;
ss << now_time() << " ";
ss << "[" <<get_service_name() << "] ";
ss << log_level_text[level] << " ";
ss << "[" << std::setfill('0') << std::setw(5) << tti << "] ";
ss << msg << std::endl;
ss << hex_string(hex, size);
cout << ss.str();
}
void log_stdout::all_log_line(srslte::LOG_LEVEL_ENUM level,
uint32_t tti,
std::string file,
int line,
char *msg)
{
std::stringstream ss;
ss << now_time() << " ";
ss << "[" <<get_service_name() << "] ";
ss << log_level_text[level] << " ";
ss << "[" << std::setfill('0') << std::setw(5) << tti << "] ";
ss << msg;
cout << ss.str();
}
void log_stdout::console(std::string message, ...) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
printf("%s",args_msg); // Print directly to stdout
va_end(args);
free(args_msg);
}
void log_stdout::error(std::string message, ...) {
if (level >= LOG_LEVEL_ERROR) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log(LOG_LEVEL_ERROR, tti, args_msg);
va_end(args);
free(args_msg);
}
}
void log_stdout::warning(std::string message, ...) {
if (level >= LOG_LEVEL_WARNING) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log(LOG_LEVEL_WARNING, tti, args_msg);
va_end(args);
free(args_msg);
}
}
void log_stdout::info(std::string message, ...) {
if (level >= LOG_LEVEL_INFO) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log(LOG_LEVEL_INFO, tti, args_msg);
va_end(args);
free(args_msg);
}
}
void log_stdout::debug(std::string message, ...) {
if (level >= LOG_LEVEL_DEBUG) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log(LOG_LEVEL_DEBUG, tti, args_msg);
va_end(args);
free(args_msg);
}
}
void log_stdout::error_hex(uint8_t *hex, int size, std::string message, ...) {
if (level >= LOG_LEVEL_ERROR) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log(LOG_LEVEL_ERROR, tti, args_msg, hex, size);
va_end(args);
free(args_msg);
}
}
void log_stdout::warning_hex(uint8_t *hex, int size, std::string message, ...) {
if (level >= LOG_LEVEL_WARNING) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log(LOG_LEVEL_WARNING, tti, args_msg, hex, size);
va_end(args);
free(args_msg);
}
}
void log_stdout::info_hex(uint8_t *hex, int size, std::string message, ...) {
if (level >= LOG_LEVEL_INFO) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log(LOG_LEVEL_INFO, tti, args_msg, hex, size);
va_end(args);
free(args_msg);
}
}
void log_stdout::debug_hex(uint8_t *hex, int size, std::string message, ...) {
if (level >= LOG_LEVEL_DEBUG) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log(LOG_LEVEL_DEBUG, tti, args_msg, hex, size);
va_end(args);
free(args_msg);
}
}
void log_stdout::error_line(std::string file, int line, std::string message, ...)
{
if (level >= LOG_LEVEL_ERROR) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log_line(LOG_LEVEL_ERROR, tti, file, line, args_msg);
va_end(args);
free(args_msg);
}
}
void log_stdout::warning_line(std::string file, int line, std::string message, ...)
{
if (level >= LOG_LEVEL_WARNING) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log_line(LOG_LEVEL_WARNING, tti, file, line, args_msg);
va_end(args);
free(args_msg);
}
}
void log_stdout::info_line(std::string file, int line, std::string message, ...)
{
if (level >= LOG_LEVEL_INFO) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log_line(LOG_LEVEL_INFO, tti, file, line, args_msg);
va_end(args);
free(args_msg);
}
}
void log_stdout::debug_line(std::string file, int line, std::string message, ...)
{
if (level >= LOG_LEVEL_DEBUG) {
char *args_msg;
va_list args;
va_start(args, message);
if(vasprintf(&args_msg, message.c_str(), args) > 0)
all_log_line(LOG_LEVEL_DEBUG, tti, file, line, args_msg);
va_end(args);
free(args_msg);
}
}
std::string log_stdout::now_time()
{
struct timeval rawtime;
struct tm * timeinfo;
char buffer[64];
char us[16];
gettimeofday(&rawtime, NULL);
timeinfo = localtime(&rawtime.tv_sec);
strftime(buffer,64,"%H:%M:%S",timeinfo);
strcat(buffer,".");
snprintf(us,16,"%ld",rawtime.tv_usec);
strcat(buffer,us);
return std::string(buffer);
}
std::string log_stdout::hex_string(uint8_t *hex, int size)
{
std::stringstream ss;
int c = 0;
ss << std::hex << std::setfill('0');
if(hex_limit >= 0) {
size = (size > hex_limit) ? hex_limit : size;
}
while(c < size) {
ss << " " << std::setw(4) << static_cast<unsigned>(c) << ": ";
int tmp = (size-c < 16) ? size-c : 16;
for(int i=0;i<tmp;i++) {
ss << std::setw(2) << static_cast<unsigned>(hex[c++]) << " ";
}
ss << "\n";
}
return ss.str();
}
}

@ -27,20 +27,20 @@
#define LOG_BUFFER_SIZE 1024*32 #define LOG_BUFFER_SIZE 1024*32
#include "srslte/common/logger.h" #include "srslte/common/logger_file.h"
using namespace std; using namespace std;
namespace srslte{ namespace srslte{
logger::logger() logger_file::logger_file()
:inited(false) :inited(false)
,not_done(true) ,not_done(true)
{} {}
logger::~logger() { logger_file::~logger_file() {
not_done = false; not_done = false;
log("Closing log"); log(new std::string("Closing log"));
if(inited) { if(inited) {
wait_thread_finish(); wait_thread_finish();
flush(); flush();
@ -48,7 +48,7 @@ logger::~logger() {
} }
} }
void logger::init(std::string file) { void logger_file::init(std::string file) {
pthread_mutex_init(&mutex, NULL); pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&not_empty, NULL); pthread_cond_init(&not_empty, NULL);
pthread_cond_init(&not_full, NULL); pthread_cond_init(&not_full, NULL);
@ -61,19 +61,18 @@ void logger::init(std::string file) {
inited = true; inited = true;
} }
void logger::log(const char *msg) { void logger_file::log(const char *msg) {
str_ptr s_ptr(new std::string(msg)); log(new std::string(msg));
log(s_ptr);
} }
void logger::log(str_ptr msg) { void logger_file::log(str_ptr msg) {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
buffer.push_back(msg); buffer.push_back(msg);
pthread_cond_signal(&not_empty); pthread_cond_signal(&not_empty);
pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex);
} }
void logger::run_thread() { void logger_file::run_thread() {
while(not_done) { while(not_done) {
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
while(buffer.empty()) { while(buffer.empty()) {
@ -89,7 +88,7 @@ void logger::run_thread() {
} }
} }
void logger::flush() { void logger_file::flush() {
std::deque<str_ptr>::iterator it; std::deque<str_ptr>::iterator it;
for(it=buffer.begin();it!=buffer.end();it++) for(it=buffer.begin();it!=buffer.end();it++)
{ {

@ -515,8 +515,8 @@ bool sch_subh::set_bsr(uint32_t buff_size[4], sch_subh::cetype format)
bool sch_subh::set_c_rnti(uint16_t crnti) bool sch_subh::set_c_rnti(uint16_t crnti)
{ {
if (((sch_pdu*)parent)->has_space_ce(2)) { if (((sch_pdu*)parent)->has_space_ce(2)) {
w_payload_ce[0] = (uint8_t) (crnti&0xff00)>>8; w_payload_ce[0] = (uint8_t) ((crnti&0xff00)>>8);
w_payload_ce[1] = (uint8_t) (crnti&0x00ff); w_payload_ce[1] = (uint8_t) ((crnti&0x00ff));
lcid = CRNTI; lcid = CRNTI;
((sch_pdu*)parent)->update_space_ce(2); ((sch_pdu*)parent)->update_space_ce(2);
nof_bytes = 2; nof_bytes = 2;

@ -55,32 +55,7 @@ set(srslte_srcs $<TARGET_OBJECTS:srslte_agc>
) )
add_library(srslte_phy STATIC ${srslte_srcs}) add_library(srslte_phy STATIC ${srslte_srcs})
set_target_properties(srslte_phy PROPERTIES target_link_libraries(srslte_phy ${FFT_LIBRARIES})
VERSION ${SRSLTE_VERSION_MAJOR}.${SRSLTE_VERSION_MINOR})
find_package(MKL)
if(MKL_FOUND)
include_directories(${MKL_INCLUDE_DIRS})
link_directories(${MKL_LIBRARY_DIRS})
else(MKL_FOUND)
find_package(FFTW3F REQUIRED)
if(FFTW3F_FOUND)
include_directories(${FFTW3F_INCLUDE_DIRS})
link_directories(${FFTW3F_LIBRARY_DIRS})
endif(FFTW3F_FOUND)
endif(MKL_FOUND)
if(MKL_FOUND)
if(STATIC_MKL)
target_link_libraries(srslte_phy ${MKL_STATIC_LIBRARIES})
else(STATIC_MKL)
target_link_libraries(srslte_phy ${MKL_LIBRARIES})
endif(STATIC_MKL)
else(MKL_FOUND)
target_link_libraries(srslte_phy ${FFTW3F_LIBRARIES})
endif(MKL_FOUND)
if(VOLK_FOUND) if(VOLK_FOUND)
target_link_libraries(srslte_phy ${VOLK_LIBRARIES}) target_link_libraries(srslte_phy ${VOLK_LIBRARIES})

@ -260,7 +260,7 @@ int srslte_pdsch_init_multi(srslte_pdsch_t *q, srslte_cell_t cell, uint32_t nof_
} }
} }
} }
for (int j=0;j<q->nof_rx_antennas;j++) { for (int j=0;j<SRSLTE_MAX(q->nof_rx_antennas, q->cell.nof_ports);j++) {
q->symbols[j] = srslte_vec_malloc(sizeof(cf_t) * q->max_re); q->symbols[j] = srslte_vec_malloc(sizeof(cf_t) * q->max_re);
if (!q->symbols[j]) { if (!q->symbols[j]) {
goto clean; goto clean;

@ -393,7 +393,7 @@ int srslte_pusch_set_rnti(srslte_pusch_t *q, uint16_t rnti) {
uint32_t i; uint32_t i;
if (!q->users[rnti]) { if (!q->users[rnti]) {
q->users[rnti] = malloc(sizeof(srslte_pusch_user_t)); q->users[rnti] = calloc(1, sizeof(srslte_pusch_user_t));
if (q->users[rnti]) { if (q->users[rnti]) {
for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) { for (i = 0; i < SRSLTE_NSUBFRAMES_X_FRAME; i++) {
if (srslte_sequence_pusch(&q->users[rnti]->seq[i], rnti, 2 * i, q->cell.id, if (srslte_sequence_pusch(&q->users[rnti]->seq[i], rnti, 2 * i, q->cell.id,

@ -240,7 +240,7 @@ void srslte_vec_norm_cfc(cf_t *x, float amplitude, cf_t *y, uint32_t len) {
// Used throughout // Used throughout
void srslte_vec_sc_prod_cfc(cf_t *x, float h, cf_t *z, uint32_t len) { void srslte_vec_sc_prod_cfc(cf_t *x, float h, cf_t *z, uint32_t len) {
#ifdef LV_HAVE_AVX #ifdef LV_HAVE_AVX
srslte_vec_mult_scalar_cf_f_avx(z,x, h, len); srslte_vec_sc_prod_cfc_avx(x,h,z,len);
#else #else
int i; int i;
for (i=0;i<len;i++) { for (i=0;i<len;i++) {

@ -820,7 +820,7 @@ void srslte_vec_abs_square_cf_sse(cf_t *x, float *z, uint32_t len) {
//srslte_32fc_s32f_multiply_32fc_avx //srslte_32fc_s32f_multiply_32fc_avx
void srslte_vec_mult_scalar_cf_f_avx( cf_t *z,const cf_t *x,const float h,const uint32_t len) void srslte_vec_sc_prod_cfc_avx( const cf_t *x,const float h,cf_t *z,const uint32_t len)
{ {
#ifdef LV_HAVE_AVX #ifdef LV_HAVE_AVX

@ -208,12 +208,14 @@ uint32_t rlc_am::get_total_buffer_state()
} }
// Bytes needed for tx SDUs // Bytes needed for tx SDUs
n_sdus = tx_sdu_queue.size(); if(tx_window.size() < 1024) {
n_bytes += tx_sdu_queue.size_bytes(); n_sdus = tx_sdu_queue.size();
if(tx_sdu) n_bytes += tx_sdu_queue.size_bytes();
{ if(tx_sdu)
n_sdus++; {
n_bytes += tx_sdu->N_bytes; n_sdus++;
n_bytes += tx_sdu->N_bytes;
}
} }
// Room needed for header extensions? (integer rounding) // Room needed for header extensions? (integer rounding)
@ -256,7 +258,7 @@ uint32_t rlc_am::get_buffer_state()
} }
// Bytes needed for tx SDUs // Bytes needed for tx SDUs
if(tx_window.size() < RLC_AM_WINDOW_SIZE) { if(tx_window.size() < 1024) {
n_sdus = tx_sdu_queue.size(); n_sdus = tx_sdu_queue.size();
n_bytes = tx_sdu_queue.size_bytes(); n_bytes = tx_sdu_queue.size_bytes();
if(tx_sdu) if(tx_sdu)
@ -286,6 +288,7 @@ int rlc_am::read_pdu(uint8_t *payload, uint32_t nof_bytes)
pthread_mutex_lock(&mutex); pthread_mutex_lock(&mutex);
log->debug("MAC opportunity - %d bytes\n", nof_bytes); log->debug("MAC opportunity - %d bytes\n", nof_bytes);
log->debug("tx_window size - %d PDUs\n", tx_window.size());
// Tx STATUS if requested // Tx STATUS if requested
if(do_status && !status_prohibited()) { if(do_status && !status_prohibited()) {
@ -298,10 +301,11 @@ int rlc_am::read_pdu(uint8_t *payload, uint32_t nof_bytes)
return build_retx_pdu(payload, nof_bytes); return build_retx_pdu(payload, nof_bytes);
} }
pthread_mutex_unlock(&mutex);
// Build a PDU from SDUs // Build a PDU from SDUs
return build_data_pdu(payload, nof_bytes); int ret = build_data_pdu(payload, nof_bytes);
pthread_mutex_unlock(&mutex);
return ret;
} }
void rlc_am::write_pdu(uint8_t *payload, uint32_t nof_bytes) void rlc_am::write_pdu(uint8_t *payload, uint32_t nof_bytes)
@ -582,6 +586,16 @@ int rlc_am::build_data_pdu(uint8_t *payload, uint32_t nof_bytes)
byte_buffer_t *pdu = pool_allocate; byte_buffer_t *pdu = pool_allocate;
if (!pdu) { if (!pdu) {
log->console("Fatal Error: Could not allocate PDU in build_data_pdu()\n"); log->console("Fatal Error: Could not allocate PDU in build_data_pdu()\n");
log->console("tx_window size: %d PDUs\n", tx_window.size());
log->console("vt_a = %d, vt_ms = %d, vt_s = %d, poll_sn = %d "
"vr_r = %d, vr_mr = %d, vr_x = %d, vr_ms = %d, vr_h = %d\n",
vt_a, vt_ms, vt_s, poll_sn,
vr_r, vr_mr, vr_x, vr_ms, vr_h);
log->console("retx_queue size: %d PDUs\n", retx_queue.size());
std::map<uint32_t, rlc_amd_tx_pdu_t>::iterator txit;
for(txit = tx_window.begin(); txit != tx_window.end(); txit++) {
log->console("tx_window - SN: %d\n", txit->first);
}
exit(-1); exit(-1);
} }
rlc_amd_pdu_header_t header; rlc_amd_pdu_header_t header;
@ -897,13 +911,13 @@ void rlc_am::handle_control_pdu(uint8_t *payload, uint32_t nof_bytes)
poll_retx_timeout.reset(); poll_retx_timeout.reset();
// Handle ACKs and NACKs // Handle ACKs and NACKs
std::map<uint32_t, rlc_amd_tx_pdu_t>::iterator it;
bool update_vt_a = true; bool update_vt_a = true;
uint32_t i = vt_a; uint32_t i = vt_a;
while(TX_MOD_BASE(i) < TX_MOD_BASE(status.ack_sn) && while(TX_MOD_BASE(i) < TX_MOD_BASE(status.ack_sn) &&
TX_MOD_BASE(i) < TX_MOD_BASE(vt_s)) TX_MOD_BASE(i) < TX_MOD_BASE(vt_s))
{ {
std::map<uint32_t, rlc_amd_tx_pdu_t>::iterator it;
bool nack = false; bool nack = false;
for(uint32_t j=0;j<status.N_nack;j++) { for(uint32_t j=0;j<status.N_nack;j++) {
if(status.nacks[j].nack_sn == i) { if(status.nacks[j].nack_sn == i) {
@ -943,14 +957,16 @@ void rlc_am::handle_control_pdu(uint8_t *payload, uint32_t nof_bytes)
if(!nack) { if(!nack) {
//ACKed SNs get marked and removed from tx_window if possible //ACKed SNs get marked and removed from tx_window if possible
it = tx_window.find(i); if(tx_window.count(i) > 0) {
if(tx_window.end() != it) it = tx_window.find(i);
{ it->second.is_acked = true;
tx_window[i].is_acked = true; if(it->second.buf) {
pool->deallocate(it->second.buf);
it->second.buf = 0;
}
if(update_vt_a) if(update_vt_a)
{ {
pool->deallocate(tx_window[i].buf); tx_window.erase(it);
tx_window.erase(i);
vt_a = (vt_a + 1)%MOD; vt_a = (vt_a + 1)%MOD;
vt_ms = (vt_ms + 1)%MOD; vt_ms = (vt_ms + 1)%MOD;
} }

@ -29,11 +29,12 @@
#include <stdio.h> #include <stdio.h>
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "srslte/common/logger_file.h"
using namespace srslte; using namespace srslte;
typedef struct { typedef struct {
logger *l; logger_file *l;
int thread_id; int thread_id;
}args_t; }args_t;
@ -78,7 +79,7 @@ void* thread_loop_hex(void *a) {
} }
void write(std::string filename) { void write(std::string filename) {
logger l; logger_file l;
l.init(filename); l.init(filename);
pthread_t threads[NTHREADS]; pthread_t threads[NTHREADS];
args_t args[NTHREADS]; args_t args[NTHREADS];

@ -29,12 +29,12 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include "srslte/common/logger.h" #include "srslte/common/logger_file.h"
using namespace srslte; using namespace srslte;
typedef struct { typedef struct {
logger *l; logger_file *l;
int thread_id; int thread_id;
}args_t; }args_t;
@ -44,13 +44,13 @@ void* thread_loop(void *a) {
for(int i=0;i<NMSGS;i++) for(int i=0;i<NMSGS;i++)
{ {
sprintf(buf, "Thread %d: %d", args->thread_id, i); sprintf(buf, "Thread %d: %d", args->thread_id, i);
args->l->log(buf); args->l->log(new std::string(buf));
} }
return NULL; return NULL;
} }
void write(std::string filename) { void write(std::string filename) {
logger l; logger_file l;
l.init(filename); l.init(filename);
pthread_t threads[NTHREADS]; pthread_t threads[NTHREADS];
args_t args[NTHREADS]; args_t args[NTHREADS];

@ -25,7 +25,8 @@
*/ */
#include <iostream> #include <iostream>
#include "srslte/common/log_stdout.h" #include "srslte/common/log_filter.h"
#include "srslte/common/logger_stdout.h"
#include "srslte/upper/rlc_am.h" #include "srslte/upper/rlc_am.h"
#include <assert.h> #include <assert.h>
#define NBUFS 5 #define NBUFS 5
@ -73,8 +74,8 @@ public:
void basic_test() void basic_test()
{ {
srslte::log_stdout log1("RLC_AM_1"); srslte::log_filter log1("RLC_AM_1");
srslte::log_stdout log2("RLC_AM_2"); srslte::log_filter log2("RLC_AM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);
@ -152,8 +153,8 @@ void basic_test()
void concat_test() void concat_test()
{ {
srslte::log_stdout log1("RLC_AM_1"); srslte::log_filter log1("RLC_AM_1");
srslte::log_stdout log2("RLC_AM_2"); srslte::log_filter log2("RLC_AM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);
@ -216,8 +217,8 @@ void concat_test()
void segment_test() void segment_test()
{ {
srslte::log_stdout log1("RLC_AM_1"); srslte::log_filter log1("RLC_AM_1");
srslte::log_stdout log2("RLC_AM_2"); srslte::log_filter log2("RLC_AM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);
@ -298,8 +299,8 @@ void segment_test()
void retx_test() void retx_test()
{ {
srslte::log_stdout log1("RLC_AM_1"); srslte::log_filter log1("RLC_AM_1");
srslte::log_stdout log2("RLC_AM_2"); srslte::log_filter log2("RLC_AM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);
@ -394,8 +395,8 @@ void resegment_test_1()
// PDUs: | 10 | 10 | 10 | 10 | 10 | // PDUs: | 10 | 10 | 10 | 10 | 10 |
// Retx PDU segments: | 5 | 5| // Retx PDU segments: | 5 | 5|
srslte::log_stdout log1("RLC_AM_1"); srslte::log_filter log1("RLC_AM_1");
srslte::log_stdout log2("RLC_AM_2"); srslte::log_filter log2("RLC_AM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);
@ -503,8 +504,8 @@ void resegment_test_2()
// PDUs: | 5 | 10 | 20 | 10 | 5 | // PDUs: | 5 | 10 | 20 | 10 | 5 |
// Retx PDU segments: | 10 | 10 | // Retx PDU segments: | 10 | 10 |
srslte::log_stdout log1("RLC_AM_1"); srslte::log_filter log1("RLC_AM_1");
srslte::log_stdout log2("RLC_AM_2"); srslte::log_filter log2("RLC_AM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);
@ -609,8 +610,8 @@ void resegment_test_3()
// PDUs: | 5 | 5| 20 | 10 | 10 | // PDUs: | 5 | 5| 20 | 10 | 10 |
// Retx PDU segments: | 10 | 10 | // Retx PDU segments: | 10 | 10 |
srslte::log_stdout log1("RLC_AM_1"); srslte::log_filter log1("RLC_AM_1");
srslte::log_stdout log2("RLC_AM_2"); srslte::log_filter log2("RLC_AM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);
@ -711,8 +712,8 @@ void resegment_test_4()
// PDUs: | 5 | 5| 30 | 5 | 5| // PDUs: | 5 | 5| 30 | 5 | 5|
// Retx PDU segments: | 15 | 15 | // Retx PDU segments: | 15 | 15 |
srslte::log_stdout log1("RLC_AM_1"); srslte::log_filter log1("RLC_AM_1");
srslte::log_stdout log2("RLC_AM_2"); srslte::log_filter log2("RLC_AM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);
@ -813,8 +814,8 @@ void resegment_test_5()
// PDUs: |2|3| 40 |3|2| // PDUs: |2|3| 40 |3|2|
// Retx PDU segments: | 20 | 20 | // Retx PDU segments: | 20 | 20 |
srslte::log_stdout log1("RLC_AM_1"); srslte::log_filter log1("RLC_AM_1");
srslte::log_stdout log2("RLC_AM_2"); srslte::log_filter log2("RLC_AM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);
@ -914,8 +915,8 @@ void resegment_test_6()
// PDUs: |10|10|10| 270 | 54 | // PDUs: |10|10|10| 270 | 54 |
// Retx PDU segments: | 120 | 150 | // Retx PDU segments: | 120 | 150 |
srslte::log_stdout log1("RLC_AM_1"); srslte::log_filter log1("RLC_AM_1");
srslte::log_stdout log2("RLC_AM_2"); srslte::log_filter log2("RLC_AM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);

@ -25,7 +25,7 @@
*/ */
#include <iostream> #include <iostream>
#include "srslte/common/log_stdout.h" #include "srslte/common/log_filter.h"
#include "srslte/upper/rlc_um.h" #include "srslte/upper/rlc_um.h"
#include <assert.h> #include <assert.h>
@ -78,8 +78,8 @@ public:
void basic_test() void basic_test()
{ {
srslte::log_stdout log1("RLC_UM_1"); srslte::log_filter log1("RLC_UM_1");
srslte::log_stdout log2("RLC_UM_2"); srslte::log_filter log2("RLC_UM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);
@ -146,8 +146,8 @@ void basic_test()
void loss_test() void loss_test()
{ {
srslte::log_stdout log1("RLC_UM_1"); srslte::log_filter log1("RLC_UM_1");
srslte::log_stdout log2("RLC_UM_2"); srslte::log_filter log2("RLC_UM_2");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log2.set_level(srslte::LOG_LEVEL_DEBUG); log2.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);

@ -21,9 +21,9 @@
find_package(LibConfig REQUIRED) find_package(LibConfig REQUIRED)
find_package(SCTP REQUIRED) find_package(SCTP REQUIRED)
if(STATIC_LIBCONFIGPP) if(BUILD_STATIC)
set(LIBCONFIGPP_LIBRARIES "${LIBCONFIGPP_STATIC_LIBRARY_PATH}") set(LIBCONFIGPP_LIBRARIES "${LIBCONFIGPP_STATIC_LIBRARY_PATH}")
endif(STATIC_LIBCONFIGPP) endif(BUILD_STATIC)
if(NOT Boost_FOUND) if(NOT Boost_FOUND)
message(FATAL_ERROR "Boost required to compile srsENB") message(FATAL_ERROR "Boost required to compile srsENB")

@ -50,7 +50,7 @@
#include "srslte/common/bcd_helpers.h" #include "srslte/common/bcd_helpers.h"
#include "srslte/common/buffer_pool.h" #include "srslte/common/buffer_pool.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/common/logger.h" #include "srslte/common/logger_file.h"
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "srslte/common/mac_pcap.h" #include "srslte/common/mac_pcap.h"
#include "srslte/interfaces/sched_interface.h" #include "srslte/interfaces/sched_interface.h"
@ -173,15 +173,15 @@ private:
srsenb::gtpu gtpu; srsenb::gtpu gtpu;
srsenb::s1ap s1ap; srsenb::s1ap s1ap;
srslte::logger logger; srslte::logger_file logger;
srslte::log_filter rf_log; srslte::log_filter rf_log;
std::vector<void*> phy_log; std::vector<void*> phy_log;
srslte::log_filter mac_log; srslte::log_filter mac_log;
srslte::log_filter rlc_log; srslte::log_filter rlc_log;
srslte::log_filter pdcp_log; srslte::log_filter pdcp_log;
srslte::log_filter rrc_log; srslte::log_filter rrc_log;
srslte::log_filter gtpu_log; srslte::log_filter gtpu_log;
srslte::log_filter s1ap_log; srslte::log_filter s1ap_log;
srslte::byte_buffer_pool *pool; srslte::byte_buffer_pool *pool;

@ -5,9 +5,9 @@ add_subdirectory(upper)
# Link libstdc++ and libgcc # Link libstdc++ and libgcc
if(STATIC_LIB) if(BUILD_STATIC)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++ -static-libgcc") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++ -static-libgcc")
endif(STATIC_LIB) endif(BUILD_STATIC)
if (RPATH) if (RPATH)
@ -33,6 +33,8 @@ if (RPATH)
set_target_properties(srsenb PROPERTIES INSTALL_RPATH ".") set_target_properties(srsenb PROPERTIES INSTALL_RPATH ".")
endif (RPATH) endif (RPATH)
install(TARGETS srsenb DESTINATION ${RUNTIME_DIR})
######################################################################## ########################################################################
# Option to run command after build (useful for remote builds) # Option to run command after build (useful for remote builds)
######################################################################## ########################################################################

@ -6,7 +6,7 @@
#include "srslte/interfaces/enb_interfaces.h" #include "srslte/interfaces/enb_interfaces.h"
#include "srslte/interfaces/sched_interface.h" #include "srslte/interfaces/sched_interface.h"
#include "srslte/common/log_stdout.h" #include "srslte/common/log_filter.h"
#include "srslte/radio/radio.h" #include "srslte/radio/radio.h"
#include "srslte/phy/utils/debug.h" #include "srslte/phy/utils/debug.h"
@ -62,7 +62,7 @@ private:
// Create classes // Create classes
srslte::log_stdout log_out("ALL"); srslte::log_filter log_out("ALL");
srsenb::sched my_sched; srsenb::sched my_sched;
srsenb::dl_metric_rr dl_metric; srsenb::dl_metric_rr dl_metric;
srsenb::ul_metric_rr ul_metric; srsenb::ul_metric_rr ul_metric;

@ -16,7 +16,7 @@
#include "srslte/interfaces/enb_interfaces.h" #include "srslte/interfaces/enb_interfaces.h"
#include "srslte/common/common.h" #include "srslte/common/common.h"
#include "srslte/common/buffer_pool.h" #include "srslte/common/buffer_pool.h"
#include "srslte/common/logger.h" #include "srslte/common/logger_file.h"
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "srslte/upper/rlc.h" #include "srslte/upper/rlc.h"
#include "srslte/radio/radio.h" #include "srslte/radio/radio.h"
@ -320,11 +320,11 @@ private:
// Create classes // Create classes
srslte::logger logger; srslte::logger_file logger;
srslte::log_filter log_phy; srslte::log_filter log_phy;
srslte::log_filter log_mac; srslte::log_filter log_mac;
srslte::log_filter log_rlc; srslte::log_filter log_rlc;
srslte::log_filter log_tester; srslte::log_filter log_tester;
srsenb::phy my_phy; srsenb::phy my_phy;
srsenb::mac my_mac; srsenb::mac my_mac;
srslte::rlc my_rlc; srslte::rlc my_rlc;

@ -49,7 +49,7 @@
#include "srslte/common/buffer_pool.h" #include "srslte/common/buffer_pool.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/common/logger.h" #include "srslte/common/logger_file.h"
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "ue_metrics_interface.h" #include "ue_metrics_interface.h"
@ -173,16 +173,16 @@ private:
srslte::gw gw; srslte::gw gw;
srsue::usim usim; srsue::usim usim;
srslte::logger logger; srslte::logger_file logger;
srslte::log_filter rf_log; srslte::log_filter rf_log;
srslte::log_filter phy_log; srslte::log_filter phy_log;
srslte::log_filter mac_log; srslte::log_filter mac_log;
srslte::log_filter rlc_log; srslte::log_filter rlc_log;
srslte::log_filter pdcp_log; srslte::log_filter pdcp_log;
srslte::log_filter rrc_log; srslte::log_filter rrc_log;
srslte::log_filter nas_log; srslte::log_filter nas_log;
srslte::log_filter gw_log; srslte::log_filter gw_log;
srslte::log_filter usim_log; srslte::log_filter usim_log;
srslte::byte_buffer_pool *pool; srslte::byte_buffer_pool *pool;

@ -22,6 +22,11 @@ add_subdirectory(phy)
add_subdirectory(mac) add_subdirectory(mac)
add_subdirectory(upper) add_subdirectory(upper)
# Link libstdc++ and libgcc
if(BUILD_STATIC)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++ -static-libgcc")
endif(BUILD_STATIC)
if (RPATH) if (RPATH)
set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE) set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
endif (RPATH) endif (RPATH)
@ -41,6 +46,8 @@ if (RPATH)
set_target_properties(srsue PROPERTIES INSTALL_RPATH ".") set_target_properties(srsue PROPERTIES INSTALL_RPATH ".")
endif (RPATH) endif (RPATH)
install(TARGETS srsue DESTINATION ${RUNTIME_DIR})
######################################################################## ########################################################################
# Option to run command after build (useful for remote builds) # Option to run command after build (useful for remote builds)
######################################################################## ########################################################################

@ -32,7 +32,7 @@
#include "srslte/radio/radio_multi.h" #include "srslte/radio/radio_multi.h"
#include "phy/phy.h" #include "phy/phy.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/common/log_stdout.h" #include "srslte/common/log_filter.h"
#include "mac/mac.h" #include "mac/mac.h"
#include "srslte/common/mac_pcap.h" #include "srslte/common/mac_pcap.h"
@ -427,7 +427,7 @@ private:
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
srslte::log_stdout mac_log("MAC"), phy_log("PHY"); srslte::log_filter mac_log("MAC"), phy_log("PHY");
rlctest my_rlc; rlctest my_rlc;
parse_args(&prog_args, argc, argv); parse_args(&prog_args, argc, argv);

@ -29,7 +29,7 @@
#include "srslte/phy/utils/debug.h" #include "srslte/phy/utils/debug.h"
#include "phy/phy.h" #include "phy/phy.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/common/log_stdout.h" #include "srslte/common/log_filter.h"
#include "srslte/radio/radio_multi.h" #include "srslte/radio/radio_multi.h"
/********************************************************************** /**********************************************************************
@ -330,7 +330,7 @@ srslte::radio_multi radio;
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
srslte::log_stdout log("PHY"); srslte::log_filter log("PHY");
parse_args(&prog_args, argc, argv); parse_args(&prog_args, argc, argv);

@ -28,7 +28,7 @@
#include "srslte/phy/utils/debug.h" #include "srslte/phy/utils/debug.h"
#include "phy/phy.h" #include "phy/phy.h"
#include "srslte/common/log_stdout.h" #include "srslte/common/log_filter.h"
#include "srslte/interfaces/ue_interfaces.h" #include "srslte/interfaces/ue_interfaces.h"
#include "srslte/radio/radio_multi.h" #include "srslte/radio/radio_multi.h"
@ -153,7 +153,7 @@ srslte::radio_multi radio;
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
srslte::log_stdout log("PHY"); srslte::log_filter log("PHY");
parse_args(&prog_args, argc, argv); parse_args(&prog_args, argc, argv);

@ -21,7 +21,7 @@
#include "srslte/common/threads.h" #include "srslte/common/threads.h"
#include "srslte/common/common.h" #include "srslte/common/common.h"
#include "srslte/common/buffer_pool.h" #include "srslte/common/buffer_pool.h"
#include "srslte/common/logger.h" #include "srslte/common/logger_file.h"
#include "srslte/common/log_filter.h" #include "srslte/common/log_filter.h"
#include "srslte/upper/rlc.h" #include "srslte/upper/rlc.h"
#include "upper/rrc.h" #include "upper/rrc.h"
@ -464,12 +464,12 @@ private:
// Create classes // Create classes
srslte::logger logger; srslte::logger_file logger;
srslte::log_filter log_phy; srslte::log_filter log_phy;
srslte::log_filter log_mac; srslte::log_filter log_mac;
srslte::log_filter log_rlc; srslte::log_filter log_rlc;
srslte::log_filter log_tester; srslte::log_filter log_tester;
srslte::mac_pcap mac_pcap; srslte::mac_pcap mac_pcap;
srsue::phy my_phy; srsue::phy my_phy;
srsue::mac my_mac; srsue::mac my_mac;
srslte::rlc rlc; srslte::rlc rlc;

@ -26,12 +26,12 @@
#include <iostream> #include <iostream>
#include <srslte/srslte.h> #include <srslte/srslte.h>
#include "srslte/common/log_stdout.h" #include "srslte/common/log_filter.h"
#include "srslte/asn1/liblte_rrc.h" #include "srslte/asn1/liblte_rrc.h"
#include "srslte/asn1/liblte_mme.h" #include "srslte/asn1/liblte_mme.h"
void nas_test() { void nas_test() {
srslte::log_stdout log1("NAS"); srslte::log_filter log1("NAS");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);
@ -91,7 +91,7 @@ void nas_test() {
} }
void basic_test() { void basic_test() {
srslte::log_stdout log1("RRC"); srslte::log_filter log1("RRC");
log1.set_level(srslte::LOG_LEVEL_DEBUG); log1.set_level(srslte::LOG_LEVEL_DEBUG);
log1.set_hex_limit(-1); log1.set_hex_limit(-1);

@ -26,7 +26,7 @@
#include <iostream> #include <iostream>
#include "upper/usim.h" #include "upper/usim.h"
#include "srslte/common/log_stdout.h" #include "srslte/common/log_filter.h"
#include <assert.h> #include <assert.h>
using namespace srsue; using namespace srsue;
@ -67,7 +67,7 @@ uint16 mnc = 93;
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
srslte::log_stdout usim_log("USIM"); srslte::log_filter usim_log("USIM");
bool net_valid; bool net_valid;
uint8_t res[16]; uint8_t res[16];

Loading…
Cancel
Save