\ K]c@`sdZddlmZmZmZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZddlmZmZmZmZmZmZmZmZddlZddlZddlmZmZddlmZm Z dd l!m"Z"m#Z#dd l$m%Z%dd l$m&Z&dd l'm(Z(m$Z$m)Z)dd lm*Z*m+Z+m,Z,ddl-m.Z/ddl0m1Z1m2Z2e3e1ddZ4ddfZ5ej6j7dZ8dZ9de:fdYZ;de:fdYZ<de#fdYZ=dZ>dZ?dZ@dZAdZBdZCd ZDeCZEd!ZFd"eGfd#YZHd$eGfd%YZIeHZJd&ZKeKZLd'eGfd(YZMd)ZNd*eGfd+YZOeOZOd,eGfd-YZPed.d/ZQd0eGfd1YZRd2ZSd3ZTd4ZUd5ZVd6ZWd7ZXd8ZYd9eGfd:YZZd;eGfd<YZ[d=eGfd>YZ\d?eGfd@YZ]dAe]fdBYZ^dCe^fdDYZ_dEe j`fdFYZadGeGfdHYZbdIebe j`fdJYZcdKeGfdLYZddMeGfdNYZedOZfdPeGfdQYZgedRdSdTdUdVdWgZhdXeGfdYYZidZZjie(jkd[6e(jld\6e(jmd]6e(jnd^6e(jod_6Zpd`eGfdaYZqdbZrdcZsddZtdeZudfZvdgZwdhZxeydiZzdjZ{dkZ|dlZ}dmZ~dnZdoZdpZdqZddrZddsZddtZdduZdvZdwZejdxZdS(ys CUDA driver bridge implementation NOTE: The new driver implementation uses a *_PendingDeallocs* that help prevents a crashing the system (particularly OSX) when the CUDA context is corrupted at resource deallocation. The old approach ties resource management directly into the object destructor; thus, at corruption of the CUDA context, subsequent deallocation could further corrupt the CUDA context and causes the system to freeze in some cases. i(tabsolute_importtprint_functiontdivisionN(tproduct(tc_inttbyreftc_size_ttc_chartc_char_pt addressoftc_void_ptc_float(t namedtupletdeque(tutilstmviewbufi(tCudaSupportErrortCudaDriverError(tAPI_PROTOTYPES(tcu_occupancy_b2d_size(tenumstdrvapit_extras(tconfigt serializeterrors(tlongint(tget_numba_envvartget_numbapro_envvartVERBOSE_CU_JIT_LOGitlinuxcC`stjt}tj|sttjj}t t|d}t |t s`tj }n|j|tjrtjtj}d}|jtjd||j|q|jtjn|S(Ns;== CUDA [%(relativeCreated)d] %(levelname)5s -- %(message)stfmt(tloggingt getLoggert__name__Rtlogger_hasHandlerststrRtCUDA_LOG_LEVELtuppertgetattrtNonet isinstancetinttCRITICALtsetLevelt StreamHandlertsyststderrt setFormattert Formattert addHandlert NullHandler(tloggertlvlthandlerR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt _make_logger.s   tDeadMemoryErrorcB`seZRS((R"t __module__(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR8Fst LinkerErrorcB`seZRS((R"R9(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR:Jst CudaAPIErrorcB`seZdZdZRS(cC`s/||_||_tt|j||dS(N(tcodetmsgtsuperR;t__init__(tselfR<R=((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?Os  cC`sd|j|jfS(Ns[%s] %s(R<R=(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt__str__Ts(R"R9R?RA(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR;Ns c C`std}|dkr"tntjdkrOtj}dg}dg}nNtjdkr|tj}dg}dg}n!tj}d d g}d d g}|dk rytj j |}Wn!t k rt d |nXtj j |st d|n|g}n;|gt ||D]!\}}tj j||^q'}g}g}x_|D]W} y|| } Wn:tk r} |jtj j |  |j| qbX| SqbWt|rtn#djd|D} t| dS(Nt CUDA_DRIVERt0twin32s\windows\system32s nvcuda.dlltdarwins/usr/local/cuda/libs libcuda.dylibs/usr/libs /usr/lib64s libcuda.sos libcuda.so.1s(NUMBA_CUDA_DRIVER %s is not a valid pathsoNUMBA_CUDA_DRIVER %s is not a valid file path. Note it must be a filepath of the .so/.dll/.dylib or the drivers cs`s|]}t|VqdS(N(R$(t.0te((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pys s(Rt_raise_driver_not_foundR.tplatformtctypestWinDLLtCDLLR(tostpathtabspatht ValueErrortisfileRtjointOSErrortappendtallt_raise_driver_error( tenvpathtdlloadertdldirtdlnamest candidatestxtytpath_not_existtdriver_load_errorRNtdllRGterrmsg((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt find_driverXsN                5   s CUDA driver library cannot be found. If you are sure that a CUDA driver is installed, try setting environment variable NUMBA_CUDA_DRIVER with the file path of the CUDA driver shared library. sM Possible CUDA driver libraries are found but error occurred during load: %s cC`sttdS(N(RtDRIVER_NOT_FOUND_MSG(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRHscC`stt|dS(N(RtDRIVER_LOAD_ERROR_MSG(RG((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRVscC`sXd}tj}x?ttD]1}|j|rtt|}|||s !icC`sG|jj|}|dkr:t|}||j|(RRk(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt__repr__scC`smyt|}Wntk r-t|nXt}tjt|||jt|||j |j S(sRead attributes lazily ( tDEVICE_ATTRIBUTESRRRRtcuDeviceGetAttributeRRRR(R@tattrR<R((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs  cC`s t|jS(N(thashR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt__hash__scC`s#t|tr|j|jkStS(N(R)RRRv(R@tother((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt__eq__scC`s ||k S(N((R@R((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt__ne__scC`sj|jdk r|jSt|tj}tjt||jt t j ||}||_|S(so Returns the primary context for the device. Note: it is not pushed to the CPU thread. N( RR(tmet_requirement_for_deviceRRRtcuDevicePrimaryCtxRetainRRtContextRR(R@Rtctx((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytget_primary_contexts   cC`stj|jd|_dS(s6 Release reference to primary context N(RtcuDevicePrimaryCtxReleaseRR(R(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytrelease_primary_contextscC`sEz-|jdk r"|jjn|jWdtj|jXdS(N(RR(RR RtcuDevicePrimaryCtxResetR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs (R"R9Rt classmethodRR?RRRRRRRRR R R(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs         cC`s,|jtkr(td|tfndS(Ns%s has compute capability < %s(RtMIN_REQUIRED_CCR(tdevice((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR'st _SizeNotSetcB`s eZdZdZdZRS(sC Dummy object for _PendingDeallocs when *size* is not set. cC`sdS(Nt?((R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRA1scC`sdS(Ni((R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt__int__4s(R"R9RRAR(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR-s t_PendingDeallocscB`seeZdZdZedZedZdZe j dZ edZ dZ RS(sd Pending deallocations of a context (or device since we are using the primary context). cC`s+t|_d|_d|_||_dS(Ni(R t_const_disable_countt_sizet_memory_capacity(R@tcapacity((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR??s   cC`st|jtjS(N(R*RRtCUDA_DEALLOCS_RATIO(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt_max_pending_bytesEscC`stjd|j||jj|||f|jt|7_t|jtj ksn|j|j kr{|j ndS(s_ Add a pending deallocation. The *dtor* arg is the destructor function that takes an argument, *handle*. It is used as ``dtor(handle)``. The *size* arg is the byte size of the resource added. It is an optional argument. Some resources (e.g. CUModule) has an unknown memory footprint on the device. s add pending dealloc: %s %s bytesN( R~RR"RRTRR*RRtCUDA_DEALLOCS_COUNTRtclear(R@tdtorthandletsize((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytadd_itemIs cC`sa|js]xE|jrP|jj\}}}tjd|j|||q Wd|_ndS(sh Flush any pending deallocations unless it is disabled. Do nothing if disabled. sdealloc: %s %s bytesiN(t is_disabledRtpopleftR~RR"R(R@RRR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRYs   cc`sD|jd7_z dVWd|jd8_|jdks?tXdS(ss Context manager to temporarily disable flushing pending deallocation. This can be nested. iNi(RR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytdisablees  cC`s |jdkS(Ni(R(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR!rscC`s t|jS(s: Returns number of pending deallocations. (RR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt__len__vs(R"R9RR?RRRR Rt contextlibtcontextmanagerR#R!R$(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR:s    t _MemoryInfos free,totalRcB`seZdZdZdZdZddZddZdZ dZ dZ d Z d Z eeed Zed Zd ZdZdZddZdZdZdZdZdZedZdZdZdZdZRS(ss This object wraps a CUDA Context resource. Contexts should not be constructed directly by user code. cC`sF||_||_tj|_d|_tj|_i|_dS(N( RRRRft allocationsR(t deallocationstmodulestextras(R@RR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?s    cC`sMtjd|jj|jj|jj|jrI|jjndS(s? Clean up all owned resources in this context. sreset context of device %sN(R~RRRR(RR*R)(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs    cC`sGt}t}tjt|t|td|jd|jS(s>Returns (free, total) memory in bytes in the context. tfreettotal(RRt cuMemGetInfoRR'R(R@R,R-((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytget_memory_infos  cC`sZt}|s1tjt||j||n"tjt||j||||jS(sReturn occupancy of a function. :param func: kernel for which occupancy is calculated :param blocksize: block size the kernel is intended to be launched with :param memsize: per-block dynamic shared memory usage intended, in bytes(RRt+cuOccupancyMaxActiveBlocksPerMultiprocessorRRt4cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlagsR(R@tfunct blocksizetmemsizetflagstretval((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt$get_active_blocks_per_multiprocessors  ""c C`st}t}t|}|sRtjt|t||j|||n.tjt|t||j|||||j|jfS(sSuggest a launch configuration with reasonable occupancy. :param func: kernel for which occupancy is calculated :param b2d_func: function that calculates how much per-block dynamic shared memory 'func' uses based on the block size. :param memsize: per-block dynamic shared memory usage intended, in bytes :param blocksizelimit: maximum block size the kernel is designed to handle(RRRt cuOccupancyMaxPotentialBlockSizeRRt)cuOccupancyMaxPotentialBlockSizeWithFlagsR( R@R2tb2d_funcR4tblocksizelimitR5tgridsizeR3tb2d_cb((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytget_max_potential_block_sizes      cC`s.|jdkr*t|jj|_ndS(sWInitialize the context for use. It's safe to be called multiple times. N(R)R(RR/R-(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytprepare_for_usescC`stj|j|jdS(s@ Pushes this context on the current CPU Thread. N(RtcuCtxPushCurrentRR?(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytpushscC`s+tj}|j|jjks'tdS(s Pops this context off the current CPU thread. Note that this context must be at the top of the context stack, otherwise an error will occur. N(RRRRR(R@R((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytpops cC`sQy |Wn?tk rL}|jtjkrF|jj|qMnXdS(s Attempt allocation by calling *allocator*. If a out-of-memory error is raised, the pending deallocations are flushed and the allocation is retried. If it fails in the second attempt, the error is reraised. N(R;R<RtCUDA_ERROR_OUT_OF_MEMORYR)R(R@t allocatorRG((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt_attempt_allocations   c`sutjfd}|j|t|}ttj||}||jj<|j S(Nc`stjtdS(N(Rt cuMemAllocR((tbytesizetptr(s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRDs( RRREt_alloc_finalizertAutoFreePointerRRR(Rtown(R@RGRDt finalizertmem((RGRHs8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytmemallocs  c `std|r%tjOn|r;tjOn|rQtjOnfd}|r||j|n|d}t||}|rtt j ||d|}||j |j j <|jStt j ||d|}|SdS(Nic`stjtdS(N(RtcuMemHostAllocR((RGR5tpointer(s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRDsRL(R RtCU_MEMHOSTALLOC_DEVICEMAPtCU_MEMHOSTALLOC_PORTABLEtCU_MEMHOSTALLOC_WRITECOMBINEDRER(t_hostalloc_finalizert MappedMemoryRRR(RRRKt PinnedMemory( R@RGtmappedtportabletwcRDtownerRLRM((RGR5RPs8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt memhostallocs,    c`s tttfr$tn|rM|jj rMtd|jnd|ritjOnfd}|r|j |n|t ||}|rt t j ||d|}||j|jj<|jStt j ||d|}|SdS(Ns%s cannot map host memoryic`stjdS(N(RtcuMemHostRegister((R5RPR(s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRD,sRL(R)R*tlongR RtCAN_MAP_HOST_MEMORYRRtCU_MEMHOSTREGISTER_DEVICEMAPREt_pin_finalizerRURRR(RRRKRV(R@RZRPRRWRDRLRM((R5RPRs8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytmempins(   cC`s tdS(N(tNotImplementedError(R@RP((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytmemunpin@scC`ststdntj}tjtj||jj |j j }|j j |jj j }t |||j|d|S(s> Returns a *IpcHandle* from a GPU allocation. sOS does not support CUDA IPCtoffset(t SUPPORTS_IPCRSRRRtcuIpcGetMemHandleRJRRZRRRRt IpcHandleR(R@tmemoryt ipchandlet source_infoRd((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytget_ipc_handleCs   cC`sMtj}d}tjt|||tdtj|d|d|S(NitcontextRPR(RRRRRt MemoryPointerRR(R@RRtdptrR5((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytopen_ipc_handleSs  icC`s,|dkstdtj||dS(sLEnable peer access between the current context and the peer context is$*flags* is reserved and MUST be zeroN(RRtcuCtxEnablePeerAccess(R@t peer_contextR5((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytenable_peer_access\scC`s2t}tjt||jj|t|S(ssReturns a bool indicating whether the peer access between the current and peer device is possible. (RRtcuDeviceCanAccessPeerRRRtbool(R@t peer_devicetcan_access_peer((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRvbs    cC`s:t|tr!|jd}nt|}|j|S(Ntutf8(R)R$tencodeRtcreate_module_image(R@tptxtimage((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytcreate_module_ptxns cC`s/t||}||j|jj(RRR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRscC`s't|tr|j|jkStSdS(N(R)RRtNotImplemented(R@R((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRscC`s|j| S(N(R(R@R((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRsN( R"R9RR?RR/R(R7R>R?RARBRERNRvR[RaRcRkRoRrRvR|RyRRR|RRRRR(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs6        #          c C`sattdd}t|}t|}it|tj6t|tj6t|tj6t|tj 6tt tj 6}t j t||j}tt||j}t j}y)tjt||t|||Wn;tk r2} d|jjd} t| j| nX|j} ttj||| t||S(s! image must be a pointer t CUDA_LOG_SIZEiscuModuleLoadDataEx error: %sRw(R*RRR RtCU_JIT_INFO_LOG_BUFFERR t!CU_JIT_INFO_LOG_BUFFER_SIZE_BYTEStCU_JIT_ERROR_LOG_BUFFERt"CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTEStVERBOSE_JIT_LOGtCU_JIT_LOG_VERBOSERt cu_jit_optionRtkeysRt cu_moduleRtcuModuleLoadDataExRR;RtdecodeR<tModuleRRt_module_finalizer( RlR{tlogsztjitinfot jiterrorstoptionst option_keyst option_valsRRGR=tinfo_log((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR}s*    c`s.|j|jfd}|S(Nc`s-rj=njtjdS(N(RR Rt cuMemFree((R(R)RR(s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytcores (R(R)(RlRRR((R(R)RRs8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRIs  c`s@|j|js!tnfd}|S(s[ Finalize page-locked host memory allocated by `context.memhostalloc`. This memory is managed by CUDA, and finalization entails deallocation. The issues noted in `_pin_finalizer` are not relevant in this case, and the finalization is placed in the `context.deallocations` queue along with finalization of device objects. c`s3rrj=njtjdS(N(RR Rt cuMemFreeHost((R(R)RRWR(s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs  (R(R)R(RlRRRWR((R(R)RRWRs8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRTs   c`s"|jfd}|S(sB Finalize temporary page-locking of host memory by `context.mempin`. This applies to memory not otherwise managed by CUDA. Page-locking can be requested multiple times on the same memory, and must therefore be lifted as soon as finalization is requested, otherwise subsequent calls to `mempin` may fail with `CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED`, leading to unexpected behavior for the context managers `cuda.{pinned,mapped}`. This function therefore carries out finalization immediately, bypassing the `context.deallocations` queue. c`s*rrj=ntjdS(N(RRtcuMemHostUnregister((R(RRW(s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs  (R((RlRRWR((R(RRWs8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR`s c`sfd}|S(Nc`sjtjdS(N(R RtcuEventDestroy((tdeallocsR(s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs((RRR((RRs8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRsc`sfd}|S(Nc`sjtjdS(N(R RtcuStreamDestroy((RR(s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs((RRR((RRs8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRsc`s+|j|jfd}|S(Nc`s/tjfd}j|dS(Nc`s/s|jksttj|dS(N(RRRtcuModuleUnload(R(R*t shutting_down(s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt module_unload s(RRR (R(tdeallocRR*(Rs8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR s (R)R*(RlRR((RRR*s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs   t _CudaIpcImplcB`s)eZdZdZdZdZRS(sjImplementation of GPU IPC using CUDA driver API. This requires the devices to be peer accessible. cC`s=|j|_|j|_|j|_|j|_d|_dS(N(tbaseRRRdR(t _opened_mem(R@tparent((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?s     cC`sz|jdk rtdn|jdk r<tdn|j|j|j|j}||_|jj |jS(sT Import the IPC memory and returns a raw CUDA memory pointer object s'opening IpcHandle from original processsIpcHandle is already openedN( RR(RPRRoRRdRRKtview(R@RlRM((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytopen$s cC`s>|jdkrtdntj|jjd|_dS(NsIpcHandle not opened(RR(RPRtcuIpcCloseMemHandleR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytclose5s(R"R9RR?RR(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs  t_StagedIpcImplcB`s)eZdZdZdZdZRS(sImplementation of GPU IPC using custom staging logic to workaround CUDA IPC limitation on peer accessibility between devices. cC`s:||_|j|_|j|_|j|_||_dS(N(RRRRRj(R@RRj((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?@s     cC`sddlm}tj|j}td|j}|j|j|j |j j }WdQX|j |j }t|||j |j|j|jWdQX|jS(Ni(tcudaR(tnumbaRRRRjRRtgpusRRRut get_contextRNRtdevice_to_deviceRRK(R@RlRtsrcdevtimplt source_ptrtnewmem((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRGscC`sdS(N((R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR]s(R"R9RR?RR(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR<s  RgcB`sweZdZd ddZdZdZdZdZdZ d dZ d Z d Z e d ZRS( s Internal IPC handle. Serialization of the CUDA IPC handle object is implemented here. The *base* attribute is a reference to the original allocation to keep it alive. The *handle* is a ctypes object of the CUDA IPC handle. The *size* is the allocation size. icC`s:||_||_||_||_d|_||_dS(N(RRRRjR(t_implRd(R@RRRRjRd((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?ls      cC`s"|jdkrtdndS(Ns#IPC handle doesn't have source info(RjR(R(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt_sentry_source_infotscC`sH|j|j|jjkr&tStj|j}|j|jS(sdReturns a bool indicating whether the active context can peer access the IPC handle ( RRjRRR|RRRvR(R@Rlt source_device((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRvxs  cC`sM|j|jdk r(tdnt||j|_|jj|S(sCOpen the IPC by allowing staging on the host memory first. sIpcHandle is already openedN(RRR(RPRRjR(R@Rl((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt open_stageds  cC`s=|jdk rtdnt||_|jj|S(sT Import the IPC memory and returns a raw CUDA memory pointer object sIpcHandle is already openedN(RR(RPRR(R@Rl((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt open_directscC`s=|jdks|j|r*|j}n |j}||S(sOpen the IPC handle and import the memory for usage in the given context. Returns a raw CUDA memory pointer object. This is enhanced over CUDA IPC that it will work regardless of whether the source device is peer-accessible by the destination device. If the devices are peer-accessible, it uses .open_direct(). If the devices are not peer-accessible, it uses .open_staged(). N(RjR(RvRR(R@Rltfn((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs   c C`sYddlm}|dkr(|j}n|j|}|jd|d|d|d|S(sC Simliar to `.open()` but returns an device array. i(t devicearraytshapetstridestdtypetgpu_dataN(tRR(titemsizeRt DeviceNDArray(R@RlRRRRRn((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt open_arrays   cC`s8|jdkrtdn|jjd|_dS(NsIpcHandle not opened(RR(RPR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs cC`s=t|j}|j||j|j|jf}tj|fS(N(ttupleRt __class__RRjRdRt_rebuild_reduction(R@tpreprocessed_handleR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt __reduce__s c C`s4tj|}|ddd|d|d|d|S(NRRRRjRd(RRR((Rst handle_aryRRjRdR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt_rebuildsN(R"R9RR(R?RRvRRRRRRR R(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRgbs      RmcB`sneZdZeZd d dZedZdZ dZ d ddZ d dZ edZ RS( soA memory pointer that owns the buffer with an optional finalizer. When an instance is deleted, the finalizer will be called regardless of the `.refct`. An instance is created with `.refct=1`. The buffer lifetime is tied to the MemoryPointer instance's lifetime. The finalizer is invoked only if the MemoryPointer instance's lifetime ends. cC`sy||_||_||_||_|dk |_d|_|j|_||_|dk rut j |||_ ndS(Ni( Rltdevice_pointerRt_cuda_memsize_R(t is_managedtrefctRt_ownerRtfinalizet _finalizer(R@RlRPRRLRZ((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?s        cC`s|jdkr|S|jS(N(RR((R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRZscC`sttj|S(N(t OwnedPointerRR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRKscC`sH|jrD|jjs$tdn|j|jj sDtndS(s8 Forces the device memory to the trash. sFreeing dead memoryN(RRtaliveRR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR,s    icC`sZ|dkr|jn|}|r@tj|j|||jntj|j||dS(N(R(RRtcuMemsetD8AsyncRRt cuMemsetD8(R@tbyteRtstream((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytmemsets  cC`s|dkr|j|}n ||}|jjdkr\|dkrStdn|}nX|jj|}|dkrtdntj|}t|j||d|j }t |j tt frt t j |j |S|SdS(Nis non-empty slice into empty slicessize cannot be negativeRZ(R(RRRRRRRmRlRZR)RRR(R@tstarttstopRRRRP((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs     cC`s|jS(N(R(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytdevice_ctypes_pointersN(R"R9RR|t__cuda_memory__R(R?RRZRKR,RRR(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRms     RJcB`seZdZdZRS(sModifies the ownership semantic of the MemoryPointer so that the instance lifetime is directly tied to the number of references. When `.refct` reaches zero, the finalizer is invoked. cO`s,tt|j|||jd8_dS(Ni(R>RJR?R(R@Rtkwargs((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?$s(R"R9RR?(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRJsRUcB`s#eZeZddZdZRS(cC`s||_||_tj}tjt||d||_tt |j |||d||j|_ |j |_ |jj|_dS(NiRL(townedt host_pointerRRRtcuMemHostGetDevicePointerRRR>RUR?RRt_buflen_Rt_bufptr_(R@RlRZt hostpointerRRLtdevptr((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?.s      cC`sttj|S(N(tMappedOwnedPointerRR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRK=sN(R"R9R|RR(R?RK(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRU+s RVcB`seZddZdZRS(cC`s}||_||_||_||_|dk |_|j|_|j|_|jj|_ |dk ryt j ||ndS(N( RlRRRR(RRRRRRR(R@RlRZRPRRL((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?Bs       cC`s|S(N((R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRKQsN(R"R9R(R?RK(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRVAs RcB`seZddZdZRS(c`s{||_|dkr$|j|_n|j s4t||_|jfd}|jjd7_tj||dS(Nc`s\yDjd8_jdks'tjdkrCjnWntk rWnXdS(Nii(RRR,tReferenceError((RM(s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytderefas i(t_memR(t_viewRRRRR(R@tmemptrRR((RMs8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?Vs     cC`st|j|S(s$Proxy MemoryPointer methods (R'R(R@R((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRnsN(R"R9R(R?R(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRUs RcB`seZRS((R"R9(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRtsRcB`s>eZdZdZdZdZejdZRS(cC`s5||_||_|dk r1tj||ndS(N(RlRR(RR(R@RlRRL((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?ys   cC`s |jjS(N(RR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRscC`sd|jj|jfS(Ns(RRRl(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRscC`stj|jdS(sy Wait for all commands in this stream to execute. This will commit any pending memory transfers. N(RtcuStreamSynchronizeR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRscc`s|V|jdS(s A context manager that waits for all commands in this stream to execute and commits any pending memory transfers upon exiting the context. N(R(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytauto_synchronizes( R"R9R?RRRR%R&R(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRxs     RcB`sGeZddZdZddZdZddZdZRS(cC`s5||_||_|dk r1tj||ndS(N(RlRR(RR(R@RlRRL((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?s   cC`sKytj|jWn,tk rB}|jtjkr<tSnXtSdS(sy Returns True if all work before the most recent record has completed; otherwise, returns False. N( Rt cuEventQueryRR;R<RtCUDA_ERROR_NOT_READYRvR|(R@RG((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytquerysicC`s,|r|jnd}tj|j|dS(s Set the record point of the event to the current point in the given stream. The event will be considered to have occurred when all work that was queued in the stream at the time of the call to ``record()`` has been completed. iN(RRt cuEventRecord(R@Rthstream((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytrecords cC`stj|jdS(sN Synchronize the host thread for the completion of the event. N(RtcuEventSynchronizeR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRscC`s5|r|jnd}d}tj||j|dS(sZ All future works submitted to stream will wait util the event completes. iN(RRtcuStreamWaitEvent(R@RRR5((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytwaitscC`s t||S(N(tevent_elapsed_time(R@tevtend((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt elapsed_timesN( R"R9R(R?RRRRR(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs     cC`s/t}tjt||j|j|jS(sF Compute the elapsed time between two events in milliseconds. (R RtcuEventElapsedTimeRRR(tevtstartRtmsec((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs RcB`s/eZddZdZdZdZRS(cC`sC||_||_||_|dk r?tj|||_ndS(N(RlRRR(RRR(R@RlRRRL((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?s     cC`s|jj|dS(N(RlR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytunloadscC`sJtj}tjt||j|jdttj |||S(NRw( Rt cu_functionRtcuModuleGetFunctionRRRxtFunctionRR(R@RkR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt get_functions cC`sbtj}tj}tjt|t||j|jdt|j |||j fS(NRw( RRRRtcuModuleGetGlobalRRRxRmRlR(R@RkRHR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytget_global_symbols   N(R"R9R(R?RR R(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs   tFuncAttrtregstsharedRtconstt maxthreadsR cB`s}eZd Zd ZdZdZdZdZeeedZ dddZ dZ e dZ dZd ZRS( iicC`s.||_||_||_|j|_dS(N(R~RRkt_read_func_attr_alltattrs(R@R~RRk((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR?s   cC`s d|jS(Ns(Rk(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRscC`sh|p|o|}|r$tj}n-|r6tj}n|rHtj}n tj}tj|j|dS(N(RtCU_FUNC_CACHE_PREFER_EQUALtCU_FUNC_CACHE_PREFER_L1tCU_FUNC_CACHE_PREFER_SHAREDtCU_FUNC_CACHE_PREFER_NONERtcuFuncSetCacheConfigR(R@t prefer_equalt prefer_cachet prefer_sharedtflag((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt cache_configs    cC`sx t|dkr"|d7}qWx t|dkrE|d7}q&Wtj|}||_||_||_|r||_n d|_|S(Niii(i(i(Rtcopytgriddimtblockdimt sharedmemR(R@R!R"R#Rtinst((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt configure s     cG`sG|jr|jj}nd}t|j|j|j|j||dS(sS *args -- Must be either ctype objects of DevicePointer instances. N(RRR(t launch_kernelR!R"R#(R@Rt streamhandle((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt__call__s  cC`s |jjjS(N(R~RlR(R@((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR)scC`s,t}tjt|||j|jS(s, Read CUfunction attributes (RRtcuFuncGetAttributeRRR(R@tattridR6((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt_read_func_attr-s c C`s|jtj}|jtj}|jtj}|jtj}|jtj}td|d|d|d|d|S(NRRRRR(R+RtCU_FUNC_ATTRIBUTE_NUM_REGSt"CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTESt"CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTESt#CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTESt'CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCKR(R@tnregstcmemtlmemtsmemtmaxtpb((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR5s (iii(iii(R"R9R!R"RR#R?RRvRR%R(RRR+R(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR s     c C`s|\}}}|\} } } g} xI|D]A} t| rY| jtt| q+| jt| q+Wtt| | }tj||||| | | |||d dS(N( tis_device_memoryRTR RR RRtcuLaunchKernelR((t cufunc_handleR!R"R#RRtgxtgytgztbxtbytbzt param_valstargtparams((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR&@s     toRztatcubintfatbintLinkercB`sYeZddZedZedZddZdZdZdZ RS( ic C`szttdd}t|}t|}it|tj6t|tj6t|tj6t|tj 6tdtj 6}|rt||tj c C`st|}t|jd}|j||g7_y2tj|jtj|t||dddWn,t k r}t d||j fnXdS(NRwis%s %s( RRxRNRt cuLinkAddDataRRtCU_JIT_INPUT_PTXRR(R;R:RT(R@RzRktptxbuftnamebufRG((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytadd_ptxs  cC`s{t|jd}|jj|y#tj|j||dddWn,tk rv}t d||j fnXdS(NRwis%s %s( RRxRNRTRt cuLinkAddFileRR(R;R:RT(R@RNtkindtpathbufRG((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytadd_files #cC`s4|jddd}t|}|j||dS(Nt.i(trsplittFILE_EXTENSION_MAPR](R@RNtextR[((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytadd_file_guess_exts cC`std}td}y&tj|jt|t|Wn,tk rl}td||jfnX|j }|dkst d|j 2||fS(s Returns (cubin, size) cubin is a pointer to a internal buffer of cubin owned by the linker; thus, it should be loaded before the linker is destroyed. is%s %ss"linker returned a zero sized cubin( R RRtcuLinkCompleteRRR;R:RTRRRN(R@RDRRG((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytcompletes  & ( R"R9R?RRRTRYR]RbRd(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRF_s ! cC`s5tjt||t|}tj|ddS(s*Query attribute on the device pointer s!Failed to query pointer attributeN(RtcuPointerGetAttributeRRt check_error(tdevmemRtodataR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt_device_pointer_attrscC`sXtd}t|tj|idtj6dtj6dtj6dtj6}||jS(sAQuery the device pointer type: host, device, array, unified? ithostRtarraytunified( RRiRt CU_POINTER_ATTRIBUTE_MEMORY_TYPEtCU_MEMORYTYPE_HOSTtCU_MEMORYTYPE_DEVICEtCU_MEMORYTYPE_ARRAYtCU_MEMORYTYPE_UNIFIEDR(RgtptrtypeRj((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytdevice_pointer_types      cC`s2td}tj}tjt||||S(sZQuery the device pointer usable in the current context from an arbitrary pointer. i(R Rt#CU_POINTER_ATTRIBUTE_DEVICE_POINTERRReR(RHRR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytget_devptr_for_active_ctxs  cC`satj}t}t|}tjt|t|||j|j}}|||fS(sFind the extents (half open begin and end pointer) of the underlying device memory allocation. NOTE: it always returns the extents of the allocation but the extents of the device memory view that can be a subsection of the entire allocation. (RRRRRtcuMemGetAddressRangeRR(RgtstnR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytdevice_extentss    cC`skt|dd}|dkrFt|\}}||}||_n|dksgtdj||S(sCheck the memory size of the device memory. The result is cached in the device memory object. It may query the driver for the memory size of the device memory allocation. Ris{} length arrayN(R'R(RyRRR(RgtszRwRG((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytdevice_memory_sizes   !cC`s+t|dd}|dk o*|jdkS(s?Returns True if the obj.dtype is datetime64 or timedelta64 RtMmN(R'R(tchar(RtR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt_is_datetime_dtypescC`s%t|r!|jtj}n|S(s^Workaround for numpy#4983: buffer protocol doesn't support datetime64 or timedelta64. (R~Rtnptint64(Rt((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt_workaround_for_datetimes cC`set|ttfr|St}|sFt|tjp@t|}nt|}tj |||S(sGet host pointer from an obj. If `readonly` is False, the buffer must be writable. NOTE: The underlying data pointer from the host data buffer is used and it should not be changed until the operation which can be asynchronous completes. ( R)R*R]RvRtvoidR~RRtmemoryview_get_buffer(Rttreadonlyt forcewritable((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRs ! cC`st|}tj|S(sHReturns (start, end) the start and end pointer of the array (half open).(RRtmemoryview_get_extents(Rt((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pythost_memory_extentss cC`sVt|t|ks$tdt|}tj||||\}}||S(s_Get the byte size of a contiguous memory buffer given the shape, strides and itemsize. s# dim mismatch(RRRtmemoryview_get_extents_info(RRRtndimRwRG((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytmemory_size_from_infos$ cC`s2t|\}}||ks*td||S(sGet the size of the memorysmemory extend of negative size(RR(RtRwRG((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pythost_memory_size)scC`s t|jS(s$Get the device pointer as an integer(RR(Rt((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR0scC`s'|dkrtdSt||jS(s,Get the ctypes object for the device pointeriN(R(R trequire_device_memoryR(Rt((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR5s   cC`st|dtS(shAll CUDA memory object is recognized as an instance with the attribute "__cuda_memory__" defined and its value evaluated to True. All CUDA memory object should also define an attribute named "device_pointer" which value is an int(or long) object carrying the pointer value of the device memory address. This is not tested in this method. R(R'Rv(Rt((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR6=scC`st|stdndS(s9A sentry for methods that accept CUDA memory object. sNot a CUDA memory object.N(R6t Exception(Rt((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyRHs cG`s#t|dg}|j|dS(sAdd dependencies to the device memory. Mainly used for creating structures that points to other device memory, so that the referees are not GC and released. t _depends_N(R'textend(Rgtobjstdepset((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytdevice_memory_dependsOscC`sog}|r=t|ts!ttj}|j|jn tj}|t|t |dt ||dS(s NOTE: The underlying data pointer from the host data buffer is used and it should not be changed until the operation which can be asynchronous completes. RN( R)RRRtcuMemcpyHtoDAsyncRTRt cuMemcpyHtoDRRR|(tdsttsrcRRtvarargsR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pythost_to_deviceYs  cC`sig}|r=t|ts!ttj}|j|jn tj}|t|t |||dS(s NOTE: The underlying data pointer from the host data buffer is used and it should not be changed until the operation which can be asynchronous completes. N( R)RRRtcuMemcpyDtoHAsyncRTRt cuMemcpyDtoHRR(RRRRRR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pytdevice_to_hostks  cC`sig}|r=t|ts!ttj}|j|jn tj}|t|t|||dS(s NOTE: The underlying data pointer from the host data buffer is used and it should not be changed until the operation which can be asynchronous completes. N( R)RRRtcuMemcpyDtoDAsyncRTRt cuMemcpyDtoDR(RRRRRR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyR}s  cC`scg}|r=t|ts!ttj}|j|jn tj}|t||||dS(sMemset on the device. If stream is not zero, asynchronous mode is used. dst: device memory val: byte value to be written size: number of byte to be written stream: a CUDA stream N( R)RRRRRTRRR(RtvalRRRR((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt device_memsets   cC`stjdS(s; Enable profile collection in the current context. N(RtcuProfilerStart(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt profile_startscC`stjdS(s< Disable profile collection in the current context. N(RtcuProfilerStop(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt profile_stopscc`stdVtdS(s] Context manager that enables profiling on entry and disables profiling on exit. N(RR(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt profilings(Rt __future__RRRR.RMRJRRR RR Rt itertoolsRRRRRRR R R R%tnumpyRt collectionsR R RRRRRRRRRRRRRRRt numba.utilsRR]tnumba.cuda.envvarsRRR*RRRIRhReR7RR8R:R;RbRcRdRHRVRlRnRRRqRoRRRRRRRRR'RR}RIRTR`RRRRRRgRmRJRUtMemAllocRVRRRRRRRR R&tCU_JIT_INPUT_OBJECTRVtCU_JIT_INPUT_LIBRARYtCU_JIT_INPUT_CUBINtCU_JIT_INPUT_FATBINARR`RFRiRsRuRyR{R~RRvRRRRRRR6RRRRRRRRR&R(((s8lib/python2.7/site-packages/numba/cuda/cudadrv/driver.pyt s         :     C    /  w  C "     $&kQ 4  P      Z