r-env

r-env on Apptainer-kontti, joka sisältää R:n, RStudio Serverin ja useita muita ominaisuuksia niiden käytön helpottamiseksi.

• R on avoimen lähdekoodin kieli ja ympäristö tilastolliseen laskentaan ja grafiikkaan. Lisätietoja R:stä löytyy R Projectin verkkosivuilta. Monet hyödylliset R-oppaat ovat saatavilla myös CRANissa.

• RStudio Server on integroitu kehitysympäristö (IDE) R:lle. Lisätietoja RStudiosta löytyy RStudion verkkosivuilta.

Uutiset

17.2.2026 R-versio 4.5.2 on nyt saatavilla r-env:ssä Puhdissa ja Mahdissa, ja se on asetettu oletusversioksi.

22.7.2025 R-versio 4.5.1 on nyt saatavilla r-env:ssä Puhdissa ja Mahdissa, ja se on asetettu oletusversioksi.

7.4.2025 r-env on nyt saatavilla myös Mahdissa, mukaan lukien RStudio Mahdin selainkäyttöliittymässä. Moduuli toimii yleisesti ottaen samalla tavalla kuin r-env Puhdissa, mutta huomaa, että alla olevaa dokumentaatiota ei ole vielä päivitetty Mahdille. Mahdin uusi pieni osio soveltuu monenlaiseen R- ja RStudio-työskentelyyn kaikkein muistisyöpimpiä tehtäviä lukuun ottamatta. Puhdin käyttäjien kannattaa huomata, että Mahdissa ei ole erillistä muistivarausta, ja ainoa tapa saada lisää muistia on varata enemmän ytimiä. Jos sinulla on kysyttävää R:n käytöstä Mahdissa, ota yhteyttä CSC:n asiakastukeen.

Saatavilla

r-env sisältää yli 1500 esiasennettua R-pakettia, mukaan lukien tuki paikkatietoanalyyseille ja rinnakkaislaskennalle. Suorituskyvyn parantamiseksi r-env on käännetty käyttäen Intel® oneAPI Math Kernel Librarya (oneMKL) (aiemmin Intel® MKL).

Pieniä poikkeuksia lukuun ottamatta r-env:n R-pakettiversiot on päivälukittu (CRAN-paketit) tai kiinnitetty tiettyyn Bioconductor -versioon.

Nykyiset Puhdissa ja Mahdissa tuetut moduulit ja versiot:

Moduulin nimi (R-versio)	Puhti / Mahti	CRAN-pakettien päiväys	Bioconductor-versio	RStudio Serverin versio	oneMKL-versio	CmdStan-versio
r-env/452	X / X	7.1.2026	3.22	2026.01.0-392	2025.3.0	2.38.0
r-env/451	X / X	7.7.2025	3.21	2025.05.1-513	2025.2.0	2.36.0
r-env/442	X / X	12.2.2025	3.20	2024.12.0-467	2025.0.1	2.36.0
r-env/440	X / -	15.5.2024	3.19	2024.04.0-735	2024.1.0	2.35.0
r-env/432	X / -	15.1.2024	3.18	2023.12.0-369	2024.0.0	2.34.1
r-env/430	X / -	07.6.2023	3.17	2023.06.0-421	2023.1.0	2.32.2
r-env/422	X / -	06.3.2023	3.16	2023.03.0-386	2023.1.0	2.32.1
r-env/421	X / -	29.6.2022	3.15	2022.02.3-492	2022.1.0	2.30.1

Muut ohjelmistot ja kirjastot:

• Open MPI (Mellanox OFED™ -ohjelmistolla) 4.1.7 (r-env/451, r-env/452), 4.1.2 (r-env/421:stä r-env/442:een)
• TensorFlow 2.20.0 (r-env/452), 2.19.0 (r-env/451), 2.18.0 (r-env/442), 2.9.1 (r-env/421:stä r-env/440:een)
• cget 0.2.0

Lisenssit

• Tietoa R:n ja siihen liittyvien ohjelmistojen (mukaan lukien paketit) käytössä olevista lisensseistä löytyy R Projectin verkkosivuilta. Paketin tarkan lisenssin voi tarkistaa myös R:n sisällä: packageDescription("package", fields="License"). Lisätietoja R:n ja eri R-pakettien siteeraamisesta (sivun alareunassa).

• RStudio Server -asennus perustuu Open Source Editioniin (saatavilla AGPL v3 -lisenssillä). Tutustu myös RStudio End User License Agreementiin.

• Open MPI jaetaan 3-lausekkeen BSD-lisenssillä (lisätiedot Open MPI:n verkkosivuilla).

• Mellanox OFED™ perustuu OFED™:iin (saatavilla kaksoislisenssillä BSD tai GPL 2.0) sekä suljettuihin komponentteihin (katso Mellanox OFED™ End-User Agreement).

• Intel® MKL jaetaan Intel Simplified Software License -lisenssillä.

• NVIDIA NCCL jaetaan 3-lausekkeen BSD-lisenssillä.

• NVIDIA cuDNN jaetaan Software License Agreement for NVIDIA software development kits -lisenssillä.

• cget on saatavilla Boost Software License -lisenssillä.

• CmdStan jaetaan 3-lausekkeen BSD-lisenssillä.

Lisenssitiedot r-env-kontissa ovat saatavilla tiedostossa /usr/licensing.txt.

Käyttö

r-env-moduulia voi käyttää Puhdissa usealla tavalla:

• Ei-interaktiiviset eräajot ilman varattuihin laskentaresursseihin kohdistuvia rajoituksia (muita kuin ne, jotka koskevat Puhtia yleisesti). Käytä tätä vaihtoehtoa analyyseihin, jotka kestävät pitkään tai vaativat paljon muistia.
• Interaktiiviset työt laskentasolmulla, käyttäen joko R-konsolia tai RStudio Serveriä. Käytä tätä vaihtoehtoa koodin valmisteluun ja pienempiin analyyseihin. Interaktiivisissa töissä resurssit voivat olla rajalliset.
• Interaktiivisesti kirjautumissolmulla käyttäen R-konsolia. Käytä tätä vaihtoehtoa vain datan siirtämiseen, pakettien saatavuuden tarkistamiseen ja pakettien asentamiseen. Puhdin kirjautumissolmut eivät ole tarkoitettu raskaisiin laskentoihin.

Interaktiivinen käyttö laskentasolmulla

Komentotulkki-istunnon käynnistäminen interactive-osiolla

Jotta voit käyttää R:ää interaktiivisesti Puhdin laskentasolmuilla, avaa komentotulkki-istunto interactive-osiolla komennolla sinteractive. Esimerkiksi alla oleva komento käynnistäisi istunnon, jossa on 4 Gt muistia ja 10 Gt paikallista scratch-tilaa.

sinteractive --account <project> --mem 4000 --tmp 10

On myös mahdollista määrittää muita asetuksia, mukaan lukien ajoaika (katso sinteractive-dokumentaatio).

R-konsolin käynnistäminen

Kun olet avannut interaktiivisen komentotulkki-istunnon, voit käynnistää R:n komentoriviversion seuraavasti (huomaa, että komento täytyy suorittaa laskentasolmulla):

module load r-env
start-r

RStudio Serverin käyttö

r-env-moduulia voidaan käyttää RStudio Serverin etäkäynnistämiseen verkkoselaimessa. Tähän on kaksi vaihtoehtoa.

Vaihtoehto 1. Puhdin selainkäyttöliittymän käyttö. Tämä on ylivoimaisesti helpoin tapa käynnistää RStudio Puhdissa. Lisätietoja löytyy Puhdin selainkäyttöliittymän dokumentaatiosta.

Vaihtoehto 2. SSH-tunneloinnin käyttö. Tämä vaihtoehto vaatii tunnistautumisen Secure Shell (SSH) -avaimella. Tarkat ohjeet löytyvät erillisestä RStudio Serverin käyttöoppaasta sekä Windowsin, macOS:n ja Linuxin SSH-avainten käyttöönottoa koskevasta dokumentaatiostamme.

Interaktiivinen käyttö kirjautumissolmulla

Käynnistä R-konsoli kirjautumissolmulla suorittamalla seuraavat komennot:

module load r-env
apptainer_wrapper exec R --no-save

# Note: this issues a warning mentioning that apptainer_wrapper
# is meant for use on a compute node. However, R will still launch
# as intended. 

Ei-interaktiivinen käyttö

Interaktiivisten töiden lisäksi R-skriptejä voidaan ajaa ei-interaktiivisesti eräajotiedostojen avulla. Seuraavien esimerkkien lisäksi katso tästä linkistä lisätietoja. Eräajotiedostot voidaan lähettää eräajo järjestelmään seuraavasti:

sbatch batch_job_file.sh

Sarjalliset eräajot

Alla on esimerkki yksiprosessorisen R-eräajon lähettämisestä Puhdissa. Huomaa, että käytössä on test-osio, jonka aikaraja on 15 minuuttia ja jota käytetään vain testaustarkoituksiin. Useimmat R-ajot kannattaa suorittaa small-osiossa. Muisti-intensiivisissä ei-interaktiivisissa töissä meidän tulisi lisäksi määrittää projektikohtainen väliaikaishakemisto polkuun /scratch/<project>. Suoritamme työn myös komennolla apptainer_wrapper.

#!/bin/bash -l
#SBATCH --job-name=r_serial
#SBATCH --account=<project>
#SBATCH --output=output_%j.txt
#SBATCH --error=errors_%j.txt
#SBATCH --partition=test
#SBATCH --time=00:05:00
#SBATCH --ntasks=1
#SBATCH --nodes=1
#SBATCH --mem-per-cpu=1000

# Load r-env
module load r-env

# Clean up .Renviron file in home directory
if test -f ~/.Renviron; then
    sed -i '/TMPDIR/d' ~/.Renviron
fi

# Specify a temp folder path
echo "TMPDIR=/scratch/<project>" >> ~/.Renviron

# Run the R script
srun apptainer_wrapper exec Rscript --no-save myscript.R

Yllä olevassa esimerkissä yksi tehtävä (--ntasks=1) suoritetaan 1 Gt:n muistilla (--mem-per-cpu=1000) ja työlle varataan viiden minuutin ajoaika (--time=00:05:00).

Rinnakkaiset eräajot

r-env-moduulia voidaan käyttää rinnakkaislaskentaan useilla tavoilla. Näihin kuuluvat moniydin- ja taulukkotyöt sekä MPI (Message Passing Interface) -pohjaiset työt. Moduulin mukana tulee useita paketteja, jotka tukevat monisolmuviestintää MPI:n kautta: doMPI (käytetään yhdessä foreach:n kanssa), future, pbdMPI ja snow.

Seuraavien esimerkkien lisäksi katso erillinen rinnakkaisten R-töiden opas. Saatavilla on myös erillinen dokumentaatio MPI-töistä. Kannattaa myös tutustua asiaankuuluvien R-pakettien oppaisiin ja tähän sivuun, jossa on esimerkkejä rinnakkaislaskennasta raster-paketilla.

Note

Jos työ käyttää Rmpi-pakettia, käytä snow-pakettia (joka on rakennettu Rmpi:n päälle). Pelkkää Rmpi:tä käyttävät työt eivät ole saatavilla yhteensopivuusongelmien vuoksi.

Moniydintyöt

Jos halutaan lähettää työ, joka käyttää useita ytimiä yhdellä solmulla, voidaan käyttää seuraavaa eräajotiedostoa. Työ varaa yhden tehtävän (--ntasks=1), kahdeksan ydintä (--cpus-per-task=8) ja yhteensä 8 Gt muistia (--mem-per-cpu=1000). Ajoaika on rajoitettu viiteen minuuttiin.

#!/bin/bash -l
#SBATCH --job-name=r_multicore
#SBATCH --account=<project>
#SBATCH --output=output_%j.txt
#SBATCH --error=errors_%j.txt
#SBATCH --partition=test
#SBATCH --time=00:05:00
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=8
#SBATCH --nodes=1
#SBATCH --mem-per-cpu=1000

# Load r-env
module load r-env

# Clean up .Renviron file in home directory
if test -f ~/.Renviron; then
    sed -i '/TMPDIR/d' ~/.Renviron
fi

# Specify a temp folder path
echo "TMPDIR=/scratch/<project>" >> ~/.Renviron

# Run the R script
srun apptainer_wrapper exec Rscript --no-save myscript.R

Taulukkotyöt

Taulukkotöitä voidaan käyttää embarrassingly parallel -tehtävien käsittelyyn. Alla oleva skripti lähettäisi työn, jossa on kymmenen osatehtävää small-osiossa, ja kukin niistä vaatii alle viisi minuuttia laskenta-aikaa ja alle 1 Gt muistia.

#!/bin/bash -l
#SBATCH --job-name=r_array
#SBATCH --account=<project>
#SBATCH --output=output_%j_%a.txt
#SBATCH --error=errors_%j_%a.txt
#SBATCH --partition=small
#SBATCH --time=00:05:00
#SBATCH --array=1-10
#SBATCH --ntasks=1
#SBATCH --nodes=1
#SBATCH --mem-per-cpu=1000

# Load r-env
module load r-env

# Clean up .Renviron file in home directory
if test -f ~/.Renviron; then
    sed -i '/TMPDIR/d' ~/.Renviron
fi

# Specify a temp folder path
echo "TMPDIR=/scratch/<project>" >> ~/.Renviron

# Run the R script
srun apptainer_wrapper exec Rscript --no-save myscript.R $SLURM_ARRAY_TASK_ID

Laajamittaisemmissa taulukkotöissä, joissa on paljon pieniä itsenäisiä ajoja, voisimme harkita seuraavaa esimerkkiä. Oletetaan, että meillä on yhteensä 1500 ajoa, jotka haluamme suorittaa. Meillä on myös lista (mylist.txt), jossa on jokaiselle ajolle yksilöllinen tunniste ja jota haluamme käyttää osana R-skriptiä oikean analysoitavan aineiston hakemiseen. Lista on järjestetty riveittäin näin:

set1
set2
set3
(...)
set1500

Jotta analyysi suoritettaisiin tehokkaasti, voisimme hyödyntää moduulia, joka sisältää GNU parallelin, ajojen "aikatauluttamiseen" taulukkotyön sisällä. Alla olevasta eräajotiedostosta kannattaa huomata muutama yksityiskohta:

• Tapa, jolla ajot jaetaan taulukoihin, riippuu tapauksesta ja vaatii manuaalista laskentaa. Tässä esimerkissä, koska mylist.txt sisältää 1500 tunnistetta ja käytämme 10 taulukkoa, on päätetty kohdistaa 150 ajoa per taulukko.

• Käytämme -j $SLURM_CPUS_PER_TASK -k kertoaksemme GNU parallelille, että sen tulee pitää 4 sovellusta käynnissä rinnakkain ja samalla varmistaa, että työn tulostusjärjestys vastaa syötejärjestystä. Samanaikaisten rinnakkaisten sovellusten määrä määritellään asetuksella --cpus-per-task.

• Todellisessa analyysissä tarvitsisimme todennäköisesti paljon enemmän aikaa ja muistia (sen mukaan, mitä teemme R-skriptissä).

#!/bin/bash -l
#SBATCH --job-name=r_array_gnupara
#SBATCH --account=<project>
#SBATCH --output=output_%j_%a.txt
#SBATCH --error=errors_%j_%a.txt
#SBATCH --partition=small
#SBATCH --time=00:05:00
#SBATCH --array=0-9
#SBATCH --ntasks=1
#SBATCH --nodes=1
#SBATCH --mem-per-cpu=1000
#SBATCH --cpus-per-task=4

# Load parallel and r-env
module load parallel/20200122
module load r-env

# Clean up .Renviron file in home directory
if test -f ~/.Renviron; then
    sed -i '/TMPDIR/d' ~/.Renviron
fi

# Specify a temp folder path
echo "TMPDIR=/scratch/<project>" >> ~/.Renviron

# Split runs into arrays and run the R script
(( from_run = SLURM_ARRAY_TASK_ID * 150 + 1 ))
(( to_run = SLURM_ARRAY_TASK_ID * 150 + 150 ))

sed -n "${from_run},${to_run}p" mylist.txt | \
    parallel -j $SLURM_CPUS_PER_TASK -k \
        apptainer_wrapper exec Rscript --no-save myscript.R \
                $SLURM_ARRAY_TASK_ID

Jos haluaisimme käyttää R-skriptissä sekä yksilöllistä ajotunnistetta että taulukon numeroa, voisimme käyttää commandArgs-funktiota.

# For example:
arrays <- commandArgs(trailingOnly = TRUE)

Työt, joissa käytetään doMPI:tä (yhdessä foreach:n kanssa)

foreach-paketti toteuttaa for-silmukan, joka käyttää iteraattoreita ja mahdollistaa rinnakkaisen suorituksen %dopar%-operaattorilla. Rinnakkaisia foreach-silmukoita on mahdollista suorittaa Puhdissa doMPI-paketin avulla. Vaikka eräajotiedosto on muuten samanlainen kuin moniprosessorityössä, korvaamme --cpus-per-task=8 asetuksella --ntasks=8. Lisäksi voisimme muokata eräajotiedoston lopussa olevaa srun-komentoa:

srun apptainer_wrapper exec Rscript --no-save --slave myscript.R

Argumentti --slave on valinnainen ja estää eri prosesseja tulostamasta tervetuloviestiä jne.

Toisin kuin snow:ta käytettäessä, doMPI:tä käyttävät työt käynnistävät yhtä monta R-istuntoa kuin varattuja ytimiä on, ja kaikki alkavat suorittaa annettua R-skriptiä. On tärkeää sisällyttää startMPIcluster()-kutsu lähelle R-skriptin alkua, koska kaikki sitä edeltävä suoritetaan kaikissa käytettävissä olevissa prosesseissa (kun taas vain master-prosessi jatkaa sen jälkeen). Suorituksen päätyttyä klusteri suljetaan closeCluster()-funktiolla. Tämän jälkeen mpi.quit()-funktiota voidaan käyttää MPI-suoritusympäristön lopettamiseen ja R:n sulkemiseen:

library(doMPI, quietly = TRUE)
cl <- startMPIcluster()
registerDoMPI(cl)

system.time(a <- foreach(i = 1:7) %dopar% system.time(sort(runif(1e7))))
a

closeCluster(cl)
mpi.quit()

Työt, joissa käytetään snow:ta

Kun useimmat r-env-moduulia käyttävät rinnakkaiset R-työt voidaan lähettää komennolla srun apptainer_wrapper exec Rscript, snow-pakettia käyttävät työt täytyy suorittaa erillisellä komennolla (RMPISNOW). snow perustuu viestintämalliin, jossa master-prosessia käytetään muiden prosessien (workerien) ohjaamiseen. Tämän vuoksi eräajotiedostossa on määritettävä yksi tehtävä enemmän kuin suunniteltu snow-workerien määrä, koska master tarvitsee oman tehtävänsä. Esimerkiksi työ, joka tarvitsee seitsemän workeria, voitaisiin lähettää seuraavasti:

#!/bin/bash -l
#SBATCH --job-name=r_snow
#SBATCH --account=<project>
#SBATCH --output=output_%j.txt
#SBATCH --error=errors_%j.txt
#SBATCH --partition=test
#SBATCH --time=00:05:00
#SBATCH --ntasks=8
#SBATCH --nodes=1
#SBATCH --mem-per-cpu=1000

# Load r-env
module load r-env

# Clean up .Renviron file in home directory
if test -f ~/.Renviron; then
    sed -i '/TMPDIR/d' ~/.Renviron
fi

# Specify a temp folder path
echo "TMPDIR=/scratch/<project>" >> ~/.Renviron

# Run the R script
srun apptainer_wrapper exec RMPISNOW --no-save --slave -f myscript.R

Toisin kuin foreach:n ja doMPI:n kanssa, tässä vain master-prosessi suorittaa R-skriptin. R-skriptin täytyy sisältää kutsu getMPIcluster(), jota käytetään viittauksen luomiseen klusteriin ja joka voidaan sitten välittää muille funktioille. Analyysin päätyttyä klusteri pysäytetään stopCluster()-funktiolla. Esimerkiksi:

cl <- getMPIcluster()

funtorun <- function(k) {
  system.time(sort(runif(1e7)))
}

system.time(a <- clusterApply(cl, 1:7, funtorun))
a

stopCluster(cl)

Työt, joissa käytetään future:a

future-paketti tarjoaa API:n futureja käyttäville R-töille (katso lisätietoja future-paketin CRAN-sivulta). Se, ratkaistaanko futuret peräkkäin vai rinnakkain, määritellään plan()-funktiolla.

Yhdelle solmulle vaativiin analyyseihin sopivat plan(multisession) ja plan(multicore). Ensimmäinen käynnistää useita itsenäisiä R-prosesseja ja jälkimmäinen haarauttaa olemassa olevan R-prosessin. plan(cluster) sopii useita solmuja käyttävään työskentelyyn.

Jos halutaan lähettää työ, joka käyttää multisession- tai multicore-futureja, tulee määrittää yksi solmu (--nodes=1), yksi tehtävä (--ntasks=1) ja ytimien määrä (--cpus-per-task=x; 40 on enimmäismäärä yhdellä solmulla). Oletuksena workerien määrä on availableCores()-funktion palauttama ytimien määrä. Ohjeita eräajotiedostojen suunnitteluun löytyy tämän sivun muista esimerkeistä.

Alla olevaa R-skriptiä voisi käyttää analyysiaikojen vertaamiseen sequential-, multisession- ja multicore-strategioilla.

library(future)
library(tictoc)
library(furrr)

# Different future plans (choose one) 
# (Note: three cores and thus three workers were used in this example)

# plan(sequential)
# plan(multisession)
# plan(multicore)

# Analysis timing

tic()
nothingness <- future_map(c(2, 2, 2), ~Sys.sleep(.x))
toc()

# sequential: 6.157 sec
# multisession: 2.463 sec
# multicore: 2.212 sec

Monisolmuanalyyseissä, joissa käytetään plan(cluster), työ voidaan lähettää snow-paketin avulla. Koska käytämme snow:ta, R täytyy käynnistää RMPISNOW:lla, ja meidän tulee määrittää riittävästi tehtäviä sekä master- että worker-prosesseille (katso 'Työt, joissa käytetään snow:ta'). Jotta future toimisi snow:n kanssa, R-skriptiin täytyy sisällyttää myös seuraavat rivit:

library(future)

cl <- getMPIcluster()
plan(cluster, workers = cl)

# Analysis here

stopCluster(cl)

Käytännön esimerkkejä töistä, joissa käytetään plan(cluster)- ja plan(multicore) -asetuksia rasteridatan kanssa, löytyy tältä sivulta.

Työt, joissa käytetään pbdMPI:tä

Analyyseissä, joissa käytetään pbdMPI-pakettia, jokainen prosessi suorittaa saman kopion ohjelmasta kuin kaikki muutkin prosessit, mutta omalla datallaan. Toisin sanoen erillistä master-prosessia ei ole kuten snow- tai doMPI-töissä. pbdMPI:tä käyttävien eräajojen suorittaminen onnistuu komennolla srun apptainer_wrapper exec Rscript. Esimerkiksi voisimme lähettää työn, jossa on neljä tehtävää jaettuna kahdelle solmulle (kummallekin solmulle kohdistetaan kaksi tehtävää):

#!/bin/bash -l
#SBATCH --job-name=r_pbdmpi
#SBATCH --account=<project>
#SBATCH --output=output_%j.txt
#SBATCH --error=errors_%j.txt
#SBATCH --partition=test
#SBATCH --time=00:05:00
#SBATCH --ntasks-per-node=2
#SBATCH --nodes=2
#SBATCH --mem-per-cpu=1000

# Load r-env
module load r-env

# Clean up .Renviron file in home directory
if test -f ~/.Renviron; then
    sed -i '/TMPDIR/d' ~/.Renviron
fi

# Specify a temp folder path
echo "TMPDIR=/scratch/<project>" >> ~/.Renviron

# Run the R script
srun apptainer_wrapper exec Rscript --no-save --slave myscript.R

Esimerkiksi tätä eräajotiedostoa voitaisiin käyttää seuraavan "hello world" -skriptin suorittamiseen (alkuperäinen versio on saatavilla pbdMPI-paketin GitHub-repositoriossa). init()-funktio alustaa MPI-kommunikaattorit, kun taas finalize()-funktiota käytetään niiden sulkemiseen ja R:stä poistumiseen.

library(pbdMPI, quietly = TRUE)

init()

message <- paste("Hello from rank", comm.rank(), "of", comm.size())
comm.print(message, all.rank = TRUE, quiet = TRUE)

finalize()

Suorituskyvyn parantaminen säikeistyksellä

r-env on käännetty käyttäen Intel® Math Kernel Librarya (MKL), mikä mahdollistaa data-analyysitehtävien suorittamisen useilla säikeillä. Lisätietoja säikeistyksestä löytyy Intel®:n verkkosivuilta.

Oletuksena r-env on yksisäikeinen. Vaikka käyttäjät voivat asettaa työlle halutun säiemäärän, tämän hyödyt laskenta-aikojen kannalta riippuvat analyysistä. Siksi suosittelemme kokeilemaan eri säiemääriä ja vertailemaan suorituskykyä pienellä esimerkkiaineistolla sekä esimerkiksi R-paketilla microbenchmark.

Note

Huomaa, että pelkkä resurssien lisääminen ei välttämättä takaa nopeampaa laskentaa!

Moduuli käyttää OpenMP-säikeistysteknologiaa, ja säikeiden määrää voidaan hallita ympäristömuuttujalla OMP_NUM_THREADS. Käytännössä säikeiden määrä asetetaan vastaamaan työn käyttämien ytimien määrää. Koska r-env perustuu Apptainer-konttiin, OpenMP-säikeiden määrää määritettäessä täytyy käyttää ympäristömuuttujaa APPTAINERENV_OMP_NUM_THREADS.

Alla on esimerkki eräajoskriptistä. Tässä lähetämme työn, joka käyttää kahdeksaa ydintä (ja siten kahdeksaa säiettä) yhdellä solmulla. Huomaa, kuinka sovitamme säikeiden ja ytimien määrän yhteen käyttämällä APPTAINERENV_OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK. Käyttämällä APPTAINERENV_OMP_PLACES=cores sidomme jokaisen säikeen yhteen ytimeen. Käytämme myös APPTAINERENV_OMP_PROC_BIND=close varmistaaksemme, että säikeet sijoitetaan mahdollisimman lähelle toisiaan (jotta säikeiden välinen viestintä olisi nopeampaa). Huomaa, että muitakin vaihtoehtoja säieaffiniteetin hallintaan on saatavilla analyysistä riippuen.

#!/bin/bash -l
#SBATCH --job-name=r_multithread
#SBATCH --account=<project>
#SBATCH --output=output_%j.txt
#SBATCH --error=errors_%j.txt
#SBATCH --partition=small
#SBATCH --time=00:05:00
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=8
#SBATCH --nodes=1
#SBATCH --mem-per-cpu=2000

# Load r-env
module load r-env

# Clean up .Renviron file in home directory
if test -f ~/.Renviron; then
    sed -i '/TMPDIR/d' ~/.Renviron
fi

# Specify a temp folder path
echo "TMPDIR=/scratch/<project>" >> ~/.Renviron

# Match thread and core numbers
export APPTAINERENV_OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK

# Thread affinity control
export APPTAINERENV_OMP_PLACES=cores
export APPTAINERENV_OMP_PROC_BIND=close

# Run the R script
srun apptainer_wrapper exec Rscript --no-save myscript.R

Moniytimisessä interaktiivisessa työssä säikeiden määrä voidaan sovittaa automaattisesti ytimien määrään suorittamalla start-r- tai start-rstudio-server-komentojen monisäikeinen versio:

start-r-multithread # or
start-rstudio-server-multithread

OpenMP / MPI -hybridityöt

Sen lisäksi, että monisäikeisiä R-töitä suoritetaan yhdellä solmulla, niitä voidaan ajaa myös useilla solmuilla. Tällöin on määritettävä seuraavien lukumäärä:

• Solmut (--nodes)

• MPI-prosessit per solmu (--ntasks-per-node)

• Kunkin MPI-prosessin käyttämät OpenMP-säikeet (--cpus-per-task)

Kun nämä listataan eräajotiedostossa, huomaa, että --ntasks-per-node × --cpus-per-task täytyy olla pienempi tai yhtä suuri kuin 40 (Puhdin yhden solmun käytettävissä olevien ytimien enimmäismäärä). Suurissa monisolmutöissä pyri käyttämään täysiä solmuja eli kaikkia 40 ydintä jokaisessa solmussa. Sopivan OpenMP-säiemäärän valinnan lisäksi optimaalisen MPI-prosessien määrän ja jaon löytäminen vaatii kokeilua, koska nämä ovat työkohtaisia.

Esimerkkinä OpenMP / MPI -hybridityöstä alla oleva lähetys käyttäisi yhteensä neljää MPI-prosessia (kaksi tehtävää per solmu ja kaksi varattua solmua), ja kukin prosessi käyttäisi kahdeksaa OpenMP-säiettä. Kokonaisuudessaan työ käyttäisi 32 ydintä (--cpus-per-task × --ntasks-per-node × --nodes). Kuten yhdellä solmulla ajettavissa monisäikeisissä töissä, säikeiden ja ytimien määrä sovitetaan yhteen käyttämällä APPTAINERENV_OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK. Käytämme myös samoja muuttujia säieaffiniteetin hallintaan.

#!/bin/bash -l
#SBATCH --job-name=r_multithread_multinode
#SBATCH --account=<project>
#SBATCH --output=output_%j.txt
#SBATCH --error=errors_%j.txt
#SBATCH --partition=test
#SBATCH --time=00:05:00
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=2
#SBATCH --cpus-per-task=8
#SBATCH --mem-per-cpu=2000

# Load r-env
module load r-env

# Clean up .Renviron file in home directory
if test -f ~/.Renviron; then
 sed -i '/TMPDIR/d' ~/.Renviron
fi

# Specify a temp folder path
echo "TMPDIR=/scratch/<project>" >> ~/.Renviron

# Match thread and core numbers
export APPTAINERENV_OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK

# Thread affinity control
export APPTAINERENV_OMP_PLACES=cores
export APPTAINERENV_OMP_PROC_BIND=close

# Run the R script
srun apptainer_wrapper exec Rscript --no-save myscript.R

Nopean paikallisen tallennustilan käyttö

I/O-intensiivisissä analyyseissä nopeaa paikallista tallennustilaa voidaan käyttää ei-interaktiivisissa eräajoissa pienin muutoksin eräajotiedostoon. Interaktiiviset R-työt käyttävät nopeaa paikallista tallennustilaa oletuksena.

Alla on esimerkki sarjallisesta eräajosta, joka käyttää 10 Gt nopeaa paikallista tallennustilaa (--gres=nvme:10). Tässä väliaikaishakemisto määritetään ympäristömuuttujalla TMPDIR, toisin kuin aiemmissa esimerkeissä, joissa se asetettiin arvoon /scratch/<project>.

#!/bin/bash -l
#SBATCH --job-name=r_serial_fastlocal
#SBATCH --account=<project>
#SBATCH --output=output_%j.txt
#SBATCH --error=errors_%j.txt
#SBATCH --partition=test
#SBATCH --time=00:05:00
#SBATCH --ntasks=1
#SBATCH --nodes=1
#SBATCH --mem-per-cpu=1000
#SBATCH --gres=nvme:10

# Load the module
module load r-env

# Clean up .Renviron file in home directory
if test -f ~/.Renviron; then
    sed -i '/TMPDIR/d' ~/.Renviron
fi

# Specify NVMe temp folder path
echo "TMPDIR=$TMPDIR" >> ~/.Renviron

# Run the R script
srun apptainer_wrapper exec Rscript --no-save myscript.R

Väliaikaistiedostojen tallennuksen lisäksi analysoitavat aineistot voidaan tallentaa nopealle paikalliselle levylle sijaintiin, jonka muuttuja LOCAL_SCRATCH määrittää. Jotta R löytää datasi, sinun täytyy ilmoittaa tämä sijainti R-skriptissäsi. Kun olet käynnistänyt R:n, voit tulostaa sijainnin seuraavalla komennolla:

Sys.getenv("LOCAL_SCRATCH")

R-rajapinta TensorFlow’hun

r-env-moduuli tukee GPU-kiihdytettyjä TensorFlow-töitä käyttäen R-rajapintaa TensorFlow’hun. Jos tarvitset vain TensorFlow’n ilman pääsyä R:ään, käytä jotakin saatavilla olevista TensorFlow-moduuleista Puhdissa. Yleistä tietoa GPU-töiden lähettämisestä löytyy tästä oppaasta. Huomaa, että r-env sisältää CUDA- ja cuDNN-kirjastot, joten CUDA- ja cuDNN-moduuleja ei tarvitse ladata erikseen.

Jotta voit lähettää GPU-työn käyttäen R-rajapintaa TensorFlow’hun, sinun täytyy käyttää GPU-osiota ja määrittää GPU:iden tyyppi ja määrä --gres-lipulla. Lopusta huolehtii R-skripti (katso esimerkkejä tältä sivulta). Alla olevassa skriptissä varaisimme yhden GPU:n ja 10 CPU:ta yhdellä solmulla:

#!/bin/bash -l
#SBATCH --job-name=r_tensorflow
#SBATCH --account=<project>
#SBATCH --output=output_%j.txt
#SBATCH --error=errors_%j.txt
#SBATCH --partition=gpu
#SBATCH --time=01:00:00
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=10
#SBATCH --nodes=1
#SBATCH --gres=gpu:v100:1

# Load the module
module load r-env

# Clean up .Renviron file in home directory
if test -f ~/.Renviron; then
    sed -i '/TMPDIR/d' ~/.Renviron
fi

# Specify a temp folder path
echo "TMPDIR=/scratch/<project>" >> ~/.Renviron

# Run the R script
srun apptainer_wrapper exec Rscript --no-save myscript.R

Huomaa, että interaktiivista työskentelyä GPU-kiihdytyksellä (esim. RStudion kanssa) ei tueta.

GPU-kiihdytys NVBLASilla

r-env voidaan määrittää käyttämään NVIDIA NVBLASia, joka on GPU-tuettu suoraan korvaava BLAS-toteutus useille BLAS3-rutiineille (lisätietoja NVBLASin verkkosivuilla). Rutiinit, joita NVBLAS ei tue, ohjataan varakirjastoon eli r-env-moduulin tapauksessa oneMKL:ään.

CPU-töihin verrattuna NVBLAS voi tarjota nopeusetuja ilman muutoksia varsinaiseen R-koodiin. Hyödyt ovat kuitenkin vahvasti analyysikohtaisia. Lisäksi NVBLAS-työt hyödyntävät GPU-osion varauksia epäoptimaalisesti, koska vain tietyt operaatiot ohjataan GPU:lle.

Ennen NVBLAS-työn suorittamista tutustu Puhdin GPU-solmujen käyttöehtoihin ja tähän tarkistuslistaan:

• Ovatko BLAS3-rutiinit työvuosi tärkein pullonkaula?
• Onko nopeutuksia mahdollista saavuttaa muilla tavoilla (esim. kirjoittamalla koodia uudelleen)?
• Voidaanko tietyt skriptin osat ajaa CPU-osiolla GPU-osion sijaan?

NVBLASia voidaan käyttää seuraavasti:

Vaihe 1. Luo tiedosto nimeltä nvblas.conf hakemistoon ~/nvblas seuraavalla sisällöllä:

NVBLAS_LOGFILE nvblas.log
NVBLAS_GPU_LIST ALL
NVBLAS_TRACE_LOG_ENABLED
NVBLAS_CPU_BLAS_LIB /opt/intel/oneapi/mkl/2022.1.0/lib/intel64/libmkl_rt.so

Huomaa, että yllä lueteltu CPU BLAS -kirjasto on erityinen versiolle r-env/421. Rivin NVBLAS_TRACE_LOG_ENABLED lisääminen on valinnaista ja saa NVBLASin luomaan listan kaikista siepatuista BLAS-kutsuista virheenjäljitystä varten.

Vaihe 2. Lisää seuraavat rivit GPU-eräajotiedostoosi:

# Use NVBLAS
export APPTAINERENV_LD_PRELOAD=/usr/local/cuda/targets/x86_64-linux/lib/libnvblas.so
export APPTAINERENV_NVBLAS_CONFIG_FILE=~/nvblas/nvblas.conf

r-env:n käyttö Stanin kanssa

r-env-moduuli sisältää useita paketteja, jotka hyödyntävät Stania tilastolliseen mallinnukseen.

Note

Säieaffiniteettimuuttujan APPTAINERENV_OMP_PLACES=cores on havaittu häiritsevän rinnakkaisia töitä, joissa käytetään rstan-pakettia. Suosittelemme tällä hetkellä, että tätä muuttujaa ei käytetä rinnakkaisissa Stania käyttävissä R-töissä.

R:n käyttö CmdStan-taustaohjelmalla

r-env-moduulin mukana tulee erillinen CmdStan -asennus, joka on moduuliversiokohtainen. Sen käyttämiseksi täytyy asettaa oikea polku CmdStaniin käyttäen cmdstanr:ää. Esimerkiksi versiolle r-env/452 tämä tehtäisiin seuraavasti:

cmdstanr::set_cmdstan_path("/appl/soft/math/r-env/452-stan/cmdstan-2.38.0")

Jos käytät CmdStania interaktiivisessa istunnossa, yllä oleva komento toimii suoraan. Ei-interaktiivisissa eräajoissa polku CmdStaniin täytyy asettaa erikseen eräajotiedostossa. Tämä tehdään lisäämällä seuraavat komennot muun eräajotiedoston sisällön lisäksi:

# Set R version
export RVER=452

# Launch R after binding CmdStan
SING_FLAGS="$SING_FLAGS -B /appl/soft/math/r-env/${RVER}-stan:/appl/soft/math/r-env/${RVER}-stan"
srun apptainer_wrapper exec Rscript --no-save script.R

Muut CmdStan-taustaohjelman käyttöön liittyvät yksityiskohdat ovat pakettikohtaisia. Yhtenä esimerkkinä sitä voisi käyttää brms -paketin kanssa:

library(brms)

fit_serial <- brm(
  count ~ zAge + zBase * Trt + (1|patient),
  data = epilepsy, family = poisson(),
  chains = 4, cores = 4, backend = "cmdstanr"
)

Huomaa, että brms:n within-chain-rinnakkaistus vaatii projektikohtaisen CmdStan-asennuksen. Ota yhteyttä CSC:n asiakastukeen saadaksesi ohjeet.

R-pakettien asennukset

Voit tarkistaa, onko tietty paketti jo asennettu, seuraavasti.

# One way is to try loading the package:
library(packagename)

# If you don't want to load the package, it is also
# possible to search through a list:
installed_packages <- library()$results[,1]
"packagename" %in% installed_packages

# Note: both ways are sensitive to upper- and lower-case letters

Lisä-R-pakettien asennukset voidaan järjestää kahta reittiä pitkin:

• Projektikohtaisia asennuksia voidaan käyttää luomalla erillinen pakettihakemisto /projappl/<project>-hakemistoon (ohjeet alla; katso myös täältä tietoa ProjApplista)

• Yleisiä asennuksia koskevat pyynnöt (tarjotaan kaikille käyttäjille osana moduulia): ota yhteyttä CSC:n asiakastukeen

Jotta voit käyttää projektikohtaista pakettikirjastoa, noudata näitä ohjeita. Luo ensin uusi kansio projektihakemistosi sisään. Huomaa, että kansion tulee olla käyttämällesi R-versiolle erityinen (eri r-env-moduuleilla asennetut R-paketit eivät ole keskenään yhteensopivia).

# On the command prompt:
# First navigate to /projappl/<project>, then
mkdir project_rpackages_<rversion>

Voit sitten lisätä kansion kirjastopuihisi R:ssä:

# Add this to your R code:
.libPaths(c("/projappl/<project>/project_rpackages_<rversion>", .libPaths()))
libpath <- .libPaths()[1]

# This command can be used to check that the folder is now visible:
.libPaths() # It should be first on the list

# Package installations should now be directed to the project
# folder by default. You can also specify the path, e.g. install.packages("package", lib = libpath)

# Note that it's also possible to fetch the R version automatically using getRversion(). For example:
.libPaths(paste0("/projappl/<project>/project_rpackages_", gsub("\\.", "", getRversion()))) 

Jotta voit käyttää /projappl-hakemistoon asennettuja R-paketteja, lisää seuraava R-skriptisi alkuun. Tämä muuttaa kirjastopuitasi vain kyseisen R-istunnon ajaksi. Toisin sanoen tämä täytyy suorittaa joka kerta, kun käynnistät R:n:

.libPaths(c("/projappl/<project>/project_rpackages_<rversion>", .libPaths()))

Vaihtoehtoisesti voit lisätä halutut muutokset .Renviron-tiedostoon:

echo "R_LIBS=/projappl/<project>/project_rpackages_<rversion>" >> ~/.Renviron

Note

Kun käytät r-env:ää, käyttäjän määrittämät muutokset R-kirjastopolkuihin täytyy määrittää R-istunnon sisällä tai .Renviron-tiedoston kautta. Muut muutokset (esim. ympäristömuuttujien muokkaaminen export-komennolla) eivät toimi, koska R-asennus toimii Apptainer-kontin sisällä. Jos analyysisi vaatisi muutoksia, joita ei voida toteuttaa yllä kuvatuilla tavoilla, ota yhteyttä meihin moduulinlaajuista pakettiasennusta varten.

PDF-renderöinti

Jos R Markdown- tai Quarto-dokumentin pdf-renderöinti epäonnistuu, suorita R:ssä seuraava:

tinytex::install_tinytex()

Kun sinulta kysytään olemassa olevasta LaTeX-jakelusta, vastaa yes, jotta asennus jatkuu siitä huolimatta.

Työskentely Allaksen kanssa

r-env-moduulin mukana tulee aws.s3 -paketti S3-tallennuksen käyttöön, mikä mahdollistaa Allas-tallennusjärjestelmän käytön suoraan R-skriptistä. Katso täältä käytännön esimerkki rasteridataa sisältävästä tapauksesta.

Allakseen pääsee r-env-moduulin kautta seuraavasti. Määritä ensin Allas-yhteys S3:lle:

module load allas
allas-conf --mode S3

Saadaksesi listan ämpäreistäsi:

library(aws.s3)
options("cloudyr.aws.default_region" = "")
bucketlist()

Viittaaminen

Jos haluat selvittää oikeat viittaukset R:lle ja eri R-paketeille, voit kirjoittaa:

citation() # for citing R
citation("package") # for citing R packages

Lisätietoja

• r-env-kontin reseptit (linkki julkiseen GitHub-repositorioon)

• Opas rinnakkaiseen R:ään

• R FAQ:t (CRANin ylläpitämä)

• Aiheeseen liittyvät projektit (lista R:ään liittyvistä projekteista R Projectin verkkosivuilla)

• R-pakettien cheatsheetit (RStudion verkkosivuilla)

• tidyverse (esiasennettu r-env-moduuliin)

• doMPI, future, furrr, lidR, pbdMPI, snow (rinnakkaisten R-pakettien CRAN-sivut)

Onko tämä sivu hyödyllinen?

Kyllä

Kiitos palautteestasi!

Ei

Kiitos! Arvostamme palautettasi.

Kerro meille miten voisimme parantaa tätä sivua ottamalla meihin yhteyttä.