File size: 9,490 Bytes
065fee7 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 |
Decorator Benchmarks
====================
The **wrapt** module ensures that your decorators will work in all
situations. The implementation therefore does not take the shortcuts that
people usually take with decorators of using function closures. Instead it
implements the wrappers as a class, which also acts as a descriptor.
Ensuring correctness though does come at an additional cost in runtime
overhead. The following attempts to quantify what that overhead is and
compare it to other solutions typically used.
Results were collected under MacOS X Mountain Lion on a 2012 model MacBook
Pro, running with Python 2.7.
Undecorated Calls
-----------------
These tests provide a baseline for comparing decorated functions against a
normal undecorated function call.
**Test Code**::
def function1():
pass
class Class(object):
def function1(self):
pass
@classmethod
def function1cm(cls):
pass
@staticmethod
def function1sm():
pass
**Test Results**::
$ python -m timeit -s 'import benchmarks' 'benchmarks.function1()'
10000000 loops, best of 3: 0.132 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function1()'
10000000 loops, best of 3: 0.143 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function1cm()'
1000000 loops, best of 3: 0.217 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function1cm()'
10000000 loops, best of 3: 0.159 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function1sm()'
1000000 loops, best of 3: 0.199 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function1sm()'
10000000 loops, best of 3: 0.13 usec per loop
Note that differences between calling the class and static methods via the
class vs the instance are possibly more to do with needing to traverse
the dotted path.
Function Closures
-----------------
These tests provide results for decorated functions where the decorators are
implemented using function closures.
**Test Code**::
def wrapper2(func):
def _wrapper2(*args, **kwargs):
return func(*args, **kwargs)
return _wrapper2
@wrapper2
def function2():
pass
class Class(object):
@wrapper2
def function2(self):
pass
@classmethod
@wrapper2
def function2cmi(cls):
pass
@staticmethod
@wrapper2
def function2smi():
pass
**Test Results**::
$ python -m timeit -s 'import benchmarks' 'benchmarks.function2()'
1000000 loops, best of 3: 0.326 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function2()'
1000000 loops, best of 3: 0.382 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function2cmi()'
1000000 loops, best of 3: 0.46 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function2cmi()'
1000000 loops, best of 3: 0.384 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function2smi()'
1000000 loops, best of 3: 0.389 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function2smi()'
1000000 loops, best of 3: 0.319 usec per loop
Note that decorators implemented as function closures cannot be added around
staticmethod and classmethod decorators and must be added inside of those
decorators.
wrapt.decorator
---------------
These tests provides results for decorated functions where the decorators
are implemented using the **wrapt** module. Separate results are provided
for when using the C extension and when using the pure Python
implementation.
**Test Code**::
@wrapt.decorator
def wrapper3(wrapped, instance, args, kwargs):
return wrapped(*args, **kwargs)
@wrapper3
def function3():
pass
class Class(object):
@wrapper3
def function3(self):
pass
@wrapper3
@classmethod
def function3cmo(cls):
pass
@classmethod
@wrapper3
def function3cmi(cls):
pass
@wrapper3
@staticmethod
def function3smo():
pass
@staticmethod
@wrapper3
def function3smi():
pass
**Test Results (C Extension)**::
$ python -m timeit -s 'import benchmarks' 'benchmarks.function3()'
1000000 loops, best of 3: 0.382 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function3()'
1000000 loops, best of 3: 0.836 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function3cmo()'
1000000 loops, best of 3: 1.11 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function3cmo()'
1000000 loops, best of 3: 1.06 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function3cmi()'
1000000 loops, best of 3: 0.535 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function3cmi()'
1000000 loops, best of 3: 0.455 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function3smo()'
1000000 loops, best of 3: 1.37 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function3smo()'
1000000 loops, best of 3: 1.31 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function3smi()'
1000000 loops, best of 3: 0.453 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function3smi()'
1000000 loops, best of 3: 0.378 usec per loop
Note that results for where the decorator is inside that of the classmethod
decorator is quite a bit less than that where it is outside. This due to a
potential bug in Python whereby it doesn't apply the descriptor protocol to
what the classmethod decorator wraps. Instead it is executing a straight
function call, which has less overhead.
**Test Results (Pure Python)**::
$ python -m timeit -s 'import benchmarks' 'benchmarks.function3()'
1000000 loops, best of 3: 0.771 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function3()'
100000 loops, best of 3: 6.67 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function3cmo()'
100000 loops, best of 3: 6.89 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function3cmo()'
100000 loops, best of 3: 6.77 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function3cmi()'
1000000 loops, best of 3: 0.911 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function3cmi()'
1000000 loops, best of 3: 0.863 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function3smo()'
100000 loops, best of 3: 7.26 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function3smo()'
100000 loops, best of 3: 7.17 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function3smi()'
1000000 loops, best of 3: 0.835 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function3smi()'
1000000 loops, best of 3: 0.774 usec per loop
Note that results for where the decorator is inside that of the classmethod
decorator is quite a bit less than that where it is outside. This due to a
potential bug in Python whereby it doesn't apply the descriptor protocol to
what the classmethod decorator wraps. Instead it is executing a straight
function call, which has less overhead.
decorator.decorator
-------------------
These tests provides results for decorated functions where the decorators
are implemented using the **decorator** module available from PyPi.
**Test Code**::
@decorator.decorator
def wrapper4(wrapped, *args, **kwargs):
return wrapped(*args, **kwargs)
@wrapper4
def function4():
pass
class Class(object):
@wrapper4
def function4(self):
pass
@classmethod
@wrapper4
def function4cmi(cls):
pass
@staticmethod
@wrapper4
def function4smi():
pass
**Test Results**::
$ python -m timeit -s 'import benchmarks' 'benchmarks.function4()'
1000000 loops, best of 3: 0.465 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function4()'
1000000 loops, best of 3: 0.537 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function4cmi()'
1000000 loops, best of 3: 0.606 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function4cmi()'
1000000 loops, best of 3: 0.533 usec per loop
$ python -m timeit -s 'import benchmarks' 'benchmarks.Class.function4smi()'
1000000 loops, best of 3: 0.532 usec per loop
$ python -m timeit -s 'import benchmarks; c=benchmarks.Class()' 'c.function4smi()'
1000000 loops, best of 3: 0.456 usec per loop
Note that decorators implemented using the decorator module cannot be added
around staticmethod and classmethod decorators and must be added inside of
those decorators.
|