YAPC::EU 2011
rurban - Reini Urban <br> vienna.pm => houston.pm
vienna.pm
houston.pm
<br><br>
Provide type semantics to enable more compile-time optimizations, to make Perl and compiled Perl smaller and faster.
my TYPE $i; my My::Class $o; # Declaration only <br> package TYPE must exist
my TYPE $i; my My::Class $o;
smaller and faster, ensured at compile-time:<br> faster method calls, fix types, declarations via class and attributes, typed arrays + hashes, perfect hashes.
Declare and check type safety. int, double, number, string. params and return values.
<img src=pix/austria-shitty-little-country.jpg>
Architect. Mainly LISP for several years. Perl as better build system.
rurban maintains cygwin perl since 5.8.8 and some modules: illguts, B::* => 5.10, mainly the "compiler".
No perl dayjob, just for fun. Until now.
In the future a lot more time for the compiler and CORE. Left AVL (automotive industry), went to cPanel to improve the compiler.
FETCH_SCALAR_ATTRIBUTES => New CHECK_SCALAR_ATTRIBUTES callback for my.
my
Yes, the language already has one. CORE:
Only a few out-of-CORE implementations: <br>
Moose, fields, <strike>types, typesafety</strike>, Lexical::Types, Attribute::Types (run-time)
Params: Devel::Declare, Params::Validate, Params::Classify <br> Objects: Class::Meta, Moose
Devel::Declare
Params::Validate
Params::Classify
Class::Meta
Moose
No standard prototype language, no CPAN prototype parser!
At first a look at CORE types, not the language:
SCALAR (non-strict, VB-like): IV, NV, UV, PV, ...
ARRAY (non-strict): AV
HASH (non-strict): HV
Objects ("stashes", @ISA, declaration)
SCALAR (non-strict, VB-like)
multiple types (IV,NV,PV) per variable, context dependent.
internally upgraded: IV => PVIV => PVNV
IV: integer
<img src=pix/sviv-14.png height=204px width=278px>
Typed IV: integer unblessed, untied. my int $i; ~SV_SMAGIC => SVf_FAKE: no head
my int $i;
>
<img src=pix/sviv-14.png height=204px width=278px> => <img src=pix/sviv-new.png height=204px width=278px>
internally upgraded: IV => NV
<img src=pix/svnv-14.png height=252px width=288px>
internally upgraded: IV => NV => PVNV
<img src=pix/svpvnv-14.png height=264px width=552px>
internally upgraded: IV => PVIV => PVNV => "Objects" => Tie
<img src=pix/svpvmg-14.png>
"STASH" - Hierarchical symbol table,<br> used as package name for Objects. i.e. "Class pointer"
<img src=pix/stash.png>
ARRAY (non-strict)
Keys are integers, Values any SCALAR
Keys are integers, Values any SCALAR - flexible, untyped, big
<img src=pix/av-sv.png>
Typed ARRAYs (optional, faster, less space)
Keys are integers, Values of one type only (native)
Untyped:
<img src=pix/av-typed.png>
AvTYPED && (IOK | NOK | POK)
<p>
Declaration already possible now!
int must be a package definition.
<small>Note: @a is currently declared as int, but not blessed.</small>
@a
int
HASH untyped: flexible, but big
Keys any SCALAR, Values any SCALAR
Internally: Keys are stringified.
HASH untyped: flexible<br> Keys any SCALAR, Values any SCALAR
<img src=pix/hv-sv.png>
HASH typed: fast, small
Keys STRING only, Values typed
HASH typed: directer access, small <br> Keys STRING only, Values typed
<img src=pix/hv-typed.png>
Keys STRING only, Values are typed.
Perfect hashes - guaranteed O(1) lookup, dynamic hash function generation, no collisions<br> Library cmph BDZ algorithm ("RAM hashing")
my %h :const;
my %h :perfect;
study %h
study untyped hash => copies the old perl hash (HV) to new perfect hash (PH).
Perfect hash. Should be typed to optimize implementation.
:const hashes are always :perfect<br> No need to study with :const and init on declaration.
:const
:perfect
- Avoid copy from perl hash to perfect hash.
- Declare size in advance.
- :const hash with computed key => values, without study
Idea 1
Init until length is filled
Idea 2
Initialization on next expression, usually a block.
OBJECTS: typed, but dynamic
run-time changable, mostly no compile-time optimizations possible.
Features: STASH ("class hash"), @ISA (mro), DESTROY
OBJECTS: typed, but dynamic.
Class by STASH, Inheritance by @ISA (mro), magic DESTROY and CLONE methods.
Four method calls possible:
pushmark <br> ARGS... <br> gv => GV *Class::sub <br> entersub
Class->method() <br> $object->method() <br> Class->$method() <br> $object->$method()
Class::sub() <br>
pushmark <br> const => PV "Class" <br> ARGS... <br> method_named => PV "method" <br> entersub
$object->method() <br> Class->$method() <br> $object->$method()
pushmark <br> padsv => GV *object <br> ARGS... <br> method_named => PV "method" <br> entersub
pushmark <br> const => PV "Class" <br> ARGS... <br> method => GV *method <br> entersub
pushmark <br> padsv => GV *object <br> ARGS... <br> method => GV *method <br> entersub
pushmark <br> const => PV "Class" <br> ARGS... <br> method_named => PV "method" <br> entersub <br> => <br> pushmark <br> const => PV "Class" <br> ARGS... <br> gv => GV *Class::method <br> entersub
or package Class :locked or in Moose immutable.<br> i.e. not changed at run-time.
package Class
=> 4% faster method calls.
Note: @Class::ISA :const = qw(bla); does not help.
@Class::ISA
qw(bla);
Dynamic method calls are possible to optimize in a similar way, if the object is declared - known class at compile-time.
Inherited methods are optimizable if all classes in path to the final class are :locked, resp. immutable.
All this is possible now, without changing the language.
Just optimized implementations are missing.
I heard that in July 2011 Moose methods of immutable classes are going to be inlined, but what I saw so far it's not using optree changes like these to speed it up.
More compile-time optimizations.
:const for variables
:locked for packages: const @ISA, no run-time created methods.
@ISA
types is Artur Bergman's compile-time checking attempt from 2002, after the compiler, B::Generate and optimize.
And before optimizer, which uses types to improve the optree.
types does compile-time type-checking only.
compile-time type-optimizations in optimizer.
Problem: slower, not faster.
The idea is to make programs with use types;
use types;
faster, not slower.
And define basic scalar types from CORE
int, double and string
double
string
The same types and declarations are used in B::CC also to optimize types even further.
B::CC also needs a syntax to optionally declare simple types:
int and double (strict)
So far it was done by magic variable name suffices: $a_i, $n_d;
$a_i
$n_d
faster, much faster
Strict types as class, and optional type hints as attributes.
With use types you get type-declarations, <br> partial type-safety, and <br> type optimizations at compile-time.
use types
http://blogs.perl.org/users/rurban/2011/02/use-types.html
To install types, copy and paste the appropriate command in to your terminal.
cpanm
cpanm types
CPAN shell
perl -MCPAN -e shell install types
For more information on module installation, please visit the detailed CPAN module installation guide.