Reini Urban > types-0.05_04 > doc/yapc_2011.pod

Download:
types-0.05_04.tar.gz

Annotate this POD

CPAN RT

New  3
Open  0
View/Report Bugs
Source  

use types; ^

YAPC::EU 2011

rurban - Reini Urban <br> vienna.pm => houston.pm

Goal ^

<br><br>

Provide type semantics to enable more compile-time optimizations, to make Perl and compiled Perl smaller and faster.

Outline ^

Status Quo: CORE types

my TYPE $i; my My::Class $o; # Declaration only <br> package TYPE must exist

Optimizations planned for 5.16 - 5.18

smaller and faster, ensured at compile-time:<br> faster method calls, fix types, declarations via class and attributes, typed arrays + hashes, perfect hashes.

Artur Bergman's types module

Declare and check type safety. int, double, number, string. params and return values.

About me ^

<img src=pix/austria-shitty-little-country.jpg>

About me ^

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.

Perl's Type System ^

FETCH_SCALAR_ATTRIBUTES => New CHECK_SCALAR_ATTRIBUTES callback for my.

Perl's Type System ^

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

Prototypes ^

No standard prototype language, no CPAN prototype parser!

Prototypes ^

No standard prototype language, no CPAN prototype parser!

Perl's Type System ^

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)

Perl's Type System - SCALAR ^

SCALAR (non-strict, VB-like)

multiple types (IV,NV,PV) per variable, context dependent.

internally upgraded: IV => PVIV => PVNV

Perl's Type System - SCALAR ^

SCALAR (non-strict, VB-like)

multiple types (IV,NV,PV) per variable, context dependent.

IV: integer

<img src=pix/sviv-14.png height=204px width=278px>

Perl's Type System - SCALAR ^

SCALAR (non-strict, VB-like)

multiple types (IV,NV,PV) per variable, context dependent.

Typed IV: integer unblessed, untied. my int $i; ~SV_SMAGIC => SVf_FAKE: no head

<img src=pix/sviv-14.png height=204px width=278px> => <img src=pix/sviv-new.png height=204px width=278px>

Perl's Type System - SCALAR ^

SCALAR (non-strict, VB-like)

multiple types (IV,NV,PV) per variable, context dependent.

internally upgraded: IV => NV

<img src=pix/svnv-14.png height=252px width=288px>

Perl's Type System - SCALAR ^

SCALAR (non-strict, VB-like)

multiple types (IV,NV,PV) per variable, context dependent.

internally upgraded: IV => NV => PVNV

<img src=pix/svpvnv-14.png height=264px width=552px>

Perl's Type System - SCALAR ^

SCALAR (non-strict, VB-like)

internally upgraded: IV => PVIV => PVNV => "Objects" => Tie

<img src=pix/svpvmg-14.png>

Perl's Type System - SCALAR ^

"STASH" - Hierarchical symbol table,<br> used as package name for Objects. i.e. "Class pointer"

<img src=pix/stash.png>

Perl's Type System - ARRAY ^

ARRAY (non-strict)

Keys are integers, Values any SCALAR

Perl's Type System - ARRAY ^

ARRAY (non-strict)

Keys are integers, Values any SCALAR

Perl's Type System - ARRAY ^

ARRAY (non-strict)

Keys are integers, Values any SCALAR - flexible, untyped, big

<img src=pix/av-sv.png>

Typed ARRAY ^

Typed ARRAYs (optional, faster, less space)

Keys are integers, Values of one type only (native)

Untyped:

Typed ARRAY ^

<img src=pix/av-typed.png>

  AvTYPED && (IOK | NOK | POK)

Typed ARRAY ^

<p>

Declaration already possible now!

int must be a package definition.

<small>Note: @a is currently declared as int, but not blessed.</small>

Perl's Type System - HASH ^

HASH untyped: flexible, but big

Keys any SCALAR, Values any SCALAR

Internally: Keys are stringified.

Perl's Type System - HASH ^

HASH untyped: flexible<br> Keys any SCALAR, Values any SCALAR

<img src=pix/hv-sv.png>

Typed HASH ^

HASH typed: fast, small

Keys STRING only, Values typed

Typed HASH ^

HASH typed: directer access, small <br> Keys STRING only, Values typed

<img src=pix/hv-typed.png>

Typed HASH ^

HASH typed: fast, small

Keys STRING only, Values are typed.

Perfect HASH ^

Perfect hashes - guaranteed O(1) lookup, dynamic hash function generation, no collisions<br> Library cmph BDZ algorithm ("RAM hashing")

my %h :const; => untyped perfect hash of unknown size<br>
my %h :perfect; => writable perfect hash
study %h; => optimize lookup function to perfect hash.

study untyped hash => copies the old perl hash (HV) to new perfect hash (PH).

Perfect HASH ^

Perfect hash. Should be typed to optimize implementation.

:const hashes are always :perfect<br> No need to study with :const and init on declaration.

Perfect HASH Idioms ^

- Avoid copy from perl hash to perfect hash.

Perfect HASH Idioms ^

- Declare size in advance.

Perfect HASH Idioms ^

- :const hash with computed key => values, without study

Idea 1

Init until length is filled

Perfect HASH Idioms ^

- :const hash with computed key => values, without study

Idea 2

Initialization on next expression, usually a block.

Perl's Type System - OBJECTS ^

OBJECTS: typed, but dynamic

run-time changable, mostly no compile-time optimizations possible.

Features: STASH ("class hash"), @ISA (mro), DESTROY

Perl's Type System - OBJECTS ^

OBJECTS: typed, but dynamic.

Class by STASH, Inheritance by @ISA (mro), magic DESTROY and CLONE methods.

Four method calls possible:

Class->method()
$object->method()
Class->$method()
$object->$method()

Compilation of a function ^

  pushmark  <br>
    ARGS...  <br>
  gv => GV *Class::sub  <br>
  entersub

Class->method() <br> $object->method() <br> Class->$method() <br> $object->$method()

Compilation of a static method call ^

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()

Compilation of a method call ^

  pushmark  <br>
  padsv => GV *object  <br>
    ARGS...  <br>
  method_named => PV "method"  <br>
  entersub

Compilation of a method call ^

  pushmark  <br>
  const => PV "Class"  <br>
    ARGS...  <br>
  method => GV *method  <br>
  entersub

Compilation of a method call ^

  pushmark  <br>
  padsv => GV *object  <br>
    ARGS...  <br>
  method => GV *method  <br>
  entersub

Optimization of a static method call ^

  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

Optimization of a static method call ^

or package Class :locked or in Moose immutable.<br> i.e. not changed at run-time.

=> 4% faster method calls.

Note: @Class::ISA :const = qw(bla); does not help.

Optimization of other method calls ^

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.

Summary so far ^

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 optimizations ^

More compile-time optimizations.

:const for variables

:locked for packages: const @ISA, no run-time created methods.

use types; ^

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.

use types; ^

types does compile-time type-checking only.

compile-time type-optimizations in optimizer.

Problem: slower, not faster.

use types; ^

The idea is to make programs with use types;

faster, not slower.

And define basic scalar types from CORE

int, double and string

B::CC ^

The same types and declarations are used in B::CC also to optimize types even further.

B::CC - optimizing perl compiler ^

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;

faster, much faster

B::CC - User Type declarations ^

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.

SUMMARY ^

SUMMARY ^

SUMMARY ^

Questions? ^

Questions? ^

http://blogs.perl.org/users/rurban/2011/02/use-types.html

syntax highlighting: