From 25be33dcd479870fa444fe33403b9bc55086decc Mon Sep 17 00:00:00 2001 From: Stefan Zager Date: Wed, 9 Feb 2011 07:31:08 +0000 Subject: [PATCH] A collection of performance tests. The variants we're most interested in are: - swig run without any special parameters - swig run with -O - swig run with -builtin git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/branches/szager-python-builtin@12444 626c5289-ae23-0410-ae9c-e8d60b6d4f22 --- Examples/python/performance/Makefile | 40 ++++ .../python/performance/constructor/Makefile | 21 ++ .../python/performance/constructor/Simple.i | 8 + .../constructor/Simple_baseline.py | 86 ++++++++ .../performance/constructor/Simple_builtin.py | 81 +++++++ .../constructor/Simple_optimized.py | 93 ++++++++ .../python/performance/constructor/runme.py | 17 ++ .../performance/constructor/runme_baseline.py | 11 + .../performance/constructor/runme_builtin.py | 11 + .../constructor/runme_optimized.py | 11 + .../performance/deep_hierarchy/Makefile | 23 ++ .../performance/deep_hierarchy/Simple.i | 52 +++++ .../deep_hierarchy/Simple_baseline.py | 205 ++++++++++++++++++ .../deep_hierarchy/Simple_builtin.py | 88 ++++++++ .../deep_hierarchy/Simple_optimized.py | 156 +++++++++++++ .../performance/deep_hierarchy/runme.py | 17 ++ .../deep_hierarchy/runme_baseline.py | 11 + .../deep_hierarchy/runme_builtin.py | 11 + .../deep_hierarchy/runme_optimized.py | 11 + Examples/python/performance/func/Makefile | 23 ++ Examples/python/performance/func/Simple.i | 8 + .../performance/func/Simple_baseline.py | 86 ++++++++ .../python/performance/func/Simple_builtin.py | 81 +++++++ .../performance/func/Simple_optimized.py | 93 ++++++++ Examples/python/performance/func/runme.py | 17 ++ .../python/performance/func/runme_baseline.py | 11 + .../python/performance/func/runme_builtin.py | 11 + .../performance/func/runme_optimized.py | 11 + 28 files changed, 1294 insertions(+) create mode 100644 Examples/python/performance/Makefile create mode 100644 Examples/python/performance/constructor/Makefile create mode 100644 Examples/python/performance/constructor/Simple.i create mode 100644 Examples/python/performance/constructor/Simple_baseline.py create mode 100644 Examples/python/performance/constructor/Simple_builtin.py create mode 100644 Examples/python/performance/constructor/Simple_optimized.py create mode 100644 Examples/python/performance/constructor/runme.py create mode 100644 Examples/python/performance/constructor/runme_baseline.py create mode 100644 Examples/python/performance/constructor/runme_builtin.py create mode 100644 Examples/python/performance/constructor/runme_optimized.py create mode 100644 Examples/python/performance/deep_hierarchy/Makefile create mode 100644 Examples/python/performance/deep_hierarchy/Simple.i create mode 100644 Examples/python/performance/deep_hierarchy/Simple_baseline.py create mode 100644 Examples/python/performance/deep_hierarchy/Simple_builtin.py create mode 100644 Examples/python/performance/deep_hierarchy/Simple_optimized.py create mode 100644 Examples/python/performance/deep_hierarchy/runme.py create mode 100644 Examples/python/performance/deep_hierarchy/runme_baseline.py create mode 100644 Examples/python/performance/deep_hierarchy/runme_builtin.py create mode 100644 Examples/python/performance/deep_hierarchy/runme_optimized.py create mode 100644 Examples/python/performance/func/Makefile create mode 100644 Examples/python/performance/func/Simple.i create mode 100644 Examples/python/performance/func/Simple_baseline.py create mode 100644 Examples/python/performance/func/Simple_builtin.py create mode 100644 Examples/python/performance/func/Simple_optimized.py create mode 100644 Examples/python/performance/func/runme.py create mode 100644 Examples/python/performance/func/runme_baseline.py create mode 100644 Examples/python/performance/func/runme_builtin.py create mode 100644 Examples/python/performance/func/runme_optimized.py diff --git a/Examples/python/performance/Makefile b/Examples/python/performance/Makefile new file mode 100644 index 000000000..c1b4a69c6 --- /dev/null +++ b/Examples/python/performance/Makefile @@ -0,0 +1,40 @@ +ifeq (,$(PY3)) + PYTHON_INCLUDE= $(DEFS) -I/usr/include/python2.6 -I/usr/lib/python2.6/config + PYTHON_LIB = + PYTHON = python + PYSCRIPT = runme.py +else + PYTHON_INCLUDE= $(DEFS) -I/home/szager/include/python3.1 + PYTHON_LIB = + PYTHON = python3 + PYSCRIPT = runme3.py +endif + +SUBDIRS := constructor func deep_hierarchy + +default : all + +.PHONY : $(SUBDIRS) all clean + +all : $(SUBDIRS) + @for subdir in $(SUBDIRS); do \ + echo Running $$subdir test... ; \ + echo -------------------------------------------------------------------------------- ; \ + cd $$subdir; \ + env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PYTHONPATH=$(srcdir):$$PYTHONPATH $(PYTHON) $(PYSCRIPT); \ + cd ..; \ + done + +$(SUBDIRS) : + $(MAKE) -C $@ + @echo Running $$subdir test... + @echo -------------------------------------------------------------------------------- + cd $@ && env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PYTHONPATH=$(srcdir):$$PYTHONPATH $(PYTHON) $(PYSCRIPT) + +%-clean : + $(MAKE) -s -C $* clean + +$(SUBDIRS:%=%-check) : + $(MAKE) -C $* check + +clean : $(SUBDIRS:%=%-clean) diff --git a/Examples/python/performance/constructor/Makefile b/Examples/python/performance/constructor/Makefile new file mode 100644 index 000000000..48449875c --- /dev/null +++ b/Examples/python/performance/constructor/Makefile @@ -0,0 +1,21 @@ +TOP = ../../.. +SWIG = $(TOP)/../preinst-swig +CXXSRCS = +TARGET = Simple +INTERFACE = Simple.i + +all : + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -module Simple_baseline' \ + TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -O -module Simple_optimized' \ + TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -builtin -O -module Simple_builtin' \ + TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp + +static : + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \ + TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static + +clean : + $(MAKE) -f $(TOP)/Makefile python_clean + rm -f $(TARGET).py diff --git a/Examples/python/performance/constructor/Simple.i b/Examples/python/performance/constructor/Simple.i new file mode 100644 index 000000000..d642d15bf --- /dev/null +++ b/Examples/python/performance/constructor/Simple.i @@ -0,0 +1,8 @@ +%inline %{ +class MyClass { +public: + MyClass () {} + ~MyClass () {} + void func () {} +}; +%} diff --git a/Examples/python/performance/constructor/Simple_baseline.py b/Examples/python/performance/constructor/Simple_baseline.py new file mode 100644 index 000000000..7e401b403 --- /dev/null +++ b/Examples/python/performance/constructor/Simple_baseline.py @@ -0,0 +1,86 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 2.0.2 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. +# This file is compatible with both classic and new-style classes. + +from sys import version_info +if version_info >= (2,6,0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_Simple_baseline', [dirname(__file__)]) + except ImportError: + import _Simple_baseline + return _Simple_baseline + if fp is not None: + try: + _mod = imp.load_module('_Simple_baseline', fp, pathname, description) + finally: + fp.close() + return _mod + _Simple_baseline = swig_import_helper() + del swig_import_helper +else: + import _Simple_baseline +del version_info +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError(name) + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 + + +class MyClass(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, MyClass, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, MyClass, name) + __repr__ = _swig_repr + def __init__(self): + this = _Simple_baseline.new_MyClass() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Simple_baseline.delete_MyClass + __del__ = lambda self : None; + def func(self): return _Simple_baseline.MyClass_func(self) +MyClass_swigregister = _Simple_baseline.MyClass_swigregister +MyClass_swigregister(MyClass) + + + diff --git a/Examples/python/performance/constructor/Simple_builtin.py b/Examples/python/performance/constructor/Simple_builtin.py new file mode 100644 index 000000000..4ecd8a63e --- /dev/null +++ b/Examples/python/performance/constructor/Simple_builtin.py @@ -0,0 +1,81 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 2.0.2 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info +if version_info >= (2,6,0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_Simple_builtin', [dirname(__file__)]) + except ImportError: + import _Simple_builtin + return _Simple_builtin + if fp is not None: + try: + _mod = imp.load_module('_Simple_builtin', fp, pathname, description) + finally: + fp.close() + return _mod + _Simple_builtin = swig_import_helper() + del swig_import_helper +else: + import _Simple_builtin +del version_info +from _Simple_builtin import * +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError(name) + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 + + +def _swig_setattr_nondynamic_method(set): + def set_attr(self,name,value): + if (name == "thisown"): return self.this.own(value) + if hasattr(self,name) or (name == "this"): + set(self,name,value) + else: + raise AttributeError("You cannot add attributes to %s" % self) + return set_attr + + + + + diff --git a/Examples/python/performance/constructor/Simple_optimized.py b/Examples/python/performance/constructor/Simple_optimized.py new file mode 100644 index 000000000..0bf42ced3 --- /dev/null +++ b/Examples/python/performance/constructor/Simple_optimized.py @@ -0,0 +1,93 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 2.0.2 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info +if version_info >= (3,0,0): + new_instancemethod = lambda func, inst, cls: _Simple_optimized.SWIG_PyInstanceMethod_New(func) +else: + from new import instancemethod as new_instancemethod +if version_info >= (2,6,0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_Simple_optimized', [dirname(__file__)]) + except ImportError: + import _Simple_optimized + return _Simple_optimized + if fp is not None: + try: + _mod = imp.load_module('_Simple_optimized', fp, pathname, description) + finally: + fp.close() + return _mod + _Simple_optimized = swig_import_helper() + del swig_import_helper +else: + import _Simple_optimized +del version_info +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError(name) + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 + + +def _swig_setattr_nondynamic_method(set): + def set_attr(self,name,value): + if (name == "thisown"): return self.this.own(value) + if hasattr(self,name) or (name == "this"): + set(self,name,value) + else: + raise AttributeError("You cannot add attributes to %s" % self) + return set_attr + + +class MyClass(object): + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + _Simple_optimized.MyClass_swiginit(self,_Simple_optimized.new_MyClass()) + __swig_destroy__ = _Simple_optimized.delete_MyClass +MyClass.func = new_instancemethod(_Simple_optimized.MyClass_func,None,MyClass) +MyClass_swigregister = _Simple_optimized.MyClass_swigregister +MyClass_swigregister(MyClass) + + + diff --git a/Examples/python/performance/constructor/runme.py b/Examples/python/performance/constructor/runme.py new file mode 100644 index 000000000..7e50aff16 --- /dev/null +++ b/Examples/python/performance/constructor/runme.py @@ -0,0 +1,17 @@ +#!/usr/bin/env + +import sys +from subprocess import * + +proc = Popen([sys.executable, 'runme_baseline.py'], stdout=PIPE) +(stdout, stderr) = proc.communicate() +print stdout + +proc = Popen([sys.executable, 'runme_optimized.py'], stdout=PIPE) +(stdout, stderr) = proc.communicate() +print stdout + +proc = Popen([sys.executable, 'runme_builtin.py'], stdout=PIPE) +(stdout, stderr) = proc.communicate() +print stdout + diff --git a/Examples/python/performance/constructor/runme_baseline.py b/Examples/python/performance/constructor/runme_baseline.py new file mode 100644 index 000000000..0eb284ccc --- /dev/null +++ b/Examples/python/performance/constructor/runme_baseline.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +import Simple_baseline +import time + +t1 = time.clock() +for i in range(1000000) : + x = Simple_baseline.MyClass() + #x.func() +t2 = time.clock() +print "Simple_baseline took %f seconds" % (t2 - t1) diff --git a/Examples/python/performance/constructor/runme_builtin.py b/Examples/python/performance/constructor/runme_builtin.py new file mode 100644 index 000000000..47ce37864 --- /dev/null +++ b/Examples/python/performance/constructor/runme_builtin.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +import Simple_builtin +import time + +t1 = time.clock() +for i in range(1000000) : + x = Simple_builtin.MyClass() + #x.func() +t2 = time.clock() +print "Simple_builtin took %f seconds" % (t2 - t1) diff --git a/Examples/python/performance/constructor/runme_optimized.py b/Examples/python/performance/constructor/runme_optimized.py new file mode 100644 index 000000000..0c0ed220f --- /dev/null +++ b/Examples/python/performance/constructor/runme_optimized.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +import Simple_optimized +import time + +t1 = time.clock() +for i in range(1000000) : + x = Simple_optimized.MyClass() + #x.func() +t2 = time.clock() +print "Simple_optimized took %f seconds" % (t2 - t1) diff --git a/Examples/python/performance/deep_hierarchy/Makefile b/Examples/python/performance/deep_hierarchy/Makefile new file mode 100644 index 000000000..0df09d908 --- /dev/null +++ b/Examples/python/performance/deep_hierarchy/Makefile @@ -0,0 +1,23 @@ +TOP = ../../.. +SWIG = $(TOP)/../preinst-swig +CXXSRCS = +TARGET = Simple +INTERFACE = Simple.i + +default : all + +all : + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -module Simple_baseline' \ + TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -O -module Simple_optimized' \ + TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -builtin -O -module Simple_builtin' \ + TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp + +static : + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \ + TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static + +clean : + $(MAKE) -f $(TOP)/Makefile python_clean + rm -f $(TARGET).py diff --git a/Examples/python/performance/deep_hierarchy/Simple.i b/Examples/python/performance/deep_hierarchy/Simple.i new file mode 100644 index 000000000..b4f43ec3e --- /dev/null +++ b/Examples/python/performance/deep_hierarchy/Simple.i @@ -0,0 +1,52 @@ +%inline %{ + +class A { +public: + A () {} + ~A () {} + void func () {} +}; + +class B : public A { +public: + B () {} + ~B () {} +}; + +class C : public B { +public: + C () {} + ~C () {} +}; + +class D : public C { +public: + D () {} + ~D () {} +}; + +class E : public D { +public: + E () {} + ~E () {} +}; + +class F : public E { +public: + F () {} + ~F () {} +}; + +class G : public F { +public: + G () {} + ~G () {} +}; + +class H : public G { +public: + H () {} + ~H () {} +}; + +%} diff --git a/Examples/python/performance/deep_hierarchy/Simple_baseline.py b/Examples/python/performance/deep_hierarchy/Simple_baseline.py new file mode 100644 index 000000000..ed91fd14d --- /dev/null +++ b/Examples/python/performance/deep_hierarchy/Simple_baseline.py @@ -0,0 +1,205 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 2.0.2 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. +# This file is compatible with both classic and new-style classes. + +from sys import version_info +if version_info >= (2,6,0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_Simple_baseline', [dirname(__file__)]) + except ImportError: + import _Simple_baseline + return _Simple_baseline + if fp is not None: + try: + _mod = imp.load_module('_Simple_baseline', fp, pathname, description) + finally: + fp.close() + return _mod + _Simple_baseline = swig_import_helper() + del swig_import_helper +else: + import _Simple_baseline +del version_info +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError(name) + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 + + +class A(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, A, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, A, name) + __repr__ = _swig_repr + def __init__(self): + this = _Simple_baseline.new_A() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Simple_baseline.delete_A + __del__ = lambda self : None; + def func(self): return _Simple_baseline.A_func(self) +A_swigregister = _Simple_baseline.A_swigregister +A_swigregister(A) + +class B(A): + __swig_setmethods__ = {} + for _s in [A]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + __setattr__ = lambda self, name, value: _swig_setattr(self, B, name, value) + __swig_getmethods__ = {} + for _s in [A]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + __getattr__ = lambda self, name: _swig_getattr(self, B, name) + __repr__ = _swig_repr + def __init__(self): + this = _Simple_baseline.new_B() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Simple_baseline.delete_B + __del__ = lambda self : None; +B_swigregister = _Simple_baseline.B_swigregister +B_swigregister(B) + +class C(B): + __swig_setmethods__ = {} + for _s in [B]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + __setattr__ = lambda self, name, value: _swig_setattr(self, C, name, value) + __swig_getmethods__ = {} + for _s in [B]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + __getattr__ = lambda self, name: _swig_getattr(self, C, name) + __repr__ = _swig_repr + def __init__(self): + this = _Simple_baseline.new_C() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Simple_baseline.delete_C + __del__ = lambda self : None; +C_swigregister = _Simple_baseline.C_swigregister +C_swigregister(C) + +class D(C): + __swig_setmethods__ = {} + for _s in [C]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + __setattr__ = lambda self, name, value: _swig_setattr(self, D, name, value) + __swig_getmethods__ = {} + for _s in [C]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + __getattr__ = lambda self, name: _swig_getattr(self, D, name) + __repr__ = _swig_repr + def __init__(self): + this = _Simple_baseline.new_D() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Simple_baseline.delete_D + __del__ = lambda self : None; +D_swigregister = _Simple_baseline.D_swigregister +D_swigregister(D) + +class E(D): + __swig_setmethods__ = {} + for _s in [D]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + __setattr__ = lambda self, name, value: _swig_setattr(self, E, name, value) + __swig_getmethods__ = {} + for _s in [D]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + __getattr__ = lambda self, name: _swig_getattr(self, E, name) + __repr__ = _swig_repr + def __init__(self): + this = _Simple_baseline.new_E() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Simple_baseline.delete_E + __del__ = lambda self : None; +E_swigregister = _Simple_baseline.E_swigregister +E_swigregister(E) + +class F(E): + __swig_setmethods__ = {} + for _s in [E]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + __setattr__ = lambda self, name, value: _swig_setattr(self, F, name, value) + __swig_getmethods__ = {} + for _s in [E]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + __getattr__ = lambda self, name: _swig_getattr(self, F, name) + __repr__ = _swig_repr + def __init__(self): + this = _Simple_baseline.new_F() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Simple_baseline.delete_F + __del__ = lambda self : None; +F_swigregister = _Simple_baseline.F_swigregister +F_swigregister(F) + +class G(F): + __swig_setmethods__ = {} + for _s in [F]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + __setattr__ = lambda self, name, value: _swig_setattr(self, G, name, value) + __swig_getmethods__ = {} + for _s in [F]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + __getattr__ = lambda self, name: _swig_getattr(self, G, name) + __repr__ = _swig_repr + def __init__(self): + this = _Simple_baseline.new_G() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Simple_baseline.delete_G + __del__ = lambda self : None; +G_swigregister = _Simple_baseline.G_swigregister +G_swigregister(G) + +class H(G): + __swig_setmethods__ = {} + for _s in [G]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + __setattr__ = lambda self, name, value: _swig_setattr(self, H, name, value) + __swig_getmethods__ = {} + for _s in [G]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + __getattr__ = lambda self, name: _swig_getattr(self, H, name) + __repr__ = _swig_repr + def __init__(self): + this = _Simple_baseline.new_H() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Simple_baseline.delete_H + __del__ = lambda self : None; +H_swigregister = _Simple_baseline.H_swigregister +H_swigregister(H) + + + diff --git a/Examples/python/performance/deep_hierarchy/Simple_builtin.py b/Examples/python/performance/deep_hierarchy/Simple_builtin.py new file mode 100644 index 000000000..6572f16bc --- /dev/null +++ b/Examples/python/performance/deep_hierarchy/Simple_builtin.py @@ -0,0 +1,88 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 2.0.2 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info +if version_info >= (2,6,0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_Simple_builtin', [dirname(__file__)]) + except ImportError: + import _Simple_builtin + return _Simple_builtin + if fp is not None: + try: + _mod = imp.load_module('_Simple_builtin', fp, pathname, description) + finally: + fp.close() + return _mod + _Simple_builtin = swig_import_helper() + del swig_import_helper +else: + import _Simple_builtin +del version_info +from _Simple_builtin import * +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError(name) + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 + + +def _swig_setattr_nondynamic_method(set): + def set_attr(self,name,value): + if (name == "thisown"): return self.this.own(value) + if hasattr(self,name) or (name == "this"): + set(self,name,value) + else: + raise AttributeError("You cannot add attributes to %s" % self) + return set_attr + + + + + + + + + + + + diff --git a/Examples/python/performance/deep_hierarchy/Simple_optimized.py b/Examples/python/performance/deep_hierarchy/Simple_optimized.py new file mode 100644 index 000000000..3cfcda3b1 --- /dev/null +++ b/Examples/python/performance/deep_hierarchy/Simple_optimized.py @@ -0,0 +1,156 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 2.0.2 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info +if version_info >= (3,0,0): + new_instancemethod = lambda func, inst, cls: _Simple_optimized.SWIG_PyInstanceMethod_New(func) +else: + from new import instancemethod as new_instancemethod +if version_info >= (2,6,0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_Simple_optimized', [dirname(__file__)]) + except ImportError: + import _Simple_optimized + return _Simple_optimized + if fp is not None: + try: + _mod = imp.load_module('_Simple_optimized', fp, pathname, description) + finally: + fp.close() + return _mod + _Simple_optimized = swig_import_helper() + del swig_import_helper +else: + import _Simple_optimized +del version_info +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError(name) + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 + + +def _swig_setattr_nondynamic_method(set): + def set_attr(self,name,value): + if (name == "thisown"): return self.this.own(value) + if hasattr(self,name) or (name == "this"): + set(self,name,value) + else: + raise AttributeError("You cannot add attributes to %s" % self) + return set_attr + + +class A(object): + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + _Simple_optimized.A_swiginit(self,_Simple_optimized.new_A()) + __swig_destroy__ = _Simple_optimized.delete_A +A.func = new_instancemethod(_Simple_optimized.A_func,None,A) +A_swigregister = _Simple_optimized.A_swigregister +A_swigregister(A) + +class B(A): + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + _Simple_optimized.B_swiginit(self,_Simple_optimized.new_B()) + __swig_destroy__ = _Simple_optimized.delete_B +B_swigregister = _Simple_optimized.B_swigregister +B_swigregister(B) + +class C(B): + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + _Simple_optimized.C_swiginit(self,_Simple_optimized.new_C()) + __swig_destroy__ = _Simple_optimized.delete_C +C_swigregister = _Simple_optimized.C_swigregister +C_swigregister(C) + +class D(C): + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + _Simple_optimized.D_swiginit(self,_Simple_optimized.new_D()) + __swig_destroy__ = _Simple_optimized.delete_D +D_swigregister = _Simple_optimized.D_swigregister +D_swigregister(D) + +class E(D): + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + _Simple_optimized.E_swiginit(self,_Simple_optimized.new_E()) + __swig_destroy__ = _Simple_optimized.delete_E +E_swigregister = _Simple_optimized.E_swigregister +E_swigregister(E) + +class F(E): + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + _Simple_optimized.F_swiginit(self,_Simple_optimized.new_F()) + __swig_destroy__ = _Simple_optimized.delete_F +F_swigregister = _Simple_optimized.F_swigregister +F_swigregister(F) + +class G(F): + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + _Simple_optimized.G_swiginit(self,_Simple_optimized.new_G()) + __swig_destroy__ = _Simple_optimized.delete_G +G_swigregister = _Simple_optimized.G_swigregister +G_swigregister(G) + +class H(G): + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + _Simple_optimized.H_swiginit(self,_Simple_optimized.new_H()) + __swig_destroy__ = _Simple_optimized.delete_H +H_swigregister = _Simple_optimized.H_swigregister +H_swigregister(H) + + + diff --git a/Examples/python/performance/deep_hierarchy/runme.py b/Examples/python/performance/deep_hierarchy/runme.py new file mode 100644 index 000000000..7e50aff16 --- /dev/null +++ b/Examples/python/performance/deep_hierarchy/runme.py @@ -0,0 +1,17 @@ +#!/usr/bin/env + +import sys +from subprocess import * + +proc = Popen([sys.executable, 'runme_baseline.py'], stdout=PIPE) +(stdout, stderr) = proc.communicate() +print stdout + +proc = Popen([sys.executable, 'runme_optimized.py'], stdout=PIPE) +(stdout, stderr) = proc.communicate() +print stdout + +proc = Popen([sys.executable, 'runme_builtin.py'], stdout=PIPE) +(stdout, stderr) = proc.communicate() +print stdout + diff --git a/Examples/python/performance/deep_hierarchy/runme_baseline.py b/Examples/python/performance/deep_hierarchy/runme_baseline.py new file mode 100644 index 000000000..584b9fb97 --- /dev/null +++ b/Examples/python/performance/deep_hierarchy/runme_baseline.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +import Simple_baseline +import time + +t1 = time.clock() +x = Simple_baseline.H() +for i in range(10000000) : + x.func() +t2 = time.clock() +print "Simple_baseline took %f seconds" % (t2 - t1) diff --git a/Examples/python/performance/deep_hierarchy/runme_builtin.py b/Examples/python/performance/deep_hierarchy/runme_builtin.py new file mode 100644 index 000000000..a095ed223 --- /dev/null +++ b/Examples/python/performance/deep_hierarchy/runme_builtin.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +import Simple_builtin +import time + +t1 = time.clock() +x = Simple_builtin.H() +for i in range(10000000) : + x.func() +t2 = time.clock() +print "Simple_builtin took %f seconds" % (t2 - t1) diff --git a/Examples/python/performance/deep_hierarchy/runme_optimized.py b/Examples/python/performance/deep_hierarchy/runme_optimized.py new file mode 100644 index 000000000..c6f20463d --- /dev/null +++ b/Examples/python/performance/deep_hierarchy/runme_optimized.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +import Simple_optimized +import time + +t1 = time.clock() +x = Simple_optimized.H() +for i in range(10000000) : + x.func() +t2 = time.clock() +print "Simple_optimized took %f seconds" % (t2 - t1) diff --git a/Examples/python/performance/func/Makefile b/Examples/python/performance/func/Makefile new file mode 100644 index 000000000..0df09d908 --- /dev/null +++ b/Examples/python/performance/func/Makefile @@ -0,0 +1,23 @@ +TOP = ../../.. +SWIG = $(TOP)/../preinst-swig +CXXSRCS = +TARGET = Simple +INTERFACE = Simple.i + +default : all + +all : + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -module Simple_baseline' \ + TARGET='$(TARGET)_baseline' INTERFACE='$(INTERFACE)' python_cpp + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -O -module Simple_optimized' \ + TARGET='$(TARGET)_optimized' INTERFACE='$(INTERFACE)' python_cpp + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG) -builtin -O -module Simple_builtin' \ + TARGET='$(TARGET)_builtin' INTERFACE='$(INTERFACE)' python_cpp + +static : + $(MAKE) -f $(TOP)/Makefile CXXSRCS='$(CXXSRCS)' SWIG='$(SWIG)' \ + TARGET='mypython' INTERFACE='$(INTERFACE)' python_cpp_static + +clean : + $(MAKE) -f $(TOP)/Makefile python_clean + rm -f $(TARGET).py diff --git a/Examples/python/performance/func/Simple.i b/Examples/python/performance/func/Simple.i new file mode 100644 index 000000000..d642d15bf --- /dev/null +++ b/Examples/python/performance/func/Simple.i @@ -0,0 +1,8 @@ +%inline %{ +class MyClass { +public: + MyClass () {} + ~MyClass () {} + void func () {} +}; +%} diff --git a/Examples/python/performance/func/Simple_baseline.py b/Examples/python/performance/func/Simple_baseline.py new file mode 100644 index 000000000..7e401b403 --- /dev/null +++ b/Examples/python/performance/func/Simple_baseline.py @@ -0,0 +1,86 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 2.0.2 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. +# This file is compatible with both classic and new-style classes. + +from sys import version_info +if version_info >= (2,6,0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_Simple_baseline', [dirname(__file__)]) + except ImportError: + import _Simple_baseline + return _Simple_baseline + if fp is not None: + try: + _mod = imp.load_module('_Simple_baseline', fp, pathname, description) + finally: + fp.close() + return _mod + _Simple_baseline = swig_import_helper() + del swig_import_helper +else: + import _Simple_baseline +del version_info +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError(name) + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 + + +class MyClass(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, MyClass, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, MyClass, name) + __repr__ = _swig_repr + def __init__(self): + this = _Simple_baseline.new_MyClass() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Simple_baseline.delete_MyClass + __del__ = lambda self : None; + def func(self): return _Simple_baseline.MyClass_func(self) +MyClass_swigregister = _Simple_baseline.MyClass_swigregister +MyClass_swigregister(MyClass) + + + diff --git a/Examples/python/performance/func/Simple_builtin.py b/Examples/python/performance/func/Simple_builtin.py new file mode 100644 index 000000000..4ecd8a63e --- /dev/null +++ b/Examples/python/performance/func/Simple_builtin.py @@ -0,0 +1,81 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 2.0.2 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info +if version_info >= (2,6,0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_Simple_builtin', [dirname(__file__)]) + except ImportError: + import _Simple_builtin + return _Simple_builtin + if fp is not None: + try: + _mod = imp.load_module('_Simple_builtin', fp, pathname, description) + finally: + fp.close() + return _mod + _Simple_builtin = swig_import_helper() + del swig_import_helper +else: + import _Simple_builtin +del version_info +from _Simple_builtin import * +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError(name) + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 + + +def _swig_setattr_nondynamic_method(set): + def set_attr(self,name,value): + if (name == "thisown"): return self.this.own(value) + if hasattr(self,name) or (name == "this"): + set(self,name,value) + else: + raise AttributeError("You cannot add attributes to %s" % self) + return set_attr + + + + + diff --git a/Examples/python/performance/func/Simple_optimized.py b/Examples/python/performance/func/Simple_optimized.py new file mode 100644 index 000000000..0bf42ced3 --- /dev/null +++ b/Examples/python/performance/func/Simple_optimized.py @@ -0,0 +1,93 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 2.0.2 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info +if version_info >= (3,0,0): + new_instancemethod = lambda func, inst, cls: _Simple_optimized.SWIG_PyInstanceMethod_New(func) +else: + from new import instancemethod as new_instancemethod +if version_info >= (2,6,0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_Simple_optimized', [dirname(__file__)]) + except ImportError: + import _Simple_optimized + return _Simple_optimized + if fp is not None: + try: + _mod = imp.load_module('_Simple_optimized', fp, pathname, description) + finally: + fp.close() + return _mod + _Simple_optimized = swig_import_helper() + del swig_import_helper +else: + import _Simple_optimized +del version_info +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError(name) + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 + + +def _swig_setattr_nondynamic_method(set): + def set_attr(self,name,value): + if (name == "thisown"): return self.this.own(value) + if hasattr(self,name) or (name == "this"): + set(self,name,value) + else: + raise AttributeError("You cannot add attributes to %s" % self) + return set_attr + + +class MyClass(object): + thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') + __repr__ = _swig_repr + def __init__(self): + _Simple_optimized.MyClass_swiginit(self,_Simple_optimized.new_MyClass()) + __swig_destroy__ = _Simple_optimized.delete_MyClass +MyClass.func = new_instancemethod(_Simple_optimized.MyClass_func,None,MyClass) +MyClass_swigregister = _Simple_optimized.MyClass_swigregister +MyClass_swigregister(MyClass) + + + diff --git a/Examples/python/performance/func/runme.py b/Examples/python/performance/func/runme.py new file mode 100644 index 000000000..7e50aff16 --- /dev/null +++ b/Examples/python/performance/func/runme.py @@ -0,0 +1,17 @@ +#!/usr/bin/env + +import sys +from subprocess import * + +proc = Popen([sys.executable, 'runme_baseline.py'], stdout=PIPE) +(stdout, stderr) = proc.communicate() +print stdout + +proc = Popen([sys.executable, 'runme_optimized.py'], stdout=PIPE) +(stdout, stderr) = proc.communicate() +print stdout + +proc = Popen([sys.executable, 'runme_builtin.py'], stdout=PIPE) +(stdout, stderr) = proc.communicate() +print stdout + diff --git a/Examples/python/performance/func/runme_baseline.py b/Examples/python/performance/func/runme_baseline.py new file mode 100644 index 000000000..6966fd904 --- /dev/null +++ b/Examples/python/performance/func/runme_baseline.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +import Simple_baseline +import time + +t1 = time.clock() +x = Simple_baseline.MyClass() +for i in range(10000000) : + x.func() +t2 = time.clock() +print "Simple_baseline took %f seconds" % (t2 - t1) diff --git a/Examples/python/performance/func/runme_builtin.py b/Examples/python/performance/func/runme_builtin.py new file mode 100644 index 000000000..ca2f88ac8 --- /dev/null +++ b/Examples/python/performance/func/runme_builtin.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +import Simple_builtin +import time + +t1 = time.clock() +x = Simple_builtin.MyClass() +for i in range(10000000) : + x.func() +t2 = time.clock() +print "Simple_builtin took %f seconds" % (t2 - t1) diff --git a/Examples/python/performance/func/runme_optimized.py b/Examples/python/performance/func/runme_optimized.py new file mode 100644 index 000000000..fe10eb376 --- /dev/null +++ b/Examples/python/performance/func/runme_optimized.py @@ -0,0 +1,11 @@ +#!/usr/bin/env python + +import Simple_optimized +import time + +t1 = time.clock() +x = Simple_optimized.MyClass() +for i in range(10000000) : + x.func() +t2 = time.clock() +print "Simple_optimized took %f seconds" % (t2 - t1)