V2.9.0 changes [Sec=Unclassified]

Well...

My performance problems were in the pass-by-value semantics of R.

I have just changed my classes to inherit from .environment and then moved data members from S4 slots to the .xData objects as Martin suggested.

Of course I haven't seen your code, but a different interpretation of
your performance issues is that, within the rules of S4, you've chosen
to implement functionality in an inefficient way. So it might be
instructive to step back a bit and try to reformulate your data
structures and methods. This is hard to do.

That meant I could remove all my returns and assignments on all method calls.

This has sped execution time for my model up by more than an order of magnitude. Eg one test simulation from 1931 secs down to 175 secs.

Not bad seeing as though the class structure, functionality and logic has not been touched.

I really do think S4 could benfit from having its slots stored in environment when the class enherits from .environment.  It would be a lot more sensible if my data members were still declared as S4 slots instead of having to hide them in .xData

Troy


Troy Robertson
Database and Computing Support Provider
Southern Ocean Ecosystems, ERM/Fish
Australian Antarctic Division
Channel Highway, Kingston 7050
PH: 03 62323571
Troy.Robertson at aad.gov.au

-----Original Message-----
From: Martin Morgan [mailto:mtmorgan at fhcrc.org]
Sent: Tuesday, 23 June 2009 11:25 PM
To: Troy Robertson
Cc: 'r-devel at R-project.org'
Subject: Re: [Rd] V2.9.0 changes [Sec=Unclassified]

Troy Robertson wrote:

Hi all,



Prefix: I am a frustrated Java coder in R.

ah good, if you're frustrated with Java you'll find R very different ;)

I am coding a medium sized ecosystem modelling program in R.  I have

changed to using S4 objects and it has cost me an order of magnitude in
execution speed over the functional model.  I cannot afford this penalty
and have found that it is the result of all the passing-by-value of
objects.

I see that you can now safely inherit from environment in V2.9.0.

That got me all excited that I would now be able to pass objects by

reference.

But...

That doesn't seem to be the case.

It only seem that passing an environment which holds the object allows

for pass-by-reference and that passing an object which inherits from
environment doesn't.

Why is this the case, either an object inherits the properties of its

parent or it doesn't.

The object inherits slots from it's parent, and the methods defined on
the parent class. Maybe this example helps?

setClass("Ticker", contains=".environment")

## initialize essential, so each instance gets its own environment
setMethod(initialize, "Ticker",
          function(.Object, ..., .xData=new.env(parent=emptyenv()))
{
    .xData[["count"]] <- 0
    callNextMethod(.Object, ..., .xData=.xData)
})

## tick: increment (private) counter by n
setGeneric("tick", function(reference, n=1L) standardGeneric("tick"),
           signature="reference")

setMethod(tick, "Ticker", function(reference, n=1L) {
    reference[["count"]] <- reference[["count"]] + n
})

## tock: report current value of counter
setGeneric("tock", function(reference) standardGeneric("tock"))

setMethod(tock, "Ticker", function(reference) {
    reference[["count"]]
})

and then

e <- new("Ticker")
tock(e)

[1] 0

tick(e); tick(e, 10); tock(e)

[1] 11

f <- e
tock(f); tick(e); tock(f)

[1] 11
[1] 12

The data inside .environment could be structured, too, using S4.
Probably it would be more appropriate to have the environment as a slot,
rather the class that is being extended. And in terms of inherited
'properties', e.g., the "[[" function as defined on environments is
available

e[["count"]]

Of course I haven't seen your code, but a different interpretation of
your performance issues is that, within the rules of S4, you've chosen
to implement functionality in an inefficient way. So it might be
instructive to step back a bit and try to reformulate your data
structures and methods. This is hard to do.

Martin

Has anyone else had a play with this?  Or have I got it all wrong.



I tried the below:

------------------------------------------------------------------------

-----------------

setClass('foo', representation=representation(stuff='list',

bar='numeric'),

                     prototype=list(stuff=list(), bar=0),

                     contains='.environment')



setGeneric('doit', function(.Object, newfoo='environment')

standardGeneric('doit'))

setMethod('doit', 'foo', function(.Object, newfoo){newfoo at bar <- 10})



z <- new('foo')



z at stuff$x <- new('foo')



doit(z,z at stuff$x)



z at stuff$x at bar



[1] 0

------------------------------------------------------------------------

------------------

Can anyone help with a better way of doing this.

I'm trying to avoid all the indirection of packing and unpacking

environments for passing.

Thanks heaps



Troy





Troy Robertson

Database and Computing Support Provider

Southern Ocean Ecosystems, ERM/Fish

Australian Antarctic Division

Channel Highway, Kingston 7050

PH: 03 62323571

Troy.Robertson at aad.gov.au