Perly Linked Lists

What About Arrays? ● Perl arrays are fast and flexible. ● But there are a few limitations: ● They require contiguous memory. ● They do not shrink: removing items from an array does not reclaim any memory. ● for( @array ) will only iterate one list at a time. ● for ( 0 .. $#array ) has problems dealing with arrays of different sizes or offsets.

Memory Issues ● Pushing a single value onto an array can double its size. ● Whole-array copies are especially painful for heavily-forked processes that use copy-on-write semantics to reduce memory use. ● There is no way to reduce the array size once it grows -- also painful for long-lived processes.

Iterating Multiple Lists ● for( @array ) will only iterate one list easily. ● Indexes with for( 0 .. $#array ) require the lists to have the same size and sequence. ● For comparisons done piecemeal there is no good way to compare the 'next item' on each lists without bookkeeping each index separately or using push/shift to rotate the lists.

Linked Lists: The Other Guys ● Perly code for linked lists is simple, simplifies memory management, and list iteration. ● What you loose is indexed access: because you have to walk the list of find a node, random access is expensive. ● List operators like push, pop, and splice are simple. ● You also get more granular locking in threaded applications.

Examples ● Insertion sorts are stable, but splicing an item into the middle of an array is expensive; adding a new node to a linked list is cheap. ● Threading can require locking an entire array to update it; linked lists can safely be locked by node. ● Circular linked lists are nice for work queues, especially in threaded environments.

Start With An Array ● Arrays can hold any type of data. ● All a singly-linked list requires is a static head element and a node variable to walk down it. ● Doubly-linked lists are also manageable with the addition of weak links. ● For the sake of time I'll only discuss singly-linked lists here.

What's Next? ● Singly-linked lists are usually drawn as some data followed by a pointer to the next link. ● In Perl it helps to draw the pointer first, because that is where you'll put it.

Adding A Node ● New data does not need to be contiguous in memory. ● A new node does not affect the nodes following it.

Dropping A Node ● Dropping a node releases its memory – at last back to Perl. ● Deletions have no effect on the following nodes. ● One reason that threading works well with the lists.

Looking At The Perl ● A link followed by data looks like: [ $node, @data ] ● Walking the list updates the node: ( $node, my @data ) = @$node; ● Adding a new node recycles the “next” ref: $node->[0] = [ $node->[0], @data ] ● Removing a node discards the next ref: $node->[0] = ${ $node->[0] }->[0];

Destroying A Linked List ● Perl's memory de-allocator is recursive. ● Without a DESTROY, large lists blow up with a stack error. ● The fix is to iterate the destructor: DESTROY { my $list = shift; $list = $list->[0] while $list; }

Simple Linked List Class ● Bless an arrayref, with the argument data in the head. ● This may be all the code you need. sub new { my $proto = shift; bless [ [], @_ ], blessed $proto || $proto } DESTROY { $list = $list->[0] while $list; }

Building the list: unshift ● This is one reason for the head node: you have something before the first node to insert after. ● The new first node has the old first node's “next” ref and the new data. sub node_unshift { my $list = shift; $list->[0] = [ $list->[0], @_ ]; }

Taking one off: shift ● This starts directly from the head node also: just replace the head node's next with the first node's next. ● And remember to return the data. sub node_shift { my $list = shift; ( $list->[0], my @data ) = @{ $list->[0] }; wantarray ? @data : @data }

Push Is A Little Harder ● This is just an unshift before the tail. ● Which is another reason for the empty placeholder node. ● Also a good reason for storing a ref to the tail node in $head->[1]. sub node_push { my $list = shift; my $node = $list->[0]; $node = $node->[0] while @{ $node->[0] }; $node->[0] = [ $node->[0], @_ ]; }

The Bane Of Single Links: pop ● You need the node-before-the-tail to pop the tail. ● By the time you've found the tail it is too late to pop it off. ● Storing the node-before-tail is also difficult because of bookkeeping. ● The trick is to use two nodes, one trailing the other: when the small roast is burned the big one is just right.

● $prior trails $node by one link. sub node_pop { my $list = shift; my $node = $list->[0]; my $prior = ''; while( @{ $node->[0] } ) { $prior = $node; # golf anyone? $node = $node->[0]; } ( $prior->[0], my @data ) = @$node; wantarray ? @data : @data }

Reverse-order List ● Lists can be built from the front inline or via $list->node_unshift. ● This leaves the items in reverse order: $list->[0] has the last data added. my $list = [ [] ]; my $node = $list->[0]; for my $value ( @_ ) { @$node = [ $node->[0], $value ]; }

In-order List ● Moving the node allows adding the next item after the last one added. ● This is a whole lot faster than calling push for each entry. my $list = [ [] ]; my $node = $list; for my $value( @_ ) { @$node = [ [], $value ]; $node = $node->[0]; }

Viewing The List ● The arrayref chain looks “nested” in the debugger: DB<11> $node = []; DB<12> $list = [ $node, 'head node' ]; DB<13> for( 1 .. 5 ) { @$node = ( [], “node-$_” ); $node = $node->[0] } DB<14> x $b 0 ARRAY(0x8390608) $list 0 ARRAY(0x83ee698) $list->[0] 0 ARRAY(0x8411f88) $list->[0][0] 0 ARRAY(0x83907c8) $list->[0][0][0] 0 ARRAY(0x83f9a10) $list->[0][0][0][0] 0 ARRAY(0x83f9a20) $list->[0][0][0][0][0] 0 ARRAY(0x83f9a50) $list->[0][0][0][0][0][0] empty array empty tail node 1 'node-5' $list->[0][0][0][0][0][1] 1 'node-4' $list->[0][0][0][0][1] 1 'node-3' $list->[0][0][0][1] 1 'node-2' $list->[0][0][1] 1 'node-1' $list->[0][1] 1 'head node' $list->[1]

Walking A List ● The node can be advanced and data extracted in one step. ● This is why putting the link first helps: @data can be anything: my $node = $head>[0]; while( $node ) { ( $node, my %info ) = @$node; ... }

Comparing Multiple Lists ● The nodes themselves can be walked separately. ● Which leads to simpler index variables. my ( $l0, $l1 ) = @_; while( $l0 && $l1 ) { ( $l0, my @data0 ) = @$l0; ( $l1, my @data1 ) = @$l1; ... }

Syncopated Lists ● There are times when lists need to be compared at different offsets. ● Testing DNA for gaps or looking for trends separated over time. my ( $l0, $l1 ) = @_; my ( $advance_0, $advance_1 ) = (1,1); while( $l0 && $l1 ) { ( $l0, my @d0 ) = @$l0 if $advance_0; ( $l1, my @d1 ) = @$l1 if $advance_1; ... }

Saving State Is Easy ● Just keep the current nodes on a stack for tracking later work. ● I use this for saving points where DNA sequences may be diverging. ● Restarting the comparison just gets new values of $l0, $l1 off the queue. my ( $l0, $l1 ) = @_; my @queue = (); ... push @queue [ $l0, $l1, $score ] if $score > 0.05;

Using The Head Node ● $head->[0] is the first node, there are a few useful things to add. ● Tracking the length or tail simplify things like sort or push. ● The head node can also store user- supplied data describing the list. ● I use this for tracking length and species names in results of DNA sequences. ● $head->[1] can also store the tail to allow for one-step push.

Classy Lists ● A list class could use inside-out data to track the head, tail, etc. ● They can also be overloaded to compare lists by length. ● Catch: $node = $node->[0] replaces node each time it moves down the list. ● Blessing only the head leaves the nodes unable to use methods. ● The goal is an object that can walk the list without changing its own refaddr.

Scalar Refs ● The fix is to bless a scalar reference. ● $node stays in one place, where $$node can walk up the list. ● This allows methods like “head” or “next” to reposition the current location without loosing inside-out data.

Basics Don't Change Much ● The only real difference is the “$$”: sub new { my $proto = shift; my $list = [ [], @_ ]; $headz{ refaddr $list } = $$list; bless $list, $proto } DESTROY { my $list = shift; $head = delete $headz{ refaddr $list }; $head = $head->[0] while $head; }

Walking The List sub head { my $list = shift $$list = $headz{ refaddr $list } } sub next { my $list = shift; ( $$list, my @data ) = @$$list or return wantarray ? @data : @data } $list->head; while( my $data = $list->next ) { ... }

Inserting Links ● Only difference is the “$$list”. sub insert { my $list = shift; $$list>[0] = [ $$list>[0], @_ ]; } # reverseorder list: my $list = List::Class>new( ... ); $list>insert( @$_ ) for @data_rows;

Summary ● Linked lists can be quite lazy for a variety of uses in Perl: ● Large, varying lists. ● Long-lived processes. ● Tightly-grained locking in threads. ● Comparing syncopated nodes. ● Circular lists for threaded queuing.

Perly Linked Lists

by Workhorse Computing

Accessibility

Categories

Upload Details

Usage Rights

1 Embed 3

Statistics

Perly Linked Lists Presentation Transcript