Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • mlange/VSCode_remote_HPC
  • umarka/VSCode_remote_HPC
  • lhausammann/VSCode_remote_HPC
  • zhouhao/VSCode_remote_HPC
  • sfux/VSCode_remote_HPC
5 results
Show changes
Commits on Source (41)
Expand all Hide whitespace changes
Inline Side-by-side
LICENSE 0 → 100644
View file @ ab09bc35
This diff is collapsed.
README.md
View file @ ab09bc35
......@@ -2,4 +2,167 @@
This script can be used to start a batch job on the cluster and then connect Microsoft VSCode to it. The script is inspired by the blog
https://medium.com/@isaiah.taylor/use-vs-code-on-a-supercomputer-15e4cbbb1bc2
\ No newline at end of file
https://medium.com/@isaiah.taylor/use-vs-code-on-a-supercomputer-15e4cbbb1bc2
## Requirements
The script assumes that you have setup SSH keys for passwordless access to the cluster. Please find some instructions on how to create SSH keys on the scicomp wiki:
https://scicomp.ethz.ch/wiki/Accessing_the_clusters#SSH_keys
Currently the script runs on Linux, Mac OS X and Windows (using WSL/WSL2 or git bash). When using a Linux computer, please make sure that xdg-open is installed. This package is used to automatically start your default browser. You can install it with the command
CentOS:
```
yum install xdg-utils
```
Ubuntu:
```
apt-get install xdg-utils
```
## Using SSH keys with non-default names
Since the reopening of Euler after the cyber attack in May 2020, we recommend to the cluster users to use SSH keys.
```
$HOME/.ssh/id_ed25519_euler
```
You can either use the -k option of the script to specify the location of the SSH key, or even better use an SSH config file with the IdentityFile option
https://scicomp.ethz.ch/wiki/Accessing_the_clusters#How_to_use_keys_with_non-default_names
I would recommend to use the SSH config file as this works more reliably.
## Preparation
The preparation steps only need to be executed once. You need to carry out those steps to set up the basic configuration for your ETH account with regards to the code-server.
* Login to the Euler
* Start and interactive job with
```
srun --ntasks=1 --time=00:10:00 --mem-per-cpu=2048 --pty bash
```
When using Euler, switch to the new software stack (in case you haven't set it as default yet), either using
```
env2lmod
```
for the current shell, or
```
set_software_stack.sh new
```
to set it as permanent default (when using this command, you need to logout and login again to make the change becoming active)
Load the modules for one of the code-server installations:
```
module load gcc/6.3.0 code-server/3.12.0
```
Start the code-server once with the command code-server
```
[sfux@eu-ms-001-01 ~]$ code-server
[2021-11-02T10:01:45.407Z] info code-server 3.12.0 4cd55f94c0a72f05c18cea070e10b969996614d2
[2021-11-02T10:01:45.409Z] info Using user-data-dir ~/.local/share/code-server
[2021-11-02T10:01:45.433Z] info Using config file ~/.config/code-server/config.yaml
[2021-11-02T10:01:45.433Z] info HTTP server listening on http://127.0.0.1:8080
[2021-11-02T10:01:45.433Z] info - Authentication is enabled
[2021-11-02T10:01:45.433Z] info - Using password from ~/.config/code-server/config.yaml
[2021-11-02T10:01:45.433Z] info - Not serving HTTPS
[sfux@eu-ms-001-01 ~]$
```
This will setup the local configuration (including a password for you) and store it in your home directory in $HOME/.config/code-server/config.yaml
After the server started, terminate it with ctrl+c
## Usage
### Install
Download the repository with the command
```
git clone https://gitlab.ethz.ch/sfux/VSCode_remote_HPC.git
```
### Run VSCode in a batch job
The start_vscode.sh script needs to be executed on your local computer. Please find below the list of options that can be used with the script:
```
$ ./start_vscode.sh --help
./start_vscode.sh: Script to start a VSCode on Euler from a local computer
Usage: start_vscode.sh [options]
Options:
-u | --username USERNAME ETH username for SSH connection to Euler
-n | --numcores NUM_CPU Number of CPU cores to be used on the cluster
-W | --runtime RUN_TIME Run time limit for the code-server in hours and minutes HH:MM
-m | --memory MEM_PER_CORE Memory limit in MB per core
-b | --batchsys BATCH_SYS Batch system to use (LSF or SLURM)
Optional arguments:
-c | --config CONFIG_FILE Configuration file for specifying options
-g | --numgpu NUM_GPU Number of GPUs to be used on the cluster
-h | --help Display help for this script and quit
-i | --interval INTERVAL Time interval for checking if the job on the cluster already started
-k | --key SSH_KEY_PATH Path to SSH key with non-standard name
-v | --version Display version of the script and exit
-j | --jobargs JOB_ARGS Additional job arguments
Examples:
./start_vscode.sh -u sfux -b SLURM -n 4 -W 04:00 -m 2048
./start_vscode.sh --username sfux --batchsys SLURM --numcores 2 --runtime 01:30 --memory 2048
./start_vscode.sh -c /c/Users/sfux/.vsc_config
Format of configuration file:
VSC_USERNAME="" # ETH username for SSH connection to Euler
VSC_NUM_CPU=1 # Number of CPU cores to be used on the cluster
VSC_NUM_GPU=0 # Number of GPUs to be used on the cluster
VSC_RUN_TIME="01:00" # Run time limit for the code-server in hours and minutes HH:MM
VSC_MEM_PER_CPU_CORE=1024 # Memory limit in MB per core
VSC_WAITING_INTERVAL=60 # Time interval to check if the job on the cluster already started
VSC_SSH_KEY_PATH="" # Path to SSH key with non-standard name
VSC_BATCH_SYSTEM="SLURM" # Batch system to use (SLURM or LSF)
VSC_JOB_ARGS="" # Additional job arguments
```
### Reconnect to a code-server session
When running the script, it creates a local file called reconnect_info in the installation directory, which contains all information regarding the used ports, the remote ip address, the command for the SSH tunnel and the URL for the browser. This information should be sufficient to reconnect to a code-server session if connection was lost.
## Cleanup after the job
Please note that when you finish working with the code-server, you need to login to the cluster, identify the job with bjobs and then kill it with the bkill command, using the jobid as parameter). Afterwards you also need to clean up the SSH tunnel that is running in the background. Example:
```
$ ps -u | grep -m1 -- "-L" | grep -- "-N"
samfux 8729 0.0 0.0 59404 6636 pts/5 S 13:46 0:00 ssh sfux@euler.ethz.ch -L 51339:10.205.4.122:8888 -N
$ kill 8729
```
This example is from a Linux computer. If you are using git bash on Windows, then you can find the SSH process with the ps kommand and use kill to stop it.
## Main author
* Samuel Fux
## Contributions
* Andreas Lugmayr
* Mike Boss
* Nadia Marounina
cleanup.sh 0 → 100755
View file @ ab09bc35
#!/bin/bash
if [[ $# -lt 1 ]]
then
echo -e "Error: No ETH username is specified, terminating script\n"
exit 1
fi
VSC_USERNAME=$1
VSC_TUNNEL=$(cat reconnect_info | grep -o -E '[0-9]+:([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+):[0-9]+')
TUNNEL_JOBS=$(ps -u | grep $VSC_TUNNEL | grep ssh | awk '{ print $2 }')
for TUNNEL_JOB in $TUNNEL_JOBS; do echo $TUNNEL_JOB; kill $TUNNEL_JOB; done
ssh -T $VSC_USERNAME@euler.ethz.ch bkill $(cat reconnect_info | grep BJOB | awk '{print $NF}')
start_vscode.sh 0 → 100755
View file @ ab09bc35
#!/bin/bash
###############################################################################
# #
# Script for local computer to start a code-server on Euler and use a SSH- #
# tunnel to connect it with a local browser #
# #
# Main author : Samuel Fux #
# Contributions : Andreas Lugmayr, Mike Boss, Nadia Marounina, #
# Haoyang Zhou, Loïc Hausammann #
# Date : Oct 2021-2023 #
# Location : ETH Zurich #
# Change history : #
# #
# 05.05.2023 Added variable for standard port #
# 24.10.2022 Added Slurm support #
# 19.05.2022 JOBID is now saved to reconnect_info file #
# 28.10.2021 Initial version of the script based on Jupyter script #
# #
###############################################################################
###############################################################################
# Configuration options, initalising variables and setting default values #
###############################################################################
# Version
VSC_VERSION="0.5"
# Script directory
VSC_SCRIPTDIR=$(pwd)
# hostname of the cluster to connect to
VSC_HOSTNAME="euler.ethz.ch"
# order for initializing configuration options
# 1. Defaults values set inside this script
# 2. Command line options overwrite defaults
# 3. Config file options overwrite command line options
# Configuration file default : $HOME/.vsc_config
VSC_CONFIG_FILE="$HOME/.vsc_config"
# Username default : no default
VSC_USERNAME=""
# Number of CPU cores default : 1 CPU core
VSC_NUM_CPU=1
# Runtime limit default : 1:00 hour
VSC_RUN_TIME="01:00"
# Memory default : 1024 MB per core
VSC_MEM_PER_CPU_CORE=1024
# Number of GPUs default : 0 GPUs
VSC_NUM_GPU=0
# Waiting interval default : 60 seconds
VSC_WAITING_INTERVAL=60
# SSH key location default : no default
VSC_SSH_KEY_PATH=""
# Batch system : Slurm
VSC_BATCH_SYSTEM="SLURM"
# Additional job arguments default : no default
VSC_JOB_ARGS=""
# Standard port for code-server : 8899
VSC_REMOTE_PORT=8899
###############################################################################
# Usage instructions #
###############################################################################
function display_help {
cat <<-EOF
$0: Script to start a VSCode on Euler from a local computer
Usage: start_vscode.sh [options]
Required options:
-b | --batchsys BATCH_SYS Batch system to use (LSF or SLURM)
-m | --memory MEM_PER_CORE Memory limit in MB per core
-n | --numcores NUM_CPU Number of CPU cores to be used on the cluster
-u | --username USERNAME ETH username for SSH connection to Euler
-W | --runtime RUN_TIME Run time limit for the code-server in hours and minutes HH:MM
Optional arguments:
-c | --config CONFIG_FILE Configuration file for specifying options
-g | --numgpu NUM_GPU Number of GPUs to be used on the cluster
-h | --help Display help for this script and quit
-i | --interval INTERVAL Time interval for checking if the job on the cluster already started
-j | --jobargs JOB_ARGS Additional job arguments
-k | --key SSH_KEY_PATH Path to SSH key with non-standard name
-p | --port CS_PORT Port number to be used by code-server
-v | --version Display version of the script and exit
Examples:
./start_vscode.sh -u sfux -b SLURM -n 4 -W 04:00 -m 2048
./start_vscode.sh --username sfux --batchsys SLURM --numcores 2 --runtime 01:30 --memory 2048
./start_vscode.sh -c $HOME/.vsc_config
Format of configuration file:
VSC_USERNAME="" # ETH username for SSH connection to Euler
VSC_NUM_CPU=1 # Number of CPU cores to be used on the cluster
VSC_NUM_GPU=0 # Number of GPUs to be used on the cluster
VSC_RUN_TIME="01:00" # Run time limit for the code-server in hours and minutes HH:MM
VSC_MEM_PER_CPU_CORE=1024 # Memory limit in MB per core
VSC_WAITING_INTERVAL=60 # Time interval to check if the job on the cluster already started
VSC_SSH_KEY_PATH="" # Path to SSH key with non-standard name
VSC_BATCH_SYSTEM="SLURM" # Batch system to use (SLURM or LSF)
VSC_JOB_ARGS="" # Additional job arguments
VSC_REMOTE_PORT=8899 # Port to be used with the code-server
EOF
exit 1
}
###############################################################################
# Parse configuration options #
###############################################################################
while [[ $# -gt 0 ]]
do
case $1 in
-h|--help)
display_help
;;
-v|--version)
echo -e "start_vscode.sh version: $VSC_VERSION\n"
exit
;;
-u|--username)
VSC_USERNAME=$2
shift
shift
;;
-n|--numcores)
VSC_NUM_CPU=$2
shift
shift
;;
-W|--runtime)
VSC_RUN_TIME=$2
shift
shift
;;
-m|--memory)
VSC_MEM_PER_CPU_CORE=$2
shift
shift
;;
-c|--config)
VSC_CONFIG_FILE=$2
shift
shift
;;
-g|--numgpu)
VSC_NUM_GPU=$2
shift
shift
;;
-i|--interval)
VSC_WAITING_INTERVAL=$2
shift
shift
;;
-k|--key)
VSC_SSH_KEY_PATH=$2
shift
shift
;;
-b|--batchsys)
VSC_BATCH_SYSTEM=$2
shift
shift
;;
-j|--jobargs)
VSC_JOB_ARGS=$2
shift
shift
;;
-p|--port)
VSC_REMOTE_PORT=$2
;;
*)
echo -e "Warning: ignoring unknown option $1 \n"
shift
;;
esac
done
###############################################################################
# Check configuration options #
###############################################################################
# check if user has a configuration file and source it to initialize options
if [ -f "$VSC_CONFIG_FILE" ]; then
echo -e "Found configuration file $VSC_CONFIG_FILE"
echo -e "Initializing configuration from file ${VSC_CONFIG_FILE}:"
cat "$VSC_CONFIG_FILE"
source "$VSC_CONFIG_FILE"
fi
# check that VSC_USERNAME is not an empty string
if [ -z "$VSC_USERNAME" ]
then
echo -e "Error: No ETH username is specified, terminating script\n"
display_help
else
echo -e "ETH username: $VSC_USERNAME"
fi
# check number of CPU cores
# check if VSC_NUM_CPU an integer
if ! [[ "$VSC_NUM_CPU" =~ ^[0-9]+$ ]]; then
echo -e "Error: $VSC_NUM_CPU -> Incorrect format. Please specify number of CPU cores as an integer and try again\n"
display_help
fi
# check if VSC_NUM_CPU is <= 128
if [ "$VSC_NUM_CPU" -gt "128" ]; then
echo -e "Error: $VSC_NUM_CPU -> Larger than 128. No distributed memory supported, therefore the number of CPU cores needs to be smaller or equal to 128\n"
display_help
fi
if [ "$VSC_NUM_CPU" -gt "0" ]; then
echo -e "Requesting $VSC_NUM_CPU CPU cores for running the code-server"
fi
# check number of GPUs
# check if VSC_NUM_GPU an integer
if ! [[ "$VSC_NUM_GPU" =~ ^[0-9]+$ ]]; then
echo -e "Error: $VSC_NUM_GPU -> Incorrect format. Please specify the number of GPU as an integer and try again\n"
display_help
fi
# check if VSC_NUM_GPU is <= 8
if [ "$VSC_NUM_GPU" -gt "8" ]; then
echo -e "Error: No distributed memory supported, therefore number of GPUs needs to be smaller or equal to 8\n"
display_help
fi
if [ "$VSC_NUM_GPU" -gt "0" ]; then
echo -e "Requesting $VSC_NUM_GPU GPUs for running the code-server"
VSC_SNUM_GPU="-R \"rusage[ngpus_excl_p=$VSC_NUM_GPU]\""
else
VSC_SNUM_GPU=""
fi
if [ ! "$VSC_NUM_CPU" -gt "0" -a ! "$VSC_NUM_GPU" -gt "0" ]; then
echo -e "Error: No CPU and no GPU resources requested, terminating script"
display_help
fi
# check if VSC_RUN_TIME is provided in HH:MM format
if ! [[ "$VSC_RUN_TIME" =~ ^[0-9][0-9]:[0-9][0-9]$ ]]; then
echo -e "Error: $VSC_RUN_TIME -> Incorrect format. Please specify runtime limit in the format HH:MM and try again\n"
display_help
else
echo -e "Run time limit set to $VSC_RUN_TIME"
fi
# check if VSC_MEM_PER_CPU_CORE is an integer
if ! [[ "$VSC_MEM_PER_CPU_CORE" =~ ^[0-9]+$ ]]; then
echo -e "Error: $VSC_MEM_PER_CPU_CORE -> Memory limit must be an integer, please try again\n"
display_help
else
echo -e "Memory per core set to $VSC_MEM_PER_CPU_CORE MB"
fi
# check if VSC_WAITING_INTERVAL is an integer
if ! [[ "$VSC_WAITING_INTERVAL" =~ ^[0-9]+$ ]]; then
echo -e "Error: $VSC_WAITING_INTERVAL -> Waiting time interval [seconds] must be an integer, please try again\n"
display_help
else
echo -e "Setting waiting time interval for checking the start of the job to $VSC_WAITING_INTERVAL seconds"
fi
# set modules
VSC_MODULE_COMMAND="gcc/6.3.0 code-server/3.12.0 eth_proxy"
# check if VSC_SSH_KEY_PATH is empty or contains a valid path
if [ -z "$VSC_SSH_KEY_PATH" ]; then
VSC_SKPATH=""
else
VSC_SKPATH="-i $VSC_SSH_KEY_PATH"
echo -e "Using SSH key $VSC_SSH_KEY_PATH"
fi
# check if VSC_BATCH_SYSTEM is set to SLURM or LSF
case $VSC_BATCH_SYSTEM in
LSF)
echo -e "Using LSF batch system"
;;
SLURM)
echo -e "Using Slurm batch system"
;;
*)
echo -e "Error: Unknown batch system $VSC_BATCH_SYSTEM. Please either specify LSF or SLURM as batch system"
;;
esac
# check if VSC_REMOTE_PORT an integer
if ! [[ "$VSC_REMOTE_PORT" =~ ^[0-9]+$ ]]; then
echo -e "Error: $VSC_REMOTE_PORT -> Incorrect format. Please specify the port number as an integer and try again\n"
display_help
fi
echo -e "Using port number $VSC_REMOTE_PORT for the code-server"
# put together string for SSH options
VSC_SSH_OPT="$VSC_SKPATH $VSC_USERNAME@$VSC_HOSTNAME"
###############################################################################
# Check for leftover files #
###############################################################################
# check if some old files are left from a previous session and delete them
# check for reconnect_info in the current directory on the local computer
echo -e "Checking for left over files from previous sessions"
if [ -f $VSC_SCRIPTDIR/reconnect_info ]; then
echo -e "Found old reconnect_info file, deleting it ..."
rm $VSC_SCRIPTDIR/reconnect_info
fi
# check for log files from a previous session in the home directory of the cluster
ssh -T $VSC_SSH_OPT <<ENDSSH
if [ -f /cluster/home/$VSC_USERNAME/vscip ]; then
echo -e "Found old vscip file, deleting it ..."
rm /cluster/home/$VSC_USERNAME/vscip
fi
ENDSSH
###############################################################################
# Start code-server on the cluster #
###############################################################################
# run the code-server job on Euler and save the ip of the compute node in the file vscip in the home directory of the user on Euler
echo -e "Connecting to $VSC_HOSTNAME to start the code-server in a $BATCH_SYS batch job"
case $VSC_BATCH_SYSTEM in
"LSF")
VSC_BJOB_OUT=$(ssh $VSC_SSH_OPT bsub -n $VSC_NUM_CPU -W $VSC_RUN_TIME -R "rusage[mem=$VSC_MEM_PER_CPU_CORE]" $VSC_SNUM_GPU $VSC_JOB_ARGS<<ENDBSUB
module load $VSC_MODULE_COMMAND
export XDG_RUNTIME_DIR="\$HOME/vsc_runtime"
VSC_IP_REMOTE="\$(hostname -i)"
echo "Remote IP:\$VSC_IP_REMOTE" >> /cluster/home/$VSC_USERNAME/vscip
code-server --bind-addr=\${VSC_IP_REMOTE}:\${VSC_REMOTE_PORT}
ENDBSUB
) ;;
"SLURM")
VSC_RUN_TIME="${VSC_RUN_TIME}":00" "
if [ "$VSC_NUM_GPU" -gt "0" ]; then
VSC_SNUM_GPU="-G $VSC_NUM_GPU"
fi
VSC_BJOB_OUT=$(ssh $VSC_SSH_OPT sbatch --ntasks=1 --cpus-per-task=$VSC_NUM_CPU "--time=$VSC_RUN_TIME" "--mem-per-cpu=$VSC_MEM_PER_CPU_CORE" -e "error.dat" $VSC_SNUM_GPU $VSC_JOB_ARGS<<ENDBSUB
#!/bin/bash
module load $VSC_MODULE_COMMAND
export XDG_RUNTIME_DIR="\$HOME/vsc_runtime"
VSC_IP_REMOTE="\$(hostname -i)"
echo "Remote IP:\$VSC_IP_REMOTE" >> /cluster/home/$VSC_USERNAME/vscip
code-server --bind-addr=\${VSC_IP_REMOTE}:\${VSC_REMOTE_PORT}
ENDBSUB
)
;;
esac
# TODO: get jobid for both cases (LSF/Slurm)
# store jobid in a variable
# VSC_BJOB_ID=$(echo $VSC_BJOB_OUT | awk '/is submitted/{print substr($2, 2, length($2)-2);}')
# wait until batch job has started, poll every $VSC_WAITING_INTERVAL seconds to check if /cluster/home/$VSC_USERNAME/vscip exists
# once the file exists and is not empty the batch job has started
ssh $VSC_SSH_OPT <<ENDSSH
while ! [ -e /cluster/home/$VSC_USERNAME/vscip -a -s /cluster/home/$VSC_USERNAME/vscip ]; do
echo 'Waiting for code-server to start, sleep for $VSC_WAITING_INTERVAL sec'
sleep $VSC_WAITING_INTERVAL
done
ENDSSH
# give the code-server a few seconds to start
sleep 7
# get remote ip and token from files stored on Euler
echo -e "Receiving ip, port and token from the code-server"
VSC_REMOTE_IP=$(ssh $VSC_SSH_OPT "cat /cluster/home/$VSC_USERNAME/vscip | grep -m1 'Remote IP' | cut -d ':' -f 2")
# check if the IP, the port and the token are defined
if [[ "$VSC_REMOTE_IP" == "" ]]; then
cat <<EOF
Error: remote ip is not defined. Terminating script.
* Please check login to the cluster and check with bjobs if the batch job on the cluster is running and terminate it with bkill.
EOF
exit 1
fi
# print information about IP, port and token
echo -e "Remote IP address: $VSC_REMOTE_IP"
echo -e "Remote port: $VSC_REMOTE_PORT"
# get a free port on local computer
echo -e "Determining free port on local computer"
#VSC_LOCAL_PORT=$(python -c 'import socket; s=socket.socket(); s.bind(("",0)); print(s.getsockname()[1]); s.close()')
# FIXME: check if there is a solution that does not require python (as some Windows computers don't have a usable Python installed by default)
# if python is not available, one could use
VSC_LOCAL_PORT=$((3 * 2**14 + RANDOM % 2**14))
# as a replacement. No guarantee that the port is unused, but so far best non-Python solution
echo -e "Using local port: $VSC_LOCAL_PORT"
# write reconnect_info file
#
# FIXME: add jobid
# BJOB ID : $VSC_BJOB_ID
cat <<EOF > $VSC_SCRIPTDIR/reconnect_info
Restart file
Remote IP address : $VSC_REMOTE_IP
Remote port : $VSC_REMOTE_PORT
Local port : $VSC_LOCAL_PORT
SSH tunnel : ssh $VSC_SSH_OPT -L $VSC_LOCAL_PORT:$VSC_REMOTE_IP:$VSC_REMOTE_PORT -N &
URL : http://localhost:$VSC_LOCAL_PORT
EOF
# setup SSH tunnel from local computer to compute node via login node
# FIXME: check if the tunnel can be managed via this script (opening, closing) by using a control socket from SSH
echo -e "Setting up SSH tunnel for connecting the browser to the code-server"
ssh $VSC_SSH_OPT -L $VSC_LOCAL_PORT:$VSC_REMOTE_IP:$VSC_REMOTE_PORT -N &
# SSH tunnel is started in the background, pause 5 seconds to make sure
# it is established before starting the browser
sleep 5
# save url in variable
VSC_URL=http://localhost:$VSC_LOCAL_PORT
echo -e "Starting browser and connecting it to the code-server"
echo -e "Connecting to url $VSC_URL"
# start local browser if possible
if [[ "$OSTYPE" == "linux-gnu" ]]; then
xdg-open $VSC_URL
elif [[ "$OSTYPE" == "darwin"* ]]; then
open $VSC_URL
elif [[ "$OSTYPE" == "msys" ]]; then # Git Bash on Windows 10
start $VSC_URL
else
echo -e "Your operating system does not allow to start the browser automatically."
echo -e "Please open $VSC_URL in your browser."
fi
\ No newline at end of file
vsconfig.example 0 → 100644
View file @ ab09bc35
VSC_USERNAME="" # ETH username for SSH connection to Euler
VSC_NUM_CPU=1 # Number of CPU cores to be used on the cluster
VSC_NUM_GPU=0 # Number of GPUs to be used on the cluster
VSC_RUN_TIME="01:00" # Run time limit for the code-server in hours and minutes HH:MM
VSC_MEM_PER_CPU_CORE=1024 # Memory limit in MB per core
VSC_WAITING_INTERVAL=60 # Time interval to check if the job on the cluster already started
VSC_SSH_KEY_PATH="" # Path to SSH key with non-standard name
VSC_JOB_ARGS="" # Additional arguments when submitting the job