CommunityData:Hyak Ikt (Deprecreated)
To use Hyak, you must first have a UW NetID, access to Hyak, and a two factor authentication token. Details on getting set up with all three are available at CommunityData:Hyak setup.
Setting up SSH
When you connect to SSH, it will ask you for a key from your token. Typing this in every time you start a connection be a pain. One approach is to create an .ssh config file that will create a "tunnel" the first time you connect and send all subsequent connections to Hyak over that tunnel. Some details in the Hyak documentation.
I've added the following config to the file ~/.ssh/config on my laptop (you will want to change the username):
Host hyak hyak.washington.edu User makohill HostName login3.hyak.washington.edu ControlPath ~/.ssh/master-%r@%h:%p ControlMaster auto ControlPersist yes ForwardX11 yes ForwardX11Trusted yes Compression yes
ONE WARNING: If your SSH connection becomes stale or disconnected (e.g., if you change networks) it may take some time for the connection to time out. Until that happens, any connections you make to hyak will silently hang. If your connections to ssh hyak are silently hanging but your Internet connection seems good, look for ssh processes running on your local machine with:
ps ax|grep hyak
If you find any, kill them with kill <PROCESSID>. Once that is done, you should have no problem connecting to Hyak.
Connecting to Hyak
To connect to Hyak, you now only need to do:
ssh hyak
It will prompt you for your UWNetID's password and your PRN which is the little number that comes from your token.
Setting Up Hyak
When setting up Hyak, you must first add this to your BASHRC file. Generally, you can simply edit the following file on Hyak: ~/.bashrc
## hyak specific options alias rgrep='grep -r' alias big_machine='qsub -W group_list=hyak-mako -l walltime=500:00:00,mem=200gb -I' alias any_machine='qsub -W group_list=hyak-mako -l walltime=500:00:00,mem=100gb -I' PYTHON_PATH="/com/local/lib/python3.5:$PYTHON_PATH" LD_LIBRARY_PATH="/com/local/lib:$LD_LIBRARY_PATH" PKG_CONFIG_PATH=/com/local/lib/pkgconfig:/usr/share/pkgconfig MC_CORES=16 PATH="/com/local/bin:$PATH" module load parallel_sql module load contrib/gcc_5.1.0-openmpi_1.10.1 umask 007
The final line is particularly important. If you do not do this, the files you create on Hyak will be able to be read or written by others in the group!
Once you do this, you will need to restart bash. This can be done simply by logging out and then logging back in or by restarting bash with the command exec bash.
I also add these two lines to my Hyak .ssh/config:
ForwardX11 yes ForwardX11Trusted yes
These lines will mean that if I have "checked out" an interactive machine, I can ssh from my computer to Hyak and then directly through an addition hop to the machine (like ssh n0652). Those ForwardX11 lines means if I graph things on this window, they will open on my local display.
Jupyter Notebook on Hyak
We have a working jupyter notebook setup on hyak. It works with python3 or R.
Connect to a hyak login node. To keep your jupyter notebook running after you disconnect run screen (or tmux). We are going to forward the connection from the compute node to the login node to your local machine.
screen
Get a machine.
any_machine
Choose a port $PORT. We should each use a different port.
run jupyter on the compute node.
jupyter-notebook --no-browser --port=$PORT
Now forward the jupyter server to the login node. Open a new screen.
Ctrl-a n
And run this ssh command.
Replace abcd with the node number.
ssh -N -f -L localhost:$PORT:localhost:$PORT nabcd
Now on you local machine (your laptop), forward the port from hyak to localhost.
ssh -N -f -L localhost:$PORT:localhost:$PORT username@hyak.washington.edu
open localhost:PORT in your browser
It should work!
Running Jobs on Hyak
When you first log in to Hyak, you will be on a "login node". These are nodes that have access to the Internet, and can be used to update code, move files around, etc. They should not be used for computationally intensive tasks. To actually run jobs, there are a few different options, described in detail in the itSigs documentation. Following are basic instructions for the two most common use cases.
Interactive nodes
For simple tasks, e.g. running R on a dataset, testing that code is working, etc. it is easiest to run it in an interactive node. This is a compute node that you interact with through the terminal. All of your disk storage is accessible just as though you were on the login node.
Parallel SQL
For big jobs you will want to use multiple nodes. Hyak has a very cool tool that makes this very easy, called Parallel SQL. Detailed instructions are in the itsigs parallel-sql documentation. There is also a full walkthrough example with instructions in the wikiresearch/hyak_example directory.
The basic workflow is:
1. Prepare the code, and test it with a single file (either on your computer, or on an interactive node). 2. Write a job_script file. This tells the node what job to run. There is an example on the Parallel SQL wiki page (linked above), and an example in the wikiresearch/hyak_example directory. 3. Create a task_list file. This is a list of commands that should be run, with one line per file that the command should operate on. An example file might look something like:
python analysis_script.py -i ./input/wiki_1.tsv -o ./output/wiki_1_analysis.tsv python analysis_script.py -i ./input/wiki_2.tsv -o ./output/wiki_2_analysis.tsv ...
The README in the hyak_example directory has some example bash commands that you might use to generate this file.
4. Load the task_list into Parallel SQL.
$ module load parallel_sql $ cat task_list | psu --load
5. Run the job_script on as many nodes as you need. When each task is finished, the node will get the next task from Parallel SQL.
$ for job in $(seq 1 N); do qsub job_script; done # N is the number of nodes
Killing jobs on compute nodes
Torque documentation suggests that you should do this with qdel. That might work, but apparently our system runs moab on top of torque and the recommended (by Hyak admins) way to kill a job is to use the mjobctl command.
For example, you might run nodestate from a login node to figure out the ID number for your job (let's say it's 12345), then run mjobctl -c 12345 to send a SIGTERM signal or mjobctl -F 12345 to send a SIGKILL signal that will bring job 12345 to an end.
Note that only four user accounts at a time can have the bits necessary to kill other people's jobs, so while you can do this on your own jobs, you'll need to bother the IRC channel to find help cancelling other's jobs (we think that Jeremy, Nate, Aaron, and Mako currently have the bits). Also, check out the documentation for mjobctl for more info.
