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

To install types, copy and paste the appropriate command in to your terminal.

cpanm types

perl -MCPAN -e shell
install types

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)