View source for R on the server

The department's Leviathan cluster has R installed on each machine. It also has RStudio Server running on each machine, so there are two ways to run R code.

== Running R on the server ==

=== Command line ===
On the Leviathans, or on other servers that do not support RStudio, log into the server via SSH first. After getting onto the server (see [[Linux_and_department_servers|Linux and the department server]]), you can start using <code>R</code> but opening an interactive session on the console with

<syntaxhighlight lang="bash">R</syntaxhighlight>

You’ll be able to run code (except for visualization as the server can’t display graphics), from the console.

=== RStudio Server ===
RStudio Server is running on each Leviathan. Choose a Leviathan with low usage. For example, suppose you choose <code>leviathan3</code>. Then type the following URL into your web browser:
 <nowiki>http://leviathan3.stat.cmu.edu:8787/</nowiki>
This will open RStudio Server. Use your statistics account (the same one you use to log in via SSH) to log in.

You will be able to use the RStudio files pane to view all your files on the Leviathans. It looks just like RStudio on your own computer. Files are shared across machines, but your RStudio session is specific to the Leviathan you started it on. Return to the same Leviathan to view your running code or output.

== Library Management ==

Compared to your personal computer (and your personal computer using RStudio), installing packages has a few nuances.

<ol>
<li>The first time installing a package, e.g. <syntaxhighlight lang="bash">server$ R

R > install.packages("tidyverse")</syntaxhighlight>
you’ll be asked to set up a local folder to store your files. 
</li>
<li>The server’s version of <code>R</code> may different than you personal computer. It will also occasionally update. This will require you to re-install packages (see[[Renv|<code>Renv</code>’s wiki (R package environments)]]&nbsp;for a way to make this less painful).</li>
<li>Compared to RStudio, you may need to debug package installation and dependence structure. Good luck!</li>
<li>Packages that use C, C++, or Fortran code will try to compile it from scratch, instead of downloading a pre-compiled version (like on Windows or macOS). This may require certain libraries to be installed on the servers; if package installation fails and tells you to use <code>apt</code> to install a library, you'll need to ask for help to install these, as you don't have the power to.
</li>
</ol>

== Running Jobs ==

Beyond just opening up an interactive <code>R</code> session with <code lang="bash">R</code>, you can run files in 2 ways (as described below). 

=== <code>Rscript</code> ===

<code>Rscript</code> is a more commonly used tool to run <code>.R</code> files, as it allows you to pass additional arguments to the file. For example:

<syntaxhighlight lang="bash">Rscript file.R arg1 arg2</syntaxhighlight>

In order to use <code>arg1</code> and <code>arg2</code> in your <code>R</code> code, you’ll access them (as strings) using <code>commandArgs()</code>, for example:
<pre class="{r}">args &lt;- commandArgs(trailingOnly = TRUE)
if (length(args) > 0) {
  first_parameter <- args[1]
  second_parameter <- as.numeric(args[2])
  ...
}</pre>

<code>Rscript</code> also allows for standard output (printed to the terminal while running). 

==== Example uses of arguments ====

Examples of argument values abound in statistical analysis. If you're using [[Slurm]] you may use arguments to parallelize a task. These types of tasks could be running through complicated data observations, examining outcomes across a grid of hyperparameters, etc. It could also be useful to pass in the name of a file to process or folder to pull from.

=== <code>R CMD BATCH</code> ===

<code>R CMD BATCH</code> is an older approach (compared to <code>Rscript</code> you cannot pass in additional arguments nor see printouts to the standard output, but a <code>file_name.Rout</code> file will be generated with all print outs of the code. 

<syntaxhighlight lang="bash">R CMD BATCH file.R</syntaxhighlight>

If you don't have any input arguments to access and want to save errors and messages that came from running your <code>.R</code> file, this might be a better approach.

== Additional useful tools ==

When approaching running code on different servers (and even on your own computer), it may be useful to understand the amount of time an analysis (or a part of an analysis) will run and how much memory it uses. This can help you decide what computing resources you need / what would make your analysis feasible. Knowing this information can also help you decide if you need to make your code more efficient (which can be done with the help of [http://adv-r.had.co.nz/Profiling.html profiles] and potentially C++ functions - link to come soon).

<ol>
<li>'''Estimating time usage''': To measure the amount of time code takes to run, one approach is to put <pre class="{r}">start <- Sys.time()</pre>

at the start and at the end
<pre class="{r}">used_time <- Sys.time() - start
print(used_time)</pre>If you're running a script, you can also use the <code>time</code> command, as in:<syntaxhighlight lang="shell">
time Rscript some_script.R
</syntaxhighlight></li>
<li>'''Understanding memory usage:''' When you are running code in <code>R</code> or RStudio, you can get some understanding of how large an object is (and therefore get a lower bound on your potential RAM usage) using the package <code>pryr</code>. Calling <code>pryr::object_size(object_name)</code> will tell you what the approximate size of the object is. See [http://adv-r.had.co.nz/memory.html adv-r] on the package usage. 

For example,

<syntaxhighlight lang="bash">
R> library(pryr)
R> dm_small <- as.matrix(dist(1:10))
R> object_size(dm_small)
2.1 kB
R> dm_medium <- as.matrix(dist(1:10-))
R> object_size(dm_medium)
87.7 kB
R> dm_large <- as.matrix(dist(1:1000))
R> object_size(dm_large)
8.07 MB
R> dm_large <- as.matrix(dist(1:10000))
R> object_size(dm_large)
801 MB
</syntaxhighlight>

If we did 
<syntaxhighlight lang="bash">
R> dm_large <- as.matrix(dist(1:1000000))
</syntaxhighlight>
we'd expect <code>object_size(dm_large)</code> to be around 80 GB, which should crash your personal computer's <code>R</code>/Rstudio since you probably don't have that much RAM.


<br>

It is possible to also check your amount of RAM usage with OS-centric tools (e.g. Mac's: [https://support.apple.com/guide/activity-monitor/view-memory-usage-actmntr1004/mac Activity Monitor] or Window's: [https://www.crucial.com/articles/about-memory/how-to-check-ram-windows-10 Dask Management]).
</li></ol>

[[Category:IDEs]]
[[Category:Department Servers]]