msb-public
/
PaddleSpeech
mirror of https://github.com/PaddlePaddle/PaddleSpeech
1
0
Code Issues Projects Releases Wiki Activity

refactor logging module; build pass on linux and andorid

Browse Source
pull/2986/head
Hui Zhang 3 years ago
parent 7489e399f1
commit f51a0523a0
17 changed files with 214 additions and 167 deletions
Show Stats Download Patch File Download Diff File

1
runtime/.gitignore vendored
Unescape View File

@ -4,3 +4,4 @@ engine/common/base/log.h
tools/valgrind*
*log
fc_patch/*
test

2
runtime/CMakeLists.txt
Unescape View File

@ -63,9 +63,7 @@ option(WITH_TESTING "unit test" ON)
###############################################################################
include(gflags)
include(glog)
add_dependencies(glog gflags)
# gtest
if(WITH_TESTING)

9
runtime/cmake/glog.cmake
Unescape View File

@ -4,17 +4,18 @@ if(ANDROID)
else() # UNIX
add_definitions(-DWITH_GLOG)
FetchContent_Declare(
extern_glog
glog
URL https://paddleaudio.bj.bcebos.com/build/glog-0.4.0.zip
URL_HASH SHA256=9e1b54eb2782f53cd8af107ecf08d2ab64b8d0dc2b7f5594472f3bd63ca85cdc
)
FetchContent_MakeAvailable(extern_glog)
FetchContent_MakeAvailable(glog)
include_directories(${glog_BINARY_DIR} ${glog_SOURCE_DIR}/src)
endif()
add_library(glog INTERFACE)
if(ANDROID)
add_library(extern_glog INTERFACE)
else() # UNIX
add_dependencies(gtest extern_glog)
add_dependencies(glog gflags)
add_library(extern_glog ALIAS glog)
endif()

10
runtime/cmake/gtest.cmake
Unescape View File

@ -4,20 +4,22 @@ include(FetchContent)
if(ANDROID)
else() # UNIX
FetchContent_Declare(
extern_gtest
gtest
URL https://paddleaudio.bj.bcebos.com/build/gtest-release-1.11.0.zip
URL_HASH SHA256=353571c2440176ded91c2de6d6cd88ddd41401d14692ec1f99e35d013feda55a
)
FetchContent_MakeAvailable(extern_gtest)
FetchContent_MakeAvailable(gtest)
include_directories(${gtest_BINARY_DIR} ${gtest_SOURCE_DIR}/src)
endif()
add_library(gtest INTERFACE)
if(ANDROID)
add_library(extern_gtest INTERFACE)
else() # UNIX
add_dependencies(gtest extern_gtest)
add_dependencies(gtest gflags gflog)
add_library(extern_gtest ALIAS gtest)
endif()
if(WITH_TESTING)

2
runtime/cmake/summary.cmake
Unescape View File

@ -17,6 +17,8 @@ function(pps_summary)
message(STATUS "*************PaddleSpeech Building Summary**********")
message(STATUS " CMake version : ${CMAKE_VERSION}")
message(STATUS " CMake command : ${CMAKE_COMMAND}")
message(STATUS " UNIX : ${UNIX}")
message(STATUS " ANDROID : ${ANDROID}")
message(STATUS " System : ${CMAKE_SYSTEM_NAME}")
message(STATUS " C++ compiler : ${CMAKE_CXX_COMPILER}")
message(STATUS " C++ compiler version : ${CMAKE_CXX_COMPILER_VERSION}")

4
runtime/engine/codelab/glog/CMakeLists.txt
Unescape View File

@ -1,8 +1,8 @@
cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
add_executable(glog_main ${CMAKE_CURRENT_SOURCE_DIR}/glog_main.cc)
target_link_libraries(glog_main glog)
target_link_libraries(glog_main extern_glog)
add_executable(glog_logtostderr_main ${CMAKE_CURRENT_SOURCE_DIR}/glog_logtostderr_main.cc)
target_link_libraries(glog_logtostderr_main glog)
target_link_libraries(glog_logtostderr_main extern_glog)

4
runtime/engine/common/base/CMakeLists.txt
Unescape View File

@ -35,8 +35,8 @@ set(csrc
log_impl.cc
glog_utils.cc
)
add_library(base ${csrc})
else() # UNIX
set(csrc)
add_library(base INTERFACE)
endif()
add_library(base ${csrc})

38
runtime/engine/common/base/log_impl.cc
Unescape View File

@ -22,8 +22,12 @@ std::string LogMessage::s_fatal_logfile_("");
*proc_name = ::ppspeech::__progname;
}
LogMessage::LogMessage(const char* file, int line, Severity level, bool verbose, bool out_to_file /* = false */) : level_(level), verbose_(verbose), out_to_file_(out_to_file) {
LogMessage::LogMessage(const char* file,
int line,
Severity level,
bool verbose,
bool out_to_file /* = false */)
: level_(level), verbose_(verbose), out_to_file_(out_to_file) {
if (FLAGS_logtostderr == 0) {
stream_ = std::shared_ptr<std::ostream>(&std::cout);
} else if (FLAGS_logtostderr == 1) {
@ -57,29 +61,39 @@ std::string LogMessage::s_fatal_logfile_("");
std::string proc_name;
get_curr_proc_info(&pid, &proc_name);
s_debug_logfile_ = std::string("log." + proc_name + ".log.DEBUG." + tmp + "." + pid);
s_info_logfile_ = std::string("log." + proc_name + ".log.INFO." + tmp + "." + pid);
s_warning_logfile_ = std::string("log." + proc_name + ".log.WARNING." + tmp + "." + pid);
s_error_logfile_ = std::string("log." + proc_name + ".log.ERROR." + tmp + "." + pid);
s_fatal_logfile_ = std::string("log." + proc_name + ".log.FATAL." + tmp + "." + pid);
s_debug_logfile_ =
std::string("log." + proc_name + ".log.DEBUG." + tmp + "." + pid);
s_info_logfile_ =
std::string("log." + proc_name + ".log.INFO." + tmp + "." + pid);
s_warning_logfile_ =
std::string("log." + proc_name + ".log.WARNING." + tmp + "." + pid);
s_error_logfile_ =
std::string("log." + proc_name + ".log.ERROR." + tmp + "." + pid);
s_fatal_logfile_ =
std::string("log." + proc_name + ".log.FATAL." + tmp + "." + pid);
}
std::ofstream ofs;
if (level_ == DEBUG) {
stream_ = std::make_shared<std::ofstream>(s_debug_logfile_.c_str(), std::ios::out | std::ios::app);
stream_ = std::make_shared<std::ofstream>(
s_debug_logfile_.c_str(), std::ios::out | std::ios::app);
// ofs.open(s_debug_logfile_.c_str(), std::ios::out | std::ios::app);
} else if (level_ == INFO) {
// ofs.open(s_warning_logfile_.c_str(), std::ios::out | std::ios::app);
stream_ = std::make_shared<std::ofstream>(s_warning_logfile_.c_str(), std::ios::out | std::ios::app);
stream_ = std::make_shared<std::ofstream>(
s_warning_logfile_.c_str(), std::ios::out | std::ios::app);
} else if (level_ == WARNING) {
// ofs.open(s_warning_logfile_.c_str(), std::ios::out | std::ios::app);
stream_ = std::make_shared<std::ofstream>(s_warning_logfile_.c_str(), std::ios::out | std::ios::app);
stream_ = std::make_shared<std::ofstream>(
s_warning_logfile_.c_str(), std::ios::out | std::ios::app);
} else if (level_ == ERROR) {
// ofs.open(s_error_logfile_.c_str(), std::ios::out | std::ios::app);
stream_ = std::make_shared<std::ofstream>(s_error_logfile_.c_str(), std::ios::out | std::ios::app);
stream_ = std::make_shared<std::ofstream>(
s_error_logfile_.c_str(), std::ios::out | std::ios::app);
} else {
// ofs.open(s_fatal_logfile_.c_str(), std::ios::out | std::ios::app);
stream_ = std::make_shared<std::ofstream>(s_fatal_logfile_.c_str(), std::ios::out | std::ios::app);
stream_ = std::make_shared<std::ofstream>(
s_fatal_logfile_.c_str(), std::ios::out | std::ios::app);
}
// stream_ = &ofs;

75
runtime/engine/common/base/log_impl.h
Unescape View File

@ -13,23 +13,26 @@
// limitations under the License.
// modified from https://github.com/Dounm/dlog
// modified form https://android.googlesource.com/platform/art/+/806defa/src/logging.h
// modified form
// https://android.googlesource.com/platform/art/+/806defa/src/logging.h
#pragma once
#include <fstream>
#include <thread>
#include <iostream>
#include <mutex>
#include <string>
#include <sstream>
#include <iostream>
#include <string>
#include <thread>
#include <unistd.h>
#include <stdlib.h>
#include <unistd.h>
#include "base/common.h"
#include "base/macros.h"
#ifndef WITH_GLOG
#include "base/glog_utils.h"
#endif
DECLARE_int32(logtostderr);
@ -50,7 +53,11 @@ class LogMessage {
public:
static void get_curr_proc_info(std::string* pid, std::string* proc_name);
LogMessage(const char* file, int line, Severity level, bool verbose, bool out_to_file = false);
LogMessage(const char* file,
int line,
Severity level,
bool verbose,
bool out_to_file = false);
~LogMessage();
@ -81,23 +88,22 @@ class LogMessage {
} // namespace ppspeech
#ifndef NDEBUG
#define DLOG_DEBUG ppspeech::log::LogMessage \
(__FILE__, __LINE__, ppspeech::log::DEBUG, false)
#define DLOG_DEBUG \
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::DEBUG, false)
#else
#define DLOG_DEBUG ppspeech::log::LogMessage \
(__FILE__, __LINE__, ppspeech::log::DEBUG, true)
#define DLOG_DEBUG \
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::DEBUG, true)
#endif
#define DLOG_INFO ppspeech::log::LogMessage \
(__FILE__, __LINE__, ppspeech::log::INFO, true)
#define DLOG_WARNING ppspeech::log::LogMessage \
(__FILE__, __LINE__, ppspeech::log::WARNING, true)
#define DLOG_ERROR ppspeech::log::LogMessage \
(__FILE__, __LINE__, ppspeech::log::ERROR, true)
#define DLOG_FATAL ppspeech::log::LogMessage \
(__FILE__, __LINE__, ppspeech::log::FATAL, true)
#define DLOG_INFO \
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::INFO, true)
#define DLOG_WARNING \
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::WARNING, true)
#define DLOG_ERROR \
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::ERROR, true)
#define DLOG_FATAL \
ppspeech::log::LogMessage(__FILE__, __LINE__, ppspeech::log::FATAL, true)
#define DLOG_0 DLOG_DEBUG
#define DLOG_1 DLOG_INFO
@ -110,8 +116,11 @@ class LogMessage {
#define VLOG(verboselevel) LOG(verboselevel)
#define CHECK(exp) ppspeech::log::LogMessage \
(__FILE__, __LINE__, ppspeech::log::FATAL, !(exp)).stream() << "Check Failed: " #exp
#define CHECK(exp) \
ppspeech::log::LogMessage( \
__FILE__, __LINE__, ppspeech::log::FATAL, !(exp)) \
.stream() \
<< "Check Failed: " #exp
#define CHECK_EQ(x, y) CHECK((x) == (y))
#define CHECK_NE(x, y) CHECK((x) != (y))
@ -129,27 +138,19 @@ class LogMessage {
#define DCHECK_GT(x, y) CHECK_GT(x, y)
#else // NDEBUG
#define DCHECK(condition) \
while (false) \
CHECK(condition)
while (false) CHECK(condition)
#define DCHECK_EQ(val1, val2) \
while (false) \
CHECK_EQ(val1, val2)
while (false) CHECK_EQ(val1, val2)
#define DCHECK_NE(val1, val2) \
while (false) \
CHECK_NE(val1, val2)
while (false) CHECK_NE(val1, val2)
#define DCHECK_LE(val1, val2) \
while (false) \
CHECK_LE(val1, val2)
while (false) CHECK_LE(val1, val2)
#define DCHECK_LT(val1, val2) \
while (false) \
CHECK_LT(val1, val2)
while (false) CHECK_LT(val1, val2)
#define DCHECK_GE(val1, val2) \
while (false) \
CHECK_GE(val1, val2)
while (false) CHECK_GE(val1, val2)
#define DCHECK_GT(val1, val2) \
while (false) \
CHECK_GT(val1, val2)
while (false) CHECK_GT(val1, val2)
#define DCHECK_STREQ(str1, str2) \
while (false) \
CHECK_STREQ(str1, str2)
while (false) CHECK_STREQ(str1, str2)
#endif

2
runtime/engine/common/frontend/CMakeLists.txt
Unescape View File

@ -24,5 +24,5 @@ set(BINS
foreach(bin_name IN LISTS BINS)
add_executable(${bin_name} ${CMAKE_CURRENT_SOURCE_DIR}/${bin_name}.cc)
target_include_directories(${bin_name} PRIVATE ${SPEECHX_ROOT} ${SPEECHX_ROOT}/kaldi)
target_link_libraries(${bin_name} PUBLIC frontend base utils kaldi-util gflags glog)
target_link_libraries(${bin_name} PUBLIC frontend base utils kaldi-util gflags extern_glog)
endforeach()

1
runtime/engine/common/frontend/compute_fbank_main.cc
Unescape View File

@ -16,7 +16,6 @@
#include "base/flags.h"
#include "base/log.h"
#include "base/log_impl.h"
#include "frontend/audio_cache.h"
#include "frontend/data_cache.h"
#include "frontend/fbank.h"

29
runtime/engine/common/utils/process_utils.h
Unescape View File

@ -0,0 +1,29 @@
#pragma once
#include <unistd.h>
#include <string>
namespace ppspeech {
pid_t GetPid() {
return getpid();
}
void GetPrpocessName(const pid_t pid, std::string& name){
char tmp[256];
sprintf(tmp, "/proc/%d/cmdline", pid);
FILE* f = fopen(tmp, "r");
if(f){
size_t size;
size = fread(name.data(), sizeof(char), sizeof(tmp), f);
if(size > 0){
if ('\n' == tmp[size-1]){
tmp
}
}
}
}
} // namespace ppspeech

2
runtime/engine/vad/CMakeLists.txt
Unescape View File

@ -1,4 +1,4 @@
add_executable(infer_onnx_silero_vad ${CMAKE_CURRENT_SOURCE_DIR}/infer_onnx_silero_vad.cc wav.h vad.cc vad.h)
# 添加FastDeploy库依赖
target_link_libraries(infer_onnx_silero_vad ${FASTDEPLOY_LIBS} gflags glog)
target_link_libraries(infer_onnx_silero_vad ${FASTDEPLOY_LIBS} gflags extern_glog)

Write Preview
Loading…
Cancel
Save