Python Context.get_device方法代码示例

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
def init_the_device_if_needed(do_it_anyway=False):
    if do_it_anyway:
        print 'import pycuda.autoinit'
        import pycuda.autoinit
        return
    try:
        Context.get_device()
    except:
        # Presumably, the line above failed because of something like that:
        # "LogicError: cuCtxGetDevice failed: not initialized"
        # -- initialize the device
        print 'import pycuda.autoinit'
        import pycuda.autoinit

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
def compile(source, nvcc="nvcc", options=None, keep=False,
        no_extern_c=False, arch=None, code=None, cache_dir=None,
        include_dirs=[], target="cubin"):

    assert target in ["cubin", "ptx", "fatbin"]

    if not no_extern_c:
        source = 'extern "C" {\n%s\n}\n' % source

    if options is None:
        options = DEFAULT_NVCC_FLAGS

    options = options[:]
    if arch is None:
        from pycuda.driver import Error
        try:
            from pycuda.driver import Context
            arch = "sm_%d%d" % Context.get_device().compute_capability()
        except Error:
            pass

    from pycuda.driver import CUDA_DEBUGGING
    if CUDA_DEBUGGING:
        cache_dir = False
        keep = True
        options.extend(["-g", "-G"])

    if cache_dir is None:
        from os.path import join
        import appdirs
        cache_dir = os.path.join(appdirs.user_cache_dir("pycuda", "pycuda"),
                "compiler-cache-v1")

        from os import makedirs
        try:
            makedirs(cache_dir)
        except OSError as e:
            from errno import EEXIST
            if e.errno != EEXIST:
                raise

    if arch is not None:
        options.extend(["-arch", arch])

    if code is not None:
        options.extend(["-code", code])

    if 'darwin' in sys.platform and sys.maxint == 9223372036854775807:
        options.append('-m64')
    elif 'win32' in sys.platform and sys.maxsize == 9223372036854775807:
        options.append('-m64')
    elif 'win32' in sys.platform and sys.maxsize == 2147483647:
        options.append('-m32')

    include_dirs = include_dirs + [_find_pycuda_include_path()]

    for i in include_dirs:
        options.append("-I"+i)

    return compile_plain(source, options, keep, nvcc, cache_dir, target)

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
def compile(source, nvcc="nvcc", options=[], keep=False,
        no_extern_c=False, arch=None, code=None, cache_dir=None,
        include_dirs=[]):

    if not no_extern_c:
        source = 'extern "C" {\n%s\n}\n' % source

    options = options[:]
    if arch is None:
        try:
            from pycuda.driver import Context
            arch = "sm_%d%d" % Context.get_device().compute_capability()
        except RuntimeError:
            pass

    from pycuda.driver import CUDA_DEBUGGING
    if CUDA_DEBUGGING:
        cache_dir = False
        keep = True
        options.extend(["-g", "-G"])

    if cache_dir is None:
        from os.path import join
        from tempfile import gettempdir
        cache_dir = join(gettempdir(), 
                "pycuda-compiler-cache-v1-%s" % _get_per_user_string())

        from os import mkdir
        try:
            mkdir(cache_dir)
        except OSError, e:
            from errno import EEXIST
            if e.errno != EEXIST:
                raise

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
def get_device(arg=None):
    """Gets the device from ID ''arg'' or given chainer's
    :class:`~pycuda.gpuarray.GPUArray`.

    Args:
        arg: Value to specify a GPU device.

    Returns:
        Device object specified by given ``arg``.

        The rule of device selection is following.

        ==================================== =====================================
         Type of ``arg``                      Return value
        ==================================== =====================================
         ``None``                             Current device
         ``int``                              Device of ID ``arg``
         :class:`~pycuda.driver.Device`       ``arg``
         :class:`~pycuda.gpuarray.GPUArray`   Device given array was allocated on
         :class:`~numpy.ndarray`              ``None``
        ==================================== =====================================

    """
    if arg is None:
        return Context.get_device()
    elif isinstance(arg, Device):
        return arg
    elif isinstance(arg, numpy.ndarray):
        return None
    elif isinstance(arg, GPUArray):
        while not hasattr(arg.gpudata, 'device'):
            arg = arg.base
        return arg.gpudata.device
    return drv.Device(arg)

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
def mem_alloc(nbytes):
    """Allocates device memory of given size from memory pool.

    This function chooses memory pool corresponding to the current device.

    Args:
        nbytes (int): The size of memory in bytes.

    Returns:
        pycuda.tools.PooledDeviceAllocation: Allocated memory with additional
        ``device`` attribute. This attribute is used to determine on which GPU
        the memory resides.

    """
    global _pools

    device = Context.get_device()
    pool   = _pools.get(device, None)

    if pool is None:
        pool = drv.DeviceMemoryPool()
        _pools[device] = pool

    allocation = pool.allocate(nbytes)
    setattr(allocation, 'device', device)
    return allocation

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
 def _check_arch(self, arch):
     if arch is None: return
     try:
         from pycuda.driver import Context
         capability = Context.get_device().compute_capability()
         if tuple(map(int, tuple(arch.split("_")[1]))) > capability:
             from warnings import warn
             warn("trying to compile for a compute capability "
                     "higher than selected GPU")
     except:
         pass

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
def init(device=None):
    """Initializes CUDA global state.

    Chainer maintains CUDA context, CUBLAS context, random number generator and
    device memory pool for each GPU device and for each process (the main
    process or a process forked by :mod:`multiprocessing`) as global states. When
    called for the first time on the process, this function initializes these global states.

    .. warning::

       This function also initializes PyCUDA and scikits.cuda. Since these
       packages do not support forking after initialization, do not call this
       function before forking the process.

    This function also registers :func:`shutdown` to :mod:`atexit` slot.

    It also initializes random number generator. User can set fixed seed with
    ``CHAINER_SEED`` environment variable.

    Args:
        device (``int`` or :class:`~pycuda.driver.Device` or ``None``): Device
            ID to initialize on.

    """
    global _contexts, _cublas_handles, _generators, _pid, _pools

    if not available:
        global _import_error
        raise RuntimeError(
            'CUDA environment is not correctly set up. ' +
            'The original import error said: ' + str(_import_error))

    pid = os.getpid()
    if _pid == pid:  # already initialized
        return

    drv.init()

    if device is None:  # use default device
        context = cutools.make_default_context()
        device  = Context.get_device()
    else:
        device  = Device(device)
        context = device.make_context()
    _contexts       = {device: context}
    _generators     = {}
    _pools          = {}
    _cublas_handles = {}
    cumisc.init(mem_alloc)

    seed(os.environ.get('CHAINER_SEED'))

    _pid = pid  # mark as initialized
    atexit.register(shutdown)

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
def get_cublas_handle():
    """Gets CUBLAS handle for the current device.

    Returns:
        CUBLAS handle.

    """
    global _cublas_handles

    device = Context.get_device()
    if device in _cublas_handles:
        return _cublas_handles[device]

    handle = cublas.cublasCreate()
    _cublas_handles[device] = handle
    return handle

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
 def __init__(self, nvcc='nvcc', link_options=None, keep=False,
         no_extern_c=False, arch=None, code=None, cache_dir=None,
         include_dirs=[],  message_handler=None, log_verbose=False,
         cuda_libdir=None):
     from pycuda.driver import Context
     compute_capability = Context.get_device().compute_capability()
     if compute_capability < (3,5):
         raise Exception('Minimum compute capability for dynamic parallelism is 3.5 (found: %u.%u)!' %
             (compute_capability[0], compute_capability[1]))
     else:
         from pycuda.driver import Linker
         self.linker = Linker(message_handler, link_options, log_verbose)
     self._check_arch(arch)
     self.nvcc = nvcc
     self.keep = keep
     self.no_extern_c = no_extern_c
     self.arch = arch
     self.code = code
     self.cache_dir = cache_dir
     self.include_dirs = include_dirs
     self.cuda_libdir = cuda_libdir
     self.libdir, self.libptn = None, None
     self.module = None

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
def compile(source, nvcc="nvcc", options=None, keep=False,
        no_extern_c=False, arch=None, code=None, cache_dir=None,
        include_dirs=[]):

    if not no_extern_c:
        source = 'extern "C" {\n%s\n}\n' % source

    if options is None:
        options = DEFAULT_NVCC_FLAGS

    options = options[:]
    if arch is None:
        try:
            from pycuda.driver import Context
            arch = "sm_%d%d" % Context.get_device().compute_capability()
        except RuntimeError:
            pass

    from pycuda.driver import CUDA_DEBUGGING
    if CUDA_DEBUGGING:
        cache_dir = False
        keep = True
        options.extend(["-g", "-G"])

    if cache_dir is None:
        from os.path import join
        import appdirs
        cache_dir = os.path.join(appdirs.user_cache_dir("pycuda", "pycuda"),
                "compiler-cache-v1")

        from os import makedirs
        try:
            makedirs(cache_dir)
        except OSError, e:
            from errno import EEXIST
            if e.errno != EEXIST:
                raise

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
#!/usr/bin/env python
"""
Created on Wed Sep  3 11:08:37 2014

Author: Oren Freifeld
Email: [email protected]
"""

from pycuda.compiler import SourceModule
from pycuda.driver import Context


try:
    Context.get_device()
except:
    import pycuda.autoinit


class KernelThinWrapper(object):
    def __init__(self, gpu_kernel, include_dirs=[]):
        self._gpu_kernel = gpu_kernel
        self._src_module = SourceModule(gpu_kernel, include_dirs=include_dirs)

    def _get_function_from_src_module(self, func_name):
        self.__dict__["_gpu_" + func_name] = self._src_module.get_function(func_name)

    def __call__(self, *args, **kwargs):
        msg = """
        You need to customize this method in the derived class.
        
        The customized method will usually have 3 parts:

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
def has_double_support():
    from pycuda.driver import Context
    return Context.get_device().compute_capability() >= (1, 3)

# 需要导入模块: from pycuda.driver import Context [as 别名]
# 或者: from pycuda.driver.Context import get_device [as 别名]
def has_stack():
    from pycuda.driver import Context
    return Context.get_device().compute_capability() >= (2, 0)