c++ grpc&onnxruntime support multi threads

funasr/runtime/grpc/CMakeLists.txt

@@ -74,7 +74,7 @@ foreach(_target
     "${_target}.cc")
   target_link_libraries(${_target}
     rg_grpc_proto
-    rapidasr
+    funasr
     ${EXTRA_LIBS}
     ${_REFLECTION}
     ${_GRPC_GRPCPP}

funasr/runtime/grpc/paraformer_server.cc

@@ -15,7 +15,6 @@
 #include "paraformer.grpc.pb.h"
 #include "paraformer_server.h"
 
-
 using grpc::Server;
 using grpc::ServerBuilder;
 using grpc::ServerContext;
@@ -24,13 +23,12 @@ using grpc::ServerReaderWriter;
 using grpc::ServerWriter;
 using grpc::Status;
 
-
 using paraformer::Request;
 using paraformer::Response;
 using paraformer::ASR;
 
 ASRServicer::ASRServicer(const char* model_path, int thread_num, bool quantize) {
-    AsrHanlde=RapidAsrInit(model_path, thread_num, quantize);
+    AsrHanlde=FunASRInit(model_path, thread_num, quantize);
     std::cout << "ASRServicer init" << std::endl;
     init_flag = 0;
 }
@@ -42,7 +40,7 @@ grpc::Status ASRServicer::Recognize(
     Request req;
     std::unordered_map<std::string, std::string> client_buffers;
     std::unordered_map<std::string, std::string> client_transcription;
-    
+
     while (stream->Read(&req)) {
         if (req.isend()) {
             std::cout << "asr end" << std::endl;
@@ -130,8 +128,8 @@ grpc::Status ASRServicer::Recognize(
                     stream->Write(res);
                 }
                 else {
-                    RPASR_RESULT Result= RapidAsrRecogPCMBuffer(AsrHanlde, tmp_data.c_str(), data_len_int, RASR_NONE, NULL);
-                    std::string asr_result = ((RPASR_RECOG_RESULT*)Result)->msg;
+                    FUNASR_RESULT Result= FunASRRecogPCMBuffer(AsrHanlde, tmp_data.c_str(), data_len_int, RASR_NONE, NULL);
+                    std::string asr_result = ((FUNASR_RECOG_RESULT*)Result)->msg;
 
                     auto end_time = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
                     std::string delay_str = std::to_string(end_time - begin_time);
@@ -163,7 +161,6 @@ grpc::Status ASRServicer::Recognize(
     return Status::OK;
 }
 
-
 void RunServer(const std::string& port, int thread_num, const char* model_path, bool quantize) {
     std::string server_address;
     server_address = "0.0.0.0:" + port;

funasr/runtime/grpc/paraformer_server.h

@@ -15,7 +15,7 @@
 #include <chrono>
 
 #include "paraformer.grpc.pb.h"
-#include "librapidasrapi.h"
+#include "libfunasrapi.h"
 
 
 using grpc::Server;
@@ -35,7 +35,7 @@ typedef struct
 {
     std::string msg;
     float  snippet_time;
-}RPASR_RECOG_RESULT;
+}FUNASR_RECOG_RESULT;
 
 
 class ASRServicer final : public ASR::Service {
@@ -45,6 +45,6 @@ class ASRServicer final : public ASR::Service {
   public:
     ASRServicer(const char* model_path, int thread_num, bool quantize);
     grpc::Status Recognize(grpc::ServerContext* context, grpc::ServerReaderWriter<Response, Request>* stream);
-    RPASR_HANDLE AsrHanlde;
+    FUNASR_HANDLE AsrHanlde;
 	
 };

funasr/runtime/onnxruntime/include/librapidasrapi.h

@@ -1,77 +0,0 @@
-#pragma once
-
-#ifdef WIN32
-#ifdef _RPASR_API_EXPORT
-#define  _RAPIDASRAPI __declspec(dllexport)
-#else
-#define  _RAPIDASRAPI __declspec(dllimport)
-#endif
-#else
-#define _RAPIDASRAPI
-#endif
-
-#ifndef _WIN32
-#define RPASR_CALLBCK_PREFIX __attribute__((__stdcall__))
-#else
-#define RPASR_CALLBCK_PREFIX __stdcall
-#endif
-
-#ifdef __cplusplus 
-
-extern "C" {
-#endif
-
-typedef void* RPASR_HANDLE;
-typedef void* RPASR_RESULT;
-typedef unsigned char RPASR_BOOL;
-
-#define RPASR_TRUE 1
-#define RPASR_FALSE 0
-#define QM_DEFAULT_THREAD_NUM  4
-
-typedef enum
-{
- RASR_NONE=-1,
- RASRM_CTC_GREEDY_SEARCH=0,
- RASRM_CTC_RPEFIX_BEAM_SEARCH = 1,
- RASRM_ATTENSION_RESCORING = 2,
- 
-}RPASR_MODE;
-
-typedef enum {
-	RPASR_MODEL_PADDLE = 0,
-	RPASR_MODEL_PADDLE_2 = 1,
-	RPASR_MODEL_K2 = 2,
-	RPASR_MODEL_PARAFORMER = 3,
-
-}RPASR_MODEL_TYPE;
-
-typedef void (* QM_CALLBACK)(int nCurStep, int nTotal); // nTotal: total steps; nCurStep: Current Step.
-	
-// APIs for qmasr
-_RAPIDASRAPI RPASR_HANDLE  RapidAsrInit(const char* szModelDir, int nThread, bool quantize);
-
-
-// if not give a fnCallback ,it should be NULL 
-_RAPIDASRAPI RPASR_RESULT	RapidAsrRecogBuffer(RPASR_HANDLE handle, const char* szBuf, int nLen, RPASR_MODE Mode, QM_CALLBACK fnCallback);
-
-_RAPIDASRAPI RPASR_RESULT	RapidAsrRecogPCMBuffer(RPASR_HANDLE handle, const char* szBuf, int nLen, RPASR_MODE Mode, QM_CALLBACK fnCallback);
-
-_RAPIDASRAPI RPASR_RESULT	RapidAsrRecogPCMFile(RPASR_HANDLE handle, const char* szFileName, RPASR_MODE Mode, QM_CALLBACK fnCallback);
-
-_RAPIDASRAPI RPASR_RESULT	RapidAsrRecogFile(RPASR_HANDLE handle, const char* szWavfile, RPASR_MODE Mode, QM_CALLBACK fnCallback);
-
-_RAPIDASRAPI const char*	RapidAsrGetResult(RPASR_RESULT Result,int nIndex);
-
-_RAPIDASRAPI const int		RapidAsrGetRetNumber(RPASR_RESULT Result);
-
-_RAPIDASRAPI void			RapidAsrFreeResult(RPASR_RESULT Result);
-
-_RAPIDASRAPI void			RapidAsrUninit(RPASR_HANDLE Handle);
-
-_RAPIDASRAPI const float	RapidAsrGetRetSnippetTime(RPASR_RESULT Result);
-
-#ifdef __cplusplus 
-
-}
-#endif

funasr/runtime/onnxruntime/src/CMakeLists.txt

@@ -6,38 +6,38 @@ set(files ${files1} ${files2} ${files3} ${files4})
 
 # message("${files}")
 
-add_library(rapidasr ${files})
+add_library(funasr ${files})
 
 if(WIN32)
 
         set(EXTRA_LIBS libfftw3f-3 yaml-cpp)
         if(CMAKE_CL_64)
-            target_link_directories(rapidasr PUBLIC ${CMAKE_SOURCE_DIR}/win/lib/x64)
+            target_link_directories(funasr PUBLIC ${CMAKE_SOURCE_DIR}/win/lib/x64)
         else()
-            target_link_directories(rapidasr PUBLIC ${CMAKE_SOURCE_DIR}/win/lib/x86)
+            target_link_directories(funasr PUBLIC ${CMAKE_SOURCE_DIR}/win/lib/x86)
         endif()
-        target_include_directories(rapidasr PUBLIC ${CMAKE_SOURCE_DIR}/win/include )
+        target_include_directories(funasr PUBLIC ${CMAKE_SOURCE_DIR}/win/include )
         
-        target_compile_definitions(rapidasr PUBLIC -D_RPASR_API_EXPORT)
+        target_compile_definitions(funasr PUBLIC -D_FUNASR_API_EXPORT)
 else()
 
     set(EXTRA_LIBS fftw3f pthread yaml-cpp)
-    target_include_directories(rapidasr PUBLIC "/usr/local/opt/fftw/include")
-    target_link_directories(rapidasr PUBLIC "/usr/local/opt/fftw/lib")
+    target_include_directories(funasr PUBLIC "/usr/local/opt/fftw/include")
+    target_link_directories(funasr PUBLIC "/usr/local/opt/fftw/lib")
 
-    target_include_directories(rapidasr PUBLIC "/usr/local/opt/openblas/include")
-    target_link_directories(rapidasr PUBLIC "/usr/local/opt/openblas/lib")
+    target_include_directories(funasr PUBLIC "/usr/local/opt/openblas/include")
+    target_link_directories(funasr PUBLIC "/usr/local/opt/openblas/lib")
 
-    target_include_directories(rapidasr PUBLIC "/usr/include")
-    target_link_directories(rapidasr PUBLIC "/usr/lib64")
+    target_include_directories(funasr PUBLIC "/usr/include")
+    target_link_directories(funasr PUBLIC "/usr/lib64")
 
-    target_include_directories(rapidasr PUBLIC  ${FFTW3F_INCLUDE_DIR})
-    target_link_directories(rapidasr PUBLIC ${FFTW3F_LIBRARY_DIR})
+    target_include_directories(funasr PUBLIC  ${FFTW3F_INCLUDE_DIR})
+    target_link_directories(funasr PUBLIC ${FFTW3F_LIBRARY_DIR})
     include_directories(${ONNXRUNTIME_DIR}/include)    
 endif()
 
 include_directories(${CMAKE_SOURCE_DIR}/include)
-target_link_libraries(rapidasr PUBLIC onnxruntime ${EXTRA_LIBS})
+target_link_libraries(funasr PUBLIC onnxruntime ${EXTRA_LIBS})
 
 
 

funasr/runtime/onnxruntime/src/FeatureExtract.cpp

@@ -5,16 +5,10 @@ using namespace std;
 
 FeatureExtract::FeatureExtract(int mode) : mode(mode)
 {
-    fftw_init();
 }
 
 FeatureExtract::~FeatureExtract()
 {
-    fftwf_free(fft_input);
-    fftwf_free(fft_out);
-    if(p){
-        fftwf_destroy_plan(p);
-    }
 }
 
 void FeatureExtract::reset()
@@ -28,23 +22,18 @@ int FeatureExtract::size()
     return fqueue.size();
 }
 
-void FeatureExtract::fftw_init()
+void FeatureExtract::insert(fftwf_plan plan, float *din, int len, int flag)
 {
     int fft_size = 512;
-    fft_input = (float *)fftwf_malloc(sizeof(float) * fft_size);
-    fft_out = (fftwf_complex *)fftwf_malloc(sizeof(fftwf_complex) * fft_size);
+    float* fft_input = (float *)fftwf_malloc(sizeof(float) * fft_size);
+    fftwf_complex* fft_out = (fftwf_complex *)fftwf_malloc(sizeof(fftwf_complex) * fft_size);
     memset(fft_input, 0, sizeof(float) * fft_size);
-    p = fftwf_plan_dft_r2c_1d(fft_size, fft_input, fft_out, FFTW_ESTIMATE);
-}
 
-void FeatureExtract::insert(float *din, int len, int flag)
-{
     const float *window = (const float *)&window_hex;
     if (mode == 3)
         window = (const float *)&window_hamm_hex;
 
     int window_size = 400;
-    int fft_size = 512;
     int window_shift = 160;
 
     speech.load(din, len);
@@ -72,7 +61,7 @@ void FeatureExtract::insert(float *din, int len, int flag)
             pre_val = cur_val;
         }
 
-        fftwf_execute(p);
+        fftwf_execute_dft_r2c(plan, fft_input, fft_out);
 
         melspect((float *)fft_out, tmp_feature);
         int tmp_flag = S_MIDDLE;
@@ -82,6 +71,8 @@ void FeatureExtract::insert(float *din, int len, int flag)
         fqueue.push(tmp_feature, tmp_flag);
     }
     speech.update(i);
+    fftwf_free(fft_input);
+    fftwf_free(fft_out);
 }
 
 bool FeatureExtract::fetch(Tensor<float> *&dout)
@@ -130,7 +121,6 @@ void FeatureExtract::global_cmvn(float *din)
 void FeatureExtract::melspect(float *din, float *dout)
 {
     float fftmag[256];
-//    float tmp;
     const float *melcoe = (const float *)melcoe_hex;
     int i;
     for (i = 0; i < 256; i++) {

funasr/runtime/onnxruntime/src/FeatureExtract.h

@@ -15,11 +15,7 @@ class FeatureExtract {
     FeatureQueue fqueue;
     int mode;
 
-    float *fft_input;
-    fftwf_complex *fft_out;
-    fftwf_plan p;
-
-    void fftw_init();
+    //void fftw_init();
     void melspect(float *din, float *dout);
     void global_cmvn(float *din);
 
@@ -27,9 +23,9 @@ class FeatureExtract {
     FeatureExtract(int mode);
     ~FeatureExtract();
     int size();
-    int status();
+    //int status();
     void reset();
-    void insert(float *din, int len, int flag);
+    void insert(fftwf_plan plan, float *din, int len, int flag);
     bool fetch(Tensor<float> *&dout);
 };
 

funasr/runtime/onnxruntime/src/commonfunc.h

@@ -5,7 +5,7 @@ typedef struct
 {
     std::string msg;
     float  snippet_time;
-}RPASR_RECOG_RESULT;
+}FUNASR_RECOG_RESULT;
 
 
 #ifdef _WIN32
@@ -53,4 +53,4 @@ inline void getOutputName(Ort::Session* session, string& outputName, int nIndex
 
         }
     }
-}
+}

funasr/runtime/onnxruntime/src/librapidasrapi.cpp

@@ -1,182 +0,0 @@
-#include "precomp.h"
-#ifdef __cplusplus 
-
-extern "C" {
-#endif
-
-	// APIs for qmasr
-	_RAPIDASRAPI RPASR_HANDLE  RapidAsrInit(const char* szModelDir, int nThreadNum, bool quantize)
-	{
-		Model* mm = create_model(szModelDir, nThreadNum, quantize);
-		return mm;
-	}
-
-	_RAPIDASRAPI RPASR_RESULT RapidAsrRecogBuffer(RPASR_HANDLE handle, const char* szBuf, int nLen, RPASR_MODE Mode, QM_CALLBACK fnCallback)
-	{
-		Model* pRecogObj = (Model*)handle;
-		if (!pRecogObj)
-			return nullptr;
-
-		Audio audio(1);
-		if (!audio.loadwav(szBuf, nLen))
-			return nullptr;
-		//audio.split();
-
-		float* buff;
-		int len;
-		int flag=0;
-		RPASR_RECOG_RESULT* pResult = new RPASR_RECOG_RESULT;
-		pResult->snippet_time = audio.get_time_len();
-		int nStep = 0;
-		int nTotal = audio.get_queue_size();
-		while (audio.fetch(buff, len, flag) > 0) {
-			//pRecogObj->reset();
-			string msg = pRecogObj->forward(buff, len, flag);
-			pResult->msg += msg;
-			nStep++;
-			if (fnCallback)
-				fnCallback(nStep, nTotal);
-		}
-
-		return pResult;
-	}
-
-	_RAPIDASRAPI RPASR_RESULT RapidAsrRecogPCMBuffer(RPASR_HANDLE handle, const char* szBuf, int nLen, RPASR_MODE Mode, QM_CALLBACK fnCallback)
-	{
-		Model* pRecogObj = (Model*)handle;
-		if (!pRecogObj)
-			return nullptr;
-
-		Audio audio(1);
-		if (!audio.loadpcmwav(szBuf, nLen))
-			return nullptr;
-		//audio.split();
-
-		float* buff;
-		int len;
-		int flag = 0;
-		RPASR_RECOG_RESULT* pResult = new RPASR_RECOG_RESULT;
-		pResult->snippet_time = audio.get_time_len();
-		int nStep = 0;
-		int nTotal = audio.get_queue_size();
-		while (audio.fetch(buff, len, flag) > 0) {
-			//pRecogObj->reset();
-			string msg = pRecogObj->forward(buff, len, flag);
-			pResult->msg += msg;
-			nStep++;
-			if (fnCallback)
-				fnCallback(nStep, nTotal);
-		}
-
-		return pResult;
-	}
-
-	_RAPIDASRAPI RPASR_RESULT RapidAsrRecogPCMFile(RPASR_HANDLE handle, const char* szFileName, RPASR_MODE Mode, QM_CALLBACK fnCallback)
-	{
-		Model* pRecogObj = (Model*)handle;
-		if (!pRecogObj)
-			return nullptr;
-
-		Audio audio(1);
-		if (!audio.loadpcmwav(szFileName))
-			return nullptr;
-		//audio.split();
-
-		float* buff;
-		int len;
-		int flag = 0;
-		RPASR_RECOG_RESULT* pResult = new RPASR_RECOG_RESULT;
-		pResult->snippet_time = audio.get_time_len();
-		int nStep = 0;
-		int nTotal = audio.get_queue_size();
-		while (audio.fetch(buff, len, flag) > 0) {
-			//pRecogObj->reset();
-			string msg = pRecogObj->forward(buff, len, flag);
-			pResult->msg += msg;
-			nStep++;
-			if (fnCallback)
-				fnCallback(nStep, nTotal);
-		}
-
-		return pResult;
-	}
-
-	_RAPIDASRAPI RPASR_RESULT RapidAsrRecogFile(RPASR_HANDLE handle, const char* szWavfile, RPASR_MODE Mode, QM_CALLBACK fnCallback)
-	{
-		Model* pRecogObj = (Model*)handle;
-		if (!pRecogObj)
-			return nullptr;
-
-		Audio audio(1);
-		if(!audio.loadwav(szWavfile))
-			return nullptr;
-		//audio.split();
-
-		float* buff;
-		int len;
-		int flag = 0;
-		int nStep = 0;
-		int nTotal = audio.get_queue_size();
-		RPASR_RECOG_RESULT* pResult = new RPASR_RECOG_RESULT;
-		pResult->snippet_time = audio.get_time_len();
-		while (audio.fetch(buff, len, flag) > 0) {
-			//pRecogObj->reset();
-			string msg = pRecogObj->forward(buff, len, flag);
-			pResult->msg+= msg;
-			nStep++;
-			if (fnCallback)
-				fnCallback(nStep, nTotal);
-		}
-	
-		return pResult;
-	}
-
-	_RAPIDASRAPI const int RapidAsrGetRetNumber(RPASR_RESULT Result)
-	{
-		if (!Result)
-			return 0;
-
-		return 1;
-	}
-
-
-	_RAPIDASRAPI const float RapidAsrGetRetSnippetTime(RPASR_RESULT Result)
-	{
-		if (!Result)
-			return 0.0f;
-
-		return ((RPASR_RECOG_RESULT*)Result)->snippet_time;
-	}
-
-	_RAPIDASRAPI const char* RapidAsrGetResult(RPASR_RESULT Result,int nIndex)
-	{
-		RPASR_RECOG_RESULT * pResult = (RPASR_RECOG_RESULT*)Result;
-		if(!pResult)
-			return nullptr;
-
-		return pResult->msg.c_str();
-	}
-
-	_RAPIDASRAPI void RapidAsrFreeResult(RPASR_RESULT Result)
-	{
-		if (Result)
-		{
-			delete (RPASR_RECOG_RESULT*)Result;
-		}
-	}
-
-	_RAPIDASRAPI void RapidAsrUninit(RPASR_HANDLE handle)
-	{
-		Model* pRecogObj = (Model*)handle;
-
-		if (!pRecogObj)
-			return;
-
-		delete pRecogObj;
-	}
-
-#ifdef __cplusplus 
-
-}
-#endif
-

funasr/runtime/onnxruntime/src/paraformer_onnx.cpp

@@ -18,7 +18,11 @@ ModelImp::ModelImp(const char* path,int nNumThread, bool quantize)
     cmvn_path = pathAppend(path, "am.mvn");
     config_path = pathAppend(path, "config.yaml");
 
-    //fe = new FeatureExtract(3);
+    int fft_size = 512;
+    fft_input = (float *)fftwf_malloc(sizeof(float) * fft_size);
+    fft_out = (fftwf_complex *)fftwf_malloc(sizeof(fftwf_complex) * fft_size);
+    memset(fft_input, 0, sizeof(float) * fft_size);
+    plan = fftwf_plan_dft_r2c_1d(fft_size, fft_input, fft_out, FFTW_ESTIMATE);
 
     //sessionOptions.SetInterOpNumThreads(1);
     sessionOptions.SetIntraOpNumThreads(nNumThread);
@@ -52,8 +56,6 @@ ModelImp::ModelImp(const char* path,int nNumThread, bool quantize)
 
 ModelImp::~ModelImp()
 {
-    //if(fe)
-    //    delete fe;
     if (m_session)
     {
         delete m_session;
@@ -61,11 +63,14 @@ ModelImp::~ModelImp()
     }
     if(vocab)
         delete vocab;
+    fftwf_free(fft_input);
+    fftwf_free(fft_out);
+    fftwf_destroy_plan(plan);
+    fftwf_cleanup();
 }
 
 void ModelImp::reset()
 {
-    //fe->reset();
     printf("Not Imp!!!!!!\n");
 }
 
@@ -163,7 +168,7 @@ string ModelImp::forward(float* din, int len, int flag)
     Tensor<float>* in;
     FeatureExtract* fe = new FeatureExtract(3);
     fe->reset();
-    fe->insert(din, len, flag);
+    fe->insert(plan, din, len, flag);
     fe->fetch(in);
     apply_lfr(in);
     apply_cmvn(in);

funasr/runtime/onnxruntime/src/paraformer_onnx.h

@@ -8,7 +8,9 @@ namespace paraformer {
 
     class ModelImp : public Model {
     private:
-        //FeatureExtract* fe;
+        float *fft_input;
+        fftwf_complex *fft_out;
+        fftwf_plan plan;
 
         Vocab* vocab;
         vector<float> means_list;

funasr/runtime/onnxruntime/src/precomp.h

@@ -46,7 +46,7 @@ using namespace std;
 #include <Audio.h>
 #include "Model.h"
 #include "paraformer_onnx.h"
-#include "librapidasrapi.h"
+#include "libfunasrapi.h"
 
 
 using namespace paraformer;

funasr/runtime/onnxruntime/tester/CMakeLists.txt

@@ -8,7 +8,7 @@ if(WIN32)
     endif()
 endif()
 
-set(EXTRA_LIBS rapidasr)
+set(EXTRA_LIBS funasr)
 
 
 include_directories(${CMAKE_SOURCE_DIR}/include)

funasr/runtime/onnxruntime/tester/tester.cpp

@@ -5,7 +5,7 @@
 #include <win_func.h>
 #endif
 
-#include "librapidasrapi.h"
+#include "libfunasrapi.h"
 
 #include <iostream>
 #include <fstream>
@@ -26,7 +26,7 @@ int main(int argc, char *argv[])
     // is quantize
     bool quantize = false;
     istringstream(argv[3]) >> boolalpha >> quantize;
-    RPASR_HANDLE AsrHanlde=RapidAsrInit(argv[1], nThreadNum, quantize);
+    FUNASR_HANDLE AsrHanlde=FunASRInit(argv[1], nThreadNum, quantize);
 
     if (!AsrHanlde)
     {
@@ -42,17 +42,17 @@ int main(int argc, char *argv[])
     gettimeofday(&start, NULL);
     float snippet_time = 0.0f;
 
-    RPASR_RESULT Result=RapidAsrRecogFile(AsrHanlde, argv[2], RASR_NONE, NULL);
+    FUNASR_RESULT Result=FunASRRecogFile(AsrHanlde, argv[2], RASR_NONE, NULL);
 
     gettimeofday(&end, NULL);
    
     if (Result)
     {
-        string msg = RapidAsrGetResult(Result, 0);
+        string msg = FunASRGetResult(Result, 0);
         setbuf(stdout, NULL);
         printf("Result: %s \n", msg.c_str());
-        snippet_time = RapidAsrGetRetSnippetTime(Result);
-        RapidAsrFreeResult(Result);
+        snippet_time = FunASRGetRetSnippetTime(Result);
+        FunASRFreeResult(Result);
     }
     else
     {
@@ -65,9 +65,9 @@ int main(int argc, char *argv[])
     printf("Model inference takes %lfs.\n", (double)taking_micros / 1000000);
     printf("Model inference RTF: %04lf.\n", (double)taking_micros/ (snippet_time*1000000));
 
-    RapidAsrUninit(AsrHanlde);
+    FunASRUninit(AsrHanlde);
 
     return 0;
 }
 
-    
+    

funasr/runtime/onnxruntime/tester/tester_rtf.cpp

@@ -5,31 +5,14 @@
 #include <win_func.h>
 #endif
 
-#include "librapidasrapi.h"
+#include "libfunasrapi.h"
 
 #include <iostream>
 #include <fstream>
 #include <sstream>
 #include <vector>
-#include <thread>
 using namespace std;
 
-void runReg(vector<string> wav_list, RPASR_HANDLE AsrHanlde)
-{
-    for (size_t i = 0; i < wav_list.size(); i++)
-    {
-        RPASR_RESULT Result=RapidAsrRecogFile(AsrHanlde, wav_list[i].c_str(), RASR_NONE, NULL);
-
-        if(Result){
-            string msg = RapidAsrGetResult(Result, 0);
-            printf("Result: %s \n", msg.c_str());
-            RapidAsrFreeResult(Result);
-        }else{
-            cout <<"No return data!";
-        }
-    }
-}
-
 int main(int argc, char *argv[])
 {
 
@@ -64,21 +47,53 @@ int main(int argc, char *argv[])
     bool quantize = false;
     istringstream(argv[3]) >> boolalpha >> quantize;
 
-    RPASR_HANDLE AsrHanlde=RapidAsrInit(argv[1], nThreadNum, quantize);
+    FUNASR_HANDLE AsrHanlde=FunASRInit(argv[1], nThreadNum, quantize);
     if (!AsrHanlde)
     {
         printf("Cannot load ASR Model from: %s, there must be files model.onnx and vocab.txt", argv[1]);
         exit(-1);
     }
+    gettimeofday(&end, NULL);
+    long seconds = (end.tv_sec - start.tv_sec);
+    long modle_init_micros = ((seconds * 1000000) + end.tv_usec) - (start.tv_usec);
+    printf("Model initialization takes %lfs.\n", (double)modle_init_micros / 1000000);
+
+    // warm up
+    for (size_t i = 0; i < 30; i++)
+    {
+        FUNASR_RESULT Result=FunASRRecogFile(AsrHanlde, wav_list[0].c_str(), RASR_NONE, NULL);
+    }
+
+    // forward
+    float snippet_time = 0.0f;
+    float total_length = 0.0f;
+    long total_time = 0.0f;
     
-    std::thread t1(runReg, wav_list, AsrHanlde);
-    std::thread t2(runReg, wav_list, AsrHanlde);
+    for (size_t i = 0; i < wav_list.size(); i++)
+    {
+        gettimeofday(&start, NULL);
+        FUNASR_RESULT Result=FunASRRecogFile(AsrHanlde, wav_list[i].c_str(), RASR_NONE, NULL);
+        gettimeofday(&end, NULL);
+        seconds = (end.tv_sec - start.tv_sec);
+        long taking_micros = ((seconds * 1000000) + end.tv_usec) - (start.tv_usec);
+        total_time += taking_micros;
 
-    t1.join();
-    t2.join();
+        if(Result){
+            string msg = FunASRGetResult(Result, 0);
+            printf("Result: %s \n", msg);
+
+            snippet_time = FunASRGetRetSnippetTime(Result);
+            total_length += snippet_time;
+            FunASRFreeResult(Result);
+        }else{
+            cout <<"No return data!";
+        }
+    }
 
-    //runReg(wav_list, AsrHanlde);
+    printf("total_time_wav %ld ms.\n", (long)(total_length * 1000));
+    printf("total_time_comput %ld ms.\n", total_time / 1000);
+    printf("total_rtf %05lf .\n", (double)total_time/ (total_length*1000000));
 
-    RapidAsrUninit(AsrHanlde);
+    FunASRUninit(AsrHanlde);
     return 0;
 }