core.py 15.0 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
# 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.

from __future__ import print_function

17
import site
18 19
import sys
import os
20 21
import warnings
import platform
22

23 24 25 26 27 28 29 30 31 32 33 34 35 36
core_suffix = 'so'
if os.name == 'nt':
    core_suffix = 'pyd'

has_avx_core = False
has_noavx_core = False

current_path = os.path.abspath(os.path.dirname(__file__))
if os.path.exists(current_path + os.sep + 'core_avx.' + core_suffix):
    has_avx_core = True

if os.path.exists(current_path + os.sep + 'core_noavx.' + core_suffix):
    has_noavx_core = True

37 38
try:
    if os.name == 'nt':
39
        third_lib_path = current_path + os.sep + '..' + os.sep + 'libs'
40 41 42 43
        # Will load shared library from 'path' on windows
        os.environ[
            'path'] = current_path + ';' + third_lib_path + ';' + os.environ[
                'path']
44
        sys.path.insert(0, third_lib_path)
45 46 47 48 49
        # Note: from python3.8, PATH will not take effect
        # https://github.com/python/cpython/pull/12302
        # Use add_dll_directory to specify dll resolution path
        if sys.version_info[:2] >= (3, 8):
            os.add_dll_directory(third_lib_path)
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

except ImportError as e:
    from .. import compat as cpt
    if os.name == 'nt':
        executable_path = os.path.abspath(os.path.dirname(sys.executable))
        raise ImportError(
            """NOTE: You may need to run \"set PATH=%s;%%PATH%%\"
        if you encounters \"DLL load failed\" errors. If you have python
        installed in other directory, replace \"%s\" with your own
        directory. The original error is: \n %s""" %
            (executable_path, executable_path, cpt.get_exception_message(e)))
    else:
        raise ImportError(
            """NOTE: You may need to run \"export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH\"
        if you encounters \"libmkldnn.so not found\" errors. If you have python
        installed in other directory, replace \"/usr/local/lib\" with your own
        directory. The original error is: \n""" + cpt.get_exception_message(e))
except Exception as e:
    raise e

T
tensor-tang 已提交
70

T
tensor-tang 已提交
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
def avx_supported():
    """
    Whether current system(Linux, MacOS, Windows) is supported with AVX.
    """
    from .. import compat as cpt
    sysstr = platform.system().lower()
    has_avx = False
    if sysstr == 'linux':
        try:
            has_avx = os.popen('cat /proc/cpuinfo | grep -i avx').read() != ''
        except Exception as e:
            sys.stderr.write('Can not get the AVX flag from /proc/cpuinfo.\n'
                             'The original error is: %s\n' %
                             cpt.get_exception_message(e))
        return has_avx
    elif sysstr == 'darwin':
T
tensor-tang 已提交
87 88
        try:
            has_avx = os.popen(
T
tensor-tang 已提交
89
                'sysctl machdep.cpu.features | grep -i avx').read() != ''
T
tensor-tang 已提交
90 91
        except Exception as e:
            sys.stderr.write(
T
tensor-tang 已提交
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
                'Can not get the AVX flag from machdep.cpu.features.\n'
                'The original error is: %s\n' % cpt.get_exception_message(e))
        if not has_avx:
            try:
                has_avx = os.popen(
                    'sysctl machdep.cpu.leaf7_features | grep -i avx').read(
                    ) != ''
            except Exception as e:
                sys.stderr.write(
                    'Can not get the AVX flag from machdep.cpu.leaf7_features.\n'
                    'The original error is: %s\n' %
                    cpt.get_exception_message(e))
        return has_avx
    elif sysstr == 'windows':
        import ctypes
        ONE_PAGE = ctypes.c_size_t(0x1000)
T
tensor-tang 已提交
108

T
tensor-tang 已提交
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
        def asm_func(code_str, restype=ctypes.c_uint32, argtypes=()):
            # Call the code_str as a function
            # Alloc 1 page to ensure the protection
            pfnVirtualAlloc = ctypes.windll.kernel32.VirtualAlloc
            pfnVirtualAlloc.restype = ctypes.c_void_p
            MEM_COMMIT = ctypes.c_ulong(0x1000)
            PAGE_READWRITE = ctypes.c_ulong(0x4)
            address = pfnVirtualAlloc(None, ONE_PAGE, MEM_COMMIT,
                                      PAGE_READWRITE)
            if not address:
                raise Exception("Failed to VirtualAlloc")

            # Copy the code into the memory segment
            memmove = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p,
                                       ctypes.c_void_p,
                                       ctypes.c_size_t)(ctypes._memmove_addr)
            if memmove(address, code_str, len(code_str)) < 0:
                raise Exception("Failed to memmove")

            # Enable execute permissions
            PAGE_EXECUTE = ctypes.c_ulong(0x10)
            pfnVirtualProtect = ctypes.windll.kernel32.VirtualProtect
            res = pfnVirtualProtect(
                ctypes.c_void_p(address), ONE_PAGE, PAGE_EXECUTE,
                ctypes.byref(ctypes.c_ulong(0)))
            if not res:
                raise Exception("Failed VirtualProtect")

            # Flush instruction cache
            pfnGetCurrentProcess = ctypes.windll.kernel32.GetCurrentProcess
            pfnGetCurrentProcess.restype = ctypes.c_void_p
            prochandle = ctypes.c_void_p(pfnGetCurrentProcess())
            res = ctypes.windll.kernel32.FlushInstructionCache(
                prochandle, ctypes.c_void_p(address), ONE_PAGE)
            if not res:
                raise Exception("Failed FlushInstructionCache")

            # Cast the memory to function
            functype = ctypes.CFUNCTYPE(restype, *argtypes)
            func = functype(address)
            return func, address

        # http://en.wikipedia.org/wiki/CPUID#EAX.3D1:_Processor_Info_and_Feature_Bits
        # mov eax,0x1; cpuid; mov cx, ax; ret
        code_str = b"\xB8\x01\x00\x00\x00\x0f\xa2\x89\xC8\xC3"
        avx_bit = 28
        retval = 0
        try:
            # Convert the code_str into a function that returns uint
            func, address = asm_func(code_str)
            retval = func()
            ctypes.windll.kernel32.VirtualFree(
                ctypes.c_void_p(address), ctypes.c_size_t(0), ONE_PAGE)
        except Exception as e:
            sys.stderr.write('Failed getting the AVX flag on Windows.\n'
                             'The original error is: %s\n' %
                             cpt.get_exception_message(e))
        return (retval & (1 << avx_bit)) > 0
    else:
        sys.stderr.write('Do not get AVX flag on %s\n' % sysstr)
        return False


172 173 174 175 176 177 178 179
def run_shell_command(cmd):
    import subprocess
    out, err = subprocess.Popen(
        cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
        shell=True).communicate()
    if err:
        return None
    else:
180
        return out.decode('utf-8').strip()
181 182 183 184 185


def get_dso_path(core_so, dso_name):
    if core_so and dso_name:
        return run_shell_command("ldd %s|grep %s|awk '{print $3}'" %
186
                                 (core_so, dso_name))
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
    else:
        return None


def load_dso(dso_absolute_path):
    if dso_absolute_path:
        try:
            from ctypes import cdll
            cdll.LoadLibrary(dso_absolute_path)
        except:
            warnings.warn("Load {} failed".format(dso_absolute_path))


def pre_load(dso_name):
    if has_avx_core:
        core_so = current_path + os.sep + 'core_avx.' + core_suffix
    elif has_noavx_core:
        core_so = current_path + os.sep + 'core_noavx.' + core_suffix
    else:
        core_so = None
    dso_path = get_dso_path(core_so, dso_name)
    load_dso(dso_path)


chen.zhiyu's avatar
chen.zhiyu 已提交
211 212 213 214 215 216 217 218 219
def get_libc_ver():
    ldd_glibc = run_shell_command("ldd --version | awk '/ldd/{print $NF}'")
    if ldd_glibc is not None:
        return ("glibc", ldd_glibc)

    ldd_musl = run_shell_command("ldd 2>&1 | awk '/Version/{print $NF}'")
    if ldd_musl is not None:
        return ("musl", ldd_musl)
    return (None, None)
220 221 222


def less_than_ver(a, b):
223 224 225
    if a is None or b is None:
        return False

226 227 228 229
    import re
    import operator

    def to_list(s):
230
        s = re.sub(r'(\.0+)+$', '', s)
231 232 233 234 235 236 237 238 239 240 241 242 243
        return [int(x) for x in s.split('.')]

    return operator.lt(to_list(a), to_list(b))


# NOTE(zhiqiu): An error may occurs when import paddle in linux platform with glibc < 2.22, 
# the error message of which is "dlopen: cannot load any more object with static TLS".
# This happens when:
# (1) the number of dynamic shared librarys (DSO) loaded > 14,
# (2) after that, load a dynamic shared library (DSO) with static TLS.
# For paddle, the problem is that 'libgomp' is a DSO with static TLS, and it is loaded after 14 DSOs.
# So, here is a tricky way to solve the problem by pre load 'libgomp' before 'core_avx.so'.
# The final solution is to upgrade glibc to > 2.22 on the target system.
chen.zhiyu's avatar
chen.zhiyu 已提交
244 245 246 247 248 249 250 251
if platform.system().lower() == 'linux':
    libc_type, libc_ver = get_libc_ver()
    if libc_type == 'glibc' and less_than_ver(libc_ver, '2.23'):
        try:
            pre_load('libgomp')
        except Exception as e:
            # NOTE(zhiqiu): do not abort if failed, since it may success when import core_avx.so
            sys.stderr.write('Error: Can not preload libgomp.so')
252

T
tensor-tang 已提交
253 254 255
load_noavx = False

if avx_supported():
256 257 258 259 260 261 262
    try:
        from .core_avx import *
        from .core_avx import __doc__, __file__, __name__, __package__
        from .core_avx import __unittest_throw_exception__
        from .core_avx import _append_python_callable_object_and_return_id
        from .core_avx import _cleanup, _Scope
        from .core_avx import _get_use_default_grad_op_desc_maker_ops
263
        from .core_avx import _get_all_register_op_kernels
264 265
        from .core_avx import _is_program_version_supported
        from .core_avx import _set_eager_deletion_mode
266
        from .core_avx import _get_eager_deletion_vars
267 268
        from .core_avx import _set_fuse_parameter_group_size
        from .core_avx import _set_fuse_parameter_memory_size
Z
Zeng Jinle 已提交
269 270
        from .core_avx import _is_dygraph_debug_enabled
        from .core_avx import _dygraph_debug_level
271
        from .core_avx import _switch_tracer
272
        from .core_avx import _set_paddle_lib_path
273
        from .core_avx import _create_loaded_parameter
274
        from .core_avx import _cuda_synchronize
275
        from .core_avx import _is_compiled_with_heterps
276
        from .core_avx import _promote_types_if_complex_exists
277 278
        from .core_avx import _device_synchronize
        from .core_avx import _get_current_stream
279
        if sys.platform != 'win32':
280 281
            from .core_avx import _set_process_pids
            from .core_avx import _erase_process_pids
282 283
            from .core_avx import _set_process_signal_handler
            from .core_avx import _throw_error_if_process_failed
284
            from .core_avx import _convert_to_tensor_list
K
Kaipeng Deng 已提交
285
            from .core_avx import _array_to_share_memory_tensor
286 287
            from .core_avx import _cleanup_mmap_fds
            from .core_avx import _remove_tensor_list_mmap_fds
T
tensor-tang 已提交
288
    except Exception as e:
289
        if has_avx_core:
290 291 292
            sys.stderr.write(
                'Error: Can not import avx core while this file exists: ' +
                current_path + os.sep + 'core_avx.' + core_suffix + '\n')
293 294
            raise e
        else:
T
tensor-tang 已提交
295
            from .. import compat as cpt
296
            sys.stderr.write(
Z
Zhou Wei 已提交
297 298 299 300 301
                "Hint: Your machine support AVX, but the installed paddlepaddle doesn't have avx core. "
                "Hence, no-avx core with worse preformance will be imported.\nIf you like, you could "
                "reinstall paddlepaddle by 'python -m pip install --force-reinstall paddlepaddle-gpu[==version]' "
                "to get better performance.\nThe original error is: %s\n" %
                cpt.get_exception_message(e))
302
            load_noavx = True
303 304 305 306 307 308 309 310 311 312 313
else:
    load_noavx = True

if load_noavx:
    try:
        from .core_noavx import *
        from .core_noavx import __doc__, __file__, __name__, __package__
        from .core_noavx import __unittest_throw_exception__
        from .core_noavx import _append_python_callable_object_and_return_id
        from .core_noavx import _cleanup, _Scope
        from .core_noavx import _get_use_default_grad_op_desc_maker_ops
314
        from .core_noavx import _get_all_register_op_kernels
315 316
        from .core_noavx import _is_program_version_supported
        from .core_noavx import _set_eager_deletion_mode
317
        from .core_noavx import _get_eager_deletion_vars
318 319
        from .core_noavx import _set_fuse_parameter_group_size
        from .core_noavx import _set_fuse_parameter_memory_size
Z
Zeng Jinle 已提交
320 321
        from .core_noavx import _is_dygraph_debug_enabled
        from .core_noavx import _dygraph_debug_level
322
        from .core_noavx import _switch_tracer
323
        from .core_noavx import _set_paddle_lib_path
324
        from .core_noavx import _create_loaded_parameter
325
        from .core_noavx import _cuda_synchronize
326
        from .core_noavx import _is_compiled_with_heterps
327
        from .core_noavx import _promote_types_if_complex_exists
328 329
        from .core_noavx import _device_synchronize
        from .core_noavx import _get_current_stream
330
        if sys.platform != 'win32':
331 332
            from .core_noavx import _set_process_pids
            from .core_noavx import _erase_process_pids
333 334
            from .core_noavx import _set_process_signal_handler
            from .core_noavx import _throw_error_if_process_failed
335
            from .core_noavx import _convert_to_tensor_list
K
Kaipeng Deng 已提交
336
            from .core_noavx import _array_to_share_memory_tensor
337 338
            from .core_noavx import _cleanup_mmap_fds
            from .core_noavx import _remove_tensor_list_mmap_fds
T
tensor-tang 已提交
339
    except Exception as e:
340 341
        if has_noavx_core:
            sys.stderr.write(
342
                'Error: Can not import noavx core while this file exists: ' +
343
                current_path + os.sep + 'core_noavx.' + core_suffix + '\n')
344 345
        elif avx_supported():
            sys.stderr.write(
Z
Zhou Wei 已提交
346 347
                "Error: The installed PaddlePaddle is incorrect. You should reinstall it by "
                "'python -m pip install --force-reinstall paddlepaddle-gpu[==version]'\n"
348
            )
349 350
        else:
            sys.stderr.write(
Z
Zhou Wei 已提交
351 352 353
                "Error: Your machine doesn't support AVX, but the installed PaddlePaddle is avx core, "
                "you should reinstall paddlepaddle with no-avx core.\n")

354
        raise e
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373


# set paddle lib path
def set_paddle_lib_path():
    site_dirs = site.getsitepackages() if hasattr(
        site,
        'getsitepackages') else [x for x in sys.path if 'site-packages' in x]
    for site_dir in site_dirs:
        lib_dir = os.path.sep.join([site_dir, 'paddle', 'libs'])
        if os.path.exists(lib_dir):
            _set_paddle_lib_path(lib_dir)
            return
    if hasattr(site, 'USER_SITE'):
        lib_dir = os.path.sep.join([site.USER_SITE, 'paddle', 'libs'])
        if os.path.exists(lib_dir):
            _set_paddle_lib_path(lib_dir)


set_paddle_lib_path()