提交 22dff409 编写于 作者: J Jiawei Wang 提交者: GitHub

Merge pull request #18 from bjjwwang/my_cool_stuff

Modifications about code-format and 
......@@ -42,12 +42,6 @@ repos:
entry: bash ./tools/codestyle/pylint_pre_commit.hook
language: system
files: \.(py)$
- repo: https://github.com/PaddlePaddle/pre-commit-golang
sha: 8337620115c25ff8333f1b1a493bd031049bd7c0
hooks:
- id: go-fmt
types:
- go
- repo: local
hooks:
- id: copyright_checker
......
......@@ -38,6 +38,7 @@ ExternalProject_Add(
-DCMAKE_INSTALL_PREFIX=${OPENCV_INSTALL_DIR}
-DCMAKE_INSTALL_LIBDIR=${OPENCV_INSTALL_DIR}/lib
-DCMAKE_POSITION_INDEPENDENT_CODE=ON
-DWITH_GTK=OFF
-DBUILD_TESTS=OFF
-DBUILD_PERF_TESTS=OFF
-DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
......
# Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
INCLUDE(ExternalProject)
SET(REDISCLIENT_SOURCES_DIR ${THIRD_PARTY_PATH}/redis++)
SET(REDISCLIENT_INSTALL_DIR ${THIRD_PARTY_PATH}/install/redis++)
SET(REDISCLIENT_INCLUDE_DIR "${REDISCLIENT_INSTALL_DIR}/include" CACHE PATH "redis++ include directory." FORCE)
SET(REDISCLIENT_LIBRARIES "${REDISCLIENT_INSTALL_DIR}/lib/libredis++.a" CACHE FILEPATH "redis++ library." FORCE)
INCLUDE_DIRECTORIES(${REDISCLIENT_INCLUDE_DIR})
ExternalProject_Add(
extern_redis++
${EXTERNAL_PROJECT_LOG_ARGS}
PREFIX ${REDISCLIENT_SOURCES_DIR}
GIT_REPOSITORY "https://github.com/sewenew/redis-plus-plus"
GIT_TAG master
UPDATE_COMMAND ""
CONFIGURE_COMMAND ""
BUILD_COMMAND cmake . && CXXFLAGS=-fPIC make -j ${NUM_OF_PROCESSOR} static
INSTALL_COMMAND mkdir -p ${REDISCLIENT_INSTALL_DIR}/lib/
&& cp ${REDISCLIENT_SOURCES_DIR}/src/extern_redis++/lib/libredis++.a ${REDISCLIENT_LIBRARIES}
&& cp -r ${REDISCLIENT_SOURCES_DIR}/src/extern_redis++/src/sw/redis++/ ${REDISCLIENT_INSTALL_DIR}/include/redis++/
BUILD_IN_SOURCE 1
)
ADD_DEPENDENCIES(extern_redis++ snappy)
ADD_LIBRARY(redis++ STATIC IMPORTED GLOBAL)
SET_PROPERTY(TARGET redis++ PROPERTY IMPORTED_LOCATION ${ROCKSDB_LIBRARIES})
ADD_DEPENDENCIES(redis++ extern_redis++)
LIST(APPEND external_project_dependencies redis++)
......@@ -16,12 +16,12 @@
#include <sys/types.h>
#include <unistd.h>
#include <algorithm>
#include <fstream>
#include "sdk-cpp/builtin_format.pb.h"
#include "sdk-cpp/echo_kvdb_service.pb.h"
#include "sdk-cpp/include/common.h"
#include "sdk-cpp/include/predictor_sdk.h"
#include <algorithm>
using baidu::paddle_serving::sdk_cpp::Predictor;
using baidu::paddle_serving::sdk_cpp::PredictorApi;
using baidu::paddle_serving::predictor::echo_kvdb_service::Request;
......@@ -48,11 +48,11 @@ void print_res(const Request& req,
uint64_t elapse_ms) {
LOG(INFO) << "Receive Response size: " << res.ress_size();
for (size_t i = 0; i < res.ress_size(); i++) {
KVDBRes val = res.ress(i);
LOG(INFO) << "Receive value from demo-server: " << val.value();
}
LOG(INFO) << "Succ call predictor[echo_kvdb_service], the tag is: " << route_tag
<< ", elapse_ms: " << elapse_ms;
KVDBRes val = res.ress(i);
LOG(INFO) << "Receive value from demo-server: " << val.value();
}
LOG(INFO) << "Succ call predictor[echo_kvdb_service], the tag is: "
<< route_tag << ", elapse_ms: " << elapse_ms;
}
int main(int argc, char** argv) {
......@@ -100,7 +100,7 @@ int main(int argc, char** argv) {
while (true) {
if (global_key > 10000) {
break;
break;
}
timeval start;
gettimeofday(&start, NULL);
......
// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
//
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
......@@ -23,36 +23,34 @@ using baidu::paddle_serving::predictor::format::KVDBRes;
using baidu::paddle_serving::predictor::echo_kvdb_service::Request;
using baidu::paddle_serving::predictor::echo_kvdb_service::Response;
int KVDBEchoOp::inference() {
debug();
}
int KVDBEchoOp::inference() { debug(); }
int KVDBEchoOp::debug() {
//TODO: implement DEBUG mode
baidu::paddle_serving::predictor::Resource& resource = baidu::paddle_serving::predictor::Resource::instance();
std::shared_ptr<RocksDBWrapper> db = resource.getDB();
const Request* req = dynamic_cast<const Request*>(get_request_message());
Response* res = mutable_data<Response>();
LOG(INFO) << "Receive request in KVDB echo service: " << req->ShortDebugString();
for (size_t i = 0; i < req->reqs_size(); i++) {
auto kvdbreq = req->reqs(i);
std::string op = kvdbreq.op();
std::string key = kvdbreq.key();
std::string val = kvdbreq.value();
if (op == "SET") {
db->Put(key, val);
KVDBRes* kvdb_value_res = res->mutable_ress()->Add();
kvdb_value_res -> set_value("OK");
} else if (op == "GET") {
std::string getvalue = db->Get(key);
KVDBRes* kvdb_value_res = res->mutable_ress()->Add();
kvdb_value_res -> set_value(getvalue);
}
// TODO: implement DEBUG mode
baidu::paddle_serving::predictor::Resource& resource =
baidu::paddle_serving::predictor::Resource::instance();
std::shared_ptr<RocksDBWrapper> db = resource.getDB();
const Request* req = dynamic_cast<const Request*>(get_request_message());
Response* res = mutable_data<Response>();
LOG(INFO) << "Receive request in KVDB echo service: "
<< req->ShortDebugString();
for (size_t i = 0; i < req->reqs_size(); i++) {
auto kvdbreq = req->reqs(i);
std::string op = kvdbreq.op();
std::string key = kvdbreq.key();
std::string val = kvdbreq.value();
if (op == "SET") {
db->Put(key, val);
KVDBRes* kvdb_value_res = res->mutable_ress()->Add();
kvdb_value_res->set_value("OK");
} else if (op == "GET") {
std::string getvalue = db->Get(key);
KVDBRes* kvdb_value_res = res->mutable_ress()->Add();
kvdb_value_res->set_value(getvalue);
}
return 0;
}
return 0;
}
DEFINE_OP(KVDBEchoOp);
}
}
......
......@@ -14,23 +14,24 @@
#pragma once
#include "demo-serving/echo_kvdb_service.pb.h"
#include "predictor/framework/resource.h"
#include "kvdb/paddle_rocksdb.h"
#include "predictor/common/inner_common.h"
#include "predictor/framework/channel.h"
#include "predictor/framework/op_repository.h"
#include "predictor/framework/resource.h"
#include "predictor/op/op.h"
#include "kvdb/paddle_rocksdb.h"
namespace baidu {
namespace paddle_serving {
namespace predictor {
class KVDBEchoOp: public OpWithChannel<baidu::paddle_serving::predictor::echo_kvdb_service::Response> {
public:
DECLARE_OP(KVDBEchoOp);
int inference();
int debug();
class KVDBEchoOp
: public OpWithChannel<
baidu::paddle_serving::predictor::echo_kvdb_service::Response> {
public:
DECLARE_OP(KVDBEchoOp);
int inference();
int debug();
};
} // namespace predictor
} // namespace paddle_serving
......
......@@ -64,9 +64,10 @@ int ReaderOp::inference() {
size_t dense_capacity = 3 * resize.width * resize.height;
size_t len = dense_capacity * sizeof(float) * sample_size;
// Allocate buffer in PaddleTensor, so that buffer will be managed by the Tensor
// Allocate buffer in PaddleTensor, so that buffer will be managed by the
// Tensor
in_tensor.data.Resize(len);
float *data = reinterpret_cast<float *>(in_tensor.data.data());
float* data = reinterpret_cast<float*>(in_tensor.data.data());
if (in_tensor.data.data() == NULL) {
LOG(ERROR) << "Failed create temp float array, "
<< "size=" << dense_capacity * sample_size * sizeof(float);
......
......@@ -20,15 +20,15 @@ package baidu.paddle_serving.predictor.echo_kvdb_service;
option cc_generic_services = true;
message Request {
repeated baidu.paddle_serving.predictor.format.KVDBReq reqs = 1;
repeated baidu.paddle_serving.predictor.format.KVDBReq reqs = 1;
};
message Response {
repeated baidu.paddle_serving.predictor.format.KVDBRes ress = 1;
repeated baidu.paddle_serving.predictor.format.KVDBRes ress = 1;
};
service EchoKVDBService {
rpc inference(Request) returns (Response);
rpc debug(Request) returns (Response);
option (pds.options).generate_impl = true;
rpc inference(Request) returns (Response);
rpc debug(Request) returns (Response);
option (pds.options).generate_impl = true;
};
// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
//
......@@ -14,10 +27,10 @@
// limitations under the License.
#pragma once
#include <vector>
#include <unordered_map>
#include <memory>
#include <chrono>
#include <memory>
#include <unordered_map>
#include <vector>
class AbstractKVDB;
class FileReader;
class ParamDict;
......@@ -27,104 +40,102 @@ typedef std::shared_ptr<FileReader> FileReaderPtr;
typedef std::shared_ptr<ParamDict> ParamDictPtr;
class AbstractKVDB {
public:
virtual void CreateDB() = 0;
virtual void SetDBName(std::string) = 0;
virtual void Set(std::string key, std::string value) = 0;
virtual std::string Get(std::string key) = 0;
virtual ~AbstractKVDB() = 0;
public:
virtual void CreateDB() = 0;
virtual void SetDBName(std::string) = 0;
virtual void Set(std::string key, std::string value) = 0;
virtual std::string Get(std::string key) = 0;
virtual ~AbstractKVDB() = 0;
};
// TODO: Implement RedisKVDB
//class RedisKVDB;
class FileReader {
public:
inline virtual std::string GetFileName() {
return this->filename_;
}
inline virtual void SetFileName(std::string filename) {
this->filename_ = filename;
this->last_md5_val_ = this->GetMD5();
this->time_stamp_ = std::chrono::system_clock::now();
}
inline virtual std::string GetMD5() {
auto getCmdOut = [] (std::string cmd) {
std::string data;
FILE *stream = nullptr;
const int max_buffer = 256;
char buffer[max_buffer];
cmd.append(" 2>&1");
stream = popen(cmd.c_str(), "r");
if (stream) {
if (fgets(buffer, max_buffer, stream) != NULL) {
data.append(buffer);
}
}
return data;
};
std::string cmd = "md5sum " + this->filename_;
//TODO: throw exception if error occurs during execution of shell command
std::string md5val = getCmdOut(cmd);
this->time_stamp_ = md5val == this->last_md5_val_? this->time_stamp_: std::chrono::system_clock::now();
this->last_md5_val_ = md5val;
return md5val;
}
inline virtual bool CheckDiff() {
return this->GetMD5() == this->last_md5_val_;
}
inline virtual std::chrono::system_clock::time_point GetTimeStamp() {
return this->time_stamp_;
}
inline virtual ~FileReader() {};
protected:
std::string filename_;
std::string last_md5_val_;
std::chrono::system_clock::time_point time_stamp_;
public:
inline virtual std::string GetFileName() { return this->filename_; }
inline virtual void SetFileName(std::string filename) {
this->filename_ = filename;
this->last_md5_val_ = this->GetMD5();
this->time_stamp_ = std::chrono::system_clock::now();
}
inline virtual std::string GetMD5() {
auto getCmdOut = [](std::string cmd) {
std::string data;
FILE *stream = nullptr;
const int max_buffer = 256;
char buffer[max_buffer];
cmd.append(" 2>&1");
stream = popen(cmd.c_str(), "r");
if (stream) {
if (fgets(buffer, max_buffer, stream) != NULL) {
data.append(buffer);
}
}
return data;
};
std::string cmd = "md5sum " + this->filename_;
// TODO: throw exception if error occurs during execution of shell command
std::string md5val = getCmdOut(cmd);
this->time_stamp_ = md5val == this->last_md5_val_
? this->time_stamp_
: std::chrono::system_clock::now();
this->last_md5_val_ = md5val;
return md5val;
}
inline virtual bool CheckDiff() {
return this->GetMD5() == this->last_md5_val_;
}
inline virtual std::chrono::system_clock::time_point GetTimeStamp() {
return this->time_stamp_;
}
inline virtual ~FileReader(){};
private:
std::string filename_;
std::string last_md5_val_;
std::chrono::system_clock::time_point time_stamp_;
};
class ParamDict {
typedef std::string Key;
typedef std::vector<std::string> Value;
public:
virtual std::vector<FileReaderPtr> GetDictReaderLst();
virtual void SetFileReaderLst(std::vector<std::string> lst);
virtual std::vector<float> GetSparseValue(int64_t, int64_t);
virtual std::vector<float> GetSparseValue(std::string, std::string);
virtual bool InsertSparseValue(int64_t, int64_t, const std::vector<float>&);
virtual bool InsertSparseValue(std::string, std::string, const std::vector<float>&);
virtual void SetReader(std::function<std::pair<Key, Value>(std::string)>);
virtual void UpdateBaseModel();
virtual void UpdateDeltaModel();
virtual std::pair<AbsKVDBPtr, AbsKVDBPtr> GetKVDB();
virtual void SetKVDB(std::pair<AbsKVDBPtr, AbsKVDBPtr>);
virtual void CreateKVDB();
virtual ~ParamDict();
protected:
std::function<std::pair<Key, Value>(std::string)> read_func_;
std::vector<FileReaderPtr> file_reader_lst_;
AbsKVDBPtr front_db, back_db;
};
typedef std::string Key;
typedef std::vector<std::string> Value;
public:
virtual std::vector<FileReaderPtr> GetDictReaderLst();
virtual void SetFileReaderLst(std::vector<std::string> lst);
virtual std::vector<float> GetSparseValue(int64_t, int64_t);
virtual std::vector<float> GetSparseValue(std::string, std::string);
class ParamDictMgr {
public:
void UpdateAll();
void InsertParamDict(std::string, ParamDictPtr);
virtual bool InsertSparseValue(int64_t, int64_t, const std::vector<float> &);
virtual bool InsertSparseValue(std::string,
std::string,
const std::vector<float> &);
virtual void SetReader(std::function<std::pair<Key, Value>(std::string)>);
virtual void UpdateBaseModel();
virtual void UpdateDeltaModel();
virtual std::pair<AbsKVDBPtr, AbsKVDBPtr> GetKVDB();
virtual void SetKVDB(std::pair<AbsKVDBPtr, AbsKVDBPtr>);
virtual void CreateKVDB();
virtual ~ParamDict();
protected:
std::unordered_map<std::string, ParamDictPtr> ParamDictMap;
private:
std::function<std::pair<Key, Value>(std::string)> read_func_;
std::vector<FileReaderPtr> file_reader_lst_;
AbsKVDBPtr front_db, back_db;
};
class ParamDictMgr {
public:
void UpdateAll();
void InsertParamDict(std::string, ParamDictPtr);
private:
std::unordered_map<std::string, ParamDictPtr> ParamDictMap;
};
......@@ -15,26 +15,25 @@
#pragma once
#include <memory>
#include <string>
#include "rocksdb/compaction_filter.h"
#include "rocksdb/db.h"
#include "rocksdb/filter_policy.h"
#include "rocksdb/options.h"
#include "rocksdb/slice.h"
#include "rocksdb/sst_file_writer.h"
#include "rocksdb/table.h"
#include "rocksdb/compaction_filter.h"
#include "rocksdb/filter_policy.h"
class RocksDBWrapper {
public:
RocksDBWrapper(std::string db_name);
std::string Get(std::string key);
public:
RocksDBWrapper(std::string db_name);
std::string Get(std::string key);
bool Put(std::string key, std::string value);
void SetDBName(std::string db_name);
static std::shared_ptr<RocksDBWrapper> RocksDBWrapperFactory(std::string db_name = "SparseMatrix");
bool Put(std::string key, std::string value);
void SetDBName(std::string db_name);
static std::shared_ptr<RocksDBWrapper> RocksDBWrapperFactory(
std::string db_name = "SparseMatrix");
protected:
rocksdb::DB *db_;
std::string db_name_;
private:
rocksdb::DB *db_;
std::string db_name_;
};
......@@ -13,23 +13,19 @@
// limitations under the License.
#pragma once
#include "kvdb_impl.h"
#include "paddle_rocksdb.h"
class RocksKVDB: public AbstractKVDB {
public:
void CreateDB();
void SetDBName(std::string);
void Set(std::string key, std::string value);
std::string Get(std::string key);
~RocksKVDB();
#include "kvdb/kvdb_impl.h"
#include "kvdb/paddle_rocksdb.h"
class RocksKVDB : public AbstractKVDB {
public:
void CreateDB();
void SetDBName(std::string);
void Set(std::string key, std::string value);
std::string Get(std::string key);
~RocksKVDB();
protected:
std::shared_ptr<RocksDBWrapper> db_;
private:
std::shared_ptr<RocksDBWrapper> db_;
public:
static int db_count;
public:
static int db_count;
};
......@@ -12,65 +12,56 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "kvdb/rocksdb_impl.h"
#include "kvdb/kvdb_impl.h"
#include "kvdb/paddle_rocksdb.h"
#include <gtest/gtest.h>
#include <string>
#include <chrono>
#include <fstream>
#include <sstream>
#include <chrono>
#include <string>
#include <thread>
#include "kvdb/kvdb_impl.h"
#include "kvdb/paddle_rocksdb.h"
#include "kvdb/rocksdb_impl.h"
class KVDBTest : public ::testing::Test {
protected:
void SetUp() override{
}
static void SetUpTestCase() {
}
protected:
void SetUp() override {}
static void SetUpTestCase() {}
};
int my_argc;
char** my_argv;
std::vector<std::string> StringSplit(std::string str, char split) {
std::vector<std::string> strs;
std::istringstream f(str);
std:: string s;
while (getline(f, s, split)) {
strs.push_back(s);
}
return strs;
std::vector<std::string> strs;
std::istringstream f(str);
std::string s;
while (getline(f, s, split)) {
strs.push_back(s);
}
return strs;
}
TEST_F(KVDBTest, AbstractKVDB_Func_Test) {
AbsKVDBPtr kvdb = std::make_shared<RocksKVDB>();
kvdb->CreateDB();
std::string set_list = "setlist.txt";
std::string get_list = "getlist.txt";
std::ifstream set_file(set_list);
std::ifstream get_file(get_list);
for (std::string line; getline(set_file, line); )
{
std::vector<std::string> strs = StringSplit (line, ' ');
kvdb->Set(strs[0], strs[1]);
}
AbsKVDBPtr kvdb = std::make_shared<RocksKVDB>();
kvdb->CreateDB();
std::string set_list = "setlist.txt";
std::string get_list = "getlist.txt";
std::ifstream set_file(set_list);
std::ifstream get_file(get_list);
for (std::string line; getline(set_file, line);) {
std::vector<std::string> strs = StringSplit(line, ' ');
kvdb->Set(strs[0], strs[1]);
}
for (std::string line; getline(get_file, line); ) {
std::vector<std::string> strs = StringSplit(line, ' ');
std::string val = kvdb->Get(strs[0]);
ASSERT_EQ(val, strs[1]);
}
for (std::string line; getline(get_file, line);) {
std::vector<std::string> strs = StringSplit(line, ' ');
std::string val = kvdb->Get(strs[0]);
ASSERT_EQ(val, strs[1]);
}
}
int main(int argc, char** argv) {
my_argc = argc;
my_argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
my_argc = argc;
my_argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
......@@ -12,63 +12,59 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "kvdb/rocksdb_impl.h"
#include "kvdb/kvdb_impl.h"
#include "kvdb/paddle_rocksdb.h"
#include <gtest/gtest.h>
#include <string>
#include <fstream>
#include <chrono>
#include <fstream>
#include <string>
#include <thread>
#include "kvdb/kvdb_impl.h"
#include "kvdb/paddle_rocksdb.h"
#include "kvdb/rocksdb_impl.h"
class KVDBTest : public ::testing::Test {
protected:
void SetUp() override{
}
static void SetUpTestCase() {
protected:
void SetUp() override {}
}
static void SetUpTestCase() {}
};
int my_argc;
char** my_argv;
void db_thread_test(AbsKVDBPtr kvdb, int size) {
for (int i = 0; i < size; i++) {
kvdb->Set(std::to_string(i), std::to_string(i));
kvdb->Get(std::to_string(i));
}
for (int i = 0; i < size; i++) {
kvdb->Set(std::to_string(i), std::to_string(i));
kvdb->Get(std::to_string(i));
}
}
TEST_F(KVDBTest, AbstractKVDB_Thread_Test) {
if (my_argc != 3) {
std::cerr << "illegal input! should be db_thread ${num_of_thread} ${num_of_ops_each_thread}" << std::endl;
return;
}
int num_of_thread = atoi(my_argv[1]);
int nums_of_ops_each_thread = atoi(my_argv[2]);
std::vector<AbsKVDBPtr> kvdbptrs;
for (int i= 0; i < num_of_thread; i++) {
kvdbptrs.push_back(std::make_shared<RocksKVDB>());
kvdbptrs[i]->CreateDB();
}
std::vector<std::thread> tarr;
for (int i = 0; i< num_of_thread; i++) {
tarr.push_back(std::thread(db_thread_test, kvdbptrs[i], nums_of_ops_each_thread));
}
for (int i = 0; i< num_of_thread; i++) {
tarr[i].join();
}
if (my_argc != 3) {
std::cerr << "illegal input! should be db_thread ${num_of_thread} "
"${num_of_ops_each_thread}"
<< std::endl;
return;
}
int num_of_thread = atoi(my_argv[1]);
int nums_of_ops_each_thread = atoi(my_argv[2]);
std::vector<AbsKVDBPtr> kvdbptrs;
for (int i = 0; i < num_of_thread; i++) {
kvdbptrs.push_back(std::make_shared<RocksKVDB>());
kvdbptrs[i]->CreateDB();
}
std::vector<std::thread> tarr;
for (int i = 0; i < num_of_thread; i++) {
tarr.push_back(
std::thread(db_thread_test, kvdbptrs[i], nums_of_ops_each_thread));
}
for (int i = 0; i < num_of_thread; i++) {
tarr[i].join();
}
return;
}
int main(int argc, char** argv) {
my_argc = argc;
my_argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
my_argc = argc;
my_argv = argv;
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
......@@ -12,32 +12,29 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "kvdb/rocksdb_impl.h"
#include "kvdb/kvdb_impl.h"
#include "kvdb/paddle_rocksdb.h"
#include <gtest/gtest.h>
#include <chrono>
#include <fstream>
#include <functional>
#include <string>
#include <fstream>
#include <chrono>
#include <thread>
#include "kvdb/kvdb_impl.h"
#include "kvdb/paddle_rocksdb.h"
#include "kvdb/rocksdb_impl.h"
class KVDBTest : public ::testing::Test {
protected:
void SetUp() override{
}
static void SetUpTestCase() {
kvdb = std::make_shared<RocksKVDB>();
dict_reader = std::make_shared<FileReader>();
param_dict = std::make_shared<ParamDict>();
}
static AbsKVDBPtr kvdb;
static FileReaderPtr dict_reader;
static ParamDictPtr param_dict;
static ParamDictMgr dict_mgr;
protected:
void SetUp() override {}
static void SetUpTestCase() {
kvdb = std::make_shared<RocksKVDB>();
dict_reader = std::make_shared<FileReader>();
param_dict = std::make_shared<ParamDict>();
}
static AbsKVDBPtr kvdb;
static FileReaderPtr dict_reader;
static ParamDictPtr param_dict;
static ParamDictMgr dict_mgr;
};
AbsKVDBPtr KVDBTest::kvdb;
FileReaderPtr KVDBTest::dict_reader;
......@@ -48,116 +45,117 @@ void GenerateTestIn(std::string);
void UpdateTestIn(std::string);
TEST_F(KVDBTest, AbstractKVDB_Unit_Test) {
kvdb->CreateDB();
kvdb->SetDBName("test_kvdb");
for (int i = 0; i < 100; i++) {
kvdb->Set(std::to_string(i), std::to_string(i * 2));
}
for (int i = 0; i < 100; i++) {
std::string val = kvdb->Get(std::to_string(i));
ASSERT_EQ(val, std::to_string(i * 2));
}
kvdb->CreateDB();
kvdb->SetDBName("test_kvdb");
for (int i = 0; i < 100; i++) {
kvdb->Set(std::to_string(i), std::to_string(i * 2));
}
for (int i = 0; i < 100; i++) {
std::string val = kvdb->Get(std::to_string(i));
ASSERT_EQ(val, std::to_string(i * 2));
}
}
TEST_F(KVDBTest, FileReader_Unit_Test) {
std::string test_in_filename = "abs_dict_reader_test_in.txt";
GenerateTestIn(test_in_filename);
dict_reader->SetFileName(test_in_filename);
std::string md5_1 = dict_reader->GetMD5();
std::chrono::system_clock::time_point timestamp_1 = dict_reader->GetTimeStamp();
std::string md5_2 = dict_reader->GetMD5();
std::chrono::system_clock::time_point timestamp_2 = dict_reader->GetTimeStamp();
ASSERT_EQ(md5_1, md5_2);
ASSERT_EQ(timestamp_1, timestamp_2);
UpdateTestIn(test_in_filename);
std::string md5_3 = dict_reader->GetMD5();
std::chrono::system_clock::time_point timestamp_3 = dict_reader->GetTimeStamp();
ASSERT_NE(md5_2, md5_3);
ASSERT_NE(timestamp_2, timestamp_3);
std::string test_in_filename = "abs_dict_reader_test_in.txt";
GenerateTestIn(test_in_filename);
dict_reader->SetFileName(test_in_filename);
std::string md5_1 = dict_reader->GetMD5();
std::chrono::system_clock::time_point timestamp_1 =
dict_reader->GetTimeStamp();
std::string md5_2 = dict_reader->GetMD5();
std::chrono::system_clock::time_point timestamp_2 =
dict_reader->GetTimeStamp();
ASSERT_EQ(md5_1, md5_2);
ASSERT_EQ(timestamp_1, timestamp_2);
UpdateTestIn(test_in_filename);
std::string md5_3 = dict_reader->GetMD5();
std::chrono::system_clock::time_point timestamp_3 =
dict_reader->GetTimeStamp();
ASSERT_NE(md5_2, md5_3);
ASSERT_NE(timestamp_2, timestamp_3);
}
#include <cmath>
TEST_F(KVDBTest, ParamDict_Unit_Test) {
std::string test_in_filename = "abs_dict_reader_test_in.txt";
param_dict->SetFileReaderLst({test_in_filename});
param_dict->SetReader(
[] (std::string text) {
auto split = [](const std::string& s,
std::vector<std::string>& sv,
const char* delim = " ") {
sv.clear();
char* buffer = new char[s.size() + 1];
std::copy(s.begin(), s.end(), buffer);
char* p = strtok(buffer, delim);
do {
sv.push_back(p);
} while ((p = strtok(NULL, delim)));
return;
};
std::vector<std::string> text_split;
split(text, text_split, " ");
std::string key = text_split[0];
text_split.erase(text_split.begin());
return make_pair(key, text_split);
});
param_dict->CreateKVDB();
GenerateTestIn(test_in_filename);
param_dict->UpdateBaseModel();
std::this_thread::sleep_for(std::chrono::seconds(2));
std::vector<float> test_vec = param_dict->GetSparseValue("1", "");
ASSERT_LT(fabs(test_vec[0] - 1.0), 1e-2);
UpdateTestIn(test_in_filename);
param_dict->UpdateDeltaModel();
std::string test_in_filename = "abs_dict_reader_test_in.txt";
param_dict->SetFileReaderLst({test_in_filename});
param_dict->SetReader([](std::string text) {
auto split = [](const std::string& s,
std::vector<std::string>& sv,
const char* delim = " ") {
sv.clear();
char* buffer = new char[s.size() + 1];
std::copy(s.begin(), s.end(), buffer);
char* p = strtok(buffer, delim);
do {
sv.push_back(p);
} while ((p = strtok(NULL, delim)));
return;
};
std::vector<std::string> text_split;
split(text, text_split, " ");
std::string key = text_split[0];
text_split.erase(text_split.begin());
return make_pair(key, text_split);
});
param_dict->CreateKVDB();
GenerateTestIn(test_in_filename);
param_dict->UpdateBaseModel();
std::this_thread::sleep_for(std::chrono::seconds(2));
std::vector<float> test_vec = param_dict->GetSparseValue("1", "");
ASSERT_LT(fabs(test_vec[0] - 1.0), 1e-2);
UpdateTestIn(test_in_filename);
param_dict->UpdateDeltaModel();
}
void GenerateTestIn(std::string filename) {
std::ifstream in_file(filename);
if (in_file.good()) {
in_file.close();
std::string cmd = "rm -rf "+ filename;
system(cmd.c_str());
std::ifstream in_file(filename);
if (in_file.good()) {
in_file.close();
std::string cmd = "rm -rf " + filename;
system(cmd.c_str());
}
std::ofstream out_file(filename);
for (size_t i = 0; i < 100000; i++) {
out_file << i << " " << i << " ";
for (size_t j = 0; j < 3; j++) {
out_file << i << " ";
}
std::ofstream out_file(filename);
for (size_t i = 0; i < 100000; i++) {
out_file << i << " " << i << " ";
for (size_t j = 0; j < 3; j++) {
out_file << i << " ";
}
out_file << std::endl;
}
out_file.close();
out_file << std::endl;
}
out_file.close();
}
void UpdateTestIn(std::string filename) {
std::ifstream in_file(filename);
if (in_file.good()) {
in_file.close();
std::string cmd = "rm -rf " + filename;
system(cmd.c_str());
}
std::ofstream out_file(filename);
for (size_t i = 0; i < 10000; i++) {
out_file << i << " " << i << " ";
for (size_t j = 0; j < 3; j++) {
out_file << i + 1 << " ";
}
out_file << std::endl;
std::ifstream in_file(filename);
if (in_file.good()) {
in_file.close();
std::string cmd = "rm -rf " + filename;
system(cmd.c_str());
}
std::ofstream out_file(filename);
for (size_t i = 0; i < 10000; i++) {
out_file << i << " " << i << " ";
for (size_t j = 0; j < 3; j++) {
out_file << i + 1 << " ";
}
out_file.close();
out_file << std::endl;
}
out_file.close();
}
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
......@@ -12,139 +12,132 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "kvdb/rocksdb_impl.h"
#include <thread>
#include <iterator>
#include <fstream>
#include <algorithm>
#include <fstream>
#include <iterator>
#include <sstream>
#include <thread>
#include "kvdb/rocksdb_impl.h"
std::vector<FileReaderPtr> ParamDict::GetDictReaderLst() {
return this->file_reader_lst_;
return this->file_reader_lst_;
}
void ParamDict::SetFileReaderLst(std::vector<std::string> lst) {
for (size_t i = 0; i < lst.size(); i++) {
FileReaderPtr fr = std::make_shared<FileReader>();
fr->SetFileName(lst[i]);
this->file_reader_lst_.push_back(fr);
}
for (size_t i = 0; i < lst.size(); i++) {
FileReaderPtr fr = std::make_shared<FileReader>();
fr->SetFileName(lst[i]);
this->file_reader_lst_.push_back(fr);
}
}
std::vector<float> ParamDict::GetSparseValue(std::string feasign, std::string slot) {
auto BytesToFloat = [](uint8_t* byteArray){
return *((float*)byteArray);
};
//TODO: the concatation of feasign and slot is TBD.
std::string result = front_db->Get(feasign + slot);
std::vector<float> value;
if (result == "NOT_FOUND")
return value;
uint8_t* raw_values_ptr = reinterpret_cast<uint8_t *>(&result[0]);
for (size_t i = 0; i < result.size(); i += 4) {
float temp = BytesToFloat(raw_values_ptr + i);
value.push_back(temp);
}
return value;
std::vector<float> ParamDict::GetSparseValue(std::string feasign,
std::string slot) {
auto BytesToFloat = [](uint8_t* byte_array) { return *((float*)byte_array); };
// TODO: the concatation of feasign and slot is TBD.
std::string result = front_db->Get(feasign + slot);
std::vector<float> value;
if (result == "NOT_FOUND") return value;
uint8_t* raw_values_ptr = reinterpret_cast<uint8_t*>(&result[0]);
for (size_t i = 0; i < result.size(); i += sizeof(float)) {
float temp = BytesToFloat(raw_values_ptr + i);
value.push_back(temp);
}
return value;
}
void ParamDict::SetReader(std::function<std::pair<Key, Value>(std::string)> func) {
read_func_ = func;
void ParamDict::SetReader(
std::function<std::pair<Key, Value>(std::string)> func) {
read_func_ = func;
}
std::vector<float> ParamDict::GetSparseValue(int64_t feasign, int64_t slot) {
return this->GetSparseValue(std::to_string(feasign), std::to_string(slot));
return this->GetSparseValue(std::to_string(feasign), std::to_string(slot));
}
bool ParamDict::InsertSparseValue(int64_t feasign, int64_t slot, const std::vector<float>& values) {
return this->InsertSparseValue(std::to_string(feasign), std::to_string(slot), values);
bool ParamDict::InsertSparseValue(int64_t feasign,
int64_t slot,
const std::vector<float>& values) {
return this->InsertSparseValue(
std::to_string(feasign), std::to_string(slot), values);
}
bool ParamDict::InsertSparseValue(std::string feasign, std::string slot, const std::vector<float>& values) {
auto FloatToBytes = [](float fvalue, uint8_t *arr){
unsigned char *pf = nullptr;
unsigned char *px = nullptr;
unsigned char i = 0;
pf =(unsigned char *)&fvalue;
px = arr;
for (i = 0; i < 4; i++)
{
*(px+i)=*(pf+i);
}
};
std::string key = feasign + slot;
uint8_t* values_ptr = new uint8_t[values.size() * 4];
std::string value;
for (size_t i = 0; i < values.size(); i++) {
FloatToBytes(values[i], values_ptr + 4 * i);
bool ParamDict::InsertSparseValue(std::string feasign,
std::string slot,
const std::vector<float>& values) {
auto FloatToBytes = [](float fvalue, uint8_t* arr) {
unsigned char* pf = nullptr;
unsigned char* px = nullptr;
unsigned char i = 0;
pf = (unsigned char*)&fvalue;
px = arr;
for (i = 0; i < sizeof(float); i++) {
*(px + i) = *(pf + i);
}
char* raw_values_ptr = reinterpret_cast<char*>(values_ptr);
for (size_t i = 0; i < values.size()*4; i++) {
value.push_back(raw_values_ptr[i]);
}
back_db->Set(key, value);
//TODO: change stateless to stateful
return true;
};
std::string key = feasign + slot;
uint8_t* values_ptr = new uint8_t[values.size() * sizeof(float)];
std::string value;
for (size_t i = 0; i < values.size(); i++) {
FloatToBytes(values[i], values_ptr + sizeof(float) * i);
}
char* raw_values_ptr = reinterpret_cast<char*>(values_ptr);
for (size_t i = 0; i < values.size() * sizeof(float); i++) {
value.push_back(raw_values_ptr[i]);
}
back_db->Set(key, value);
// TODO: change stateless to stateful
return true;
}
void ParamDict::UpdateBaseModel() {
auto is_number = [] (const std::string& s)
{
return !s.empty() && std::find_if(s.begin(),
s.end(), [](char c) { return !std::isdigit(c); }) == s.end();
};
std::thread t([&] () {
for (FileReaderPtr file_reader: this->file_reader_lst_) {
std::string line;
std::ifstream infile(file_reader->GetFileName());
if (infile.is_open()) {
while (getline(infile, line)) {
std::pair<Key, Value> kvpair = read_func_(line);
std::vector<float> nums;
for (size_t i = 0; i < kvpair.second.size(); i++) {
if (is_number(kvpair.second[i])) {
nums.push_back(std::stof(kvpair.second[i]));
}
}
this->InsertSparseValue(kvpair.first, "", nums);
}
auto is_number = [](const std::string& s) {
return !s.empty() && std::find_if(s.begin(), s.end(), [](char c) {
return !std::isdigit(c);
}) == s.end();
};
std::thread t([&]() {
for (FileReaderPtr file_reader : this->file_reader_lst_) {
std::string line;
std::ifstream infile(file_reader->GetFileName());
if (infile.is_open()) {
while (getline(infile, line)) {
std::pair<Key, Value> kvpair = read_func_(line);
std::vector<float> nums;
for (size_t i = 0; i < kvpair.second.size(); i++) {
if (is_number(kvpair.second[i])) {
nums.push_back(std::stof(kvpair.second[i]));
}
infile.close();
}
this->InsertSparseValue(kvpair.first, "", nums);
}
AbsKVDBPtr temp = front_db;
front_db = back_db;
back_db = temp;
});
t.detach();
}
infile.close();
}
AbsKVDBPtr temp = front_db;
front_db = back_db;
back_db = temp;
});
t.detach();
}
void ParamDict::UpdateDeltaModel() { UpdateBaseModel(); }
void ParamDict::UpdateDeltaModel() {
UpdateBaseModel();
}
std::pair<AbsKVDBPtr, AbsKVDBPtr> ParamDict::GetKVDB() {
return {front_db, back_db};
std::pair<AbsKVDBPtr, AbsKVDBPtr> ParamDict::GetKVDB() {
return {front_db, back_db};
}
void ParamDict::SetKVDB(std::pair<AbsKVDBPtr, AbsKVDBPtr> kvdbs) {
this->front_db = kvdbs.first;
this->back_db = kvdbs.second;
this->front_db = kvdbs.first;
this->back_db = kvdbs.second;
}
void ParamDict::CreateKVDB() {
this->front_db = std::make_shared<RocksKVDB>();
this->back_db = std::make_shared<RocksKVDB>();
this->front_db->CreateDB();
this->back_db->CreateDB();
this->front_db = std::make_shared<RocksKVDB>();
this->back_db = std::make_shared<RocksKVDB>();
this->front_db->CreateDB();
this->back_db->CreateDB();
}
ParamDict::~ParamDict() {
}
ParamDict::~ParamDict() {}
......@@ -15,39 +15,40 @@
#include "kvdb/paddle_rocksdb.h"
RocksDBWrapper::RocksDBWrapper(std::string db_name) {
rocksdb::Options options;
options.create_if_missing = true;
db_name_ = db_name;
db_ = nullptr;
rocksdb::Status s = rocksdb::DB::Open(options, db_name, &db_);
return;
rocksdb::Options options;
options.create_if_missing = true;
db_name_ = db_name;
db_ = nullptr;
rocksdb::Status s = rocksdb::DB::Open(options, db_name, &db_);
return;
}
std::string RocksDBWrapper::Get(std::string key) {
rocksdb::ReadOptions options;
options.verify_checksums = true;
std::string result;
rocksdb::Status s = db_->Get(options, key, &result);
if (s.IsNotFound()) {
result = "NOT_FOUND";
}
return result;
rocksdb::ReadOptions options;
options.verify_checksums = true;
std::string result;
rocksdb::Status s = db_->Get(options, key, &result);
if (s.IsNotFound()) {
result = "NOT_FOUND";
}
return result;
}
bool RocksDBWrapper::Put(std::string key, std::string value) {
rocksdb::WriteOptions options;
rocksdb::Status s = db_->Put(options, key, value);
if (s.ok()) {
return true;
} else {
return false;
}
rocksdb::WriteOptions options;
rocksdb::Status s = db_->Put(options, key, value);
if (s.ok()) {
return true;
} else {
return false;
}
}
void RocksDBWrapper::SetDBName(std::string db_name) {
this->db_name_ = db_name;
this->db_name_ = db_name;
}
std::shared_ptr<RocksDBWrapper> RocksDBWrapper::RocksDBWrapperFactory(std::string db_name) {
return std::make_shared<RocksDBWrapper>(db_name);
std::shared_ptr<RocksDBWrapper> RocksDBWrapper::RocksDBWrapperFactory(
std::string db_name) {
return std::make_shared<RocksDBWrapper>(db_name);
}
......@@ -15,14 +15,14 @@
#include "kvdb/kvdb_impl.h"
void ParamDictMgr::UpdateAll() {
for (auto it = this->ParamDictMap.begin(); it!= this->ParamDictMap.end(); ++it) {
it->second->UpdateBaseModel();
}
for (auto it = this->ParamDictMap.begin(); it != this->ParamDictMap.end();
++it) {
it->second->UpdateBaseModel();
}
}
void ParamDictMgr::InsertParamDict(std::string key, ParamDictPtr value) {
this->ParamDictMap.insert(std::make_pair(key, value));
this->ParamDictMap.insert(std::make_pair(key, value));
}
AbstractKVDB::~AbstractKVDB() {}
......@@ -16,29 +16,22 @@
int RocksKVDB::db_count;
void RocksKVDB::CreateDB() {
this->db_ = RocksDBWrapper::RocksDBWrapperFactory("RocksDB_" + std::to_string(RocksKVDB::db_count));
RocksKVDB::db_count ++;
return;
this->db_ = RocksDBWrapper::RocksDBWrapperFactory(
"RocksDB_" + std::to_string(RocksKVDB::db_count));
RocksKVDB::db_count++;
return;
}
void RocksKVDB::SetDBName(std::string db_name) {
this->db_->SetDBName(db_name);
return;
this->db_->SetDBName(db_name);
return;
}
void RocksKVDB::Set(std::string key, std::string value) {
this->db_->Put(key, value);
return;
this->db_->Put(key, value);
return;
}
std::string RocksKVDB::Get(std::string key) {
return this->db_->Get(key);
}
RocksKVDB::~RocksKVDB() {
}
std::string RocksKVDB::Get(std::string key) { return this->db_->Get(key); }
RocksKVDB::~RocksKVDB() {}
......@@ -12,37 +12,34 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "kvdb/rocksdb_impl.h"
#include "kvdb/paddle_rocksdb.h"
#include <iostream>
#include "kvdb/paddle_rocksdb.h"
#include "kvdb/rocksdb_impl.h"
void test_rockskvdb() {
RocksKVDB db;
db.CreateDB();
db.SetDBName("Sparse Matrix");
db.Set("1", "One");
std::cout << db.Get("1") << std::endl;
return ;
RocksKVDB db;
db.CreateDB();
db.SetDBName("Sparse Matrix");
db.Set("1", "One");
std::cout << db.Get("1") << std::endl;
return;
}
void test_rocksdbwrapper() {
std::shared_ptr<RocksDBWrapper> db = RocksDBWrapper::RocksDBWrapperFactory("TEST");
for (size_t i = 0; i < 1000; i++) {
db->Put(std::to_string(i), std::to_string(i * 2));
}
for (size_t i = 0; i < 1000; i++) {
std::string res = db->Get(std::to_string(i));
std::cout << res << " ";
}
std::cout << std::endl;
std::shared_ptr<RocksDBWrapper> db =
RocksDBWrapper::RocksDBWrapperFactory("TEST");
for (size_t i = 0; i < 1000; i++) {
db->Put(std::to_string(i), std::to_string(i * 2));
}
for (size_t i = 0; i < 1000; i++) {
std::string res = db->Get(std::to_string(i));
std::cout << res << " ";
}
std::cout << std::endl;
}
#ifdef RAW_TEST
int main() {
test_rockskvdb();
test_rocksdbwrapper();
test_rockskvdb();
test_rocksdbwrapper();
}
#endif
......@@ -484,7 +484,8 @@ class PdsCodeGenerator : public CodeGenerator {
"response);\n"
"}\n"
"tt.stop();\n"
"if (ret.flags != baidu::rpc::SKIP_SUB_CHANNEL && ret.method != NULL) {\n"
"if (ret.flags != baidu::rpc::SKIP_SUB_CHANNEL && ret.method != "
"NULL) {\n"
" _stub_handler->update_latency(tt.u_elapsed(), \"pack_map\");\n"
"}\n"
"return ret;\n");
......@@ -498,7 +499,8 @@ class PdsCodeGenerator : public CodeGenerator {
////////////////////////////////////////////////////////////////
printer->Print(
"class $name$_StubResponseMerger : public baidu::rpc::ResponseMerger {\n"
"class $name$_StubResponseMerger : public baidu::rpc::ResponseMerger "
"{\n"
"private:\n"
" uint32_t _package_size;\n"
" baidu::paddle_serving::sdk_cpp::Stub* _stub_handler;\n"
......@@ -600,7 +602,8 @@ class PdsCodeGenerator : public CodeGenerator {
"}\n");
"LOG(INFO) \n"
" << \"[default] Succ map, channel_index: \" << channel_index;\n";
printer->Print("return baidu::rpc::SubCall(method, request, cur_res, 0);\n");
printer->Print(
"return baidu::rpc::SubCall(method, request, cur_res, 0);\n");
return true;
}
bool generate_paddle_serving_stub_default_merger(
......
......@@ -37,4 +37,3 @@ install(FILES ${CMAKE_CURRENT_LIST_DIR}/mempool/mempool.h
DESTINATION ${PADDLE_SERVING_INSTALL_DIR}/include/predictor/mempool)
install(FILES ${CMAKE_CURRENT_LIST_DIR}/op/op.h
DESTINATION ${PADDLE_SERVING_INSTALL_DIR}/include/predictor/op)
......@@ -20,11 +20,10 @@ namespace paddle_serving {
namespace predictor {
struct MempoolRegion {
MempoolRegion(im::fugue::memory::Region *region,
im::Mempool *mempool) :
_region(region), _mempool(mempool){}
im::fugue::memory::Region *region() {return _region;}
im::Mempool *mempool() {return _mempool;}
MempoolRegion(im::fugue::memory::Region* region, im::Mempool* mempool)
: _region(region), _mempool(mempool) {}
im::fugue::memory::Region* region() { return _region; }
im::Mempool* mempool() { return _mempool; }
im::fugue::memory::Region* _region;
im::Mempool* _mempool;
......@@ -54,10 +53,10 @@ int MempoolWrapper::initialize() {
}
int MempoolWrapper::thread_initialize() {
im::fugue::memory::Region *region = new im::fugue::memory::Region();
im::fugue::memory::Region* region = new im::fugue::memory::Region();
region->init();
im::Mempool* mempool = new (std::nothrow) im::Mempool(region);
MempoolRegion *mempool_region = new MempoolRegion(region, mempool);
MempoolRegion* mempool_region = new MempoolRegion(region, mempool);
if (mempool == NULL) {
LOG(ERROR) << "Failed create thread mempool";
return -1;
......@@ -76,7 +75,8 @@ int MempoolWrapper::thread_initialize() {
}
int MempoolWrapper::thread_clear() {
MempoolRegion* mempool_region = (MempoolRegion*)THREAD_GETSPECIFIC(_bspec_key);
MempoolRegion* mempool_region =
(MempoolRegion*)THREAD_GETSPECIFIC(_bspec_key);
if (mempool_region == NULL) {
LOG(WARNING) << "THREAD_GETSPECIFIC() returned NULL";
return -1;
......@@ -91,7 +91,8 @@ int MempoolWrapper::thread_clear() {
}
void* MempoolWrapper::malloc(size_t size) {
MempoolRegion* mempool_region = (MempoolRegion*)THREAD_GETSPECIFIC(_bspec_key);
MempoolRegion* mempool_region =
(MempoolRegion*)THREAD_GETSPECIFIC(_bspec_key);
if (mempool_region == NULL) {
LOG(WARNING) << "THREAD_GETSPECIFIC() returned NULL";
return NULL;
......
......@@ -39,7 +39,7 @@ class MempoolWrapper {
void* malloc(size_t size);
private:
//im::fugue::memory::Region _region;
// im::fugue::memory::Region _region;
THREAD_KEY_T _bspec_key;
};
......
......@@ -24,7 +24,7 @@
#include <butil/scoped_lock.h> // BAIDU_SCOPED_LOCK
#endif
#include <bvar/bvar.h> // bvar
#include <bvar/bvar.h> // bvar
#include <string>
#ifdef BCLOUD
......
......@@ -36,13 +36,9 @@ DynamicResource::DynamicResource() {}
DynamicResource::~DynamicResource() {}
int DynamicResource::initialize() {
return 0;
}
int DynamicResource::initialize() { return 0; }
std::shared_ptr<RocksDBWrapper> Resource::getDB() {
return db;
}
std::shared_ptr<RocksDBWrapper> Resource::getDB() { return db; }
int DynamicResource::clear() { return 0; }
......@@ -86,7 +82,7 @@ int Resource::initialize(const std::string& path, const std::string& file) {
LOG(ERROR) << "unable to create tls_bthread_key of thrd_data";
return -1;
}
//init rocksDB instance
// init rocksDB instance
if (db.get() == nullptr) {
db = RocksDBWrapper::RocksDBWrapperFactory("kvdb");
}
......
......@@ -14,9 +14,9 @@
#pragma once
#include <string>
#include "kvdb/paddle_rocksdb.h"
#include "predictor/common/inner_common.h"
#include "predictor/framework/memory.h"
#include "kvdb/paddle_rocksdb.h"
namespace baidu {
namespace paddle_serving {
......@@ -31,7 +31,6 @@ struct DynamicResource {
int initialize();
int clear();
};
class Resource {
......@@ -65,7 +64,7 @@ class Resource {
private:
int thread_finalize() { return 0; }
std::shared_ptr<RocksDBWrapper> db;
THREAD_KEY_T _tls_bspec_key;
};
......
......@@ -16,7 +16,7 @@
#ifdef BCLOUD
#include <baidu/rpc/policy/nova_pbrpc_protocol.h> // NovaServiceAdaptor
#include <baidu/rpc/policy/nshead_mcpack_protocol.h> // NsheadMcpackAdaptor
#include <baidu/rpc/policy/public_pbrpc_protocol.h> // PublicPbrpcServiceAdaptor
#include <baidu/rpc/policy/public_pbrpc_protocol.h> // PublicPbrpcServiceAdaptor
#else
#include <brpc/policy/nova_pbrpc_protocol.h> // NovaServiceAdaptor
#include <brpc/policy/nshead_mcpack_protocol.h> // NsheadMcpackAdaptor
......
......@@ -17,16 +17,11 @@ package baidu.paddle_serving.predictor.format;
// echo kvdb formant
message KVDBReq {
required string op = 1;
required string key = 2;
optional string value = 3;
required string op = 1;
required string key = 2;
optional string value = 3;
};
message KVDBRes{
required string value = 2;
};
message KVDBRes { required string value = 2; };
// dense format
message DenseInstance { repeated float features = 1; };
......
......@@ -143,7 +143,8 @@ int main(int argc, char** argv) {
std::string filename(argv[0]);
filename = filename.substr(filename.find_last_of('/') + 1);
settings.log_file = strdup((std::string("./log/") + filename + ".log").c_str());
settings.log_file =
strdup((std::string("./log/") + filename + ".log").c_str());
settings.delete_old = logging::DELETE_OLD_LOG_FILE;
logging::InitLogging(settings);
......
......@@ -31,11 +31,11 @@
#include "baidu/rpc/channel.h"
#include "baidu/rpc/parallel_channel.h"
#include "baidu/rpc/traceprintf.h"
#include "bthread.h"
#include "base/logging.h"
#include "base/comlog_sink.h"
#include "base/logging.h"
#include "base/object_pool.h"
#include "base/time.h"
#include "bthread.h"
#else
#include "brpc/channel.h"
#include "brpc/parallel_channel.h"
......
......@@ -20,15 +20,15 @@ package baidu.paddle_serving.predictor.echo_kvdb_service;
option cc_generic_services = true;
message Request {
repeated baidu.paddle_serving.predictor.format.KVDBReq reqs = 1;
repeated baidu.paddle_serving.predictor.format.KVDBReq reqs = 1;
};
message Response {
repeated baidu.paddle_serving.predictor.format.KVDBRes ress = 1;
repeated baidu.paddle_serving.predictor.format.KVDBRes ress = 1;
};
service EchoKVDBService {
rpc inference(Request) returns (Response);
rpc debug(Request) returns (Response);
option (pds.options).generate_stub = true;
rpc inference(Request) returns (Response);
rpc debug(Request) returns (Response);
option (pds.options).generate_stub = true;
};
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册