\n catalog.add_function('printf(\"printed from C: %d\", a);',function)\n \n add_function() adds function to the front of the cache. function,\n along with the path information to its module, are also stored in a\n persistent catalog for future use by python sessions. \n\"\"\" \n\nimport os,sys,string\nimport pickle\n\ntry:\n import dbhash\n import shelve\n dumb = 0\nexcept ImportError:\n import dumb_shelve as shelve\n dumb = 1\n\n#For testing...\n#import dumb_shelve as shelve\n#dumb = 1\n\n#import shelve\n#dumb = 0\n \ndef getmodule(object):\n \"\"\" Discover the name of the module where object was defined.\n \n This is an augmented version of inspect.getmodule that can discover \n the parent module for extension functions.\n \"\"\"\n import inspect\n value = inspect.getmodule(object)\n if value is None:\n #walk trough all modules looking for function\n for name,mod in sys.modules.items():\n # try except used because of some comparison failures\n # in wxPoint code. Need to review this\n try:\n if mod and object in mod.__dict__.values():\n value = mod\n # if it is a built-in module, keep looking to see\n # if a non-builtin also has it. Otherwise quit and\n # consider the module found. (ain't perfect, but will \n # have to do for now).\n if string.find('(built-in)',str(mod)) is -1:\n break\n \n except (TypeError, KeyError):\n pass \n return value\n\ndef expr_to_filename(expr):\n \"\"\" Convert an arbitrary expr string to a valid file name.\n \n The name is based on the md5 check sum for the string and\n Something that was a little more human readable would be \n nice, but the computer doesn't seem to care.\n \"\"\"\n import md5\n base = 'sc_'\n return base + md5.new(expr).hexdigest()\n\ndef unique_file(d,expr):\n \"\"\" Generate a unqiue file name based on expr in directory d\n \n This is meant for use with building extension modules, so\n a file name is considered unique if none of the following\n extension '.cpp','.o','.so','module.so','.py', or '.pyd'\n exists in directory d. The fully qualified path to the\n new name is returned. You'll need to append your own\n extension to it before creating files.\n \"\"\"\n files = os.listdir(d)\n #base = 'scipy_compile'\n base = expr_to_filename(expr)\n for i in range(1000000):\n fname = base + `i`\n if not (fname+'.cpp' in files or\n fname+'.o' in files or\n fname+'.so' in files or\n fname+'module.so' in files or\n fname+'.py' in files or\n fname+'.pyd' in files):\n break\n return os.path.join(d,fname)\n \ndef default_dir():\n \"\"\" Return a default location to store compiled files and catalogs.\n \n XX is the Python version number in all paths listed below\n On windows, the default location is the temporary directory\n returned by gettempdir()/pythonXX.\n \n On Unix, ~/.pythonXX_compiled is the default location. If it doesn't\n exist, it is created. The directory is marked rwx------.\n \n If for some reason it isn't possible to build a default directory\n in the user's home, /tmp/_pythonXX_compiled is used. If it \n doesn't exist, it is created. The directory is marked rwx------\n to try and keep people from being able to sneak a bad module\n in on you. \n \"\"\"\n import tempfile \n python_name = \"python%d%d_compiled\" % tuple(sys.version_info[:2]) \n if sys.platform != 'win32':\n try:\n path = os.path.join(os.environ['HOME'],'.' + python_name)\n except KeyError:\n temp_dir = `os.getuid()` + '_' + python_name\n path = os.path.join(tempfile.gettempdir(),temp_dir) \n else:\n path = os.path.join(tempfile.gettempdir(),python_name)\n \n if not os.path.exists(path):\n os.mkdir(path)\n os.chmod(path,0700) # make it only accessible by this user.\n if not os.access(path,os.W_OK):\n print 'warning: default directory is not write accessible.'\n print 'defualt:', path\n return path\n\ndef intermediate_dir():\n \"\"\" Location in temp dir for storing .cpp and .o files during\n builds.\n \"\"\"\n import tempfile \n python_name = \"python%d%d_intermediate\" % tuple(sys.version_info[:2]) \n path = os.path.join(tempfile.gettempdir(),python_name)\n if not os.path.exists(path):\n os.mkdir(path)\n return path\n \ndef default_temp_dir():\n path = os.path.join(default_dir(),'temp')\n if not os.path.exists(path):\n os.mkdir(path)\n os.chmod(path,0700) # make it only accessible by this user.\n if not os.access(path,os.W_OK):\n print 'warning: default directory is not write accessible.'\n print 'defualt:', path\n return path\n\n \ndef os_dependent_catalog_name():\n \"\"\" Generate catalog name dependent on OS and Python version being used.\n \n This allows multiple platforms to have catalog files in the\n same directory without stepping on each other. For now, it \n bases the name of the value returned by sys.platform and the\n version of python being run. If this isn't enough to descriminate\n on some platforms, we can try to add other info. It has \n occured to me that if we get fancy enough to optimize for different\n architectures, then chip type might be added to the catalog name also.\n \"\"\"\n version = '%d%d' % sys.version_info[:2]\n return sys.platform+version+'compiled_catalog'\n \ndef catalog_path(module_path):\n \"\"\" Return the full path name for the catalog file in the given directory.\n \n module_path can either be a file name or a path name. If it is a \n file name, the catalog file name in its parent directory is returned.\n If it is a directory, the catalog file in that directory is returned.\n\n If module_path doesn't exist, None is returned. Note though, that the\n catalog file does *not* have to exist, only its parent. '~', shell\n variables, and relative ('.' and '..') paths are all acceptable.\n \n catalog file names are os dependent (based on sys.platform), so this \n should support multiple platforms sharing the same disk space \n (NFS mounts). See os_dependent_catalog_name() for more info.\n \"\"\"\n module_path = os.path.expanduser(module_path)\n module_path = os.path.expandvars(module_path)\n module_path = os.path.abspath(module_path)\n if not os.path.exists(module_path):\n catalog_file = None\n elif not os.path.isdir(module_path):\n module_path,dummy = os.path.split(module_path)\n catalog_file = os.path.join(module_path,os_dependent_catalog_name())\n else: \n catalog_file = os.path.join(module_path,os_dependent_catalog_name())\n return catalog_file\n\ndef get_catalog(module_path,mode='r'):\n \"\"\" Return a function catalog (shelve object) from the path module_path\n\n If module_path is a directory, the function catalog returned is\n from that directory. If module_path is an actual module_name,\n then the function catalog returned is from its parent directory.\n mode uses the standard 'c' = create, 'n' = new, 'r' = read, \n 'w' = write file open modes available for anydbm databases.\n \n Well... it should be. Stuck with dumbdbm for now and the modes\n almost don't matter. We do some checking for 'r' mode, but that\n is about it.\n \n See catalog_path() for more information on module_path.\n \"\"\"\n if mode not in ['c','r','w','n']:\n msg = \" mode must be 'c', 'n', 'r', or 'w'. See anydbm for more info\"\n raise ValueError, msg\n catalog_file = catalog_path(module_path)\n try:\n # code reliant on the fact that we are using dumbdbm\n if dumb and mode == 'r' and not os.path.exists(catalog_file+'.dat'):\n sh = None\n else:\n sh = shelve.open(catalog_file,mode)\n except: # not sure how to pin down which error to catch yet\n sh = None\n return sh\n\nclass catalog:\n \"\"\" Stores information about compiled functions both in cache and on disk.\n \n catalog stores (code, list_of_function) pairs so that all the functions\n that have been compiled for code are available for calling (usually in\n inline or blitz).\n \n catalog keeps a dictionary of previously accessed code values cached \n for quick access. It also handles the looking up of functions compiled \n in previously called Python sessions on disk in function catalogs. \n catalog searches the directories in the PYTHONCOMPILED environment \n variable in order loading functions that correspond to the given code \n fragment. A default directory is also searched for catalog functions. \n On unix, the default directory is usually '~/.pythonxx_compiled' where \n xx is the version of Python used. On windows, it is the directory \n returned by temfile.gettempdir(). Functions closer to the front are of \n the variable list are guaranteed to be closer to the front of the \n function list so that they will be called first. See \n get_cataloged_functions() for more info on how the search order is \n traversed.\n \n Catalog also handles storing information about compiled functions to\n a catalog. When writing this information, the first writable catalog\n file in PYTHONCOMPILED path is used. If a writable catalog is not\n found, it is written to the catalog in the default directory. This\n directory should always be writable.\n \"\"\"\n def __init__(self,user_path_list=None):\n \"\"\" Create a catalog for storing/searching for compiled functions. \n \n user_path_list contains directories that should be searched \n first for function catalogs. They will come before the path\n entries in the PYTHONCOMPILED environment varilable.\n \"\"\"\n if type(user_path_list) == type('string'):\n self.user_path_list = [user_path_list]\n elif user_path_list:\n self.user_path_list = user_path_list\n else:\n self.user_path_list = []\n self.cache = {}\n self.module_dir = None\n self.paths_added = 0\n \n def set_module_directory(self,module_dir):\n \"\"\" Set the path that will replace 'MODULE' in catalog searches.\n \n You should call clear_module_directory() when your finished\n working with it.\n \"\"\"\n self.module_dir = module_dir\n def get_module_directory(self):\n \"\"\" Return the path used to replace the 'MODULE' in searches.\n \"\"\"\n return self.module_dir\n def clear_module_directory(self):\n \"\"\" Reset 'MODULE' path to None so that it is ignored in searches. \n \"\"\"\n self.module_dir = None\n \n def get_environ_path(self):\n \"\"\" Return list of paths from 'PYTHONCOMPILED' environment variable.\n \n On Unix the path in PYTHONCOMPILED is a ':' separated list of\n directories. On Windows, a ';' separated list is used. \n \"\"\"\n paths = []\n if os.environ.has_key('PYTHONCOMPILED'):\n path_string = os.environ['PYTHONCOMPILED'] \n if sys.platform == 'win32':\n #probably should also look in registry\n paths = path_string.split(';')\n else: \n paths = path_string.split(':')\n return paths \n\n def build_search_order(self):\n \"\"\" Returns a list of paths that are searched for catalogs. \n \n Values specified in the catalog constructor are searched first,\n then values found in the PYTHONCOMPILED environment variable.\n The directory returned by default_dir() is always returned at\n the end of the list.\n \n There is a 'magic' path name called 'MODULE' that is replaced\n by the directory defined by set_module_directory(). If the\n module directory hasn't been set, 'MODULE' is ignored.\n \"\"\"\n \n paths = self.user_path_list + self.get_environ_path()\n search_order = []\n for path in paths:\n if path == 'MODULE':\n if self.module_dir:\n search_order.append(self.module_dir)\n else:\n search_order.append(path)\n search_order.append(default_dir())\n return search_order\n\n def get_catalog_files(self):\n \"\"\" Returns catalog file list in correct search order.\n \n Some of the catalog files may not currently exists.\n However, all will be valid locations for a catalog\n to be created (if you have write permission).\n \"\"\"\n files = map(catalog_path,self.build_search_order())\n files = filter(lambda x: x is not None,files)\n return files\n\n def get_existing_files(self):\n \"\"\" Returns all existing catalog file list in correct search order.\n \"\"\"\n files = self.get_catalog_files()\n # open every stinking file to check if it exists.\n # This is because anydbm doesn't provide a consistent naming \n # convention across platforms for its files \n existing_files = []\n for file in files:\n if get_catalog(os.path.dirname(file),'r') is not None:\n existing_files.append(file)\n # This is the non-portable (and much faster) old code\n #existing_files = filter(os.path.exists,files)\n return existing_files\n\n def get_writable_file(self,existing_only=0):\n \"\"\" Return the name of the first writable catalog file.\n \n Its parent directory must also be writable. This is so that\n compiled modules can be written to the same directory.\n \"\"\"\n # note: both file and its parent directory must be writeable\n if existing_only:\n files = self.get_existing_files()\n else:\n files = self.get_catalog_files()\n # filter for (file exists and is writable) OR directory is writable\n def file_test(x):\n from os import access, F_OK, W_OK\n return (access(x,F_OK) and access(x,W_OK) or\n access(os.path.dirname(x),W_OK))\n writable = filter(file_test,files)\n if writable:\n file = writable[0]\n else:\n file = None\n return file\n \n def get_writable_dir(self):\n \"\"\" Return the parent directory of first writable catalog file.\n \n The returned directory has write access.\n \"\"\"\n return os.path.dirname(self.get_writable_file())\n \n def unique_module_name(self,code,module_dir=None):\n \"\"\" Return full path to unique file name that in writable location.\n \n The directory for the file is the first writable directory in \n the catalog search path. The unique file name is derived from\n the code fragment. If, module_dir is specified, it is used\n to replace 'MODULE' in the search path.\n \"\"\"\n if module_dir is not None:\n self.set_module_directory(module_dir)\n try:\n d = self.get_writable_dir()\n finally:\n if module_dir is not None:\n self.clear_module_directory()\n return unique_file(d,code)\n\n def path_key(self,code):\n \"\"\" Return key for path information for functions associated with code.\n \"\"\"\n return '__path__' + code\n \n def configure_path(self,cat,code):\n \"\"\" Add the python path for the given code to the sys.path\n \n unconfigure_path() should be called as soon as possible after\n imports associated with code are finished so that sys.path \n is restored to normal.\n \"\"\"\n try:\n paths = cat[self.path_key(code)]\n self.paths_added = len(paths)\n sys.path = paths + sys.path\n except:\n self.paths_added = 0 \n \n def unconfigure_path(self):\n \"\"\" Restores sys.path to normal after calls to configure_path()\n \n Remove the previously added paths from sys.path\n \"\"\"\n sys.path = sys.path[self.paths_added:]\n self.paths_added = 0\n\n def get_cataloged_functions(self,code):\n \"\"\" Load all functions associated with code from catalog search path.\n \n Sometimes there can be trouble loading a function listed in a\n catalog file because the actual module that holds the function \n has been moved or deleted. When this happens, that catalog file\n is \"repaired\", meaning the entire entry for this function is \n removed from the file. This only affects the catalog file that\n has problems -- not the others in the search path.\n \n The \"repair\" behavior may not be needed, but I'll keep it for now.\n \"\"\"\n mode = 'r'\n cat = None\n function_list = []\n for path in self.build_search_order():\n cat = get_catalog(path,mode)\n if cat is not None and cat.has_key(code):\n # set up the python path so that modules for this\n # function can be loaded.\n self.configure_path(cat,code)\n try: \n function_list += cat[code]\n except: #SystemError and ImportError so far seen \n # problems loading a function from the catalog. Try to\n # repair the cause.\n cat.close()\n self.repair_catalog(path,code)\n self.unconfigure_path() \n return function_list\n\n\n def repair_catalog(self,catalog_path,code):\n \"\"\" Remove entry for code from catalog_path\n \n Occasionally catalog entries could get corrupted. An example\n would be when a module that had functions in the catalog was\n deleted or moved on the disk. The best current repair method is \n just to trash the entire catalog entry for this piece of code. \n This may loose function entries that are valid, but thats life.\n \n catalog_path must be writable for repair. If it isn't, the\n function exists with a warning. \n \"\"\"\n writable_cat = None\n if not os.path.exists(catalog_path):\n return\n try:\n writable_cat = get_catalog(catalog_path,'w')\n except:\n print 'warning: unable to repair catalog entry\\n %s\\n in\\n %s' % \\\n (code,catalog_path)\n return \n if writable_cat.has_key(code):\n print 'repairing catalog by removing key'\n del writable_cat[code]\n \n # it is possible that the path key doesn't exist (if the function registered\n # was a built-in function), so we have to check if the path exists before\n # arbitrarily deleting it.\n path_key = self.path_key(code) \n if writable_cat.has_key(path_key):\n del writable_cat[path_key] \n \n def get_functions_fast(self,code):\n \"\"\" Return list of functions for code from the cache.\n \n Return an empty list if the code entry is not found.\n \"\"\"\n return self.cache.get(code,[])\n \n def get_functions(self,code,module_dir=None):\n \"\"\" Return the list of functions associated with this code fragment.\n \n The cache is first searched for the function. If an entry\n in the cache is not found, then catalog files on disk are \n searched for the entry. This is slooooow, but only happens\n once per code object. All the functions found in catalog files\n on a cache miss are loaded into the cache to speed up future calls.\n The search order is as follows:\n \n 1. user specified path (from catalog initialization)\n 2. directories from the PYTHONCOMPILED environment variable\n 3. The temporary directory on your platform.\n\n The path specified by module_dir will replace the 'MODULE' \n place holder in the catalog search path. See build_search_order()\n for more info on the search path. \n \"\"\" \n # Fast!! try cache first.\n if self.cache.has_key(code):\n return self.cache[code]\n \n # 2. Slow!! read previously compiled functions from disk.\n try:\n self.set_module_directory(module_dir)\n function_list = self.get_cataloged_functions(code)\n # put function_list in cache to save future lookups.\n if function_list:\n self.cache[code] = function_list\n # return function_list, empty or otherwise.\n finally:\n self.clear_module_directory()\n return function_list\n\n def add_function(self,code,function,module_dir=None):\n \"\"\" Adds a function to the catalog.\n \n The function is added to the cache as well as the first\n writable file catalog found in the search path. If no\n code entry exists in the cache, the on disk catalogs\n are loaded into the cache and function is added to the\n beginning of the function list.\n \n The path specified by module_dir will replace the 'MODULE' \n place holder in the catalog search path. See build_search_order()\n for more info on the search path. \n \"\"\" \n\n # 1. put it in the cache.\n if self.cache.has_key(code):\n if function not in self.cache[code]:\n self.cache[code].insert(0,function)\n else:\n # if it is in the cache, then it is also\n # been persisted \n return\n else: \n # Load functions and put this one up front\n self.cache[code] = self.get_functions(code) \n self.fast_cache(code,function)\n # 2. Store the function entry to disk. \n try:\n self.set_module_directory(module_dir)\n self.add_function_persistent(code,function)\n finally:\n self.clear_module_directory()\n \n def add_function_persistent(self,code,function):\n \"\"\" Store the code->function relationship to disk.\n \n Two pieces of information are needed for loading functions\n from disk -- the function pickle (which conveniently stores\n the module name, etc.) and the path to its module's directory.\n The latter is needed so that the function can be loaded no\n matter what the user's Python path is.\n \"\"\" \n # add function to data in first writable catalog\n mode = 'c' # create if doesn't exist, otherwise, use existing\n cat_dir = self.get_writable_dir()\n cat = get_catalog(cat_dir,mode)\n if cat is None:\n cat_dir = default_dir()\n cat = get_catalog(cat_dir,mode)\n if cat is None:\n cat_dir = default_dir() \n cat_file = catalog_path(cat_dir)\n print 'problems with default catalog -- removing'\n import glob\n files = glob.glob(cat_file+'*')\n for f in files:\n os.remove(f)\n cat = get_catalog(cat_dir,mode)\n if cat is None:\n raise ValueError, 'Failed to access a catalog for storing functions' \n # Prabhu was getting some corrupt catalog errors. I'll put a try/except\n # to protect against this, but should really try and track down the issue.\n function_list = [function]\n try:\n function_list = function_list + cat.get(code,[])\n except pickle.UnpicklingError:\n pass\n cat[code] = function_list\n # now add needed path information for loading function\n module = getmodule(function)\n try:\n # built in modules don't have the __file__ extension, so this\n # will fail. Just pass in this case since path additions aren't\n # needed for built-in modules.\n mod_path,f=os.path.split(os.path.abspath(module.__file__))\n pkey = self.path_key(code)\n cat[pkey] = [mod_path] + cat.get(pkey,[])\n except:\n pass\n\n def fast_cache(self,code,function):\n \"\"\" Move function to the front of the cache entry for code\n \n If future calls to the function have the same type signature,\n this will speed up access significantly because the first\n function call is correct.\n \n Note: The cache added to the inline_tools module is significantly\n faster than always calling get_functions, so this isn't\n as necessary as it used to be. Still, it's probably worth\n doing. \n \"\"\"\n try:\n if self.cache[code][0] == function:\n return\n except: # KeyError, IndexError \n pass\n try:\n self.cache[code].remove(function)\n except ValueError:\n pass\n # put new function at the beginning of the list to search.\n self.cache[code].insert(0,function)\n \ndef test():\n from scipy_test import module_test\n module_test(__name__,__file__)\n\ndef test_suite():\n from scipy_test import module_test_suite\n return module_test_suite(__name__,__file__) \n",
"source_code_before": "\"\"\" Track relationships between compiled extension functions & code fragments\n\n catalog keeps track of which compiled(or even standard) functions are \n related to which code fragments. It also stores these relationships\n to disk so they are remembered between Python sessions. When \n \n a = 1\n compiler.inline('printf(\"printed from C: %d\",a);',['a'] )\n \n is called, inline() first looks to see if it has seen the code \n 'printf(\"printed from C\");' before. If not, it calls \n \n catalog.get_functions('printf(\"printed from C: %d\", a);')\n \n which returns a list of all the function objects that have been compiled\n for the code fragment. Multiple functions can occur because the code\n could be compiled for different types for 'a' (although not likely in\n this case). The catalog first looks in its cache and quickly returns\n a list of the functions if possible. If the cache lookup fails, it then\n looks through possibly multiple catalog files on disk and fills its\n cache with all the functions that match the code fragment. \n \n In case where the code fragment hasn't been compiled, inline() compiles\n the code and then adds it to the catalog:\n \n function = \n catalog.add_function('printf(\"printed from C: %d\", a);',function)\n \n add_function() adds function to the front of the cache. function,\n along with the path information to its module, are also stored in a\n persistent catalog for future use by python sessions. \n\"\"\" \n\nimport os,sys,string\nimport pickle\n\ntry:\n import dbhash\n import shelve\n dumb = 0\nexcept ImportError:\n import dumb_shelve as shelve\n dumb == 1\n\n#For testing...\n#import dumb_shelve as shelve\n#dumb = 1\n\n#import shelve\n#dumb = 0\n \ndef getmodule(object):\n \"\"\" Discover the name of the module where object was defined.\n \n This is an augmented version of inspect.getmodule that can discover \n the parent module for extension functions.\n \"\"\"\n import inspect\n value = inspect.getmodule(object)\n if value is None:\n #walk trough all modules looking for function\n for name,mod in sys.modules.items():\n # try except used because of some comparison failures\n # in wxPoint code. Need to review this\n try:\n if mod and object in mod.__dict__.values():\n value = mod\n # if it is a built-in module, keep looking to see\n # if a non-builtin also has it. Otherwise quit and\n # consider the module found. (ain't perfect, but will \n # have to do for now).\n if string.find('(built-in)',str(mod)) is -1:\n break\n \n except (TypeError, KeyError):\n pass \n return value\n\ndef expr_to_filename(expr):\n \"\"\" Convert an arbitrary expr string to a valid file name.\n \n The name is based on the md5 check sum for the string and\n Something that was a little more human readable would be \n nice, but the computer doesn't seem to care.\n \"\"\"\n import md5\n base = 'sc_'\n return base + md5.new(expr).hexdigest()\n\ndef unique_file(d,expr):\n \"\"\" Generate a unqiue file name based on expr in directory d\n \n This is meant for use with building extension modules, so\n a file name is considered unique if none of the following\n extension '.cpp','.o','.so','module.so','.py', or '.pyd'\n exists in directory d. The fully qualified path to the\n new name is returned. You'll need to append your own\n extension to it before creating files.\n \"\"\"\n files = os.listdir(d)\n #base = 'scipy_compile'\n base = expr_to_filename(expr)\n for i in range(1000000):\n fname = base + `i`\n if not (fname+'.cpp' in files or\n fname+'.o' in files or\n fname+'.so' in files or\n fname+'module.so' in files or\n fname+'.py' in files or\n fname+'.pyd' in files):\n break\n return os.path.join(d,fname)\n \ndef default_dir():\n \"\"\" Return a default location to store compiled files and catalogs.\n \n XX is the Python version number in all paths listed below\n On windows, the default location is the temporary directory\n returned by gettempdir()/pythonXX.\n \n On Unix, ~/.pythonXX_compiled is the default location. If it doesn't\n exist, it is created. The directory is marked rwx------.\n \n If for some reason it isn't possible to build a default directory\n in the user's home, /tmp/_pythonXX_compiled is used. If it \n doesn't exist, it is created. The directory is marked rwx------\n to try and keep people from being able to sneak a bad module\n in on you. \n \"\"\"\n import tempfile \n python_name = \"python%d%d_compiled\" % tuple(sys.version_info[:2]) \n if sys.platform != 'win32':\n try:\n path = os.path.join(os.environ['HOME'],'.' + python_name)\n except KeyError:\n temp_dir = `os.getuid()` + '_' + python_name\n path = os.path.join(tempfile.gettempdir(),temp_dir) \n else:\n path = os.path.join(tempfile.gettempdir(),python_name)\n \n if not os.path.exists(path):\n os.mkdir(path)\n os.chmod(path,0700) # make it only accessible by this user.\n if not os.access(path,os.W_OK):\n print 'warning: default directory is not write accessible.'\n print 'defualt:', path\n return path\n\ndef intermediate_dir():\n \"\"\" Location in temp dir for storing .cpp and .o files during\n builds.\n \"\"\"\n import tempfile \n python_name = \"python%d%d_intermediate\" % tuple(sys.version_info[:2]) \n path = os.path.join(tempfile.gettempdir(),python_name)\n if not os.path.exists(path):\n os.mkdir(path)\n return path\n \ndef default_temp_dir():\n path = os.path.join(default_dir(),'temp')\n if not os.path.exists(path):\n os.mkdir(path)\n os.chmod(path,0700) # make it only accessible by this user.\n if not os.access(path,os.W_OK):\n print 'warning: default directory is not write accessible.'\n print 'defualt:', path\n return path\n\n \ndef os_dependent_catalog_name():\n \"\"\" Generate catalog name dependent on OS and Python version being used.\n \n This allows multiple platforms to have catalog files in the\n same directory without stepping on each other. For now, it \n bases the name of the value returned by sys.platform and the\n version of python being run. If this isn't enough to descriminate\n on some platforms, we can try to add other info. It has \n occured to me that if we get fancy enough to optimize for different\n architectures, then chip type might be added to the catalog name also.\n \"\"\"\n version = '%d%d' % sys.version_info[:2]\n return sys.platform+version+'compiled_catalog'\n \ndef catalog_path(module_path):\n \"\"\" Return the full path name for the catalog file in the given directory.\n \n module_path can either be a file name or a path name. If it is a \n file name, the catalog file name in its parent directory is returned.\n If it is a directory, the catalog file in that directory is returned.\n\n If module_path doesn't exist, None is returned. Note though, that the\n catalog file does *not* have to exist, only its parent. '~', shell\n variables, and relative ('.' and '..') paths are all acceptable.\n \n catalog file names are os dependent (based on sys.platform), so this \n should support multiple platforms sharing the same disk space \n (NFS mounts). See os_dependent_catalog_name() for more info.\n \"\"\"\n module_path = os.path.expanduser(module_path)\n module_path = os.path.expandvars(module_path)\n module_path = os.path.abspath(module_path)\n if not os.path.exists(module_path):\n catalog_file = None\n elif not os.path.isdir(module_path):\n module_path,dummy = os.path.split(module_path)\n catalog_file = os.path.join(module_path,os_dependent_catalog_name())\n else: \n catalog_file = os.path.join(module_path,os_dependent_catalog_name())\n return catalog_file\n\ndef get_catalog(module_path,mode='r'):\n \"\"\" Return a function catalog (shelve object) from the path module_path\n\n If module_path is a directory, the function catalog returned is\n from that directory. If module_path is an actual module_name,\n then the function catalog returned is from its parent directory.\n mode uses the standard 'c' = create, 'n' = new, 'r' = read, \n 'w' = write file open modes available for anydbm databases.\n \n Well... it should be. Stuck with dumbdbm for now and the modes\n almost don't matter. We do some checking for 'r' mode, but that\n is about it.\n \n See catalog_path() for more information on module_path.\n \"\"\"\n if mode not in ['c','r','w','n']:\n msg = \" mode must be 'c', 'n', 'r', or 'w'. See anydbm for more info\"\n raise ValueError, msg\n catalog_file = catalog_path(module_path)\n try:\n # code reliant on the fact that we are using dumbdbm\n if dumb and mode == 'r' and not os.path.exists(catalog_file+'.dat'):\n sh = None\n else:\n sh = shelve.open(catalog_file,mode)\n except: # not sure how to pin down which error to catch yet\n sh = None\n return sh\n\nclass catalog:\n \"\"\" Stores information about compiled functions both in cache and on disk.\n \n catalog stores (code, list_of_function) pairs so that all the functions\n that have been compiled for code are available for calling (usually in\n inline or blitz).\n \n catalog keeps a dictionary of previously accessed code values cached \n for quick access. It also handles the looking up of functions compiled \n in previously called Python sessions on disk in function catalogs. \n catalog searches the directories in the PYTHONCOMPILED environment \n variable in order loading functions that correspond to the given code \n fragment. A default directory is also searched for catalog functions. \n On unix, the default directory is usually '~/.pythonxx_compiled' where \n xx is the version of Python used. On windows, it is the directory \n returned by temfile.gettempdir(). Functions closer to the front are of \n the variable list are guaranteed to be closer to the front of the \n function list so that they will be called first. See \n get_cataloged_functions() for more info on how the search order is \n traversed.\n \n Catalog also handles storing information about compiled functions to\n a catalog. When writing this information, the first writable catalog\n file in PYTHONCOMPILED path is used. If a writable catalog is not\n found, it is written to the catalog in the default directory. This\n directory should always be writable.\n \"\"\"\n def __init__(self,user_path_list=None):\n \"\"\" Create a catalog for storing/searching for compiled functions. \n \n user_path_list contains directories that should be searched \n first for function catalogs. They will come before the path\n entries in the PYTHONCOMPILED environment varilable.\n \"\"\"\n if type(user_path_list) == type('string'):\n self.user_path_list = [user_path_list]\n elif user_path_list:\n self.user_path_list = user_path_list\n else:\n self.user_path_list = []\n self.cache = {}\n self.module_dir = None\n self.paths_added = 0\n \n def set_module_directory(self,module_dir):\n \"\"\" Set the path that will replace 'MODULE' in catalog searches.\n \n You should call clear_module_directory() when your finished\n working with it.\n \"\"\"\n self.module_dir = module_dir\n def get_module_directory(self):\n \"\"\" Return the path used to replace the 'MODULE' in searches.\n \"\"\"\n return self.module_dir\n def clear_module_directory(self):\n \"\"\" Reset 'MODULE' path to None so that it is ignored in searches. \n \"\"\"\n self.module_dir = None\n \n def get_environ_path(self):\n \"\"\" Return list of paths from 'PYTHONCOMPILED' environment variable.\n \n On Unix the path in PYTHONCOMPILED is a ':' separated list of\n directories. On Windows, a ';' separated list is used. \n \"\"\"\n paths = []\n if os.environ.has_key('PYTHONCOMPILED'):\n path_string = os.environ['PYTHONCOMPILED'] \n if sys.platform == 'win32':\n #probably should also look in registry\n paths = path_string.split(';')\n else: \n paths = path_string.split(':')\n return paths \n\n def build_search_order(self):\n \"\"\" Returns a list of paths that are searched for catalogs. \n \n Values specified in the catalog constructor are searched first,\n then values found in the PYTHONCOMPILED environment variable.\n The directory returned by default_dir() is always returned at\n the end of the list.\n \n There is a 'magic' path name called 'MODULE' that is replaced\n by the directory defined by set_module_directory(). If the\n module directory hasn't been set, 'MODULE' is ignored.\n \"\"\"\n \n paths = self.user_path_list + self.get_environ_path()\n search_order = []\n for path in paths:\n if path == 'MODULE':\n if self.module_dir:\n search_order.append(self.module_dir)\n else:\n search_order.append(path)\n search_order.append(default_dir())\n return search_order\n\n def get_catalog_files(self):\n \"\"\" Returns catalog file list in correct search order.\n \n Some of the catalog files may not currently exists.\n However, all will be valid locations for a catalog\n to be created (if you have write permission).\n \"\"\"\n files = map(catalog_path,self.build_search_order())\n files = filter(lambda x: x is not None,files)\n return files\n\n def get_existing_files(self):\n \"\"\" Returns all existing catalog file list in correct search order.\n \"\"\"\n files = self.get_catalog_files()\n # open every stinking file to check if it exists.\n # This is because anydbm doesn't provide a consistent naming \n # convention across platforms for its files \n existing_files = []\n for file in files:\n if get_catalog(os.path.dirname(file),'r') is not None:\n existing_files.append(file)\n # This is the non-portable (and much faster) old code\n #existing_files = filter(os.path.exists,files)\n return existing_files\n\n def get_writable_file(self,existing_only=0):\n \"\"\" Return the name of the first writable catalog file.\n \n Its parent directory must also be writable. This is so that\n compiled modules can be written to the same directory.\n \"\"\"\n # note: both file and its parent directory must be writeable\n if existing_only:\n files = self.get_existing_files()\n else:\n files = self.get_catalog_files()\n # filter for (file exists and is writable) OR directory is writable\n def file_test(x):\n from os import access, F_OK, W_OK\n return (access(x,F_OK) and access(x,W_OK) or\n access(os.path.dirname(x),W_OK))\n writable = filter(file_test,files)\n if writable:\n file = writable[0]\n else:\n file = None\n return file\n \n def get_writable_dir(self):\n \"\"\" Return the parent directory of first writable catalog file.\n \n The returned directory has write access.\n \"\"\"\n return os.path.dirname(self.get_writable_file())\n \n def unique_module_name(self,code,module_dir=None):\n \"\"\" Return full path to unique file name that in writable location.\n \n The directory for the file is the first writable directory in \n the catalog search path. The unique file name is derived from\n the code fragment. If, module_dir is specified, it is used\n to replace 'MODULE' in the search path.\n \"\"\"\n if module_dir is not None:\n self.set_module_directory(module_dir)\n try:\n d = self.get_writable_dir()\n finally:\n if module_dir is not None:\n self.clear_module_directory()\n return unique_file(d,code)\n\n def path_key(self,code):\n \"\"\" Return key for path information for functions associated with code.\n \"\"\"\n return '__path__' + code\n \n def configure_path(self,cat,code):\n \"\"\" Add the python path for the given code to the sys.path\n \n unconfigure_path() should be called as soon as possible after\n imports associated with code are finished so that sys.path \n is restored to normal.\n \"\"\"\n try:\n paths = cat[self.path_key(code)]\n self.paths_added = len(paths)\n sys.path = paths + sys.path\n except:\n self.paths_added = 0 \n \n def unconfigure_path(self):\n \"\"\" Restores sys.path to normal after calls to configure_path()\n \n Remove the previously added paths from sys.path\n \"\"\"\n sys.path = sys.path[self.paths_added:]\n self.paths_added = 0\n\n def get_cataloged_functions(self,code):\n \"\"\" Load all functions associated with code from catalog search path.\n \n Sometimes there can be trouble loading a function listed in a\n catalog file because the actual module that holds the function \n has been moved or deleted. When this happens, that catalog file\n is \"repaired\", meaning the entire entry for this function is \n removed from the file. This only affects the catalog file that\n has problems -- not the others in the search path.\n \n The \"repair\" behavior may not be needed, but I'll keep it for now.\n \"\"\"\n mode = 'r'\n cat = None\n function_list = []\n for path in self.build_search_order():\n cat = get_catalog(path,mode)\n if cat is not None and cat.has_key(code):\n # set up the python path so that modules for this\n # function can be loaded.\n self.configure_path(cat,code)\n try: \n function_list += cat[code]\n except: #SystemError and ImportError so far seen \n # problems loading a function from the catalog. Try to\n # repair the cause.\n cat.close()\n self.repair_catalog(path,code)\n self.unconfigure_path() \n return function_list\n\n\n def repair_catalog(self,catalog_path,code):\n \"\"\" Remove entry for code from catalog_path\n \n Occasionally catalog entries could get corrupted. An example\n would be when a module that had functions in the catalog was\n deleted or moved on the disk. The best current repair method is \n just to trash the entire catalog entry for this piece of code. \n This may loose function entries that are valid, but thats life.\n \n catalog_path must be writable for repair. If it isn't, the\n function exists with a warning. \n \"\"\"\n writable_cat = None\n if not os.path.exists(catalog_path):\n return\n try:\n writable_cat = get_catalog(catalog_path,'w')\n except:\n print 'warning: unable to repair catalog entry\\n %s\\n in\\n %s' % \\\n (code,catalog_path)\n return \n if writable_cat.has_key(code):\n print 'repairing catalog by removing key'\n del writable_cat[code]\n \n # it is possible that the path key doesn't exist (if the function registered\n # was a built-in function), so we have to check if the path exists before\n # arbitrarily deleting it.\n path_key = self.path_key(code) \n if writable_cat.has_key(path_key):\n del writable_cat[path_key] \n \n def get_functions_fast(self,code):\n \"\"\" Return list of functions for code from the cache.\n \n Return an empty list if the code entry is not found.\n \"\"\"\n return self.cache.get(code,[])\n \n def get_functions(self,code,module_dir=None):\n \"\"\" Return the list of functions associated with this code fragment.\n \n The cache is first searched for the function. If an entry\n in the cache is not found, then catalog files on disk are \n searched for the entry. This is slooooow, but only happens\n once per code object. All the functions found in catalog files\n on a cache miss are loaded into the cache to speed up future calls.\n The search order is as follows:\n \n 1. user specified path (from catalog initialization)\n 2. directories from the PYTHONCOMPILED environment variable\n 3. The temporary directory on your platform.\n\n The path specified by module_dir will replace the 'MODULE' \n place holder in the catalog search path. See build_search_order()\n for more info on the search path. \n \"\"\" \n # Fast!! try cache first.\n if self.cache.has_key(code):\n return self.cache[code]\n \n # 2. Slow!! read previously compiled functions from disk.\n try:\n self.set_module_directory(module_dir)\n function_list = self.get_cataloged_functions(code)\n # put function_list in cache to save future lookups.\n if function_list:\n self.cache[code] = function_list\n # return function_list, empty or otherwise.\n finally:\n self.clear_module_directory()\n return function_list\n\n def add_function(self,code,function,module_dir=None):\n \"\"\" Adds a function to the catalog.\n \n The function is added to the cache as well as the first\n writable file catalog found in the search path. If no\n code entry exists in the cache, the on disk catalogs\n are loaded into the cache and function is added to the\n beginning of the function list.\n \n The path specified by module_dir will replace the 'MODULE' \n place holder in the catalog search path. See build_search_order()\n for more info on the search path. \n \"\"\" \n\n # 1. put it in the cache.\n if self.cache.has_key(code):\n if function not in self.cache[code]:\n self.cache[code].insert(0,function)\n else:\n # if it is in the cache, then it is also\n # been persisted \n return\n else: \n # Load functions and put this one up front\n self.cache[code] = self.get_functions(code) \n self.fast_cache(code,function)\n # 2. Store the function entry to disk. \n try:\n self.set_module_directory(module_dir)\n self.add_function_persistent(code,function)\n finally:\n self.clear_module_directory()\n \n def add_function_persistent(self,code,function):\n \"\"\" Store the code->function relationship to disk.\n \n Two pieces of information are needed for loading functions\n from disk -- the function pickle (which conveniently stores\n the module name, etc.) and the path to its module's directory.\n The latter is needed so that the function can be loaded no\n matter what the user's Python path is.\n \"\"\" \n # add function to data in first writable catalog\n mode = 'c' # create if doesn't exist, otherwise, use existing\n cat_dir = self.get_writable_dir()\n cat = get_catalog(cat_dir,mode)\n if cat is None:\n cat_dir = default_dir()\n cat = get_catalog(cat_dir,mode)\n if cat is None:\n cat_dir = default_dir() \n cat_file = catalog_path(cat_dir)\n print 'problems with default catalog -- removing'\n import glob\n files = glob.glob(cat_file+'*')\n for f in files:\n os.remove(f)\n cat = get_catalog(cat_dir,mode)\n if cat is None:\n raise ValueError, 'Failed to access a catalog for storing functions' \n # Prabhu was getting some corrupt catalog errors. I'll put a try/except\n # to protect against this, but should really try and track down the issue.\n function_list = [function]\n try:\n function_list = function_list + cat.get(code,[])\n except pickle.UnpicklingError:\n pass\n cat[code] = function_list\n # now add needed path information for loading function\n module = getmodule(function)\n try:\n # built in modules don't have the __file__ extension, so this\n # will fail. Just pass in this case since path additions aren't\n # needed for built-in modules.\n mod_path,f=os.path.split(os.path.abspath(module.__file__))\n pkey = self.path_key(code)\n cat[pkey] = [mod_path] + cat.get(pkey,[])\n except:\n pass\n\n def fast_cache(self,code,function):\n \"\"\" Move function to the front of the cache entry for code\n \n If future calls to the function have the same type signature,\n this will speed up access significantly because the first\n function call is correct.\n \n Note: The cache added to the inline_tools module is significantly\n faster than always calling get_functions, so this isn't\n as necessary as it used to be. Still, it's probably worth\n doing. \n \"\"\"\n try:\n if self.cache[code][0] == function:\n return\n except: # KeyError, IndexError \n pass\n try:\n self.cache[code].remove(function)\n except ValueError:\n pass\n # put new function at the beginning of the list to search.\n self.cache[code].insert(0,function)\n \ndef test():\n from scipy_test import module_test\n module_test(__name__,__file__)\n\ndef test_suite():\n from scipy_test import module_test_suite\n return module_test_suite(__name__,__file__) \n",
"methods": [
{
"name": "getmodule",
"long_name": "getmodule( object )",
"filename": "catalog.py",
"nloc": 13,
"complexity": 7,
"token_count": 79,
"parameters": [
"object"
],
"start_line": 52,
"end_line": 77,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 26,
"top_nesting_level": 0
},
{
"name": "expr_to_filename",
"long_name": "expr_to_filename( expr )",
"filename": "catalog.py",
"nloc": 4,
"complexity": 1,
"token_count": 24,
"parameters": [
"expr"
],
"start_line": 79,
"end_line": 88,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 10,
"top_nesting_level": 0
},
{
"name": "unique_file",
"long_name": "unique_file( d , expr )",
"filename": "catalog.py",
"nloc": 13,
"complexity": 8,
"token_count": 89,
"parameters": [
"d",
"expr"
],
"start_line": 90,
"end_line": 112,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 23,
"top_nesting_level": 0
},
{
"name": "default_dir",
"long_name": "default_dir( )",
"filename": "catalog.py",
"nloc": 18,
"complexity": 5,
"token_count": 145,
"parameters": [],
"start_line": 114,
"end_line": 147,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 34,
"top_nesting_level": 0
},
{
"name": "intermediate_dir",
"long_name": "intermediate_dir( )",
"filename": "catalog.py",
"nloc": 7,
"complexity": 2,
"token_count": 56,
"parameters": [],
"start_line": 149,
"end_line": 158,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 10,
"top_nesting_level": 0
},
{
"name": "default_temp_dir",
"long_name": "default_temp_dir( )",
"filename": "catalog.py",
"nloc": 9,
"complexity": 3,
"token_count": 64,
"parameters": [],
"start_line": 160,
"end_line": 168,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 9,
"top_nesting_level": 0
},
{
"name": "os_dependent_catalog_name",
"long_name": "os_dependent_catalog_name( )",
"filename": "catalog.py",
"nloc": 3,
"complexity": 1,
"token_count": 24,
"parameters": [],
"start_line": 171,
"end_line": 183,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 13,
"top_nesting_level": 0
},
{
"name": "catalog_path",
"long_name": "catalog_path( module_path )",
"filename": "catalog.py",
"nloc": 12,
"complexity": 3,
"token_count": 105,
"parameters": [
"module_path"
],
"start_line": 185,
"end_line": 210,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 26,
"top_nesting_level": 0
},
{
"name": "get_catalog",
"long_name": "get_catalog( module_path , mode = 'r' )",
"filename": "catalog.py",
"nloc": 13,
"complexity": 6,
"token_count": 80,
"parameters": [
"module_path",
"mode"
],
"start_line": 212,
"end_line": 239,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 28,
"top_nesting_level": 0
},
{
"name": "__init__",
"long_name": "__init__( self , user_path_list = None )",
"filename": "catalog.py",
"nloc": 10,
"complexity": 3,
"token_count": 60,
"parameters": [
"self",
"user_path_list"
],
"start_line": 268,
"end_line": 283,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 16,
"top_nesting_level": 1
},
{
"name": "set_module_directory",
"long_name": "set_module_directory( self , module_dir )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 13,
"parameters": [
"self",
"module_dir"
],
"start_line": 285,
"end_line": 291,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 7,
"top_nesting_level": 1
},
{
"name": "get_module_directory",
"long_name": "get_module_directory( self )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 10,
"parameters": [
"self"
],
"start_line": 292,
"end_line": 295,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 1
},
{
"name": "clear_module_directory",
"long_name": "clear_module_directory( self )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 11,
"parameters": [
"self"
],
"start_line": 296,
"end_line": 299,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 1
},
{
"name": "get_environ_path",
"long_name": "get_environ_path( self )",
"filename": "catalog.py",
"nloc": 9,
"complexity": 3,
"token_count": 55,
"parameters": [
"self"
],
"start_line": 301,
"end_line": 315,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 15,
"top_nesting_level": 1
},
{
"name": "build_search_order",
"long_name": "build_search_order( self )",
"filename": "catalog.py",
"nloc": 11,
"complexity": 4,
"token_count": 62,
"parameters": [
"self"
],
"start_line": 317,
"end_line": 339,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 23,
"top_nesting_level": 1
},
{
"name": "get_catalog_files",
"long_name": "get_catalog_files( self )",
"filename": "catalog.py",
"nloc": 4,
"complexity": 1,
"token_count": 34,
"parameters": [
"self"
],
"start_line": 341,
"end_line": 350,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 10,
"top_nesting_level": 1
},
{
"name": "get_existing_files",
"long_name": "get_existing_files( self )",
"filename": "catalog.py",
"nloc": 7,
"complexity": 3,
"token_count": 48,
"parameters": [
"self"
],
"start_line": 352,
"end_line": 365,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 14,
"top_nesting_level": 1
},
{
"name": "get_writable_file.file_test",
"long_name": "get_writable_file.file_test( x )",
"filename": "catalog.py",
"nloc": 4,
"complexity": 3,
"token_count": 43,
"parameters": [
"x"
],
"start_line": 379,
"end_line": 382,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 2
},
{
"name": "get_writable_file",
"long_name": "get_writable_file( self , existing_only = 0 )",
"filename": "catalog.py",
"nloc": 12,
"complexity": 3,
"token_count": 55,
"parameters": [
"self",
"existing_only"
],
"start_line": 367,
"end_line": 388,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 22,
"top_nesting_level": 1
},
{
"name": "get_writable_dir",
"long_name": "get_writable_dir( self )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 19,
"parameters": [
"self"
],
"start_line": 390,
"end_line": 395,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 6,
"top_nesting_level": 1
},
{
"name": "unique_module_name",
"long_name": "unique_module_name( self , code , module_dir = None )",
"filename": "catalog.py",
"nloc": 9,
"complexity": 4,
"token_count": 53,
"parameters": [
"self",
"code",
"module_dir"
],
"start_line": 397,
"end_line": 412,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 16,
"top_nesting_level": 1
},
{
"name": "path_key",
"long_name": "path_key( self , code )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 12,
"parameters": [
"self",
"code"
],
"start_line": 414,
"end_line": 417,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 1
},
{
"name": "configure_path",
"long_name": "configure_path( self , cat , code )",
"filename": "catalog.py",
"nloc": 7,
"complexity": 2,
"token_count": 47,
"parameters": [
"self",
"cat",
"code"
],
"start_line": 419,
"end_line": 431,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 13,
"top_nesting_level": 1
},
{
"name": "unconfigure_path",
"long_name": "unconfigure_path( self )",
"filename": "catalog.py",
"nloc": 3,
"complexity": 1,
"token_count": 24,
"parameters": [
"self"
],
"start_line": 433,
"end_line": 439,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 7,
"top_nesting_level": 1
},
{
"name": "get_cataloged_functions",
"long_name": "get_cataloged_functions( self , code )",
"filename": "catalog.py",
"nloc": 15,
"complexity": 5,
"token_count": 86,
"parameters": [
"self",
"code"
],
"start_line": 441,
"end_line": 470,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 30,
"top_nesting_level": 1
},
{
"name": "repair_catalog",
"long_name": "repair_catalog( self , catalog_path , code )",
"filename": "catalog.py",
"nloc": 16,
"complexity": 5,
"token_count": 83,
"parameters": [
"self",
"catalog_path",
"code"
],
"start_line": 473,
"end_line": 503,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 31,
"top_nesting_level": 1
},
{
"name": "get_functions_fast",
"long_name": "get_functions_fast( self , code )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 20,
"parameters": [
"self",
"code"
],
"start_line": 505,
"end_line": 510,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 6,
"top_nesting_level": 1
},
{
"name": "get_functions",
"long_name": "get_functions( self , code , module_dir = None )",
"filename": "catalog.py",
"nloc": 11,
"complexity": 4,
"token_count": 65,
"parameters": [
"self",
"code",
"module_dir"
],
"start_line": 512,
"end_line": 544,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 33,
"top_nesting_level": 1
},
{
"name": "add_function",
"long_name": "add_function( self , code , function , module_dir = None )",
"filename": "catalog.py",
"nloc": 14,
"complexity": 4,
"token_count": 97,
"parameters": [
"self",
"code",
"function",
"module_dir"
],
"start_line": 546,
"end_line": 577,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 32,
"top_nesting_level": 1
},
{
"name": "add_function_persistent",
"long_name": "add_function_persistent( self , code , function )",
"filename": "catalog.py",
"nloc": 31,
"complexity": 7,
"token_count": 194,
"parameters": [
"self",
"code",
"function"
],
"start_line": 579,
"end_line": 624,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 46,
"top_nesting_level": 1
},
{
"name": "fast_cache",
"long_name": "fast_cache( self , code , function )",
"filename": "catalog.py",
"nloc": 11,
"complexity": 4,
"token_count": 59,
"parameters": [
"self",
"code",
"function"
],
"start_line": 626,
"end_line": 648,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 23,
"top_nesting_level": 1
},
{
"name": "test",
"long_name": "test( )",
"filename": "catalog.py",
"nloc": 3,
"complexity": 1,
"token_count": 14,
"parameters": [],
"start_line": 650,
"end_line": 652,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 3,
"top_nesting_level": 0
},
{
"name": "test_suite",
"long_name": "test_suite( )",
"filename": "catalog.py",
"nloc": 3,
"complexity": 1,
"token_count": 15,
"parameters": [],
"start_line": 654,
"end_line": 656,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 3,
"top_nesting_level": 0
}
],
"methods_before": [
{
"name": "getmodule",
"long_name": "getmodule( object )",
"filename": "catalog.py",
"nloc": 13,
"complexity": 7,
"token_count": 79,
"parameters": [
"object"
],
"start_line": 52,
"end_line": 77,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 26,
"top_nesting_level": 0
},
{
"name": "expr_to_filename",
"long_name": "expr_to_filename( expr )",
"filename": "catalog.py",
"nloc": 4,
"complexity": 1,
"token_count": 24,
"parameters": [
"expr"
],
"start_line": 79,
"end_line": 88,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 10,
"top_nesting_level": 0
},
{
"name": "unique_file",
"long_name": "unique_file( d , expr )",
"filename": "catalog.py",
"nloc": 13,
"complexity": 8,
"token_count": 89,
"parameters": [
"d",
"expr"
],
"start_line": 90,
"end_line": 112,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 23,
"top_nesting_level": 0
},
{
"name": "default_dir",
"long_name": "default_dir( )",
"filename": "catalog.py",
"nloc": 18,
"complexity": 5,
"token_count": 145,
"parameters": [],
"start_line": 114,
"end_line": 147,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 34,
"top_nesting_level": 0
},
{
"name": "intermediate_dir",
"long_name": "intermediate_dir( )",
"filename": "catalog.py",
"nloc": 7,
"complexity": 2,
"token_count": 56,
"parameters": [],
"start_line": 149,
"end_line": 158,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 10,
"top_nesting_level": 0
},
{
"name": "default_temp_dir",
"long_name": "default_temp_dir( )",
"filename": "catalog.py",
"nloc": 9,
"complexity": 3,
"token_count": 64,
"parameters": [],
"start_line": 160,
"end_line": 168,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 9,
"top_nesting_level": 0
},
{
"name": "os_dependent_catalog_name",
"long_name": "os_dependent_catalog_name( )",
"filename": "catalog.py",
"nloc": 3,
"complexity": 1,
"token_count": 24,
"parameters": [],
"start_line": 171,
"end_line": 183,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 13,
"top_nesting_level": 0
},
{
"name": "catalog_path",
"long_name": "catalog_path( module_path )",
"filename": "catalog.py",
"nloc": 12,
"complexity": 3,
"token_count": 105,
"parameters": [
"module_path"
],
"start_line": 185,
"end_line": 210,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 26,
"top_nesting_level": 0
},
{
"name": "get_catalog",
"long_name": "get_catalog( module_path , mode = 'r' )",
"filename": "catalog.py",
"nloc": 13,
"complexity": 6,
"token_count": 80,
"parameters": [
"module_path",
"mode"
],
"start_line": 212,
"end_line": 239,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 28,
"top_nesting_level": 0
},
{
"name": "__init__",
"long_name": "__init__( self , user_path_list = None )",
"filename": "catalog.py",
"nloc": 10,
"complexity": 3,
"token_count": 60,
"parameters": [
"self",
"user_path_list"
],
"start_line": 268,
"end_line": 283,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 16,
"top_nesting_level": 1
},
{
"name": "set_module_directory",
"long_name": "set_module_directory( self , module_dir )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 13,
"parameters": [
"self",
"module_dir"
],
"start_line": 285,
"end_line": 291,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 7,
"top_nesting_level": 1
},
{
"name": "get_module_directory",
"long_name": "get_module_directory( self )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 10,
"parameters": [
"self"
],
"start_line": 292,
"end_line": 295,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 1
},
{
"name": "clear_module_directory",
"long_name": "clear_module_directory( self )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 11,
"parameters": [
"self"
],
"start_line": 296,
"end_line": 299,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 1
},
{
"name": "get_environ_path",
"long_name": "get_environ_path( self )",
"filename": "catalog.py",
"nloc": 9,
"complexity": 3,
"token_count": 55,
"parameters": [
"self"
],
"start_line": 301,
"end_line": 315,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 15,
"top_nesting_level": 1
},
{
"name": "build_search_order",
"long_name": "build_search_order( self )",
"filename": "catalog.py",
"nloc": 11,
"complexity": 4,
"token_count": 62,
"parameters": [
"self"
],
"start_line": 317,
"end_line": 339,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 23,
"top_nesting_level": 1
},
{
"name": "get_catalog_files",
"long_name": "get_catalog_files( self )",
"filename": "catalog.py",
"nloc": 4,
"complexity": 1,
"token_count": 34,
"parameters": [
"self"
],
"start_line": 341,
"end_line": 350,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 10,
"top_nesting_level": 1
},
{
"name": "get_existing_files",
"long_name": "get_existing_files( self )",
"filename": "catalog.py",
"nloc": 7,
"complexity": 3,
"token_count": 48,
"parameters": [
"self"
],
"start_line": 352,
"end_line": 365,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 14,
"top_nesting_level": 1
},
{
"name": "get_writable_file.file_test",
"long_name": "get_writable_file.file_test( x )",
"filename": "catalog.py",
"nloc": 4,
"complexity": 3,
"token_count": 43,
"parameters": [
"x"
],
"start_line": 379,
"end_line": 382,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 2
},
{
"name": "get_writable_file",
"long_name": "get_writable_file( self , existing_only = 0 )",
"filename": "catalog.py",
"nloc": 12,
"complexity": 3,
"token_count": 55,
"parameters": [
"self",
"existing_only"
],
"start_line": 367,
"end_line": 388,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 22,
"top_nesting_level": 1
},
{
"name": "get_writable_dir",
"long_name": "get_writable_dir( self )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 19,
"parameters": [
"self"
],
"start_line": 390,
"end_line": 395,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 6,
"top_nesting_level": 1
},
{
"name": "unique_module_name",
"long_name": "unique_module_name( self , code , module_dir = None )",
"filename": "catalog.py",
"nloc": 9,
"complexity": 4,
"token_count": 53,
"parameters": [
"self",
"code",
"module_dir"
],
"start_line": 397,
"end_line": 412,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 16,
"top_nesting_level": 1
},
{
"name": "path_key",
"long_name": "path_key( self , code )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 12,
"parameters": [
"self",
"code"
],
"start_line": 414,
"end_line": 417,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 1
},
{
"name": "configure_path",
"long_name": "configure_path( self , cat , code )",
"filename": "catalog.py",
"nloc": 7,
"complexity": 2,
"token_count": 47,
"parameters": [
"self",
"cat",
"code"
],
"start_line": 419,
"end_line": 431,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 13,
"top_nesting_level": 1
},
{
"name": "unconfigure_path",
"long_name": "unconfigure_path( self )",
"filename": "catalog.py",
"nloc": 3,
"complexity": 1,
"token_count": 24,
"parameters": [
"self"
],
"start_line": 433,
"end_line": 439,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 7,
"top_nesting_level": 1
},
{
"name": "get_cataloged_functions",
"long_name": "get_cataloged_functions( self , code )",
"filename": "catalog.py",
"nloc": 15,
"complexity": 5,
"token_count": 86,
"parameters": [
"self",
"code"
],
"start_line": 441,
"end_line": 470,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 30,
"top_nesting_level": 1
},
{
"name": "repair_catalog",
"long_name": "repair_catalog( self , catalog_path , code )",
"filename": "catalog.py",
"nloc": 16,
"complexity": 5,
"token_count": 83,
"parameters": [
"self",
"catalog_path",
"code"
],
"start_line": 473,
"end_line": 503,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 31,
"top_nesting_level": 1
},
{
"name": "get_functions_fast",
"long_name": "get_functions_fast( self , code )",
"filename": "catalog.py",
"nloc": 2,
"complexity": 1,
"token_count": 20,
"parameters": [
"self",
"code"
],
"start_line": 505,
"end_line": 510,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 6,
"top_nesting_level": 1
},
{
"name": "get_functions",
"long_name": "get_functions( self , code , module_dir = None )",
"filename": "catalog.py",
"nloc": 11,
"complexity": 4,
"token_count": 65,
"parameters": [
"self",
"code",
"module_dir"
],
"start_line": 512,
"end_line": 544,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 33,
"top_nesting_level": 1
},
{
"name": "add_function",
"long_name": "add_function( self , code , function , module_dir = None )",
"filename": "catalog.py",
"nloc": 14,
"complexity": 4,
"token_count": 97,
"parameters": [
"self",
"code",
"function",
"module_dir"
],
"start_line": 546,
"end_line": 577,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 32,
"top_nesting_level": 1
},
{
"name": "add_function_persistent",
"long_name": "add_function_persistent( self , code , function )",
"filename": "catalog.py",
"nloc": 31,
"complexity": 7,
"token_count": 194,
"parameters": [
"self",
"code",
"function"
],
"start_line": 579,
"end_line": 624,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 46,
"top_nesting_level": 1
},
{
"name": "fast_cache",
"long_name": "fast_cache( self , code , function )",
"filename": "catalog.py",
"nloc": 11,
"complexity": 4,
"token_count": 59,
"parameters": [
"self",
"code",
"function"
],
"start_line": 626,
"end_line": 648,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 23,
"top_nesting_level": 1
},
{
"name": "test",
"long_name": "test( )",
"filename": "catalog.py",
"nloc": 3,
"complexity": 1,
"token_count": 14,
"parameters": [],
"start_line": 650,
"end_line": 652,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 3,
"top_nesting_level": 0
},
{
"name": "test_suite",
"long_name": "test_suite( )",
"filename": "catalog.py",
"nloc": 3,
"complexity": 1,
"token_count": 15,
"parameters": [],
"start_line": 654,
"end_line": 656,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 3,
"top_nesting_level": 0
}
],
"changed_methods": [],
"nloc": 351,
"complexity": 100,
"token_count": 1908,
"diff_parsed": {
"added": [
" dumb = 1"
],
"deleted": [
" dumb == 1"
]
}
}
]
},
{
"hash": "5472eedf02fd8647ad3dfc246c1a65388ceb907a",
"msg": "added a couple of implementations using lists instead of Numeric arrays. They are very slow.",
"author": {
"name": "Eric Jones",
"email": "eric@enthought.com"
},
"committer": {
"name": "Eric Jones",
"email": "eric@enthought.com"
},
"author_date": "2002-01-15T21:39:59+00:00",
"author_timezone": 0,
"committer_date": "2002-01-15T21:39:59+00:00",
"committer_timezone": 0,
"branches": [
"main"
],
"in_main_branch": true,
"merge": false,
"parents": [
"68b8d1007e6b92f3fb4c218196a384c86039598d"
],
"project_name": "repo_copy",
"project_path": "/tmp/tmp55a0ktwg/repo_copy",
"deletions": 7,
"insertions": 73,
"lines": 80,
"files": 1,
"dmm_unit_size": 0.55,
"dmm_unit_complexity": 0.0,
"dmm_unit_interfacing": 0.45,
"modified_files": [
{
"old_path": "weave/examples/ramp.py",
"new_path": "weave/examples/ramp.py",
"filename": "ramp.py",
"extension": "py",
"change_type": "MODIFY",
"diff": "@@ -1,3 +1,20 @@\n+\"\"\" Comparison of several different ways of calculating a \"ramp\"\n+ function.\n+ \n+ C:\\home\\ej\\wrk\\junk\\scipy\\weave\\examples>python ramp.py \n+ python (seconds*ratio): 128.149998188\n+ arr[500]: 0.0500050005001\n+ compiled numeric1 (seconds, speed up): 1.42199993134 90.1195530071\n+ arr[500]: 0.0500050005001\n+ compiled numeric2 (seconds, speed up): 0.950999975204 134.752893301\n+ arr[500]: 0.0500050005001\n+ compiled list1 (seconds, speed up): 53.100001812 2.41337088164\n+ arr[500]: 0.0500050005001\n+ compiled list4 (seconds, speed up): 30.5500030518 4.19476220578\n+ arr[500]: 0.0500050005001 \n+\n+\"\"\"\n+\n import time\n import weave\n from Numeric import *\n@@ -27,6 +44,30 @@ def Ramp_numeric2(result,size,start,end):\n }\n \"\"\"\n weave.inline(code,['result','size','start','end'],compiler='gcc')\n+\n+def Ramp_list1(result, size, start, end):\n+ code = \"\"\"\n+ double step = (end-start)/(size-1);\n+ int i; \n+ for (i = 0; i < size; i++) \n+ {\n+ result[i] = Py::Float(start + step*i);\n+ }\n+ \"\"\"\n+ weave.inline(code, [\"result\", \"size\", \"start\", \"end\"], verbose=2)\n+\n+def Ramp_list2(result, size, start, end):\n+ code = \"\"\"\n+ double step = (end-start)/(size-1);\n+ int i;\n+ PyObject* raw_result = result.ptr();\n+ for (i = 0; i < size; i++) \n+ {\n+ PyObject* val = PyFloat_FromDouble( start + step*i );\n+ PySequence_SetItem(raw_result,i, val);\n+ }\n+ \"\"\"\n+ weave.inline(code, [\"result\", \"size\", \"start\", \"end\"], verbose=2)\n \n def main():\n N_array = 10000\n@@ -44,29 +85,54 @@ def main():\n print 'python (seconds*ratio):', py_time\n print 'arr[500]:', arr[500]\n \n- arr = array([0]*N_array,Float64)\n+ arr1 = array([0]*N_array,Float64)\n # First call compiles function or loads from cache.\n # I'm not including this in the timing.\n- Ramp_numeric1(arr, N_array, 0.0, 1.0)\n+ Ramp_numeric1(arr1, N_array, 0.0, 1.0)\n t1 = time.time()\n for i in xrange(N_c):\n- Ramp_numeric1(arr, N_array, 0.0, 1.0)\n+ Ramp_numeric1(arr1, N_array, 0.0, 1.0)\n t2 = time.time()\n c_time = (t2 - t1)\n print 'compiled numeric1 (seconds, speed up):', c_time, py_time/ c_time\n- print 'arr[500]:', arr[500]\n+ print 'arr[500]:', arr1[500]\n \n arr2 = array([0]*N_array,Float64)\n # First call compiles function or loads from cache.\n # I'm not including this in the timing.\n- Ramp_numeric2(arr, N_array, 0.0, 1.0)\n+ Ramp_numeric2(arr2, N_array, 0.0, 1.0)\n t1 = time.time()\n for i in xrange(N_c):\n- Ramp_numeric2(arr, N_array, 0.0, 1.0)\n+ Ramp_numeric2(arr2, N_array, 0.0, 1.0)\n t2 = time.time()\n c_time = (t2 - t1) \n print 'compiled numeric2 (seconds, speed up):', c_time, py_time/ c_time\n- print 'arr[500]:', arr[500]\n+ print 'arr[500]:', arr2[500]\n+\n+ arr3 = [0]*N_array\n+ # First call compiles function or loads from cache.\n+ # I'm not including this in the timing.\n+ Ramp_list1(arr3, N_array, 0.0, 1.0)\n+ t1 = time.time()\n+ for i in xrange(N_py):\n+ Ramp_list1(arr3, N_array, 0.0, 1.0)\n+ t2 = time.time()\n+ c_time = (t2 - t1) * ratio \n+ print 'compiled list1 (seconds, speed up):', c_time, py_time/ c_time\n+ print 'arr[500]:', arr3[500]\n+ \n+ arr4 = [0]*N_array\n+ # First call compiles function or loads from cache.\n+ # I'm not including this in the timing.\n+ Ramp_list2(arr4, N_array, 0.0, 1.0)\n+ t1 = time.time()\n+ for i in xrange(N_py):\n+ Ramp_list2(arr4, N_array, 0.0, 1.0)\n+ t2 = time.time()\n+ c_time = (t2 - t1) * ratio \n+ print 'compiled list4 (seconds, speed up):', c_time, py_time/ c_time\n+ print 'arr[500]:', arr4[500]\n+ \n \n if __name__ == '__main__':\n main()\n\\ No newline at end of file\n",
"added_lines": 73,
"deleted_lines": 7,
"source_code": "\"\"\" Comparison of several different ways of calculating a \"ramp\"\n function.\n \n C:\\home\\ej\\wrk\\junk\\scipy\\weave\\examples>python ramp.py \n python (seconds*ratio): 128.149998188\n arr[500]: 0.0500050005001\n compiled numeric1 (seconds, speed up): 1.42199993134 90.1195530071\n arr[500]: 0.0500050005001\n compiled numeric2 (seconds, speed up): 0.950999975204 134.752893301\n arr[500]: 0.0500050005001\n compiled list1 (seconds, speed up): 53.100001812 2.41337088164\n arr[500]: 0.0500050005001\n compiled list4 (seconds, speed up): 30.5500030518 4.19476220578\n arr[500]: 0.0500050005001 \n\n\"\"\"\n\nimport time\nimport weave\nfrom Numeric import *\n\ndef Ramp(result, size, start, end):\n step = (end-start)/(size-1)\n for i in xrange(size):\n result[i] = start + step*i\n\ndef Ramp_numeric1(result,size,start,end):\n code = \"\"\"\n double step = (end-start)/(size-1);\n double val = start;\n for (int i = 0; i < size; i++)\n *result_data++ = start + step*i;\n \"\"\"\n weave.inline(code,['result','size','start','end'],compiler='gcc')\n\ndef Ramp_numeric2(result,size,start,end):\n code = \"\"\"\n double step = (end-start)/(size-1);\n double val = start;\n for (int i = 0; i < size; i++)\n {\n result_data[i] = val;\n val += step; \n }\n \"\"\"\n weave.inline(code,['result','size','start','end'],compiler='gcc')\n\ndef Ramp_list1(result, size, start, end):\n code = \"\"\"\n double step = (end-start)/(size-1);\n int i; \n for (i = 0; i < size; i++) \n {\n result[i] = Py::Float(start + step*i);\n }\n \"\"\"\n weave.inline(code, [\"result\", \"size\", \"start\", \"end\"], verbose=2)\n\ndef Ramp_list2(result, size, start, end):\n code = \"\"\"\n double step = (end-start)/(size-1);\n int i;\n PyObject* raw_result = result.ptr();\n for (i = 0; i < size; i++) \n {\n PyObject* val = PyFloat_FromDouble( start + step*i );\n PySequence_SetItem(raw_result,i, val);\n }\n \"\"\"\n weave.inline(code, [\"result\", \"size\", \"start\", \"end\"], verbose=2)\n \ndef main():\n N_array = 10000\n N_py = 200\n N_c = 10000\n \n ratio = float(N_c) / N_py \n \n arr = [0]*N_array\n t1 = time.time()\n for i in xrange(N_py):\n Ramp(arr, N_array, 0.0, 1.0)\n t2 = time.time()\n py_time = (t2 - t1) * ratio\n print 'python (seconds*ratio):', py_time\n print 'arr[500]:', arr[500]\n \n arr1 = array([0]*N_array,Float64)\n # First call compiles function or loads from cache.\n # I'm not including this in the timing.\n Ramp_numeric1(arr1, N_array, 0.0, 1.0)\n t1 = time.time()\n for i in xrange(N_c):\n Ramp_numeric1(arr1, N_array, 0.0, 1.0)\n t2 = time.time()\n c_time = (t2 - t1)\n print 'compiled numeric1 (seconds, speed up):', c_time, py_time/ c_time\n print 'arr[500]:', arr1[500]\n\n arr2 = array([0]*N_array,Float64)\n # First call compiles function or loads from cache.\n # I'm not including this in the timing.\n Ramp_numeric2(arr2, N_array, 0.0, 1.0)\n t1 = time.time()\n for i in xrange(N_c):\n Ramp_numeric2(arr2, N_array, 0.0, 1.0)\n t2 = time.time()\n c_time = (t2 - t1) \n print 'compiled numeric2 (seconds, speed up):', c_time, py_time/ c_time\n print 'arr[500]:', arr2[500]\n\n arr3 = [0]*N_array\n # First call compiles function or loads from cache.\n # I'm not including this in the timing.\n Ramp_list1(arr3, N_array, 0.0, 1.0)\n t1 = time.time()\n for i in xrange(N_py):\n Ramp_list1(arr3, N_array, 0.0, 1.0)\n t2 = time.time()\n c_time = (t2 - t1) * ratio \n print 'compiled list1 (seconds, speed up):', c_time, py_time/ c_time\n print 'arr[500]:', arr3[500]\n \n arr4 = [0]*N_array\n # First call compiles function or loads from cache.\n # I'm not including this in the timing.\n Ramp_list2(arr4, N_array, 0.0, 1.0)\n t1 = time.time()\n for i in xrange(N_py):\n Ramp_list2(arr4, N_array, 0.0, 1.0)\n t2 = time.time()\n c_time = (t2 - t1) * ratio \n print 'compiled list4 (seconds, speed up):', c_time, py_time/ c_time\n print 'arr[500]:', arr4[500]\n \n \nif __name__ == '__main__':\n main()",
"source_code_before": "import time\nimport weave\nfrom Numeric import *\n\ndef Ramp(result, size, start, end):\n step = (end-start)/(size-1)\n for i in xrange(size):\n result[i] = start + step*i\n\ndef Ramp_numeric1(result,size,start,end):\n code = \"\"\"\n double step = (end-start)/(size-1);\n double val = start;\n for (int i = 0; i < size; i++)\n *result_data++ = start + step*i;\n \"\"\"\n weave.inline(code,['result','size','start','end'],compiler='gcc')\n\ndef Ramp_numeric2(result,size,start,end):\n code = \"\"\"\n double step = (end-start)/(size-1);\n double val = start;\n for (int i = 0; i < size; i++)\n {\n result_data[i] = val;\n val += step; \n }\n \"\"\"\n weave.inline(code,['result','size','start','end'],compiler='gcc')\n \ndef main():\n N_array = 10000\n N_py = 200\n N_c = 10000\n \n ratio = float(N_c) / N_py \n \n arr = [0]*N_array\n t1 = time.time()\n for i in xrange(N_py):\n Ramp(arr, N_array, 0.0, 1.0)\n t2 = time.time()\n py_time = (t2 - t1) * ratio\n print 'python (seconds*ratio):', py_time\n print 'arr[500]:', arr[500]\n \n arr = array([0]*N_array,Float64)\n # First call compiles function or loads from cache.\n # I'm not including this in the timing.\n Ramp_numeric1(arr, N_array, 0.0, 1.0)\n t1 = time.time()\n for i in xrange(N_c):\n Ramp_numeric1(arr, N_array, 0.0, 1.0)\n t2 = time.time()\n c_time = (t2 - t1)\n print 'compiled numeric1 (seconds, speed up):', c_time, py_time/ c_time\n print 'arr[500]:', arr[500]\n\n arr2 = array([0]*N_array,Float64)\n # First call compiles function or loads from cache.\n # I'm not including this in the timing.\n Ramp_numeric2(arr, N_array, 0.0, 1.0)\n t1 = time.time()\n for i in xrange(N_c):\n Ramp_numeric2(arr, N_array, 0.0, 1.0)\n t2 = time.time()\n c_time = (t2 - t1) \n print 'compiled numeric2 (seconds, speed up):', c_time, py_time/ c_time\n print 'arr[500]:', arr[500]\n \nif __name__ == '__main__':\n main()",
"methods": [
{
"name": "Ramp",
"long_name": "Ramp( result , size , start , end )",
"filename": "ramp.py",
"nloc": 4,
"complexity": 2,
"token_count": 42,
"parameters": [
"result",
"size",
"start",
"end"
],
"start_line": 22,
"end_line": 25,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 0
},
{
"name": "Ramp_numeric1",
"long_name": "Ramp_numeric1( result , size , start , end )",
"filename": "ramp.py",
"nloc": 8,
"complexity": 1,
"token_count": 34,
"parameters": [
"result",
"size",
"start",
"end"
],
"start_line": 27,
"end_line": 34,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 8,
"top_nesting_level": 0
},
{
"name": "Ramp_numeric2",
"long_name": "Ramp_numeric2( result , size , start , end )",
"filename": "ramp.py",
"nloc": 11,
"complexity": 1,
"token_count": 34,
"parameters": [
"result",
"size",
"start",
"end"
],
"start_line": 36,
"end_line": 46,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 11,
"top_nesting_level": 0
},
{
"name": "Ramp_list1",
"long_name": "Ramp_list1( result , size , start , end )",
"filename": "ramp.py",
"nloc": 10,
"complexity": 1,
"token_count": 34,
"parameters": [
"result",
"size",
"start",
"end"
],
"start_line": 48,
"end_line": 57,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 10,
"top_nesting_level": 0
},
{
"name": "Ramp_list2",
"long_name": "Ramp_list2( result , size , start , end )",
"filename": "ramp.py",
"nloc": 12,
"complexity": 1,
"token_count": 34,
"parameters": [
"result",
"size",
"start",
"end"
],
"start_line": 59,
"end_line": 70,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 12,
"top_nesting_level": 0
},
{
"name": "main",
"long_name": "main( )",
"filename": "ramp.py",
"nloc": 49,
"complexity": 6,
"token_count": 414,
"parameters": [],
"start_line": 72,
"end_line": 134,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 63,
"top_nesting_level": 0
}
],
"methods_before": [
{
"name": "Ramp",
"long_name": "Ramp( result , size , start , end )",
"filename": "ramp.py",
"nloc": 4,
"complexity": 2,
"token_count": 42,
"parameters": [
"result",
"size",
"start",
"end"
],
"start_line": 5,
"end_line": 8,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 0
},
{
"name": "Ramp_numeric1",
"long_name": "Ramp_numeric1( result , size , start , end )",
"filename": "ramp.py",
"nloc": 8,
"complexity": 1,
"token_count": 34,
"parameters": [
"result",
"size",
"start",
"end"
],
"start_line": 10,
"end_line": 17,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 8,
"top_nesting_level": 0
},
{
"name": "Ramp_numeric2",
"long_name": "Ramp_numeric2( result , size , start , end )",
"filename": "ramp.py",
"nloc": 11,
"complexity": 1,
"token_count": 34,
"parameters": [
"result",
"size",
"start",
"end"
],
"start_line": 19,
"end_line": 29,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 11,
"top_nesting_level": 0
},
{
"name": "main",
"long_name": "main( )",
"filename": "ramp.py",
"nloc": 31,
"complexity": 4,
"token_count": 252,
"parameters": [],
"start_line": 31,
"end_line": 69,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 39,
"top_nesting_level": 0
}
],
"changed_methods": [
{
"name": "Ramp_list2",
"long_name": "Ramp_list2( result , size , start , end )",
"filename": "ramp.py",
"nloc": 12,
"complexity": 1,
"token_count": 34,
"parameters": [
"result",
"size",
"start",
"end"
],
"start_line": 59,
"end_line": 70,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 12,
"top_nesting_level": 0
},
{
"name": "main",
"long_name": "main( )",
"filename": "ramp.py",
"nloc": 49,
"complexity": 6,
"token_count": 414,
"parameters": [],
"start_line": 72,
"end_line": 134,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 63,
"top_nesting_level": 0
},
{
"name": "Ramp_list1",
"long_name": "Ramp_list1( result , size , start , end )",
"filename": "ramp.py",
"nloc": 10,
"complexity": 1,
"token_count": 34,
"parameters": [
"result",
"size",
"start",
"end"
],
"start_line": 48,
"end_line": 57,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 10,
"top_nesting_level": 0
}
],
"nloc": 115,
"complexity": 12,
"token_count": 615,
"diff_parsed": {
"added": [
"\"\"\" Comparison of several different ways of calculating a \"ramp\"",
" function.",
"",
" C:\\home\\ej\\wrk\\junk\\scipy\\weave\\examples>python ramp.py",
" python (seconds*ratio): 128.149998188",
" arr[500]: 0.0500050005001",
" compiled numeric1 (seconds, speed up): 1.42199993134 90.1195530071",
" arr[500]: 0.0500050005001",
" compiled numeric2 (seconds, speed up): 0.950999975204 134.752893301",
" arr[500]: 0.0500050005001",
" compiled list1 (seconds, speed up): 53.100001812 2.41337088164",
" arr[500]: 0.0500050005001",
" compiled list4 (seconds, speed up): 30.5500030518 4.19476220578",
" arr[500]: 0.0500050005001",
"",
"\"\"\"",
"",
"",
"def Ramp_list1(result, size, start, end):",
" code = \"\"\"",
" double step = (end-start)/(size-1);",
" int i;",
" for (i = 0; i < size; i++)",
" {",
" result[i] = Py::Float(start + step*i);",
" }",
" \"\"\"",
" weave.inline(code, [\"result\", \"size\", \"start\", \"end\"], verbose=2)",
"",
"def Ramp_list2(result, size, start, end):",
" code = \"\"\"",
" double step = (end-start)/(size-1);",
" int i;",
" PyObject* raw_result = result.ptr();",
" for (i = 0; i < size; i++)",
" {",
" PyObject* val = PyFloat_FromDouble( start + step*i );",
" PySequence_SetItem(raw_result,i, val);",
" }",
" \"\"\"",
" weave.inline(code, [\"result\", \"size\", \"start\", \"end\"], verbose=2)",
" arr1 = array([0]*N_array,Float64)",
" Ramp_numeric1(arr1, N_array, 0.0, 1.0)",
" Ramp_numeric1(arr1, N_array, 0.0, 1.0)",
" print 'arr[500]:', arr1[500]",
" Ramp_numeric2(arr2, N_array, 0.0, 1.0)",
" Ramp_numeric2(arr2, N_array, 0.0, 1.0)",
" print 'arr[500]:', arr2[500]",
"",
" arr3 = [0]*N_array",
" # First call compiles function or loads from cache.",
" # I'm not including this in the timing.",
" Ramp_list1(arr3, N_array, 0.0, 1.0)",
" t1 = time.time()",
" for i in xrange(N_py):",
" Ramp_list1(arr3, N_array, 0.0, 1.0)",
" t2 = time.time()",
" c_time = (t2 - t1) * ratio",
" print 'compiled list1 (seconds, speed up):', c_time, py_time/ c_time",
" print 'arr[500]:', arr3[500]",
"",
" arr4 = [0]*N_array",
" # First call compiles function or loads from cache.",
" # I'm not including this in the timing.",
" Ramp_list2(arr4, N_array, 0.0, 1.0)",
" t1 = time.time()",
" for i in xrange(N_py):",
" Ramp_list2(arr4, N_array, 0.0, 1.0)",
" t2 = time.time()",
" c_time = (t2 - t1) * ratio",
" print 'compiled list4 (seconds, speed up):', c_time, py_time/ c_time",
" print 'arr[500]:', arr4[500]",
""
],
"deleted": [
" arr = array([0]*N_array,Float64)",
" Ramp_numeric1(arr, N_array, 0.0, 1.0)",
" Ramp_numeric1(arr, N_array, 0.0, 1.0)",
" print 'arr[500]:', arr[500]",
" Ramp_numeric2(arr, N_array, 0.0, 1.0)",
" Ramp_numeric2(arr, N_array, 0.0, 1.0)",
" print 'arr[500]:', arr[500]"
]
}
}
]
},
{
"hash": "653df5af033fd2514869639131074f58c68a2f38",
"msg": "patched an error in the string printing section -- forgot to convert from Py::String to a char*.",
"author": {
"name": "Eric Jones",
"email": "eric@enthought.com"
},
"committer": {
"name": "Eric Jones",
"email": "eric@enthought.com"
},
"author_date": "2002-01-15T21:51:56+00:00",
"author_timezone": 0,
"committer_date": "2002-01-15T21:51:56+00:00",
"committer_timezone": 0,
"branches": [
"main"
],
"in_main_branch": true,
"merge": false,
"parents": [
"5472eedf02fd8647ad3dfc246c1a65388ceb907a"
],
"project_name": "repo_copy",
"project_path": "/tmp/tmp55a0ktwg/repo_copy",
"deletions": 3,
"insertions": 11,
"lines": 14,
"files": 1,
"dmm_unit_size": null,
"dmm_unit_complexity": null,
"dmm_unit_interfacing": null,
"modified_files": [
{
"old_path": "weave/doc/tutorial.html",
"new_path": "weave/doc/tutorial.html",
"filename": "tutorial.html",
"extension": "html",
"change_type": "MODIFY",
"diff": "@@ -499,13 +499,21 @@ More with printf
\n \n \n \n-For printing strings, the format statement needs to be changed.\n+For printing strings, the format statement needs to be changed. Also, weave\n+doesn't convert strings to char*. Instead it uses CXX Py::String type, so \n+you have to do a little more work. Here we convert it to a C++ std::string\n+and then ask cor the char* version.\n \n
\n- >>> a = 'string'\n- >>> weave.inline(r'printf(\"%s\\n\",a);',['a'])\n+ >>> a = 'string' \n+ >>> weave.inline(r'printf(\"%s\\n\",std::string(a).c_str());',['a'])\n string\n
\n+\n+ \n+This is a little convoluted. Perhaps strings should convert to std::string\n+objects instead of CXX objects. Or maybe to char*.\n+\n \n
\n As in this case, C/C++ code fragments often have to change to accept different \n",
"added_lines": 11,
"deleted_lines": 3,
"source_code": "\n
Weave Documentation
\n\nBy Eric Jones eric@enthought.com\n
\n
Outline
\n \n- Introduction\n
- Requirements\n
- Installation\n
- Testing\n
- Benchmarks\n
- Inline\n
\n - More with printf\n
- \n More examples\n \n
- Keyword options\n
- Returning values\n \n
- A quick look at the code\n
- \n Technical Details\n \n
\n
\n- Blitz\n
\n - Requirements\n
- Limitations\n
- Numeric Efficiency Issues\n
- The Tools \n
\n - Parser\n
- Blitz and Numeric\n
\n - Type defintions and coersion\n
- Cataloging Compiled Functions\n
- Checking Array Sizes\n
- Creating the Extension Module\n
\n- Extension Modules\n \n
- Customizing Type Conversions -- Type Factories (not written)\n
\n - Type Specifications\n
- Type Information\n
- The Conversion Process \n
\n
\n\nIntroduction
\n\n\nThe weave package provides tools for including C/C++ code within\nin Python code. This offers both another level of optimization to those who need \nit, and an easy way to modify and extend any supported extension libraries such \nas wxPython and hopefully VTK soon. Inlining C/C++ code within Python generally\nresults in speed ups of 1.5x to 30x speed-up over algorithms written in pure\nPython (However, it is also possible to slow things down...). Generally \nalgorithms that require a large number of calls to the Python API don't benefit\nas much from the conversion to C/C++ as algorithms that have inner loops \ncompletely convertable to C.\n
\nThere are three basic ways to use weave. The \nweave.inline() function executes C code directly within Python, \nand weave.blitz() translates Python Numeric expressions to C++ \nfor fast execution. blitz() was the original reason \nweave was built. For those interested in building extension\nlibraries, the ext_tools module provides classes for building \nextension modules within Python. \n
\nMost of weave's functionality should work on Windows and Unix, \nalthough some of its functionality requires gcc or a similarly \nmodern C++ compiler that handles templates well. Up to now, most testing has \nbeen done on Windows 2000 with Microsoft's C++ compiler (MSVC) and with gcc \n(mingw32 2.95.2 and 2.95.3-6). All tests also pass on Linux (RH 7.1 \nwith gcc 2.96), and I've had reports that it works on Debian also (thanks \nPearu).\n
\nThe inline and blitz provide new functionality to \nPython (although I've recently learned about the PyInline project which may offer \nsimilar functionality to inline). On the other hand, tools for \nbuilding Python extension modules already exists (SWIG, SIP, pycpp, CXX, and \nothers). As of yet, I'm not sure where weave fits in this \nspectrum. It is closest in flavor to CXX in that it makes creating new C/C++ \nextension modules pretty easy. However, if you're wrapping a gaggle of legacy \nfunctions or classes, SWIG and friends are definitely the better choice. \nweave is set up so that you can customize how Python types are \nconverted to C types in weave. This is great for \ninline(), but, for wrapping legacy code, it is more flexible to \nspecify things the other way around -- that is how C types map to Python types. \nThis weave does not do. I guess it would be possible to build \nsuch a tool on top of weave, but with good tools like SWIG around, \nI'm not sure the effort produces any new capabilities. Things like function \noverloading are probably easily implemented in weave and it might \nbe easier to mix Python/C code in function calls, but nothing beyond this comes \nto mind. So, if you're developing new extension modules or optimizing Python \nfunctions in C, weave.ext_tools() might be the tool \nfor you. If you're wrapping legacy code, stick with SWIG.\n
\nThe next several sections give the basics of how to use weave.\nWe'll discuss what's happening under the covers in more detail later \non. Serious users will need to at least look at the type conversion section to \nunderstand how Python variables map to C/C++ types and how to customize this \nbehavior. One other note. If you don't know C or C++ then these docs are \nprobably of very little help to you. Further, it'd be helpful if you know \nsomething about writing Python extensions. weave does quite a \nbit for you, but for anything complex, you'll need to do some conversions, \nreference counting, etc.\n
\n\nNote: weave is actually part of the SciPy package. However, it works fine as a \nstandalone package. The examples here are given as if it is used as a stand \nalone package. If you are using from within scipy, you can use from \nscipy import weave and the examples will work identically.\n\n\n
Requirements
\n\n - Python\n
\n I use 2.1.1. Probably 2.0 or higher should work.\n
\n
\n \n - C++ compiler\n
\n weave uses distutils to actually build \n extension modules, so it uses whatever compiler was originally used to \n build Python. weave itself requires a C++ compiler. If \n you used a C++ compiler to build Python, your probably fine.\n
\n On Unix gcc is the preferred choice because I've done a little \n testing with it. All testing has been done with gcc, but I expect the \n majority of compilers should work for inline and \n ext_tools. The one issue I'm not sure about is that I've \n hard coded things so that compilations are linked with the \n stdc++ library. Is this standard across \n Unix compilers, or is this a gcc-ism?\n
\n For blitz(), you'll need a reasonably recent version of \n gcc. 2.95.2 works on windows and 2.96 looks fine on Linux. Other \n versions are likely to work. Its likely that KAI's C++ compiler and \n maybe some others will work, but I haven't tried. My advice is to use \n gcc for now unless your willing to tinker with the code some.\n
\n On Windows, either MSVC or gcc (www.mingw.org\" > mingw32) should work. Again, \n you'll need gcc for blitz() as the\n MSVC compiler doesn't handle templates well.\n
\n I have not tried Cygwin, so please report success if it works for you.\n
\n
\n\n - Numeric (optional)\n
\n The python Numeric module from here. is required for \n blitz() to work. Be sure and get NumPy, not NumArray\n which is the \"next generation\" implementation. This is not\n required for using inline() or ext_tools.\n
\n
\n - scipy_distutils and scipy_test (packaged with
weave)\n \n These two modules are packaged with weave in both\n the windows installer and the source distributions. If you are using\n CVS, however, you'll need to download these separately (also available\n through CVS at SciPy).\n
\n
\n
\nInstallation
\n\nThere are currently two ways to get weave. Fist, \nweave is part of SciPy and installed automatically (as a sub-\npackage) whenever SciPy is installed (although the latest version isn't in \nSciPy yet, so use this one for now). Second, since weave is \nuseful outside of the scientific community, it has been setup so that it can be\nused as a stand-alone module. \n\n
\nThe stand-alone version can be downloaded from here. Unix users should grab the \ntar ball (.tgz file) and install it using the following commands.\n\n
\n tar -xzvf weave-0.2.tar.gz\n cd weave-0.2\n python setup.py install\n
\n\nThis will also install two other packages, scipy_distutils and \nscipy_test. The first is needed by the setup process itself and \nboth are used in the unit-testing process. Numeric is required if you want to \nuse blitz(), but isn't necessary for inline() or \next_tools\n\nFor Windows users, it's even easier. You can download the click-install .exe \nfile and run it for automatic installation. There is also a .zip file of the\nsource for those interested. It also includes a setup.py file to simplify\ninstallation. \n
\nIf you're using the CVS version, you'll need to install \nscipy_distutils and scipy_test packages (also \navailable from CVS) on your own.\n
\n \nNote: The dependency issue here is a little sticky. I hate to make people \ndownload more than one file (and so I haven't), but distutils doesn't have a \nway to do conditional installation -- at least that I know about. This can \nlead to undesired clobbering of the scipy_test and scipy_distutils modules. \nWhat to do, what to do... Right now it is a very minor issue.\n\n
Testing
\nOnce weave is installed, fire up python and run its unit tests.\n\n \n >>> import weave\n >>> weave.test()\n runs long time... spews tons of output and a few warnings\n .\n .\n .\n ..............................................................\n ................................................................\n ..................................................\n ----------------------------------------------------------------------\n Ran 184 tests in 158.418s\n\n OK\n \n >>> \n
\n\nThis takes a loooong time. On windows, it is usually several minutes. On Unix \nwith remote file systems, I've had it take 15 or so minutes. In the end, it \nshould run about 180 tests and spew some speed results along the way. If you \nget errors, they'll be reported at the end of the output. Please let me know\nwhat if this occurs.\n\nIf you don't have Numeric installed, you'll get some module import errors \nduring the test setup phase for modules that are Numeric specific (blitz_spec, \nblitz_tools, size_check, standard_array_spec, ast_tools), but all test should\npass (about 100 and they should complete in several minutes).\n\nIf you only want to test a single module of the package, you can do this by\nrunning test() for that specific module.\n\n
\n >>> import weave.scalar_spec\n >>> weave.scalar_spec.test()\n .......\n ----------------------------------------------------------------------\n Ran 7 tests in 23.284s\n
\n\nTesting Notes:\n\n - \n Windows 1\n
\n I've had some test fail on windows machines where I have msvc, gcc-2.95.2 \n (in c:\\gcc-2.95.2), and gcc-2.95.3-6 (in c:\\gcc) all installed. My \n environment has c:\\gcc in the path and does not have c:\\gcc-2.95.2 in the \n path. The test process runs very smoothly until the end where several test \n using gcc fail with cpp0 not found by g++. If I check os.system('gcc -v') \n before running tests, I get gcc-2.95.3-6. If I check after running tests \n (and after failure), I get gcc-2.95.2. ??huh??. The os.environ['PATH'] \n still has c:\\gcc first in it and is not corrupted (msvc/distutils messes \n with the environment variables, so we have to undo its work in some \n places). If anyone else sees this, let me know - - it may just be an quirk \n on my machine (unlikely). Testing with the gcc- 2.95.2 installation always \n works.\n
\n
\n - \n Windows 2\n
\n If you run the tests from PythonWin or some other GUI tool, you'll get a\n ton of DOS windows popping up periodically as weave spawns\n the compiler multiple times. Very annoying. Anyone know how to fix this?\n
\n
\n - \n wxPython\n
\n wxPython tests are not enabled by default because importing wxPython on a \n Unix machine without access to a X-term will cause the program to exit. \n Anyone know of a safe way to detect whether wxPython can be imported and \n whether a display exists on a machine? \n
\n
\n
\n\nBenchmarks
\nThis section has a few benchmarks -- thats all people want to see anyway right? \nThese are mostly taken from running files in the weave/example \ndirectory and also from the test scripts. Without more information about what \nthe test actually do, their value is limited. Still, their here for the \ncurious. Look at the example scripts for more specifics about what problem was \nactually solved by each run. These examples are run under windows 2000 using \nMicrosoft Visual C++ and python2.1 on a 850 MHz PIII laptop with 320 MB of RAM.\nSpeed up is the improvement (degredation) factor of weave compared to \nconventional Python functions. The blitz() comparisons are shown\ncompared to Numeric.\n\n
\n\n\n inline and ext_tools
Algorithm
Speed up
binary search 1.50 fibonacci (recursive) 82.10 fibonacci (loop) 9.17 return None 0.14 map 1.20 dictionary sort 2.54 vector quantization 37.40 \n blitz -- double precision
Algorithm
Speed up
a = b + c 512x512 3.05 a = b + c + d 512x512 4.59 5 pt avg. filter, 2D Image 512x512 9.01 Electromagnetics (FDTD) 100x100x100 8.61
\n \n\n\nThe benchmarks shown blitz in the best possible light. Numeric \n(at least on my machine) is significantly worse for double precision than it is \nfor single precision calculations. If your interested in single precision \nresults, you can pretty much divide the double precision speed up by 3 and you'll\nbe close.\n\n\n
Inline
\n\ninline() compiles and executes C/C++ code on the fly. Variables \nin the local and global Python scope are also available in the C/C++ code. \nValues are passed to the C/C++ code by assignment much like variables \nare passed into a standard Python function. Values are returned from the C/C++ \ncode through a special argument called return_val. Also, the contents of \nmutable objects can be changed within the C/C++ code and the changes remain \nafter the C code exits and returns to Python. (more on this later)\n
\nHere's a trivial printf example using inline():\n\n
\n >>> import weave \n >>> a = 1\n >>> weave.inline('printf(\"%d\\\\n\",a);',['a'])\n 1\n
\n\nIn this, its most basic form, inline(c_code, var_list) requires two \narguments. c_code is a string of valid C/C++ code. \nvar_list is a list of variable names that are passed from \nPython into C/C++. Here we have a simple printf statement that \nwrites the Python variable a to the screen. The first time you run \nthis, there will be a pause while the code is written to a .cpp file, compiled \ninto an extension module, loaded into Python, cataloged for future use, and \nexecuted. On windows (850 MHz PIII), this takes about 1.5 seconds when using \nMicrosoft's C++ compiler (MSVC) and 6-12 seconds using gcc (mingw32 2.95.2). \nAll subsequent executions of the code will happen very quickly because the code \nonly needs to be compiled once. If you kill and restart the interpreter and then \nexecute the same code fragment again, there will be a much shorter delay in the \nfractions of seconds range. This is because weave stores a \ncatalog of all previously compiled functions in an on disk cache. When it sees \na string that has been compiled, it loads the already compiled module and \nexecutes the appropriate function. \n
\n\nNote: If you try the printf example in a GUI shell such as IDLE, \nPythonWin, PyShell, etc., you're unlikely to see the output. This is because the \nC code is writing to stdout, instead of to the GUI window. This doesn't mean \nthat inline doesn't work in these environments -- it only means that standard \nout in C is not the same as the standard out for Python in these cases. Non \ninput/output functions will work as expected.\n\n
\nAlthough effort has been made to reduce the overhead associated with calling \ninline, it is still less efficient for simple code snippets than using \nequivalent Python code. The simple printf example is actually \nslower by 30% or so than using Python print statement. And, it is \nnot difficult to create code fragments that are 8-10 times slower using inline \nthan equivalent Python. However, for more complicated algorithms, \nthe speed up can be worth while -- anywhwere from 1.5- 30 times faster. \nAlgorithms that have to manipulate Python objects (sorting a list) usually only \nsee a factor of 2 or so improvement. Algorithms that are highly computational \nor manipulate Numeric arrays can see much larger improvements. The \nexamples/vq.py file shows a factor of 30 or more improvement on the vector \nquantization algorithm that is used heavily in information theory and \nclassification problems.\n
More with printf
\n\nMSVC users will actually see a bit of compiler output that distutils does not\nsupress the first time the code executes:\n\n
\n >>> weave.inline(r'printf(\"%d\\n\",a);',['a'])\n sc_e013937dbc8c647ac62438874e5795131.cpp\n Creating library C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\n \\Release\\sc_e013937dbc8c647ac62438874e5795131.lib and object C:\\DOCUME\n ~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_e013937dbc8c64\n 7ac62438874e5795131.exp\n 1\n
\n\nNothing bad is happening, its just a bit annoying. Anyone know how to \nturn this off? \n
\nThis example also demonstrates using 'raw strings'. The r \npreceeding the code string in the last example denotes that this is a 'raw \nstring'. In raw strings, the backslash character is not interpreted as an \nescape character, and so it isn't necessary to use a double backslash to \nindicate that the '\\n' is meant to be interpreted in the C printf \nstatement instead of by Python. If your C code contains a lot\nof strings and control characters, raw strings might make things easier.\nMost of the time, however, standard strings work just as well.\n\n
\nThe printf statement in these examples is formatted to print \nout integers. What happens if a is a string? inline\nwill happily, compile a new version of the code to accept strings as input,\nand execute the code. The result?\n\n
\n >>> a = 'string'\n >>> weave.inline(r'printf(\"%d\\n\",a);',['a'])\n 32956972\n
\n\nIn this case, the result is non-sensical, but also non-fatal. In other \nsituations, it might produce a compile time error because a is \nrequired to be an integer at some point in the code, or it could produce a \nsegmentation fault. Its possible to protect against passing \ninline arguments of the wrong data type by using asserts in \nPython.\n\n
\n >>> a = 'string'\n >>> def protected_printf(a): \n ... assert(type(a) == type(1))\n ... weave.inline(r'printf(\"%d\\n\",a);',['a'])\n >>> protected_printf(1)\n 1\n >>> protected_printf('string')\n AssertError...\n
\n\n\nFor printing strings, the format statement needs to be changed. Also, weave\ndoesn't convert strings to char*. Instead it uses CXX Py::String type, so \nyou have to do a little more work. Here we convert it to a C++ std::string\nand then ask cor the char* version.\n\n
\n >>> a = 'string' \n >>> weave.inline(r'printf(\"%s\\n\",std::string(a).c_str());',['a'])\n string\n
\n\n \nThis is a little convoluted. Perhaps strings should convert to std::string\nobjects instead of CXX objects. Or maybe to char*.\n\n\n
\nAs in this case, C/C++ code fragments often have to change to accept different \ntypes. For the given printing task, however, C++ streams provide a way of a \nsingle statement that works for integers and strings. By default, the stream \nobjects live in the std (standard) namespace and thus require the use of \nstd::.\n\n
\n >>> weave.inline('std::cout << a << std::endl;',['a'])\n 1 \n >>> a = 'string'\n >>> weave.inline('std::cout << a << std::endl;',['a'])\n string\n
\n \n\nExamples using printf and cout are included in \nexamples/print_example.py.\n\n\n
More examples
\n\nThis section shows several more advanced uses of inline. It \nincludes a few algorithms from the Python Cookbook \nthat have been re-written in inline C to improve speed as well as a couple \nexamples using Numeric and wxPython.\n\n\n Binary search
\nLets look at the example of searching a sorted list of integers for a value. \nFor inspiration, we'll use Kalle Svensson's \nbinary_search() algorithm from the Python Cookbook. His recipe follows:\n\n \n def binary_search(seq, t):\n min = 0; max = len(seq) - 1\n while 1:\n if max < min:\n return -1\n m = (min + max) / 2\n if seq[m] < t: \n min = m + 1 \n elif seq[m] > t: \n max = m - 1 \n else:\n return m \n
\n\nThis Python version works for arbitrary Python data types. The C version below is \nspecialized to handle integer values. There is a little type checking done in \nPython to assure that we're working with the correct data types before heading \ninto C. The variables seq and t don't need to be \ndeclared beacuse weave handles converting and declaring them in \nthe C code. All other temporary variables such as min, max, etc. \nmust be declared -- it is C after all. Here's the new mixed Python/C function:\n\n \n\n def c_int_binary_search(seq,t):\n # do a little type checking in Python\n assert(type(t) == type(1))\n assert(type(seq) == type([]))\n \n # now the C code\n code = \"\"\"\n #line 29 \"binary_search.py\"\n int val, m, min = 0; \n int max = seq.length() - 1;\n PyObject *py_val; \n for(;;)\n {\n if (max < min ) \n { \n return_val = Py::new_reference_to(Py::Int(-1)); \n break;\n } \n m = (min + max) /2;\n val = py_to_int(PyList_GetItem(seq.ptr(),m),\"val\"); \n if (val < t) \n min = m + 1;\n else if (val > t)\n max = m - 1;\n else\n {\n return_val = Py::new_reference_to(Py::Int(m));\n break;\n }\n }\n \"\"\"\n return inline(code,['seq','t'])\n
\nWe have two variables seq and t passed in. \nt is guaranteed (by the assert) to be an integer. \nPython integers are converted to C int types in the transition from Python to \nC. seq is a Python list. By default, it is translated to a CXX \nlist object. Full documentation for the CXX library can be found at its website. The basics are that the CXX \nprovides C++ class equivalents for Python objects that simplify, or at \nleast object orientify, working with Python objects in C/C++. For example, \nseq.length() returns the length of the list. A little more about\nCXX and its class methods, etc. is in the ** type conversions ** section.\n
\n\nNote: CXX uses templates and therefore may be a little less portable than \nanother alternative by Gordan McMillan called SCXX which was inspired by\nCXX. It doesn't use templates so it should compile faster and be more portable.\nSCXX has a few less features, but it appears to me that it would mesh with\nthe needs of weave quite well. Hopefully xxx_spec files will be written\nfor SCXX in the future, and we'll be able to compare on a more empirical\nbasis. Both sets of spec files will probably stick around, it just a question\nof which becomes the default.\n\n
\nMost of the algorithm above looks similar in C to the original Python code. \nThere are two main differences. The first is the setting of \nreturn_val instead of directly returning from the C code with a \nreturn statement. return_val is an automatically \ndefined variable of type PyObject* that is returned from the C \ncode back to Python. You'll have to handle reference counting issues when \nsetting this variable. In this example, CXX classes and functions handle the \ndirty work. All CXX functions and classes live in the namespace \nPy::. The following code converts the integer m to a \nCXX Int() object and then to a PyObject* with an \nincremented reference count using Py::new_reference_to().\n\n
\n\n return_val = Py::new_reference_to(Py::Int(m));\n
\nThe second big differences shows up in the retrieval of integer values from the \nPython list. The simple Python seq[i] call balloons into a C \nPython API call to grab the value out of the list and then a separate call to \npy_to_int() that converts the PyObject* to an integer. \npy_to_int() includes both a NULL cheack and a \nPyInt_Check() call as well as the conversion call. If either of \nthe checks fail, an exception is raised. The entire C++ code block is executed \nwith in a try/catch block that handles exceptions much like Python \ndoes. This removes the need for most error checking code.\n
\nIt is worth note that CXX lists do have indexing operators that result \nin code that looks much like Python. However, the overhead in using them \nappears to be relatively high, so the standard Python API was used on the \nseq.ptr() which is the underlying PyObject* of the \nList object.\n
\nThe #line directive that is the first line of the C code \nblock isn't necessary, but it's nice for debugging. If the compilation fails \nbecause of the syntax error in the code, the error will be reported as an error \nin the Python file \"binary_search.py\" with an offset from the given line number \n(29 here).\n
\nSo what was all our effort worth in terms of efficiency? Well not a lot in \nthis case. The examples/binary_search.py file runs both Python and C versions \nof the functions As well as using the standard bisect module. If \nwe run it on a 1 million element list and run the search 3000 times (for 0-\n2999), here are the results we get:\n\n
\n\n C:\\home\\ej\\wrk\\scipy\\weave\\examples> python binary_search.py\n Binary search for 3000 items in 1000000 length list of integers:\n speed in python: 0.159999966621\n speed of bisect: 0.121000051498\n speed up: 1.32\n speed in c: 0.110000014305\n speed up: 1.45\n speed in c(no asserts): 0.0900000333786\n speed up: 1.78\n
\nSo, we get roughly a 50-75% improvement depending on whether we use the Python \nasserts in our C version. If we move down to searching a 10000 element list, \nthe advantage evaporates. Even smaller lists might result in the Python \nversion being faster. I'd like to say that moving to Numeric lists (and \ngetting rid of the GetItem() call) offers a substantial speed up, but my \npreliminary efforts didn't produce one. I think the log(N) algorithm is to \nblame. Because the algorithm is nice, there just isn't much time spent \ncomputing things, so moving to C isn't that big of a win. If there are ways to \nreduce conversion overhead of values, this may improve the C/Python speed \nup. Anyone have other explanations or faster code, please let me know.\n\n\n
\nThe demo in examples/dict_sort.py is another example from the Python CookBook. \nThis \nsubmission, by Alex Martelli, demonstrates how to return the values from a \ndictionary sorted by their keys:\n\n
\n\n def sortedDictValues3(adict):\n keys = adict.keys()\n keys.sort()\n return map(adict.get, keys)\n
\nAlex provides 3 algorithms and this is the 3rd and fastest of the set. The C \nversion of this same algorithm follows:\n\n
\n\n def c_sort(adict):\n assert(type(adict) == type({}))\n code = \"\"\" \n #line 21 \"dict_sort.py\" \n Py::List keys = adict.keys();\n Py::List items(keys.length()); keys.sort(); \n PyObject* item = NULL; \n for(int i = 0; i < keys.length();i++)\n {\n item = PyList_GET_ITEM(keys.ptr(),i);\n item = PyDict_GetItem(adict.ptr(),item);\n Py_XINCREF(item);\n PyList_SetItem(items.ptr(),i,item); \n } \n return_val = Py::new_reference_to(items);\n \"\"\" \n return inline_tools.inline(code,['adict'],verbose=1)\n
\nLike the original Python function, the C++ version can handle any Python \ndictionary regardless of the key/value pair types. It uses CXX objects for the \nmost part to declare python types in C++, but uses Python API calls to manipulate \ntheir contents. Again, this choice is made for speed. The C++ version, while\nmore complicated, is about a factor of 2 faster than Python.\n\n
\n\n C:\\home\\ej\\wrk\\scipy\\weave\\examples> python dict_sort.py\n Dict sort of 1000 items for 300 iterations:\n speed in python: 0.319999933243\n [0, 1, 2, 3, 4]\n speed in c: 0.151000022888\n speed up: 2.12\n [0, 1, 2, 3, 4]\n
\n\nAnd the following is a inline C version of the same function:\n\n\n def _castCopyAndTranspose(type, array):\n if a.typecode() == type:\n cast_array = copy.copy(Numeric.transpose(a))\n else:\n cast_array = copy.copy(Numeric.transpose(a).astype(type))\n return cast_array\n
\n\nThis example uses blitz++ arrays instead of the standard representation of \nNumeric arrays so that indexing is simplier to write. This is accomplished by \npassing in the blitz++ \"type factories\" to override the standard Python to C++ \ntype conversions. Blitz++ arrays allow you to write clean, fast code, but they \nalso are sloooow to compile (20 seconds or more for this snippet). This is why \nthey aren't the default type used for Numeric arrays (and also because most \ncompilers can't compile blitz arrays...).\n from weave.blitz_tools import blitz_type_factories\n from weave import scalar_spec\n from weave import inline\n def _cast_copy_transpose(type,a_2d):\n assert(len(shape(a_2d)) == 2)\n new_array = zeros(shape(a_2d),type)\n numeric_type = scalar_spec.numeric_to_blitz_type_mapping[type]\n code = \\\n \"\"\" \n for(int i = 0;i < _Na_2d[0]; i++) \n for(int j = 0; j < _Na_2d[1]; j++)\n new_array(i,j) = (%s) a_2d(j,i);\n \"\"\" % numeric_type\n inline(code,['new_array','a_2d'],\n type_factories = blitz_type_factories,compiler='gcc')\n return new_array\n
inline() is also forced \nto use 'gcc' as the compiler because the default compiler on Windows (MSVC) \nwill not compile blitz code. 'gcc' I think will use the standard compiler \non Unix machine instead of explicitly forcing gcc (check this) \n\nComparisons of the Python vs inline C++ code show a factor of 3 speed up. Also \nshown are the results of an \"inplace\" transpose routine that can be used if the \noutput of the linear algebra routine can overwrite the original matrix (this is \noften appropriate). This provides another factor of 2 improvement.\n\n \n\n\n\n #C:\\home\\ej\\wrk\\scipy\\weave\\examples> python cast_copy_transpose.py\n # Cast/Copy/Transposing (150,150)array 1 times\n # speed in python: 0.870999932289\n # speed in c: 0.25\n # speed up: 3.48\n # inplace transpose c: 0.129999995232\n # speed up: 6.70\n
inline knows how to handle wxPython objects. Thats nice in and of\nitself, but it also demonstrates that the type conversion mechanism is reasonably \nflexible. Chances are, it won't take a ton of effort to support special types\nyou might have. The examples/wx_example.py borrows the scrolled window\nexample from the wxPython demo, accept that it mixes inline C code in the middle\nof the drawing function.\n\n \n\nHere, some of the Python calls to wx objects were just converted to C++ calls. There\nisn't any benefit, it just demonstrates the capabilities. You might want to use this\nif you have a computationally intensive loop in your drawing code that you want to \nspeed up.\n\nOn windows, you'll have to use the MSVC compiler if you use the standard wxPython\nDLLs distributed by Robin Dunn. Thats because MSVC and gcc, while binary\ncompatible in C, are not binary compatible for C++. In fact, its probably best, no \nmatter what platform you're on, to specify that\n def DoDrawing(self, dc):\n \n red = wxNamedColour(\"RED\");\n blue = wxNamedColour(\"BLUE\");\n grey_brush = wxLIGHT_GREY_BRUSH;\n code = \\\n \"\"\"\n #line 108 \"wx_example.py\" \n dc->BeginDrawing();\n dc->SetPen(wxPen(*red,4,wxSOLID));\n dc->DrawRectangle(5,5,50,50);\n dc->SetBrush(*grey_brush);\n dc->SetPen(wxPen(*blue,4,wxSOLID));\n dc->DrawRectangle(15, 15, 50, 50);\n \"\"\"\n inline(code,['dc','red','blue','grey_brush'])\n \n dc.SetFont(wxFont(14, wxSWISS, wxNORMAL, wxNORMAL))\n dc.SetTextForeground(wxColour(0xFF, 0x20, 0xFF))\n te = dc.GetTextExtent(\"Hello World\")\n dc.DrawText(\"Hello World\", 60, 65)\n\n dc.SetPen(wxPen(wxNamedColour('VIOLET'), 4))\n dc.DrawLine(5, 65+te[1], 60+te[0], 65+te[1])\n ...\n
inline use the same\ncompiler that was used to build wxPython to be on the safe side. There isn't currently\na way to learn this info from the library -- you just have to know. Also, at least\non the windows platform, you'll need to install the wxWindows libraries and link to \nthem. I think there is a way around this, but I haven't found it yet -- I get some\nlinking errors dealing with wxString. One final note. You'll probably have to\ntweak weave/wx_spec.py or weave/wx_info.py for your machine's configuration to\npoint at the correct directories etc. There. That should sufficiently scare people\ninto not even looking at this... :)\n\n\n\nThe basic definition of the inline() function has a slew of \noptional variables. It also takes keyword arguments that are passed to \ndistutils as compiler options. The following is a formatted \ncut/paste of the argument section of inline's doc-string. It \nexplains all of the variables. Some examples using various options will \nfollow.\n\n
\n\n \n\n def inline(code,arg_names,local_dict = None, global_dict = None, \n force = 0, \n compiler='',\n verbose = 0, \n support_code = None,\n customize=None, \n type_factories = None, \n auto_downcast=1,\n **kw):\n
inline has quite \na few options as listed below. Also, the keyword arguments for distutils \nextension modules are accepted to specify extra information needed for \ncompiling. \n\n\n\n\n\n
\n- code
\n \n- \nstring. A string of valid C++ code. It should not \n specify a return statement. Instead it should assign results that need to be \n returned to Python in the return_val. \n
\n\n- arg_names
\n \n- \nlist of strings. A list of Python variable names \n that should be transferred from Python into the C/C++ code. \n
\n\n- local_dict
\n \n- \noptional. dictionary. If specified, it is a \n dictionary of values that should be used as the local scope for the C/C++ \n code. If local_dict is not specified the local dictionary of the calling \n function is used. \n
\n\n- global_dict
\n \n- \noptional. dictionary. If specified, it is a \n dictionary of values that should be used as the global scope for the C/C++ \n code. If global_dict is not specified the global dictionary of the calling \n function is used. \n
\n\n- force
\n \n- \noptional. 0 or 1. default 0. If 1, the C++ code is \n compiled every time inline is called. This is really only useful for \n debugging, and probably only useful if you're editing support_code a lot. \n
\n\n- compiler
\n \n- \noptional. string. The name of compiler to use when compiling. On windows, it \nunderstands 'msvc' and 'gcc' as well as all the compiler names understood by \ndistutils. On Unix, it'll only understand the values understoof by distutils. \n(I should add 'gcc' though to this).\n
\n\n\nOn windows, the compiler defaults to the Microsoft C++ compiler. If this isn't \navailable, it looks for mingw32 (the gcc compiler).\n
\nOn Unix, it'll probably use the same compiler that was used when compiling \nPython. Cygwin's behavior should be similar.
\n- verbose
\n \n- \noptional. 0,1, or 2. defualt 0. Speficies how much \n much information is printed during the compile phase of inlining code. 0 is \n silent (except on windows with msvc where it still prints some garbage). 1 \n informs you when compiling starts, finishes, and how long it took. 2 prints \n out the command lines for the compilation process and can be useful if you're \n having problems getting code to work. Its handy for finding the name of the \n .cpp file if you need to examine it. verbose has no affect if the \n compilation isn't necessary. \n
\n\n- support_code
\n \n- \noptional. string. A string of valid C++ code \n declaring extra code that might be needed by your compiled function. This \n could be declarations of functions, classes, or structures. \n
\n\n- customize
\n \n- \noptional. base_info.custom_info object. An \n alternative way to specifiy support_code, headers, etc. needed by the \n function see the weave.base_info module for more details. (not sure \n this'll be used much). \n \n
\n- type_factories
\n \n- \noptional. list of type specification factories. These guys are what convert \nPython data types to C/C++ data types. If you'd like to use a different set of \ntype conversions than the default, specify them here. Look in the type \nconversions section of the main documentation for examples.\n
\n- auto_downcast
\n \n- \noptional. 0 or 1. default 1. This only affects functions that have Numeric \narrays as input variables. Setting this to 1 will cause all floating point \nvalues to be cast as float instead of double if all the Numeric arrays are of \ntype float. If even one of the arrays has type double or double complex, all \nvariables maintain there standard types.\n
\n
\n\n\n\ninline()also accepts a number ofdistutilskeywords \nfor controlling how the code is compiled. The following descriptions have been \ncopied from Greg Ward'sdistutils.extension.Extensionclass doc-\nstrings for convenience:\n\n\n
\n- sources
\n \n- \n[string] list of source filenames, relative to the \n distribution root (where the setup script lives), in Unix form \n (slash-separated) for portability. Source files may be C, C++, SWIG (.i), \n platform-specific resource files, or whatever else is recognized by the \n \"build_ext\" command as source for a Python extension. Note: The module_path \n file is always appended to the front of this list \n
\n\n- include_dirs
\n \n- \n[string] list of directories to search for C/C++ \n header files (in Unix form for portability) \n
\n\n- define_macros
\n \n- \n[(name : string, value : string|None)] list of \n macros to define; each macro is defined using a 2-tuple, where 'value' is \n either the string to define it to or None to define it without a particular \n value (equivalent of \"#define FOO\" in source or -DFOO on Unix C compiler \n command line) \n
\n- undef_macros
\n \n- \n[string] list of macros to undefine explicitly \n
\n- library_dirs
\n- \n[string] list of directories to search for C/C++ libraries at link time \n
\n- libraries
\n- \n[string] list of library names (not filenames or paths) to link against \n
\n- runtime_library_dirs
\n- \n[string] list of directories to search for C/C++ libraries at run time (for \nshared extensions, this is when the extension is loaded) \n
\n\n- extra_objects
\n \n- \n[string] list of extra files to link with (eg. \n object files not implied by 'sources', static library that must be \n explicitly specified, binary resource files, etc.) \n
\n\n- extra_compile_args
\n \n- \n[string] any extra platform- and compiler-specific \n information to use when compiling the source files in 'sources'. For \n platforms and compilers where \"command line\" makes sense, this is typically \n a list of command-line arguments, but for other platforms it could be \n anything. \n
\n- extra_link_args
\n \n- \n[string] any extra platform- and compiler-specific \n information to use when linking object files together to create the \n extension (or to create a new static Python interpreter). Similar \n interpretation as for 'extra_compile_args'. \n
\n- export_symbols
\n \n- \n[string] list of symbols to be exported from a shared extension. Not used on \nall platforms, and not generally necessary for Python extensions, which \ntypically export exactly one symbol: \"init\" + extension_name. \n
\n
inline and also how the various arguments are used.\n\nIn the simplest (most) cases, code and arg_names\nare the only arguments that need to be specified. Here's a simple example\nrun on Windows machine that has Microsoft VC++ installed.\n\n \n \nWhen\n >>> from weave import inline\n >>> a = 'string'\n >>> code = \"\"\"\n ... int l = a.length();\n ... return_val = Py::new_reference_to(Py::Int(l));\n ... \"\"\"\n >>> inline(code,['a'])\n sc_86e98826b65b047ffd2cd5f479c627f12.cpp\n Creating\n library C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_86e98826b65b047ffd2cd5f479c627f12.lib\n and object C:\\DOCUME~ 1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_86e98826b65b047ff\n d2cd5f479c627f12.exp\n 6\n >>> inline(code,['a'])\n 6\n
inline is first run, you'll notice that pause and some \ntrash printed to the screen. The \"trash\" is acutually part of the compilers\noutput that distutils does not supress. The name of the extension file, \nsc_bighonkingnumber.cpp, is generated from the md5 check sum\nof the C/C++ code fragment. On Unix or windows machines with only\ngcc installed, the trash will not appear. On the second call, the code \nfragment is not compiled since it already exists, and only the answer is \nreturned. Now kill the interpreter and restart, and run the same code with\na different string.\n\n \n\n >>> from weave import inline\n >>> a = 'a longer string' \n >>> code = \"\"\" \n ... int l = a.length();\n ... return_val = Py::new_reference_to(Py::Int(l)); \n ... \"\"\"\n >>> inline(code,['a'])\n 15\n
\nNotice this time, inline() did not recompile the code because it\nfound the compiled function in the persistent catalog of functions. There is\na short pause as it looks up and loads the function, but it is much shorter \nthan compiling would require.\n
\nYou can specify the local and global dictionaries if you'd like (much like \nexec or eval() in Python), but if they aren't \nspecified, the \"expected\" ones are used -- i.e. the ones from the function that \ncalled inline() . This is accomplished through a little call \nframe trickery. Here is an example where the local_dict is specified using\nthe same code example from above:\n\n
\n \n\n >>> a = 'a longer string'\n >>> b = 'an even longer string' \n >>> my_dict = {'a':b}\n >>> inline(code,['a'])\n 15\n >>> inline(code,['a'],my_dict)\n 21\n
\nEverytime, the code is changed, inline does a \nrecompile. However, changing any of the other options in inline does not\nforce a recompile. The force option was added so that one\ncould force a recompile when tinkering with other variables. In practice,\nit is just as easy to change the code by a single character\n(like adding a space some place) to force the recompile. Note: It also \nmight be nice to add some methods for purging the cache and on disk \ncatalogs.\n
\nI use verbose sometimes for debugging. When set to 2, it'll \noutput all the information (including the name of the .cpp file) that you'd\nexpect from running a make file. This is nice if you need to examine the\ngenerated code to see where things are going haywire. Note that error\nmessages from failed compiles are printed to the screen even if verbose\n is set to 0.\n
\nThe following example demonstrates using gcc instead of the standard msvc \ncompiler on windows using same code fragment as above. Because the example has \nalready been compiled, the force=1 flag is needed to make \ninline() ignore the previously compiled version and recompile \nusing gcc. The verbose flag is added to show what is printed out:\n\n
\n\nThat's quite a bit of output.\n >>>inline(code,['a'],compiler='gcc',verbose=2,force=1)\n running build_ext \n building 'sc_86e98826b65b047ffd2cd5f479c627f13' extension \n c:\\gcc-2.95.2\\bin\\g++.exe -mno-cygwin -mdll -O2 -w -Wstrict-prototypes -IC:\n \\home\\ej\\wrk\\scipy\\weave -IC:\\Python21\\Include -c C:\\DOCUME~1\\eric\\LOCAL\n S~1\\Temp\\python21_compiled\\sc_86e98826b65b047ffd2cd5f479c627f13.cpp -o C:\\D\n OCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_86e98826b65b04\n 7ffd2cd5f479c627f13.o \n skipping C:\\home\\ej\\wrk\\scipy\\weave\\CXX\\cxxextensions.c (C:\\DOCUME~1\\eri\n c\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\cxxextensions.o up-to-date)\n skipping C:\\home\\ej\\wrk\\scipy\\weave\\CXX\\cxxsupport.cxx (C:\\DOCUME~1\\eric\n \\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\cxxsupport.o up-to-date)\n skipping C:\\home\\ej\\wrk\\scipy\\weave\\CXX\\IndirectPythonInterface.cxx (C:\\\n DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\indirectpythonin\n terface.o up-to-date)\n skipping C:\\home\\ej\\wrk\\scipy\\weave\\CXX\\cxx_extensions.cxx (C:\\DOCUME~1\\\n eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\cxx_extensions.o up-to-da\n te)\n writing C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_86\n e98826b65b047ffd2cd5f479c627f13.def\n c:\\gcc-2.95.2\\bin\\dllwrap.exe --driver-name g++ -mno-cygwin -mdll -static -\n -output-lib C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\l\n ibsc_86e98826b65b047ffd2cd5f479c627f13.a --def C:\\DOCUME~1\\eric\\LOCALS~1\\Te\n mp\\python21_compiled\\temp\\Release\\sc_86e98826b65b047ffd2cd5f479c627f13.def \n -s C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_86e9882\n 6b65b047ffd2cd5f479c627f13.o C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compil\n ed\\temp\\Release\\cxxextensions.o C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_com\n piled\\temp\\Release\\cxxsupport.o C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_com\n piled\\temp\\Release\\indirectpythoninterface.o C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\n \\python21_compiled\\temp\\Release\\cxx_extensions.o -LC:\\Python21\\libs -lpytho\n n21 -o C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\sc_86e98826b65b047f\n fd2cd5f479c627f13.pyd\n 15\n
verbose=1 just prints the compile\ntime.\n\n \n\n\n >>>inline(code,['a'],compiler='gcc',verbose=1,force=1)\n Compiling code...\n finished compiling (sec): 6.00800001621\n 15\n
\n Note: I've only used the compiler option for switching between 'msvc'\nand 'gcc' on windows. It may have use on Unix also, but I don't know yet.\n\n\n
\nThe support_code argument is likely to be used a lot. It allows \nyou to specify extra code fragments such as function, structure or class \ndefinitions that you want to use in the code string. Note that \nchanges to support_code do not force a recompile. The \ncatalog only relies on code (for performance reasons) to determine \nwhether recompiling is necessary. So, if you make a change to support_code, \nyou'll need to alter code in some way or use the \nforce argument to get the code to recompile. I usually just add \nsome inocuous whitespace to the end of one of the lines in code \nsomewhere. Here's an example of defining a separate method for calculating\nthe string length:\n\n
\n\n >>> from weave import inline\n >>> a = 'a longer string'\n >>> support_code = \"\"\"\n ... PyObject* length(Py::String a)\n ... {\n ... int l = a.length(); \n ... return Py::new_reference_to(Py::Int(l)); \n ... }\n ... \"\"\" \n >>> inline(\"return_val = length(a);\",['a'],\n ... support_code = support_code)\n 15\n
\ncustomize is a left over from a previous way of specifying \ncompiler options. It is a custom_info object that can specify \nquite a bit of information about how a file is compiled. These \ninfo objects are the standard way of defining compile information \nfor type conversion classes. However, I don't think they are as handy here, \nespecially since we've exposed all the keyword arguments that distutils can \nhandle. Between these keywords, and the support_code option, I \nthink customize may be obsolete. We'll see if anyone cares to use \nit. If not, it'll get axed in the next version.\n
\nThe type_factories variable is important to people who want to\ncustomize the way arguments are converted from Python to C. We'll talk about\nthis in the next chapter **xx** of this document when we discuss type\nconversions.\n
\nauto_downcast handles one of the big type conversion issues that\nis common when using Numeric arrays in conjunction with Python scalar values.\nIf you have an array of single precision values and multiply that array by a \nPython scalar, the result is upcast to a double precision array because the\nscalar value is double precision. This is not usually the desired behavior\nbecause it can double your memory usage. auto_downcast goes\nsome distance towards changing the casting precedence of arrays and scalars.\nIf your only using single precision arrays, it will automatically downcast all\nscalar values from double to single precision when they are passed into the\nC++ code. This is the default behavior. If you want all values to keep there\ndefault type, set auto_downcast to 0.\n
inline were to completely live up\nto its name, any modifications to variables in the C++ code would be reflected\nin the Python variables when control was passed back to Python. For example,\nthe desired behavior would be something like:\n\n \n\nInstead you get:\n\n\n # THIS DOES NOT WORK\n >>> a = 1\n >>> weave.inline(\"a++;\",['a'])\n >>> a\n 2\n
\n \nVariables are passed into C++ as if you are calling a Python function. Python's \ncalling convention is sometimes called \"pass by assignment\". This means its as \nif a\n >>> a = 1\n >>> weave.inline(\"a++;\",['a'])\n >>> a\n 1\n
c_a = a assignment is made right before inline \ncall is made and the c_a variable is used within the C++ code. \nThus, any changes made to c_a are not reflected in Python's \na variable. Things do get a little more confusing, however, when \nlooking at variables with mutable types. Changes made in C++ to the contents \nof mutable types are reflected in the Python variables.\n\n \n\nSo modifications to the contents of mutable types in C++ are seen when control\nis returned to Python. Modifications to immutable types such as tuples,\nstrings, and numbers do not alter the Python variables.\n\nIf you need to make changes to an immutable variable, you'll need to assign\nthe new value to the \"magic\" variable\n >>> a= [1,2]\n >>> weave.inline(\"PyList_SetItem(a.ptr(),0,PyInt_FromLong(3));\",['a'])\n >>> print a\n [3, 2]\n
return_val in C++. This\nvalue is returned by the inline() function:\n\n \n\nThe\n >>> a = 1\n >>> a = weave.inline(\"return_val = Py::new_reference_to(Py::Int(a+1));\",['a']) \n >>> a\n 2\n
return_val variable can also be used to return newly created \nvalues. This is possible by returning a tuple. The following trivial example \nillustrates how this can be done:\n\n \n\n # python version\n def multi_return():\n return 1, '2nd'\n \n # C version.\n def c_multi_return(): \n code = \"\"\"\n \t Py::Tuple results(2);\n \t results[0] = Py::Int(1);\n \t results[1] = Py::String(\"2nd\");\n \t return_val = Py::new_reference_to(results); \t \n \"\"\"\n return inline_tools.inline(code)\n
\nThe example is available in examples/tuple_return.py. It also\nhas the dubious honor of demonstrating how much inline() can \nslow things down. The C version here is about 10 times slower than the Python\nversion. Of course, something so trivial has no reason to be written in\nC anyway.\n\n\n
locals()\ninline passes the locals() and globals() \ndictionaries from Python into the C++ function from the calling function. It \nextracts the variables that are used in the C++ code from these dictionaries, \nconverts then to C++ variables, and then calculates using them. It seems like \nit would be trivial, then, after the calculations were finished to then insert \nthe new values back into the locals() and globals() \ndictionaries so that the modified values were reflected in Python. \nUnfortunately, as pointed out by the Python manual, the locals() dictionary is \nnot writable. \n
\n\nI suspect locals() is not writable because there are some \noptimizations done to speed lookups of the local namespace. I'm guessing local \nlookups don't always look at a dictionary to find values. Can someone \"in the \nknow\" confirm or correct this? Another thing I'd like to know is whether there \nis a way to write to the local namespace of another stack frame from C/C++. If \nso, it would be possible to have some clean up code in compiled functions that \nwrote final values of variables in C++ back to the correct Python stack frame. \nI think this goes a long way toward making inline truely live up \nto its name. I don't think we'll get to the point of creating variables in \nPython for variables created in C -- although I suppose with a C/C++ parser you \ncould do that also.\n\n
weave generates a C++ file holding an extension function for \neach inline code snippet. These file names are generated using \nfrom the md5 signature of the code snippet and saved to a location specified by \nthe PYTHONCOMPILED environment variable (discussed later). The cpp files are \ngenerally about 200-400 lines long and include quite a few functions to support \ntype conversions, etc. However, the actual compiled function is pretty simple. \nBelow is the familiar printf example:\n\n \n\nAnd here is the extension function generated by\n >>> import weave \n >>> a = 1\n >>> weave.inline('printf(\"%d\\\\n\",a);',['a'])\n 1\n
inline:\n\n \n\nEvery inline function takes exactly two arguments -- the local and global\ndictionaries for the current scope. All variable values are looked up out\nof these dictionaries. The lookups, along with all\n static PyObject* compiled_func(PyObject*self, PyObject* args)\n {\n // The Py_None needs an incref before returning\n PyObject *return_val = NULL;\n int exception_occured = 0;\n PyObject *py__locals = NULL;\n PyObject *py__globals = NULL;\n PyObject *py_a;\n py_a = NULL;\n \n if(!PyArg_ParseTuple(args,\"OO:compiled_func\",&py__locals,&py__globals))\n return NULL;\n try \n { \n PyObject* raw_locals = py_to_raw_dict(py__locals,\"_locals\");\n PyObject* raw_globals = py_to_raw_dict(py__globals,\"_globals\");\n int a = py_to_int (get_variable(\"a\",raw_locals,raw_globals),\"a\");\n /* Here is the inline code */ \n printf(\"%d\\n\",a);\n /* I would like to fill in changed locals and globals here... */\n } \n catch( Py::Exception& e) \n { \n return_val = Py::Null(); \n exception_occured = 1; \n } \n if(!return_val && !exception_occured)\n {\n \n Py_INCREF(Py_None); \n return_val = Py_None; \n }\n /* clean up code */\n \n /* return */ \n return return_val; \n } \n
inline code \nexecution, are done within a C++ try block. If the variables\naren't found, or there is an error converting a Python variable to the \nappropriate type in C++, an exception is raised. The C++ exception\nis automatically converted to a Python exception by CXX and returned to Python.\n\nThe py_to_int() function illustrates how the conversions and\nexception handling works. py_to_int first checks that the given PyObject*\npointer is not NULL and is a Python integer. If all is well, it calls the\nPython API to convert the value to an int. Otherwise, it calls\nhandle_bad_type() which gathers information about what went wrong\nand then raises a CXX TypeError which returns to Python as a TypeError.\n\n \n\n\n int py_to_int(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyInt_Check(py_obj))\n handle_bad_type(py_obj,\"int\", name);\n return (int) PyInt_AsLong(py_obj);\n }\n
\n\nSince the\n void handle_bad_type(PyObject* py_obj, char* good_type, char* var_name)\n {\n char msg[500];\n sprintf(msg,\"received '%s' type instead of '%s' for variable '%s'\",\n find_type(py_obj),good_type,var_name);\n throw Py::TypeError(msg);\n }\n \n char* find_type(PyObject* py_obj)\n {\n if(py_obj == NULL) return \"C NULL value\";\n if(PyCallable_Check(py_obj)) return \"callable\";\n if(PyString_Check(py_obj)) return \"string\";\n if(PyInt_Check(py_obj)) return \"int\";\n if(PyFloat_Check(py_obj)) return \"float\";\n if(PyDict_Check(py_obj)) return \"dict\";\n if(PyList_Check(py_obj)) return \"list\";\n if(PyTuple_Check(py_obj)) return \"tuple\";\n if(PyFile_Check(py_obj)) return \"file\";\n if(PyModule_Check(py_obj)) return \"module\";\n \n //should probably do more interagation (and thinking) on these.\n if(PyCallable_Check(py_obj) && PyInstance_Check(py_obj)) return \"callable\";\n if(PyInstance_Check(py_obj)) return \"instance\"; \n if(PyCallable_Check(py_obj)) return \"callable\";\n return \"unkown type\";\n }\n
inline is also executed within the try/catch\nblock, you can use CXX exceptions within your code. It is usually a bad idea\nto directly return from your code, even if an error occurs. This\nskips the clean up section of the extension function. In this simple example,\nthere isn't any clean up code, but in more complicated examples, there may\nbe some reference counting that needs to be taken care of here on converted\nvariables. To avoid this, either uses exceptions or set \nreturn_val to NULL and use if/then's to skip code\nafter errors.\n\n\n\nThere are several main steps to using C/C++ code withing Python:\n
\nItems 1 and 2 above are related, but most easily discussed separately. Type \nconversions are customizable by the user if needed. Understanding them is \npretty important for anything beyond trivial uses of inline. \nGenerating the C/C++ code is handled by ext_function and \next_module classes and . For the most part, compiling the code is \nhandled by distutils. Some customizations were needed, but they were \nrelatively minor and do not require changes to distutils itself. Cataloging is \npretty simple in concept, but surprisingly required the most code to implement \n(and still likely needs some work). So, this section covers items 1 and 4 from \nthe list. Item 2 is covered later in the chapter covering the \next_tools module, and distutils is covered by a completely \nseparate document xxx.\n\n
xxx_converter instead of \nxxx_specification is a more descriptive name. Might change in \nfuture version?\n\n\n\nBy default, inline() makes the following type conversions between\nPython and C++ types.\n
\n\n
| \n Default Data Type Conversions | |
| \n Python | \n C++ |
| int | int |
| float | double |
| complex | std::complex |
| string | Py::String |
| list | Py::List |
| dict | Py::Dict |
| tuple | Py::Tuple |
| file | FILE* |
| callable | PyObject* |
| instance | PyObject* |
| Numeric.array | PyArrayObject* |
| wxXXX | wxXXX* |
\nThe Py:: namespace is defined by the \nCXX library which has C++ class\nequivalents for many Python types. std:: is the namespace of the\nstandard library in C++.\n
\n\nNote: \n\n
\n\nlong int yet (I think they are currenlty converted \n to int - - check this). \n \n
\n\nPython to C++ conversions fill in code in several locations in the generated\ninline extension function. Below is the basic template for the\nfunction. This is actually the exact code that is generated by calling\nweave.inline(\"\").\n\n
\n\nThe\n static PyObject* compiled_func(PyObject*self, PyObject* args)\n {\n PyObject *return_val = NULL;\n int exception_occured = 0;\n PyObject *py__locals = NULL;\n PyObject *py__globals = NULL;\n PyObject *py_a;\n py_a = NULL;\n \n if(!PyArg_ParseTuple(args,\"OO:compiled_func\",&py__locals,&py__globals))\n return NULL;\n try\n {\n PyObject* raw_locals = py_to_raw_dict(py__locals,\"_locals\");\n PyObject* raw_globals = py_to_raw_dict(py__globals,\"_globals\");\n /* argument conversion code */\n /* inline code */\n /*I would like to fill in changed locals and globals here...*/\n \n }\n catch( Py::Exception& e)\n {\n return_val = Py::Null();\n exception_occured = 1;\n }\n /* cleanup code */\n if(!return_val && !exception_occured)\n {\n \n Py_INCREF(Py_None);\n return_val = Py_None;\n }\n \n return return_val;\n }\n
/* inline code */ section is filled with the code passed to\nthe inline() function call. The \n/*argument convserion code*/ and /* cleanup code */\nsections are filled with code that handles conversion from Python to C++\ntypes and code that deallocates memory or manipulates reference counts before\nthe function returns. The following sections demostrate how these two areas\nare filled in by the default conversion methods.\n\n \nNote: I'm not sure I have reference counting correct on a few of these. The \nonly thing I increase/decrease the ref count on is Numeric arrays. If you\nsee an issue, please let me know.\n\n\n\n\n\nThe argument conversion code inserted for\n >>> a = 1\n >>> inline(\"\",['a'])\n
a is:\n\n \n\n\n /* argument conversion code */\n int a = py_to_int (get_variable(\"a\",raw_locals,raw_globals),\"a\");\n
get_variable() reads the variable a\nfrom the local and global namespaces. py_to_int() has the following\nform:\n\n \n\nSimilarly, the float and complex conversion routines look like:\n\n\n static int py_to_int(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyInt_Check(py_obj))\n handle_bad_type(py_obj,\"int\", name);\n return (int) PyInt_AsLong(py_obj);\n }\n
\n\nNumeric conversions do not require any clean up code.\n\n\n\n static double py_to_float(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyFloat_Check(py_obj))\n handle_bad_type(py_obj,\"float\", name);\n return PyFloat_AsDouble(py_obj);\n }\n \n static std::complexpy_to_complex(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyComplex_Check(py_obj))\n handle_bad_type(py_obj,\"complex\", name);\n return std::complex (PyComplex_RealAsDouble(py_obj),\n PyComplex_ImagAsDouble(py_obj)); \n }\n
\n\nThe argument conversion code inserted for\n >>> a = [1]\n >>> inline(\"\",['a'])\n
a is:\n\n \n\n\n /* argument conversion code */\n Py::List a = py_to_list (get_variable(\"a\",raw_locals,raw_globals),\"a\");\n
get_variable() reads the variable a\nfrom the local and global namespaces. py_to_list() and its\nfriends has the following form:\n\n \n\nCXX handles reference counts on for strings, lists, tuples, and dictionaries,\nso clean up code isn't necessary.\n\n\n\n static Py::List py_to_list(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyList_Check(py_obj))\n handle_bad_type(py_obj,\"list\", name);\n return Py::List(py_obj);\n }\n \n static Py::String py_to_string(PyObject* py_obj,char* name)\n {\n if (!PyString_Check(py_obj))\n handle_bad_type(py_obj,\"string\", name);\n return Py::String(py_obj);\n }\n\n static Py::Dict py_to_dict(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyDict_Check(py_obj))\n handle_bad_type(py_obj,\"dict\", name);\n return Py::Dict(py_obj);\n }\n \n static Py::Tuple py_to_tuple(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyTuple_Check(py_obj))\n handle_bad_type(py_obj,\"tuple\", name);\n return Py::Tuple(py_obj);\n }\n
\n\nThe argument conversion code is:\n\n\n >>> a = open(\"bob\",'w') \n >>> inline(\"\",['a'])\n
\n\n\n /* argument conversion code */\n PyObject* py_a = get_variable(\"a\",raw_locals,raw_globals);\n FILE* a = py_to_file(py_a,\"a\");\n
get_variable() reads the variable a\nfrom the local and global namespaces. py_to_file() converts\nPyObject* to a FILE* and increments the reference count of the PyObject*:\n\n \n\nBecause the PyObject* was incremented, the clean up code needs to decrement\nthe counter\n\n\n FILE* py_to_file(PyObject* py_obj, char* name)\n {\n if (!py_obj || !PyFile_Check(py_obj))\n handle_bad_type(py_obj,\"file\", name);\n \n Py_INCREF(py_obj);\n return PyFile_AsFile(py_obj);\n }\n
\n\nIts important to understand that file conversion only works on actual files --\ni.e. ones created using the\n /* cleanup code */\n Py_XDECREF(py_a);\n
open() command in Python. It does\nnot support converting arbitrary objects that support the file interface into\nC FILE* pointers. This can affect many things. For example, in\ninitial printf() examples, one might be tempted to solve the \nproblem of C and Python IDE's (PythonWin, PyCrust, etc.) writing to different\nstdout and stderr by using fprintf() and passing in \nsys.stdout and sys.stderr. For example, instead of\n\n \n \nYou might try:\n\n\n >>> weave.inline('printf(\"hello\\\\n\");')\n
\n\nThis will work as expected from a standard python interpreter, but in PythonWin,\nthe following occurs:\n\n\n >>> buf = sys.stdout\n >>> weave.inline('fprintf(buf,\"hello\\\\n\");',['buf'])\n
\n\nThe traceback tells us that\n >>> buf = sys.stdout\n >>> weave.inline('fprintf(buf,\"hello\\\\n\");',['buf'])\n Traceback (most recent call last):\n File \"\", line 1, in ?\n File \"C:\\Python21\\weave\\inline_tools.py\", line 315, in inline\n auto_downcast = auto_downcast,\n File \"C:\\Python21\\weave\\inline_tools.py\", line 386, in compile_function\n type_factories = type_factories)\n File \"C:\\Python21\\weave\\ext_tools.py\", line 197, in __init__\n auto_downcast, type_factories)\n File \"C:\\Python21\\weave\\ext_tools.py\", line 390, in assign_variable_types\n raise TypeError, format_error_msg(errors)\n TypeError: {'buf': \"Unable to convert variable 'buf' to a C++ type.\"}\n
inline() was unable to convert 'buf' to a\nC++ type (If instance conversion was implemented, the error would have occurred at \nruntime instead). Why is this? Let's look at what the buf object \nreally is:\n\n \n\nPythonWin has reassigned\n >>> buf\n pywin.framework.interact.InteractiveView instance at 00EAD014\n
sys.stdout to a special object that \nimplements the Python file interface. This works great in Python, but since \nthe special object doesn't have a FILE* pointer underlying it, fprintf doesn't \nknow what to do with it (well this will be the problem when instance conversion \nis implemented...).\n\n\n\n\nCallable and instance variables are converted to PyObject*. Nothing is done\nto there reference counts.\n\n\n >>> def a(): \n pass\n >>> inline(\"\",['a'])\n
\n\n\n /* argument conversion code */\n PyObject* a = py_to_callable(get_variable(\"a\",raw_locals,raw_globals),\"a\");\n
get_variable() reads the variable a\nfrom the local and global namespaces. The py_to_callable() and\npy_to_instance() don't currently increment the ref count.\n\n \n \nThere is no cleanup code for callables, modules, or instances.\n\n\n\n PyObject* py_to_callable(PyObject* py_obj, char* name)\n {\n if (!py_obj || !PyCallable_Check(py_obj))\n handle_bad_type(py_obj,\"callable\", name); \n return py_obj;\n }\n\n PyObject* py_to_instance(PyObject* py_obj, char* name)\n {\n if (!py_obj || !PyFile_Check(py_obj))\n handle_bad_type(py_obj,\"instance\", name); \n return py_obj;\n }\n
\nConverting from Python to C++ types is handled by xxx_specification classes. A \ntype specification class actually serve in two related but different \nroles. The first is in determining whether a Python variable that needs to be \nconverted should be represented by the given class. The second is as a code \ngenerator that generate C++ code needed to convert from Python to C++ types for \na specific variable.\n
\nWhen \n\n
\n \nis called for the first time, the code snippet has to be compiled. In this \nprocess, the variable 'a' is tested against a list of type specifications (the \ndefault list is stored in weave/ext_tools.py). The first \nspecification in the list is used to represent the variable. \n\n\n >>> a = 1\n >>> weave.inline('printf(\"%d\",a);',['a'])\n
\nExamples of xxx_specification are scattered throughout numerous \n\"xxx_spec.py\" files in the weave package. Closely related to \nthe xxx_specification classes are yyy_info classes. \nThese classes contain compiler, header, and support code information necessary \nfor including a certain set of capabilities (such as blitz++ or CXX support)\nin a compiled module. xxx_specification classes have one or more\nyyy_info classes associated with them.\n\nIf you'd like to define your own set of type specifications, the current best route\nis to examine some of the existing spec and info files. Maybe looking over\nsequence_spec.py and cxx_info.py are a good place to start. After defining \nspecification classes, you'll need to pass them into inline using the \ntype_factories argument. \n\nA lot of times you may just want to change how a specific variable type is \nrepresented. Say you'd rather have Python strings converted to \nstd::string or maybe char* instead of using the CXX \nstring object, but would like all other type conversions to have default \nbehavior. This requires that a new specification class that handles strings\nis written and then prepended to a list of the default type specifications. Since\nit is closer to the front of the list, it effectively overrides the default\nstring specification.\n\nThe following code demonstrates how this is done:\n\n...\n\n\n
\ncatalog.py has a class called catalog that helps keep \ntrack of previously compiled functions. This prevents inline() \nand related functions from having to compile functions everytime they are \ncalled. Instead, catalog will check an in memory cache to see if the function \nhas already been loaded into python. If it hasn't, then it starts searching \nthrough persisent catalogs on disk to see if it finds an entry for the given \nfunction. By saving information about compiled functions to disk, it isn't\nnecessary to re-compile functions everytime you stop and restart the interpreter.\nFunctions are compiled once and stored for future use.\n\n
\nWhen inline(cpp_code) is called the following things happen:\n
cpp_code. If an entry for cpp_code doesn't exist in the \n cache or the cached function call fails (perhaps because the function doesn't \n have compatible types) then the next step is to check the catalog. \n cpp_code. If cpp_code has\n ever been called, then this cache will be present (loaded from disk). If\n the cache isn't present, then it is loaded from disk.\n \n If the cache is present, each function in the cache is \n called until one is found that was compiled for the correct argument types. If \n none of the functions work, a new function is compiled with the given argument \n types. This function is written to the on-disk catalog as well as into the \n in-memory cache.
\ncpp_code fails, the catalog looks through \n the on-disk function catalogs for the entries. The PYTHONCOMPILED variable \n determines where to search for these catalogs and in what order. If \n PYTHONCOMPILED is not present several platform dependent locations are \n searched. All functions found for cpp_code in the path are \n loaded into the in-memory cache with functions found earlier in the search \n path closer to the front of the call list.\n \n If the function isn't found in the on-disk catalog, \n then the function is compiled, written to the first writable directory in the \n PYTHONCOMPILED path, and also loaded into the in-memory cache.
\n\nFunction caches are stored as dictionaries where the key is the entire C++\ncode string and the value is either a single function (as in the \"level 1\"\ncache) or a list of functions (as in the main catalog cache). On disk\ncatalogs are stored in the same manor using standard Python shelves.\n
\nEarly on, there was a question as to whether md5 check sums of the C++\ncode strings should be used instead of the actual code strings. I think this\nis the route inline Perl took. Some (admittedly quick) tests of the md5 vs.\nthe entire string showed that using the entire string was at least a\nfactor of 3 or 4 faster for Python. I think this is because it is more\ntime consuming to compute the md5 value than it is to do look-ups of long\nstrings in the dictionary. Look at the examples/md5_speed.py file for the\ntest run. \n\n\n
\nThe default location for catalog files on Unix is is ~/.pythonXX_compiled where \nXX is version of Python being used. If this directory doesn't exist, it is \ncreated the first time a catalog is used. The directory must be writable. If, \nfor any reason it isn't, then the catalog attempts to create a directory based \non your user id in the /tmp directory. The directory permissions are set so \nthat only you have access to the directory. If this fails, I think you're out of \nluck. I don't think either of these should ever fail though. On Windows, a \ndirectory called pythonXX_compiled is created in the user's temporary \ndirectory. \n
\nThe actual catalog file that lives in this directory is a Python shelve with\na platform specific name such as \"nt21compiled_catalog\" so that multiple OSes\ncan share the same file systems without trampling on each other. Along with\nthe catalog file, the .cpp and .so or .pyd files created by inline will live\nin this directory. The catalog file simply contains keys which are the C++\ncode strings with values that are lists of functions. The function lists point\nat functions within these compiled modules. Each function in the lists \nexecutes the same C++ code string, but compiled for different input variables.\n
\nYou can use the PYTHONCOMPILED environment variable to specify alternative\nlocations for compiled functions. On Unix this is a colon (':') separated\nlist of directories. On windows, it is a (';') separated list of directories.\nThese directories will be searched prior to the default directory for a\ncompiled function catalog. Also, the first writable directory in the list\nis where all new compiled function catalogs, .cpp and .so or .pyd files are\nwritten. Relative directory paths ('.' and '..') should work fine in the\nPYTHONCOMPILED variable as should environement variables.\n
\nThere is a \"special\" path variable called MODULE that can be placed in the \nPYTHONCOMPILED variable. It specifies that the compiled catalog should\nreside in the same directory as the module that called it. This is useful\nif an admin wants to build a lot of compiled functions during the build\nof a package and then install them in site-packages along with the package.\nUser's who specify MODULE in their PYTHONCOMPILED variable will have access\nto these compiled functions. Note, however, that if they call the function\nwith a set of argument types that it hasn't previously been built for, the\nnew function will be stored in their default directory (or some other writable\ndirectory in the PYTHONCOMPILED path) because the user will not have write\naccess to the site-packages directory.\n
\nAn example of using the PYTHONCOMPILED path on bash follows:\n\n
\n\nIf you are using python21 on linux, and the module bob.py in site-packages\nhas a compiled function in it, then the catalog search order when calling that\nfunction for the first time in a python session would be:\n\n\n PYTHONCOMPILED=MODULE:/some/path;export PYTHONCOMPILED;\n
\n\nThe default location is always included in the search path.\n\n /usr/lib/python21/site-packages/linuxpython_compiled\n /some/path/linuxpython_compiled\n ~/.python21_compiled/linuxpython_compiled\n
\n \nNote: hmmm. see a possible problem here. I should probably make a sub-\ndirectory such as /usr/lib/python21/site-\npackages/python21_compiled/linuxpython_compiled so that library files compiled \nwith python21 are tried to link with python22 files in some strange scenarios. \nNeed to check this.\n\n\n
\nThe in-module cache (in weave.inline_tools reduces the overhead \nof calling inline functions by about a factor of 2. It can be reduced a little \nmore for type loop calls where the same function is called over and over again \nif the cache was a single value instead of a dictionary, but the benefit is \nvery small (less than 5%) and the utility is quite a bit less. So, we'll stick \nwith a dictionary as the cache.\n
\nweave.blitz() compiles Numeric Python expressions for fast \nexecution. For most applications, compiled expressions should provide a \nfactor of 2-10 speed-up over Numeric arrays. Using compiled \nexpressions is meant to be as unobtrusive as possible and works much like \npythons exec statement. As an example, the following code fragment takes a 5 \npoint average of the 512x512 2d image, b, and stores it in array, a:\n\n
\n \nTo compile the expression, convert the expression to a string by putting\nquotes around it and then use\n from scipy import * # or from Numeric import *\n a = ones((512,512), Float64) \n b = ones((512,512), Float64) \n # ...do some stuff to fill in b...\n # now average\n a[1:-1,1:-1] = (b[1:-1,1:-1] + b[2:,1:-1] + b[:-2,1:-1] \\\n + b[1:-1,2:] + b[1:-1,:-2]) / 5.\n
weave.blitz:\n\n \n\nThe first time\n import weave\n expr = \"a[1:-1,1:-1] = (b[1:-1,1:-1] + b[2:,1:-1] + b[:-2,1:-1]\" \\\n \"+ b[1:-1,2:] + b[1:-1,:-2]) / 5.\"\n weave.blitz(expr)\n
weave.blitz is run for a given expression and \nset of arguements, C++ code that accomplishes the exact same task as the Python \nexpression is generated and compiled to an extension module. This can take up \nto a couple of minutes depending on the complexity of the function. Subsequent \ncalls to the function are very fast. Futher, the generated module is saved \nbetween program executions so that the compilation is only done once for a \ngiven expression and associated set of array types. If the given expression\nis executed with a new set of array types, the code most be compiled again. This\ndoes not overwrite the previously compiled function -- both of them are saved and\navailable for exectution. \n\nThe following table compares the run times for standard Numeric code and \ncompiled code for the 5 point averaging.\n
\n
| Method | Run Time (seconds) |
| Standard Numeric | 0.46349 |
| blitz (1st time compiling) | 78.95526 |
| blitz (subsequent calls) | 0.05843 (factor of 8 speedup) |
\nThese numbers are for a 512x512 double precision image run on a 400 MHz Celeron \nprocessor under RedHat Linux 6.2.\n
\nBecause of the slow compile times, its probably most effective to develop \nalgorithms as you usually do using the capabilities of scipy or the Numeric \nmodule. Once the algorithm is perfected, put quotes around it and execute it \nusing weave.blitz. This provides the standard rapid \nprototyping strengths of Python and results in algorithms that run close to \nthat of hand coded C or Fortran.\n\n\n
weave.blitz has only been tested under Linux \nwith gcc-2.95-3 and on Windows with Mingw32 (2.95.2). Its compiler \nrequirements are pretty heavy duty (see the \nblitz++ home page), so it won't \nwork with just any compiler. Particularly MSVC++ isn't up to snuff. A number \nof other compilers such as KAI++ will also work, but my suspicions are that gcc \nwill get the most use.\n\n\nweave.blitz handles all standard mathematic \noperators except for the ** power operator. The built-in trigonmetric, log, \nfloor/ceil, and fabs functions might work (but haven't been tested). It also \nhandles all types of array indexing supported by the Numeric module. \n\nweave.blitz does not currently support operations that use \narray broadcasting, nor have any of the special purpose functions in Numeric \nsuch as take, compress, etc. been implemented. Note that there are no obvious \nreasons why most of this functionality cannot be added to scipy.weave, so it \nwill likely trickle into future versions. Using slice() objects \ndirectly instead of start:stop:step is also not supported.\n
\n\nThis means that the result array must exist before calling \n\n >>> result = b + c + d\n
weave.blitz. Future versions will allow the following:\n\n \n\n >>> result = weave.blitz_eval(\"b + c + d\")\n
weave.blitz works best when algorithms can be expressed in a \n\"vectorized\" form. Algorithms that have a large number of if/thens and other \nconditions are better hand written in C or Fortran. Further, the restrictions \nimposed by requiring vectorized expressions sometimes preclude the use of more \nefficient data structures or algorithms. For maximum speed in these cases, \nhand-coded C or Fortran code is the only way to go.\nweave.blitz can produce different results than Numeric in certain \nsituations. It can happen when the array receiving the results of a \ncalculation is also used during the calculation. The Numeric behavior is to \ncarry out the entire calculation on the right hand side of an equation and \nstore it in a temporary array. This temprorary array is assigned to the array \non the left hand side of the equation. blitz, on the other hand, does a \n\"running\" calculation of the array elements assigning values from the right hand\nside to the elements on the left hand side immediately after they are calculated.\nHere is an example, provided by Prabhu Ramachandran, where this happens:\n\n \n \n You can prevent this behavior by using a temporary array.\n \n\n # 4 point average.\n >>> expr = \"u[1:-1, 1:-1] = (u[0:-2, 1:-1] + u[2:, 1:-1] + \"\\\n ... \"u[1:-1,0:-2] + u[1:-1, 2:])*0.25\"\n >>> u = zeros((5, 5), 'd'); u[0,:] = 100\n >>> exec (expr)\n >>> u\n array([[ 100., 100., 100., 100., 100.],\n [ 0., 25., 25., 25., 0.],\n [ 0., 0., 0., 0., 0.],\n [ 0., 0., 0., 0., 0.],\n [ 0., 0., 0., 0., 0.]])\n \n >>> u = zeros((5, 5), 'd'); u[0,:] = 100\n >>> weave.blitz (expr)\n >>> u\n array([[ 100. , 100. , 100. , 100. , 100. ],\n [ 0. , 25. , 31.25 , 32.8125 , 0. ],\n [ 0. , 6.25 , 9.375 , 10.546875 , 0. ],\n [ 0. , 1.5625 , 2.734375 , 3.3203125, 0. ],\n [ 0. , 0. , 0. , 0. , 0. ]]) \n
\n \n\n >>> u = zeros((5, 5), 'd'); u[0,:] = 100\n >>> temp = zeros((4, 4), 'd');\n >>> expr = \"temp = (u[0:-2, 1:-1] + u[2:, 1:-1] + \"\\\n ... \"u[1:-1,0:-2] + u[1:-1, 2:])*0.25;\"\\\n ... \"u[1:-1,1:-1] = temp\"\n >>> weave.blitz (expr)\n >>> u\n array([[ 100., 100., 100., 100., 100.],\n [ 0., 25., 25., 25., 0.],\n [ 0., 0., 0., 0., 0.],\n [ 0., 0., 0., 0., 0.],\n [ 0., 0., 0., 0., 0.]])\n
weave.blitz is not a general purpose Python->C compiler. It \nonly works for expressions that contain Numeric arrays and/or \nPython scalar values. This focused scope concentrates effort on the \ncompuationally intensive regions of the program and sidesteps the difficult \nissues associated with a general purpose Python->C compiler.\n\n \nWhen Numeric calculates the value for the 2d array,\n a = 1.2 * b + c * d\n
a, it does \nthe following steps:\n\n \n \nTwo things to note. Since\n temp1 = 1.2 * b\n temp2 = c * d\n a = temp1 + temp2\n
c is an (perhaps large) array, a large \ntemporary array must be created to store the results of 1.2 * b. \nThe same is true for temp2. Allocation is slow. The second thing \nis that we have 3 loops executing, one to calculate temp1, one for \ntemp2 and one for adding them up. A C loop for the same problem \nmight look like:\n\n \n \nHere, the 3 loops have been fused into a single loop and there is no longer\na need for a temporary array. This provides a significant speed improvement\nover the above example (write me and tell me what you get). \n\n for(int i = 0; i < M; i++)\n for(int j = 0; j < N; j++)\n a[i,j] = 1.2 * b[i,j] + c[i,j] * d[i,j]\n
\nSo, converting Numeric expressions into C/C++ loops that fuse the loops and \neliminate temporary arrays can provide big gains. The goal then,is to convert \nNumeric expression to C/C++ loops, compile them in an extension module, and \nthen call the compiled extension function. The good news is that there is an \nobvious correspondence between the Numeric expression above and the C loop. The \nbad news is that Numeric is generally much more powerful than this simple \nexample illustrates and handling all possible indexing possibilities results in \nloops that are less than straight forward to write. (take a peak in Numeric for \nconfirmation). Luckily, there are several available tools that simplify the \nprocess.\n\n\n
weave.blitz relies heavily on several remarkable tools. On the \nPython side, the main facilitators are Jermey Hylton's parser module and Jim \nHuginin's Numeric module. On the compiled language side, Todd Veldhuizen's \nblitz++ array library, written in C++ (shhhh. don't tell David Beazley), does \nthe heavy lifting. Don't assume that, because it's C++, it's much slower than C \nor Fortran. Blitz++ uses a jaw dropping array of template techniques \n(metaprogramming, template expression, etc) to convert innocent looking and \nreadable C++ expressions into to code that usually executes within a few \npercentage points of Fortran code for the same problem. This is good. \nUnfortunately all the template raz-ma-taz is very expensive to compile, so the \n200 line extension modules often take 2 or more minutes to compile. This isn't so \ngood. weave.blitz works to minimize this issue by remembering \nwhere compiled modules live and reusing them instead of re-compiling every time \na program is re-run.\n\n\nparser module. \nThe following fragment creates an Abstract Syntax Tree (AST) object for the \nexpression and then converts to a (rather unpleasant looking) deeply nested list \nrepresentation of the tree. \n \n \n\nDespite its looks, with some tools developed by Jermey H., its possible\nto search these trees for specific patterns (sub-trees), extract the \nsub-tree, manipulate them converting python specific code fragments\nto blitz code fragments, and then re-insert it in the parse tree. The parser\nmodule documentation has some details on how to do this. Traversing the \nnew blitzified tree, writing out the terminal symbols as you go, creates\nour new blitz++ expression string.\n\n \n\n >>> import parser\n >>> import scipy.weave.misc\n >>> ast = parser.suite(\"a = b * c + d\")\n >>> ast_list = ast.tolist()\n >>> sym_list = scipy.weave.misc.translate_symbols(ast_list)\n >>> pprint.pprint(sym_list)\n ['file_input',\n ['stmt',\n ['simple_stmt',\n ['small_stmt',\n ['expr_stmt',\n ['testlist',\n ['test',\n ['and_test',\n ['not_test',\n ['comparison',\n ['expr',\n ['xor_expr',\n ['and_expr',\n ['shift_expr',\n ['arith_expr',\n ['term',\n ['factor', ['power', ['atom', ['NAME', 'a']]]]]]]]]]]]]]],\n ['EQUAL', '='],\n ['testlist',\n ['test',\n ['and_test',\n ['not_test',\n ['comparison',\n ['expr',\n ['xor_expr',\n ['and_expr',\n ['shift_expr',\n ['arith_expr',\n ['term',\n ['factor', ['power', ['atom', ['NAME', 'b']]]],\n ['STAR', '*'],\n ['factor', ['power', ['atom', ['NAME', 'c']]]]],\n ['PLUS', '+'],\n ['term',\n ['factor', ['power', ['atom', ['NAME', 'd']]]]]]]]]]]]]]]]],\n ['NEWLINE', '']]],\n ['ENDMARKER', '']]\n
\n\n\nIn Blitz it is as follows:\n\n\n >>> a = b[0:4:2] + c\n >>> a\n [0,2,4]\n
\n\n\nHere the range object works exactly like Python slice objects with the exception\nthat the top index (3) is inclusive where as Python's (4) is exclusive. Other \ndifferences include the type declaraions in C++ and parentheses instead of \nbrackets for indexing arrays. Currently,\n Array<2,int> b(10);\n Array<2,int> c(3);\n // ...\n Array<2,int> a = b(Range(0,3,2)) + c;\n
weave.blitz handles the \ninclusive/exclusive issue by subtracting one from upper indices during the\ntranslation. An alternative that is likely more robust/maintainable in the \nlong run, is to write a PyRange class that behaves like Python's range. \nThis is likely very easy.\n\nThe stock blitz also doesn't handle negative indices in ranges. The current \nimplementation of the blitz() has a partial solution to this \nproblem. It calculates and index that starts with a '-' sign by subtracting it \nfrom the maximum index in the array so that:\n\n
\n\nThis approach fails, however, when the top index is calculated from other \nvalues. In the following scenario, if\n upper index limit\n /-----\\\n b[:-1] -> b(Range(0,Nb[0]-1-1))\n
i+j evaluates to a negative \nvalue, the compiled code will produce incorrect results and could even core-\ndump. Right now, all calculated indices are assumed to be positive.\n \n \n\nA solution is to calculate all indices up front using if/then to handle the\n+/- cases. This is a little work and results in more code, so it hasn't been\ndone. I'm holding out to see if blitz++ can be modified to handle negative\nindexing, but haven't looked into how much effort is involved yet. While it \nneeds fixin', I don't think there is a ton of code where this is an issue.\n\n b[:i-j] -> b(Range(0,i+j))\n
\nThe actual translation of the Python expressions to blitz expressions is \ncurrently a two part process. First, all x:y:z slicing expression are removed\nfrom the AST, converted to slice(x,y,z) and re-inserted into the tree. Any\nmath needed on these expressions (subtracting from the \nmaximum index, etc.) are also preformed here. _beg and _end are used as special\nvariables that are defined as blitz::fromBegin and blitz::toEnd.\n\n
\n\nbecomes a more verbose:\n \n\n a[i+j:i+j+1,:] = b[2:3,:] \n
\n \nThe second part does a simple string search/replace to convert to a blitz \nexpression with the following translations:\n\n\n a[slice(i+j,i+j+1),slice(_beg,_end)] = b[slice(2,3),slice(_beg,_end)]\n
\n\n\n slice(_beg,_end) -> _all # not strictly needed, but cuts down on code.\n slice -> blitz::Range\n [ -> (\n ] -> )\n _stp -> 1\n
_all is defined in the compiled function as \nblitz::Range.all(). These translations could of course happen \ndirectly in the syntax tree. But the string replacement is slightly easier. \nNote that name spaces are maintained in the C++ code to lessen the likelyhood \nof name clashes. Currently no effort is made to detect name clashes. A good \nrule of thumb is don't use values that start with '_' or 'py_' in compiled \nexpressions and you'll be fine.\n\n \nweave.blitz handles this issue by examining the types of the\nvariables in the expression being executed, and compiling a function for those\nexplicit types. For example:\n\n \n\nWhen compiling this expression to C++,\n a = ones((5,5),Float32)\n b = ones((5,5),Float32)\n weave.blitz(\"a = a + b\")\n
weave.blitz sees that the\nvalues for a and b in the local scope have type Float32, or 'float'\non a 32 bit architecture. As a result, it compiles the function using \nthe float type (no attempt has been made to deal with 64 bit issues).\nIt also goes one step further. If all arrays have the same type, a templated\nversion of the function is made and instantiated for float, double, \ncomplex\nWhat happens if you call a compiled function with array types that are \ndifferent than the ones for which it was originally compiled? No biggie, you'll \njust have to wait on it to compile a new version for your new types. This \ndoesn't overwrite the old functions, as they are still accessible. See the \ncatalog section in the inline() documentation to see how this is handled. \nSuffice to say, the mechanism is transparent to the user and behaves \nlike dynamic typing with the occasional wait for compiling newly typed \nfunctions.\n
\nWhen working with combined scalar/array operations, the type of the array is \nalways used. This is similar to the savespace flag that was recently \nadded to Numeric. This prevents issues with the following expression perhaps \nunexpectedly being calculated at a higher (more expensive) precision that can \noccur in Python:\n\n
\n \nIn this example, \n\n\n >>> a = array((1,2,3),typecode = Float32)\n >>> b = a * 2.1 # results in b being a Float64 array.\n
\n \nthe\n >>> a = ones((5,5),Float32)\n >>> b = ones((5,5),Float32)\n >>> weave.blitz(\"b = a * 2.1\")\n
2.1 is cast down to a float before carrying out \nthe operation. If you really want to force the calculation to be a \ndouble, define a and b as \ndouble arrays.\n\nOne other point of note. Currently, you must include both the right hand side \nand left hand side (assignment side) of your equation in the compiled \nexpression. Also, the array being assigned to must be created prior to calling \nweave.blitz. I'm pretty sure this is easily changed so that a \ncompiled_eval expression can be defined, but no effort has been made to \nallocate new arrays (and decern their type) on the fly.\n\n \n
weave.inline() documentation.\n\n \n\n \nIt only requires that arrays\n a = b + c\n
a, b, and c \nhave the same shape. However, expressions like:\n\n \n\nare not so trivial. Since slicing is involved, the size of the slices, not the \ninput arrays must be checked. Broadcasting complicates things further because \narrays and slices with different dimensions and shapes may be compatible for \nmath operations (broadcasting isn't yet supported by \n\n a[i+j:i+j+1,:] = b[2:3,:] + c\n
weave.blitz). Reductions have a similar effect as their \nresults are different shapes than their input operand. The binary operators in \nNumeric compare the shapes of their two operands just before they operate on \nthem. This is possible because Numeric treats each operation independently. \nThe intermediate (temporary) arrays created during sub-operations in an \nexpression are tested for the correct shape before they are combined by another \noperation. Because weave.blitz fuses all operations into a \nsingle loop, this isn't possible. The shape comparisons must be done and \nguaranteed compatible before evaluating the expression.\n\nThe solution chosen converts input arrays to \"dummy arrays\" that only represent \nthe dimensions of the arrays, not the data. Binary operations on dummy arrays \ncheck that input array sizes are comptible and return a dummy array with the \nsize correct size. Evaluating an expression of dummy arrays traces the \nchanging array sizes through all operations and fails if incompatible array \nsizes are ever found. \n
\nThe machinery for this is housed in weave.size_check. It \nbasically involves writing a new class (dummy array) and overloading it math \noperators to calculate the new sizes correctly. All the code is in Python and \nthere is a fair amount of logic (mainly to handle indexing and slicing) so the \noperation does impose some overhead. For large arrays (ie. 50x50x50), the \noverhead is negligible compared to evaluating the actual expression. For small \narrays (ie. 16x16), the overhead imposed for checking the shapes with this \nmethod can cause the weave.blitz to be slower than evaluating \nthe expression in Python. \n
\nWhat can be done to reduce the overhead? (1) The size checking code could be \nmoved into C. This would likely remove most of the overhead penalty compared \nto Numeric (although there is also some calling overhead), but no effort has \nbeen made to do this. (2) You can also call weave.blitz with\ncheck_size=0 and the size checking isn't done. However, if the \nsizes aren't compatible, it can cause a core-dump. So, foregoing size_checking\nisn't advisable until your code is well debugged.\n\n \n
weave.blitz uses the same machinery as \nweave.inline to build the extension module. The only difference\nis the code included in the function is automatically generated from the\nNumeric array expression instead of supplied by the user.\n\n\nweave.inline and weave.blitz are high level tools\nthat generate extension modules automatically. Under the covers, they use several\nclasses from weave.ext_tools to help generate the extension module.\nThe main two classes are ext_module and ext_function (I'd\nlike to add ext_class and ext_method also). These classes\nsimplify the process of generating extension modules by handling most of the \"boiler\nplate\" code automatically.\n\n\nNote: inline actually sub-classes weave.ext_tools.ext_function \nto generate slightly different code than the standard ext_function.\nThe main difference is that the standard class converts function arguments to\nC types, while inline always has two arguments, the local and global dicts, and\nthe grabs the variables that need to be convereted to C from these.\n\n\n\n\n\n\nThe function\n # examples/increment_example.py\n from weave import ext_tools\n \n def build_increment_ext():\n \"\"\" Build a simple extension with functions that increment numbers.\n The extension will be built in the local directory.\n \"\"\" \n mod = ext_tools.ext_module('increment_ext')\n \n a = 1 # effectively a type declaration for 'a' in the \n # following functions.\n \n ext_code = \"return_val = Py::new_reference_to(Py::Int(a+1));\" \n func = ext_tools.ext_function('increment',ext_code,['a'])\n mod.add_function(func)\n \n ext_code = \"return_val = Py::new_reference_to(Py::Int(a+2));\" \n func = ext_tools.ext_function('increment_by_2',ext_code,['a'])\n mod.add_function(func)\n \n mod.compile()\n
build_increment_ext() creates an extension module \nnamed increment_ext and compiles it to a shared library (.so or \n.pyd) that can be loaded into Python.. increment_ext contains two \nfunctions, increment and increment_by_2. \n\nThe first line of build_increment_ext(),\n\n \n\ncreates an\n mod = ext_tools.ext_module('increment_ext') \n
ext_module instance that is ready to have \next_function instances added to it. ext_function \ninstances are created much with a calling convention similar to \nweave.inline(). The most common call includes a C/C++ code \nsnippet and a list of the arguments for the function. The following\n\n \n \ncreates a C/C++ extension function that is equivalent to the following Python\nfunction:\n\n\n ext_code = \"return_val = Py::new_reference_to(Py::Int(a+1));\" \n func = ext_tools.ext_function('increment',ext_code,['a'])\n
\n\nA second method is also added to the module and then,\n\n\n def increment(a):\n return a + 1\n
\n\nis called to build the extension module. By default, the module is created\nin the current working directory.\n\nThis example is available in the\n mod.compile()\n
examples/increment_example.py file\nfound in the weave directory. At the bottom of the file in the\nmodule's \"main\" program, an attempt to import increment_ext without\nbuilding it is made. If this fails (the module doesn't exist in the PYTHONPATH), \nthe module is built by calling build_increment_ext(). This approach\nonly takes the time consuming ( a few seconds for this example) process of building\nthe module if it hasn't been built before.\n\n \n\n\nNote: If we were willing to always pay the penalty of building the C++ code for \na module, we could store the md5 checksum of the C++ code along with some \ninformation about the compiler, platform, etc. Then, \n\n if __name__ == \"__main__\":\n try:\n import increment_ext\n except ImportError:\n build_increment_ext()\n import increment_ext\n a = 1\n print 'a, a+1:', a, increment_ext.increment(a)\n print 'a, a+2:', a, increment_ext.increment_by_2(a) \n
ext_module.compile() could try importing the module before it actually\ncompiles it, check the md5 checksum and other meta-data in the imported module\nwith the meta-data of the code it just produced and only compile the code if\nthe module didn't exist or the meta-data didn't match. This would reduce the\nabove code to:\n\n \n\nNote: There would always be the overhead of building the C++ code, but it would only actually compile the code once. You pay a little in overhead and get cleaner\n\"import\" code. Needs some thought.\n\n\n if __name__ == \"__main__\":\n build_increment_ext()\n\n a = 1\n print 'a, a+1:', a, increment_ext.increment(a)\n print 'a, a+2:', a, increment_ext.increment_by_2(a) \n
\n\nIf you run increment_example.py from the command line, you get\nthe following:\n\n
\n\nIf the module didn't exist before it was run, the module is created. If it did\nexist, it is just imported and used.\n\n\n\n [eric@n0]$ python increment_example.py\n a, a+1: 1 2\n a, a+2: 1 3\n
examples/fibonacci.py provides a little more complex example of \nhow to use ext_tools. Fibonacci numbers are a series of numbers \nwhere each number in the series is the sum of the previous two: 1, 1, 2, 3, 5, \n8, etc. Here, the first two numbers in the series are taken to be 1. One \napproach to calculating Fibonacci numbers uses recursive function calls. In \nPython, it might be written as:\n\n \n\nIn C, the same function would look something like this:\n\n\n def fib(a):\n if a <= 2:\n return 1\n else:\n return fib(a-2) + fib(a-1)\n
\n\nRecursion is much faster in C than in Python, so it would be beneficial\nto use the C version for fibonacci number calculations instead of the\nPython version. We need an extension function that calls this C function\nto do this. This is possible by including the above code snippet as \n\"support code\" and then calling it from the extension function. Support \ncode snippets (usually structure definitions, helper functions and the like)\nare inserted into the extension module C/C++ file before the extension\nfunction code. Here is how to build the C version of the fibonacci number\ngenerator:\n\n\n int fib(int a)\n { \n if(a <= 2)\n return 1;\n else\n return fib(a-2) + fib(a-1); \n } \n
\n\nXXX More about custom_info, and what xxx_info instances are good for.\n\n\ndef build_fibonacci():\n \"\"\" Builds an extension module with fibonacci calculators.\n \"\"\"\n mod = ext_tools.ext_module('fibonacci_ext')\n a = 1 # this is effectively a type declaration\n \n # recursive fibonacci in C \n fib_code = \"\"\"\n int fib1(int a)\n { \n if(a <= 2)\n return 1;\n else\n return fib1(a-2) + fib1(a-1); \n } \n \"\"\"\n ext_code = \"\"\"\n int val = fib1(a);\n return_val = Py::new_reference_to(Py::Int(val));\n \"\"\" \n fib = ext_tools.ext_function('fib',ext_code,['a'])\n fib.customize.add_support_code(fib_code)\n mod.add_function(fib)\n\n mod.compile()\n\n
\n\nNote: recursion is not the fastest way to calculate fibonacci numbers, but this \napproach serves nicely for this example.\n\n
weave didstdio.h) For instance, if you\ntry to pass in a variable named stdout, you'll get a cryptic error report\ndue to the fact that stdio.h also defines the name. weave\nshould probably try and handle this in some way.\n\nOther things...",
"source_code_before": "\n\nBy Eric Jones eric@enthought.com\n
\n
\nThe weave package provides tools for including C/C++ code within\nin Python code. This offers both another level of optimization to those who need \nit, and an easy way to modify and extend any supported extension libraries such \nas wxPython and hopefully VTK soon. Inlining C/C++ code within Python generally\nresults in speed ups of 1.5x to 30x speed-up over algorithms written in pure\nPython (However, it is also possible to slow things down...). Generally \nalgorithms that require a large number of calls to the Python API don't benefit\nas much from the conversion to C/C++ as algorithms that have inner loops \ncompletely convertable to C.\n
\nThere are three basic ways to use weave. The \nweave.inline() function executes C code directly within Python, \nand weave.blitz() translates Python Numeric expressions to C++ \nfor fast execution. blitz() was the original reason \nweave was built. For those interested in building extension\nlibraries, the ext_tools module provides classes for building \nextension modules within Python. \n
\nMost of weave's functionality should work on Windows and Unix, \nalthough some of its functionality requires gcc or a similarly \nmodern C++ compiler that handles templates well. Up to now, most testing has \nbeen done on Windows 2000 with Microsoft's C++ compiler (MSVC) and with gcc \n(mingw32 2.95.2 and 2.95.3-6). All tests also pass on Linux (RH 7.1 \nwith gcc 2.96), and I've had reports that it works on Debian also (thanks \nPearu).\n
\nThe inline and blitz provide new functionality to \nPython (although I've recently learned about the PyInline project which may offer \nsimilar functionality to inline). On the other hand, tools for \nbuilding Python extension modules already exists (SWIG, SIP, pycpp, CXX, and \nothers). As of yet, I'm not sure where weave fits in this \nspectrum. It is closest in flavor to CXX in that it makes creating new C/C++ \nextension modules pretty easy. However, if you're wrapping a gaggle of legacy \nfunctions or classes, SWIG and friends are definitely the better choice. \nweave is set up so that you can customize how Python types are \nconverted to C types in weave. This is great for \ninline(), but, for wrapping legacy code, it is more flexible to \nspecify things the other way around -- that is how C types map to Python types. \nThis weave does not do. I guess it would be possible to build \nsuch a tool on top of weave, but with good tools like SWIG around, \nI'm not sure the effort produces any new capabilities. Things like function \noverloading are probably easily implemented in weave and it might \nbe easier to mix Python/C code in function calls, but nothing beyond this comes \nto mind. So, if you're developing new extension modules or optimizing Python \nfunctions in C, weave.ext_tools() might be the tool \nfor you. If you're wrapping legacy code, stick with SWIG.\n
\nThe next several sections give the basics of how to use weave.\nWe'll discuss what's happening under the covers in more detail later \non. Serious users will need to at least look at the type conversion section to \nunderstand how Python variables map to C/C++ types and how to customize this \nbehavior. One other note. If you don't know C or C++ then these docs are \nprobably of very little help to you. Further, it'd be helpful if you know \nsomething about writing Python extensions. weave does quite a \nbit for you, but for anything complex, you'll need to do some conversions, \nreference counting, etc.\n
\n\nNote: weave is actually part of the SciPy package. However, it works fine as a \nstandalone package. The examples here are given as if it is used as a stand \nalone package. If you are using from within scipy, you can use from \nscipy import weave and the examples will work identically.\n\n\n
\n I use 2.1.1. Probably 2.0 or higher should work.\n
\n
\n weave uses distutils to actually build \n extension modules, so it uses whatever compiler was originally used to \n build Python. weave itself requires a C++ compiler. If \n you used a C++ compiler to build Python, your probably fine.\n
\n On Unix gcc is the preferred choice because I've done a little \n testing with it. All testing has been done with gcc, but I expect the \n majority of compilers should work for inline and \n ext_tools. The one issue I'm not sure about is that I've \n hard coded things so that compilations are linked with the \n stdc++ library. Is this standard across \n Unix compilers, or is this a gcc-ism?\n
\n For blitz(), you'll need a reasonably recent version of \n gcc. 2.95.2 works on windows and 2.96 looks fine on Linux. Other \n versions are likely to work. Its likely that KAI's C++ compiler and \n maybe some others will work, but I haven't tried. My advice is to use \n gcc for now unless your willing to tinker with the code some.\n
\n On Windows, either MSVC or gcc (www.mingw.org\" > mingw32) should work. Again, \n you'll need gcc for blitz() as the\n MSVC compiler doesn't handle templates well.\n
\n I have not tried Cygwin, so please report success if it works for you.\n
\n
\n The python Numeric module from here. is required for \n blitz() to work. Be sure and get NumPy, not NumArray\n which is the \"next generation\" implementation. This is not\n required for using inline() or ext_tools.\n
\n
weave)\n \n These two modules are packaged with weave in both\n the windows installer and the source distributions. If you are using\n CVS, however, you'll need to download these separately (also available\n through CVS at SciPy).\n
\n
\nThere are currently two ways to get weave. Fist, \nweave is part of SciPy and installed automatically (as a sub-\npackage) whenever SciPy is installed (although the latest version isn't in \nSciPy yet, so use this one for now). Second, since weave is \nuseful outside of the scientific community, it has been setup so that it can be\nused as a stand-alone module. \n\n
\nThe stand-alone version can be downloaded from here. Unix users should grab the \ntar ball (.tgz file) and install it using the following commands.\n\n
\n\nThis will also install two other packages,\n tar -xzvf weave-0.2.tar.gz\n cd weave-0.2\n python setup.py install\n
scipy_distutils and \nscipy_test. The first is needed by the setup process itself and \nboth are used in the unit-testing process. Numeric is required if you want to \nuse blitz(), but isn't necessary for inline() or \next_tools\n\nFor Windows users, it's even easier. You can download the click-install .exe \nfile and run it for automatic installation. There is also a .zip file of the\nsource for those interested. It also includes a setup.py file to simplify\ninstallation. \n
\nIf you're using the CVS version, you'll need to install \nscipy_distutils and scipy_test packages (also \navailable from CVS) on your own.\n
\n \nNote: The dependency issue here is a little sticky. I hate to make people \ndownload more than one file (and so I haven't), but distutils doesn't have a \nway to do conditional installation -- at least that I know about. This can \nlead to undesired clobbering of the scipy_test and scipy_distutils modules. \nWhat to do, what to do... Right now it is a very minor issue.\n\n
weave is installed, fire up python and run its unit tests.\n\n \n\nThis takes a loooong time. On windows, it is usually several minutes. On Unix \nwith remote file systems, I've had it take 15 or so minutes. In the end, it \nshould run about 180 tests and spew some speed results along the way. If you \nget errors, they'll be reported at the end of the output. Please let me know\nwhat if this occurs.\n\nIf you don't have Numeric installed, you'll get some module import errors \nduring the test setup phase for modules that are Numeric specific (blitz_spec, \nblitz_tools, size_check, standard_array_spec, ast_tools), but all test should\npass (about 100 and they should complete in several minutes).\n\n >>> import weave\n >>> weave.test()\n runs long time... spews tons of output and a few warnings\n .\n .\n .\n ..............................................................\n ................................................................\n ..................................................\n ----------------------------------------------------------------------\n Ran 184 tests in 158.418s\n\n OK\n\n >>> \n
\nIf you only want to test a single module of the package, you can do this by\nrunning test() for that specific module.\n\n
\n\nTesting Notes:\n\n >>> import weave.scalar_spec\n >>> weave.scalar_spec.test()\n .......\n ----------------------------------------------------------------------\n Ran 7 tests in 23.284s\n
\n I've had some test fail on windows machines where I have msvc, gcc-2.95.2 \n (in c:\\gcc-2.95.2), and gcc-2.95.3-6 (in c:\\gcc) all installed. My \n environment has c:\\gcc in the path and does not have c:\\gcc-2.95.2 in the \n path. The test process runs very smoothly until the end where several test \n using gcc fail with cpp0 not found by g++. If I check os.system('gcc -v') \n before running tests, I get gcc-2.95.3-6. If I check after running tests \n (and after failure), I get gcc-2.95.2. ??huh??. The os.environ['PATH'] \n still has c:\\gcc first in it and is not corrupted (msvc/distutils messes \n with the environment variables, so we have to undo its work in some \n places). If anyone else sees this, let me know - - it may just be an quirk \n on my machine (unlikely). Testing with the gcc- 2.95.2 installation always \n works.\n
\n
\n If you run the tests from PythonWin or some other GUI tool, you'll get a\n ton of DOS windows popping up periodically as weave spawns\n the compiler multiple times. Very annoying. Anyone know how to fix this?\n
\n
\n wxPython tests are not enabled by default because importing wxPython on a \n Unix machine without access to a X-term will cause the program to exit. \n Anyone know of a safe way to detect whether wxPython can be imported and \n whether a display exists on a machine? \n
\n
weave/example \ndirectory and also from the test scripts. Without more information about what \nthe test actually do, their value is limited. Still, their here for the \ncurious. Look at the example scripts for more specifics about what problem was \nactually solved by each run. These examples are run under windows 2000 using \nMicrosoft Visual C++ and python2.1 on a 850 MHz PIII laptop with 320 MB of RAM.\nSpeed up is the improvement (degredation) factor of weave compared to \nconventional Python functions. The blitz() comparisons are shown\ncompared to Numeric.\n\n
| \n inline and ext_tools | |
Algorithm | Speed up |
| binary search | 1.50 |
| fibonacci (recursive) | 82.10 |
| fibonacci (loop) | 9.17 |
| return None | 0.14 |
| map | 1.20 |
| dictionary sort | 2.54 |
| vector quantization | 37.40 |
| \n blitz -- double precision | |
Algorithm | Speed up |
| a = b + c 512x512 | 3.05 |
| a = b + c + d 512x512 | 4.59 |
| 5 pt avg. filter, 2D Image 512x512 | 9.01 |
| Electromagnetics (FDTD) 100x100x100 | 8.61 |
\n\nThe benchmarks shown blitz in the best possible light. Numeric \n(at least on my machine) is significantly worse for double precision than it is \nfor single precision calculations. If your interested in single precision \nresults, you can pretty much divide the double precision speed up by 3 and you'll\nbe close.\n\n\n
\ninline() compiles and executes C/C++ code on the fly. Variables \nin the local and global Python scope are also available in the C/C++ code. \nValues are passed to the C/C++ code by assignment much like variables \nare passed into a standard Python function. Values are returned from the C/C++ \ncode through a special argument called return_val. Also, the contents of \nmutable objects can be changed within the C/C++ code and the changes remain \nafter the C code exits and returns to Python. (more on this later)\n
\nHere's a trivial printf example using inline():\n\n
\n\n >>> import weave \n >>> a = 1\n >>> weave.inline('printf(\"%d\\\\n\",a);',['a'])\n 1\n
\nIn this, its most basic form, inline(c_code, var_list) requires two \narguments. c_code is a string of valid C/C++ code. \nvar_list is a list of variable names that are passed from \nPython into C/C++. Here we have a simple printf statement that \nwrites the Python variable a to the screen. The first time you run \nthis, there will be a pause while the code is written to a .cpp file, compiled \ninto an extension module, loaded into Python, cataloged for future use, and \nexecuted. On windows (850 MHz PIII), this takes about 1.5 seconds when using \nMicrosoft's C++ compiler (MSVC) and 6-12 seconds using gcc (mingw32 2.95.2). \nAll subsequent executions of the code will happen very quickly because the code \nonly needs to be compiled once. If you kill and restart the interpreter and then \nexecute the same code fragment again, there will be a much shorter delay in the \nfractions of seconds range. This is because weave stores a \ncatalog of all previously compiled functions in an on disk cache. When it sees \na string that has been compiled, it loads the already compiled module and \nexecutes the appropriate function. \n
\n\nNote: If you try the printf example in a GUI shell such as IDLE, \nPythonWin, PyShell, etc., you're unlikely to see the output. This is because the \nC code is writing to stdout, instead of to the GUI window. This doesn't mean \nthat inline doesn't work in these environments -- it only means that standard \nout in C is not the same as the standard out for Python in these cases. Non \ninput/output functions will work as expected.\n\n
\nAlthough effort has been made to reduce the overhead associated with calling \ninline, it is still less efficient for simple code snippets than using \nequivalent Python code. The simple printf example is actually \nslower by 30% or so than using Python print statement. And, it is \nnot difficult to create code fragments that are 8-10 times slower using inline \nthan equivalent Python. However, for more complicated algorithms, \nthe speed up can be worth while -- anywhwere from 1.5- 30 times faster. \nAlgorithms that have to manipulate Python objects (sorting a list) usually only \nsee a factor of 2 or so improvement. Algorithms that are highly computational \nor manipulate Numeric arrays can see much larger improvements. The \nexamples/vq.py file shows a factor of 30 or more improvement on the vector \nquantization algorithm that is used heavily in information theory and \nclassification problems.\n
\nMSVC users will actually see a bit of compiler output that distutils does not\nsupress the first time the code executes:\n\n
\n\n >>> weave.inline(r'printf(\"%d\\n\",a);',['a'])\n sc_e013937dbc8c647ac62438874e5795131.cpp\n Creating library C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\n \\Release\\sc_e013937dbc8c647ac62438874e5795131.lib and object C:\\DOCUME\n ~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_e013937dbc8c64\n 7ac62438874e5795131.exp\n 1\n
\nNothing bad is happening, its just a bit annoying. Anyone know how to \nturn this off? \n
\nThis example also demonstrates using 'raw strings'. The r \npreceeding the code string in the last example denotes that this is a 'raw \nstring'. In raw strings, the backslash character is not interpreted as an \nescape character, and so it isn't necessary to use a double backslash to \nindicate that the '\\n' is meant to be interpreted in the C printf \nstatement instead of by Python. If your C code contains a lot\nof strings and control characters, raw strings might make things easier.\nMost of the time, however, standard strings work just as well.\n\n
\nThe printf statement in these examples is formatted to print \nout integers. What happens if a is a string? inline\nwill happily, compile a new version of the code to accept strings as input,\nand execute the code. The result?\n\n
\n\n >>> a = 'string'\n >>> weave.inline(r'printf(\"%d\\n\",a);',['a'])\n 32956972\n
\nIn this case, the result is non-sensical, but also non-fatal. In other \nsituations, it might produce a compile time error because a is \nrequired to be an integer at some point in the code, or it could produce a \nsegmentation fault. Its possible to protect against passing \ninline arguments of the wrong data type by using asserts in \nPython.\n\n
\n\n\n >>> a = 'string'\n >>> def protected_printf(a): \n ... assert(type(a) == type(1))\n ... weave.inline(r'printf(\"%d\\n\",a);',['a'])\n >>> protected_printf(1)\n 1\n >>> protected_printf('string')\n AssertError...\n
\nFor printing strings, the format statement needs to be changed.\n\n
\n\n\n >>> a = 'string'\n >>> weave.inline(r'printf(\"%s\\n\",a);',['a'])\n string\n
\nAs in this case, C/C++ code fragments often have to change to accept different \ntypes. For the given printing task, however, C++ streams provide a way of a \nsingle statement that works for integers and strings. By default, the stream \nobjects live in the std (standard) namespace and thus require the use of \nstd::.\n\n
\n \n\n >>> weave.inline('std::cout << a << std::endl;',['a'])\n 1 \n >>> a = 'string'\n >>> weave.inline('std::cout << a << std::endl;',['a'])\n string\n
\nExamples using printf and cout are included in \nexamples/print_example.py.\n\n\n
inline. It \nincludes a few algorithms from the Python Cookbook \nthat have been re-written in inline C to improve speed as well as a couple \nexamples using Numeric and wxPython.\n\n\n\n\nThis Python version works for arbitrary Python data types. The C version below is \nspecialized to handle integer values. There is a little type checking done in \nPython to assure that we're working with the correct data types before heading \ninto C. The variables\n def binary_search(seq, t):\n min = 0; max = len(seq) - 1\n while 1:\n if max < min:\n return -1\n m = (min + max) / 2\n if seq[m] < t: \n min = m + 1 \n elif seq[m] > t: \n max = m - 1 \n else:\n return m \n
seq and t don't need to be \ndeclared beacuse weave handles converting and declaring them in \nthe C code. All other temporary variables such as min, max, etc. \nmust be declared -- it is C after all. Here's the new mixed Python/C function:\n\n \n\n def c_int_binary_search(seq,t):\n # do a little type checking in Python\n assert(type(t) == type(1))\n assert(type(seq) == type([]))\n \n # now the C code\n code = \"\"\"\n #line 29 \"binary_search.py\"\n int val, m, min = 0; \n int max = seq.length() - 1;\n PyObject *py_val; \n for(;;)\n {\n if (max < min ) \n { \n return_val = Py::new_reference_to(Py::Int(-1)); \n break;\n } \n m = (min + max) /2;\n val = py_to_int(PyList_GetItem(seq.ptr(),m),\"val\"); \n if (val < t) \n min = m + 1;\n else if (val > t)\n max = m - 1;\n else\n {\n return_val = Py::new_reference_to(Py::Int(m));\n break;\n }\n }\n \"\"\"\n return inline(code,['seq','t'])\n
\nWe have two variables seq and t passed in. \nt is guaranteed (by the assert) to be an integer. \nPython integers are converted to C int types in the transition from Python to \nC. seq is a Python list. By default, it is translated to a CXX \nlist object. Full documentation for the CXX library can be found at its website. The basics are that the CXX \nprovides C++ class equivalents for Python objects that simplify, or at \nleast object orientify, working with Python objects in C/C++. For example, \nseq.length() returns the length of the list. A little more about\nCXX and its class methods, etc. is in the ** type conversions ** section.\n
\n\nNote: CXX uses templates and therefore may be a little less portable than \nanother alternative by Gordan McMillan called SCXX which was inspired by\nCXX. It doesn't use templates so it should compile faster and be more portable.\nSCXX has a few less features, but it appears to me that it would mesh with\nthe needs of weave quite well. Hopefully xxx_spec files will be written\nfor SCXX in the future, and we'll be able to compare on a more empirical\nbasis. Both sets of spec files will probably stick around, it just a question\nof which becomes the default.\n\n
\nMost of the algorithm above looks similar in C to the original Python code. \nThere are two main differences. The first is the setting of \nreturn_val instead of directly returning from the C code with a \nreturn statement. return_val is an automatically \ndefined variable of type PyObject* that is returned from the C \ncode back to Python. You'll have to handle reference counting issues when \nsetting this variable. In this example, CXX classes and functions handle the \ndirty work. All CXX functions and classes live in the namespace \nPy::. The following code converts the integer m to a \nCXX Int() object and then to a PyObject* with an \nincremented reference count using Py::new_reference_to().\n\n
\n\n return_val = Py::new_reference_to(Py::Int(m));\n
\nThe second big differences shows up in the retrieval of integer values from the \nPython list. The simple Python seq[i] call balloons into a C \nPython API call to grab the value out of the list and then a separate call to \npy_to_int() that converts the PyObject* to an integer. \npy_to_int() includes both a NULL cheack and a \nPyInt_Check() call as well as the conversion call. If either of \nthe checks fail, an exception is raised. The entire C++ code block is executed \nwith in a try/catch block that handles exceptions much like Python \ndoes. This removes the need for most error checking code.\n
\nIt is worth note that CXX lists do have indexing operators that result \nin code that looks much like Python. However, the overhead in using them \nappears to be relatively high, so the standard Python API was used on the \nseq.ptr() which is the underlying PyObject* of the \nList object.\n
\nThe #line directive that is the first line of the C code \nblock isn't necessary, but it's nice for debugging. If the compilation fails \nbecause of the syntax error in the code, the error will be reported as an error \nin the Python file \"binary_search.py\" with an offset from the given line number \n(29 here).\n
\nSo what was all our effort worth in terms of efficiency? Well not a lot in \nthis case. The examples/binary_search.py file runs both Python and C versions \nof the functions As well as using the standard bisect module. If \nwe run it on a 1 million element list and run the search 3000 times (for 0-\n2999), here are the results we get:\n\n
\n\n C:\\home\\ej\\wrk\\scipy\\weave\\examples> python binary_search.py\n Binary search for 3000 items in 1000000 length list of integers:\n speed in python: 0.159999966621\n speed of bisect: 0.121000051498\n speed up: 1.32\n speed in c: 0.110000014305\n speed up: 1.45\n speed in c(no asserts): 0.0900000333786\n speed up: 1.78\n
\nSo, we get roughly a 50-75% improvement depending on whether we use the Python \nasserts in our C version. If we move down to searching a 10000 element list, \nthe advantage evaporates. Even smaller lists might result in the Python \nversion being faster. I'd like to say that moving to Numeric lists (and \ngetting rid of the GetItem() call) offers a substantial speed up, but my \npreliminary efforts didn't produce one. I think the log(N) algorithm is to \nblame. Because the algorithm is nice, there just isn't much time spent \ncomputing things, so moving to C isn't that big of a win. If there are ways to \nreduce conversion overhead of values, this may improve the C/Python speed \nup. Anyone have other explanations or faster code, please let me know.\n\n\n
\nThe demo in examples/dict_sort.py is another example from the Python CookBook. \nThis \nsubmission, by Alex Martelli, demonstrates how to return the values from a \ndictionary sorted by their keys:\n\n
\n\n def sortedDictValues3(adict):\n keys = adict.keys()\n keys.sort()\n return map(adict.get, keys)\n
\nAlex provides 3 algorithms and this is the 3rd and fastest of the set. The C \nversion of this same algorithm follows:\n\n
\n\n def c_sort(adict):\n assert(type(adict) == type({}))\n code = \"\"\" \n #line 21 \"dict_sort.py\" \n Py::List keys = adict.keys();\n Py::List items(keys.length()); keys.sort(); \n PyObject* item = NULL; \n for(int i = 0; i < keys.length();i++)\n {\n item = PyList_GET_ITEM(keys.ptr(),i);\n item = PyDict_GetItem(adict.ptr(),item);\n Py_XINCREF(item);\n PyList_SetItem(items.ptr(),i,item); \n } \n return_val = Py::new_reference_to(items);\n \"\"\" \n return inline_tools.inline(code,['adict'],verbose=1)\n
\nLike the original Python function, the C++ version can handle any Python \ndictionary regardless of the key/value pair types. It uses CXX objects for the \nmost part to declare python types in C++, but uses Python API calls to manipulate \ntheir contents. Again, this choice is made for speed. The C++ version, while\nmore complicated, is about a factor of 2 faster than Python.\n\n
\n\n C:\\home\\ej\\wrk\\scipy\\weave\\examples> python dict_sort.py\n Dict sort of 1000 items for 300 iterations:\n speed in python: 0.319999933243\n [0, 1, 2, 3, 4]\n speed in c: 0.151000022888\n speed up: 2.12\n [0, 1, 2, 3, 4]\n
\n\nAnd the following is a inline C version of the same function:\n\n\n def _castCopyAndTranspose(type, array):\n if a.typecode() == type:\n cast_array = copy.copy(Numeric.transpose(a))\n else:\n cast_array = copy.copy(Numeric.transpose(a).astype(type))\n return cast_array\n
\n\nThis example uses blitz++ arrays instead of the standard representation of \nNumeric arrays so that indexing is simplier to write. This is accomplished by \npassing in the blitz++ \"type factories\" to override the standard Python to C++ \ntype conversions. Blitz++ arrays allow you to write clean, fast code, but they \nalso are sloooow to compile (20 seconds or more for this snippet). This is why \nthey aren't the default type used for Numeric arrays (and also because most \ncompilers can't compile blitz arrays...).\n from weave.blitz_tools import blitz_type_factories\n from weave import scalar_spec\n from weave import inline\n def _cast_copy_transpose(type,a_2d):\n assert(len(shape(a_2d)) == 2)\n new_array = zeros(shape(a_2d),type)\n numeric_type = scalar_spec.numeric_to_blitz_type_mapping[type]\n code = \\\n \"\"\" \n for(int i = 0;i < _Na_2d[0]; i++) \n for(int j = 0; j < _Na_2d[1]; j++)\n new_array(i,j) = (%s) a_2d(j,i);\n \"\"\" % numeric_type\n inline(code,['new_array','a_2d'],\n type_factories = blitz_type_factories,compiler='gcc')\n return new_array\n
inline() is also forced \nto use 'gcc' as the compiler because the default compiler on Windows (MSVC) \nwill not compile blitz code. 'gcc' I think will use the standard compiler \non Unix machine instead of explicitly forcing gcc (check this) \n\nComparisons of the Python vs inline C++ code show a factor of 3 speed up. Also \nshown are the results of an \"inplace\" transpose routine that can be used if the \noutput of the linear algebra routine can overwrite the original matrix (this is \noften appropriate). This provides another factor of 2 improvement.\n\n \n\n\n\n #C:\\home\\ej\\wrk\\scipy\\weave\\examples> python cast_copy_transpose.py\n # Cast/Copy/Transposing (150,150)array 1 times\n # speed in python: 0.870999932289\n # speed in c: 0.25\n # speed up: 3.48\n # inplace transpose c: 0.129999995232\n # speed up: 6.70\n
inline knows how to handle wxPython objects. Thats nice in and of\nitself, but it also demonstrates that the type conversion mechanism is reasonably \nflexible. Chances are, it won't take a ton of effort to support special types\nyou might have. The examples/wx_example.py borrows the scrolled window\nexample from the wxPython demo, accept that it mixes inline C code in the middle\nof the drawing function.\n\n \n\nHere, some of the Python calls to wx objects were just converted to C++ calls. There\nisn't any benefit, it just demonstrates the capabilities. You might want to use this\nif you have a computationally intensive loop in your drawing code that you want to \nspeed up.\n\nOn windows, you'll have to use the MSVC compiler if you use the standard wxPython\nDLLs distributed by Robin Dunn. Thats because MSVC and gcc, while binary\ncompatible in C, are not binary compatible for C++. In fact, its probably best, no \nmatter what platform you're on, to specify that\n def DoDrawing(self, dc):\n \n red = wxNamedColour(\"RED\");\n blue = wxNamedColour(\"BLUE\");\n grey_brush = wxLIGHT_GREY_BRUSH;\n code = \\\n \"\"\"\n #line 108 \"wx_example.py\" \n dc->BeginDrawing();\n dc->SetPen(wxPen(*red,4,wxSOLID));\n dc->DrawRectangle(5,5,50,50);\n dc->SetBrush(*grey_brush);\n dc->SetPen(wxPen(*blue,4,wxSOLID));\n dc->DrawRectangle(15, 15, 50, 50);\n \"\"\"\n inline(code,['dc','red','blue','grey_brush'])\n \n dc.SetFont(wxFont(14, wxSWISS, wxNORMAL, wxNORMAL))\n dc.SetTextForeground(wxColour(0xFF, 0x20, 0xFF))\n te = dc.GetTextExtent(\"Hello World\")\n dc.DrawText(\"Hello World\", 60, 65)\n\n dc.SetPen(wxPen(wxNamedColour('VIOLET'), 4))\n dc.DrawLine(5, 65+te[1], 60+te[0], 65+te[1])\n ...\n
inline use the same\ncompiler that was used to build wxPython to be on the safe side. There isn't currently\na way to learn this info from the library -- you just have to know. Also, at least\non the windows platform, you'll need to install the wxWindows libraries and link to \nthem. I think there is a way around this, but I haven't found it yet -- I get some\nlinking errors dealing with wxString. One final note. You'll probably have to\ntweak weave/wx_spec.py or weave/wx_info.py for your machine's configuration to\npoint at the correct directories etc. There. That should sufficiently scare people\ninto not even looking at this... :)\n\n\n\nThe basic definition of the inline() function has a slew of \noptional variables. It also takes keyword arguments that are passed to \ndistutils as compiler options. The following is a formatted \ncut/paste of the argument section of inline's doc-string. It \nexplains all of the variables. Some examples using various options will \nfollow.\n\n
\n\n \n\n def inline(code,arg_names,local_dict = None, global_dict = None, \n force = 0, \n compiler='',\n verbose = 0, \n support_code = None,\n customize=None, \n type_factories = None, \n auto_downcast=1,\n **kw):\n
inline has quite \na few options as listed below. Also, the keyword arguments for distutils \nextension modules are accepted to specify extra information needed for \ncompiling. \n\n\n\n\n\n
\n- code
\n \n- \nstring. A string of valid C++ code. It should not \n specify a return statement. Instead it should assign results that need to be \n returned to Python in the return_val. \n
\n\n- arg_names
\n \n- \nlist of strings. A list of Python variable names \n that should be transferred from Python into the C/C++ code. \n
\n\n- local_dict
\n \n- \noptional. dictionary. If specified, it is a \n dictionary of values that should be used as the local scope for the C/C++ \n code. If local_dict is not specified the local dictionary of the calling \n function is used. \n
\n\n- global_dict
\n \n- \noptional. dictionary. If specified, it is a \n dictionary of values that should be used as the global scope for the C/C++ \n code. If global_dict is not specified the global dictionary of the calling \n function is used. \n
\n\n- force
\n \n- \noptional. 0 or 1. default 0. If 1, the C++ code is \n compiled every time inline is called. This is really only useful for \n debugging, and probably only useful if you're editing support_code a lot. \n
\n\n- compiler
\n \n- \noptional. string. The name of compiler to use when compiling. On windows, it \nunderstands 'msvc' and 'gcc' as well as all the compiler names understood by \ndistutils. On Unix, it'll only understand the values understoof by distutils. \n(I should add 'gcc' though to this).\n
\n\n\nOn windows, the compiler defaults to the Microsoft C++ compiler. If this isn't \navailable, it looks for mingw32 (the gcc compiler).\n
\nOn Unix, it'll probably use the same compiler that was used when compiling \nPython. Cygwin's behavior should be similar.
\n- verbose
\n \n- \noptional. 0,1, or 2. defualt 0. Speficies how much \n much information is printed during the compile phase of inlining code. 0 is \n silent (except on windows with msvc where it still prints some garbage). 1 \n informs you when compiling starts, finishes, and how long it took. 2 prints \n out the command lines for the compilation process and can be useful if you're \n having problems getting code to work. Its handy for finding the name of the \n .cpp file if you need to examine it. verbose has no affect if the \n compilation isn't necessary. \n
\n\n- support_code
\n \n- \noptional. string. A string of valid C++ code \n declaring extra code that might be needed by your compiled function. This \n could be declarations of functions, classes, or structures. \n
\n\n- customize
\n \n- \noptional. base_info.custom_info object. An \n alternative way to specifiy support_code, headers, etc. needed by the \n function see the weave.base_info module for more details. (not sure \n this'll be used much). \n \n
\n- type_factories
\n \n- \noptional. list of type specification factories. These guys are what convert \nPython data types to C/C++ data types. If you'd like to use a different set of \ntype conversions than the default, specify them here. Look in the type \nconversions section of the main documentation for examples.\n
\n- auto_downcast
\n \n- \noptional. 0 or 1. default 1. This only affects functions that have Numeric \narrays as input variables. Setting this to 1 will cause all floating point \nvalues to be cast as float instead of double if all the Numeric arrays are of \ntype float. If even one of the arrays has type double or double complex, all \nvariables maintain there standard types.\n
\n
\n\n\n\ninline()also accepts a number ofdistutilskeywords \nfor controlling how the code is compiled. The following descriptions have been \ncopied from Greg Ward'sdistutils.extension.Extensionclass doc-\nstrings for convenience:\n\n\n
\n- sources
\n \n- \n[string] list of source filenames, relative to the \n distribution root (where the setup script lives), in Unix form \n (slash-separated) for portability. Source files may be C, C++, SWIG (.i), \n platform-specific resource files, or whatever else is recognized by the \n \"build_ext\" command as source for a Python extension. Note: The module_path \n file is always appended to the front of this list \n
\n\n- include_dirs
\n \n- \n[string] list of directories to search for C/C++ \n header files (in Unix form for portability) \n
\n\n- define_macros
\n \n- \n[(name : string, value : string|None)] list of \n macros to define; each macro is defined using a 2-tuple, where 'value' is \n either the string to define it to or None to define it without a particular \n value (equivalent of \"#define FOO\" in source or -DFOO on Unix C compiler \n command line) \n
\n- undef_macros
\n \n- \n[string] list of macros to undefine explicitly \n
\n- library_dirs
\n- \n[string] list of directories to search for C/C++ libraries at link time \n
\n- libraries
\n- \n[string] list of library names (not filenames or paths) to link against \n
\n- runtime_library_dirs
\n- \n[string] list of directories to search for C/C++ libraries at run time (for \nshared extensions, this is when the extension is loaded) \n
\n\n- extra_objects
\n \n- \n[string] list of extra files to link with (eg. \n object files not implied by 'sources', static library that must be \n explicitly specified, binary resource files, etc.) \n
\n\n- extra_compile_args
\n \n- \n[string] any extra platform- and compiler-specific \n information to use when compiling the source files in 'sources'. For \n platforms and compilers where \"command line\" makes sense, this is typically \n a list of command-line arguments, but for other platforms it could be \n anything. \n
\n- extra_link_args
\n \n- \n[string] any extra platform- and compiler-specific \n information to use when linking object files together to create the \n extension (or to create a new static Python interpreter). Similar \n interpretation as for 'extra_compile_args'. \n
\n- export_symbols
\n \n- \n[string] list of symbols to be exported from a shared extension. Not used on \nall platforms, and not generally necessary for Python extensions, which \ntypically export exactly one symbol: \"init\" + extension_name. \n
\n
inline and also how the various arguments are used.\n\nIn the simplest (most) cases, code and arg_names\nare the only arguments that need to be specified. Here's a simple example\nrun on Windows machine that has Microsoft VC++ installed.\n\n \n \nWhen\n >>> from weave import inline\n >>> a = 'string'\n >>> code = \"\"\"\n ... int l = a.length();\n ... return_val = Py::new_reference_to(Py::Int(l));\n ... \"\"\"\n >>> inline(code,['a'])\n sc_86e98826b65b047ffd2cd5f479c627f12.cpp\n Creating\n library C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_86e98826b65b047ffd2cd5f479c627f12.lib\n and object C:\\DOCUME~ 1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_86e98826b65b047ff\n d2cd5f479c627f12.exp\n 6\n >>> inline(code,['a'])\n 6\n
inline is first run, you'll notice that pause and some \ntrash printed to the screen. The \"trash\" is acutually part of the compilers\noutput that distutils does not supress. The name of the extension file, \nsc_bighonkingnumber.cpp, is generated from the md5 check sum\nof the C/C++ code fragment. On Unix or windows machines with only\ngcc installed, the trash will not appear. On the second call, the code \nfragment is not compiled since it already exists, and only the answer is \nreturned. Now kill the interpreter and restart, and run the same code with\na different string.\n\n \n\n >>> from weave import inline\n >>> a = 'a longer string' \n >>> code = \"\"\" \n ... int l = a.length();\n ... return_val = Py::new_reference_to(Py::Int(l)); \n ... \"\"\"\n >>> inline(code,['a'])\n 15\n
\nNotice this time, inline() did not recompile the code because it\nfound the compiled function in the persistent catalog of functions. There is\na short pause as it looks up and loads the function, but it is much shorter \nthan compiling would require.\n
\nYou can specify the local and global dictionaries if you'd like (much like \nexec or eval() in Python), but if they aren't \nspecified, the \"expected\" ones are used -- i.e. the ones from the function that \ncalled inline() . This is accomplished through a little call \nframe trickery. Here is an example where the local_dict is specified using\nthe same code example from above:\n\n
\n \n\n >>> a = 'a longer string'\n >>> b = 'an even longer string' \n >>> my_dict = {'a':b}\n >>> inline(code,['a'])\n 15\n >>> inline(code,['a'],my_dict)\n 21\n
\nEverytime, the code is changed, inline does a \nrecompile. However, changing any of the other options in inline does not\nforce a recompile. The force option was added so that one\ncould force a recompile when tinkering with other variables. In practice,\nit is just as easy to change the code by a single character\n(like adding a space some place) to force the recompile. Note: It also \nmight be nice to add some methods for purging the cache and on disk \ncatalogs.\n
\nI use verbose sometimes for debugging. When set to 2, it'll \noutput all the information (including the name of the .cpp file) that you'd\nexpect from running a make file. This is nice if you need to examine the\ngenerated code to see where things are going haywire. Note that error\nmessages from failed compiles are printed to the screen even if verbose\n is set to 0.\n
\nThe following example demonstrates using gcc instead of the standard msvc \ncompiler on windows using same code fragment as above. Because the example has \nalready been compiled, the force=1 flag is needed to make \ninline() ignore the previously compiled version and recompile \nusing gcc. The verbose flag is added to show what is printed out:\n\n
\n\nThat's quite a bit of output.\n >>>inline(code,['a'],compiler='gcc',verbose=2,force=1)\n running build_ext \n building 'sc_86e98826b65b047ffd2cd5f479c627f13' extension \n c:\\gcc-2.95.2\\bin\\g++.exe -mno-cygwin -mdll -O2 -w -Wstrict-prototypes -IC:\n \\home\\ej\\wrk\\scipy\\weave -IC:\\Python21\\Include -c C:\\DOCUME~1\\eric\\LOCAL\n S~1\\Temp\\python21_compiled\\sc_86e98826b65b047ffd2cd5f479c627f13.cpp -o C:\\D\n OCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_86e98826b65b04\n 7ffd2cd5f479c627f13.o \n skipping C:\\home\\ej\\wrk\\scipy\\weave\\CXX\\cxxextensions.c (C:\\DOCUME~1\\eri\n c\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\cxxextensions.o up-to-date)\n skipping C:\\home\\ej\\wrk\\scipy\\weave\\CXX\\cxxsupport.cxx (C:\\DOCUME~1\\eric\n \\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\cxxsupport.o up-to-date)\n skipping C:\\home\\ej\\wrk\\scipy\\weave\\CXX\\IndirectPythonInterface.cxx (C:\\\n DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\indirectpythonin\n terface.o up-to-date)\n skipping C:\\home\\ej\\wrk\\scipy\\weave\\CXX\\cxx_extensions.cxx (C:\\DOCUME~1\\\n eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\cxx_extensions.o up-to-da\n te)\n writing C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_86\n e98826b65b047ffd2cd5f479c627f13.def\n c:\\gcc-2.95.2\\bin\\dllwrap.exe --driver-name g++ -mno-cygwin -mdll -static -\n -output-lib C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\l\n ibsc_86e98826b65b047ffd2cd5f479c627f13.a --def C:\\DOCUME~1\\eric\\LOCALS~1\\Te\n mp\\python21_compiled\\temp\\Release\\sc_86e98826b65b047ffd2cd5f479c627f13.def \n -s C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\temp\\Release\\sc_86e9882\n 6b65b047ffd2cd5f479c627f13.o C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compil\n ed\\temp\\Release\\cxxextensions.o C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_com\n piled\\temp\\Release\\cxxsupport.o C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_com\n piled\\temp\\Release\\indirectpythoninterface.o C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\n \\python21_compiled\\temp\\Release\\cxx_extensions.o -LC:\\Python21\\libs -lpytho\n n21 -o C:\\DOCUME~1\\eric\\LOCALS~1\\Temp\\python21_compiled\\sc_86e98826b65b047f\n fd2cd5f479c627f13.pyd\n 15\n
verbose=1 just prints the compile\ntime.\n\n \n\n\n >>>inline(code,['a'],compiler='gcc',verbose=1,force=1)\n Compiling code...\n finished compiling (sec): 6.00800001621\n 15\n
\n Note: I've only used the compiler option for switching between 'msvc'\nand 'gcc' on windows. It may have use on Unix also, but I don't know yet.\n\n\n
\nThe support_code argument is likely to be used a lot. It allows \nyou to specify extra code fragments such as function, structure or class \ndefinitions that you want to use in the code string. Note that \nchanges to support_code do not force a recompile. The \ncatalog only relies on code (for performance reasons) to determine \nwhether recompiling is necessary. So, if you make a change to support_code, \nyou'll need to alter code in some way or use the \nforce argument to get the code to recompile. I usually just add \nsome inocuous whitespace to the end of one of the lines in code \nsomewhere. Here's an example of defining a separate method for calculating\nthe string length:\n\n
\n\n >>> from weave import inline\n >>> a = 'a longer string'\n >>> support_code = \"\"\"\n ... PyObject* length(Py::String a)\n ... {\n ... int l = a.length(); \n ... return Py::new_reference_to(Py::Int(l)); \n ... }\n ... \"\"\" \n >>> inline(\"return_val = length(a);\",['a'],\n ... support_code = support_code)\n 15\n
\ncustomize is a left over from a previous way of specifying \ncompiler options. It is a custom_info object that can specify \nquite a bit of information about how a file is compiled. These \ninfo objects are the standard way of defining compile information \nfor type conversion classes. However, I don't think they are as handy here, \nespecially since we've exposed all the keyword arguments that distutils can \nhandle. Between these keywords, and the support_code option, I \nthink customize may be obsolete. We'll see if anyone cares to use \nit. If not, it'll get axed in the next version.\n
\nThe type_factories variable is important to people who want to\ncustomize the way arguments are converted from Python to C. We'll talk about\nthis in the next chapter **xx** of this document when we discuss type\nconversions.\n
\nauto_downcast handles one of the big type conversion issues that\nis common when using Numeric arrays in conjunction with Python scalar values.\nIf you have an array of single precision values and multiply that array by a \nPython scalar, the result is upcast to a double precision array because the\nscalar value is double precision. This is not usually the desired behavior\nbecause it can double your memory usage. auto_downcast goes\nsome distance towards changing the casting precedence of arrays and scalars.\nIf your only using single precision arrays, it will automatically downcast all\nscalar values from double to single precision when they are passed into the\nC++ code. This is the default behavior. If you want all values to keep there\ndefault type, set auto_downcast to 0.\n
inline were to completely live up\nto its name, any modifications to variables in the C++ code would be reflected\nin the Python variables when control was passed back to Python. For example,\nthe desired behavior would be something like:\n\n \n\nInstead you get:\n\n\n # THIS DOES NOT WORK\n >>> a = 1\n >>> weave.inline(\"a++;\",['a'])\n >>> a\n 2\n
\n \nVariables are passed into C++ as if you are calling a Python function. Python's \ncalling convention is sometimes called \"pass by assignment\". This means its as \nif a\n >>> a = 1\n >>> weave.inline(\"a++;\",['a'])\n >>> a\n 1\n
c_a = a assignment is made right before inline \ncall is made and the c_a variable is used within the C++ code. \nThus, any changes made to c_a are not reflected in Python's \na variable. Things do get a little more confusing, however, when \nlooking at variables with mutable types. Changes made in C++ to the contents \nof mutable types are reflected in the Python variables.\n\n \n\nSo modifications to the contents of mutable types in C++ are seen when control\nis returned to Python. Modifications to immutable types such as tuples,\nstrings, and numbers do not alter the Python variables.\n\nIf you need to make changes to an immutable variable, you'll need to assign\nthe new value to the \"magic\" variable\n >>> a= [1,2]\n >>> weave.inline(\"PyList_SetItem(a.ptr(),0,PyInt_FromLong(3));\",['a'])\n >>> print a\n [3, 2]\n
return_val in C++. This\nvalue is returned by the inline() function:\n\n \n\nThe\n >>> a = 1\n >>> a = weave.inline(\"return_val = Py::new_reference_to(Py::Int(a+1));\",['a']) \n >>> a\n 2\n
return_val variable can also be used to return newly created \nvalues. This is possible by returning a tuple. The following trivial example \nillustrates how this can be done:\n\n \n\n # python version\n def multi_return():\n return 1, '2nd'\n \n # C version.\n def c_multi_return(): \n code = \"\"\"\n \t Py::Tuple results(2);\n \t results[0] = Py::Int(1);\n \t results[1] = Py::String(\"2nd\");\n \t return_val = Py::new_reference_to(results); \t \n \"\"\"\n return inline_tools.inline(code)\n
\nThe example is available in examples/tuple_return.py. It also\nhas the dubious honor of demonstrating how much inline() can \nslow things down. The C version here is about 10 times slower than the Python\nversion. Of course, something so trivial has no reason to be written in\nC anyway.\n\n\n
locals()\ninline passes the locals() and globals() \ndictionaries from Python into the C++ function from the calling function. It \nextracts the variables that are used in the C++ code from these dictionaries, \nconverts then to C++ variables, and then calculates using them. It seems like \nit would be trivial, then, after the calculations were finished to then insert \nthe new values back into the locals() and globals() \ndictionaries so that the modified values were reflected in Python. \nUnfortunately, as pointed out by the Python manual, the locals() dictionary is \nnot writable. \n
\n\nI suspect locals() is not writable because there are some \noptimizations done to speed lookups of the local namespace. I'm guessing local \nlookups don't always look at a dictionary to find values. Can someone \"in the \nknow\" confirm or correct this? Another thing I'd like to know is whether there \nis a way to write to the local namespace of another stack frame from C/C++. If \nso, it would be possible to have some clean up code in compiled functions that \nwrote final values of variables in C++ back to the correct Python stack frame. \nI think this goes a long way toward making inline truely live up \nto its name. I don't think we'll get to the point of creating variables in \nPython for variables created in C -- although I suppose with a C/C++ parser you \ncould do that also.\n\n
weave generates a C++ file holding an extension function for \neach inline code snippet. These file names are generated using \nfrom the md5 signature of the code snippet and saved to a location specified by \nthe PYTHONCOMPILED environment variable (discussed later). The cpp files are \ngenerally about 200-400 lines long and include quite a few functions to support \ntype conversions, etc. However, the actual compiled function is pretty simple. \nBelow is the familiar printf example:\n\n \n\nAnd here is the extension function generated by\n >>> import weave \n >>> a = 1\n >>> weave.inline('printf(\"%d\\\\n\",a);',['a'])\n 1\n
inline:\n\n \n\nEvery inline function takes exactly two arguments -- the local and global\ndictionaries for the current scope. All variable values are looked up out\nof these dictionaries. The lookups, along with all\n static PyObject* compiled_func(PyObject*self, PyObject* args)\n {\n // The Py_None needs an incref before returning\n PyObject *return_val = NULL;\n int exception_occured = 0;\n PyObject *py__locals = NULL;\n PyObject *py__globals = NULL;\n PyObject *py_a;\n py_a = NULL;\n \n if(!PyArg_ParseTuple(args,\"OO:compiled_func\",&py__locals,&py__globals))\n return NULL;\n try \n { \n PyObject* raw_locals = py_to_raw_dict(py__locals,\"_locals\");\n PyObject* raw_globals = py_to_raw_dict(py__globals,\"_globals\");\n int a = py_to_int (get_variable(\"a\",raw_locals,raw_globals),\"a\");\n /* Here is the inline code */ \n printf(\"%d\\n\",a);\n /* I would like to fill in changed locals and globals here... */\n } \n catch( Py::Exception& e) \n { \n return_val = Py::Null(); \n exception_occured = 1; \n } \n if(!return_val && !exception_occured)\n {\n \n Py_INCREF(Py_None); \n return_val = Py_None; \n }\n /* clean up code */\n \n /* return */ \n return return_val; \n } \n
inline code \nexecution, are done within a C++ try block. If the variables\naren't found, or there is an error converting a Python variable to the \nappropriate type in C++, an exception is raised. The C++ exception\nis automatically converted to a Python exception by CXX and returned to Python.\n\nThe py_to_int() function illustrates how the conversions and\nexception handling works. py_to_int first checks that the given PyObject*\npointer is not NULL and is a Python integer. If all is well, it calls the\nPython API to convert the value to an int. Otherwise, it calls\nhandle_bad_type() which gathers information about what went wrong\nand then raises a CXX TypeError which returns to Python as a TypeError.\n\n \n\n\n int py_to_int(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyInt_Check(py_obj))\n handle_bad_type(py_obj,\"int\", name);\n return (int) PyInt_AsLong(py_obj);\n }\n
\n\nSince the\n void handle_bad_type(PyObject* py_obj, char* good_type, char* var_name)\n {\n char msg[500];\n sprintf(msg,\"received '%s' type instead of '%s' for variable '%s'\",\n find_type(py_obj),good_type,var_name);\n throw Py::TypeError(msg);\n }\n \n char* find_type(PyObject* py_obj)\n {\n if(py_obj == NULL) return \"C NULL value\";\n if(PyCallable_Check(py_obj)) return \"callable\";\n if(PyString_Check(py_obj)) return \"string\";\n if(PyInt_Check(py_obj)) return \"int\";\n if(PyFloat_Check(py_obj)) return \"float\";\n if(PyDict_Check(py_obj)) return \"dict\";\n if(PyList_Check(py_obj)) return \"list\";\n if(PyTuple_Check(py_obj)) return \"tuple\";\n if(PyFile_Check(py_obj)) return \"file\";\n if(PyModule_Check(py_obj)) return \"module\";\n \n //should probably do more interagation (and thinking) on these.\n if(PyCallable_Check(py_obj) && PyInstance_Check(py_obj)) return \"callable\";\n if(PyInstance_Check(py_obj)) return \"instance\"; \n if(PyCallable_Check(py_obj)) return \"callable\";\n return \"unkown type\";\n }\n
inline is also executed within the try/catch\nblock, you can use CXX exceptions within your code. It is usually a bad idea\nto directly return from your code, even if an error occurs. This\nskips the clean up section of the extension function. In this simple example,\nthere isn't any clean up code, but in more complicated examples, there may\nbe some reference counting that needs to be taken care of here on converted\nvariables. To avoid this, either uses exceptions or set \nreturn_val to NULL and use if/then's to skip code\nafter errors.\n\n\n\nThere are several main steps to using C/C++ code withing Python:\n
\nItems 1 and 2 above are related, but most easily discussed separately. Type \nconversions are customizable by the user if needed. Understanding them is \npretty important for anything beyond trivial uses of inline. \nGenerating the C/C++ code is handled by ext_function and \next_module classes and . For the most part, compiling the code is \nhandled by distutils. Some customizations were needed, but they were \nrelatively minor and do not require changes to distutils itself. Cataloging is \npretty simple in concept, but surprisingly required the most code to implement \n(and still likely needs some work). So, this section covers items 1 and 4 from \nthe list. Item 2 is covered later in the chapter covering the \next_tools module, and distutils is covered by a completely \nseparate document xxx.\n\n
xxx_converter instead of \nxxx_specification is a more descriptive name. Might change in \nfuture version?\n\n\n\nBy default, inline() makes the following type conversions between\nPython and C++ types.\n
\n\n
| \n Default Data Type Conversions | |
| \n Python | \n C++ |
| int | int |
| float | double |
| complex | std::complex |
| string | Py::String |
| list | Py::List |
| dict | Py::Dict |
| tuple | Py::Tuple |
| file | FILE* |
| callable | PyObject* |
| instance | PyObject* |
| Numeric.array | PyArrayObject* |
| wxXXX | wxXXX* |
\nThe Py:: namespace is defined by the \nCXX library which has C++ class\nequivalents for many Python types. std:: is the namespace of the\nstandard library in C++.\n
\n\nNote: \n\n
\n\nlong int yet (I think they are currenlty converted \n to int - - check this). \n \n
\n\nPython to C++ conversions fill in code in several locations in the generated\ninline extension function. Below is the basic template for the\nfunction. This is actually the exact code that is generated by calling\nweave.inline(\"\").\n\n
\n\nThe\n static PyObject* compiled_func(PyObject*self, PyObject* args)\n {\n PyObject *return_val = NULL;\n int exception_occured = 0;\n PyObject *py__locals = NULL;\n PyObject *py__globals = NULL;\n PyObject *py_a;\n py_a = NULL;\n \n if(!PyArg_ParseTuple(args,\"OO:compiled_func\",&py__locals,&py__globals))\n return NULL;\n try\n {\n PyObject* raw_locals = py_to_raw_dict(py__locals,\"_locals\");\n PyObject* raw_globals = py_to_raw_dict(py__globals,\"_globals\");\n /* argument conversion code */\n /* inline code */\n /*I would like to fill in changed locals and globals here...*/\n \n }\n catch( Py::Exception& e)\n {\n return_val = Py::Null();\n exception_occured = 1;\n }\n /* cleanup code */\n if(!return_val && !exception_occured)\n {\n \n Py_INCREF(Py_None);\n return_val = Py_None;\n }\n \n return return_val;\n }\n
/* inline code */ section is filled with the code passed to\nthe inline() function call. The \n/*argument convserion code*/ and /* cleanup code */\nsections are filled with code that handles conversion from Python to C++\ntypes and code that deallocates memory or manipulates reference counts before\nthe function returns. The following sections demostrate how these two areas\nare filled in by the default conversion methods.\n\n \nNote: I'm not sure I have reference counting correct on a few of these. The \nonly thing I increase/decrease the ref count on is Numeric arrays. If you\nsee an issue, please let me know.\n\n\n\n\n\nThe argument conversion code inserted for\n >>> a = 1\n >>> inline(\"\",['a'])\n
a is:\n\n \n\n\n /* argument conversion code */\n int a = py_to_int (get_variable(\"a\",raw_locals,raw_globals),\"a\");\n
get_variable() reads the variable a\nfrom the local and global namespaces. py_to_int() has the following\nform:\n\n \n\nSimilarly, the float and complex conversion routines look like:\n\n\n static int py_to_int(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyInt_Check(py_obj))\n handle_bad_type(py_obj,\"int\", name);\n return (int) PyInt_AsLong(py_obj);\n }\n
\n\nNumeric conversions do not require any clean up code.\n\n\n\n static double py_to_float(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyFloat_Check(py_obj))\n handle_bad_type(py_obj,\"float\", name);\n return PyFloat_AsDouble(py_obj);\n }\n \n static std::complexpy_to_complex(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyComplex_Check(py_obj))\n handle_bad_type(py_obj,\"complex\", name);\n return std::complex (PyComplex_RealAsDouble(py_obj),\n PyComplex_ImagAsDouble(py_obj)); \n }\n
\n\nThe argument conversion code inserted for\n >>> a = [1]\n >>> inline(\"\",['a'])\n
a is:\n\n \n\n\n /* argument conversion code */\n Py::List a = py_to_list (get_variable(\"a\",raw_locals,raw_globals),\"a\");\n
get_variable() reads the variable a\nfrom the local and global namespaces. py_to_list() and its\nfriends has the following form:\n\n \n\nCXX handles reference counts on for strings, lists, tuples, and dictionaries,\nso clean up code isn't necessary.\n\n\n\n static Py::List py_to_list(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyList_Check(py_obj))\n handle_bad_type(py_obj,\"list\", name);\n return Py::List(py_obj);\n }\n \n static Py::String py_to_string(PyObject* py_obj,char* name)\n {\n if (!PyString_Check(py_obj))\n handle_bad_type(py_obj,\"string\", name);\n return Py::String(py_obj);\n }\n\n static Py::Dict py_to_dict(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyDict_Check(py_obj))\n handle_bad_type(py_obj,\"dict\", name);\n return Py::Dict(py_obj);\n }\n \n static Py::Tuple py_to_tuple(PyObject* py_obj,char* name)\n {\n if (!py_obj || !PyTuple_Check(py_obj))\n handle_bad_type(py_obj,\"tuple\", name);\n return Py::Tuple(py_obj);\n }\n
\n\nThe argument conversion code is:\n\n\n >>> a = open(\"bob\",'w') \n >>> inline(\"\",['a'])\n
\n\n\n /* argument conversion code */\n PyObject* py_a = get_variable(\"a\",raw_locals,raw_globals);\n FILE* a = py_to_file(py_a,\"a\");\n
get_variable() reads the variable a\nfrom the local and global namespaces. py_to_file() converts\nPyObject* to a FILE* and increments the reference count of the PyObject*:\n\n \n\nBecause the PyObject* was incremented, the clean up code needs to decrement\nthe counter\n\n\n FILE* py_to_file(PyObject* py_obj, char* name)\n {\n if (!py_obj || !PyFile_Check(py_obj))\n handle_bad_type(py_obj,\"file\", name);\n \n Py_INCREF(py_obj);\n return PyFile_AsFile(py_obj);\n }\n
\n\nIts important to understand that file conversion only works on actual files --\ni.e. ones created using the\n /* cleanup code */\n Py_XDECREF(py_a);\n
open() command in Python. It does\nnot support converting arbitrary objects that support the file interface into\nC FILE* pointers. This can affect many things. For example, in\ninitial printf() examples, one might be tempted to solve the \nproblem of C and Python IDE's (PythonWin, PyCrust, etc.) writing to different\nstdout and stderr by using fprintf() and passing in \nsys.stdout and sys.stderr. For example, instead of\n\n \n \nYou might try:\n\n\n >>> weave.inline('printf(\"hello\\\\n\");')\n
\n\nThis will work as expected from a standard python interpreter, but in PythonWin,\nthe following occurs:\n\n\n >>> buf = sys.stdout\n >>> weave.inline('fprintf(buf,\"hello\\\\n\");',['buf'])\n
\n\nThe traceback tells us that\n >>> buf = sys.stdout\n >>> weave.inline('fprintf(buf,\"hello\\\\n\");',['buf'])\n Traceback (most recent call last):\n File \"\", line 1, in ?\n File \"C:\\Python21\\weave\\inline_tools.py\", line 315, in inline\n auto_downcast = auto_downcast,\n File \"C:\\Python21\\weave\\inline_tools.py\", line 386, in compile_function\n type_factories = type_factories)\n File \"C:\\Python21\\weave\\ext_tools.py\", line 197, in __init__\n auto_downcast, type_factories)\n File \"C:\\Python21\\weave\\ext_tools.py\", line 390, in assign_variable_types\n raise TypeError, format_error_msg(errors)\n TypeError: {'buf': \"Unable to convert variable 'buf' to a C++ type.\"}\n
inline() was unable to convert 'buf' to a\nC++ type (If instance conversion was implemented, the error would have occurred at \nruntime instead). Why is this? Let's look at what the buf object \nreally is:\n\n \n\nPythonWin has reassigned\n >>> buf\n pywin.framework.interact.InteractiveView instance at 00EAD014\n
sys.stdout to a special object that \nimplements the Python file interface. This works great in Python, but since \nthe special object doesn't have a FILE* pointer underlying it, fprintf doesn't \nknow what to do with it (well this will be the problem when instance conversion \nis implemented...).\n\n\n\n\nCallable and instance variables are converted to PyObject*. Nothing is done\nto there reference counts.\n\n\n >>> def a(): \n pass\n >>> inline(\"\",['a'])\n
\n\n\n /* argument conversion code */\n PyObject* a = py_to_callable(get_variable(\"a\",raw_locals,raw_globals),\"a\");\n
get_variable() reads the variable a\nfrom the local and global namespaces. The py_to_callable() and\npy_to_instance() don't currently increment the ref count.\n\n \n \nThere is no cleanup code for callables, modules, or instances.\n\n\n\n PyObject* py_to_callable(PyObject* py_obj, char* name)\n {\n if (!py_obj || !PyCallable_Check(py_obj))\n handle_bad_type(py_obj,\"callable\", name); \n return py_obj;\n }\n\n PyObject* py_to_instance(PyObject* py_obj, char* name)\n {\n if (!py_obj || !PyFile_Check(py_obj))\n handle_bad_type(py_obj,\"instance\", name); \n return py_obj;\n }\n
\nConverting from Python to C++ types is handled by xxx_specification classes. A \ntype specification class actually serve in two related but different \nroles. The first is in determining whether a Python variable that needs to be \nconverted should be represented by the given class. The second is as a code \ngenerator that generate C++ code needed to convert from Python to C++ types for \na specific variable.\n
\nWhen \n\n
\n \nis called for the first time, the code snippet has to be compiled. In this \nprocess, the variable 'a' is tested against a list of type specifications (the \ndefault list is stored in weave/ext_tools.py). The first \nspecification in the list is used to represent the variable. \n\n\n >>> a = 1\n >>> weave.inline('printf(\"%d\",a);',['a'])\n
\nExamples of xxx_specification are scattered throughout numerous \n\"xxx_spec.py\" files in the weave package. Closely related to \nthe xxx_specification classes are yyy_info classes. \nThese classes contain compiler, header, and support code information necessary \nfor including a certain set of capabilities (such as blitz++ or CXX support)\nin a compiled module. xxx_specification classes have one or more\nyyy_info classes associated with them.\n\nIf you'd like to define your own set of type specifications, the current best route\nis to examine some of the existing spec and info files. Maybe looking over\nsequence_spec.py and cxx_info.py are a good place to start. After defining \nspecification classes, you'll need to pass them into inline using the \ntype_factories argument. \n\nA lot of times you may just want to change how a specific variable type is \nrepresented. Say you'd rather have Python strings converted to \nstd::string or maybe char* instead of using the CXX \nstring object, but would like all other type conversions to have default \nbehavior. This requires that a new specification class that handles strings\nis written and then prepended to a list of the default type specifications. Since\nit is closer to the front of the list, it effectively overrides the default\nstring specification.\n\nThe following code demonstrates how this is done:\n\n...\n\n\n
\ncatalog.py has a class called catalog that helps keep \ntrack of previously compiled functions. This prevents inline() \nand related functions from having to compile functions everytime they are \ncalled. Instead, catalog will check an in memory cache to see if the function \nhas already been loaded into python. If it hasn't, then it starts searching \nthrough persisent catalogs on disk to see if it finds an entry for the given \nfunction. By saving information about compiled functions to disk, it isn't\nnecessary to re-compile functions everytime you stop and restart the interpreter.\nFunctions are compiled once and stored for future use.\n\n
\nWhen inline(cpp_code) is called the following things happen:\n
cpp_code. If an entry for cpp_code doesn't exist in the \n cache or the cached function call fails (perhaps because the function doesn't \n have compatible types) then the next step is to check the catalog. \n cpp_code. If cpp_code has\n ever been called, then this cache will be present (loaded from disk). If\n the cache isn't present, then it is loaded from disk.\n \n If the cache is present, each function in the cache is \n called until one is found that was compiled for the correct argument types. If \n none of the functions work, a new function is compiled with the given argument \n types. This function is written to the on-disk catalog as well as into the \n in-memory cache.
\ncpp_code fails, the catalog looks through \n the on-disk function catalogs for the entries. The PYTHONCOMPILED variable \n determines where to search for these catalogs and in what order. If \n PYTHONCOMPILED is not present several platform dependent locations are \n searched. All functions found for cpp_code in the path are \n loaded into the in-memory cache with functions found earlier in the search \n path closer to the front of the call list.\n \n If the function isn't found in the on-disk catalog, \n then the function is compiled, written to the first writable directory in the \n PYTHONCOMPILED path, and also loaded into the in-memory cache.
\n\nFunction caches are stored as dictionaries where the key is the entire C++\ncode string and the value is either a single function (as in the \"level 1\"\ncache) or a list of functions (as in the main catalog cache). On disk\ncatalogs are stored in the same manor using standard Python shelves.\n
\nEarly on, there was a question as to whether md5 check sums of the C++\ncode strings should be used instead of the actual code strings. I think this\nis the route inline Perl took. Some (admittedly quick) tests of the md5 vs.\nthe entire string showed that using the entire string was at least a\nfactor of 3 or 4 faster for Python. I think this is because it is more\ntime consuming to compute the md5 value than it is to do look-ups of long\nstrings in the dictionary. Look at the examples/md5_speed.py file for the\ntest run. \n\n\n
\nThe default location for catalog files on Unix is is ~/.pythonXX_compiled where \nXX is version of Python being used. If this directory doesn't exist, it is \ncreated the first time a catalog is used. The directory must be writable. If, \nfor any reason it isn't, then the catalog attempts to create a directory based \non your user id in the /tmp directory. The directory permissions are set so \nthat only you have access to the directory. If this fails, I think you're out of \nluck. I don't think either of these should ever fail though. On Windows, a \ndirectory called pythonXX_compiled is created in the user's temporary \ndirectory. \n
\nThe actual catalog file that lives in this directory is a Python shelve with\na platform specific name such as \"nt21compiled_catalog\" so that multiple OSes\ncan share the same file systems without trampling on each other. Along with\nthe catalog file, the .cpp and .so or .pyd files created by inline will live\nin this directory. The catalog file simply contains keys which are the C++\ncode strings with values that are lists of functions. The function lists point\nat functions within these compiled modules. Each function in the lists \nexecutes the same C++ code string, but compiled for different input variables.\n
\nYou can use the PYTHONCOMPILED environment variable to specify alternative\nlocations for compiled functions. On Unix this is a colon (':') separated\nlist of directories. On windows, it is a (';') separated list of directories.\nThese directories will be searched prior to the default directory for a\ncompiled function catalog. Also, the first writable directory in the list\nis where all new compiled function catalogs, .cpp and .so or .pyd files are\nwritten. Relative directory paths ('.' and '..') should work fine in the\nPYTHONCOMPILED variable as should environement variables.\n
\nThere is a \"special\" path variable called MODULE that can be placed in the \nPYTHONCOMPILED variable. It specifies that the compiled catalog should\nreside in the same directory as the module that called it. This is useful\nif an admin wants to build a lot of compiled functions during the build\nof a package and then install them in site-packages along with the package.\nUser's who specify MODULE in their PYTHONCOMPILED variable will have access\nto these compiled functions. Note, however, that if they call the function\nwith a set of argument types that it hasn't previously been built for, the\nnew function will be stored in their default directory (or some other writable\ndirectory in the PYTHONCOMPILED path) because the user will not have write\naccess to the site-packages directory.\n
\nAn example of using the PYTHONCOMPILED path on bash follows:\n\n
\n\nIf you are using python21 on linux, and the module bob.py in site-packages\nhas a compiled function in it, then the catalog search order when calling that\nfunction for the first time in a python session would be:\n\n\n PYTHONCOMPILED=MODULE:/some/path;export PYTHONCOMPILED;\n
\n\nThe default location is always included in the search path.\n\n /usr/lib/python21/site-packages/linuxpython_compiled\n /some/path/linuxpython_compiled\n ~/.python21_compiled/linuxpython_compiled\n
\n \nNote: hmmm. see a possible problem here. I should probably make a sub-\ndirectory such as /usr/lib/python21/site-\npackages/python21_compiled/linuxpython_compiled so that library files compiled \nwith python21 are tried to link with python22 files in some strange scenarios. \nNeed to check this.\n\n\n
\nThe in-module cache (in weave.inline_tools reduces the overhead \nof calling inline functions by about a factor of 2. It can be reduced a little \nmore for type loop calls where the same function is called over and over again \nif the cache was a single value instead of a dictionary, but the benefit is \nvery small (less than 5%) and the utility is quite a bit less. So, we'll stick \nwith a dictionary as the cache.\n
\nweave.blitz() compiles Numeric Python expressions for fast \nexecution. For most applications, compiled expressions should provide a \nfactor of 2-10 speed-up over Numeric arrays. Using compiled \nexpressions is meant to be as unobtrusive as possible and works much like \npythons exec statement. As an example, the following code fragment takes a 5 \npoint average of the 512x512 2d image, b, and stores it in array, a:\n\n
\n \nTo compile the expression, convert the expression to a string by putting\nquotes around it and then use\n from scipy import * # or from Numeric import *\n a = ones((512,512), Float64) \n b = ones((512,512), Float64) \n # ...do some stuff to fill in b...\n # now average\n a[1:-1,1:-1] = (b[1:-1,1:-1] + b[2:,1:-1] + b[:-2,1:-1] \\\n + b[1:-1,2:] + b[1:-1,:-2]) / 5.\n
weave.blitz:\n\n \n\nThe first time\n import weave\n expr = \"a[1:-1,1:-1] = (b[1:-1,1:-1] + b[2:,1:-1] + b[:-2,1:-1]\" \\\n \"+ b[1:-1,2:] + b[1:-1,:-2]) / 5.\"\n weave.blitz(expr)\n
weave.blitz is run for a given expression and \nset of arguements, C++ code that accomplishes the exact same task as the Python \nexpression is generated and compiled to an extension module. This can take up \nto a couple of minutes depending on the complexity of the function. Subsequent \ncalls to the function are very fast. Futher, the generated module is saved \nbetween program executions so that the compilation is only done once for a \ngiven expression and associated set of array types. If the given expression\nis executed with a new set of array types, the code most be compiled again. This\ndoes not overwrite the previously compiled function -- both of them are saved and\navailable for exectution. \n\nThe following table compares the run times for standard Numeric code and \ncompiled code for the 5 point averaging.\n
\n
| Method | Run Time (seconds) |
| Standard Numeric | 0.46349 |
| blitz (1st time compiling) | 78.95526 |
| blitz (subsequent calls) | 0.05843 (factor of 8 speedup) |
\nThese numbers are for a 512x512 double precision image run on a 400 MHz Celeron \nprocessor under RedHat Linux 6.2.\n
\nBecause of the slow compile times, its probably most effective to develop \nalgorithms as you usually do using the capabilities of scipy or the Numeric \nmodule. Once the algorithm is perfected, put quotes around it and execute it \nusing weave.blitz. This provides the standard rapid \nprototyping strengths of Python and results in algorithms that run close to \nthat of hand coded C or Fortran.\n\n\n
weave.blitz has only been tested under Linux \nwith gcc-2.95-3 and on Windows with Mingw32 (2.95.2). Its compiler \nrequirements are pretty heavy duty (see the \nblitz++ home page), so it won't \nwork with just any compiler. Particularly MSVC++ isn't up to snuff. A number \nof other compilers such as KAI++ will also work, but my suspicions are that gcc \nwill get the most use.\n\n\nweave.blitz handles all standard mathematic \noperators except for the ** power operator. The built-in trigonmetric, log, \nfloor/ceil, and fabs functions might work (but haven't been tested). It also \nhandles all types of array indexing supported by the Numeric module. \n\nweave.blitz does not currently support operations that use \narray broadcasting, nor have any of the special purpose functions in Numeric \nsuch as take, compress, etc. been implemented. Note that there are no obvious \nreasons why most of this functionality cannot be added to scipy.weave, so it \nwill likely trickle into future versions. Using slice() objects \ndirectly instead of start:stop:step is also not supported.\n
\n\nThis means that the result array must exist before calling \n\n >>> result = b + c + d\n
weave.blitz. Future versions will allow the following:\n\n \n\n >>> result = weave.blitz_eval(\"b + c + d\")\n
weave.blitz works best when algorithms can be expressed in a \n\"vectorized\" form. Algorithms that have a large number of if/thens and other \nconditions are better hand written in C or Fortran. Further, the restrictions \nimposed by requiring vectorized expressions sometimes preclude the use of more \nefficient data structures or algorithms. For maximum speed in these cases, \nhand-coded C or Fortran code is the only way to go.\nweave.blitz can produce different results than Numeric in certain \nsituations. It can happen when the array receiving the results of a \ncalculation is also used during the calculation. The Numeric behavior is to \ncarry out the entire calculation on the right hand side of an equation and \nstore it in a temporary array. This temprorary array is assigned to the array \non the left hand side of the equation. blitz, on the other hand, does a \n\"running\" calculation of the array elements assigning values from the right hand\nside to the elements on the left hand side immediately after they are calculated.\nHere is an example, provided by Prabhu Ramachandran, where this happens:\n\n \n \n You can prevent this behavior by using a temporary array.\n \n\n # 4 point average.\n >>> expr = \"u[1:-1, 1:-1] = (u[0:-2, 1:-1] + u[2:, 1:-1] + \"\\\n ... \"u[1:-1,0:-2] + u[1:-1, 2:])*0.25\"\n >>> u = zeros((5, 5), 'd'); u[0,:] = 100\n >>> exec (expr)\n >>> u\n array([[ 100., 100., 100., 100., 100.],\n [ 0., 25., 25., 25., 0.],\n [ 0., 0., 0., 0., 0.],\n [ 0., 0., 0., 0., 0.],\n [ 0., 0., 0., 0., 0.]])\n \n >>> u = zeros((5, 5), 'd'); u[0,:] = 100\n >>> weave.blitz (expr)\n >>> u\n array([[ 100. , 100. , 100. , 100. , 100. ],\n [ 0. , 25. , 31.25 , 32.8125 , 0. ],\n [ 0. , 6.25 , 9.375 , 10.546875 , 0. ],\n [ 0. , 1.5625 , 2.734375 , 3.3203125, 0. ],\n [ 0. , 0. , 0. , 0. , 0. ]]) \n
\n \n\n >>> u = zeros((5, 5), 'd'); u[0,:] = 100\n >>> temp = zeros((4, 4), 'd');\n >>> expr = \"temp = (u[0:-2, 1:-1] + u[2:, 1:-1] + \"\\\n ... \"u[1:-1,0:-2] + u[1:-1, 2:])*0.25;\"\\\n ... \"u[1:-1,1:-1] = temp\"\n >>> weave.blitz (expr)\n >>> u\n array([[ 100., 100., 100., 100., 100.],\n [ 0., 25., 25., 25., 0.],\n [ 0., 0., 0., 0., 0.],\n [ 0., 0., 0., 0., 0.],\n [ 0., 0., 0., 0., 0.]])\n
weave.blitz is not a general purpose Python->C compiler. It \nonly works for expressions that contain Numeric arrays and/or \nPython scalar values. This focused scope concentrates effort on the \ncompuationally intensive regions of the program and sidesteps the difficult \nissues associated with a general purpose Python->C compiler.\n\n \nWhen Numeric calculates the value for the 2d array,\n a = 1.2 * b + c * d\n
a, it does \nthe following steps:\n\n \n \nTwo things to note. Since\n temp1 = 1.2 * b\n temp2 = c * d\n a = temp1 + temp2\n
c is an (perhaps large) array, a large \ntemporary array must be created to store the results of 1.2 * b. \nThe same is true for temp2. Allocation is slow. The second thing \nis that we have 3 loops executing, one to calculate temp1, one for \ntemp2 and one for adding them up. A C loop for the same problem \nmight look like:\n\n \n \nHere, the 3 loops have been fused into a single loop and there is no longer\na need for a temporary array. This provides a significant speed improvement\nover the above example (write me and tell me what you get). \n\n for(int i = 0; i < M; i++)\n for(int j = 0; j < N; j++)\n a[i,j] = 1.2 * b[i,j] + c[i,j] * d[i,j]\n
\nSo, converting Numeric expressions into C/C++ loops that fuse the loops and \neliminate temporary arrays can provide big gains. The goal then,is to convert \nNumeric expression to C/C++ loops, compile them in an extension module, and \nthen call the compiled extension function. The good news is that there is an \nobvious correspondence between the Numeric expression above and the C loop. The \nbad news is that Numeric is generally much more powerful than this simple \nexample illustrates and handling all possible indexing possibilities results in \nloops that are less than straight forward to write. (take a peak in Numeric for \nconfirmation). Luckily, there are several available tools that simplify the \nprocess.\n\n\n
weave.blitz relies heavily on several remarkable tools. On the \nPython side, the main facilitators are Jermey Hylton's parser module and Jim \nHuginin's Numeric module. On the compiled language side, Todd Veldhuizen's \nblitz++ array library, written in C++ (shhhh. don't tell David Beazley), does \nthe heavy lifting. Don't assume that, because it's C++, it's much slower than C \nor Fortran. Blitz++ uses a jaw dropping array of template techniques \n(metaprogramming, template expression, etc) to convert innocent looking and \nreadable C++ expressions into to code that usually executes within a few \npercentage points of Fortran code for the same problem. This is good. \nUnfortunately all the template raz-ma-taz is very expensive to compile, so the \n200 line extension modules often take 2 or more minutes to compile. This isn't so \ngood. weave.blitz works to minimize this issue by remembering \nwhere compiled modules live and reusing them instead of re-compiling every time \na program is re-run.\n\n\nparser module. \nThe following fragment creates an Abstract Syntax Tree (AST) object for the \nexpression and then converts to a (rather unpleasant looking) deeply nested list \nrepresentation of the tree. \n \n \n\nDespite its looks, with some tools developed by Jermey H., its possible\nto search these trees for specific patterns (sub-trees), extract the \nsub-tree, manipulate them converting python specific code fragments\nto blitz code fragments, and then re-insert it in the parse tree. The parser\nmodule documentation has some details on how to do this. Traversing the \nnew blitzified tree, writing out the terminal symbols as you go, creates\nour new blitz++ expression string.\n\n \n\n >>> import parser\n >>> import scipy.weave.misc\n >>> ast = parser.suite(\"a = b * c + d\")\n >>> ast_list = ast.tolist()\n >>> sym_list = scipy.weave.misc.translate_symbols(ast_list)\n >>> pprint.pprint(sym_list)\n ['file_input',\n ['stmt',\n ['simple_stmt',\n ['small_stmt',\n ['expr_stmt',\n ['testlist',\n ['test',\n ['and_test',\n ['not_test',\n ['comparison',\n ['expr',\n ['xor_expr',\n ['and_expr',\n ['shift_expr',\n ['arith_expr',\n ['term',\n ['factor', ['power', ['atom', ['NAME', 'a']]]]]]]]]]]]]]],\n ['EQUAL', '='],\n ['testlist',\n ['test',\n ['and_test',\n ['not_test',\n ['comparison',\n ['expr',\n ['xor_expr',\n ['and_expr',\n ['shift_expr',\n ['arith_expr',\n ['term',\n ['factor', ['power', ['atom', ['NAME', 'b']]]],\n ['STAR', '*'],\n ['factor', ['power', ['atom', ['NAME', 'c']]]]],\n ['PLUS', '+'],\n ['term',\n ['factor', ['power', ['atom', ['NAME', 'd']]]]]]]]]]]]]]]]],\n ['NEWLINE', '']]],\n ['ENDMARKER', '']]\n
\n\n\nIn Blitz it is as follows:\n\n\n >>> a = b[0:4:2] + c\n >>> a\n [0,2,4]\n
\n\n\nHere the range object works exactly like Python slice objects with the exception\nthat the top index (3) is inclusive where as Python's (4) is exclusive. Other \ndifferences include the type declaraions in C++ and parentheses instead of \nbrackets for indexing arrays. Currently,\n Array<2,int> b(10);\n Array<2,int> c(3);\n // ...\n Array<2,int> a = b(Range(0,3,2)) + c;\n
weave.blitz handles the \ninclusive/exclusive issue by subtracting one from upper indices during the\ntranslation. An alternative that is likely more robust/maintainable in the \nlong run, is to write a PyRange class that behaves like Python's range. \nThis is likely very easy.\n\nThe stock blitz also doesn't handle negative indices in ranges. The current \nimplementation of the blitz() has a partial solution to this \nproblem. It calculates and index that starts with a '-' sign by subtracting it \nfrom the maximum index in the array so that:\n\n
\n\nThis approach fails, however, when the top index is calculated from other \nvalues. In the following scenario, if\n upper index limit\n /-----\\\n b[:-1] -> b(Range(0,Nb[0]-1-1))\n
i+j evaluates to a negative \nvalue, the compiled code will produce incorrect results and could even core-\ndump. Right now, all calculated indices are assumed to be positive.\n \n \n\nA solution is to calculate all indices up front using if/then to handle the\n+/- cases. This is a little work and results in more code, so it hasn't been\ndone. I'm holding out to see if blitz++ can be modified to handle negative\nindexing, but haven't looked into how much effort is involved yet. While it \nneeds fixin', I don't think there is a ton of code where this is an issue.\n\n b[:i-j] -> b(Range(0,i+j))\n
\nThe actual translation of the Python expressions to blitz expressions is \ncurrently a two part process. First, all x:y:z slicing expression are removed\nfrom the AST, converted to slice(x,y,z) and re-inserted into the tree. Any\nmath needed on these expressions (subtracting from the \nmaximum index, etc.) are also preformed here. _beg and _end are used as special\nvariables that are defined as blitz::fromBegin and blitz::toEnd.\n\n
\n\nbecomes a more verbose:\n \n\n a[i+j:i+j+1,:] = b[2:3,:] \n
\n \nThe second part does a simple string search/replace to convert to a blitz \nexpression with the following translations:\n\n\n a[slice(i+j,i+j+1),slice(_beg,_end)] = b[slice(2,3),slice(_beg,_end)]\n
\n\n\n slice(_beg,_end) -> _all # not strictly needed, but cuts down on code.\n slice -> blitz::Range\n [ -> (\n ] -> )\n _stp -> 1\n
_all is defined in the compiled function as \nblitz::Range.all(). These translations could of course happen \ndirectly in the syntax tree. But the string replacement is slightly easier. \nNote that name spaces are maintained in the C++ code to lessen the likelyhood \nof name clashes. Currently no effort is made to detect name clashes. A good \nrule of thumb is don't use values that start with '_' or 'py_' in compiled \nexpressions and you'll be fine.\n\n \nweave.blitz handles this issue by examining the types of the\nvariables in the expression being executed, and compiling a function for those\nexplicit types. For example:\n\n \n\nWhen compiling this expression to C++,\n a = ones((5,5),Float32)\n b = ones((5,5),Float32)\n weave.blitz(\"a = a + b\")\n
weave.blitz sees that the\nvalues for a and b in the local scope have type Float32, or 'float'\non a 32 bit architecture. As a result, it compiles the function using \nthe float type (no attempt has been made to deal with 64 bit issues).\nIt also goes one step further. If all arrays have the same type, a templated\nversion of the function is made and instantiated for float, double, \ncomplex\nWhat happens if you call a compiled function with array types that are \ndifferent than the ones for which it was originally compiled? No biggie, you'll \njust have to wait on it to compile a new version for your new types. This \ndoesn't overwrite the old functions, as they are still accessible. See the \ncatalog section in the inline() documentation to see how this is handled. \nSuffice to say, the mechanism is transparent to the user and behaves \nlike dynamic typing with the occasional wait for compiling newly typed \nfunctions.\n
\nWhen working with combined scalar/array operations, the type of the array is \nalways used. This is similar to the savespace flag that was recently \nadded to Numeric. This prevents issues with the following expression perhaps \nunexpectedly being calculated at a higher (more expensive) precision that can \noccur in Python:\n\n
\n \nIn this example, \n\n\n >>> a = array((1,2,3),typecode = Float32)\n >>> b = a * 2.1 # results in b being a Float64 array.\n
\n \nthe\n >>> a = ones((5,5),Float32)\n >>> b = ones((5,5),Float32)\n >>> weave.blitz(\"b = a * 2.1\")\n
2.1 is cast down to a float before carrying out \nthe operation. If you really want to force the calculation to be a \ndouble, define a and b as \ndouble arrays.\n\nOne other point of note. Currently, you must include both the right hand side \nand left hand side (assignment side) of your equation in the compiled \nexpression. Also, the array being assigned to must be created prior to calling \nweave.blitz. I'm pretty sure this is easily changed so that a \ncompiled_eval expression can be defined, but no effort has been made to \nallocate new arrays (and decern their type) on the fly.\n\n \n
weave.inline() documentation.\n\n \n\n \nIt only requires that arrays\n a = b + c\n
a, b, and c \nhave the same shape. However, expressions like:\n\n \n\nare not so trivial. Since slicing is involved, the size of the slices, not the \ninput arrays must be checked. Broadcasting complicates things further because \narrays and slices with different dimensions and shapes may be compatible for \nmath operations (broadcasting isn't yet supported by \n\n a[i+j:i+j+1,:] = b[2:3,:] + c\n
weave.blitz). Reductions have a similar effect as their \nresults are different shapes than their input operand. The binary operators in \nNumeric compare the shapes of their two operands just before they operate on \nthem. This is possible because Numeric treats each operation independently. \nThe intermediate (temporary) arrays created during sub-operations in an \nexpression are tested for the correct shape before they are combined by another \noperation. Because weave.blitz fuses all operations into a \nsingle loop, this isn't possible. The shape comparisons must be done and \nguaranteed compatible before evaluating the expression.\n\nThe solution chosen converts input arrays to \"dummy arrays\" that only represent \nthe dimensions of the arrays, not the data. Binary operations on dummy arrays \ncheck that input array sizes are comptible and return a dummy array with the \nsize correct size. Evaluating an expression of dummy arrays traces the \nchanging array sizes through all operations and fails if incompatible array \nsizes are ever found. \n
\nThe machinery for this is housed in weave.size_check. It \nbasically involves writing a new class (dummy array) and overloading it math \noperators to calculate the new sizes correctly. All the code is in Python and \nthere is a fair amount of logic (mainly to handle indexing and slicing) so the \noperation does impose some overhead. For large arrays (ie. 50x50x50), the \noverhead is negligible compared to evaluating the actual expression. For small \narrays (ie. 16x16), the overhead imposed for checking the shapes with this \nmethod can cause the weave.blitz to be slower than evaluating \nthe expression in Python. \n
\nWhat can be done to reduce the overhead? (1) The size checking code could be \nmoved into C. This would likely remove most of the overhead penalty compared \nto Numeric (although there is also some calling overhead), but no effort has \nbeen made to do this. (2) You can also call weave.blitz with\ncheck_size=0 and the size checking isn't done. However, if the \nsizes aren't compatible, it can cause a core-dump. So, foregoing size_checking\nisn't advisable until your code is well debugged.\n\n \n
weave.blitz uses the same machinery as \nweave.inline to build the extension module. The only difference\nis the code included in the function is automatically generated from the\nNumeric array expression instead of supplied by the user.\n\n\nweave.inline and weave.blitz are high level tools\nthat generate extension modules automatically. Under the covers, they use several\nclasses from weave.ext_tools to help generate the extension module.\nThe main two classes are ext_module and ext_function (I'd\nlike to add ext_class and ext_method also). These classes\nsimplify the process of generating extension modules by handling most of the \"boiler\nplate\" code automatically.\n\n\nNote: inline actually sub-classes weave.ext_tools.ext_function \nto generate slightly different code than the standard ext_function.\nThe main difference is that the standard class converts function arguments to\nC types, while inline always has two arguments, the local and global dicts, and\nthe grabs the variables that need to be convereted to C from these.\n\n\n\n\n\n\nThe function\n # examples/increment_example.py\n from weave import ext_tools\n \n def build_increment_ext():\n \"\"\" Build a simple extension with functions that increment numbers.\n The extension will be built in the local directory.\n \"\"\" \n mod = ext_tools.ext_module('increment_ext')\n \n a = 1 # effectively a type declaration for 'a' in the \n # following functions.\n \n ext_code = \"return_val = Py::new_reference_to(Py::Int(a+1));\" \n func = ext_tools.ext_function('increment',ext_code,['a'])\n mod.add_function(func)\n \n ext_code = \"return_val = Py::new_reference_to(Py::Int(a+2));\" \n func = ext_tools.ext_function('increment_by_2',ext_code,['a'])\n mod.add_function(func)\n \n mod.compile()\n
build_increment_ext() creates an extension module \nnamed increment_ext and compiles it to a shared library (.so or \n.pyd) that can be loaded into Python.. increment_ext contains two \nfunctions, increment and increment_by_2. \n\nThe first line of build_increment_ext(),\n\n \n\ncreates an\n mod = ext_tools.ext_module('increment_ext') \n
ext_module instance that is ready to have \next_function instances added to it. ext_function \ninstances are created much with a calling convention similar to \nweave.inline(). The most common call includes a C/C++ code \nsnippet and a list of the arguments for the function. The following\n\n \n \ncreates a C/C++ extension function that is equivalent to the following Python\nfunction:\n\n\n ext_code = \"return_val = Py::new_reference_to(Py::Int(a+1));\" \n func = ext_tools.ext_function('increment',ext_code,['a'])\n
\n\nA second method is also added to the module and then,\n\n\n def increment(a):\n return a + 1\n
\n\nis called to build the extension module. By default, the module is created\nin the current working directory.\n\nThis example is available in the\n mod.compile()\n
examples/increment_example.py file\nfound in the weave directory. At the bottom of the file in the\nmodule's \"main\" program, an attempt to import increment_ext without\nbuilding it is made. If this fails (the module doesn't exist in the PYTHONPATH), \nthe module is built by calling build_increment_ext(). This approach\nonly takes the time consuming ( a few seconds for this example) process of building\nthe module if it hasn't been built before.\n\n \n\n\nNote: If we were willing to always pay the penalty of building the C++ code for \na module, we could store the md5 checksum of the C++ code along with some \ninformation about the compiler, platform, etc. Then, \n\n if __name__ == \"__main__\":\n try:\n import increment_ext\n except ImportError:\n build_increment_ext()\n import increment_ext\n a = 1\n print 'a, a+1:', a, increment_ext.increment(a)\n print 'a, a+2:', a, increment_ext.increment_by_2(a) \n
ext_module.compile() could try importing the module before it actually\ncompiles it, check the md5 checksum and other meta-data in the imported module\nwith the meta-data of the code it just produced and only compile the code if\nthe module didn't exist or the meta-data didn't match. This would reduce the\nabove code to:\n\n \n\nNote: There would always be the overhead of building the C++ code, but it would only actually compile the code once. You pay a little in overhead and get cleaner\n\"import\" code. Needs some thought.\n\n\n if __name__ == \"__main__\":\n build_increment_ext()\n\n a = 1\n print 'a, a+1:', a, increment_ext.increment(a)\n print 'a, a+2:', a, increment_ext.increment_by_2(a) \n
\n\nIf you run increment_example.py from the command line, you get\nthe following:\n\n
\n\nIf the module didn't exist before it was run, the module is created. If it did\nexist, it is just imported and used.\n\n\n\n [eric@n0]$ python increment_example.py\n a, a+1: 1 2\n a, a+2: 1 3\n
examples/fibonacci.py provides a little more complex example of \nhow to use ext_tools. Fibonacci numbers are a series of numbers \nwhere each number in the series is the sum of the previous two: 1, 1, 2, 3, 5, \n8, etc. Here, the first two numbers in the series are taken to be 1. One \napproach to calculating Fibonacci numbers uses recursive function calls. In \nPython, it might be written as:\n\n \n\nIn C, the same function would look something like this:\n\n\n def fib(a):\n if a <= 2:\n return 1\n else:\n return fib(a-2) + fib(a-1)\n
\n\nRecursion is much faster in C than in Python, so it would be beneficial\nto use the C version for fibonacci number calculations instead of the\nPython version. We need an extension function that calls this C function\nto do this. This is possible by including the above code snippet as \n\"support code\" and then calling it from the extension function. Support \ncode snippets (usually structure definitions, helper functions and the like)\nare inserted into the extension module C/C++ file before the extension\nfunction code. Here is how to build the C version of the fibonacci number\ngenerator:\n\n\n int fib(int a)\n { \n if(a <= 2)\n return 1;\n else\n return fib(a-2) + fib(a-1); \n } \n
\n\nXXX More about custom_info, and what xxx_info instances are good for.\n\n\ndef build_fibonacci():\n \"\"\" Builds an extension module with fibonacci calculators.\n \"\"\"\n mod = ext_tools.ext_module('fibonacci_ext')\n a = 1 # this is effectively a type declaration\n \n # recursive fibonacci in C \n fib_code = \"\"\"\n int fib1(int a)\n { \n if(a <= 2)\n return 1;\n else\n return fib1(a-2) + fib1(a-1); \n } \n \"\"\"\n ext_code = \"\"\"\n int val = fib1(a);\n return_val = Py::new_reference_to(Py::Int(val));\n \"\"\" \n fib = ext_tools.ext_function('fib',ext_code,['a'])\n fib.customize.add_support_code(fib_code)\n mod.add_function(fib)\n\n mod.compile()\n\n
\n\nNote: recursion is not the fastest way to calculate fibonacci numbers, but this \napproach serves nicely for this example.\n\n
weave didstdio.h) For instance, if you\ntry to pass in a variable named stdout, you'll get a cryptic error report\ndue to the fact that stdio.h also defines the name. weave\nshould probably try and handle this in some way.\n\nOther things...",
"methods": [],
"methods_before": [],
"changed_methods": [],
"nloc": null,
"complexity": null,
"token_count": null,
"diff_parsed": {
"added": [
"For printing strings, the format statement needs to be changed. Also, weave",
"doesn't convert strings to char*. Instead it uses CXX Py::String type, so",
"you have to do a little more work. Here we convert it to a C++ std::string",
"and then ask cor the char* version.",
" >>> a = 'string'",
" >>> weave.inline(r'printf(\"%s\\n\",std::string(a).c_str());',['a'])",
"",
"",
"This is a little convoluted. Perhaps strings should convert to std::string",
"objects instead of CXX objects. Or maybe to char*.",
""
],
"deleted": [
"For printing strings, the format statement needs to be changed.",
" >>> a = 'string'",
" >>> weave.inline(r'printf(\"%s\\n\",a);',['a'])"
]
}
}
]
},
{
"hash": "c9d6cb8e55c5bd9fc27b359e3f87530b1e602288",
"msg": "found improved way of making g++ -shared the linker instead of simply adding stdc++ as a library for gcc.",
"author": {
"name": "Eric Jones",
"email": "eric@enthought.com"
},
"committer": {
"name": "Eric Jones",
"email": "eric@enthought.com"
},
"author_date": "2002-01-16T09:41:21+00:00",
"author_timezone": 0,
"committer_date": "2002-01-16T09:41:21+00:00",
"committer_timezone": 0,
"branches": [
"main"
],
"in_main_branch": true,
"merge": false,
"parents": [
"653df5af033fd2514869639131074f58c68a2f38"
],
"project_name": "repo_copy",
"project_path": "/tmp/tmp55a0ktwg/repo_copy",
"deletions": 6,
"insertions": 24,
"lines": 30,
"files": 1,
"dmm_unit_size": 1.0,
"dmm_unit_complexity": 1.0,
"dmm_unit_interfacing": 1.0,
"modified_files": [
{
"old_path": "weave/build_tools.py",
"new_path": "weave/build_tools.py",
"filename": "build_tools.py",
"extension": "py",
"change_type": "MODIFY",
"diff": "@@ -21,6 +21,21 @@\n import tempfile\n import exceptions\n \n+# If linker is 'gcc', this will convert it to 'g++'\n+# necessary to make sure stdc++ is linked in cross-platform way.\n+import distutils.sysconfig\n+\n+old_init_posix = distutils.sysconfig._init_posix\n+\n+def _init_posix():\n+ old_init_posix()\n+ ld = distutils.sysconfig._config_vars['LDSHARED']\n+ distutils.sysconfig._config_vars['LDSHARED'] = ld.replace('gcc','g++')\n+\n+distutils.sysconfig._init_posix = _init_posix \n+# end force g++\n+\n+\n class CompileError(exceptions.Exception):\n pass\n \n@@ -144,12 +159,15 @@ def build_extension(module_path,compiler_name = '',build_dir = None,\n sources = kw.get('sources',[])\n kw['sources'] = [module_path] + sources \n \n- # add module to the needed source code files and build extension\n- # FIX this is g++ specific. It probably should be fixed for other\n- # Unices/compilers. Find a generic solution\n- if compiler_name != 'msvc':\n- libraries = kw.get('libraries',[])\n- kw['libraries'] = ['stdc++'] + libraries \n+ # ! This was fixed at beginning of file by using g++ on most \n+ # !machines. We'll have to check how to handle it on non-gcc machines \n+ ## add module to the needed source code files and build extension\n+ ## FIX this is g++ specific. It probably should be fixed for other\n+ ## Unices/compilers. Find a generic solution\n+ #if compiler_name != 'msvc':\n+ # libraries = kw.get('libraries',[])\n+ # kw['libraries'] = ['stdc++'] + libraries \n+ # !\n \n # SunOS specific\n # fix for issue with linking to libstdc++.a. see:\n",
"added_lines": 24,
"deleted_lines": 6,
"source_code": "\"\"\" Tools for compiling C/C++ code to extension modules\n\n The main function, build_extension(), takes the C/C++ file\n along with some other options and builds a Python extension.\n It uses distutils for most of the heavy lifting.\n \n choose_compiler() is also useful (mainly on windows anyway)\n for trying to determine whether MSVC++ or gcc is available.\n MSVC doesn't handle templates as well, so some of the code emitted\n by the python->C conversions need this info to choose what kind\n of code to create.\n \n The other main thing here is an alternative version of the MingW32\n compiler class. The class makes it possible to build libraries with\n gcc even if the original version of python was built using MSVC. It\n does this by converting a pythonxx.lib file to a libpythonxx.a file.\n Note that you need write access to the pythonxx/lib directory to do this.\n\"\"\"\n\nimport sys,os,string,time\nimport tempfile\nimport exceptions\n\n# If linker is 'gcc', this will convert it to 'g++'\n# necessary to make sure stdc++ is linked in cross-platform way.\nimport distutils.sysconfig\n\nold_init_posix = distutils.sysconfig._init_posix\n\ndef _init_posix():\n old_init_posix()\n ld = distutils.sysconfig._config_vars['LDSHARED']\n distutils.sysconfig._config_vars['LDSHARED'] = ld.replace('gcc','g++')\n\ndistutils.sysconfig._init_posix = _init_posix \n# end force g++\n\n\nclass CompileError(exceptions.Exception):\n pass\n \ndef build_extension(module_path,compiler_name = '',build_dir = None,\n temp_dir = None, verbose = 0, **kw):\n \"\"\" Build the file given by module_path into a Python extension module.\n \n build_extensions uses distutils to build Python extension modules.\n kw arguments not used are passed on to the distutils extension\n module. Directory settings can handle absoulte settings, but don't\n currently expand '~' or environment variables.\n \n module_path -- the full path name to the c file to compile. \n Something like: /full/path/name/module_name.c \n The name of the c/c++ file should be the same as the\n name of the module (i.e. the initmodule() routine)\n compiler_name -- The name of the compiler to use. On Windows if it \n isn't given, MSVC is used if it exists (is found).\n gcc is used as a second choice. If neither are found, \n the default distutils compiler is used. Acceptable \n names are 'gcc', 'msvc' or any of the compiler names \n shown by distutils.ccompiler.show_compilers()\n build_dir -- The location where the resulting extension module \n should be placed. This location must be writable. If\n it isn't, several default locations are tried. If the \n build_dir is not in the current python path, a warning\n is emitted, and it is added to the end of the path.\n build_dir defaults to the current directory.\n temp_dir -- The location where temporary files (*.o or *.obj)\n from the build are placed. This location must be \n writable. If it isn't, several default locations are \n tried. It defaults to tempfile.gettempdir()\n verbose -- 0, 1, or 2. 0 is as quiet as possible. 1 prints\n minimal information. 2 is noisy. \n **kw -- keyword arguments. These are passed on to the \n distutils extension module. Most of the keywords\n are listed below.\n\n Distutils keywords. These are cut and pasted from Greg Ward's\n distutils.extension.Extension class for convenience:\n \n sources : [string]\n list of source filenames, relative to the distribution root\n (where the setup script lives), in Unix form (slash-separated)\n for portability. Source files may be C, C++, SWIG (.i),\n platform-specific resource files, or whatever else is recognized\n by the \"build_ext\" command as source for a Python extension.\n Note: The module_path file is always appended to the front of this\n list \n include_dirs : [string]\n list of directories to search for C/C++ header files (in Unix\n form for portability) \n define_macros : [(name : string, value : string|None)]\n list of macros to define; each macro is defined using a 2-tuple,\n where 'value' is either the string to define it to or None to\n define it without a particular value (equivalent of \"#define\n FOO\" in source or -DFOO on Unix C compiler command line) \n undef_macros : [string]\n list of macros to undefine explicitly\n library_dirs : [string]\n list of directories to search for C/C++ libraries at link time\n libraries : [string]\n list of library names (not filenames or paths) to link against\n runtime_library_dirs : [string]\n list of directories to search for C/C++ libraries at run time\n (for shared extensions, this is when the extension is loaded)\n extra_objects : [string]\n list of extra files to link with (eg. object files not implied\n by 'sources', static library that must be explicitly specified,\n binary resource files, etc.)\n extra_compile_args : [string]\n any extra platform- and compiler-specific information to use\n when compiling the source files in 'sources'. For platforms and\n compilers where \"command line\" makes sense, this is typically a\n list of command-line arguments, but for other platforms it could\n be anything.\n extra_link_args : [string]\n any extra platform- and compiler-specific information to use\n when linking object files together to create the extension (or\n to create a new static Python interpreter). Similar\n interpretation as for 'extra_compile_args'.\n export_symbols : [string]\n list of symbols to be exported from a shared extension. Not\n used on all platforms, and not generally necessary for Python\n extensions, which typically export exactly one symbol: \"init\" +\n extension_name.\n \"\"\"\n success = 0\n from distutils.core import setup, Extension\n \n # this is a screwy trick to get rid of a ton of warnings on Unix\n import distutils.sysconfig\n distutils.sysconfig.get_config_vars()\n if distutils.sysconfig._config_vars.has_key('OPT'):\n flags = distutils.sysconfig._config_vars['OPT'] \n flags = flags.replace('-Wall','')\n distutils.sysconfig._config_vars['OPT'] = flags\n \n # get the name of the module and the extension directory it lives in. \n module_dir,cpp_name = os.path.split(os.path.abspath(module_path))\n module_name,ext = os.path.splitext(cpp_name) \n \n # configure temp and build directories\n temp_dir = configure_temp_dir(temp_dir) \n build_dir = configure_build_dir(module_dir)\n \n compiler_name = choose_compiler(compiler_name)\n configure_sys_argv(compiler_name,temp_dir,build_dir)\n \n # the business end of the function\n try:\n if verbose == 1:\n print 'Compiling code...'\n \n # set compiler verboseness 2 or more makes it output results\n if verbose > 1: verb = 1 \n else: verb = 0\n \n t1 = time.time() \n # add module to the needed source code files and build extension\n sources = kw.get('sources',[])\n kw['sources'] = [module_path] + sources \n \n # ! This was fixed at beginning of file by using g++ on most \n # !machines. We'll have to check how to handle it on non-gcc machines \n ## add module to the needed source code files and build extension\n ## FIX this is g++ specific. It probably should be fixed for other\n ## Unices/compilers. Find a generic solution\n #if compiler_name != 'msvc':\n # libraries = kw.get('libraries',[])\n # kw['libraries'] = ['stdc++'] + libraries \n # !\n \n # SunOS specific\n # fix for issue with linking to libstdc++.a. see:\n # http://mail.python.org/pipermail/python-dev/2001-March/013510.html\n platform = sys.platform\n version = sys.version.lower()\n if platform[:5] == 'sunos' and version.find('gcc') != -1:\n extra_link_args = kw.get('extra_link_args',[])\n kw['extra_link_args'] = ['-mimpure-text'] + extra_link_args\n \n ext = Extension(module_name, **kw)\n \n # the switcheroo on SystemExit here is meant to keep command line\n # sessions from exiting when compiles fail.\n builtin = sys.modules['__builtin__']\n old_SysExit = builtin.__dict__['SystemExit']\n builtin.__dict__['SystemExit'] = CompileError\n \n # distutils for MSVC messes with the environment, so we save the\n # current state and restore them afterward.\n import copy\n environ = copy.deepcopy(os.environ)\n try:\n setup(name = module_name, ext_modules = [ext],verbose=verb)\n finally:\n # restore state\n os.environ = environ \n # restore SystemExit\n builtin.__dict__['SystemExit'] = old_SysExit\n t2 = time.time()\n \n if verbose == 1:\n print 'finished compiling (sec): ', t2 - t1 \n success = 1\n configure_python_path(build_dir)\n except SyntaxError: #TypeError:\n success = 0 \n \n # restore argv after our trick... \n restore_sys_argv()\n \n return success\n\nold_argv = []\ndef configure_sys_argv(compiler_name,temp_dir,build_dir):\n # We're gonna play some tricks with argv here to pass info to distutils \n # which is really built for command line use. better way??\n global old_argv\n old_argv = sys.argv[:] \n sys.argv = ['','build_ext','--build-lib', build_dir,\n '--build-temp',temp_dir] \n if compiler_name == 'gcc':\n sys.argv.insert(2,'--compiler='+compiler_name)\n elif compiler_name:\n sys.argv.insert(2,'--compiler='+compiler_name)\n\ndef restore_sys_argv():\n sys.argv = old_argv\n \ndef configure_python_path(build_dir): \n #make sure the module lives in a directory on the python path.\n python_paths = [os.path.abspath(x) for x in sys.path]\n if os.path.abspath(build_dir) not in python_paths:\n #print \"warning: build directory was not part of python path.\"\\\n # \" It has been appended to the path.\"\n sys.path.append(os.path.abspath(build_dir))\n\ndef choose_compiler(compiler_name=''):\n \"\"\" Try and figure out which compiler is gonna be used on windows.\n On other platforms, it just returns whatever value it is given.\n \n converts 'gcc' to 'mingw32' on win32\n \"\"\"\n if sys.platform == 'win32': \n if not compiler_name:\n # On Windows, default to MSVC and use gcc if it wasn't found\n # wasn't found. If neither are found, go with whatever\n # the default is for distutils -- and probably fail...\n if msvc_exists():\n compiler_name = 'msvc'\n elif gcc_exists():\n compiler_name = 'mingw32'\n elif compiler_name == 'gcc':\n compiler_name = 'mingw32'\n else:\n # don't know how to force gcc -- look into this.\n if compiler_name == 'gcc':\n compiler_name = 'unix' \n return compiler_name\n \ndef gcc_exists():\n \"\"\" Test to make sure gcc is found \n \n Does this return correct value on win98???\n \"\"\"\n result = 0\n try:\n w,r=os.popen4('gcc -v')\n w.close()\n str_result = r.read()\n #print str_result\n if string.find(str_result,'Reading specs') != -1:\n result = 1\n except:\n # This was needed because the msvc compiler messes with\n # the path variable. and will occasionlly mess things up\n # so much that gcc is lost in the path. (Occurs in test\n # scripts)\n result = not os.system('gcc -v')\n return result\n\ndef msvc_exists():\n \"\"\" Determine whether MSVC is available on the machine.\n \"\"\"\n result = 0\n try:\n w,r=os.popen4('cl')\n w.close()\n str_result = r.read()\n #print str_result\n if string.find(str_result,'Microsoft') != -1:\n result = 1\n except:\n #assume we're ok if devstudio exists\n import distutils.msvccompiler\n version = distutils.msvccompiler.get_devstudio_version()\n if version:\n result = 1\n return result\n\ndef configure_temp_dir(temp_dir=None):\n if temp_dir is None: \n temp_dir = tempfile.gettempdir()\n elif not os.path.exists(temp_dir) or not os.access(temp_dir,os.W_OK):\n print \"warning: specified temp_dir '%s' does not exist or is \" \\\n \"or is not writable. Using the default temp directory\" % \\\n temp_dir\n temp_dir = tempfile.gettempdir()\n\n # final check that that directories are writable. \n if not os.access(temp_dir,os.W_OK):\n msg = \"Either the temp or build directory wasn't writable. Check\" \\\n \" these locations: '%s'\" % temp_dir \n raise ValueError, msg\n return temp_dir\n\ndef configure_build_dir(build_dir=None):\n # make sure build_dir exists and is writable\n if build_dir and (not os.path.exists(build_dir) or \n not os.access(build_dir,os.W_OK)):\n print \"warning: specified build_dir '%s' does not exist or is \" \\\n \"or is not writable. Trying default locations\" % build_dir\n build_dir = None\n \n if build_dir is None:\n #default to building in the home directory of the given module. \n build_dir = os.curdir\n # if it doesn't work use the current directory. This should always\n # be writable. \n if not os.access(build_dir,os.W_OK):\n print \"warning:, neither the module's directory nor the \"\\\n \"current directory are writable. Using the temporary\"\\\n \"directory.\"\n build_dir = tempfile.gettempdir()\n\n # final check that that directories are writable.\n if not os.access(build_dir,os.W_OK):\n msg = \"The build directory wasn't writable. Check\" \\\n \" this location: '%s'\" % build_dir\n raise ValueError, msg\n \n return os.path.abspath(build_dir) \n \nif sys.platform == 'win32':\n import distutils.cygwinccompiler\n # the same as cygwin plus some additional parameters\n class Mingw32CCompiler (distutils.cygwinccompiler.CygwinCCompiler):\n \"\"\" A modified MingW32 compiler compatible with an MSVC built Python.\n \n \"\"\"\n \n compiler_type = 'mingw32'\n \n def __init__ (self,\n verbose=0,\n dry_run=0,\n force=0):\n \n distutils.cygwinccompiler.CygwinCCompiler.__init__ (self, verbose, \n dry_run, force)\n \n # A real mingw32 doesn't need to specify a different entry point,\n # but cygwin 2.91.57 in no-cygwin-mode needs it.\n if self.gcc_version <= \"2.91.57\":\n entry_point = '--entry _DllMain@12'\n else:\n entry_point = ''\n if self.linker_dll == 'dllwrap':\n self.linker = 'dllwrap' + ' --driver-name g++'\n elif self.linker_dll == 'gcc':\n self.linker = 'g++' \n # **changes: eric jones 4/11/01\n # 1. Check for import library on Windows. Build if it doesn't exist.\n if not import_library_exists():\n build_import_library()\n \n # **changes: eric jones 4/11/01\n # 2. increased optimization and turned off all warnings\n # 3. also added --driver-name g++\n #self.set_executables(compiler='gcc -mno-cygwin -O2 -w',\n # compiler_so='gcc -mno-cygwin -mdll -O2 -w',\n # linker_exe='gcc -mno-cygwin',\n # linker_so='%s --driver-name g++ -mno-cygwin -mdll -static %s' \n # % (self.linker, entry_point))\n self.set_executables(compiler='g++ -mno-cygwin -O2 -w',\n compiler_so='g++ -mno-cygwin -mdll -O2 -w -Wstrict-prototypes',\n linker_exe='g++ -mno-cygwin',\n linker_so='%s -mno-cygwin -mdll -static %s' \n % (self.linker, entry_point))\n \n # Maybe we should also append -mthreads, but then the finished\n # dlls need another dll (mingwm10.dll see Mingw32 docs)\n # (-mthreads: Support thread-safe exception handling on `Mingw32') \n \n # no additional libraries needed \n self.dll_libraries=[]\n \n # __init__ ()\n \n # On windows platforms, we want to default to mingw32 (gcc)\n # because msvc can't build blitz stuff.\n # We should also check the version of gcc available...\n #distutils.ccompiler._default_compilers['nt'] = 'mingw32'\n #distutils.ccompiler._default_compilers = (('nt', 'mingw32'))\n # reset the Mingw32 compiler in distutils to the one defined above\n distutils.cygwinccompiler.Mingw32CCompiler = Mingw32CCompiler\n \n def import_library_exists():\n \"\"\" on windows platforms, make sure a gcc import library exists\n \"\"\"\n if os.name == 'nt':\n lib_name = \"libpython%d%d.a\" % tuple(sys.version_info[:2])\n full_path = os.path.join(sys.prefix,'libs',lib_name)\n if not os.path.exists(full_path):\n return 0\n return 1\n \n def build_import_library():\n \"\"\" Build the import libraries for Mingw32-gcc on Windows\n \"\"\"\n import lib2def as lib2def\n #libfile, deffile = parse_cmd()\n #if deffile == None:\n # deffile = sys.stdout\n #else:\n # deffile = open(deffile, 'w')\n lib_name = \"python%d%d.lib\" % tuple(sys.version_info[:2]) \n lib_file = os.path.join(sys.prefix,'libs',lib_name)\n def_name = \"python%d%d.def\" % tuple(sys.version_info[:2]) \n def_file = os.path.join(sys.prefix,'libs',def_name)\n nm_cmd = '%s %s' % (lib2def.DEFAULT_NM, lib_file)\n nm_output = lib2def.getnm(nm_cmd)\n dlist, flist = lib2def.parse_nm(nm_output)\n lib2def.output_def(dlist, flist, lib2def.DEF_HEADER, open(def_file, 'w'))\n \n out_name = \"libpython%d%d.a\" % tuple(sys.version_info[:2])\n out_file = os.path.join(sys.prefix,'libs',out_name)\n dll_name = \"python%d%d.dll\" % tuple(sys.version_info[:2])\n args = (dll_name,def_file,out_file)\n cmd = 'dlltool --dllname %s --def %s --output-lib %s' % args\n success = not os.system(cmd)\n # for now, fail silently\n if not success:\n print 'WARNING: failed to build import library for gcc. Linking will fail.'\n #if not success:\n # msg = \"Couldn't find import library, and failed to build it.\"\n # raise DistutilsPlatformError, msg\n \ndef test():\n from scipy_test import module_test\n module_test(__name__,__file__)\n\ndef test_suite():\n from scipy_test import module_test_suite\n return module_test_suite(__name__,__file__) \n\n\n\n",
"source_code_before": "\"\"\" Tools for compiling C/C++ code to extension modules\n\n The main function, build_extension(), takes the C/C++ file\n along with some other options and builds a Python extension.\n It uses distutils for most of the heavy lifting.\n \n choose_compiler() is also useful (mainly on windows anyway)\n for trying to determine whether MSVC++ or gcc is available.\n MSVC doesn't handle templates as well, so some of the code emitted\n by the python->C conversions need this info to choose what kind\n of code to create.\n \n The other main thing here is an alternative version of the MingW32\n compiler class. The class makes it possible to build libraries with\n gcc even if the original version of python was built using MSVC. It\n does this by converting a pythonxx.lib file to a libpythonxx.a file.\n Note that you need write access to the pythonxx/lib directory to do this.\n\"\"\"\n\nimport sys,os,string,time\nimport tempfile\nimport exceptions\n\nclass CompileError(exceptions.Exception):\n pass\n \ndef build_extension(module_path,compiler_name = '',build_dir = None,\n temp_dir = None, verbose = 0, **kw):\n \"\"\" Build the file given by module_path into a Python extension module.\n \n build_extensions uses distutils to build Python extension modules.\n kw arguments not used are passed on to the distutils extension\n module. Directory settings can handle absoulte settings, but don't\n currently expand '~' or environment variables.\n \n module_path -- the full path name to the c file to compile. \n Something like: /full/path/name/module_name.c \n The name of the c/c++ file should be the same as the\n name of the module (i.e. the initmodule() routine)\n compiler_name -- The name of the compiler to use. On Windows if it \n isn't given, MSVC is used if it exists (is found).\n gcc is used as a second choice. If neither are found, \n the default distutils compiler is used. Acceptable \n names are 'gcc', 'msvc' or any of the compiler names \n shown by distutils.ccompiler.show_compilers()\n build_dir -- The location where the resulting extension module \n should be placed. This location must be writable. If\n it isn't, several default locations are tried. If the \n build_dir is not in the current python path, a warning\n is emitted, and it is added to the end of the path.\n build_dir defaults to the current directory.\n temp_dir -- The location where temporary files (*.o or *.obj)\n from the build are placed. This location must be \n writable. If it isn't, several default locations are \n tried. It defaults to tempfile.gettempdir()\n verbose -- 0, 1, or 2. 0 is as quiet as possible. 1 prints\n minimal information. 2 is noisy. \n **kw -- keyword arguments. These are passed on to the \n distutils extension module. Most of the keywords\n are listed below.\n\n Distutils keywords. These are cut and pasted from Greg Ward's\n distutils.extension.Extension class for convenience:\n \n sources : [string]\n list of source filenames, relative to the distribution root\n (where the setup script lives), in Unix form (slash-separated)\n for portability. Source files may be C, C++, SWIG (.i),\n platform-specific resource files, or whatever else is recognized\n by the \"build_ext\" command as source for a Python extension.\n Note: The module_path file is always appended to the front of this\n list \n include_dirs : [string]\n list of directories to search for C/C++ header files (in Unix\n form for portability) \n define_macros : [(name : string, value : string|None)]\n list of macros to define; each macro is defined using a 2-tuple,\n where 'value' is either the string to define it to or None to\n define it without a particular value (equivalent of \"#define\n FOO\" in source or -DFOO on Unix C compiler command line) \n undef_macros : [string]\n list of macros to undefine explicitly\n library_dirs : [string]\n list of directories to search for C/C++ libraries at link time\n libraries : [string]\n list of library names (not filenames or paths) to link against\n runtime_library_dirs : [string]\n list of directories to search for C/C++ libraries at run time\n (for shared extensions, this is when the extension is loaded)\n extra_objects : [string]\n list of extra files to link with (eg. object files not implied\n by 'sources', static library that must be explicitly specified,\n binary resource files, etc.)\n extra_compile_args : [string]\n any extra platform- and compiler-specific information to use\n when compiling the source files in 'sources'. For platforms and\n compilers where \"command line\" makes sense, this is typically a\n list of command-line arguments, but for other platforms it could\n be anything.\n extra_link_args : [string]\n any extra platform- and compiler-specific information to use\n when linking object files together to create the extension (or\n to create a new static Python interpreter). Similar\n interpretation as for 'extra_compile_args'.\n export_symbols : [string]\n list of symbols to be exported from a shared extension. Not\n used on all platforms, and not generally necessary for Python\n extensions, which typically export exactly one symbol: \"init\" +\n extension_name.\n \"\"\"\n success = 0\n from distutils.core import setup, Extension\n \n # this is a screwy trick to get rid of a ton of warnings on Unix\n import distutils.sysconfig\n distutils.sysconfig.get_config_vars()\n if distutils.sysconfig._config_vars.has_key('OPT'):\n flags = distutils.sysconfig._config_vars['OPT'] \n flags = flags.replace('-Wall','')\n distutils.sysconfig._config_vars['OPT'] = flags\n \n # get the name of the module and the extension directory it lives in. \n module_dir,cpp_name = os.path.split(os.path.abspath(module_path))\n module_name,ext = os.path.splitext(cpp_name) \n \n # configure temp and build directories\n temp_dir = configure_temp_dir(temp_dir) \n build_dir = configure_build_dir(module_dir)\n \n compiler_name = choose_compiler(compiler_name)\n configure_sys_argv(compiler_name,temp_dir,build_dir)\n \n # the business end of the function\n try:\n if verbose == 1:\n print 'Compiling code...'\n \n # set compiler verboseness 2 or more makes it output results\n if verbose > 1: verb = 1 \n else: verb = 0\n \n t1 = time.time() \n # add module to the needed source code files and build extension\n sources = kw.get('sources',[])\n kw['sources'] = [module_path] + sources \n \n # add module to the needed source code files and build extension\n # FIX this is g++ specific. It probably should be fixed for other\n # Unices/compilers. Find a generic solution\n if compiler_name != 'msvc':\n libraries = kw.get('libraries',[])\n kw['libraries'] = ['stdc++'] + libraries \n \n # SunOS specific\n # fix for issue with linking to libstdc++.a. see:\n # http://mail.python.org/pipermail/python-dev/2001-March/013510.html\n platform = sys.platform\n version = sys.version.lower()\n if platform[:5] == 'sunos' and version.find('gcc') != -1:\n extra_link_args = kw.get('extra_link_args',[])\n kw['extra_link_args'] = ['-mimpure-text'] + extra_link_args\n \n ext = Extension(module_name, **kw)\n \n # the switcheroo on SystemExit here is meant to keep command line\n # sessions from exiting when compiles fail.\n builtin = sys.modules['__builtin__']\n old_SysExit = builtin.__dict__['SystemExit']\n builtin.__dict__['SystemExit'] = CompileError\n \n # distutils for MSVC messes with the environment, so we save the\n # current state and restore them afterward.\n import copy\n environ = copy.deepcopy(os.environ)\n try:\n setup(name = module_name, ext_modules = [ext],verbose=verb)\n finally:\n # restore state\n os.environ = environ \n # restore SystemExit\n builtin.__dict__['SystemExit'] = old_SysExit\n t2 = time.time()\n \n if verbose == 1:\n print 'finished compiling (sec): ', t2 - t1 \n success = 1\n configure_python_path(build_dir)\n except SyntaxError: #TypeError:\n success = 0 \n \n # restore argv after our trick... \n restore_sys_argv()\n \n return success\n\nold_argv = []\ndef configure_sys_argv(compiler_name,temp_dir,build_dir):\n # We're gonna play some tricks with argv here to pass info to distutils \n # which is really built for command line use. better way??\n global old_argv\n old_argv = sys.argv[:] \n sys.argv = ['','build_ext','--build-lib', build_dir,\n '--build-temp',temp_dir] \n if compiler_name == 'gcc':\n sys.argv.insert(2,'--compiler='+compiler_name)\n elif compiler_name:\n sys.argv.insert(2,'--compiler='+compiler_name)\n\ndef restore_sys_argv():\n sys.argv = old_argv\n \ndef configure_python_path(build_dir): \n #make sure the module lives in a directory on the python path.\n python_paths = [os.path.abspath(x) for x in sys.path]\n if os.path.abspath(build_dir) not in python_paths:\n #print \"warning: build directory was not part of python path.\"\\\n # \" It has been appended to the path.\"\n sys.path.append(os.path.abspath(build_dir))\n\ndef choose_compiler(compiler_name=''):\n \"\"\" Try and figure out which compiler is gonna be used on windows.\n On other platforms, it just returns whatever value it is given.\n \n converts 'gcc' to 'mingw32' on win32\n \"\"\"\n if sys.platform == 'win32': \n if not compiler_name:\n # On Windows, default to MSVC and use gcc if it wasn't found\n # wasn't found. If neither are found, go with whatever\n # the default is for distutils -- and probably fail...\n if msvc_exists():\n compiler_name = 'msvc'\n elif gcc_exists():\n compiler_name = 'mingw32'\n elif compiler_name == 'gcc':\n compiler_name = 'mingw32'\n else:\n # don't know how to force gcc -- look into this.\n if compiler_name == 'gcc':\n compiler_name = 'unix' \n return compiler_name\n \ndef gcc_exists():\n \"\"\" Test to make sure gcc is found \n \n Does this return correct value on win98???\n \"\"\"\n result = 0\n try:\n w,r=os.popen4('gcc -v')\n w.close()\n str_result = r.read()\n #print str_result\n if string.find(str_result,'Reading specs') != -1:\n result = 1\n except:\n # This was needed because the msvc compiler messes with\n # the path variable. and will occasionlly mess things up\n # so much that gcc is lost in the path. (Occurs in test\n # scripts)\n result = not os.system('gcc -v')\n return result\n\ndef msvc_exists():\n \"\"\" Determine whether MSVC is available on the machine.\n \"\"\"\n result = 0\n try:\n w,r=os.popen4('cl')\n w.close()\n str_result = r.read()\n #print str_result\n if string.find(str_result,'Microsoft') != -1:\n result = 1\n except:\n #assume we're ok if devstudio exists\n import distutils.msvccompiler\n version = distutils.msvccompiler.get_devstudio_version()\n if version:\n result = 1\n return result\n\ndef configure_temp_dir(temp_dir=None):\n if temp_dir is None: \n temp_dir = tempfile.gettempdir()\n elif not os.path.exists(temp_dir) or not os.access(temp_dir,os.W_OK):\n print \"warning: specified temp_dir '%s' does not exist or is \" \\\n \"or is not writable. Using the default temp directory\" % \\\n temp_dir\n temp_dir = tempfile.gettempdir()\n\n # final check that that directories are writable. \n if not os.access(temp_dir,os.W_OK):\n msg = \"Either the temp or build directory wasn't writable. Check\" \\\n \" these locations: '%s'\" % temp_dir \n raise ValueError, msg\n return temp_dir\n\ndef configure_build_dir(build_dir=None):\n # make sure build_dir exists and is writable\n if build_dir and (not os.path.exists(build_dir) or \n not os.access(build_dir,os.W_OK)):\n print \"warning: specified build_dir '%s' does not exist or is \" \\\n \"or is not writable. Trying default locations\" % build_dir\n build_dir = None\n \n if build_dir is None:\n #default to building in the home directory of the given module. \n build_dir = os.curdir\n # if it doesn't work use the current directory. This should always\n # be writable. \n if not os.access(build_dir,os.W_OK):\n print \"warning:, neither the module's directory nor the \"\\\n \"current directory are writable. Using the temporary\"\\\n \"directory.\"\n build_dir = tempfile.gettempdir()\n\n # final check that that directories are writable.\n if not os.access(build_dir,os.W_OK):\n msg = \"The build directory wasn't writable. Check\" \\\n \" this location: '%s'\" % build_dir\n raise ValueError, msg\n \n return os.path.abspath(build_dir) \n \nif sys.platform == 'win32':\n import distutils.cygwinccompiler\n # the same as cygwin plus some additional parameters\n class Mingw32CCompiler (distutils.cygwinccompiler.CygwinCCompiler):\n \"\"\" A modified MingW32 compiler compatible with an MSVC built Python.\n \n \"\"\"\n \n compiler_type = 'mingw32'\n \n def __init__ (self,\n verbose=0,\n dry_run=0,\n force=0):\n \n distutils.cygwinccompiler.CygwinCCompiler.__init__ (self, verbose, \n dry_run, force)\n \n # A real mingw32 doesn't need to specify a different entry point,\n # but cygwin 2.91.57 in no-cygwin-mode needs it.\n if self.gcc_version <= \"2.91.57\":\n entry_point = '--entry _DllMain@12'\n else:\n entry_point = ''\n if self.linker_dll == 'dllwrap':\n self.linker = 'dllwrap' + ' --driver-name g++'\n elif self.linker_dll == 'gcc':\n self.linker = 'g++' \n # **changes: eric jones 4/11/01\n # 1. Check for import library on Windows. Build if it doesn't exist.\n if not import_library_exists():\n build_import_library()\n \n # **changes: eric jones 4/11/01\n # 2. increased optimization and turned off all warnings\n # 3. also added --driver-name g++\n #self.set_executables(compiler='gcc -mno-cygwin -O2 -w',\n # compiler_so='gcc -mno-cygwin -mdll -O2 -w',\n # linker_exe='gcc -mno-cygwin',\n # linker_so='%s --driver-name g++ -mno-cygwin -mdll -static %s' \n # % (self.linker, entry_point))\n self.set_executables(compiler='g++ -mno-cygwin -O2 -w',\n compiler_so='g++ -mno-cygwin -mdll -O2 -w -Wstrict-prototypes',\n linker_exe='g++ -mno-cygwin',\n linker_so='%s -mno-cygwin -mdll -static %s' \n % (self.linker, entry_point))\n \n # Maybe we should also append -mthreads, but then the finished\n # dlls need another dll (mingwm10.dll see Mingw32 docs)\n # (-mthreads: Support thread-safe exception handling on `Mingw32') \n \n # no additional libraries needed \n self.dll_libraries=[]\n \n # __init__ ()\n \n # On windows platforms, we want to default to mingw32 (gcc)\n # because msvc can't build blitz stuff.\n # We should also check the version of gcc available...\n #distutils.ccompiler._default_compilers['nt'] = 'mingw32'\n #distutils.ccompiler._default_compilers = (('nt', 'mingw32'))\n # reset the Mingw32 compiler in distutils to the one defined above\n distutils.cygwinccompiler.Mingw32CCompiler = Mingw32CCompiler\n \n def import_library_exists():\n \"\"\" on windows platforms, make sure a gcc import library exists\n \"\"\"\n if os.name == 'nt':\n lib_name = \"libpython%d%d.a\" % tuple(sys.version_info[:2])\n full_path = os.path.join(sys.prefix,'libs',lib_name)\n if not os.path.exists(full_path):\n return 0\n return 1\n \n def build_import_library():\n \"\"\" Build the import libraries for Mingw32-gcc on Windows\n \"\"\"\n import lib2def as lib2def\n #libfile, deffile = parse_cmd()\n #if deffile == None:\n # deffile = sys.stdout\n #else:\n # deffile = open(deffile, 'w')\n lib_name = \"python%d%d.lib\" % tuple(sys.version_info[:2]) \n lib_file = os.path.join(sys.prefix,'libs',lib_name)\n def_name = \"python%d%d.def\" % tuple(sys.version_info[:2]) \n def_file = os.path.join(sys.prefix,'libs',def_name)\n nm_cmd = '%s %s' % (lib2def.DEFAULT_NM, lib_file)\n nm_output = lib2def.getnm(nm_cmd)\n dlist, flist = lib2def.parse_nm(nm_output)\n lib2def.output_def(dlist, flist, lib2def.DEF_HEADER, open(def_file, 'w'))\n \n out_name = \"libpython%d%d.a\" % tuple(sys.version_info[:2])\n out_file = os.path.join(sys.prefix,'libs',out_name)\n dll_name = \"python%d%d.dll\" % tuple(sys.version_info[:2])\n args = (dll_name,def_file,out_file)\n cmd = 'dlltool --dllname %s --def %s --output-lib %s' % args\n success = not os.system(cmd)\n # for now, fail silently\n if not success:\n print 'WARNING: failed to build import library for gcc. Linking will fail.'\n #if not success:\n # msg = \"Couldn't find import library, and failed to build it.\"\n # raise DistutilsPlatformError, msg\n \ndef test():\n from scipy_test import module_test\n module_test(__name__,__file__)\n\ndef test_suite():\n from scipy_test import module_test_suite\n return module_test_suite(__name__,__file__) \n\n\n\n",
"methods": [
{
"name": "_init_posix",
"long_name": "_init_posix( )",
"filename": "build_tools.py",
"nloc": 4,
"complexity": 1,
"token_count": 34,
"parameters": [],
"start_line": 30,
"end_line": 33,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 0
},
{
"name": "build_extension",
"long_name": "build_extension( module_path , compiler_name = '' , build_dir = None , temp_dir = None , verbose = 0 , ** kw )",
"filename": "build_tools.py",
"nloc": 49,
"complexity": 9,
"token_count": 364,
"parameters": [
"module_path",
"compiler_name",
"build_dir",
"temp_dir",
"verbose",
"kw"
],
"start_line": 42,
"end_line": 212,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 171,
"top_nesting_level": 0
},
{
"name": "configure_sys_argv",
"long_name": "configure_sys_argv( compiler_name , temp_dir , build_dir )",
"filename": "build_tools.py",
"nloc": 9,
"complexity": 3,
"token_count": 68,
"parameters": [
"compiler_name",
"temp_dir",
"build_dir"
],
"start_line": 215,
"end_line": 225,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 11,
"top_nesting_level": 0
},
{
"name": "restore_sys_argv",
"long_name": "restore_sys_argv( )",
"filename": "build_tools.py",
"nloc": 2,
"complexity": 1,
"token_count": 9,
"parameters": [],
"start_line": 227,
"end_line": 228,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 2,
"top_nesting_level": 0
},
{
"name": "configure_python_path",
"long_name": "configure_python_path( build_dir )",
"filename": "build_tools.py",
"nloc": 4,
"complexity": 3,
"token_count": 51,
"parameters": [
"build_dir"
],
"start_line": 230,
"end_line": 236,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 7,
"top_nesting_level": 0
},
{
"name": "choose_compiler",
"long_name": "choose_compiler( compiler_name = '' )",
"filename": "build_tools.py",
"nloc": 13,
"complexity": 7,
"token_count": 55,
"parameters": [
"compiler_name"
],
"start_line": 238,
"end_line": 259,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 22,
"top_nesting_level": 0
},
{
"name": "gcc_exists",
"long_name": "gcc_exists( )",
"filename": "build_tools.py",
"nloc": 11,
"complexity": 3,
"token_count": 61,
"parameters": [],
"start_line": 261,
"end_line": 280,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 20,
"top_nesting_level": 0
},
{
"name": "msvc_exists",
"long_name": "msvc_exists( )",
"filename": "build_tools.py",
"nloc": 14,
"complexity": 4,
"token_count": 71,
"parameters": [],
"start_line": 282,
"end_line": 299,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 18,
"top_nesting_level": 0
},
{
"name": "configure_temp_dir",
"long_name": "configure_temp_dir( temp_dir = None )",
"filename": "build_tools.py",
"nloc": 13,
"complexity": 5,
"token_count": 82,
"parameters": [
"temp_dir"
],
"start_line": 301,
"end_line": 315,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 15,
"top_nesting_level": 0
},
{
"name": "configure_build_dir",
"long_name": "configure_build_dir( build_dir = None )",
"filename": "build_tools.py",
"nloc": 18,
"complexity": 7,
"token_count": 112,
"parameters": [
"build_dir"
],
"start_line": 317,
"end_line": 342,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 26,
"top_nesting_level": 0
},
{
"name": "__init__",
"long_name": "__init__( self , verbose = 0 , dry_run = 0 , force = 0 )",
"filename": "build_tools.py",
"nloc": 22,
"complexity": 5,
"token_count": 117,
"parameters": [
"self",
"verbose",
"dry_run",
"force"
],
"start_line": 354,
"end_line": 396,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 43,
"top_nesting_level": 2
},
{
"name": "import_library_exists",
"long_name": "import_library_exists( )",
"filename": "build_tools.py",
"nloc": 7,
"complexity": 3,
"token_count": 57,
"parameters": [],
"start_line": 408,
"end_line": 416,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 9,
"top_nesting_level": 1
},
{
"name": "build_import_library",
"long_name": "build_import_library( )",
"filename": "build_tools.py",
"nloc": 18,
"complexity": 2,
"token_count": 190,
"parameters": [],
"start_line": 418,
"end_line": 444,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 27,
"top_nesting_level": 1
},
{
"name": "test",
"long_name": "test( )",
"filename": "build_tools.py",
"nloc": 3,
"complexity": 1,
"token_count": 14,
"parameters": [],
"start_line": 449,
"end_line": 451,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 3,
"top_nesting_level": 0
},
{
"name": "test_suite",
"long_name": "test_suite( )",
"filename": "build_tools.py",
"nloc": 3,
"complexity": 1,
"token_count": 15,
"parameters": [],
"start_line": 453,
"end_line": 455,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 3,
"top_nesting_level": 0
}
],
"methods_before": [
{
"name": "build_extension",
"long_name": "build_extension( module_path , compiler_name = '' , build_dir = None , temp_dir = None , verbose = 0 , ** kw )",
"filename": "build_tools.py",
"nloc": 52,
"complexity": 10,
"token_count": 390,
"parameters": [
"module_path",
"compiler_name",
"build_dir",
"temp_dir",
"verbose",
"kw"
],
"start_line": 27,
"end_line": 194,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 168,
"top_nesting_level": 0
},
{
"name": "configure_sys_argv",
"long_name": "configure_sys_argv( compiler_name , temp_dir , build_dir )",
"filename": "build_tools.py",
"nloc": 9,
"complexity": 3,
"token_count": 68,
"parameters": [
"compiler_name",
"temp_dir",
"build_dir"
],
"start_line": 197,
"end_line": 207,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 11,
"top_nesting_level": 0
},
{
"name": "restore_sys_argv",
"long_name": "restore_sys_argv( )",
"filename": "build_tools.py",
"nloc": 2,
"complexity": 1,
"token_count": 9,
"parameters": [],
"start_line": 209,
"end_line": 210,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 2,
"top_nesting_level": 0
},
{
"name": "configure_python_path",
"long_name": "configure_python_path( build_dir )",
"filename": "build_tools.py",
"nloc": 4,
"complexity": 3,
"token_count": 51,
"parameters": [
"build_dir"
],
"start_line": 212,
"end_line": 218,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 7,
"top_nesting_level": 0
},
{
"name": "choose_compiler",
"long_name": "choose_compiler( compiler_name = '' )",
"filename": "build_tools.py",
"nloc": 13,
"complexity": 7,
"token_count": 55,
"parameters": [
"compiler_name"
],
"start_line": 220,
"end_line": 241,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 22,
"top_nesting_level": 0
},
{
"name": "gcc_exists",
"long_name": "gcc_exists( )",
"filename": "build_tools.py",
"nloc": 11,
"complexity": 3,
"token_count": 61,
"parameters": [],
"start_line": 243,
"end_line": 262,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 20,
"top_nesting_level": 0
},
{
"name": "msvc_exists",
"long_name": "msvc_exists( )",
"filename": "build_tools.py",
"nloc": 14,
"complexity": 4,
"token_count": 71,
"parameters": [],
"start_line": 264,
"end_line": 281,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 18,
"top_nesting_level": 0
},
{
"name": "configure_temp_dir",
"long_name": "configure_temp_dir( temp_dir = None )",
"filename": "build_tools.py",
"nloc": 13,
"complexity": 5,
"token_count": 82,
"parameters": [
"temp_dir"
],
"start_line": 283,
"end_line": 297,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 15,
"top_nesting_level": 0
},
{
"name": "configure_build_dir",
"long_name": "configure_build_dir( build_dir = None )",
"filename": "build_tools.py",
"nloc": 18,
"complexity": 7,
"token_count": 112,
"parameters": [
"build_dir"
],
"start_line": 299,
"end_line": 324,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 26,
"top_nesting_level": 0
},
{
"name": "__init__",
"long_name": "__init__( self , verbose = 0 , dry_run = 0 , force = 0 )",
"filename": "build_tools.py",
"nloc": 22,
"complexity": 5,
"token_count": 117,
"parameters": [
"self",
"verbose",
"dry_run",
"force"
],
"start_line": 336,
"end_line": 378,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 43,
"top_nesting_level": 2
},
{
"name": "import_library_exists",
"long_name": "import_library_exists( )",
"filename": "build_tools.py",
"nloc": 7,
"complexity": 3,
"token_count": 57,
"parameters": [],
"start_line": 390,
"end_line": 398,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 9,
"top_nesting_level": 1
},
{
"name": "build_import_library",
"long_name": "build_import_library( )",
"filename": "build_tools.py",
"nloc": 18,
"complexity": 2,
"token_count": 190,
"parameters": [],
"start_line": 400,
"end_line": 426,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 27,
"top_nesting_level": 1
},
{
"name": "test",
"long_name": "test( )",
"filename": "build_tools.py",
"nloc": 3,
"complexity": 1,
"token_count": 14,
"parameters": [],
"start_line": 431,
"end_line": 433,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 3,
"top_nesting_level": 0
},
{
"name": "test_suite",
"long_name": "test_suite( )",
"filename": "build_tools.py",
"nloc": 3,
"complexity": 1,
"token_count": 15,
"parameters": [],
"start_line": 435,
"end_line": 437,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 3,
"top_nesting_level": 0
}
],
"changed_methods": [
{
"name": "_init_posix",
"long_name": "_init_posix( )",
"filename": "build_tools.py",
"nloc": 4,
"complexity": 1,
"token_count": 34,
"parameters": [],
"start_line": 30,
"end_line": 33,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 4,
"top_nesting_level": 0
},
{
"name": "build_extension",
"long_name": "build_extension( module_path , compiler_name = '' , build_dir = None , temp_dir = None , verbose = 0 , ** kw )",
"filename": "build_tools.py",
"nloc": 49,
"complexity": 9,
"token_count": 364,
"parameters": [
"module_path",
"compiler_name",
"build_dir",
"temp_dir",
"verbose",
"kw"
],
"start_line": 42,
"end_line": 212,
"fan_in": 0,
"fan_out": 0,
"general_fan_out": 0,
"length": 171,
"top_nesting_level": 0
}
],
"nloc": 225,
"complexity": 55,
"token_count": 1391,
"diff_parsed": {
"added": [
"# If linker is 'gcc', this will convert it to 'g++'",
"# necessary to make sure stdc++ is linked in cross-platform way.",
"import distutils.sysconfig",
"",
"old_init_posix = distutils.sysconfig._init_posix",
"",
"def _init_posix():",
" old_init_posix()",
" ld = distutils.sysconfig._config_vars['LDSHARED']",
" distutils.sysconfig._config_vars['LDSHARED'] = ld.replace('gcc','g++')",
"",
"distutils.sysconfig._init_posix = _init_posix",
"# end force g++",
"",
"",
" # ! This was fixed at beginning of file by using g++ on most",
" # !machines. We'll have to check how to handle it on non-gcc machines",
" ## add module to the needed source code files and build extension",
" ## FIX this is g++ specific. It probably should be fixed for other",
" ## Unices/compilers. Find a generic solution",
" #if compiler_name != 'msvc':",
" # libraries = kw.get('libraries',[])",
" # kw['libraries'] = ['stdc++'] + libraries",
" # !"
],
"deleted": [
" # add module to the needed source code files and build extension",
" # FIX this is g++ specific. It probably should be fixed for other",
" # Unices/compilers. Find a generic solution",
" if compiler_name != 'msvc':",
" libraries = kw.get('libraries',[])",
" kw['libraries'] = ['stdc++'] + libraries"
]
}
}
]
},
{
"hash": "79cd95adf1c70d464b266d1fd84e1d98781117b1",
"msg": "Minor changes for better f2py support",
"author": {
"name": "Pearu Peterson",
"email": "pearu.peterson@gmail.com"
},
"committer": {
"name": "Pearu Peterson",
"email": "pearu.peterson@gmail.com"
},
"author_date": "2002-01-16T19:10:10+00:00",
"author_timezone": 0,
"committer_date": "2002-01-16T19:10:10+00:00",
"committer_timezone": 0,
"branches": [
"main"
],
"in_main_branch": true,
"merge": false,
"parents": [
"c9d6cb8e55c5bd9fc27b359e3f87530b1e602288"
],
"project_name": "repo_copy",
"project_path": "/tmp/tmp55a0ktwg/repo_copy",
"deletions": 3,
"insertions": 10,
"lines": 13,
"files": 3,
"dmm_unit_size": 0.0,
"dmm_unit_complexity": 0.0,
"dmm_unit_interfacing": 0.0,
"modified_files": [
{
"old_path": "scipy_distutils/__version__.py",
"new_path": "scipy_distutils/__version__.py",
"filename": "__version__.py",
"extension": "py",
"change_type": "MODIFY",
"diff": "@@ -1,4 +1,4 @@\n # This file is automatically updated with update_version\n # function from scipy_distutils.misc_util.py\n-version = '0.6.23-alpha-90'\n-version_info = (0, 6, 23, 'alpha', 90)\n+version = '0.6.23-alpha-93'\n+version_info = (0, 6, 23, 'alpha', 93)\n",
"added_lines": 2,
"deleted_lines": 2,
"source_code": "# This file is automatically updated with update_version\n# function from scipy_distutils.misc_util.py\nversion = '0.6.23-alpha-93'\nversion_info = (0, 6, 23, 'alpha', 93)\n",
"source_code_before": "# This file is automatically updated with update_version\n# function from scipy_distutils.misc_util.py\nversion = '0.6.23-alpha-90'\nversion_info = (0, 6, 23, 'alpha', 90)\n",
"methods": [],
"methods_before": [],
"changed_methods": [],
"nloc": 2,
"complexity": 0,
"token_count": 16,
"diff_parsed": {
"added": [
"version = '0.6.23-alpha-93'",
"version_info = (0, 6, 23, 'alpha', 93)"
],
"deleted": [
"version = '0.6.23-alpha-90'",
"version_info = (0, 6, 23, 'alpha', 90)"
]
}
},
{
"old_path": "scipy_distutils/command/build_flib.py",
"new_path": "scipy_distutils/command/build_flib.py",
"filename": "build_flib.py",
"extension": "py",
"change_type": "MODIFY",
"diff": "@@ -49,6 +49,11 @@\n from distutils.command.build_clib import build_clib\n from distutils.errors import *\n \n+class FortranCompilerError (CCompilerError):\n+ \"\"\"Some compile/link operation failed.\"\"\"\n+class FortranCompileError (FortranCompilerError):\n+ \"\"\"Failure to compile one or more Fortran source files.\"\"\"\n+\n if os.name == 'nt':\n def run_command(command):\n \"\"\" not sure how to get exit status on nt. \"\"\"\n@@ -286,7 +291,7 @@ def f_compile(self,compiler,switches, source_files,\n print cmd\n failure = os.system(cmd)\n if failure:\n- raise ValueError, 'failure during compile' \n+ raise FortranCompileError, 'failure during compile' \n object_files.append(object)\n return object_files\n #return all object files to make sure everything is archived \n",
"added_lines": 6,
"deleted_lines": 1,
"source_code": "\"\"\" Implements the build_flib command which should go into Distutils\n at some point.\n \n Note:\n Right now, we're dynamically linking to the Fortran libraries on \n some platforms (Sun for sure). This is fine for local installations\n but a bad thing for redistribution because these libraries won't\n live on any machine that doesn't have a fortran compiler installed.\n It is pretty hard (impossible?) to get gcc to pass the right compiler\n flags on Sun to get the linker to use static libs for the fortran\n stuff. Investigate further...\n\nBugs:\n *** Options -e and -x have no effect when used with --help-compiler\n options. E.g. \n ./setup.py build_flib --help-compiler -e g77-3.0\n finds g77-2.95.\n How to extract these options inside the show_compilers function?\n *** compiler.is_available() method may not work correctly on nt\n because of lack of knowledge how to get exit status in\n run_command function. However, it may give reasonable results\n based on a version string.\n *** Some vendors provide different compilers for F77 and F90\n compilations. Currently, checking the availability of these\n compilers is based on only checking the availability of the\n corresponding F77 compiler. If it exists, then F90 is assumed\n to exist also.\n\nOpen issues:\n *** User-defined compiler flags. Do we need --fflags?\n\nFortran compilers (as to be used with --fcompiler= option):\n Absoft\n Sun\n SGI\n Intel\n Itanium\n NAG\n Compaq\n Gnu\n VAST\n\"\"\"\n\nimport distutils\nimport distutils.dep_util, distutils.dir_util\nimport os,sys,string\nimport commands,re\nfrom types import *\nfrom distutils.command.build_clib import build_clib\nfrom distutils.errors import *\n\nclass FortranCompilerError (CCompilerError):\n \"\"\"Some compile/link operation failed.\"\"\"\nclass FortranCompileError (FortranCompilerError):\n \"\"\"Failure to compile one or more Fortran source files.\"\"\"\n\nif os.name == 'nt':\n def run_command(command):\n \"\"\" not sure how to get exit status on nt. \"\"\"\n in_pipe,out_pipe = os.popen4(command)\n in_pipe.close()\n text = out_pipe.read()\n return 0, text\nelse:\n run_command = commands.getstatusoutput\n \ndef show_compilers():\n for compiler_class in all_compilers:\n compiler = compiler_class()\n if compiler.is_available():\n print compiler\n\nclass build_flib (build_clib):\n\n description = \"build f77/f90 libraries used by Python extensions\"\n\n user_options = [\n ('build-flib', 'b',\n \"directory to build f77/f90 libraries to\"),\n ('build-temp', 't',\n \"directory to put temporary build by-products\"),\n ('debug', 'g',\n \"compile with debugging information\"),\n ('force', 'f',\n \"forcibly build everything (ignore file timestamps)\"),\n ('fcompiler=', 'c',\n \"specify the compiler type\"),\n ('fcompiler-exec=', 'e',\n \"specify the path to F77 compiler\"),\n ('f90compiler-exec=', 'x',\n \"specify the path to F90 compiler\"),\n ]\n\n boolean_options = ['debug', 'force']\n\n help_options = [\n ('help-compiler', None,\n \"list available compilers\", show_compilers),\n ]\n\n def initialize_options (self):\n\n self.build_flib = None\n self.build_temp = None\n\n self.fortran_libraries = None\n self.define = None\n self.undef = None\n self.debug = None\n self.force = 0\n self.fcompiler = None\n self.fcompiler_exec = None\n self.f90compiler_exec = None\n\n # initialize_options()\n\n def finalize_options (self):\n self.set_undefined_options('build',\n ('build_temp', 'build_flib'),\n ('build_temp', 'build_temp'),\n ('debug', 'debug'),\n ('force', 'force'))\n fc = find_fortran_compiler(self.fcompiler,\n self.fcompiler_exec,\n self.f90compiler_exec)\n if not fc:\n raise DistutilsOptionError, 'Fortran compiler not available: %s'%(self.fcompiler)\n else:\n self.announce(' using %s Fortran compiler' % fc)\n self.fcompiler = fc\n if self.has_f_libraries():\n self.fortran_libraries = self.distribution.fortran_libraries\n self.check_library_list(self.fortran_libraries)\n\n # finalize_options()\n\n def has_f_libraries(self):\n return self.distribution.fortran_libraries \\\n and len(self.distribution.fortran_libraries) > 0\n\n def run (self):\n if not self.has_f_libraries():\n return\n self.build_libraries(self.fortran_libraries)\n\n # run ()\n\n def get_library_names(self):\n if not self.has_f_libraries():\n return None\n\n lib_names = [] \n\n for (lib_name, build_info) in self.fortran_libraries:\n lib_names.append(lib_name)\n\n if self.fcompiler is not None:\n lib_names.extend(self.fcompiler.get_libraries())\n \n return lib_names\n\n # get_library_names ()\n\n def get_library_dirs(self):\n if not self.has_f_libraries():\n return []#None\n\n lib_dirs = [] \n\n if self.fcompiler is not None:\n lib_dirs.extend(self.fcompiler.get_library_dirs())\n \n return lib_dirs\n\n # get_library_dirs ()\n\n def get_runtime_library_dirs(self):\n if not self.has_f_libraries():\n return []#None\n\n lib_dirs = [] \n\n if self.fcompiler is not None:\n lib_dirs.extend(self.fcompiler.get_runtime_library_dirs())\n \n return lib_dirs\n\n # get_library_dirs ()\n\n def get_source_files (self):\n self.check_library_list(self.fortran_libraries)\n filenames = []\n\n # Gets source files specified \n for ext in self.fortran_libraries:\n filenames.extend(ext[1]['sources'])\n\n return filenames \n \n def build_libraries (self, fortran_libraries):\n \n fcompiler = self.fcompiler\n \n for (lib_name, build_info) in fortran_libraries:\n sources = build_info.get('sources')\n if sources is None or type(sources) not in (ListType, TupleType):\n raise DistutilsSetupError, \\\n (\"in 'fortran_libraries' option (library '%s'), \" +\n \"'sources' must be present and must be \" +\n \"a list of source filenames\") % lib_name\n sources = list(sources)\n module_dirs = build_info.get('module_dirs')\n module_files = build_info.get('module_files')\n self.announce(\" building '%s' library\" % lib_name)\n \n if module_files:\n fcompiler.build_library(lib_name, module_files,\n temp_dir=self.build_temp)\n \n fcompiler.build_library(lib_name, sources,\n module_dirs, temp_dir=self.build_temp)\n\n # for loop\n\n # build_libraries ()\n\n\nclass fortran_compiler_base:\n\n vendor = None\n ver_match = None\n \n def __init__(self):\n # Default initialization. Constructors of derived classes MUST\n # call this functions.\n self.version = None\n \n self.f77_switches = ''\n self.f77_opt = ''\n self.f77_debug = ''\n \n self.f90_switches = ''\n self.f90_opt = ''\n self.f90_debug = ''\n \n self.libraries = []\n self.library_dirs = []\n\n if self.vendor is None:\n raise DistutilsInternalError,\\\n '%s must define vendor attribute'%(self.__class__)\n if self.ver_match is None:\n raise DistutilsInternalError,\\\n '%s must define ver_match attribute'%(self.__class__)\n\n def to_object(self,dirty_files,module_dirs=None, temp_dir=''):\n files = string.join(dirty_files)\n f90_files = get_f90_files(dirty_files)\n f77_files = get_f77_files(dirty_files)\n if f90_files != []:\n obj1 = self.f90_compile(f90_files,module_dirs,temp_dir = temp_dir)\n else:\n obj1 = []\n if f77_files != []:\n obj2 = self.f77_compile(f77_files, temp_dir = temp_dir)\n else:\n obj2 = []\n return obj1 + obj2\n\n def source_to_object_names(self,source_files, temp_dir=''):\n file_list = map(lambda x: os.path.basename(x),source_files)\n file_base_ext = map(lambda x: os.path.splitext(x),file_list)\n object_list = map(lambda x: x[0] +'.o',file_base_ext)\n object_files = map(lambda x,td=temp_dir: os.path.join(td,x),object_list)\n return object_files\n \n def source_and_object_pairs(self,source_files, temp_dir=''):\n object_files = self.source_to_object_names(source_files,temp_dir)\n file_pairs = zip(source_files,object_files)\n return file_pairs\n \n def f_compile(self,compiler,switches, source_files,\n module_dirs=None, temp_dir=''):\n module_switch = self.build_module_switch(module_dirs)\n file_pairs = self.source_and_object_pairs(source_files,temp_dir)\n object_files = []\n for source,object in file_pairs:\n if distutils.dep_util.newer(source,object):\n cmd = compiler + ' ' + switches + \\\n module_switch + ' -c ' + source + ' -o ' + object \n print cmd\n failure = os.system(cmd)\n if failure:\n raise FortranCompileError, 'failure during compile' \n object_files.append(object)\n return object_files\n #return all object files to make sure everything is archived \n #return map(lambda x: x[1], file_pairs)\n\n def f90_compile(self,source_files,module_dirs=None, temp_dir=''):\n switches = string.join((self.f90_switches, self.f90_opt))\n return self.f_compile(self.f90_compiler,switches,\n source_files, module_dirs,temp_dir)\n\n def f77_compile(self,source_files,module_dirs=None, temp_dir=''):\n switches = string.join((self.f77_switches, self.f77_opt))\n return self.f_compile(self.f77_compiler,switches,\n source_files, module_dirs,temp_dir)\n\n\n def build_module_switch(self, module_dirs):\n return ''\n\n def create_static_lib(self, object_files, library_name,\n output_dir='', debug=None):\n lib_file = os.path.join(output_dir,'lib'+library_name+'.a')\n newer = distutils.dep_util.newer\n # This doesn't work -- no way to know if the file is in the archive\n #object_files = filter(lambda o,lib=lib_file:\\\n # distutils.dep_util.newer(o,lib),object_files)\n objects = string.join(object_files)\n if objects:\n cmd = 'ar -cur %s %s' % (lib_file,objects)\n print cmd\n os.system(cmd)\n\n def build_library(self,library_name,source_list,module_dirs=None,\n temp_dir = ''):\n #make sure the temp directory exists before trying to build files\n import distutils.dir_util\n distutils.dir_util.mkpath(temp_dir)\n #this compiles the files\n object_list = self.to_object(source_list,module_dirs,temp_dir)\n # actually we need to use all the object file names here to\n # make sure the library is always built. It could occur that an\n # object file exists but hasn't been put in the archive. (happens\n # a lot when builds fail once and are restarted).\n object_list = self.source_to_object_names(source_list, temp_dir)\n #self.create_static_lib(object_list,library_name,temp_dir) \n # This is pure bunk...\n # Windows fails for long argument strings on the command line.\n # if objects is real long (> 2048 chars or so on my machine),\n # the command fails (cmd.exe /e:2048 on w2k)\n # for now we'll split linking into to steps which should work for\n objects = object_list[:]\n while objects:\n obj,objects = objects[:20],objects[20:]\n self.create_static_lib(obj,library_name,temp_dir)\n\n def dummy_fortran_files(self):\n import tempfile \n d = tempfile.gettempdir()\n dummy_name = os.path.join(d,'__dummy.f')\n dummy = open(dummy_name,'w')\n dummy.write(\" subroutine dummy()\\n end\\n\")\n dummy.close()\n return (os.path.join(d,'__dummy.f'),os.path.join(d,'__dummy.o'))\n \n def is_available(self):\n return self.get_version()\n \n def get_version(self):\n \"\"\"Return the compiler version. If compiler is not available,\n return empty string.\"\"\"\n # XXX: Is there compilers that have no version? If yes,\n # this test will fail even if the compiler is available.\n if self.version is not None:\n # Finding version is expensive, so return previously found\n # version string.\n return self.version\n self.version = ''\n # works I think only for unix... \n #print 'command:', self.ver_cmd\n exit_status, out_text = run_command(self.ver_cmd)\n #print exit_status, out_text\n if not exit_status:\n m = re.match(self.ver_match,out_text)\n if m:\n self.version = m.group('version')\n return self.version\n\n def get_libraries(self):\n return self.libraries\n def get_library_dirs(self):\n return self.library_dirs\n def get_extra_link_args(self):\n return []\n def get_runtime_library_dirs(self):\n return []\n def get_linker_so(self):\n \"\"\"\n If a compiler requires specific linker then return a list\n containing a linker executable name and linker options.\n Otherwise, return None.\n \"\"\"\n\n def __str__(self):\n return \"%s %s\" % (self.vendor, self.get_version())\n\n\nclass absoft_fortran_compiler(fortran_compiler_base):\n\n vendor = 'Absoft'\n ver_match = r'FORTRAN 77 Compiler (?P