Bizarre additional calling overhead.

[Chris Mellon]

>>def test_func():
.... pass
....

>>import new
test_func2 = new.function(te st_func.func_co de, {}, "test_func2 ")
test_func2

<function test_func2 at 0x01B8C2F0>

>>test_func

<function test_func at 0x01B8C270>

>>import timeit
tf = timeit.Timer("t est_func()", "from __main__ import test_func")
tf.repeat()

[0.2183461704377 247, 0.1806821531448 9791, 0.1797858584149 8085]

>>tf2 = timeit.Timer("t est_func2()", "from __main__ import test_func2")
tf2.repeat( )

[0.4001539023989 0891, 0.3589345287939 6648, 0.3603462813373 7456]

>>>

Why almost twice the calling overhead for a dynamic function?

[Matimus]

On Nov 2, 3:08 pm, "Chris Mellon" <arka...@gmail. comwrote:

>def test_func():

... pass
...>>import new

>test_func2 = new.function(te st_func.func_co de, {}, "test_func2 ")
test_func2

<function test_func2 at 0x01B8C2F0>>>te st_func

<function test_func at 0x01B8C270>>>im port timeit

>tf = timeit.Timer("t est_func()", "from __main__ import test_func")
tf.repeat()

[0.2183461704377 247, 0.1806821531448 9791, 0.1797858584149 8085]>>tf2 = timeit.Timer("t est_func2()", "from __main__ import test_func2")

>tf2.repeat()

[0.4001539023989 0891, 0.3589345287939 6648, 0.3603462813373 7456]

Why almost twice the calling overhead for a dynamic function?

So, I don't have an official explanation for why it takes twice as
long, but the only difference between the two functions I could find
was that test_func.func_ globals was set to globals() and
test_func2.func _globals was an empty dict. When I re-created
test_func2 with globals set to globals() it ran just as fast as
test_func.

>>test_func2 = new.function(te st_func.func_co de, globals(), "test_func" )
tf2 = timeit.Timer("t est_func2()", "from __main__ import test_func2")
tf2.repeat( )

[0.1811911849131 3202, 0.1839622074871 8406, 0.1872240745681 2107]

>>tf.repeat()

[0.1812512484129 9112, 0.1798125180714 5782, 0.1851799600228 7873]

Matt

[Steven D'Aprano]

On Fri, 02 Nov 2007 17:08:06 -0500, Chris Mellon wrote:

>>>def test_func():

... pass
...

>>>import new
test_func2 = new.function(te st_func.func_co de, {}, "test_func2 ")

[snip results of timeit]

Why almost twice the calling overhead for a dynamic function?

When I time the functions, I get a lot of variability. The minimum value
is probably the best one to look at:

>>min(timeit.Ti mer("test_func( )",

.... "from __main__ import test_func").rep eat(20))
0.3566401004791 2598

>>min(timeit.Ti mer("test_func2 ()",

.... "from __main__ import test_func2").re peat(20))
0.6813821792602 5391
Disassembling the code does not give any hints:

>>import dis
dis.dis(test_ func)

2 0 LOAD_CONST 0 (None)
3 RETURN_VALUE

>>dis.dis(test_ func2)

2 0 LOAD_CONST 0 (None)
3 RETURN_VALUE

Which is what we should expect, because both functions have the same code:

>>test_func.fun c_code is test_func2.func _code

True
But try this:

>>test_func3 = new.function(te st_func.func_co de,

.... globals(), 'test_func3')

>>min(timeit.Ti mer("test_func3 ()",

.... "from __main__ import test_func3").re peat(20))
0.3577220439910 8887
Hmmm... it looks like the difference in speed has to do with the globals,
not the fact that it is created dynamically. I wonder why?


--
Steven.