CSC/ECE 517 Fall 2010/ch5 5c ck

Dynamic Dispatch

Introduction

Dynamic dispatch means there is a determination of which method to execute at run time, when a class and one of it's subclasses have the same method signature. Evaluation of Control Structures for Dynamic Dispatch in JAVA (pg 5)[1]

Dynamic dispatch occurs when a class is downcast to one of its super classes and a method is called on that super class object.

See the Generic Example for an explanation of downcasting.

Generic Example

Using Dynamic Dispatch

We have a set of objects that can be rendered to the display.
Each object implements the IRenderable interface as seen below:



Utilizing the ability of dynamic dispatch it is very simple to render a collection of IRenderable[] objects for the display:

IRenderable[] irCollection = {new Circle(0,0,.5), new Polygon(0,0,1,1,2,2,0,0)}
foreach (IRenderable ir in irCollection)
{
   ir.render();
}

In the above example, when ir is a Circle it is dynamically downcast to Circle to call Circle.render() and when ir is a Polygon it is dynamically downcast to Polygon to call Polygon .render();

Note: This example would be the same if IRenderable were a class or abstract class object.

Static Simulation of Dynamic Dispatch

Without dynamic dispatch we would have to test the type of the object, cast it to a subtype and make the call.

IRenderable[] irCollection = {new Circle(0,0,.5), new Polygon(0,0,1,1,2,2,0,0)}
foreach (IRenderable ir in irCollection)
{
   if (ir is Circle) ((Circle)ir).render();
   if (ir is Polygon) ((Polygon)ir).render();
}

This is more complicated than using dynamic dispatch and it also requires us to alter this code every time we add a new class.

Inside View of Dynamic Dispatch

A non dispatched method call is simply a jump to a pointer that is stored inside of the object that the message is sent to.
In the simplest single dispatch case, a dispatched method call has to look up the location of where to jump in a table.
In a more complex case, such as double or multiple dispatch, it may have to calculate the table location before looking it up.
For an in-depth article of how some languages implement dynamic dispatch, read this virtual method table wiki.

Single and Multiple Dispatch

I will start with an example to make it easier to explain.

Example

class Thing{
   function defeats(Thing t) {throw SingleDispatchException}
}
class Rock extends Thing{
   function defeats(Rock r){throw tryagain}
   function defeats(Scissors s){return t}
   function defeats(Paper p){return f}
}
class Paper extends Thing{
   function defeats(Rock r){return t}
   function defeats(Scissors s){return f}
   function defeats(Paper p){throw tryagain}
}
class Scissors extends Thing{
   function defeats(Rock r){return f}
   function defeats(Scissors s){throw tryagain}
   function defeats(Paper p){return t}
}

Rock r = new Rock();
Thing rt = new Rock();
Thing pt = new Paper();

pt.defeats(rt);
pt.defeats(r);

In a single dispatch language:

• pt has a dynamic type of paper so pt. will call the methods in the paper object.
• pt.defeats(rt); would throw SingleDispatchException because the parameter rt is of static type Thing.
  
• pt.defeats(r); would return true because the parameter r is of static type Rock
  

In a multiple dispatch language:

• pt has a dynamic type of paper so pt. will call the methods in the paper object.
• pt.defeats(rt); would return true because the parameter rt is of dynamic type Rock.
  
• pt.defeats(r); would return true because the parameter r is of dynamic type Rock
  

Single Dispatch

At a minimum, all Object Oriented languages implement a dynamic dispatch process known as single dispatch (pg2)[2].
In single dispatch:

• A method call considers the dynamic type of only the class that the message is sent to.
• All parameters are treated as static types.

Double Dispatch

Polygon p = new Square(pt1, pt2, pt2, pt4);
3dObject o = new Pyramid(pt3d1,pt3d2,pt3d3,pt3d4,pt3d5);
o.AddPoints(p,plane);

In double dispatch the above would correctly determine that is needs to call Pyramid.AddPoints(Square, Plane).

This method uses single dispatch and the visitor pattern pg(526-530)[3] to simulate a special form of multiple dispatch where the run time types of two arguments are taken into account.

Multiple Dispatch

A few Object Oriented languages implement a more complete dynamic dispatch process known as multiple dispatch (pg2)[2].
In multiple dispatch:

• Like single dispatch, a method call considers the dynamic type of the class that the message is sent to.
• One or more parameters are dynamically accessed at run time.

Note: When multiple dispatch is implemented, the above double dispatch method with be a part of multiple dispatch.

Multiple Dispatch Simulation

Efficient multimethods in a single dispatch Language[2] is a paper that describes several methods that can be used to simulate multi dispatch in a single dispatch language. It also compares the relative performance of each method.

Performance

According to Technical Report on C++ Performance (pg 26)[4] "Calling a virtual function is roughly equivalent to calling a function through a pointer stored in an array"
I interpret this to mean that the speed of single dispatch is roughly the same as the speed of calling a non dispatched method.

Efficient multimethods in a single dispatch Language (pg 16,17)[2] tested the performance of their simulated multiple dispatch methods showing (pg 17): Performanace Comparison

Method	Speed
Single Dispatch	0.20
Double Dispatch	1.00
Multidispatch (3 args)	1.35
Multidispatch (7 args)	2.32

It also shows that other methods such as case statements or dictionary lookup are significantly slower.

MultiJava is a Java language that support multiple dispatch. MultiJava: Design, implementation, and evaluation (pg 89 table 6)[5] shows that in MultiJava the native multiple dispatch methods are 62% faster than simulated double dispatch and 59% faster than simulated multiple dispatch.

Conclusion

The information presented in this article covered all of the different types of run time dispatch. It also demonstrated that the trade off between simulated multiple dispatch and native multiple dispatch is only a factor in an application where a very large number of iterations involving multiple dispatch operations are present.

References

[1] Evaluation of Control Structures for Dynamic Dispatch in Java by Inira Lorraine and Karel Drieson(pg 5)
[2] Efficient Multimethods in a single dispatch Language Brian Foote, Ralph E. Johnson and James Noble
[3] Visitor by Robert C. Martin 2002 pg(526-520)
[4] Technical Report on C++ Performance ISO/IEC TR 18015:2006(E) 2006-02-15 (pg. 26)
[5] MultiJava: Design, implementation, and evaluation Curtis Charles Clifton November 2001(pg 89 table 6)