run on xpu bugfix

core/configure/CMakeLists.txt

@@ -76,7 +76,7 @@ if (SERVER)
 py_proto_compile(server_config_py_proto SRCS proto/server_configure.proto)
 add_custom_target(server_config_py_proto_init ALL COMMAND ${CMAKE_COMMAND} -E touch __init__.py)
 add_dependencies(server_config_py_proto server_config_py_proto_init)
-if (NOT WITH_GPU)
+if (NOT WITH_GPU AND NOT WITH_LITE)
 add_custom_command(TARGET server_config_py_proto POST_BUILD
 		COMMAND ${CMAKE_COMMAND} -E make_directory ${PADDLE_SERVING_BINARY_DIR}/python/paddle_serving_server/proto
 		COMMAND cp *.py ${PADDLE_SERVING_BINARY_DIR}/python/paddle_serving_server/proto

python/CMakeLists.txt

@@ -7,7 +7,7 @@ if (CLIENT)
 endif()
 
 if (SERVER)
-    if (NOT WITH_GPU)
+    if (NOT WITH_GPU AND NOT WITH_LITE)
         file(INSTALL pipeline DESTINATION paddle_serving_server)
         file(GLOB_RECURSE SERVING_SERVER_PY_FILES paddle_serving_server/*.py)
     else()
@@ -34,7 +34,7 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/setup.py.app.in
 endif()
 
 if (SERVER)
-    if (NOT WITH_GPU)
+    if (NOT WITH_GPU AND NOT WITH_LITE)
         configure_file(${CMAKE_CURRENT_SOURCE_DIR}/setup.py.server.in
             ${CMAKE_CURRENT_BINARY_DIR}/setup.py)
     else()
@@ -72,7 +72,7 @@ add_custom_target(paddle_python ALL DEPENDS serving_client ${PADDLE_SERVING_BINA
 endif()
 
 if (SERVER)
-    if(NOT WITH_GPU)
+    if(NOT WITH_GPU AND NOT WITH_LITE)
         add_custom_command(
             OUTPUT ${PADDLE_SERVING_BINARY_DIR}/.timestamp
             COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/paddle_serving_server/ ${PADDLE_SERVING_BINARY_DIR}/python/
@@ -90,6 +90,16 @@ if (SERVER)
             COMMAND env ${py_env} ${PYTHON_EXECUTABLE} setup.py bdist_wheel
             DEPENDS ${SERVING_SERVER_CORE} server_config_py_proto ${PY_FILES})
         add_custom_target(paddle_python ALL DEPENDS ${PADDLE_SERVING_BINARY_DIR}/.timestamp)
+    elseif(WITH_LITE)
+        add_custom_command(
+            OUTPUT ${PADDLE_SERVING_BINARY_DIR}/.timestamp
+            COMMAND cp -r
+            ${CMAKE_CURRENT_SOURCE_DIR}/paddle_serving_server_gpu/ ${PADDLE_SERVING_BINARY_DIR}/python/
+            COMMAND env ${py_env} ${PYTHON_EXECUTABLE} gen_version.py
+            "server_gpu" arm 
+            COMMAND env ${py_env} ${PYTHON_EXECUTABLE} setup.py bdist_wheel
+            DEPENDS ${SERVING_SERVER_CORE} server_config_py_proto ${PY_FILES})
+        add_custom_target(paddle_python ALL DEPENDS ${PADDLE_SERVING_BINARY_DIR}/.timestamp)
     else()
         add_custom_command(
             OUTPUT ${PADDLE_SERVING_BINARY_DIR}/.timestamp

python/paddle_serving_server_gpu/__init__.py

@@ -75,6 +75,10 @@ def serve_args():
         help="Use Multi-language-service")
     parser.add_argument(
         "--use_trt", default=False, action="store_true", help="Use TensorRT")
+    parser.add_argument(
+        "--use_lite", default=False, action="store_true", help="Use PaddleLite")
+    parser.add_argument(
+        "--use_xpu", default=False, action="store_true", help="Use XPU")
     parser.add_argument(
         "--product_name",
         type=str,
@@ -208,6 +212,8 @@ class Server(object):
         self.use_local_bin = False
         self.gpuid = 0
         self.use_trt = False
+        self.use_lite = False
+        self.use_xpu = False
         self.model_config_paths = None  # for multi-model in a workflow
         self.product_name = None
         self.container_id = None
@@ -277,6 +283,12 @@ class Server(object):
     def set_trt(self):
         self.use_trt = True
 
+    def set_lite(self):
+        self.use_lite = True
+
+    def set_xpu(self):
+        self.use_xpu = True
+
     def _prepare_engine(self, model_config_paths, device):
         if self.model_toolkit_conf == None:
             self.model_toolkit_conf = server_sdk.ModelToolkitConf()
@@ -297,11 +309,17 @@ class Server(object):
             engine.static_optimization = False
             engine.force_update_static_cache = False
             engine.use_trt = self.use_trt
+            engine.use_lite = self.use_lite
+            engine.use_xpu = self.use_xpu
+
+
 
             if device == "cpu":
                 engine.type = "FLUID_CPU_ANALYSIS_DIR"
             elif device == "gpu":
                 engine.type = "FLUID_GPU_ANALYSIS_DIR"
+            elif device == "arm":
+                engine.type = "FLUID_ARM_ANALYSIS_DIR"
 
             self.model_toolkit_conf.engines.extend([engine])
 
@@ -505,36 +523,65 @@ class Server(object):
                 time.sleep(1)
         else:
             print("Use local bin : {}".format(self.bin_path))
-        self.check_cuda()
-        command = "{} " \
-                  "-enable_model_toolkit " \
-                  "-inferservice_path {} " \
-                  "-inferservice_file {} " \
-                  "-max_concurrency {} " \
-                  "-num_threads {} " \
-                  "-port {} " \
-                  "-reload_interval_s {} " \
-                  "-resource_path {} " \
-                  "-resource_file {} " \
-                  "-workflow_path {} " \
-                  "-workflow_file {} " \
-                  "-bthread_concurrency {} " \
-                  "-gpuid {} " \
-                  "-max_body_size {} ".format(
-                      self.bin_path,
-                      self.workdir,
-                      self.infer_service_fn,
-                      self.max_concurrency,
-                      self.num_threads,
-                      self.port,
-                      self.reload_interval_s,
-                      self.workdir,
-                      self.resource_fn,
-                      self.workdir,
-                      self.workflow_fn,
-                      self.num_threads,
-                      self.gpuid,
-                      self.max_body_size)
+        #self.check_cuda()
+        if self.use_lite:
+            command = "{} " \
+                      "-enable_model_toolkit " \
+                      "-inferservice_path {} " \
+                      "-inferservice_file {} " \
+                      "-max_concurrency {} " \
+                      "-num_threads {} " \
+                      "-port {} " \
+                      "-reload_interval_s {} " \
+                      "-resource_path {} " \
+                      "-resource_file {} " \
+                      "-workflow_path {} " \
+                      "-workflow_file {} " \
+                      "-bthread_concurrency {} " \
+                      "-max_body_size {} ".format(
+                          self.bin_path,
+                          self.workdir,
+                          self.infer_service_fn,
+                          self.max_concurrency,
+                          self.num_threads,
+                          self.port,
+                          self.reload_interval_s,
+                          self.workdir,
+                          self.resource_fn,
+                          self.workdir,
+                          self.workflow_fn,
+                          self.num_threads,
+                          self.max_body_size)
+        else:
+            command = "{} " \
+                      "-enable_model_toolkit " \
+                      "-inferservice_path {} " \
+                      "-inferservice_file {} " \
+                      "-max_concurrency {} " \
+                      "-num_threads {} " \
+                      "-port {} " \
+                      "-reload_interval_s {} " \
+                      "-resource_path {} " \
+                      "-resource_file {} " \
+                      "-workflow_path {} " \
+                      "-workflow_file {} " \
+                      "-bthread_concurrency {} " \
+                      "-gpuid {} " \
+                      "-max_body_size {} ".format(
+                          self.bin_path,
+                          self.workdir,
+                          self.infer_service_fn,
+                          self.max_concurrency,
+                          self.num_threads,
+                          self.port,
+                          self.reload_interval_s,
+                          self.workdir,
+                          self.resource_fn,
+                          self.workdir,
+                          self.workflow_fn,
+                          self.num_threads,
+                          self.gpuid,
+                          self.max_body_size)
         print("Going to Run Comand")
         print(command)
 

python/paddle_serving_server_gpu/serve.py

@@ -38,7 +38,9 @@ def start_gpu_card_model(index, gpuid, args):  # pylint: disable=doc-string-miss
     ir_optim = args.ir_optim
     max_body_size = args.max_body_size
     use_multilang = args.use_multilang
-    workdir = "{}_{}".format(args.workdir, gpuid)
+    workdir = args.workdir
+    if gpuid >= 0:
+        workdir = "{}_{}".format(args.workdir, gpuid)
 
     if model == "":
         print("You must specify your serving model")
@@ -67,6 +69,13 @@ def start_gpu_card_model(index, gpuid, args):  # pylint: disable=doc-string-miss
     if args.use_trt:
         server.set_trt()
 
+    if args.use_lite:
+        server.set_lite()
+        device = "arm"
+
+    if args.use_xpu:
+        server.set_xpu()
+
     if args.product_name != None:
         server.set_product_name(args.product_name)
     if args.container_id != None:
@@ -95,7 +104,10 @@ def start_multi_card(args):  # pylint: disable=doc-string-missing
                     exit(-1)
         else:
             env_gpus = []
-    if len(gpus) <= 0:
+    if args.use_lite:
+        print("run arm server.")
+        start_gpu_card_model(-1, -1, args)
+    elif len(gpus) <= 0:
         print("gpu_ids not set, going to run cpu service.")
         start_gpu_card_model(-1, -1, args)
     else: