View source for OPS102 - Resources and Processes

[[Category:OPS102]]
== Computer Resources ==

Every digital computer system has finite resources, managed by the operating system.

One or more of these three broad categories of resources constrain (limit) the system's ability to execute each running program:
# '''Memory''' - The availability of adequate memory, and the performance of that memory.
# '''CPU''' - The ability of the CPU to execute the instructions contained in the program at a particular speed.
# '''Input/Output''' (I/O) - This is a very broad category that includes storage, networking, printers, keyboard and mouse, and so forth.

=== Processes ===

On a multitasking computer system, a ''process'' is a single instance of an executing computer program. For example, <code>ssh</code> is one program. If there are no running instances of ssh on a computer system, then there are no ssh processes. If one user starts one ssh session, then one there is one ssh process. If five users start a combined total of twelve ssh sessions, then there are twelve ssh processes.

Each process is assigned a Process ID (PID) and is allocated its own resources, such as memory. Processes are scheduled to run (execute) on a CPU core for a fraction of a second, and then the operating system may intervene and switch the CPU core to run another processes. However, if a process is waiting for an I/O resources, such as data from a storage device, a packet of data from the network, or a keystroke from the user, it may inform the operating system that it does not need to be executed until that resource is available. A process which is ineligible for execution because it is waiting for a resources is called a ''sleeping'' process.

=== Resource Conflicts ===

When the resource requirements of running computer programs significantly exceed available resources, system performance will become unsatisfactory.

It is important to be able to identify the resource consumption of each process, and each operating system provides multiple tools to do this. They also provide tools to terminate processes if they are unstable or consuming excessive resources.

=== Challenges with Monitoring Resource Usage ===

It is difficult to accurately monitor a process' resource utilization because it will change from microsecond to microsecond. In addition, some resources are very difficult to accurately measure:

==== Memory ====

On contemporary computer systems, memory is very actively and dynamically managed by the Operating System using the hardware's virtual memory features. This enables many useful techniques, including:
* Demand Loading - Only the portion of programs which are used are loaded. Code for features that are not used is not loaded into memory. For example, in a word processor (such as LibreOffice/OpenOffice or Word), features such as table of content generation, endnotes, and watermarks are not used in many documents, and the code for those features will not be loaded in many cases.
* Sharing of Memory - Shared libraries (also called Dynamically Linked Libraries) may be used by many different processes. These libraries are loaded into memory only once, using demand loading, regardless of the number of processes using each library. Similarly, a program which is running in two or more processes will be loaded into memory only once, and shared between the processes. This significantly reduces memory requirements.
* Swap - When system memory (RAM) is approaching full utilization, the operating system may take some of the least-recently-used areas of memory and place them in storage (hard disk or solid state disk) or compress them in order to avoid running out of free memory. Areas of memory swapped out may be swapped back in if they are later required.

Due to the utilization of these techniques and others, the memory consumption of a program can be calculated in many different ways. For example:
* You could add up the full size of the program, all of the shared libraries, and the data used by a process, but that would yield a large number (a pessimistic view of memory consumption). The process is likely not occupying that much memory, and terminating the process will typically release only a fraction of that memory because most of the shared libraries will still be loaded into memory and in use by other programs.
* You could add up just the portion of the program in memory plus the data area in memory used by a process, but this would understate the full memory utilization because it does not include the shared libraries nor the portion of the program or data which has been swapped out or which has not (yet) been demand-loaded.

Therefore resource monitoring tools may present several different statistics about memory usage for each process, or may try to present a rough approximation of the amount of total system memory which can be reasonably attributed to a process.

==== CPU ====

Each CPU core is independently capable of executing programs. Most modern CPUs have multiple cores (Symmetric Multi Processing, SMP), enabling multiple programs to be executed simultaneously. Many modern CPUs can execute more than one '''thread''' on a core (Symmetric Multi Threading, SMT), meaning that they have hardware support for rapid switching between two or more processes (or, in some cases, sub-processes called '''threads''') on one core -- so a 4-core CPU may be marketed as capable of running up to 8 tasks. However, this does not mean that 8 programs can be fully executed at once!

To use an analogy, a SMP processor is a bit like an apartment building, where each core is like an apartment ad can fully accommodate a family (whether a single, couple, roommates, or parents and children), or, in the case of the CPU, fully execute a process. SMT capability is a bit like Airbnb rentals, which enable those units to be shared out quickly when they're not in use by the main occupants, or in the case of the CPU, quickly run other threads when the core (or part of the core) is not in use.

Further complicating the issue is the fact that CPUs may have multiple cores of different specifications -- some fast, power-hungry cores used for heavy tasks, and other slower, energy-efficient cores for lighter tasks. Cores may be shut down and started up by the OS as needed. For example, some Seneca lab computers have an Intel CPU with 12 cores consisting of 10 performance cores (capable of running 2 threads) and 2 efficiency cores (capable of running 1 thread). In a similar way, a Google Pixel 8 phone has 4 energy-efficient/low-performance Arm Cortex-A510 cores, 4 mid-range Cortex-A715 cores, and one high-energy-usage/very high-performance Cortex-X3 core.

In addition, current CPUs can operate at a range of speeds, and the OS and hardware work together to dynamically tune the speed to balance temperature, energy usage, and performance.

Therefore, statistics reporting the percentage of CPU capability in use by a process may report the percentage of a core's capability in use, either with or without considering SMT capabilities, or they may report the percentage of the full CPU's capability (including all cores). When cores of different specifications are part of a single CPU, it may be difficult to determine the relative ratio of performance between the different types of cores, especially as the speed of those cores is being adjusted -- and therefore utilization percentages are almost always a rough approximation.

=== Monitoring and Terminating Processes ===

==== Monitoring and Terminating Processes on Windows ====

===== Graphical User Interface =====

To manage processes graphically on Windows, use the ''Task Manager'' tool. You can access this from the Start menu, or by pressing Ctrl-Alt-Delete and selecting Task Manager from the menu that appears.

The Task Manager display shows processes grouped by executable name, along with approximate resource usage.

To terminate a process, select it using the mouse, and then click on the End Task button in the lower-right corner of the display.

===== Command Line Interface using the CMD Shell =====

To manage processes using the CMD shell (the default shell on Windows), use these commands:

1. '''tasklist''' - displays a list of tasks (processes) active on the system. You can use options to select which processes are displayed, as well as the output format (table, list, or comma-separated values).

2. '''taskkill''' - terminates a process. By default, this command attempts to get tasks to terminate in a safe manner (for example, if the program is saving a file, that operation will be completed before the program terminates). If a program does not respond to request, you can specify the <code>/f</code> option, which forcibly terminates the program.

You can specify the process to be terminated in one of two ways:
* By process ID, using the <code>/PID ''nnn''</code> option, which will terminate the process with the specified process ID.
* By image (program or library) name, using the <code>/IM ''name''</code> option, which terminates processes with the given image name. Asterisk wildcard characters may be specified as part of the name. Names must include the extension (for example, use <code>taskkill /im firefox.exe</code> or <code>taskkill /im firefox*</code> instead of <code>taskkill /im firefox</code>). 

The tasklist and taskkill commands also provide a mechanism for filtering the process selection; see the online documentation for details (<code>help tasklist</code> or <code>help taskkill</code>).

===== Command Line Interface using Powershell =====

Powershell is an alternate Windows shell. You can use these commands to view and terminate processes using Powershell:

1. '''get-process''' - Displays a list of current processes with basic information about each. You can specify a program name as a positional argument  (without the filename extension); see the online documentation for other available options.

2. '''stop-process''' - Terminates a process. You may specify a PID using the -ID option (<code>stop-process -id ''pid''</code>) or a program name (without the filename extension) using the -NAME option (<code>stop-process -name ''name''</code>).

{{Admon/tip|Short Names|Many Powershell commandlets (built-in commands) have short names. The short name for the <code>get-process</code> command is <code>ps</code> and the short name for the <code>stop-process</code> command is <code>kill</code>, which conveniently match the names of similar commands on Linux!}}

==== Monitoring and Terminating Processes on Linux ====

===== Command Line Interface =====

From the bash (default shell) command line on Linux, you can view the current process table using the process status command <code>ps</code>. By default, it will show only processes associated with the current shell, and will show only the process ID (PID), terminal, total execution time, and command name:

 $ '''ps'''
     PID TTY          TIME CMD
  303632 pts/4    00:00:00 bash
  303771 pts/4    00:00:00 ps

There are many ps options available to control which processes are displayed and what information is displayed about each process. These are the more commonly-used:

 '''-u ''user'' ''' - Displays all processes owned by ''user''
 
 '''-e''' - Shows every process
 
 '''-l''' - Shows long output, including process status (S), process ID (PID), parent process ID (PPID), approximate memory size (SZ), total execution time (TIME), and program name (CMD)
 
 '''-f''' - Shows full output, including process ID (PID), parent process ID (PPID), process start time (STIME), total execution time (TIME), and program name (CMD)

To terminate a process on Linux, send it a signal using the <code>kill</code> command. Processes are specified by ID:

 kill ''PID''

By default, processes are send the terminate signal (signal 15, SIGTERM). This requests that the process terminate gracefully (for example, by completing pending operations before stopping). If a program does not respond to this signal, the kill signal (signal 9, SIGKILL) may be specified; this signal tells the operating system to abruptly and forcefully terminate the process. Either of these forms is accepted:

 kill -9 ''PID''
 kill -KILL ''PID''

There are many other signals that may be sent to processes; to see a list of all available signals, run the command <code>kill -l</code> or see the online documentation for signal(7) (by running the command: <code>man 7 signal</code>).

To find all processes associated with a given program, use the pgrep command: <code>pgrep ''name''</code>

To terminate processes by program name, use the killall command: <code>killall ''name''</code>

===== Text User Interface =====

In addition to the command-line interface (CLI) tools mentioned above, there are several text user interface (TUI) tools available which display a full-screen view of the current process status which is updated periodically.

The most common TUI process monitoring tool is <code>top</code>, which displays output like this:

 top - 11:51:05 up 1 day, 22:23,  2 users,  load average: 0.63, 0.62, 0.66
 Tasks: 530 total,   1 running, 529 sleeping,   0 stopped,   0 zombie
 %Cpu(s):  1.2 us,  1.4 sy,  0.0 ni, 97.1 id,  0.0 wa,  0.2 hi,  0.1 si,  0.0 st
 MiB Mem :  28797.0 total,    730.7 free,  17121.8 used,  10944.4 buff/cache
 MiB Swap:   8192.0 total,   8188.0 free,      4.0 used.  10960.2 avail Mem 
 
 '''    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND'''
  299042 qemu      20   0   11.4g   8.2g  30336 S  18.5  29.2  23:06.23 qemu-system-x86                     
    2382 chris     20   0 1313576 201884  78048 S   2.6   0.7  11:56.51 Xorg                                
    7037 chris     20   0   33.0g 562524 275008 S   2.6   1.9  24:20.54 chrome                              
    2654 chris     20   0 6512860 298252 136624 S   2.3   1.0  16:25.62 gnome-shell                         
  304806 chris     20   0 1005964  54372  40312 S   2.3   0.2   1:00.46 gnome-system-mo                     
    8265 chris     20   0  851044  64084  39280 S   1.0   0.2  14:41.79 gnome-terminal-                     
    1111 polkitd   20   0  603836  12488   7528 S   0.7   0.0   3:37.71 polkitd                             
    7089 chris     20   0   33.0g 324364 171304 S   0.7   1.1   5:50.08 chrome                              
    7354 chris     20   0 1134.3g 355716 129476 S   0.7   1.2   6:32.51 chrome                              
  296095 chris     20   0 1132.2g 160168 115772 S   0.7   0.5   1:14.49 chrome                              
  299134 qemu      20   0   11.0g   2.9g  27264 S   0.7  10.2   1:25.34 qemu-system-x86                     
       1 root      20   0  217576  28572  10624 S   0.3   0.1   0:54.85 systemd                             
    1118 root      20   0   15232   7552   6784 S   0.3   0.0   0:25.38 systemd-machine                     
    2823 root      20   0  249680  19604   8064 S   0.3   0.1   7:15.86 sssd_kcm                            
    2955 chris     20   0  684472  17024  14720 S   0.3   0.1   9:13.72 gsd-smartcard                       
    3340 root      20   0  542844  13952  11776 S   0.3   0.0   0:04.69 abrt-dbus                           
    7090 chris     20   0   32.6g 155276 108568 S   0.3   0.5  13:29.98 chrome                              
    7363 chris     20   0 1132.3g 335376 120948 S   0.3   1.1   3:16.12 chrome                              
  295131 chris     20   0 1136.3g 426468 132800 S   0.3   1.4   3:13.88 chrome                              
  311918 chris     20   0  225500   4224   3072 R   0.3   0.0   0:00.21 top                                 
       2 root      20   0       0      0      0 S   0.0   0.0   0:00.20 kthreadd                            
       3 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 rcu_gp                              
       4 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 rcu_par_gp                          
       5 root       0 -20       0      0      0 I   0.0   0.0   0:00.00 slub_flushwq                        

This display is sorted by processor utilization (shown in the %CPU column); you can change the sort order to memory utilization (%MEM) by pressing Shift-M, and change back to processor utilization by pressing Shift-P.

By default, this display is updated every 3 seconds; you can change the update frequency by pressing S and typing a new update frequency (in seconds between updates).

To terminate a process, press K; the program will prompt you for the process ID to be killed (defaulting to the one at the top of the display, using the most resources), and the signal to be sent to that process (defaulting to signal 15, SIGTERM).

To see help messages about available options, press the ? key.

To exit from top, press the Q key (quit).

The <code>top</code> command is available on most Linux and Unix-like systems, including matrix.senecacollege.ca. There are several newer commands available, including <code>htop</code> and <code>btop</code>, but these are not present on all systems.

===== Graphical User Interface =====

If you're using a GUI on a Linux system, many graphical process monitoring and control tools are available, including the [https://gitlab.gnome.org/GNOME/gnome-system-monitor Gnome System Monitor] and [https://github.com/brndnmtthws/conky Conky].