Phoenix performance

[Michael Hipp]

I've just started working with Phoenix on a couple of projects...

Is it my imagination or is Phoenix quite a bit faster and more
responsive than Classic?

Michael

[Metallicow]

Post by Michael Hipp
I've just started working with Phoenix on a couple of projects...
Is it my imagination or is Phoenix quite a bit faster and more
responsive than Classic?
Michael

Depends on how you are using it, but in general in the long run there will
be less cruft and whatnot so in theory yes.
I have been focusing on optimizing performance parts of the code also:
loops etc. Ex: ListCtrlHighlighterMixin
Stuff like that.
So it all depends... PY2 and PY3 performance will be different also, but
generally 3.3 has the same speeds overall as 2.7 did.
It will only get better with time.

[Robin Dunn]

Post by Michael Hipp
I've just started working with Phoenix on a couple of projects...
Is it my imagination or is Phoenix quite a bit faster and more
responsive than Classic?

Yes, I haven't done any actual measurements, but that has been my
feeling too and it fits with the changes in code structure and
architecture that have been made. Early on it looked like there was
going to be a significant runtime memory usage savings too, but that gap
has narrowed somewhat as more class wrappers have been added in the core
module.

Some of the general changes in the generated wrapper code that
contribute to the improvements include:

* Less layers. In most cases a call to a wrapped C++ method goes
directly to that method's C wrapper without needing to pass through 1 or
2 layers of additional Python function calls.

* Wrapped classes are extension types instead of just a collection of
function wrappers that are glued together into a class by Python code.

* More efficient type checking and type conversion.

* Less hacks. Most things that I had to make "creative workarounds" for
in the past are built-in and so the implementation and support of the
feature is part of the design and intent of the code instead of
something bolted on to the side.

* Less memory use for string constants. Generated string constants in
the code for things like class, method, parameter and instance names are
reused via a pointer to a single instance of the text instead of just
using yet another new but identical string literal each time.

And probably some others I'm not thinking of at the moment.