Scripting

Running Processes in the Background

To background a new process, type an & at the end of the command line when the program is executed. For example, the command sleep waits a given number of seconds before continuing. Type

$ sleep 10

This will wait 10 seconds before returning the command prompt $. Until the command prompt is returned, you can do nothing except wait.

To run sleep in the background, type

$ sleep 10 &

[1] 6259

The & runs the job in the background and returns the prompt straight away, allowing you do run other programs while waiting for that one to finish. Of course, running sleep in the background defeats the purpose of this specific program, but you get the idea.

The first line in the above example is typed in by the user; the next line, indicating job number and PID, is returned by the machine. The user is be notified of a job number (numbered from 1) enclosed in square brackets, together with a PID and is notified when a background process is finished. Backgrounding is useful for jobs which will take a long time to complete, or for starting graphical programs that you want to run alongside the command line.

Backgrounding a Foreground Process

At the prompt, type

$ sleep 600

This will not return to the prompt for 10 minutes. You can suspend the process running in the foreground by typing ^z, i.e. hold down the “control” key and type “z”. This has suspended the job. To put it in the background, type

$ bg

Note: do not background terminal-based programs that require user interaction e.g. vi or nano

Listing Processes

When a process is running, backgrounded or suspended, it will be entered onto a list along with a job number. To examine this list, type

$ jobs

An example of a job list could be

[1] Suspended sleep 600
[2] Running firefox
[3] Running matlab

To restart (foreground) a suspended or backgrounded processes, type

$ fg <jobnumber>

For example, to bring sleep 600 to the foreground, type

$ fg 1

Typing fg with no job number foregrounds the most-recently suspended or backgrounded process.

Killing a Process

It is sometimes necessary to kill a process (for example, when an executing program is in an infinite loop). To kill a job running in the foreground, type ^c ([control]-[c]. For example, run

$ sleep 100
^c

To kill a suspended or background process, type

$ kill %<jobnumber>

For example, run

$ sleep 100 &
$ jobs

If sleep 100 is job number 4, type

$ kill %4

To check whether this has worked, examine the job list again to see if the process has been removed.

Alternatively, any process owned by a user (not just one launched from that terminal) can be killed by finding the process’ corresponding ID number (PID) and using kill

$ sleep 1000 &
$ ps

  PID TTY          TIME CMD
32093 ?        00:00:00 sshd
32094 pts/3    00:00:00 bash
32259 pts/3    00:00:00 sleep
32260 pts/3    00:00:00 ps

To kill off the process sleep 1000, type

$ kill 32259

and then type ps again to see if it has been removed from the list.

If for some reason a process that you own refuses to be killed, you can try using the -9 option, i.e. type

$ kill -9 32259

Note: It is not possible to kill off other users’ processes, unless you are a “superuser” on that computer.

Summary of commands for interacting with running processes:

Bash Scripts

Basics of Bash shell scripting:

• The first line of the shell script file should include the line

  #!/bin/bash
  

  to indicate that the script contents should be executed by the Bash shell. This line works on Linux and OS X systems; Bash scripting on Windows is an entirely different animal!

• Lines beginning with a # character are interpreted as comments (except for the first line).

As an example, consider the following script:

#!/bin/bash

# define the "odd" function, takes one argument
odd() {
   echo "  $1 is odd"
}

# define the "even" function, takes one argument
even() {
   echo "  $1 is even"
}

# define the "other" function, takes one argument
other() {
   echo "  $1 is neither even nor odd"
}

# loop over some integers, checking even/odd
for i in {1..20}; do
   m=$(($i % 2))
   if [ $m -eq 0 ]; then
      even $i
   elif [ $m -eq 1 ]; then
      odd $i
   else
      other $i
   fi
done

The structure of this example should be obvious from the preceding short examples, except that there are a few notable exceptions:

• We perform arithmetic: these operations must be of the form $(( expression )).

• We use the “modulus” operator, %. Other allowable arithmetic operators include +, -, * and /.

• We perform the logical “equality” operation via -eq. The inequality logical operation is -ne. The mathematical <, ≤, > and ≥ operators are given by -lt, -le, -gt and -ge, respectively.

• Bash logic operations may be performed using the standard && (and), || (or) and ! (not).

• Function arguments are passed in following the function name; more than one function argument may be supplied (though not shown here).

Python Scripts

Basics of Python shell scripting:

• The first line of the shell script file can include the line

  #!/usr/bin/env python
  

  to indicate that the script contents should be executed by the Python shell. Again, the above line is usable on Linux and OS X machines, and does not apply to Windows.

• Lines beginning with a # character are interpreted as comments (except for the first line).

As a more lengthy example (akin to the Bash example above), consider the following script (in python_example.py):

#!/usr/bin/env python

# define the "odd" function, takes one argument
def odd(val):
   print "  ", val, " is odd"

# define the "even" function, takes one argument
def even(val):
   print "  ", val, " is even"

# define the "other" function, takes one argument
def other(val):
   print "  ", val, " is neither even nor odd"

# loop over some integers, checking even/odd
for i in range(1,21):
   m = i % 2
   if m == 0:
      even(i)
   elif m == 1:
      odd(i)
   else:
      other(i)

As with the previous Bash example, the structure of this example should be obvious from the preceding explanations, except that there are a few notable exceptions:

• We perform the logical “equality” operation via ==. The inequality logical operation is !=. Similarly, <, <=, > and >= correspond to the the mathematical <, ≤, > and ≥ operators.

• Python logic operations may be combined using and, or and not (self-explanatory).

Primes

Construct your own Bash or Python script that determines all of the prime numbers between 2 and 1000:

1. Create a function called is_prime that takes a number x as input:

   1. For each number n from 2 to x-1, test whether x is evenly divisible by n (actually, you could stop iterating at the largest integer less than or equal to $sqrt{x}$, where sqrt() is available from the NumPy package by adding the Python command from numpy import * to the top of your script).

   2. If x is evenly divisible by n, then return False.

   3. If the loop finishes without returning False, then return True.

2. Loop over the values 2 through 1000. For each number, call your new function is_prime to determine whether the number is prime or not.

3. If the number is prime, then print it to the screen, otherwise do not print.

For a little extra work, keep track of how many primes there are in this range and print this out at the end of your script (you should get 168).

Monte Carlo Method for Estimating π

A Monte Carlo method for estimating the value of π is randomly selecting points in a unit square and then calculating the ratio $p=frac{m}{n}$ where m is the number of points that satisfy the condition x² + y² ≤ 1. Using the ratio, π is estimated as π ≈ p × 4.

In this tutorial each person will write a Bash script in the that does this calculation for 1000 random points. The calculation, though very quick, should be run through the queue system using srun or sbatch where m and the job ID are written to a file named $USER.txt, where $USER is your username.

Once the calculation is complete, we can compare the results the Python implementation.