The dispatch performance should be roughly on par with S3 and S4,
though as this is implemented in a package there is some overhead due to
.Call vs .Primitive.
Text := new_class(parent = class_character)
Number := new_class(parent = class_double)
x <- Text("hi")
y <- Number(1)
foo_S7 := new_generic("x")
method(foo_S7, Text) <- function(x, ...) paste0(x, "-foo")
foo_S3 <- function(x, ...) {
UseMethod("foo_S3")
}
foo_S3.Text <- function(x, ...) {
paste0(x, "-foo")
}
library(methods)
setOldClass(c("Number", "numeric", "S7_object"))
setOldClass(c("Text", "character", "S7_object"))
setGeneric("foo_S4", function(x, ...) standardGeneric("foo_S4"))
#> [1] "foo_S4"
setMethod("foo_S4", c("Text"), function(x, ...) paste0(x, "-foo"))
# Measure performance of single dispatch
bench::mark(foo_S7(x), foo_S3(x), foo_S4(x))
#> # A tibble: 3 × 6
#> expression min median `itr/sec` mem_alloc `gc/sec`
#> <bch:expr> <bch:tm> <bch:tm> <dbl> <bch:byt> <dbl>
#> 1 foo_S7(x) 2.21µs 2.71µs 361659. 0B 36.2
#> 2 foo_S3(x) 901.99ns 1.11µs 816532. 0B 81.7
#> 3 foo_S4(x) 1.02µs 1.23µs 784934. 0B 0
bar_S7 := new_generic(c("x", "y"))
method(bar_S7, list(Text, Number)) <- function(x, y, ...) paste0(x, "-", y, "-bar")
setGeneric("bar_S4", function(x, y, ...) standardGeneric("bar_S4"))
#> [1] "bar_S4"
setMethod("bar_S4", c("Text", "Number"), function(x, y, ...) paste0(x, "-", y, "-bar"))
# Measure performance of double dispatch
bench::mark(bar_S7(x, y), bar_S4(x, y))
#> # A tibble: 2 × 6
#> expression min median `itr/sec` mem_alloc `gc/sec`
#> <bch:expr> <bch:tm> <bch:tm> <dbl> <bch:byt> <dbl>
#> 1 bar_S7(x, y) 4.59µs 5.45µs 182579. 0B 54.8
#> 2 bar_S4(x, y) 2.54µs 3.03µs 326164. 0B 65.2A potential optimization is caching based on the class names, but lookup should be fast without this.
The following benchmark generates a class hierarchy of different levels and lengths of class names and compares the time to dispatch on the first class in the hierarchy vs the time to dispatch on the last class.
We find that even in very extreme cases (e.g. 100 deep hierarchy 100 of character class names) the overhead is reasonable, and for more reasonable cases (e.g. 10 deep hierarchy of 15 character class names) the overhead is basically negligible.
library(S7)
gen_character <- function (n, min = 5, max = 25, values = c(letters, LETTERS, 0:9)) {
lengths <- sample(min:max, replace = TRUE, size = n)
values <- sample(values, sum(lengths), replace = TRUE)
starts <- c(1, cumsum(lengths)[-n] + 1)
ends <- cumsum(lengths)
mapply(function(start, end) paste0(values[start:end], collapse=""), starts, ends)
}
bench::press(
num_classes = c(3, 5, 10, 50, 100),
class_nchar = c(15, 100),
{
# Construct a class hierarchy with that number of classes
Text := new_class(parent = class_character)
parent <- Text
classes <- gen_character(num_classes, min = class_nchar, max = class_nchar)
env <- new.env()
for (x in classes) {
assign(x, new_class(x, parent = parent), env)
parent <- get(x, env)
}
# Get the last defined class
cls <- parent
# Construct an object of that class
x <- do.call(cls, list("hi"))
# Define a generic and a method for the last class (best case scenario)
foo_S7 := new_generic("x")
method(foo_S7, cls) <- function(x, ...) paste0(x, "-foo")
# Define a generic and a method for the first class (worst case scenario)
foo2_S7 := new_generic("x")
method(foo2_S7, S7_object) <- function(x, ...) paste0(x, "-foo")
bench::mark(
best = foo_S7(x),
worst = foo2_S7(x)
)
}
)
#> # A tibble: 20 × 8
#> expression num_classes class_nchar min median `itr/sec` mem_alloc `gc/sec`
#> <bch:expr> <dbl> <dbl> <bch:tm> <bch:tm> <dbl> <bch:byt> <dbl>
#> 1 best 3 15 2.25µs 2.79µs 351992. 0B 70.4
#> 2 worst 3 15 2.34µs 2.79µs 354650. 0B 70.9
#> 3 best 5 15 2.21µs 2.62µs 373131. 0B 74.6
#> 4 worst 5 15 2.3µs 2.79µs 358818. 0B 71.8
#> 5 best 10 15 2.17µs 2.62µs 376193. 0B 75.3
#> 6 worst 10 15 2.42µs 2.91µs 341407. 0B 34.1
#> 7 best 50 15 2.34µs 2.79µs 355180. 0B 35.5
#> 8 worst 50 15 3.2µs 3.81µs 262513. 0B 26.3
#> 9 best 100 15 2.46µs 2.99µs 330044. 0B 66.0
#> 10 worst 100 15 4.3µs 5.04µs 198445. 0B 39.7
#> 11 best 3 100 2.34µs 2.83µs 349229. 0B 69.9
#> 12 worst 3 100 2.3µs 2.79µs 343238. 0B 68.7
#> 13 best 5 100 2.3µs 2.75µs 344661. 0B 68.9
#> 14 worst 5 100 2.54µs 3.08µs 318760. 0B 31.9
#> 15 best 10 100 2.21µs 2.83µs 339766. 0B 68.0
#> 16 worst 10 100 2.87µs 3.36µs 282309. 0B 56.5
#> 17 best 50 100 2.38µs 2.87µs 333758. 0B 33.4
#> 18 worst 50 100 5.29µs 6.07µs 161379. 0B 32.3
#> 19 best 100 100 2.38µs 2.91µs 324539. 0B 64.9
#> 20 worst 100 100 8.28µs 8.98µs 102446. 0B 20.5And the same benchmark using double-dispatch
bench::press(
num_classes = c(3, 5, 10, 50, 100),
class_nchar = c(15, 100),
{
# Construct a class hierarchy with that number of classes
Text := new_class(parent = class_character)
parent <- Text
classes <- gen_character(num_classes, min = class_nchar, max = class_nchar)
env <- new.env()
for (x in classes) {
assign(x, new_class(x, parent = parent), env)
parent <- get(x, env)
}
# Get the last defined class
cls <- parent
# Construct an object of that class
x <- do.call(cls, list("hi"))
y <- do.call(cls, list("ho"))
# Define a generic and a method for the last class (best case scenario)
foo_S7 := new_generic(c("x", "y"))
method(foo_S7, list(cls, cls)) <- function(x, y, ...) paste0(x, y, "-foo")
# Define a generic and a method for the first class (worst case scenario)
foo2_S7 := new_generic(c("x", "y"))
method(foo2_S7, list(S7_object, S7_object)) <- function(x, y, ...) paste0(x, y, "-foo")
bench::mark(
best = foo_S7(x, y),
worst = foo2_S7(x, y)
)
}
)
#> # A tibble: 20 × 8
#> expression num_classes class_nchar min median `itr/sec` mem_alloc `gc/sec`
#> <bch:expr> <dbl> <dbl> <bch:tm> <bch:tm> <dbl> <bch:byt> <dbl>
#> 1 best 3 15 3.03µs 3.69µs 257395. 0B 51.5
#> 2 worst 3 15 3.36µs 4.06µs 233308. 0B 70.0
#> 3 best 5 15 3.12µs 3.81µs 249737. 0B 74.9
#> 4 worst 5 15 3.36µs 4.02µs 240406. 0B 48.1
#> 5 best 10 15 3.2µs 3.85µs 244318. 0B 73.3
#> 6 worst 10 15 3.53µs 4.22µs 224484. 0B 67.4
#> 7 best 50 15 3.36µs 3.98µs 239074. 0B 71.7
#> 8 worst 50 15 5.17µs 6.07µs 161576. 0B 32.3
#> 9 best 100 15 3.65µs 4.35µs 224651. 0B 67.4
#> 10 worst 100 15 7.05µs 8.08µs 124100. 0B 24.8
#> 11 best 3 100 3.32µs 3.94µs 245437. 0B 73.7
#> 12 worst 3 100 3.48µs 4.06µs 245332. 0B 49.1
#> 13 best 5 100 3.36µs 3.9µs 256528. 0B 51.3
#> 14 worst 5 100 3.85µs 4.43µs 207280. 0B 62.2
#> 15 best 10 100 3.12µs 3.77µs 251849. 0B 50.4
#> 16 worst 10 100 4.3µs 4.71µs 201257. 0B 60.4
#> 17 best 50 100 3.32µs 3.77µs 250217. 0B 75.1
#> 18 worst 50 100 9.47µs 9.96µs 94092. 0B 18.8
#> 19 best 100 100 3.65µs 4.1µs 234979. 0B 47.0
#> 20 worst 100 100 16.52µs 17.18µs 54556. 0B 16.4