Journal

Linux Processes

Sat, 02 Nov 2019 15:26:54 +0000

The instance of a program that is being executed by one or many threads is called a process. Any command that you give to your machine starts a new process. It is basically the running instance of your program, made up of instructions and sometimes with some form of input such as data from a file or user input.

While a program is a passive collection of instructions, a process is the actual execution of those instructions. A program may be run on multiple processes.

Fundamentally, we have two kinds of processes; the ones running in the background and the ones that run interactively. Background processes run automatically without expecting a user input while foreground processes are usually started and controlled through a terminal session.

We also have daemons - these are background processes that start when you boot up your machine and keep running forever, unless they are stopped.

Properties of a process

You can see the status of currently running processes by running the ps command. This command will also show you certain properties of these processes, should you ask about them by passing arguments like ps -o pid,ppid,tty,uid,args.

PID: Every process has a unique identifier associated to it. You can reference a specific process using their PID.

PPID: The PID of the parent process. Parent of a process is the process that was responsible for its creation. In the above example, the process for the ps command was initiated by /bin/bash, as you can see the PPID of it is same as bash PID.

TTY: The identifier of the terminal session that triggered this process. Almost every process will be attached to a terminal (except daemons). In the example above you can see that I have a terminal sessions running (pts/1). You can check your current tty by running the tty command.

UID: The identifier for the user who is the owner of this process, which will define the permissions available for this process. Run the command id -u yourUsername to check your user id.

ARGS: The command (followed by its arguments) that’s running in this process.

There are tons of properties besides the ones I’ve mentioned above, such as fname, start, cgname, class, machine, nwchan, c, %mem, pidns, pgid. Check the man ps for a long list of keywords available.

The init process

init is the first program that’s executed when the linux system boots up, so it doesn’t really have a parent process.

The Kernel, User Space and Kernel Space

The kernel is the program that controls all other programs on the computer, talking both to the hardware and software, managing resources.

A modern OS will usually isolate virtual memory into kernel space and user space, to provide memory and hardware protection from malicious behaviour.

Kernel space is reserved for running a privileged OS kernel, its extensions and most device drivers, while user space is the memory area where normal user processes (anything other than the kernel) can execute.

Processes that are running in the user space will only have access to this limited part of memory, while kernel can access all of the memory.

The Shell

A shell program is a command-line interface on a computer that allows the user to interact with the file system (a.k.a. the user space). In most operating systems, you access the shell (eg. bash) through a terminal emulator (eg. Konsole).

To run programs and start processes, the shell needs to pass it to the kernel. Basically, the shell is your interface to communicate with the kernel.

When you run ls -l, The shell reads the command from the getline() function’s STDIN, parses the command into arguments that will be then passed to the program it is executing. The shell checks if ls is an alias. If it is, the alias replaces ls with its value. If it isn’t an alias, the shell checks if this is a built-in command.

Then the shell will try to find a program file for this ls command. How would it know where to look for it?

The shell environment holds a bunch of environment specific variables, including a well known one that is $PATH. $PATH is a list of directories that shell can search in upon receiving a command. You can see your environmental variables by running the printenv command.

This is how a sample$PATH would look like: PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games

$PATH will be parsed using the = as the delimiter, then all the directories within the path will be tokenized and parsed further with : as the delimiter.

Most of the built-in executable programs live within /usr/bin, so the shell will find the program for ls at /usr/bin/ls location.

Most programs can take options and/or arguments. ls lists the contents found in the current working directory. It can take a specific directory as the argument and it would then list files under that directory.

Most options actually stand for something that is longer to type. Each program defines its options (like -l for ls) and arguments (like /foo for listing ls /foo) that it will expose to users.

Most of the programs differentiate options from arguments by requiring a dash (-) or two dashes (–) before them. For some options you can define a value, like --dir=/home/username/foo.

The order of options and arguments might matter, and options come before arguments do in most cases. So if you were to run ls /foo -l in a system without GNU C library, you would make ls treat -l as another directory. In GNU & GNU/Linux many programs will automatically treat the options as if they were typed before the arguments, so running ls /foo -l still works.

Let’s summarize what’s happening when you run ls -l.

Shell uses getline() to receive the user given command and it stores this into a buffer.
Shell uses strtok() to tokenize each word found in the command using space as the delimiter.
Checks for aliases. For example, ll is an alias for ls -l. When you run ll, the shell will replace this with the full command.
Checks if the received command is a built-in command. This is sort of like looking a function’s definition first within the current namespace in PHP. If the program is contained within the shell itself, it’ll just run it directly.
Search for the command within the directories found in the $PATH, if it was not a built-in program.
The shell will use a system call fork() to create a child process that the program can run on, and when it’s done executing we get back to the shell. It uses the system call wait() to wait until the program operation is finalized before exiting back to the command prompt.
If the found program is executable, the shell will use the execve() system call to execute the program in the child process.
Once the execution is complete, any returns from the program will be returned, anything the program wants to print out, like the list of directories in the current working directory, will be displayed on the command prompt.

Exit codes

An exit code is the code returned to a parent process (caller) by a child process (callee) that has finished executing. The child process exits by calling the exit syscall when it finishes executing. This syscall passes the exit status code back to the parent, which can retrieve it using the wait syscall.

On POSIX systems the standard exit code is 0 for success and any number from 1 to 255 for anything else. You can find some of the well accepted exit codes listed at the related section of the Advanced Bash-Scripting Guide.

If the child process exits and the parent somehow fails to wait, you get a zombie process. These zombie processes don’t really exist anymore, yet they will still show up in the process table with a status Z. The kernel cannot right away get rid of a process when it exits, since this would make it impossible to read its exit code, so it just waits until the parent calls wait and then it gets fully removed.

If a child process is still running, but it’s parent exits (because it crashed etc), then you get an orphan process. Orphan processes get ‘adopted’ by the init process (or launchd on Mac OS, basically the very first process executed) and their PPID will be 1.

A process can become a daemon by being made an orphan process on purpose (eg. by forking a child and immediately exiting). This is useful when you’d like to detach a long running process from your session. Usually one makes use of signals to terminate daemon processes using the kill syscall. kill actually just send a message (any message available, see kill -l), it doesn’t terminate a process by default.

With the exception of SIGKILL and SIGSTOP, processes can trap a signal to ignore it completely or to take some custom action. If Ctrl-c doesn’t kill the process, your target process probably traps it to do something before exiting.

The init process can ignore even a SIGKILL or a SIGSTOP signal, because the kernel forces a system crash if the init process terminates, so it will ignore any such signal.

System calls, interrupts and processor modes

A system call lets a program to requests a service from the kernel. They act as an interface between a process and the OS it is running on. This could be a hardware-related request like accessing the file system, creating, executing or scheduling a new process. In most systems, system calls can only be made from user space processes.

The architecture of most modern processors (except some embedded systems) involves a security model. Ie. the rings model specifies multiple privilege levels under which software may be executed.

Usually all programs run in their own address space so that they aren’t allowed to access or modify other programs, devices or the OS itself.

However, many applications do need access to these components, so the OS exposes the system calls to provide safe implementations for such operations. The OS is executing at the highest level of privilege possible and it allows applications to use system calls to request services. These are often initiated via interrupts.

An interrupt puts the CPU into some elevated privilege level automatically, then passes control to the kernel. The kernel determines whether the calling program shall be granted the requested service. If the service is granted access, the kernel will execute a set of instructions over which the calling program has no direct control. It will then return to the privilege level of the calling program, and return the control back to the calling program.

Usually a library or API sits between normal programs and the OS. On Unix-like systems, this API is generally part of an implementation of the libc (such as glibc), providing wrapper functions for system calls.

On Windows NT, this comes in the Native API (ntdll.dll) and it is used by implementations of the regular Windows API and by some system programs on Windows. These wrapper functions expose a function calling convention (a subroutine call on the assembly level) for using the system call. They place the arguments to be passed to the syscall in the appropriate registers and set a unique system call number for the kernel to call.

The call to the library function is usually a subroutine call, it doesn’t cause a switch to kernel mode (if the execution was not already in kernel mode). The actual system call transfers control to kernel and it’s more implementation and platform dependent than the library call abstracting it. E.g. in Unix-like systems, fork and execve are libc functions that invoke the fork and exec system calls.

The library functions are meant to abstract away the implementation to avoid making the system call directly in the application code. The low-level interface for the syscall operation can change over time and thus it should not be a part of the ABI.

Some known system calls (in Unix-like and other POSIX-compliant OSes) are open, read, write, close, wait, exec, fork, exit, and kill.

Many modern operating systems have hundreds of system calls. Check out syscalls page for a long list of syscalls available in Linux.

Tools such as strace, ftrace and truss allow a process to execute from start and report all system calls the process invokes. They can also be attached to a running process and intercept any system calls it is making. This functionality is usually also implemented with a system call, e.g. strace is implemented with ptrace or system calls on files in procfs.

There are different categories of syscalls: process control (eg. fork to create a process, get/set process attributes, allocate and free memory), file management (eg. create/delete/open/close/read/write files), device management (eg. logically attach/detach devices, get/set device attributes), information maintenance (eg. get/set time or date, system data, process, file or device attributes), communication (eg. send/receive messages, transfer status info), protection (eg. get/set file permissions).

Processor Modes

Processor modes (a.k.a CPU modes, CPU states or CPU privilege levels) are operating modes for the CPU of certain architectures that place restrictions on the type and scope of operations that can be performed by processes being run by the CPU. This allows the OS to run at a higher privilege level than any other software.

Only the kernel code runs in unrestricted mode while everything else runs in a restricted mode and needs to use system calls via interrupts to ask the kernel to run operations on its behalf. However, syscalls might hurt performance or take some time, so it’s not that uncommon for system designers to allow some time-critical software (eg. device drivers) to run with full kernel privileges.

The unrestricted mode is often called kernel mode (or master mode, supervisor mode, privileged mode, etc.). Restricted modes are usually referred to as user modes (or slave mode, problem state, etc.).

In kernel mode, the CPU can perform any operation allowed by its architecture, letting any instruction that may be executed, any I/O operation initiated, any area of memory accessed, and so on. In other modes, certain restrictions on CPU operations are enforced by the hardware. Typically, altering the global state of the machine is not allowed and some memory areas cannot be accessed etc.

Must-reads on this topic

Notes on Analyzing Database Queries

Tue, 01 Oct 2019 07:15:21 +0000

This is an interesting topic to dive into. While I personally prefer PostgreSQL most of the time, this post will mostly have my notes on MySQL side of things.

What’s index cardinality?

Cardinality literally means number of elements of a given set. For the very interested, the relation of having the same cardinality is called equinumerosity, and this is an equivalence relation on the class of all sets.

What does it have to do with the database or queries then?

Well, considering a table holds a set of rows and columns, the number of records in the table can be referred as it’s cardinality. For an index, cardinality is considered to be the number of unique values in the index.

A unique index would have cardinality equal to the number of rows in the table. But a non-unique index can have a cardinality of anywhere from 1 to the number of rows in the table, depending on how many times each index key appears in the table.

Indexes with relatively few unique values are considered to be low cardinality indexes. If a column can only take a yes or no would have a cardinality of 2. Columns like status, color, currency would have a small set of unique values, hence they are good examples to low cardinality indexes.

The lower the cardinality, the more duplicated elements you would have in a column. Thus, a column with the lowest possible cardinality would have the same value for every row.

Indexes work best for columns that have a high cardinality relative to the number of rows in the table (that is, columns that have many unique values and few duplicates).

If a column contains many different age values, an index will differentiate rows readily. An index will not help for a column that is used to record sex and contains only the two values ‘M’ and ‘F’.

If the values occur about equally, you’ll get about half of the rows whichever value you search for. Under these circumstances, the index might never be used at all, because the query optimizer generally skips an index in favor of a full table scan if it determines that a value occurs in a large percentage of a table’s rows.

Low cardinality isn’t always bad.

Say your col1 can only take two distinct values and your FOO:BAR ratio looks like below.

mysql> SELECT col1, COUNT(*) FROM test GROUP BY col1;

col1	COUNT(*)
FOO	5909
BAR	10

We've got low cardinality (with just 2 possible values) yet if we are just looking for "BAR" rows then they should be easy to find with the index.

I haz an index, why is it not used!?

Just because you have the index there it doesn’t mean that MySQL will decide to use it. MySQL can be smart enough to know about the distribution of the data and can decide that it would be much faster to just go through all of the data rather than the n% that it could return from the index lookup. When the query is restrictive enough however, it would know it will be better to use the index.

Notes on indexes

Index short values

Use smaller data types when possible. Don’t use a BIGINT column if a MEDIUMINT is large enough to hold the values you need to store. Don’t use CHAR(100) if none of your values are longer than 25 characters.
Shorter values can be compared more quickly, so index lookups are faster.
Smaller values result in smaller indexes that require less disk I/O.
With shorter key values, index blocks in the key cache hold more key values. MySQL can hold more keys in memory at once, which improves the likelihood of locating key values without reading additional index blocks from disk.
If you’re indexing a string column, specify a prefix length whenever it makes sense.

Leftmost prefixes

When you create an n-column composite index, you actually create n indexes that MySQL can use. A composite index serves as several indexes because any leftmost set of columns in the index can be used to match rows. Such a set is called a “leftmost prefix.”

Given a table with a composite index on columns named state, city, and zip, rows in the index are sorted in state, city, zip order, so they’re automatically sorted in state, city order and also in state order. This means that MySQL can take advantage of the index even if you specify only state values in a query, or only state and city values. Thus, the index can be used to search the following combinations of columns: state, city, zip or state, city or just state

MySQL cannot use the index for searches that don’t involve a leftmost prefix. So, if you search by city or zip, the index isn’t used at all.

Avoid over-indexing

Every additional index takes extra disk space and hurts performance of write operations.
Indexes must be updated and possibly reorganized when you modify the contents of your tables. The more indexes you have, the longer this will take.
MySQL considers indexes when generating an execution plan for retrievals. Creating extra indexes creates more work for the query optimizer.
It’s also possible (if unlikely) that MySQL will fail to choose the best index to use when you have too many indexes. Maintaining only the indexes you need helps the query optimizer avoid making such mistakes.

If you’re thinking about adding an index to a table that is already indexed, consider whether the index you’re thinking about adding is a leftmost prefix of an existing multiple-column index. If so, don’t bother adding the index because, in effect, you already have it. (Following the example above, if you already have an index on state, city, and zip, there is no point in adding an index on state.)

Oh also, Use the slow-query log to identify queries that are taking too long.

Understand how the query optimizer works

The query optimizer has different goals, but it will primarily aim to use the most restrictive index in order to eliminate as many rows as possible, as soon as possible. The faster it can eliminate rows from consideration, the more quickly the rows that do match your criteria can be found.

How do I help the optimizer?

Try to compare columns that have the same data type.
Try to make indexed columns stand alone in comparison expressions.
- If you use a column in a function call or as part of a more complex term in an arithmetic expression, MySQL can’t use the index because it must compute the value of the expression for every row. Sometimes this is unavoidable, but often you can rewrite a query to get the indexed column to appear by itself.
- Say you have an indexed created_date column and you do a query like: SELECT * FROM test WHERE YEAR(created_date) < 1990;
  - The expression doesn’t compare 1990 to an indexed column; it compares 1990 to a value calculated from the column, and that value must be computed for each row.
  - As a result, the index on created_date is not used because performing the query requires a full table scan.
  - You can fix this by just using a literal date like WHERE created_date < 1990-01-01
Don’t use wildcards at the beginning of a LIKE pattern if you’re really looking for the string only when it occurs at the beginning of the column, leave out the first %.
Use EXPLAIN to verify optimizer operations. EXPLAIN FORMAT=JSON is very, very cool. See the must-reads section for an awesome read about this one.
Avoid overuse of MySQL’s automatic type conversion.

if int_col is an integer column, each of these queries will return the same result:

SELECT * FROM test WHERE int_col = 7;

SELECT * FROM test WHERE int_col = '7';

BUT, the second query involves a small performance penalty for converting the integer and string to double to perform the comparison. A more serious problem is that if int_col is indexed, a comparison that involves type conversion may prevent the index from being used. Same can happen when comparing a string column to a numeric value.

There’s a lot more to touch when it comes to analyzing queries, indexes and the inner workings of the optimizer that I may come back here with more notes. I’ve listed a few great readings below for the interested.

Must-reads on this topic

Message Queues: RabbitMQ

Thu, 16 Nov 2017 17:39:59 +0000

Related posts: Message Queues: Overview

RabbitMQ is a message broker; it accepts and forwards messages just like a post office.

Producing means sending a message. Producers receive sent messages. A queue is the name of a post box which lives inside RabbitMQ, only bound by the host’s memory and disk limits. Essentially it is a large message buffer. Many producers can send messages that go to one queue and many consumers can try to receive data from that queue.

Consumers are programs that mostly wait to receive messages.

Sending

The publisher will connect to RabbitMQ, send a single message, then exit.

Channel is where most of the API for getting things done resides. To send a message we declare a queue for us to send to; then we can publish a message.

Declaring a queue is idempotent. Message content is a byte array so one can encode whatever needed.

<?php declare(strict_types = 1);

use PhpAmqpLib\Connection\AMQPStreamConnection;
use PhpAmqpLib\Message\AMQPMessage;

$connection = new AMQPStreamConnection('localhost', 5672, 'guest', 'guest');
$channel = $connection->channel();

$channel->queue_declare('hello', false, false, false, false);

$msg = new AMQPMessage('Hello World!');
$channel->basic_publish($msg, '', 'hello');

echo " [x] Sent 'Hello World!'\n";

$channel->close();
$connection->close();

Receiving

Same as sending, we open a connection and a channel and then declare a queue from which we will consume.

Our code will block while our channel has callbacks. Whenever we receive a message our callback function will be passed the received message.

<?php declare(strict_types = 1);

use PhpAmqpLib\Connection\AMQPStreamConnection;

$connection = new AMQPStreamConnection('localhost', 5672, 'guest', 'guest');
$channel = $connection->channel();

$channel->queue_declare('hello', false, false, false, false);

echo ' [*] Waiting for messages. To exit press CTRL+C', "\n";

$callback = function($msg) {
  echo " [x] Received ", $msg->body, "\n";
};

$channel->basic_consume('hello', '', false, true, false, false, $callback);

while(count($channel->callbacks)) {
    $channel->wait();
}

Exchanges

Messages are not published directly to a queue, instead, the producer sends messages to an exchange.

An exchange is responsible for the routing of the messages to the different queues.
An exchange accepts messages from the producer application and routes them to message queues with the help of bindings and routing keys.
A binding is a link between a queue and an exchange.

Message Flow in RabbitMQ

The producer publishes a message to an exchange. When you create the exchange, you have to specify the type of it. Read about different types of exchanges.
The exchange receives the message and is now responsible for the routing of the message. The exchange takes different message attributes into account, such as routing key, depending on the exchange type.
Bindings have to be created from the exchange to queues. In this case, we see two bindings to two different queues from the exchange. The Exchange routes the message into the queues depending on message attributes.
The messages stay in the queue until they are handled by a consumer
The consumer handles the message.

Key terminology:

Producer: Application that sends the messages.

Consumer: Application that receives the messages.

Queue: Buffer that stores messages.

Message: Information that is sent from the producer to a consumer through RabbitMQ.

Connection: A connection is a TCP connection between your application and the RabbitMQ broker.

Channel: A channel is a virtual connection inside a connection. When you are publishing or consuming messages from a queue - it’s all done over a channel.

Exchange: Receives messages from producers and pushes them to queues depending on rules defined by the exchange type. In order to receive messages, a queue needs to be bound to at least one exchange.

Binding: A binding is a link between a queue and an exchange.

Routing key: The routing key is a key that the exchange looks at to decide how to route the message to queues. The routing key is like an address for the message.

AMQP: AMQP (Advanced Message Queuing Protocol) is the protocol used by RabbitMQ for messaging.

Users: It is possible to connect to RabbitMQ with a given username and password. Every user can be assigned permissions such as rights to read, write and configure privileges within the instance. Users can also be assigned permissions to specific virtual hosts.

Vhost, virtual host: A Virtual host provides a way to segregate applications using the same RabbitMQ instance. Different users can have different access privileges to different vhost and queues and exchanges can be created so they only exist in one vhost.

Resources

Message Queues: Overview

Thu, 16 Nov 2017 16:19:59 +0000

Queue

A queue is a kind of abstract data type, a collection, in which the entities are kept in order and its main operations are enqueuing additional entities to the rear terminal position, dequeuing entities from the front. Hence a queue is a sequential, first in first out (FIFO) data structure.

A bounded queue is a queue with a fixed (limited) size.

An efficient implementation of a queue should perform the operations - enqueuing and dequeuing - in O(1) time. There are several implementations;

A doubly linked list has O(1) insertion and deletion at both ends.
A sinly linked list only has efficient insertion and deletion at one end, however keeping a pointer to the last note in addition to the first one allows one to implement a more efficient queue.
A deque implemented using a modified dynamic array.

Message Queues

Message queues provide an asynchronous communication protocol where the sender and receiver do not need to interact with the queue at the same time. Messages inserted into the queue are stored until the recipient retrieves them.

You could consider a queue as a line of tasks waiting to be handled in a sequential order. A message queue is a list of messages sent between applications. A message is the transported data between the sender and receiver applications. Essentially it is a byte array with some headers. A message could tell a system to start processing a task or contain a response from a finished task or just be a plaintext.

The consumer application connects to the queue and gets the messages to be placed, until then the messages are stored within the queue.

Consider an email.

When an email is sent the sender keeps processing other things without an instant response from the receiver. This decouples producers and consumers of a message, allowing them to interact with the queue separately from each other.

Imagine you have a service that receives many requests every second, where no request is affordable to lose and all requests need to be processed by a process that consumes plenty of time. If you want your service to always be highly available and ready to receive more requests instead of being locked processing the previous requests, it is very ideal to implement a queue between the services that take and process requests.

Scaling such a system can be done now by adding more workers and receivers to work on queues faster.

AMQP - Advanced Message Queuing Protocol

An open standard application layer protocol for message-oriented middleware, featuring message orientation, queuing, routing (pub-sub, point-to-point), reliability and security. AMQP mandates the behavior of the messaging provider and client to the extent that implementations from different vendors are interoperable, in the same way as SMTP, HTTP, FTP, etc.

The basic unit of data in AMQP is a frame. There are nine AMQP frame bodies defined that are used to initiate, control and tear down the transfer of messages between two peers. These are:

open
begin
attach
transfer
flow
disposition
detach
end
close

The link protocol is at the heart of AMQP.

An attach frame body is sent to initiate a new link; a detach to tear down a link. Links may be established in order to receive or send messages.

Messages are sent over an established link using the transfer frame. Messages on a link flow in only one direction.

Transfers are subject to a credit based flow control scheme, managed using flow frames. This allows a process to protect itself from being overwhelmed by too large a volume of messages or more simply to allow a subscribing link to pull messages as and when desired.

AMQP 0-9-1 Model

According to this model messages are published to exchanges, which are often compared to mailboxes. Exchanges then distribute message copies to queues using bindings. Then AMQP brokers either deliver messages to consumers subscribed to the queues or consumers fetch/pull messages from queues on demand.

Networks are unreliable and applications may fail to process messages therefore the AMQP model has a notion of message acknowledgements: when a message is delivered to a consumer the consumer notifies the broker, either automatically or as soon as the application developer chooses to do so. When message acknowledgements are in use, a broker will only completely remove a message from a queue when it receives a notification for that message (or group of messages).

STOMP - Streaming Text Oriented Message Protocol

STOMP/TTMP, is a simple text-based protocol, designed for working with message-oriented middleware. It provides an interoperable wire format that allows STOMP clients to talk with any message broker supporting the protocol. It is thus language-agnostic, meaning a broker developed for one programming language or platform can receive communications from client software developed in another language.

Being very similar to HTTP, it works over TCP using the following commands

CONNECT
SEND
SUBSCRIBE
UNSUBSCRIBE
BEGIN
COMMIT
ABORT
ACK
NACK
DISCONNECT

Communication between client and server is through a frame consisting of a number of lines. The first line contains the command, followed by headers in the form : (one per line), followed by a blank line and then the body content, ending in a `null character`. Communication between server and client is through a `MESSAGE`, `RECEIPT` or `ERROR frame` with a similar format of headers and body content.

POSIX message queues

POSIX message queues allow processes to exchange data in the form of messages, providing similar functionality to System V message queues (msgget, msgsnd, msgrcv).

Message queues are created with mq_open which returns a message queue descriptor (mqd_t) which is used to refer to the opened message queue in later calls.
Two processes can operate on the same queue by passing the same name to mq_open.
Messages are transferred to and from a queue using mq_send and mq_receive.
When a process has finished using the queue, it closes it using mq_close, and when the queue is no longer required, it can be deleted using mq_unlink.
Queue attributes can be retrieved and (in some cases) modified using mq_getattr and mq_setattr.
A process can request asynchronous notification of the arrival of a message on a previously empty queue using mq_notify.
On Linux, a message queue descriptor is actually a file descriptor, and can be monitored using select, poll, or epoll.

Next: Message Queues: RabbitMQ

Resources

AMQP Concepts

Collision Resolution: Linear Probing

Mon, 30 Oct 2017 02:44:44 +0000

Related data structures: Hashtable, Array

Linear Probing

This method resolves the problem by probing or searching through alternative locations in the probe sequence until the target or an unused slot is found.

When two records demand for the same location in the hash table, the collision can be solved by placing second record linearly down wherever an empty location is found. Lookups are performed in the same way (by searching the table sequentially starting at the position given by the hash function) until finding a cell with a matching key or an empty cell. Because linear probing is especially sensitive to unevenly distributed hash values, it is important to combine it with a high-quality hash function that does not produce such irregularities.

Consider the following hash table.

Index	Data
0
1	131
2	21
3	31
4	4
5	5
6	61
7	7
8	8
9

Given the hash table on the left, if the first number which is to be placed is 131 then 131 % 10 equals to 1. The remainder is 1, so the hash key is 1. That means we are supposed to place the record at index 1.

Next number is 21 which also gives hash key = 1 as 21 % 10 = 1. But 131 is already placed at index 1. That means collision has occurred. We will now apply linear probing.

In this method, we will search the place for number 21 from location of 131. In this case we can place the number 21 at index 2. Then if 31 has to be stored, it can be stored at index 3. Similarly, 61 can be stored at 6 because number 4 and 5 are stored before 61.
This technique makes the search operation efficient, as we have to search only limited list to obtain the desired number.

Example hashtable implementation holding maximum 10 student records.

#include<stdio.h>
#include<stdlib.h>
 
#define LIMIT 10
 
enum record_status {EMPTY, DELETED, OCCUPIED};
 
struct Student
{
    int student_id, student_age;
    char student_name[42];
};
 
struct Record
{
    struct Student info;
    enum record_status status;
}; 
 
int hash_function(int key)
{
    return (key % LIMIT);
}
 
int search_records(int key, struct Record hash_table[])
{
    int count, temp, position;
    temp = hash_function(key); 
    position = temp;

    for (count = 1; count != LIMIT - 1; count++) {
        if (hash_table[position].status == EMPTY) {
            return -1;
        }

        if (hash_table[position].info.student_id == key) {
            return position;
        }

        position = (temp + count) % LIMIT; 
    }
    
    return -1;
}
 
void insert_records(struct Student student_rec, struct Record hash_table[])
{
    int count, position, temp;
    int key = student_rec.student_id;
    temp = hash_function(key); 
    position = temp; 

    for (count = 1; count != LIMIT - 1; count++) {
        if (hash_table[position].status == EMPTY || hash_table[position].status == DELETED) {
            hash_table[position].info = student_rec;
            hash_table[position].status = OCCUPIED; 
            printf("\nNew record inserted into hashtable.\n");
            return;
        }

        if (hash_table[position].info.student_id == key) {
            printf("\nCannot insert duplicate record.\n");
            return;
        }

        position = (temp + count) % LIMIT; 
    }

    printf("\nHashtable limit exceeded.\n");
}
 
void print_records(struct Record hash_table[])
{
    int count;
    printf("\nHashtable\n");

    for (count = 0; count < LIMIT; count++) {
        printf("\n[%d]:\t", count);

        if (hash_table[count].status == OCCUPIED) {
            printf("Occupied - ID: %d Name: %s Age: %d", hash_table[count].info.student_id, hash_table[count].info.student_name, hash_table[count].info.student_age);
        } else if(hash_table[count].status == DELETED) {
            printf("Record was deleted\n");
        } else {
            printf("Empty\n");
        }
    }
}
 
void delete_records(int key, struct Record hash_table[])
{
    int position = search_records(key, hash_table);

    if (position == -1) {
        printf("\nCould not find the key\n");
    } else {
        hash_table[position].status = DELETED;
    }
}
 
int main()
{
    int count, key, option;
    struct Record hash_table[LIMIT];
    struct Student student_rec;

    for (count = 0; count <= LIMIT - 1; count++) {
        hash_table[count].status = EMPTY;
    } 

    while(1) {
        printf("1. Insert a student record\n");
        printf("2. Delete a student record\n");
        printf("3. Search a student by ID\n");
        printf("4. Display All\n");
        printf("5. Exit\n");
        printf("Enter option number:\t");
        scanf("%d", &option);

        switch(option)
        {
            case 1: 
                printf("\nEnter Student ID:\t");
                scanf("%d", &student_rec.student_id); 
                
                printf("Enter Student Name:\t");
                scanf("%s", student_rec.student_name);

                printf("Enter Student Age:\t");
                scanf("%d", &student_rec.student_age);

                insert_records(student_rec, hash_table);
                break;

            case 2: 
                printf("\nEnter the key (ID) to delete a student:\t");
                scanf("%d", &key);

                delete_records(key, hash_table);
                break;

            case 3: 
                printf("\nEnter the key (ID) to search for a student:\t");      
                scanf("%d", &key);
                count = search_records(key, hash_table);

                if (count == -1) {
                    printf("\nCould not find a student record with given ID.\n");
                } else {
                    printf("\nStudent record found at index position:\t%d\n", count);
                }
                break;

            case 4: 
                print_records(hash_table);
                break;

            case 5: 
                exit(1);
        }
    }

    return 0;
}

Collision Resolution: Bucket Hashing

Mon, 30 Oct 2017 01:14:59 +0000

Related data structures: Hashtable, Array

Bucket Hashing

Bucket hashing is treating the hash table as a two dimensional array instead of a linear array.

Consider a hash table with S slots that are divided into B buckets, with each bucket consisting of S/B slots. The hash function assigns each record to the first slot within one of the buckets. If the slot was already occupied then the bucket slots are searched sequentially until an empty slot is found. If the bucket is completely full, the record will be stored in an overflow bucket of infinite capacity at the end of the table, which is shared by all buckets. Which makes bucket hashing a form of closed hashing implementation. An ideal implementation will use a hash function that distributes the records evenly among all buckets so there will be as few records as possible to store in the overflow bucket.

Index	Bucket	Data
0	B0[0]	30
1	B0[1]	20
2	B1[0]
3	B1[1]
4	B2[0]
5	B2[1]
6	B3[0]	18
7	B3[1]	38
8	B4[0]
9	B4[1]

Overflow Bucket
48
25

Given this bucket hash table for an array of size 10 storing 5 buckets, each bucket having two slots in size, let's demonstrate how this method works in practice. We also have an overflow bucket of infinite size on the right to store records when the buckets in the main hash table are occupied. I will be using mod operation as the hash function.

Let us start by inserting the number 18 as our first record. Since we have 5 buckets, we take mod 5. 18 % 5 is 3. We put this into the top of B3, which is slot 6 of the hash table.
Now inserting a record for 30. 30 % 5 is 0. 30 goes into B0[0].
Next we insert a record for 38; 38 % 5 is 3 so it will be placed in B3[1].
Next up we have 48. 48 % 5 is 3, but the B3 is already full, hence we store 48 in the first available slot of our overflow bucket.
We can now try with 20. 20 % 5 is 0; B0[0] is occupied hence it will be stored in B0[1].
Now if we insert 25, 25 % 5 is 0 and we know both slots of B0 are occupied now, hence it will end up in our overflow bucket.

When looking for a record, we first take its hash value and search the resulting bucket.
If we search for key value 20, we search in B0, first checking B0[0] which holds a different value, so we check B0[1] and we find our key.
When searching for the key value 25, we look in B0 sequentially. We see it doesn't hold our key value and it is full, hence we look through the overflow bucket. First checking OB[0], then OB[1] and we have found it.
Note that if there are many records in the overflow bucket, this will be an expensive process.

Bucket methods are good for implementing hash tables stored on disk, because the bucket size can be set to the size of a disk block. Whenever search or insertion occurs, the entire bucket is read into memory. Because the entire bucket is then in memory, processing an insert or search operation requires only one disk access, unless the bucket is full. If the bucket is full, then the overflow bucket must be retrieved from disk as well. Naturally, overflow should be kept small to minimize unnecessary disk accesses.

Next: Collision Resolution: Linear Probing

Hashtable

Mon, 23 Oct 2017 18:28:59 +0000

Related data structures: Array

A map, symbol table, a dictionary or an associative array is considered an abstract data type composed of a collection of (unique_key, value) pairs. Operations associated with this data type are addition and removal of a pair in a collection, lookup values by their keys and modification of an existing pair.

A hashtable uses the key of each record to determine the location in an array structure. To achieve this, the key is passed into a hash function which returns a numeric value based on the key.

Hash Functions

A good Hash Function should

be simple to compute.
always return the same numeric value when given the exact same key.
have less number of collisions while placing the record in the hash table. Ideally none should occur (perfect hash function).
produce such keys which will get distributed uniformly over an array.
depend on every bit of the key. Thus a hash function that simply extracts the portion of a key is not suitable.

Load Factor

The load factor denoted by the symbol λ measures the fullness of the hash table. It is calculated by the formula λ = number of records in table ÷ number of locations.

Dictionary Problem

Data structures that maintain a set of data during search, delete and insert operations suffer from a data structural problem known as the dictionary problem.

Consider the following data structural problem.

We have a set of items. Each item is a (key, value) pair. Keys are in the range {1,...,U} and values are arbitrary. A data structure supporting the following operations is called a dynamic dictionary.

insert(k, v): insert a new item into the database with key k and value v. If an item with key k already exists in the database, update its value to v.
delete(x): delete item x from the database (we assume x is a pointer to the item)
query(k): return the the value associated with key k, or null if key k is not in the database.

This is a dynamic data structural problem since we also need to support insertion and deletion. (Dynamic variants of data structure problems are ones that support the data set being updated.)

Hashing is a known method to solve this problem.

A hash family H is a set of functions h: {1,...,U} -> {1,...,m}. The idea is to maintain an array of size m where an item with key k is stored at the h(k)th position of the array. Unfortunately, due to collisions this would not work; Two different keys k, k' in a database may have h(k) = h(k').

Assume we initialize an array X of size a where X[i] stores the pointer to the head of a doubly linked list. We pick a hash h at random from a hash family. This way, X[i] will be a doubly linked list containing (key, value) pairs of all items whose key k satisfies h(k) = i. Basically, colliding items are stored in the same linked list.

For inserting a (k,v) pair you simply insert the pair to the head of the list at X[h(k)].

To query k you traverse the list at X[h(k)] until finding an item with key k or see that the key does not exist.

Deletion splices the item out of the doubly linked list when the key is found.

Collisions

Since a hash function translates all keys into indexes in an array, it is often the case that there will be many more keys than there are indexes. Therefore it is always a possibility that multiple keys will be translated into the same index, which is a collision. Generally speaking, collisions are unavoidable. Thus, hashing implementations must have a collision resolution policy. Collision resolution methods can be broken into two classes: open hashing and closed hashing. The difference between the two methods has to do with whether collisions are stored outside the table (open hashing) or at another slot in the same table (closed hashing).

The simplest way of implementing a form of open hashing is to define each slot in the hash table to be the head of a linked list. All records that hash to a specific slot are placed on its linked list. Ordering of records within a linked list of a slot can be done with insertion sort, key-value ordering, or frequency-of-access order. Ordering the list by key value provides an advantage in the case of an unsuccessful search, because we know to stop searching the list once we encounter a key that is greater than the one being searched for. If records on the list are unordered or ordered by frequency, then an unsuccessful search will need to visit every record on the list.

Open hashing is most appropriate when the hash table is kept in main memory, with the lists implemented by a standard in-memory linked list. Storing an open hash table on disk in an efficient way is difficult, because members of a given linked list might be stored on different disk blocks. This would result in multiple disk accesses when searching for a particular key value, which defeats the purpose of using hashing.

Closed hashing stores all records directly in the hash table. Each record R with key value K has a home position h(K) that is computed by the hash function. If R is inserted and another value already fills the computed h(K) then R will be stored at some other slot in the table. Which collision detection method is used determines which slot that may be.

Next: Collision Resolution: Bucket Hashing

Array

Thu, 20 Jul 2017 18:29:59 +0000

Array as a data structure, is simply a collection of elements each identified by an index or a key. In many cases you can consider an array as a synonym of the word table. One can use arrays to implement other data structures and concepts such as strings, lists and lookup tables. Some programming languages use hash tables, linked lists, search trees etc. to implement arrays.

From a mathematical perspective

A tuple is a finite ordered sequence of elements. A sequence of n (non-negative integer) elements is an n-tuple. 0-tuple is an empty sequence. In this sense, one could consider tuples as the mathematical equivalent of arrays.

Arrays exploit the addressing logic of computers. The memory address of the first element of an array is called the foundation address.

An array is stored so that the position of each element can be computed from its index tuple by a mathematical formula. For example, an array of 10 32-bit integer variables, with indices 0 through 9, may be stored as 10 words at memory addresses 2000, 2004, 2008, … 2036, so that the element with index i has the address 2000 + 4 × i.

A matrix can be represented as a two-dimensional grid, hence two-dimensional arrays can be considered as matrices.

Arrays in different programming languages

C Arrays

Arrays in C store related data under a single variable name with an index, also known as the subscript. It’s simply a list of ordered grouping for variables of the same type. Arrays can be considered as a constant pointer.

You declare an array as type name[number of elements]={comma-separated values} e.g.

int point[6]={0,0,1,0,0,0}; or char letters[29]; or float matrix[ NROWS ][ NCOLS ];

You can omit the array dimension if you type it as int point[]={0,0,1,0,0,0}; (The index in C is actually an offset from the beginning of the array. The first element of this array is point[0])

If the dimension is specified, but not all elements in the array are initialized, the remaining elements will contain a value of 0. int numbers[2000]={245}; sets the first value of the array to 245, and the rest to 0.

char two_dim[3][5]; is a two dimensional array that has 3 rows and 5 columns. To access a value we need two indexes:

char ch;
ch = two_dim[2][4];

two_dim[0][0] = 'x';

/* Initialization of a multi-dimensional array */
int two_d[2][3] = { { 5, 2, 1 }, { 6, 7, 8 } };

/* More examples */

int i =  5, intArray[ 6 ] = { 1, 2, 3, 4, 5, 6 }, k;
float sum  = 0.0f, floatArray[ 100 ] = { 1.0f, 5.0f, 20.0f };
double  piFractions[ ] = { 3.141592654, 1.570796327, 0.785398163 };

/* In C99 there is an alternative mechanism that allows you to initialize arrays that have non-sequential indexes. 
 * This method can be mixed in with traditional initialization.
 *
 * If the size of the array is not given, 
 * the largest initialized position determines the size of the array.
 */
int numbers[ 100 ] = { 1, 2, 3, [10] = 10, 11, 12, [60] = 50, [42] = 420 };

#include <stdlib.h>
#include <stdio.h> 

int main( void ) {
    
    int i, fibonacci[ 20 ]; /* first 20 Fibonacci numbers */
    
    fibonacci[ 0 ] = 0;
    fibonacci[ 1 ] = 1;
    
    for( i = 2; i < 20; i++ )
        fibonacci[ i ] = fibonacci[ i - 2 ] + fibonacci[ i - 1 ];
        
    for( i = 0; i < 20; i++ )
        printf( "Fibonacci[ %d ] = %f\n", i, fibonacci[ i ] );
    
}

Array keys have to be integers and need to be continuous. If you have the keys 0, 1 and 2, then the next key has to be 3 and can’t be 234567890.

PHP

The underlying PHP implementation for arrays varies between different versions of PHP but its main difference with C’s own implementation is that it supports non-continuous integer keys and allows mixing them with string keys.

One can implement such an array either by using

a binary search tree search complexity: O(log n), access complexity (best case): O(n)
a hashtable complexity: O(1).

Check out the Resources section for a set of related articles about hashtables (hash maps) and varying PHP implementations that take the topic more in detail.

<?php

$array = ["foo", "bar", "ohai"];
var_dump($array);
# array(4) { [0]=> string(3) "foo" [1]=> string(3) "bar" [2]=> string(4) "ohai" }

$array = ["a", "b", 6 => "c", "d"];
var_dump($array);
# array(4) { [0]=> string(1) "a" [1]=> string(1) "b" [6]=> string(1) "c" [7]=> string(1) "d" }

$array = [
    1    => "a",
    "1"  => "b",
    1.5  => "c",
    true => "d"
];

var_dump($array);
# array(1) { [1]=> string(1) "d" }

$array = [
    "Foo" => "Bar",
    24    => 42,
    "multi" => [
         "dimensional" => [
             "universe" => "what?"
         ]
    ]
];

var_dump($array["foo"]);
# Notice: Undefined index: foo in test.php on line 13
# NULL
var_dump($array["Foo"]);
# string(3) "Bar"
var_dump($array[24]);
# int(42)
var_dump($array["multi"]["dimensional"]["universe"]);
# string(5) "what?"

JavaScript

The JavaScript Array object is a global object that is used in the construction of arrays; which are high-level, list-like objects.

Arrays are list-like objects whose prototype has methods to perform traversal and mutation operations. Neither the length of a JavaScript array nor the types of its elements are fixed. Since an array’s length can change at any time, and data can be stored at non-contiguous locations in the array, JavaScript arrays are not guaranteed to be dense; this depends on how the programmer chooses to use them. In general, these are convenient characteristics; but if these features are not desirable for your particular use, you might consider using typed arrays.

Arrays cannot use strings as element indexes (as in an associative array), but must use integers. Setting or accessing via non-integers using bracket notation (or dot notation) will not set or retrieve an element from the array list itself, but will set or access a variable associated with that array’s object property collection. The array’s object properties and list of array elements are separate, and the array’s traversal and mutation operations cannot be applied to these named properties.

const fruits = ['Apple', 'Banana'];
console.log(fruits.length); // 2

const first = fruits[0]; // Apple

const last = fruits[fruits.length - 1]; // Banana

fruits.forEach(function(item, index) {
  console.log(item, index);
});
// Apple 0
// Banana 1

Common Lisp

In principle, an array in Common Lisp may have any number of dimensions, including zero. (A zero-dimensional array has exactly one element.) In practice, an implementation may limit the number of dimensions supported, but every Common Lisp implementation must support arrays of up to seven dimensions. Each dimension is a non-negative integer; if any dimension of an array is zero, the array has no elements.

An array may be a general array, meaning each element may be any Lisp object, or it may be a specialized array, meaning that each element must be of a given restricted type.

One-dimensional arrays are called vectors. General vectors may contain any Lisp object.

make-array dimensions &key element-type initial-element initial-contents adjustable fill-pointer displaced-to displaced-index-offset
=> new-array

Argument description:

dimensions              list of dimensions, or non-negative integer
element-type            a type specifier, default is T - any type
initial-element         a value, default is implementation dependent
initial-contents        an object
adjustable              a generalized boolean, default is NIL
fill-pointer            a valid fill pointer for the array, or T or NIL
displaced-to            an array or NIL, default is NIL
displaced-index-offset  a valid array row-major index for displaced arrays, default is 0
new-array               an array

(make-array 5 :initial-element 'x) => #(X X X X X)
(make-array '(2 3) :initial-element 'x) => #2A((X X X) (X X X))

(length (make-array 10 :fill-pointer 4)) => 4

(array-dimensions (make-array 10 :fill-pointer 4)) => (10)

(make-array 10 :element-type 'bit :initial-element 0) => #*0000000000
(make-array 10 :element-type 'character :initial-element #\a) => "aaaaaaaaaa"

(let ((a (make-array '(2 2) :initial-element 'x :adjustable t))) (adjust-array a '(1 3) :initial-element 'y) a) => #2A((X X Y))

make-array '(4 2 3) :initial-contents
           '(((a b c) (1 2 3))
            ((d e f) (3 1 2))
            ((g h i) (2 3 1))
            ((j k l) (0 0 0))))

Resources

Function Trampoline

Wed, 07 Jun 2017 18:28:59 +0000

Trampolines are memory locations holding addresses pointing to interrupt service routines (interrupt handlers), I/O routines, etc. Also referred to as indirect jump vectors. Execution jumps into the trampoline and then immediately jumps out, or bounces, hence the term trampoline.

Trampoline can be used to overcome the limitations imposed by a CPU architecture that expects to always find vectors in fixed locations.

When an operating system is booted on a symmetric multiprocessing (SMP) machine, only one processor, the boot-strap processor, will be active. After the operating system has configured itself, it will instruct the other processors to jump to a piece of trampoline code that will initialize the processors and wait for the operating system to start scheduling threads on them.

A trampoline can be a loop that iteratively invokes thunk-returning functions (continuation-passing style). A thunk is essentially a function that wraps a call to another function, along with any parameters it needs, for later execution. A way to emulate lazy evaluation.

The goal of a trampoline is to prevent recursion in function calls.

The idea is to transform our function, so that its caller can detect when it recurses or when it leaves. If it performs a recursive call to itself, the trampoline will control its stack by becoming its callee. If it returns its result, the trampoline should notice it and stop.

<?php
function trampoline_factorial($n, $acc = 1)
{
    if ($n == 1) {
        return $acc;
    }
    return function() use ($n, $acc) { return trampoline_factorial($n-1, $n * $acc); };
}

You see here that this function doesn’t directly call itself, but it wraps its recursive call into a closure. This is because now we won’t launch our recursive function directly, but using a trampoline.

When the trampoline sees a closure returned, it launches it, when it sees a non-closure, it returns; hence the “trampoline” wording.

<?php
function trampoline(callable $c, ...$args)
{
    while (is_callable($c)) { $c = $c(...$args); } return $c;
}

echo trampoline('trampoline_factorial', 42);

Trampolines & tail-recursive function calls

When you need a tail call optimization like structure in a language that doesn’t (necessarily) provide it, but does provide closures, you can use a trampoline to achieve constant stack space (with a trade off for heap space for closure objects, of course).

The trampoline is a generic solution to recursion. If you can’t refactor your function to eliminate recursive calls, then transform it to a tail-call function that can be launched through a trampoline.

To illustrate the idea, here is a simple example of trampoline function that can be used effectively to eliminate recursive calls. In languages like C this concept is important because the compiler is usually unable to optimize tail recursive calls, unlike languages such as Scheme.

A basic, recursive way of calculating a factorial in C looks like this:

int fact(int x, int total) {
   if (x <= 1) return total;
   return fact(x-1, total*x);
}

int main() {
   printf("result is %d\n", fact(10, 1));
   return 0;
}

The problem with above piece of code is that we are using the function stack to maintain the intermediate results. Although, because the size of the integer is more of a limitation than the size of the stack, this is not really a problem here but it can be a real concern in other recursive implementations.

So what can we do using a trampoline function instead? Instead of calling the function itself, we will call a pointer to a function, then return a pointer to a place where we need to go next:

#include <stdlib.h>
#include <stdio.h>

typedef void * (*Func)(int *x, int *total);

void *fact0(int *x, int *total) { return NULL; }

void *fact(int *x, int *total) {
   if (*x <= 1) return fact0;
   *total *= *x;
   *x = *x-1;

   printf("total %d, x: %d\n", *total, *x);
   return fact;
}

int main() {
   int res=1, n = 10;
   Func f = fact;
   while (f != NULL) {
      f = (Func)f(&n, &res);
   }

   printf("result is %d\n", res);
   return 0;
}

On this example, at each time, the stack holds only the context for the function that is being called. Since we don’t need to store return information for the last call, this can always be done in a tail recursive function.

Resources

Notes on Iteration & Recursion

Tue, 09 May 2017 15:35:21 +0000

Iteration is the repetition of a process to produce a sequence of outcomes. Each repetition of this process is a single iteration and the outcome of every iteration is the starting point of the next iteration.

In mathematics, one can use iteration to find approximate solutions to equations. Repeatedly solving an equation to obtain a result using the result from the previous calculation is referred as an iterative process. Many root-finding algorithms make use of iterative methods, producing a sequence of numbers that are hopefully approximating toward the root with each iteration. Take a look at Newton’s method and Brent’s method as example root-finding algorithms.

In programming we use iteration quite often. Many programming languages have loop constructs that lets you iterate over a given set or we can write iterative functions that loop to repeat some piece of code. We also have the concept of recursion, which is similar to iteration but instead of repeating some piece of code, a recursive function calls itself to repeat the code.

Using a simple for loop construct to loop through all the integers from 1 to n, multiplying as we go along, would be an iterative process. Writing down a function fn(n) that calls itself taking n as the argument and returning n * fn(n - 1) unless n = 0, would be a recursive process.

Most CPUs model recursion with loops and a stack data structure. Each recursive call pushes a new stack frame then pops it when it returns. Recursion hence usually has the overhead of method calls (unless you’re using tail recursion and a compiler that handles it), but it usually requires less code than iteration. Infinite recursion can lead to system crash while infinite iteration would consume CPU cycles.

Next: Function Trampoline