Performance benefit by using compiled model definitions in mkin

- - - - -

+ + + + + + + + + + + + + + +Performance benefit by using compiled model definitions in mkin + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + + + + + + + + + + + + + +

+ +

+ + + + + + +

Model that can also be solved with Eigenvalues

This evaluation is taken from the example section of mkinfit. When using an mkin version equal to or greater than 0.9-36 and a C compiler (gcc) is available, you will see a message that the model is being compiled from autogenerated C code when defining a model using mkinmod. The mkinmod() function checks for presence of the gcc compiler using

Sys.which("gcc")

Model that can also be solved with Eigenvalues

Sys.which("gcc")

##            gcc 
-## "/usr/bin/gcc"

+## "/usr/bin/gcc"

First, we build a simple degradation model for a parent compound with one metabolite.

library("mkin")

library("mkin")

## Loading required package: minpack.lm

## Loading required package: rootSolve

## Loading required package: inline

## Loading required package: methods

## Loading required package: parallel

SFO_SFO <- mkinmod(
-  parent = mkinsub("SFO", "m1"),
-  m1 = mkinsub("SFO"))

SFO_SFO <- mkinmod(
+  parent = mkinsub("SFO", "m1"),
+  m1 = mkinsub("SFO"))

## Successfully compiled differential equation model from auto-generated C code.

We can compare the performance of the Eigenvalue based solution against the compiled version and the R implementation of the differential equations using the microbenchmark package.

library("microbenchmark")
-library("ggplot2")
-mb.1 <- microbenchmark(
-  "deSolve, not compiled" = mkinfit(SFO_SFO, FOCUS_2006_D,
-                                    solution_type = "deSolve",
-                                    use_compiled = FALSE, quiet = TRUE),
-  "Eigenvalue based" = mkinfit(SFO_SFO, FOCUS_2006_D,
-                               solution_type = "eigen", quiet = TRUE),
-  "deSolve, compiled" = mkinfit(SFO_SFO, FOCUS_2006_D,
-                                solution_type = "deSolve", quiet = TRUE),
-  times = 3, control = list(warmup = 0))

## Warning in microbenchmark(`deSolve, not compiled` = mkinfit(SFO_SFO,
-## FOCUS_2006_D, : Could not measure overhead. Your clock might lack
-## precision.

smb.1 <- summary(mb.1)
-print(mb.1)

## Unit: milliseconds
-##                   expr       min        lq      mean    median        uq
-##  deSolve, not compiled 5185.0893 5231.5690 5266.8769 5278.0487 5307.7706
-##       Eigenvalue based  843.3153  847.1503  876.5398  850.9853  893.1520
-##      deSolve, compiled  723.0636  740.5682  755.9995  758.0729  772.4674
-##        max neval cld
-##  5337.4926     3   b
-##   935.3187     3  a 
-##   786.8620     3  a

autoplot(mb.1)

We see that using the compiled model is by a factor of 7 faster than using the R version with the default ode solver, and it is even faster than the Eigenvalue based solution implemented in R which does not need iterative solution of the ODEs:

rownames(smb.1) <- smb.1$expr
-smb.1["median"]/smb.1["deSolve, compiled", "median"]

##                         median
-## deSolve, not compiled 6.962456
-## Eigenvalue based      1.122564
-## deSolve, compiled     1.000000

We can compare the performance of the Eigenvalue based solution against the compiled version and the R implementation of the differential equations using the benchmark package.

if (require(rbenchmark)) {
+  b.1 <- benchmark(
+    "deSolve, not compiled" = mkinfit(SFO_SFO, FOCUS_2006_D,
+                                      solution_type = "deSolve",
+                                      use_compiled = FALSE, quiet = TRUE),
+    "Eigenvalue based" = mkinfit(SFO_SFO, FOCUS_2006_D,
+                                 solution_type = "eigen", quiet = TRUE),
+    "deSolve, compiled" = mkinfit(SFO_SFO, FOCUS_2006_D,
+                                  solution_type = "deSolve", quiet = TRUE),
+    replications = 3)
+  print(b.1)
+  factor_SFO_SFO <- round(b.1["1", "relative"])
+} else {
+  factor_SFO_SFO <- NA
+  print("R package benchmark is not available")
+}

## Loading required package: rbenchmark

##                    test replications elapsed relative user.self sys.self
+## 3     deSolve, compiled            3   2.040    1.000     2.040        0
+## 1 deSolve, not compiled            3  14.622    7.168    14.624        0
+## 2      Eigenvalue based            3   2.478    1.215     2.480        0
+##   user.child sys.child
+## 3          0         0
+## 1          0         0
+## 2          0         0

We see that using the compiled model is by a factor of around 7 faster than using the R version with the default ode solver, and it is even faster than the Eigenvalue based solution implemented in R which does not need iterative solution of the ODEs.

Model that can not be solved with Eigenvalues

This evaluation is also taken from the example section of mkinfit.

FOMC_SFO <- mkinmod(
-  parent = mkinsub("FOMC", "m1"),
-  m1 = mkinsub( "SFO"))

if (require(rbenchmark)) {
+  FOMC_SFO <- mkinmod(
+    parent = mkinsub("FOMC", "m1"),
+    m1 = mkinsub( "SFO"))
+
+  b.2 <- benchmark(
+    "deSolve, not compiled" = mkinfit(FOMC_SFO, FOCUS_2006_D,
+                                      use_compiled = FALSE, quiet = TRUE),
+    "deSolve, compiled" = mkinfit(FOMC_SFO, FOCUS_2006_D, quiet = TRUE),
+    replications = 3)
+  print(b.2)
+  factor_FOMC_SFO <- round(b.2["1", "relative"])
+} else {
+  factor_FOMC_SFO <- NA
+  print("R package benchmark is not available")
+}

## Successfully compiled differential equation model from auto-generated C code.

mb.2 <- microbenchmark(
-  "deSolve, not compiled" = mkinfit(FOMC_SFO, FOCUS_2006_D,
-                                    use_compiled = FALSE, quiet = TRUE),
-  "deSolve, compiled" = mkinfit(FOMC_SFO, FOCUS_2006_D, quiet = TRUE),
-  times = 3, control = list(warmup = 0))

## Warning in microbenchmark(`deSolve, not compiled` = mkinfit(FOMC_SFO,
-## FOCUS_2006_D, : Could not measure overhead. Your clock might lack
-## precision.

smb.2 <- summary(mb.2)
-print(mb.2)

## Unit: seconds
-##                   expr       min        lq      mean   median        uq
-##  deSolve, not compiled 10.963655 10.992677 11.033360 11.02170 11.068212
-##      deSolve, compiled  1.287898  1.309754  1.322972  1.33161  1.340509
-##        max neval cld
-##  11.114726     3   b
-##   1.349408     3  a

smb.2["median"]/smb.2["deSolve, compiled", "median"]

##   median
-## 1     NA
-## 2     NA

autoplot(mb.2)

Here we get a performance benefit of a factor of 8.3 using the version of the differential equation model compiled from C code!

##                    test replications elapsed relative user.self sys.self
+## 2     deSolve, compiled            3   3.500    1.000     3.500        0
+## 1 deSolve, not compiled            3  29.932    8.552    29.932        0
+##   user.child sys.child
+## 2          0         0
+## 1          0         0

Here we get a performance benefit of a factor of 9 using the version of the differential equation model compiled from C code!

This vignette was built with mkin 0.9.45 on

## R version 3.3.2 (2016-10-31)
+## R version 3.4.0 (2017-04-21)
 ## Platform: x86_64-pc-linux-gnu (64-bit)
 ## Running under: Debian GNU/Linux 8 (jessie)
 ## CPU model: Intel(R) Core(TM) i7-4710MQ CPU @ 2.50GHz


-
-  
-        
-      Contents
-      Model that can also be solved with Eigenvalues
-      Model that can not be solved with Eigenvalues
-      
-      
 
-


 
 
-      
-  Developed by Johannes Ranke.
+


 
-
-  Site built with pkgdown.
 
 
-


+
+
 
-  
+
+
-- 
cgit v1.2.1

Johannes Ranke

2016-12-08

Performance benefit by using compiled model definitions in mkin

Johannes Ranke

2017-05-05

Model that can also be solved with Eigenvalues

Model that can also be solved with Eigenvalues

Model that can not be solved with Eigenvalues

Model that can not be solved with Eigenvalues

Contents