Xc@`sldZddlmZmZmZddlmZddlZddlZddlZddl Z ddl Z ddl m Z ddl mZddl mZddlmZmZdd lmZmZdd lmZdd lmZdd lmZdd lmZddlmZmZddlmZej dZ!e"a#e"dZ$e"a%dZ&dfdYZ'dZ(dZ)dZ*dZ+dZ,dZ-dZ.dZ/dZ0dZ1dZ2d Z3d!Z4d"ej5fd#YZ6d$e7fd%YZ8d&ej9fd'YZ:d(Z;d)ej5fd*YZ<d+e7fd,YZ=dS(-s4 Defines Linkers that deal with C implementations. i(tabsolute_importtprint_functiontdivision(tcopyN(tconfig(tPY3(tizip(t string_typestreraise(tStringIOtxrange(tgraph(tlink(tutils(tcmodule(tget_lockt release_lock(t CallCaches theano.gof.cccC`stjtjd|S(s Parameters ---------- init_args If not None, the (k, v) pairs in this dictionary will be forwarded to the ModuleCache constructor as keyword arguments. t init_args(Rtget_module_cacheRt compiledir(R((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyR&s cC`s1tdkr-ttjjtjdantS(Ntpersistent_cache(t_persistent_module_cachetNoneRtostpathtjoinRR(((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pytget_persistent_module_cache6s t CodeBlockcB`seZdZdZRS(s% Represents a computation unit composed of declare, behavior, and cleanup. The constructor initializes a L{CodeBlock} with templatized declare, behavior and cleanup. The sub parameter will be used in the other arguments' templates. sub should contain a key called 'id' that maps to an identifier for this block. The identifier will be used to determine the failure code and a label to jump to. It should also contain a key called 'failure_var' that contains the name of the variable that contains the error code. Parameters ---------- declare C code that declares variables for use by the computation. behavior C code that performs the computation. cleanup C code that cleans up things allocated or incref-ed in behavior. cC`s/||_||_d||d||_dS(Ns__label_%(id)i: s double __DUMMY_%(id)i; (tdeclaretbehaviortcleanup(tselfRRRtsub((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt__init__Us   (t__name__t __module__t__doc__R"(((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyR>scC`sd|S(s Code contained in sub['fail'], usually substituted for %(fail)s. It sets information about current error, then goto the code actually handling the failure, which is defined in struct_gen(). s{ %(failure_var)s = %(id)s; if (!PyErr_Occurred()) { PyErr_SetString(PyExc_RuntimeError, "Unexpected error in an Op's C code. " "No Python exception was set."); } goto __label_%(id)i;}((R!((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt failure_codeascC`sd|S(s Code for failure in the struct init. Parameters: ---------- sub Dictionary used to template the struct. * failure_var -> must contain a variable name to use for the failure code. s{ if (!PyErr_Occurred()) { PyErr_SetString(PyExc_RuntimeError, "Unexpected error in an Op's C code. " "No Python exception was set."); } return %(id)d; }((R!((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pytfailure_code_initsscC`s^d}d}d}x=|D]5}||j7}|d|j}d|j|}qW|||S(s$ From a list of L{CodeBlock} instances, returns a string that executes them all in sequence. Eg for C{(decl1, task1, cleanup1)} and C{(decl2, task2, cleanup2)} the returned string will be of the form: decl1 decl2 { task1 { task2 cleanup2 } cleanup1 } Parameters: ---------- blocks List of CodeBlock instances such that * declarations, behavior and cleanup are in the run() method of the struct ts { %ss%s } (RRR(tblockstdecltheadttailtblock((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pytcode_gens  cC`sgd}d}d}d}x9|D]1}||j7}|d|j}||j7}qWt|} djg|D]} d| ^qm} djg|D]} d| | f^q} djg|D]} d| ^q} djg|D]} d| ^q}dj|}djg|D]} d | ^q}d |}t|}|jtd |}|S( s Generates a struct conforming to the following specifications: Parameters ---------- args All of the PyObject* type, stored in the struct they represent the storage and must be length 1 python lists. struct_builders List of L{CodeBlock} instances such that * declarations are in the struct * behavior is in the constructor * cleanup is in the destructor blocks List of CodeBlock instances such that * declarations, behavior and cleanup are in the run() method of the struct sub Dictionary used to template the struct. * failure_var -> must contain a variable name to use for the failure code. Returns ------- object In a nutshell, this returns code for a struct that represents a function with state. The state's initialization and destruction are handled by struct_builders and the actual behavior of the function is handled by blocks. R(s %ss s PyObject* %s;sthis->%s = %s;sPy_XINCREF(%s);sPy_XDECREF(this->%s);s, s PyObject* %ssk if (%(failure_var)s) { // When there is a failure, this code puts the exception // in __ERROR. PyObject* err_type = NULL; PyObject* err_msg = NULL; PyObject* err_traceback = NULL; PyErr_Fetch(&err_type, &err_msg, &err_traceback); if (!err_type) {err_type = Py_None;Py_INCREF(Py_None);} if (!err_msg) {err_msg = Py_None; Py_INCREF(Py_None);} if (!err_traceback) {err_traceback = Py_None; Py_INCREF(Py_None);} PyObject* old_err_type = PyList_GET_ITEM(__ERROR, 0); PyObject* old_err_msg = PyList_GET_ITEM(__ERROR, 1); PyObject* old_err_traceback = PyList_GET_ITEM(__ERROR, 2); PyList_SET_ITEM(__ERROR, 0, err_type); PyList_SET_ITEM(__ERROR, 1, err_msg); PyList_SET_ITEM(__ERROR, 2, err_traceback); {Py_XDECREF(old_err_type);} {Py_XDECREF(old_err_msg);} {Py_XDECREF(old_err_traceback);} } // The failure code is returned to index what code block failed. return %(failure_var)s; s} namespace { struct %(name)s { PyObject* __ERROR; %(storage_decl)s %(struct_decl)s %(name)s() { // This is only somewhat safe because we: // 1) Are not a virtual class // 2) Do not use any virtual classes in the members // 3) Deal with mostly POD and pointers // If this changes, we would have to revise this, but for // now I am tired of chasing segfaults because // initialization code had an error and some pointer has // a junk value. memset(this, 0, sizeof(*this)); } ~%(name)s(void) { cleanup(); } int init(PyObject* __ERROR, %(args_decl)s) { %(storage_incref)s %(storage_set)s %(struct_init_head)s this->__ERROR = __ERROR; return 0; } void cleanup(void) { %(struct_cleanup)s %(storage_decref)s } int run(void) { int %(failure_var)s = 0; %(behavior)s %(do_return)s } }; } (RRRR.Rtdicttupdatetlocals(targststruct_buildersR)R!t struct_decltstruct_init_headtstruct_init_tailtstruct_cleanupR-Rtargt storage_declt storage_settstorage_increftstorage_decreft args_namest args_declt do_returnt struct_code((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt struct_gens(    &,&&&  / cC`sdS(s WRITEME R(((trtnameR!((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt get_nothing@scC`stg|jD]3\}}t|ts t|jdtj^q sm|jrt|jjdtjr|j j ||t }n|j j ||t }dt }||S(s: Wrapper around c_declare that declares py_name. t check_inputs PyObject* py_%(name)s; (tanytclientst isinstanceRtgetattrtopRREtownerttypet c_declaretTruetFalseR1(RBRCR!tct_RMtpre((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt get_c_declareHs 0  cC`s$dt}||jj||S(sE Wrapper around c_init that initializes py_name to Py_None. s? py_%(name)s = Py_None; {Py_XINCREF(py_%(name)s);} (R1RLtc_init(RBRCR!RR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt get_c_init`s cC`s*tg|jD]3\}}t|ts t|jdtj^q rtg|jD]0\}}t|tsVt|jdt^qVr|j j ||t}qy"|j j ||tdt }Wqt k r}|j j ||t}qXn|j j ||t }dt }||S(sJ Wrapper around c_extract that initializes py_name from storage. REtcheck_broadcasts\ py_%(name)s = PyList_GET_ITEM(storage_%(name)s, 0); {Py_XINCREF(py_%(name)s);} (RFRGRHRRIRJRRERNRLt c_extractROt TypeErrorR1(RBRCR!RPRQRWteRR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt get_c_extractls 0-    cC`st|jjdtj}t|jjdtrN|jj|||}nPy"|jj|||dt}Wn+t k r}|jj|||}nXdt }||S(sN Wrapper around c_extract_out that initializes py_name from storage. RERVs\ py_%(name)s = PyList_GET_ITEM(storage_%(name)s, 0); {Py_XINCREF(py_%(name)s);} ( RIRKRJRRERNRLt c_extract_outRORXR1(RBRCR!RERWRYRR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pytget_c_extract_outs   cC`s$dt}|jj|||S(s9 Wrapper around c_cleanup that decrefs py_name. s$ {Py_XDECREF(py_%(name)s);} (R1RLt c_cleanup(RBRCR!tpost((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt get_c_cleanups cC`s)dtd|jj||d||S(sA Wrapper around c_sync that syncs py_name with storage. s if (!%(failure_var)s) { %(sync)s PyObject* old = PyList_GET_ITEM(storage_%(name)s, 0); {Py_XINCREF(py_%(name)s);} PyList_SET_ITEM(storage_%(name)s, 0, py_%(name)s); {Py_XDECREF(old);} } tsyncRC(R/RLtc_sync(RBRCR!((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt get_c_syncs cC`sVt|ttfrFd}x$|D]}|||||7}q"W|S||||S(s# Apply the list of policies to name.r,sub Parameters ---------- policy List of functions that map a L{Variable} to a string, or a single such function. r: L{Variable} Returns ------- object C{policy[0](r) + policy[1](r) + ...}. R((RHtlistttuple(tpolicyRBRCR!trett sub_policy((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt apply_policys  c C`sd|}||kr#|||]sN(RsR{toutputsRtt node_ordertlenRGt variablesR R/t node_paramst run_paramstNoParamsRLt params_typetAssertionErrortappendRzRctorphanstconstsRHt c_literaltdatatremoveR tMethodNotDefinedtNotImplementedErrortsett differencettemps(R RstvartnodeRyRm((R s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyRv7s<   .!    "  c% C`st|dtr|jS|j}g}g}i}g}g}g}g}d} d} x<|jD]1} td| } | |jkrd| jj| j d|| |j-||}t|t(s$t)t*|j$dWnt&j'k r;nXy>|j.||}t|t(syt)t*|j$dWnt&j'k rnXy|j/||||| }Wn$t&j'k rt0d|nXt|t(st)t*|j$dd|j$j1j2d|}y|j3||||| }Wnt&j'k rUd}nXt4j5dt*||jt6d||| |j|d| f| d7} |jt6|||i| d 6|j|d | f| d7} qWg}|gt&j7|j |j|jD]} d|| ^q7}dd} t8|||td| d | }!|!|_| |_9||_:||_;||_<||_=||_>||_?|j |j|j}"||_%||_+|j=|j?f|j@krtAd!|j=d"tBjCtA|j@d#d"tBjCtAd$|j?d"tBjCtA|j@dd"tBjC|j=|j?f|j@kst)ngt|"D]<\}#}$|"jD|$dkr|"jE|$|#kr|#^q|_F|jS(%s Generates code for a struct that does the computation of the fgraph and stores it in the struct_code field of the instance. If reuse_storage is True, outputs and temporaries will be stored in the struct so they can be reused each time a function returned by make_function is called, which means that the output of a call will be invalidated by the next. If reuse_storage is False, that problem is avoided. This method caches its computations. R@t __failureit failure_vart(t)s2All orphans to CLinker must be Constant instances.s8this shouldn't be possible, please report this exceptiontinittgetis node_<<<>>>_%iRiRjRyR(is0 didn't return a string for c_support_code_applys- didn't return a string for c_init_code_applys. didn't return a string for c_init_code_structs1 didn't return a string for c_support_code_structs1 didn't return a string for c_cleanup_code_structs%s cannot produce C codes" didn't return a string for c_codes // Op class s scompiling un-versioned Apply %stcodes storage_%ss__struct_compiled_op_%ss<<<>>>RCs init_tasks tfileistasks (GRIROR@RwRR/RRLRRR{RDRSRZR_RRHR RzRXRt c_is_simpleRUR}RbR\t ExceptionRqRt enumerateR~RRRR&R'RJtc_support_code_applyR RRRtstrtc_init_code_applytc_init_code_structtc_support_code_structtc_cleanup_code_structtc_codeRt __class__R#tc_code_cleanupt_loggertinfoRtuniqRAt struct_nameR2tr2symbolt init_blockst init_tasksR)ttaskstget_init_taskstprinttsyststderrtcounttindextdupidx(%R RwRRtsymbolRRRR)RRiRmR!RetbuilderR-tnode_numRRyt params_varRCRBtisymstosymst sub_structtstruct_supportt struct_initR7RJRRR2RR@tall_infotitx((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyR.os0  !                              9              '9cC`sg}xrg|jD]}|j^qg|jD]}|j^q/D]4}y|j|jWqCtjk rvqCXqCW|S(s Returns a list of support code strings that are needed by one or more Variables or Ops. The support code from Variables is added before the support code from Ops.This might contain duplicates. (RRLR~RJRtc_support_codeR R(R RftyR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt support_code~s$cC`sdg}|ddddg7}|j}xg|jD]}|j^q8g|jD]}|j^qTD]\}y?y||j|7}Wn!tk r||j7}nXWqhtjk rqhXqhWtj |}||j 7}xg|jD]}|j^qg|jD]}|j^qD]}ymy|j |}Wntk r_|j }nXx3|D]+}y|j |Wqgt k rqgXqgWWq$tjk rq$Xq$W|S(s Returns a list of compile args that are needed by one or more Variables or Ops. This might contain duplicates. s-O3s-fno-math-errnos-Wno-unused-labels-Wno-unused-variables-Wno-write-strings(t c_compilerRRLR~RJtc_compile_argsRXR RRt compile_argstc_no_compile_argsRt ValueError(R RfRRRtno_compR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyRs@    $ $    cC`sg}|j}xg|jD]}|j^qg|jD]}|j^q;D]\}y?y||j|7}Wn!tk r||j7}nXWqOtjk rqOXqOWtj |S(s Returns a list of headers that are needed by one or more Types or Ops. The return value will not contain duplicates. ( RRRLR~RJt c_headersRXR RR(R RfRRR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pytheaderss $ cC`sg}xog|jD]}|j^qg|jD]}|j^q/D]1}y||j7}WqCtjk rsqCXqCWtj|S(s Return a list of code snippets that have to be inserted in the module initialization code. The return value will not contain duplicates. (RRLR~RJt c_init_codeR RR(R RfRR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt init_codes$cC`sd}xg|jD]}|j^qg|jD]}|j^q/D]f}t|drC|j}nqC|dkr|}qC|rC||krCtd||fqCqCW|dkrtj S|SdS(NRs1Nodes have requested specific different compilers( RRRLR~RJthasattrRRRt GCC_compiler(R RRRt x_compiler((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyRs$   cC`sg}|j}xg|jD]}|j^qg|jD]}|j^q;D]\}y?y||j|7}Wn!tk r||j7}nXWqOtjk rqOXqOWtj |S(s Returns a list of lib directories that are needed by one or more Types or Ops. The return value will not contain duplicates. ( RRRLR~RJt c_header_dirsRXR RR(R RfRRR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt header_dirss $ cC`sg}|j}xg|jD]}|j^qg|jD]}|j^q;D]\}y?y||j|7}Wn!tk r||j7}nXWqOtjk rqOXqOWtj |S(s Returns a list of libraries that are needed by one or more Types or Ops. The return value will not contain duplicates. ( RRRLR~RJt c_librariesRXR RR(R RfRRR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt librariess $ cC`sg}|j}xg|jD]}|j^qg|jD]}|j^q;D]\}y?y||j|7}Wn!tk r||j7}nXWqOtjk rqOXqOWtj |S(s Returns a list of lib directories that are needed by one or more Types or Ops. The return value will not contain duplicates. ( RRRLR~RJt c_lib_dirsRXR RR(R RfRRR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pytlib_dirs-s $ c C`srdddg}|dkr7td|jD}n|dkri}g}x+t|jD]\}}||||Yst keep_lockN( RRdR{RR}Rtcthunk_factoryRRsR t ContainerRN( R t input_storagetoutput_storaget storage_mapRt error_storagetmapRRmtthunktinputtstoragetoutput((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt __compile__Bs2       47cC`sg}g}d}x`|jD]U}||jkr7qn|j|d|f|j|d|df|d7}qWxK|jD]@}|j|d|f|j|d|df|d7}qW||fS(NiRRiR(RRRR~(R RRRitvR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyRssc C`sg|j\}}|j|||d|\}}} } t|||| } |j| _| || fS(s Compiles this linker's fgraph and returns a function to perform the computations, as well as lists of storage cells for both the inputs and outputs. Parameters ---------- input_storage: list or None List of lists of length 1. In order to use the thunk returned by __compile__, the inputs must be put in that storage. If None, storage will be allocated. output_storage: list of lists of length 1. The thunk returned by __compile__ will put the variables of the computation in these lists. If None, storage will be allocated. storage_map: dict that map variables to storages. This is used when you need to customize the storage of this thunk keep_lock: If True, we won't release the lock on the compiledir at the end of this function call. Returns: thunk, input_storage, output_storage The return values can be used as follows: f, istor, ostor = clinker.make_thunk() istor[0].data = first_input istor[1].data = second_input f() first_output = ostor[0].data R(RRt_CThunkR~tnodes( R RRRRRRtcthunkt in_storaget out_storageRtres((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt make_thunks   c C`sF|j|j|jd|jd|jd|jd|jS(s Return a complete hashable signature of the module we compiled. This function must have the property that no two programs that compute different things yield the same key. The key returned by this function is of the form (version, signature) The signature has the following form: {{{ 'CLinker.cmodule_key', compilation args, libraries, header_dirs, numpy ABI version, config md5, (op0, input_signature0, output_signature0), (op1, input_signature1, output_signature1), ... (opK, input_signatureK, output_signatureK), }}} The signature is a tuple, some elements of which are sub-tuples. The outer tuple has a brief header, containing the compilation options passed to the compiler, the libraries to link against, an md5 hash of theano.config (for all config options where "in_c_key" is True). It is followed by elements for every node in the topological ordering of `self.fgraph`. Input Signature --------------- Each input signature is a tuple with an element for each input to the corresponding Apply node. Each element identifies the type of the node input, and the nature of that input in the graph. The nature of a typical variable is encoded by integer pairs ``((a,b),c)``: ``a`` is the topological position of the input's owner (-1 for graph inputs), ``b`` is the index of the variable in the owner's output list. ``c`` is a flag indicating whether the variable is in the no_recycling set. If a variable is also a graph output, then its position in the outputs list is also bundled with this tuple (after the b). The nature of a Constant instance is defined as its signature, together with two integers: the topological position of the first Apply using that Constant instance, and the lowest index into that Apply's inputs that refers to that Constant. (These two integers are a surrogate for the id() of the Constant. The integers are important because merge-able constants have the same signature, but require separate containers in C code.) The membership in no_recycling is also included in the signature. Output Signature ---------------- The outputs of a node are entirely determined by the node's Op and the nature of the inputs, but the set of outputs that may be re-used by the computation (the elements of self.no_recycling) can affect the code that is generated. The format of each Op's output signature is a (version, no_recycle) pair, where version is incremented if codegen() changes how it handles the outputs, and no_recycle is simply a list of booleans, indicating whether each output is in the no_recycling set. Older versions of compiled modules only have the no_recycle list. RRRR(t cmodule_key_RsRwRRRR(R ((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt cmodule_keys G   c C`sAdddY} | ||} |j| ||||||S(NtFakeFunctionGraphcB`seZdZdZRS(cS`s||_||_dS(N(R{R}(R R{R}((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyR"s cS`stj|j|jS(N(R t io_toposortR{R}(R ((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyttoposorts(R#R$R"R(((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyRs ((R( R R{R}RwRRRtinsert_config_md5RRRs((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pytcmodule_key_variabless  c`s|dkrg}n|dkr*g}n|dkr?g}n|jt}tdtjDtidg} |dk rt|} t| } | j| n|dk rt|} t| } | j| n|dk r*t|} t| } | j| n| jdt j j j |rg| jd|j n|r| jdtjjn | jdtgfdg} xtD]\} t| jdr| j| jj| nx'| jD]} | j| jjqWx'| jD]}| j|jjqBW| j| jtfd t| jDd tfd | jDffd rdS| <|j| jqWxvgtjD]0\} }tt|d gs| |f^qD].\}}| j|j|d|fq/Wt| } t| } x| D]}|sd| fSqW| | fS(s Do the actual computation of cmodule_key in a static method to allow it to be reused in scalar.Composite.__eq__. cs`s'|]\}}|d|ffVqdS(iN((R|tposR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pys (ssCLinker.cmodule_keysNPY_ABI_VERSION=0x%Xsc_compiler_str=smd5:smd5: c`st|tjrt|kr|j||f}t|ddrh|dj||f}nyt|Wntk rt dwsN(tallR}(R|to((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pys wscs`s|]}|jdkVqdS(N(RKR(R|R((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pys yss what is this?(RHR RzRit signatureRRthashRRNRRKRRR{RLRGR}R(Rttopological_posti_idxtisig(t constant_idst error_on_playRstfgraph_inputs_dictRwtop_postorder(s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pytin_sigUs4      "tc_code_cache_version_applyc3`s0|]&\}}|j||fVqdS(N(RL(R|tiposR(Rtnode_pos(s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pys sic3`s|]}|kVqdS(N((R|R(Rw(s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pys siRGiN((RRtRR/RR{tsortedRdRtnptcoret multiarrayt_get_ndarray_c_versiont version_strttheanot configparsertget_config_md5RORRJRRLtc_code_cache_versionR}R0RRI(R RsRwRRRRRtfgraph_computed_settsigR2tversionRRRRRR(( RRRsRRRwRRRs-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyRsz                      !0&   4&   cC`s|j}|jS(N(tget_dynamic_moduleR(R tmod((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt get_src_codes c C`s |d kr!tjtj}n|j}|j}|j}|j}|j }t zy_t j dt ||jd|jd|d|d|jd|jd|d|}Wn1tk r}|jt |jf7_nXWd tX|S( se This compiles the source code for this linker and returns a loaded module. s LOCATION %st module_nametsrc_codetlocationt include_dirsRtlibstpreargsN(RRtdlimport_workdirRRRRRRRRRtdebugRt compile_strt code_hashRRRR2RsR( R RRRRRRtmoduleRY((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pytcompile_cmodules0            cC`sGt|ds@|jtj}|jdt|j}tjd|dtj}t rzdj d|j }ndt d|j }x(|j |jD]}|j|qW|j|j|j||j|x!|jD]}|j|qWx(|j|jD]}|j|qW||_n|jS(s Return a cmodule.DynamicModule instance full of the code for our fgraph. This method is cached on the first call so it can be called multiple times without penalty. t_modit instantiatetmethods0 static int {struct_name}_executor({struct_name} *self) {{ return self->run(); }} static void {struct_name}_destructor(PyObject *capsule) {{ {struct_name} *self = ({struct_name} *)PyCapsule_GetContext(capsule); delete self; }} Rs static int %(struct_name)s_executor(%(struct_name)s* self) { return self->run(); } static void %(struct_name)s_destructor(void* executor, void* self) { delete ((%(struct_name)s*)self); } (RR.Rt DynamicModuletinstantiate_codeRR2t ExtFunctiont METH_VARARGSRtformatRR/RRtadd_support_codeR@t add_functionRt add_includeRRt add_init_codeR#(R RRR$tstaticRtheadertinit_code_block((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyRs(        cC`sy|j}Wntk r)d}nX|dkrE|j}nNx*|jD]}|jj||ddqOWtjd|d|d|}|j |j |j } gt | D]<\} } | j | dkr| j| | kr| ^q} gt |D](\} } | t|| kr| ^q}gt |D]\} } | | krA| ^qA}|dkrg|j D]} | jg^q{}n g|j D]} || ^q}|j||||}|S(s Returns a thunk that points to an instance of a C struct that can carry on the computation of this linker's fgraph Parameters: ---------- error_storage -> list of length 3 in_storage -> list of lists of length 1, one per input out_storage -> list of lists of length 1, one per output Returns a thunk that points to an instance of a C struct that can carry on the computation of this linker's fgraph. That thunk, when executed, will fetch its inputs from in_storage, put its outputs in out_storage and if an error occurs will put the type, value and traceback of the exception in error_storage. RPtkeytlnkRiN(RtKeyErrorRR"R~RJt prepare_nodeRtmodule_from_keyR{R}RRRRRRR$(R RRRRRR2R!RtvarsRRRtorphantorphdRf((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyRs,    6"1 %  cC`sLt}|j}tdd|tdd|tdtd|tdtd|tdd|tdd|tdtd|td d jd t|Dd d|td d|tdd|tdd|trtdjtd|ntdtd|tdd||jS(NsDstatic PyObject * instantiate(PyObject * self, PyObject *argtuple) {Rs" assert(PyTuple_Check(argtuple));s- if (%(n_args)i != PyTuple_Size(argtuple)){ s{ PyErr_Format(PyExc_TypeError, "Wrong number of arguments, expected %(n_args)i, got %%i", (int)PyTuple_Size(argtuple));s return NULL;s }s6 %(struct_name)s* struct_ptr = new %(struct_name)s();s if (struct_ptr->init(t,cs`s|]}d|VqdS(sPyTuple_GET_ITEM(argtuple, %i)N((R|tn((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pys Qss ) != 0) {s delete struct_ptr;s return NULL;s PyObject* thunk = PyCapsule_New((void*)(&{struct_name}_executor), NULL, {struct_name}_destructor); if (thunk != NULL && PyCapsule_SetContext(thunk, struct_ptr) != 0) {{ PyErr_Clear(); Py_DECREF(thunk); thunk = NULL; }} s} PyObject* thunk = PyCObject_FromVoidPtrAndDesc((void*)(&%(struct_name)s_executor), struct_ptr, %(struct_name)s_destructor);s return thunk; }( R RRR1RR RR*tgetvalue(R tn_argsRR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyR'Gs&  /(R#R$R%RR"RuRvR.RRRRRRRRRORRRRRNRRRR"RRR'(((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyRrs>   8   :      0 ( O    <2RcB`s)eZdZdZdZdZRS(s A thunk with a C implementation. Parameters ---------- cthunk The CObject pointer used by run_cthunk. init_tasks WRITEME tasks WRITEME error_storage WRITEME cC`sGtdkrddlman||_||_||_||_dS(Ni(t run_cthunk(R>Rttheano.gof.cutilsRRRR(R RRRR((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyR"us     cC`s\|d8}t|j}|d|krI|j|jg|d|dS|j||SdS(sL Maps a failure code to the task that is associated to it. iiN(RRR(R R&R;((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt find_tasks  c C`st|j}|r|j|\}}}y |j}Wntk rSd}nXyR|j\}}}||jkr|jj||_n||} || _ WnCt k rt ddddt j t |jdt j nXt|| |ndS(Ns?ERROR retrieving error_storage.Was the error set in the c code?tendt R((R>RR@ttracetAttributeErrorRRRtposition_of_errort__thunk_trace__RRRRR( R tfailurettaskttasknameRiRCtexc_typet _exc_valuet exc_tracet exc_value((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyt__call__s&       (R#R$R%R"R@RN(((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyRds t OpWiseCLinkercB`sMeZdZiZededdZdddZdddddZRS(s Uses CLinker on the individual Ops that comprise an fgraph and loops over them in Python. The variable is slower than a compiled version of the whole fgraph, but saves on compilation time because small changes in the computation graph won't necessarily trigger any recompilation, only local changes in the Variables or Ops that are used. If fallback_on_perform is True, OpWiseCLinker will use an op's perform method if no C version can be generated. no_recycling can contain a list of Variables that belong to the fgraph. If a Variable is in no_recycling, CLinker will clear the output storage associated to it prior to computation (to avoid reusing it). Notes ----- This is in a sense the 'default' linker for Theano. The overhead of using the OpWiseCLinker as compared with the CLinker is only noticeable for graphs of very small tensors (such as 20 elements or less). cC`sR|dkrtj}nd|_||_||_||_|rN||_ndS(N(RRtallow_gcRstfallback_on_performt nice_errorsRt(R RQRPRRRt((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyR"s      c C`s|dkrg}n|jdk rs|j|k rst|d|jd|jd|jd|jj|||S||_||_|S(s. Associate linker with fgraph RQRPRRRtN( RRsRLRQRPRRRtRuRw(R RsRwRx((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyRus          c C`sttdd}z+|j}|j|}|j}tj|||||\}}}|jrtj|\} } g} nd} i} x$|D]} | j dkg| | R%t __future__RRRRRRtloggingtnumpyRR Rt theano.compatRRtsixRRt six.movesR R t theano.gofR R R Rttheano.gof.compilelockRRttheano.gof.callcacheRt getLoggerRRR>RRRRR&R'R.RARDRSRURZR\R_RbRhRqtLinkerRrtobjectRt LocalLinkerROReRfR}(((s-/tmp/pip-build-X4mzal/theano/theano/gof/cc.pyts^       #   %   & !   /RA a