Mislav Jurić

Tag: command

  • Linux Tutorial Series – 108 – Process priorities

    Here is the video version, if you prefer it:

    Let’s talk about process priorities today. Why do processes even have priorities?

    Let’s say that the world within your computer is like the real world. Let’s further imagine you are going about your day, doing your thing, driving your car, when all of a sudden you hear an ambulance. Uh-oh. You know you have to move yourself out of the ambulance’s way, because it has priority.

    By the same token, processes in your operating system have priorities, depending on how important they are. In Linux, processes have priorities which range from -20 to 20, with -20 being the most important. Yes, you read that right: -20 is the highest priority. (Ward, 2014)⁠

    There is also something called a nice value, which is added to the process priority. By default, it is 0. This makes sense – as we learned in the previous paragraph, the higher the priority (in terms of its number), the lower it actually is. So if a processes nice factor is 10, then its real priority is whatever priority it has + 10. The higher the nice value, the more nice the process, since it effectively lowers its own priority. You will most likely never have to meddle with the nice level of a process.

    Hope you learned something useful!

    References

    Ward, B. (2014). How Linux Works: What Every Superuser Should Know (2nd ed.). No Starch Press. Pages 179-180

  • Linux Tutorial Series – 107 – Measuring how much time it takes for your program to execute

    Here is the video version, if you prefer it:

    If you are a software developer, you sometimes want to know how much time does your program need to execute. Or, if you are a “regular” Linux user, maybe you want to know how much time a command takes to execute (albeit most likely not). Here is how to measure it: (Ward, 2014)⁠

    time programName

    An example:

    mislav@mislavovo-racunalo:~$ time ls

    ...

    real 0m0.004s

    user 0m0.000s

    sys 0m0.004s

    There are 3 relevant times: (“What do ‘real’, ‘user’ and ‘sys’ mean in the output of time(1)?,” n.d.)⁠

    • real time – the amount of CPU time from starting the call to finishing the call of the process; this includes the time your process waited for some resource and the time the processor was executing other processes (your processor can switch to another process and execute a fraction of that process, then get back to the execution of your process)
    • user time – the amount of CPU time spent within the process
    • sys time – the amount of CPU time spent in the kernel within the process; if you wanted to do some stuff that only the kernel can do (remember that a regular user can’t do everything), you call the kernel function to do that and then this gets added up to sys time

    The CPU time your process takes up is user + sys time.

    References

    Ward, B. (2014). How Linux Works: What Every Superuser Should Know (2nd ed.). No Starch Press. Pages 178-179

    What do “real”, “user” and “sys” mean in the output of time(1)? (n.d.). Retrieved February 14, 2020, from https://stackoverflow.com/questions/556405/what-do-real-user-and-sys-mean-in-the-output-of-time1

  • Linux Tutorial Series – 106 – Viewing threads

    Here is the video version, if you prefer it:

    To view threads you are currently running, you can either execute ps m or execute top, then press H to see a list of all the threads. (Ward, 2014)⁠ Examples for both:

    mislav@mislavovo-racunalo:~$ ps m

    PID TTY STAT TIME COMMAND

    5008 pts/1 - 0:00 bash

    - - Ss 0:00 -

    6695 tty2 - 0:00 /usr/lib/gdm3/gdm-wayland-session /usr/bin/gnome-sess

    - - Ssl+ 0:00 -

    - - Ssl+ 0:00 -

    - - Ssl+ 0:00 -

    Where there is a dash instead of a PID, that’s a thread.

    top - 20:44:14 up 96 days, 3:05, 1 user, load average: 0.58, 0.62, 0.62

    Threads: 864 total, 1 running, 862 sleeping, 0 stopped, 1 zombie

    %Cpu(s): 3.5 us, 4.1 sy, 0.0 ni, 92.4 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st

    MiB Mem : 7853.8 total, 1109.6 free, 4105.2 used, 2639.0 buff/cache

    MiB Swap: 8066.0 total, 6836.9 free, 1229.1 used. 3052.6 avail Mem

    …

    I got to this by pressing H after I ran top.

    Side note: I don’t think you will ever have to mangle with threads (I haven’t), but pays to know what they are and how to view them.

    Hope you learned something useful!

    References

    Ward, B. (2014). How Linux Works: What Every Superuser Should Know (2nd ed.). No Starch Press. Pages 177-178

  • Linux Tutorial Series – 105 – A trip back down the OS lane – threads

    Here is the video version, if you prefer it:

    Today, let’s go back down the good ol’ OS lane and talk about something called threads. A side note: I tried to fit in “memory lane”, but I couldn’t; it wouldn’t fit the content.

    A thread is a sequence of commands that can be executed. A process always has at least one thread, but it can have multiple threads.

    “Why have multiple threads?”, you may ask. A fair question. If you divide up the task into multiple threads (and assuming you have multiple processor cores), each thread can execute in its own core and the job can be done faster. An example: Say you were multiplying two matrices – each was of dimensions 20 000 x 20 000. You could do it in one thread, or maybe you could create 4 threads, each dealing with a particular part of the matrix. Or you could have 8 threads, or 80 threads – doesn’t matter. The point is, the more threads you have, the faster the program will execute, if you have the appropriate processor (one that has multiple cores) or multiple processors in your system (as in servers).

    A thing I want to mention: Even if you have one processor core, you may have many apps open and they seem to be working flawlessly. In that case, what is actually happening is that you have an illusion of multitasking – your processor is just switching between programs very fast. You don’t even notice that switch, but again, it is an illusion of parallel execution. (Ward, 2014)⁠

    A thing I also want to mention: Dealing with threads is hard. Like, real hard. An example: Say you have two threads running concurrently (at the same time). Let’s call them thread A and thread B. Say both of them want to write in the same memory location. What can happen? Well, thread A can write its result first, then thread B can write its result and you have the result of the thread B. The reverse is also possible – thread B can write its result and that result can get overridden by thread A. Or, thread A can be writing its result, thread B starts writing its result in the middle of thread A writing its result… It is a mess. And again, to repeat, it is hard to manage threads. There are mechanisms to deal with thread management, but just know that dealing with threads is hard.

    Hope you learned something useful!

    References

    Ward, B. (2014). How Linux Works: What Every Superuser Should Know (2nd ed.). No Starch Press. Page 5-6

  • Linux Tutorial Series – 104 – The pgrep and pkill commands

    Here is the video version, if you prefer it:

    Today, I will just throw a bug in your ear (this is a colloquialism in Croatia for “useful for you to know”) and tell you about two commands I have used – pgrep and pkill.

    You most likely won’t be needing those commands in most cases, but sometimes you know only the process name, but don’t know its ID and you want to end the process. Then you can use pgrep in combination with xargs (see here: (“Can I chain pgrep with kill?,” n.d.)⁠) or use pkill with the process name as the argument (“pkill(1) – Linux man page,” n.d.)⁠.

    Hope you learned something useful!

    References

    Can I chain pgrep with kill? (n.d.). Retrieved February 10, 2020, from https://unix.stackexchange.com/questions/138202/can-i-chain-pgrep-with-kill

    pkill(1) – Linux man page. (n.d.). Retrieved February 10, 2020, from https://linux.die.net/man/1/pkill

  • Linux Tutorial Series – 103 – The kill command

    Here is the video version, if you prefer it:

    Let’s talk about how to kill a process. That means to end a process; to terminate it. You can do this with the kill command.

    Usage of kill is this:

    kill <PID>

    where PID is the process ID of the process you want to kill (you can attain this ID using ps with its various options). By default, kill sends a TERM signal to the process. (Ward, 2014)⁠ You don’t really need to know any other signals. If the process doesn’t terminate after that, you can try using

    kill -KILL <PID>

    which sends the KILL signal, but use it as the last resort – it ends the process in an ugly way.

    Hope you learned something new!

    References

    Ward, B. (2014). How Linux Works: What Every Superuser Should Know (2nd ed.). No Starch Press. Pages 31-32

  • Linux Tutorial Series – 102 – Signals in operating systems – what are they used for?

    Here is the video version, if you prefer it:

    Today we will take a look at signals. They are very important in regard to operating systems and so they are relevant for Linux. Signals are a way for processes to communicate with one another. (“Signal (IPC),” n.d.)⁠

    Processes can’t access each other’s memory locations. So if Process A has memory locations 0 to 99 and Process B has memory locations 100 to 199, then if Process A tries to access memory location 129, operating system will not allow it.

    But, it is useful for processes to be able to communicate with each other. Let’s say Process A wants to somehow say to Process B “Stop! Stop!”. It can use a signal to do so.

    There are a lot of signals you can send to a process and they are listed here: (“POSIX signals,” n.d.)⁠. You don’t need to know their names. Just know what they are used for – communication between processes (also called inter-process communication (IPC)).

    Thank you for reading!

    References

    POSIX signals. (n.d.). Retrieved February 10, 2020, from https://en.wikipedia.org/wiki/Signal_(IPC)#POSIX_signals

    Signal (IPC). (n.d.). Retrieved February 28, 2020, from https://en.wikipedia.org/wiki/Signal_(IPC)

  • Linux Tutorial Series – 101 – The jobs command

    Here is the video version, if you prefer it:

    The jobs command displays status of jobs in your current Terminal session. (Barrett, 2016)⁠ Jobs are programs you are running in your current shell. The difference between jobs and processes is that processes are a operation systems term, while jobs are shell specific term – job is any program you start in the shell (whether in the foreground or in the background). (“What is the difference between a job and a process?,” n.d.)⁠

    I never used this command so far, so just mentioning it here.

    Thank you for reading!

    References

    Barrett, D. J. (2016). Linux pocket guide (3rd ed.). O’Reilly Media. Page 40

    What is the difference between a job and a process? (n.d.). Retrieved February 28, 2020, from https://unix.stackexchange.com/questions/4214/what-is-the-difference-between-a-job-and-a-process

  • Linux Tutorial Series – 100 – The top command

    Here is the video version, if you prefer it:

    To view processes dynamically, use top. (Shotts, 2019) It displays which processes are using up your resources the most – the ones using the most resources is always at the top of the list.

    An example:

    mislav@mislavovo-racunalo:~$ top

    top - 20:34:02 up 96 days, 2:55, 1 user, load average: 1.11, 0.79, 0.62

    Tasks: 237 total, 1 running, 235 sleeping, 0 stopped, 1 zombie

    %Cpu(s): 5.2 us, 0.7 sy, 0.0 ni, 93.3 id, 0.0 wa, 0.0 hi, 0.7 si, 0.0 st

    MiB Mem : 7853.8 total, 985.1 free, 4153.0 used, 2715.7 buff/cache

    MiB Swap: 8066.0 total, 6826.2 free, 1239.8 used. 3013.4 avail Mem

    PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND

    1145 mislav 20 0 874948 216852 29184 S 33.3 2.7 89:30.61 gedit

    6729 mislav 20 0 4991000 460424 110440 S 13.3 5.7 1631:07 gnome-she+

    15544 mislav 20 0 11276 3644 3060 R 6.7 0.0 0:00.01 top

    ...

    ⁠I won’t go into the details of the column names or the meaning of each element of the summary statistics here. I will leave that for review, when we cover all of the relevant concepts. For now, just remember that top is a command that displays the processes with the most resource-intensive processes closer to the top of the process list.

    Hope you learned something useful!

    References

    Shotts, W. (2019). The Linux Command Line, Fifth Internet Edition. Retrieved from http://linuxcommand.org/tlcl.php. Pages 137-139

  • Linux Tutorial Series – 99 – The ps command

    Here is the video version, if you prefer it:

    The ps command is used to display the processes which are currently running. By running ps without any options, you get the processes associated with the current Terminal, as so:

    mislav@mislavovo-racunalo:~/Linux_folder$ ps

    PID TTY TIME CMD

    10653 pts/1 00:00:00 bash

    31210 pts/1 00:00:00 ps

    PID is process ID. TTY is the controlling terminal associated with the process – this field is irrelevant. TIME is processor time the process is taking up – the more processor time a process takes up, the more demanding it is. CMD is the command with which we started the process; it’s the name of the process, with arguments, if arguments exist. (Shotts, 2019)⁠

    ps x gives us all the processes that our current user is running. An example:

    mislav@mislavovo-racunalo:~/Linux_folder$ ps x

    PID TTY STAT TIME COMMAND

    1145 ? Sl 78:18 /usr/bin/gedit --gapplication-service

    3350 ? Ss 0:22 /lib/systemd/systemd --user

    3351 ? S 0:00 (sd-pam)

    3455 ? Ssl 1397:59 /usr/bin/pulseaudio –daemonize=no

    ...

    The new column STAT is short for state. State is the process state – it indicates what the process is doing. The first capital S means that process is sleeping, and that means the process is waiting for input. There are other process states, which you can learn more about by typing man ps and navigating to a section titled PROCESS STATE CODES.

    ps aux gives us the processes of all users. Its sample output is:

    mislav@mislavovo-racunalo:~/Linux_folder$ ps aux

    USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND

    root 1 0.0 0.0 170896 5584 ? Ss 2019 26:40 /sbin/init

    root 2 0.0 0.0 0 0 ? S 2019 0:01 [kthreadd]

    root 3 0.0 0.0 0 0 ? I< 2019 0:00 [rcu_gp]

    root 4 0.0 0.0 0 0 ? I< 2019 0:00 [rcu_par_gp]

    …

    As you can see here, we can see which user started each process (the column USER). We have a couple of additional columns – %CPU signifies how much CPU (in percentages) the process are using, %MEM is the percentage of RAM the process are using, VSZ is the virtual memory size (think of virtual memory as being as large as your hard drive and RAM size combined), RSS (Resident Set Size) is the amount of RAM the process is using in kilobytes, and START is the time when the process had started.

    This is how you can take a look at the processes running in your computer.

    Hope you learned something useful!

    References

    Shotts, W. (2019). The Linux Command Line, Fifth Internet Edition. Retrieved from http://linuxcommand.org/tlcl.php. Pages 135-137