factory.h

// 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.

#pragma once
#include <map>
#include <string>
#include <utility>
#include "core/sdk-cpp/include/common.h"
#include "core/sdk-cpp/include/stub_impl.h"

namespace baidu {
namespace paddle_serving {
namespace sdk_cpp {

#ifdef BCLOUD
namespace brpc = baidu::rpc;
#endif

#define ERROR_STRING_LEN 10240

#define INLINE_REGIST_OBJECT(D, B, E)                                   \
  do {                                                                  \
    Factory<D, B>* factory = new (std::nothrow) Factory<D, B>();        \
    if (factory == NULL ||                                              \
        FactoryPool<B>::instance().register_factory(#D, factory) != 0) {\
      char err_str[ERROR_STRING_LEN];                                   \
      snprintf(err_str, ERROR_STRING_LEN - 1,                           \
        "Failed regist factory: %s->%s in macro!", #D, #B);             \
      RAW_LOG(ERROR, err_str);                                          \
      return E;                                                         \
    }                                                                   \
  } while (0)

#define DECLARE_FACTORY_OBJECT(D, B)                                    \
  static int regist(const std::string& tag) {                           \
    Factory<D, B>* factory = new (std::nothrow) Factory<D, B>();        \
    if (factory == NULL ||                                              \
      FactoryPool<B>::instance().register_factory(tag, factory) != 0) { \
      char err_str[ERROR_STRING_LEN];                                   \
      snprintf(err_str, ERROR_STRING_LEN - 1,                           \
        "Failed regist factory: %s in macro!", #D);                     \
      RAW_LOG(ERROR, err_str);                                          \
      return -1;                                                        \
    }                                                                   \
    return 0;                                                           \
  }

#define PDS_STR_CAT(a, b) PDS_STR_CAT_I(a, b)
#define PDS_STR_CAT_I(a, b) a##b

#define DEFINE_FACTORY_OBJECT(D)                                           \
  __attribute__((constructor)) static void PDS_STR_CAT(GlobalRegistObject, \
                                                       __LINE__)(void) {   \
    D::regist(#D);                                                         \
  }

#define REGIST_FACTORY_OBJECT_IMPL(D, B)                                    \
  __attribute__((constructor)) static void PDS_STR_CAT(GlobalRegistObject,  \
                                                       __LINE__)(void) {    \
    ::baidu::paddle_serving::sdk_cpp::Factory<D, B>* factory =              \
      new (::std::nothrow)::baidu::paddle_serving::sdk_cpp::Factory<D, B>();\
    if (factory == NULL ||                                                  \
      ::baidu::paddle_serving::sdk_cpp::FactoryPool<B>::instance()          \
                .register_factory(#D, factory) != 0) {                      \
      char err_str[ERROR_STRING_LEN];                                       \
      snprintf(err_str, ERROR_STRING_LEN - 1,                               \
        "Failed regist factory: %s->%s in macro!", #D, #B);                 \
      RAW_LOG(ERROR, err_str);                                              \
      return;                                                               \
    }                                                                       \
    return;                                                                 \
  }

#define REGIST_FACTORY_OBJECT_IMPL_WITH_TAG(D, B, T)                        \
  __attribute__((constructor)) static void PDS_STR_CAT(GlobalRegistObject,  \
                                                       __LINE__)(void) {    \
    ::baidu::paddle_serving::sdk_cpp::Factory<D, B>* factory =              \
      new (::std::nothrow)::baidu::paddle_serving::sdk_cpp::Factory<D, B>();\
    if (factory == NULL ||                                                  \
      ::baidu::paddle_serving::sdk_cpp::FactoryPool<B>::instance()          \
            .register_factory(T, factory) != 0) {                           \
      char err_str[ERROR_STRING_LEN];                                       \
      snprintf(err_str, ERROR_STRING_LEN - 1,                               \
        "Failed regist factory: %s->%s, tag %s in macro!", #D, #B, T);      \
      RAW_LOG(ERROR, err_str);                                              \
      return;                                                               \
    }                                                                       \
    return;                                                                 \
  } 

#define REGIST_ABTEST_OBJECT(D) \
  REGIST_FACTORY_OBJECT_IMPL(   \
      D, ::baidu::paddle_serving::sdk_cpp::ABTestRouterBase)

#define REGIST_ABTEST_OBJECT_WITH_TAG(D, T) \
  REGIST_FACTORY_OBJECT_IMPL_WITH_TAG(      \
      D, ::baidu::paddle_serving::sdk_cpp::ABTestRouterBase, T)

#define REGIST_STUB_OBJECT_WITH_TAG(D, C, R, I, O, T)                       \
  __attribute__((constructor)) static void PDS_STR_CAT(GlobalRegistObject,  \
                                                       __LINE__)(void) {    \
    ::baidu::paddle_serving::sdk_cpp::Factory<                              \
        ::baidu::paddle_serving::sdk_cpp::StubImpl<D, C, R, I, O>,          \
        ::baidu::paddle_serving::sdk_cpp::Stub>* factory =                  \
        new (::std::nothrow)::baidu::paddle_serving::sdk_cpp::Factory<      \
            ::baidu::paddle_serving::sdk_cpp::StubImpl<D, C, R, I, O>,      \
            ::baidu::paddle_serving::sdk_cpp::Stub>();                      \
    if (factory == NULL ||                                                  \
        ::baidu::paddle_serving::sdk_cpp::FactoryPool<                      \
            ::baidu::paddle_serving::sdk_cpp::Stub>::instance()             \
                .register_factory(T, factory) != 0) {                       \
      char err_str[ERROR_STRING_LEN];                                       \
      snprintf(err_str, ERROR_STRING_LEN - 1,                               \
        "Failed regist factory: %s->Stub, tag: %s in macro!", #D, T);       \
      RAW_LOG(ERROR, err_str);                                              \
      return;                                                               \
    }                                                                       \
    return;                                                                 \
  }

class Stub;
class EndpointRouterBase;
class VariantRouterBase;

template <typename B>
class FactoryBase {
 public:
  virtual B* gen() = 0;
  virtual void del(B* obj) = 0;
};

template <typename D, typename B>
class Factory : public FactoryBase<B> {
 public:
  B* gen() { return new (std::nothrow) D(); }

  void del(B* obj) { delete dynamic_cast<D*>(obj); }
};

template <typename B>
class FactoryPool {
 public:
  static FactoryPool<B>& instance() {
    static FactoryPool<B> singleton;
    return singleton;
  }

  int register_factory(const std::string& tag, FactoryBase<B>* factory) {
    typename std::map<std::string, FactoryBase<B>*>::iterator it =
        _pool.find(tag);
    if (it != _pool.end()) {
      char err_str[ERROR_STRING_LEN];
      snprintf(err_str, ERROR_STRING_LEN - 1, 
        "Insert duplicate with tag: %s", tag.c_str());
      RAW_LOG(ERROR, err_str);
      return -1;
    }

    std::pair<typename std::map<std::string, FactoryBase<B>*>::iterator, bool>
        r = _pool.insert(std::make_pair(tag, factory));
    if (!r.second) {
      char err_str[ERROR_STRING_LEN];
      snprintf(err_str, ERROR_STRING_LEN - 1, 
        "Failed insert new factory with: %s", tag.c_str());
      RAW_LOG(ERROR, err_str);
      return -1;
    }

    return 0;
  }

  B* generate_object(const std::string& tag) {
    typename std::map<std::string, FactoryBase<B>*>::iterator it =
        _pool.find(tag);
    if (it == _pool.end() || it->second == NULL) {
      char err_str[ERROR_STRING_LEN];
      snprintf(err_str, ERROR_STRING_LEN - 1, 
        "Not found factory pool, tag: %s, pool size: %u", 
        tag.c_str(), _pool.size());
      RAW_LOG(ERROR, err_str);
      return NULL;
    }

    return it->second->gen();
  }

  template <typename D>
  void return_object(B* object) {
    Factory<D, B> factory;
    factory->del(object);
  }

 private:
  std::map<std::string, FactoryBase<B>*> _pool;
};

typedef FactoryPool<Stub> StubFactory;
typedef FactoryPool<brpc::CallMapper> CallMapperFactory;
typedef FactoryPool<brpc::ResponseMerger> ResponseMergerFactory;
typedef FactoryPool<EndpointRouterBase> EndpointRouterFactory;
typedef FactoryPool<VariantRouterBase> VariantRouterFactory;

}  // namespace sdk_cpp
}  // namespace paddle_serving
}  // namespace baidu