Rice Wiki - User contributions [en]

Thread

2024-10-07T19:28:33Z

Rice:

[[File:OSTEP 26.1.png|thumb|Credits to OSTEP textbook]]
A '''thread''' in Computer Science is defined as a sequence of executing instructions from a program. Notably, it is active/running. It is different from a process in that multiple threads can share an [[address space]].

The state of a thread consists of the Program Counter and the set of register values.

A '''thread control block (TCB)''' stores the states of threads to enable switching between them.

Each thread will also have its own stack, which is thus called '''thread-local storage'''. The address space diagram shows that not all stacks can grow indefinitely and may run into problems if there are lots of recursion.

== Motivation ==
The first motivation for threads is '''parallelizing operations''' to multiple processors, which may speed up certain operations such as array calculations significantly.

The second motivation is to avoid progress being blocked by I/O such as disk read/writes.

== Downsides ==
[[Category:Operating System]]

Thread

2024-10-07T19:17:01Z

Rice:

File:OSTEP 26.1.png

2024-10-07T19:15:25Z

Rice:

From the OSTEP textbook, Single-threaded vs multi-threaded process address space

Address space

2024-10-04T18:43:56Z

Rice:

The '''address space''' of a process usually consists of three segments

* Stack
* Data
* Code

Typically, stack and data segments are dynamic.

Address space abstracts physical memory in the following three ways:

* Address independence: Each process has its own memory
* Protection: that only it can access
* Virtual memory: that is large
'''Multiprogramming''' allows multiple processes in memory at a time. This is motivated by the observation that most processes would only require a small bit of memory at a time. '''Address translation''' by the [[MMU]] is used to avoid conflicting addresses by using symbolic addresses to represent physical addresses.
[[Category:Operating System]]

Address space

2024-10-04T18:40:23Z

Rice:

The '''address space''' of a process usually consists of three segments

* Stack
* Data
* Code

Typically, stack and data segments are dynamic.

Address space abstracts physical memory in the following three ways:

* Address independence: Each process has its own memory
* Protection: that only it can access
* Virtual memory: that is large
'''Multiprogramming''' allows multiple processes in memory at a time. This is motivated by the observation that most processes would only require a small bit of memory at a time. '''Address translation''' is used to avoid conflicting addresses by using symbolic addresses to represent physical addresses.
[[Category:Operating System]]

Address space

2024-10-04T18:39:28Z

Rice:

Address space

2024-10-04T18:34:11Z

Rice:

Address space

2024-10-04T18:28:29Z

Rice: Created page with "The '''address space''' of a process usually consists of three segments * Stack * Data * Code Typically, stack and data segments are dynamic. Category:Operating System"

The '''address space''' of a process usually consists of three segments

* Stack
* Data
* Code

Typically, stack and data segments are dynamic.
[[Category:Operating System]]

Process

2024-10-04T18:27:30Z

Rice: /* Machine state */

[[Category:Computer Science]]
A '''program''' is a passive set of machine code instructions and data stored in an executable image. A '''process''' can be thought of as this passive program in action. More formally, it is one or more [[Thread|threads]] in their own address space.

Processes are independent separate tasks. If one process crashed, it will not affect any other processes. The end goal of processes is to achieve the illusion of having multiple CPUs when executing multiple programs. This is done by '''virtualization'''.

== Machine state ==
Representing the execution of a program, a process includes the state of the program first and foremost. This includes

* The [[program counter]]
* CPU [[Register|registers]]
* The process [[stack]]
* The [[address space]]
* etc.

Beyond the state of the program, each process is allocated its own process identifier (PID) and [[virtual memory]] among other things.

== Virtualization ==
The virtualization of CPU's is what allows more processes than CPU to exist. This is implemented by low-level '''time-sharing''' [[Mechanism|mechanisms]]. On top of these mechanisms resides '''scheduling [[Policy|policies]],''' which decides which program should run.

== API ==
Typical process APIs include the following:

* '''Create'''
* '''Destroy''' - Killing processes forcefully
* '''Wait''' - Suspend a process to be restarted later
* '''Status''' - Obtain current information of the process

There are many other misc. controls that are possible.

== Process creation ==

# Code and static data are loaded into memory. In modern operating systems, this is done lazily.
# Allocate memory such as runtime stack and heap
# Perform initialization tasks, especially those related to I/O.
# Start the program

== Process state ==
[[File:Process state transitions.png|thumb|A process' state diagram from Three Pieces textbook]]
A process has three states

# '''Running''' - Its instructions are currently being executed by the CPU
# '''Ready''' - Ready to run but OS is not running it for misc. reasons (such as time-sharing)
# '''Blocked''' - Waiting some I/O to finish, such as requesting a write to disk.

A process is '''scheduled''' when the OS moves it from Ready to Running. It is '''descheduled''' when it is moved from Running to Ready. This decision is made by the [[scheduler]].

The kernel also keeps a table of all the metadata of processes. This include PID, parent, page tables, etc.

== Processes in Linux ==
When the computer starts, the only thing the kernel execute in the [[user space]] is a init command (shown with ps -f 1). This process is allocated a PID of 1 and is the only process with no parent process.

In contrast to the init process, all other processes are created by parent processes. This is done with ''fork'' and ''exec''. First, the [[shell]] will run ''fork'' to create a cloned process from the current process, and ''exec'' replaces the program in the cloned process with another program.

The syscall ''fork'' clones a process almost perfectly. For example, the child process would not start running at ''main''; instead, it continues where the parent leaves off. The only differences between the two processes is the return value of ''fork'': In the parent it is the PID of the child, whereas in the child it is 0. This syscall is notably non-deterministic, as the CPU scheduler is free to run either process before the other.

The ''wait'' syscall halt execution of the parent until the child is complete.

To run a new process, the ''exec'' syscall can be used. It replaces the current process with that specified in the arguments.

== Motivation of ''fork'' ==
The motivation behind this unintuitive set of APIs (fork, wait, exec) is to allow the parent process time to alter the environment of the child process.

= Sources =

* Linux documentation: https://tldp.org/LDP/tlk/tlk.html
* Linux processes, init, fork/exec, ps, kill, fg, bg, jobs: https://www.youtube.com/watch?v=TJzltwv7jJs
* Operating Systems, Three Easy Pieces
[[Category:Operating System]]

Limited direct execution

2024-10-04T18:08:37Z

Rice: /* Limiting operations */

'''Limited direct execution''' is a technique of allowing programs to partially execute on the CPU directly. This ensures the two necessities of CPU [[virtualization]]: performance and control.

== Direct execution ==
[[File:OSTEP 6.1.png|thumb|OSTEP: Direct Execution Protocol (Without Limits)]]
Let's first talk about the simpler sibling of limited direct execution. '''Direct execution''' (without limits) simply allows programs to run on the CPU.

This approach, while fast and simple, has problems over ''control'':

* '''Restricted operation:''' How does the OS stop processes from doing things we don't want it to do?
* '''Switching between processes:''' How does the OS stop an executing process, which is needed for time sharing?

== Limiting operations ==
There are many things that a user may not want a process to do. For example, performing I/O operations to disks, demanding more system resources, etc. Many functions that we take for granted would be impossible on a direct execution system, an example being limiting disk access to certain programs/users with file permissions.

To limit sensitive operations, most operating systems have two modes: '''kernel mode''' and '''user mode'''. In kernel mode, all instructions are fair game. In user mode, certain sensitive operations such as I/O and process/resource management would raise an exception.

We want to limit a process' control but still allow them to perform necessary functions. This is done through '''system calls'''. When a user program wants to access restricted resources, they make a system call, which then use the '''trap''' instruction to elevate to kernel mode. The kernel then checks the necessary permissions.
[[Category:Operating System]]

Process

2024-10-02T18:19:09Z

Rice: /* Process state */

[[Category:Computer Science]]
A '''program''' is a passive set of machine code instructions and data stored in an executable image. A '''process''' can be thought of as this passive program in action. More formally, it is one or more [[Thread|threads]] in their own address space.

Processes are independent separate tasks. If one process crashed, it will not affect any other processes. The end goal of processes is to achieve the illusion of having multiple CPUs when executing multiple programs. This is done by '''virtualization'''.

== Machine state ==
Representing the execution of a program, a process includes the state of the program first and foremost. This includes

* The [[program counter]]
* CPU [[Register|registers]]
* The process [[stack]]
* The address space
* etc.

Beyond the state of the program, each process is allocated its own process identifier (PID) and [[virtual memory]] among other things.

== Virtualization ==
The virtualization of CPU's is what allows more processes than CPU to exist. This is implemented by low-level '''time-sharing''' [[Mechanism|mechanisms]]. On top of these mechanisms resides '''scheduling [[Policy|policies]],''' which decides which program should run.

== API ==
Typical process APIs include the following:

* '''Create'''
* '''Destroy''' - Killing processes forcefully
* '''Wait''' - Suspend a process to be restarted later
* '''Status''' - Obtain current information of the process

There are many other misc. controls that are possible.

== Process creation ==

# Code and static data are loaded into memory. In modern operating systems, this is done lazily.
# Allocate memory such as runtime stack and heap
# Perform initialization tasks, especially those related to I/O.
# Start the program

== Process state ==
[[File:Process state transitions.png|thumb|A process' state diagram from Three Pieces textbook]]
A process has three states

# '''Running''' - Its instructions are currently being executed by the CPU
# '''Ready''' - Ready to run but OS is not running it for misc. reasons (such as time-sharing)
# '''Blocked''' - Waiting some I/O to finish, such as requesting a write to disk.

A process is '''scheduled''' when the OS moves it from Ready to Running. It is '''descheduled''' when it is moved from Running to Ready. This decision is made by the [[scheduler]].

The kernel also keeps a table of all the metadata of processes. This include PID, parent, page tables, etc.

== Processes in Linux ==
When the computer starts, the only thing the kernel execute in the [[user space]] is a init command (shown with ps -f 1). This process is allocated a PID of 1 and is the only process with no parent process.

In contrast to the init process, all other processes are created by parent processes. This is done with ''fork'' and ''exec''. First, the [[shell]] will run ''fork'' to create a cloned process from the current process, and ''exec'' replaces the program in the cloned process with another program.

The syscall ''fork'' clones a process almost perfectly. For example, the child process would not start running at ''main''; instead, it continues where the parent leaves off. The only differences between the two processes is the return value of ''fork'': In the parent it is the PID of the child, whereas in the child it is 0. This syscall is notably non-deterministic, as the CPU scheduler is free to run either process before the other.

The ''wait'' syscall halt execution of the parent until the child is complete.

To run a new process, the ''exec'' syscall can be used. It replaces the current process with that specified in the arguments.

== Motivation of ''fork'' ==
The motivation behind this unintuitive set of APIs (fork, wait, exec) is to allow the parent process time to alter the environment of the child process.

= Sources =

* Linux documentation: https://tldp.org/LDP/tlk/tlk.html
* Linux processes, init, fork/exec, ps, kill, fg, bg, jobs: https://www.youtube.com/watch?v=TJzltwv7jJs
* Operating Systems, Three Easy Pieces
[[Category:Operating System]]

Limited direct execution

2024-10-02T18:01:08Z

Rice:

Limited direct execution

2024-10-02T17:49:00Z

Rice:

File:OSTEP 6.1.png

2024-10-02T17:48:36Z

Rice:

Direct Execution Protocol (Without Limits)

Limited direct execution

2024-10-02T17:46:09Z

Rice: Created page with "'''Limited direct execution''' is a technique of allowing programs to partially execute on the CPU directly. This ensures the two necessities of CPU virtualization: performance and control. Category:Operating System"

Process

2024-09-30T17:53:05Z

Rice:

[[Category:Computer Science]]
A '''program''' is a passive set of machine code instructions and data stored in an executable image. A '''process''' can be thought of as this passive program in action. More formally, it is one or more [[Thread|threads]] in their own address space.

Processes are independent separate tasks. If one process crashed, it will not affect any other processes. The end goal of processes is to achieve the illusion of having multiple CPUs when executing multiple programs. This is done by '''virtualization'''.

== Machine state ==
Representing the execution of a program, a process includes the state of the program first and foremost. This includes

* The [[program counter]]
* CPU [[Register|registers]]
* The process [[stack]]
* The address space
* etc.

Beyond the state of the program, each process is allocated its own process identifier (PID) and [[virtual memory]] among other things.

== Virtualization ==
The virtualization of CPU's is what allows more processes than CPU to exist. This is implemented by low-level '''time-sharing''' [[Mechanism|mechanisms]]. On top of these mechanisms resides '''scheduling [[Policy|policies]],''' which decides which program should run.

== API ==
Typical process APIs include the following:

* '''Create'''
* '''Destroy''' - Killing processes forcefully
* '''Wait''' - Suspend a process to be restarted later
* '''Status''' - Obtain current information of the process

There are many other misc. controls that are possible.

== Process creation ==

# Code and static data are loaded into memory. In modern operating systems, this is done lazily.
# Allocate memory such as runtime stack and heap
# Perform initialization tasks, especially those related to I/O.
# Start the program

== Process state ==
[[File:Process state transitions.png|thumb|A process' state diagram from Three Pieces textbook]]
A process has three states

# '''Running''' - Its instructions are currently being executed by the CPU
# '''Ready''' - Ready to run but OS is not running it for misc. reasons (such as time-sharing)
# '''Blocked''' - Waiting some I/O to finish, such as requesting a write to disk.

A process is '''scheduled''' when the OS moves it from Ready to Running. It is '''descheduled''' when it is moved from Running to Ready. This decision is made by the [[scheduler]].

== Processes in Linux ==
When the computer starts, the only thing the kernel execute in the [[user space]] is a init command (shown with ps -f 1). This process is allocated a PID of 1 and is the only process with no parent process.

In contrast to the init process, all other processes are created by parent processes. This is done with ''fork'' and ''exec''. First, the [[shell]] will run ''fork'' to create a cloned process from the current process, and ''exec'' replaces the program in the cloned process with another program.

The syscall ''fork'' clones a process almost perfectly. For example, the child process would not start running at ''main''; instead, it continues where the parent leaves off. The only differences between the two processes is the return value of ''fork'': In the parent it is the PID of the child, whereas in the child it is 0. This syscall is notably non-deterministic, as the CPU scheduler is free to run either process before the other.

The ''wait'' syscall halt execution of the parent until the child is complete.

To run a new process, the ''exec'' syscall can be used. It replaces the current process with that specified in the arguments.

== Motivation of ''fork'' ==
The motivation behind this unintuitive set of APIs (fork, wait, exec) is to allow the parent process time to alter the environment of the child process.

= Sources =

* Linux documentation: https://tldp.org/LDP/tlk/tlk.html
* Linux processes, init, fork/exec, ps, kill, fg, bg, jobs: https://www.youtube.com/watch?v=TJzltwv7jJs
* Operating Systems, Three Easy Pieces
[[Category:Operating System]]

Process

2024-09-30T17:46:26Z

Rice: /* Processes in Linux */

[[Category:Computer Science]]
A '''program''' is a passive set of machine code instructions and data stored in an executable image. A '''process''' can be thought of as this passive program in action. More formally, it is one or more [[Thread|threads]] in their own address space.

Processes are independent separate tasks. If one process crashed, it will not affect any other processes. The end goal of processes is to achieve the illusion of having multiple CPUs when executing multiple programs. This is done by '''virtualization'''.

== Machine state ==
Representing the execution of a program, a process includes the state of the program first and foremost. This includes

* The [[program counter]]
* CPU [[Register|registers]]
* The process [[stack]]
* The address space
* etc.

Beyond the state of the program, each process is allocated its own process identifier (PID) and [[virtual memory]] among other things.

== Virtualization ==
The virtualization of CPU's is what allows more processes than CPU to exist. This is implemented by low-level '''time-sharing''' [[Mechanism|mechanisms]]. On top of these mechanisms resides '''scheduling [[Policy|policies]],''' which decides which program should run.

== API ==
Typical process APIs include the following:

* '''Create'''
* '''Destroy''' - Killing processes forcefully
* '''Wait''' - Suspend a process to be restarted later
* '''Status''' - Obtain current information of the process

There are many other misc. controls that are possible.

== Process creation ==

# Code and static data are loaded into memory. In modern operating systems, this is done lazily.
# Allocate memory such as runtime stack and heap
# Perform initialization tasks, especially those related to I/O.
# Start the program

== Process state ==
[[File:Process state transitions.png|thumb|A process' state diagram from Three Pieces textbook]]
A process has three states

# '''Running''' - Its instructions are currently being executed by the CPU
# '''Ready''' - Ready to run but OS is not running it for misc. reasons (such as time-sharing)
# '''Blocked''' - Waiting some I/O to finish, such as requesting a write to disk.

A process is '''scheduled''' when the OS moves it from Ready to Running. It is '''descheduled''' when it is moved from Running to Ready. This decision is made by the [[scheduler]].

== Processes in Linux ==
When the computer starts, the only thing the kernel execute in the [[user space]] is a init command (shown with ps -f 1). This process is allocated a PID of 1 and is the only process with no parent process.

In contrast to the init process, all other processes are created by parent processes. This is done with ''fork'' and ''exec''. First, the [[shell]] will run ''fork'' to create a cloned process from the current process, and ''exec'' replaces the program in the cloned process with another program.

The syscall ''fork'' clones a process almost perfectly. For example, the child process would not start running at ''main''; instead, it continues where the parent leaves off. The only differences between the two processes is the return value of ''fork'': In the parent it is the PID of the child, whereas in the child it is 0. This syscall is notably non-deterministic, as the CPU scheduler is free to run either process before the other.

The ''wait'' syscall halt execution of the parent until the child is complete.

To run a new process, the ''exec'' syscall can be used. It replaces the current process with that specified in the arguments.

= Sources =

* Linux documentation: https://tldp.org/LDP/tlk/tlk.html
* Linux processes, init, fork/exec, ps, kill, fg, bg, jobs: https://www.youtube.com/watch?v=TJzltwv7jJs
* Operating Systems, Three Easy Pieces
[[Category:Operating System]]

Process

2024-09-27T18:17:24Z

Rice:

[[Category:Computer Science]]
A '''program''' is a passive set of machine code instructions and data stored in an executable image. A '''process''' can be thought of as this passive program in action. More formally, it is one or more [[Thread|threads]] in their own address space.

Processes are independent separate tasks. If one process crashed, it will not affect any other processes. The end goal of processes is to achieve the illusion of having multiple CPUs when executing multiple programs. This is done by '''virtualization'''.

== Machine state ==
Representing the execution of a program, a process includes the state of the program first and foremost. This includes

* The [[program counter]]
* CPU [[Register|registers]]
* The process [[stack]]
* The address space
* etc.

Beyond the state of the program, each process is allocated its own process identifier (PID) and [[virtual memory]] among other things.

== Virtualization ==
The virtualization of CPU's is what allows more processes than CPU to exist. This is implemented by low-level '''time-sharing''' [[Mechanism|mechanisms]]. On top of these mechanisms resides '''scheduling [[Policy|policies]],''' which decides which program should run.

== API ==
Typical process APIs include the following:

* '''Create'''
* '''Destroy''' - Killing processes forcefully
* '''Wait''' - Suspend a process to be restarted later
* '''Status''' - Obtain current information of the process

There are many other misc. controls that are possible.

== Process creation ==

# Code and static data are loaded into memory. In modern operating systems, this is done lazily.
# Allocate memory such as runtime stack and heap
# Perform initialization tasks, especially those related to I/O.
# Start the program

== Process state ==
[[File:Process state transitions.png|thumb|A process' state diagram from Three Pieces textbook]]
A process has three states

# '''Running''' - Its instructions are currently being executed by the CPU
# '''Ready''' - Ready to run but OS is not running it for misc. reasons (such as time-sharing)
# '''Blocked''' - Waiting some I/O to finish, such as requesting a write to disk.

A process is '''scheduled''' when the OS moves it from Ready to Running. It is '''descheduled''' when it is moved from Running to Ready. This decision is made by the [[scheduler]].

== Processes in Linux ==

===== Init process =====
When the computer starts, the only thing the kernel execute in the [[user space]] is a init command (shown with ps -f 1). This process is allocated a PID of 1 and is the only process with no parent process.

===== Creating a process =====
In contrast to the init process, all other processes are created by parent processes. This is done with ''fork'' and ''exec''. First, the [[shell]] will run ''fork'' to create a cloned process from the current process, and ''exec'' replaces the program in the cloned process with another program.

= Sources =

* Linux documentation: https://tldp.org/LDP/tlk/tlk.html
* Linux processes, init, fork/exec, ps, kill, fg, bg, jobs: https://www.youtube.com/watch?v=TJzltwv7jJs
* Operating Systems, Three Easy Pieces
[[Category:Operating System]]

Thread

2024-09-27T18:17:09Z

Rice: Created page with "A '''thread''' in Computer Science is defined as a sequence of executing instructions from a program. Notably, it is active/running. Category:Operating System"

A '''thread''' in Computer Science is defined as a sequence of executing instructions from a program. Notably, it is active/running.
[[Category:Operating System]]

Process

2024-09-27T18:13:24Z

Rice:

[[Category:Computer Science]]
A '''program''' is a passive set of machine code instructions and data stored in an executable image. A '''process''' can be thought of as this passive program in action. More formally, it is one or more threads in their own address space.

Processes are independent separate tasks. If one process crashed, it will not affect any other processes. The end goal of processes is to achieve the illusion of having multiple CPUs when executing multiple programs. This is done by '''virtualization'''.

== Machine state ==
Representing the execution of a program, a process includes the state of the program first and foremost. This includes

* The [[program counter]]
* CPU [[Register|registers]]
* The process [[stack]]
* The address space
* etc.

Beyond the state of the program, each process is allocated its own process identifier (PID) and [[virtual memory]] among other things.

== Virtualization ==
The virtualization of CPU's is what allows more processes than CPU to exist. This is implemented by low-level '''time-sharing''' [[Mechanism|mechanisms]]. On top of these mechanisms resides '''scheduling [[Policy|policies]],''' which decides which program should run.

== API ==
Typical process APIs include the following:

* '''Create'''
* '''Destroy''' - Killing processes forcefully
* '''Wait''' - Suspend a process to be restarted later
* '''Status''' - Obtain current information of the process

There are many other misc. controls that are possible.

== Process creation ==

# Code and static data are loaded into memory. In modern operating systems, this is done lazily.
# Allocate memory such as runtime stack and heap
# Perform initialization tasks, especially those related to I/O.
# Start the program

== Process state ==
[[File:Process state transitions.png|thumb|A process' state diagram from Three Pieces textbook]]
A process has three states

# '''Running''' - Its instructions are currently being executed by the CPU
# '''Ready''' - Ready to run but OS is not running it for misc. reasons (such as time-sharing)
# '''Blocked''' - Waiting some I/O to finish, such as requesting a write to disk.

A process is '''scheduled''' when the OS moves it from Ready to Running. It is '''descheduled''' when it is moved from Running to Ready. This decision is made by the [[scheduler]].

== Processes in Linux ==

===== Init process =====
When the computer starts, the only thing the kernel execute in the [[user space]] is a init command (shown with ps -f 1). This process is allocated a PID of 1 and is the only process with no parent process.

===== Creating a process =====
In contrast to the init process, all other processes are created by parent processes. This is done with ''fork'' and ''exec''. First, the [[shell]] will run ''fork'' to create a cloned process from the current process, and ''exec'' replaces the program in the cloned process with another program.

= Sources =

* Linux documentation: https://tldp.org/LDP/tlk/tlk.html
* Linux processes, init, fork/exec, ps, kill, fg, bg, jobs: https://www.youtube.com/watch?v=TJzltwv7jJs
* Operating Systems, Three Easy Pieces

Process

2024-09-26T05:10:07Z

Rice:

[[Category:Computer Science]]
A '''program''' is a passive set of machine code instructions and data stored in an executable image. A '''process''' can be thought of as this passive program in action.

Processes are independent separate tasks. If one process crashed, it will not affect any other processes. The end goal of processes is to achieve the illusion of having multiple CPUs when executing multiple programs. This is done by '''virtualization'''.

== Machine state ==
Representing the execution of a program, a process includes the state of the program first and foremost. This includes

* The [[program counter]]
* CPU [[Register|registers]]
* The process [[stack]]
* The address space
* etc.

Beyond the state of the program, each process is allocated its own process identifier (PID) and [[virtual memory]] among other things.

== Virtualization ==
The virtualization of CPU's is what allows more processes than CPU to exist. This is implemented by low-level '''time-sharing''' [[Mechanism|mechanisms]]. On top of these mechanisms resides '''scheduling [[Policy|policies]],''' which decides which program should run.

== API ==
Typical process APIs include the following:

* '''Create'''
* '''Destroy''' - Killing processes forcefully
* '''Wait''' - Suspend a process to be restarted later
* '''Status''' - Obtain current information of the process

There are many other misc. controls that are possible.

== Process creation ==

# Code and static data are loaded into memory. In modern operating systems, this is done lazily.
# Allocate memory such as runtime stack and heap
# Perform initialization tasks, especially those related to I/O.
# Start the program

== Process state ==
[[File:Process state transitions.png|thumb|A process' state diagram from Three Pieces textbook]]
A process has three states

# '''Running''' - Its instructions are currently being executed by the CPU
# '''Ready''' - Ready to run but OS is not running it for misc. reasons (such as time-sharing)
# '''Blocked''' - Waiting some I/O to finish, such as requesting a write to disk.

A process is '''scheduled''' when the OS moves it from Ready to Running. It is '''descheduled''' when it is moved from Running to Ready. This decision is made by the [[scheduler]].

== Processes in Linux ==

===== Init process =====
When the computer starts, the only thing the kernel execute in the [[user space]] is a init command (shown with ps -f 1). This process is allocated a PID of 1 and is the only process with no parent process.

===== Creating a process =====
In contrast to the init process, all other processes are created by parent processes. This is done with ''fork'' and ''exec''. First, the [[shell]] will run ''fork'' to create a cloned process from the current process, and ''exec'' replaces the program in the cloned process with another program.

= Sources =

* Linux documentation: https://tldp.org/LDP/tlk/tlk.html
* Linux processes, init, fork/exec, ps, kill, fg, bg, jobs: https://www.youtube.com/watch?v=TJzltwv7jJs
* Operating Systems, Three Easy Pieces

File:Process state transitions.png

2024-09-26T05:04:07Z

Rice:

Process state diagram

Modern physics

2024-09-25T20:17:10Z

Rice: Created page with "'''Modern physics''' is primarily about the following concepts: * Special relativity says that the speed of light is constant in all frames, and that time is not the same. * General relativity says that acceleration is indistinguishable from gravity * Interactions are quantized/discrete at a single space-time point, with no action at a distance * Modern physics is fundamentally statistical, whereas classical physics are deterministic. This includes topics such..."

'''Modern physics''' is primarily about the following concepts:

* [[Special relativity]] says that the speed of light is constant in all frames, and that time is not the same.
* [[General relativity]] says that acceleration is indistinguishable from gravity
* Interactions are quantized/discrete at a single space-time point, with no action at a distance
* Modern physics is fundamentally statistical, whereas classical physics are deterministic.

This includes topics such as special/general relativity, quantum mechanics, statistical physics, nuclear physics, and fundamental particles.

Object relationship

2024-08-10T02:21:05Z

Rice:

= IMPORTANT NOTE: This page may be wrong since I am confused. =
In [[OOP]], interrelated objects are composed together for complex functionality. This page describes concepts that relate one object to another.

= Inheritance =
Implementation inheritance extends the implementation of a parent class with a child class that inherit the members of the parent class while adding/overriding certain members.

= Composition =
Unlike [[Object relationship#Inheritance|inheritance]], which directly extends a parent object, composition owns the object whose functionality it wishes to extend. This solves many of the issues of inheritance.<syntaxhighlight lang="c++">
class Owner
{
Extended ext;

public:
Owner() {
ext = Extended();
}
};

</syntaxhighlight>

= Aggregation =
Similar to [[Object relationship#Composition|composition]], aggregation involves an object "having" another object. The difference between the two lies in that composition focuses on a parent-child relationship, whereas Aggregation

Object relationship

2024-08-08T17:51:44Z

Rice:

In [[OOP]], interrelated objects are composed together for complex functionality. This page describes concepts that relate one object to another.

= Inheritance =
Implementation inheritance extends the implementation of a parent class with a child class that inherit the members of the parent class while adding/overriding certain members.

= Composition =
Unlike [[Object relationship#Inheritance|inheritance]], which directly extends a parent object, composition owns the object whose functionality it wishes to extend. This solves many of the issues of inheritance.<syntaxhighlight lang="c++">
class Owner
{
Extended ext;

public:
Owner() {
ext = Extended();
}
};

</syntaxhighlight>

= Aggregation =
Similar to [[Object relationship#Composition|composition]], aggregation involves an object "having" another object. The difference between the two lies in that composition focuses on a parent-child relationship, whereas Aggregation

Object relationship

2024-08-08T16:18:04Z

Rice: Created page with "In OOP, interrelated objects are composed together for complex functionality. This page describes concepts that relate one object to another. = Inheritance = = Composition = = Aggregation = Unlike"

In [[OOP]], interrelated objects are composed together for complex functionality. This page describes concepts that relate one object to another.

= Inheritance =

= Composition =

= Aggregation =
Unlike

Category:Object Oriented Programming

2024-08-08T16:14:14Z

Rice: Created page with "OOP"

OOP

Relational model

2024-07-20T23:19:19Z

Rice: Created page with "The '''relational model''' is a data model that stores data in a simple data structure called a '''relation'''. == Relation == Essentially a table. It stores entries (rows) of related attributes (columns). For example, let's say we want to store a student's data. This student is considered one entry in the student database. In this entry is the student's full name, home address, and GPA, which are attributes that relate to each other because they are from..."

The '''relational model''' is a [[Database|data model]] that stores data in a simple data structure called a '''relation'''.

== Relation ==
Essentially a table. It stores entries (rows) of related attributes (columns).

For example, let's say we want to store a student's data. This student is considered one entry in the student database. In this entry is the student's full name, home address, and GPA, which are attributes that relate to each other because they are from the same student.

=== Primary key ===
In each relation, an attribute is used as the '''primary key'''. This is the unique identifier of each entry.

== Operations ==
The relational model specifies the following operations to be performed on the database.

=== Select ===
The '''select''' operator selects a subset of entries from a relation with a criteria.

In conjunction with the primary key, it allows the user to select a particular entry inside the database.

=== Permutation ===
[[Category:Computer Science]]

Database

2024-07-20T23:08:49Z

Rice: /* Relational model */

A '''database''' stores, retrieves, and operates on a collection of related data. A '''database management system (DBMS)''' is a general way to implement databases. This page will describe why we want a system specifically for this task, a high-level breakdown of its functionality, as well as an overview of how it is implemented.

== Motivation ==
A separate system for the management of collections of data is necessary because of two things: 1) the task's prevalence in many application, and 2) the difficulty to implement such a system correctly and efficiently. The former point is relatively intuitive, but the second point is more involved.

To design a way to manage collections of data is to solve the following problems among many.

* '''Data integrity''': Ensure that data stored is valid and will not cause errors upon operation and/or retrieval. Examples include type checking.
* '''Efficient implementation:''' Implementation needs to be efficient for the task at hand. Examples include data structures and concurrency.
* '''Durability:''' Ensure the safety of the data during system errors and modifications. Examples include computer crashing.

All of the above tasks are highly involved. As such, a layer of abstraction is very beneficial for development: you don't want to handle all of these problems when building your project!

== Description ==
The role of a general-purpose DBMS is to handle the definition, creation, querying, update, and administration of databases. DBMSes are widely tested and deployed, and as such allow developers to focus on other aspects of their program and rely on DBMSes to store the data.

== Data models ==
A '''data model''' is a collection of concepts that describes how data is represented in the database.

=== [[Relational model]] ===
The '''relational model''' abstracts away database implementation by allowing developers to access data through a high-level language, where the DBMS decides the strategy. It stores data in a simple structure called a '''relation''', and the physical implementation of the database is handled by the DBMS.

The relational model is known for its flexibility, and is the most frequently used model to this day.

=== [[NoSQL]] ===
'''NoSQL''' is a diverse category of data models. The following list some examples.

* Key/Value
* Graph
* Document
* Column-family

=== Other models ===

* Array/Matrix is useful for machine learning applications
* Hierarchical, network, multi-value is used in legacy systems.
{{Database sources}}
[[Category:Computer Science]]

Database

2024-07-20T23:03:20Z

Rice: /* Relational model */

A '''database''' stores, retrieves, and operates on a collection of related data. A '''database management system (DBMS)''' is a general way to implement databases. This page will describe why we want a system specifically for this task, a high-level breakdown of its functionality, as well as an overview of how it is implemented.

== Motivation ==
A separate system for the management of collections of data is necessary because of two things: 1) the task's prevalence in many application, and 2) the difficulty to implement such a system correctly and efficiently. The former point is relatively intuitive, but the second point is more involved.

To design a way to manage collections of data is to solve the following problems among many.

* '''Data integrity''': Ensure that data stored is valid and will not cause errors upon operation and/or retrieval. Examples include type checking.
* '''Efficient implementation:''' Implementation needs to be efficient for the task at hand. Examples include data structures and concurrency.
* '''Durability:''' Ensure the safety of the data during system errors and modifications. Examples include computer crashing.

All of the above tasks are highly involved. As such, a layer of abstraction is very beneficial for development: you don't want to handle all of these problems when building your project!

== Description ==
The role of a general-purpose DBMS is to handle the definition, creation, querying, update, and administration of databases. DBMSes are widely tested and deployed, and as such allow developers to focus on other aspects of their program and rely on DBMSes to store the data.

== Models ==

=== [[Relational model]] ===
The '''relational model''' abstracts away database implementation by allowing developers to access data through a high-level language, where the DBMS decides the strategy. It stores data in a simple structure called a '''relation''', and the physical implementation of the database is handled by the DBMS.

{{Database sources}}
[[Category:Computer Science]]

Database

2024-07-20T23:02:51Z

Rice: /* Description */

A '''database''' stores, retrieves, and operates on a collection of related data. A '''database management system (DBMS)''' is a general way to implement databases. This page will describe why we want a system specifically for this task, a high-level breakdown of its functionality, as well as an overview of how it is implemented.

== Motivation ==
A separate system for the management of collections of data is necessary because of two things: 1) the task's prevalence in many application, and 2) the difficulty to implement such a system correctly and efficiently. The former point is relatively intuitive, but the second point is more involved.

To design a way to manage collections of data is to solve the following problems among many.

* '''Data integrity''': Ensure that data stored is valid and will not cause errors upon operation and/or retrieval. Examples include type checking.
* '''Efficient implementation:''' Implementation needs to be efficient for the task at hand. Examples include data structures and concurrency.
* '''Durability:''' Ensure the safety of the data during system errors and modifications. Examples include computer crashing.

All of the above tasks are highly involved. As such, a layer of abstraction is very beneficial for development: you don't want to handle all of these problems when building your project!

== Description ==
The role of a general-purpose DBMS is to handle the definition, creation, querying, update, and administration of databases. DBMSes are widely tested and deployed, and as such allow developers to focus on other aspects of their program and rely on DBMSes to store the data.

== Models ==

=== [[Relational model]] ===
The '''relational model''' abstracts away database implementation by allowing developers to access data through a high-level language, where the DBMS decides the strategy. It stores data in a simple structure called a '''relation''', and the physical implementation of the database is handled by the DBMS.{{Database sources}}
[[Category:Computer Science]]

Database

2024-07-20T22:58:03Z

Rice: /* Motivation */

Template:Database sources

2024-07-20T22:53:34Z

Rice:

= Sources =
Information about databases on this wiki come from the following sources:
* [https://www.youtube.com/watch?v=v4bU6n97Vr8&list=PLSE8ODhjZXjZaHA6QcxDfJ0SIWBzQFKEG&index=1 CMU public lecture on YouTube]
[[Category:Computer Science]]
[[Category:Sources]]

Template:Database sources

2024-07-20T22:53:01Z

Rice:

Template:Database sources

2024-07-20T22:52:49Z

Rice: Created page with "# Sources Information about databases on this wiki come from the following sources: * [https://www.youtube.com/watch?v=v4bU6n97Vr8&list=PLSE8ODhjZXjZaHA6QcxDfJ0SIWBzQFKEG&index=1 CMU public lecture on YouTube] Category:Computer Science"

# Sources
Information about databases on this wiki come from the following sources:
* [https://www.youtube.com/watch?v=v4bU6n97Vr8&list=PLSE8ODhjZXjZaHA6QcxDfJ0SIWBzQFKEG&index=1 CMU public lecture on YouTube]
[[Category:Computer Science]]

Database

2024-07-20T22:49:51Z

Rice:

A '''database management system (DBMS)''' is a system that stores, retrieves, and operates on a collection of related data. This page will describe why we want a system specifically for this task, a high-level breakdown of its functionality, as well as an overview of how it is implemented.

== Motivation ==
A separate system for the management of collections of data is necessary because of two things: 1) the task's prevalence in many application, and 2) the difficulty to implement such a system correctly and efficiently. The former point is relatively intuitive, but the second point is more involved.

To design a way to manage collections of data is to solve the following problems among many.

* '''Data integrity''': Ensure that data stored is valid and will not cause errors upon operation and/or retrieval. Examples include type checking.
* '''Efficient implementation:''' Implementation needs to be efficient for the task at hand. Examples include data structures and concurrency.
* '''Durability:''' Ensure the safety of the data during system errors and modifications. Examples include computer crashing.

As such, it is unproductive to do this for every application.
[[Category:Computer Science]]

Database

2024-07-20T22:36:55Z

Rice:

A '''database''' is a system that stores, retrieves, and operates on a collection of related data.
[[Category:Computer Science]]

Database

2024-07-20T22:36:35Z

Rice: Created page with "A '''database''' is a system that stores, retrieves, and operates on a collection of related data efficiently. Category:Computer Science"

A '''database''' is a system that stores, retrieves, and operates on a collection of related data efficiently.
[[Category:Computer Science]]

Diffusion model

2024-07-05T23:08:24Z

Rice:

In a nutshell, '''diffusion models''' work by making something more random/noisy, and through the process finding the inverse, which is making noisy things less random, thus generating data.

Diffusion models are frequently used for computer vision tasks such as text-to-image. This page will focus exclusively on that use case.

== Principle ==
More specifically, diffusion models consists of two steps: ''forward'' ''diffusion'', which turns an image into noise, and ''backward diffusion'', which turns noise back into an image.

=== Forward diffusion ===
Mathematically, each step of the forward diffusion process is defined as <math>q(x_t|x_{t-1})=\mathcal{N}(x_t, \sqrt{1-\beta_t}x_{t-1} , \beta_tI)</math>, where ''xt'' is the process output at step ''t'', ''q'' is a distribution at the current step depending on the previous step, ''N'' is a [[multivariate normal distribution]], the square root is the mean, and the last one being the variance.

Explained more textually, the process generates a probability distribution of the current step (''xt'') given the last step. The distribution is normal, with randomness injected by a schedule. The image starts with a non-random distribution, and through this process we destroy that distribution into noise. In real scenarios, the noise is not added iteratively, but this is the principle.

==== Schedule ====
''Beta t'' is the hyperparameter called ''schedule''. It increases w.r.t. time step ''t'' and controls the variance of the distribution during the forward process. It is a value ranging from 0 to 1, and as a result, it brings the mean of the gaussian closer to 0 and the variance closer to ''I'', which is the goal of the forward process.

We want a small schedule such that learning how to undo it isn't too difficult.

==== Noising process ====
Thus, the entire noise added at time step ''T'' is defined to be <math>q(x_{1:T} |x_0)=\prod^T_{t=i}q(x_t|x_{t-1})</math>, coming form probability.

With the derivation in source 1, we can simplify it to a single equation instead of an iterative process, significantly speeding up the algorithm.

= Sources =

# https://erdem.pl/2023/11/step-by-step-visual-introduction-to-diffusion-models
# [https://www.youtube.com/watch?v=fbLgFrlTnGU&t=75s https://www.youtube.com/watch?v=fbLgFrlTnGU]

[[Category:Computer Science]]
[[Category:Machine Learning]]

Diffusion model

2024-07-05T23:06:48Z

Rice: /* Principle */

In a nutshell, '''diffusion models''' work by making something more random/noisy, and through the process finding the inverse, which is making noisy things less random, thus generating data.

Diffusion models are frequently used for computer vision tasks such as text-to-image. This page will focus exclusively on that use case.

== Principle ==
More specifically, diffusion models consists of two steps: ''forward'' ''diffusion'', which turns an image into noise, and ''backward diffusion'', which turns noise back into an image.

=== Forward diffusion ===
Mathematically, each step of the forward diffusion process is defined as <math>q(x_t|x_{t-1})=\mathcal{N}(x_t, \sqrt{1-\beta_t}x_{t-1} , \beta_tI)</math>, where ''xt'' is the process output at step ''t'', ''q'' is a distribution at the current step depending on the previous step, ''N'' is a [[multivariate normal distribution]], the square root is the mean, and the last one being the variance.

Explained more textually, the process generates a probability distribution of the current step (''xt'') given the last step. The distribution is normal, with randomness injected by a schedule. The image starts with a non-random distribution, and through this process we destroy that distribution into noise. In real scenarios, the noise is not added iteratively, but this is the principle.

==== Schedule ====
''Beta t'' is the hyperparameter called ''schedule''. It increases w.r.t. time step ''t'' and controls the variance of the distribution during the forward process. It is a value ranging from 0 to 1, and as a result, it brings the mean of the gaussian closer to 0 and the variance closer to ''I'', which is the goal of the forward process.

We want a small schedule such that learning how to undo it isn't too difficult.

==== Noising process ====
Thus, the entire noise added at time step ''T'' is defined to be <math>q(x_{1:T} |x_0)=\prod^T_{t=i}q(x_t|x_{t-1})</math>, coming form probability.

= Sources =

* https://erdem.pl/2023/11/step-by-step-visual-introduction-to-diffusion-models
* [https://www.youtube.com/watch?v=fbLgFrlTnGU&t=75s https://www.youtube.com/watch?v=fbLgFrlTnGU]

[[Category:Computer Science]]
[[Category:Machine Learning]]

Entity relationship diagram

2024-07-05T01:21:43Z

Rice:

[[Category:Computer Science]]
As the name suggests, an '''entity relationship diagram (ERD)''' shows '''entities''', their properties, and their relationships with other entities. It is the industry standard used to illustrate [[Relational database|relational databases]] graphically.

== Definitions ==
The core of an ERD is the ''entity''. It is a definable "thing" that stores information.

Both ''entity types'' and ''entity sets'' are groups of definable things. However, entity types are time-independent, whereas entity sets are entity types at a particular interval of time. ''An entity is an instance of an entity type''.

=== Entity categories ===
Entities are categorized into strong, weak, and associative. A ''strong'' entity can be defined solely by its properties, making it unique to other strong entities of the same type, whereas a weak one cannot be defined solely by its properties and is usually tied to a strong entity. The difference can be thought of as one having a key and the other not having one.

In contrast to the distinction between strong and weak by the uniqueness of an entity in its type, an associative entity is used to describe an association (relationship) between entities. Think of it as weak entities with multiple parents.
[[File:ERD Cardinality.png|thumb|Figure 1. Cardinality diagram sourced from lucidchart]]

=== Cardinality ===
Lines are used to represent relationships between entity types in an ERD, and the ''cardinality'' of the relationship further describes that relationship in terms of the number on each side. Figure 1 illustrates all cardinality lines.

= Sources =

* https://www.lucidchart.com/pages/er-diagrams

File:ERD Cardinality.png

2024-07-05T01:21:13Z

Rice:

Diagram of cardinality from https://www.lucidchart.com/pages/er-diagrams

Entity relationship diagram

2024-07-05T01:17:34Z

Rice:

[[Category:Computer Science]]
As the name suggests, an '''entity relationship diagram (ERD)''' shows '''entities''', their properties, and their relationships with other entities. It is the industry standard used to illustrate [[Relational database|relational databases]] graphically.

== Definitions ==
The core of an ERD is the ''entity''. It is a definable "thing" that stores information.

Both ''entity types'' and ''entity sets'' are groups of definable things. However, entity types are time-independent, whereas entity sets are entity types at a particular interval of time. ''An entity is an instance of an entity type''.

=== Entity categories ===
Entities are categorized into strong, weak, and associative. A ''strong'' entity can be defined solely by its properties, making it unique to other strong entities of the same type, whereas a weak one cannot be defined solely by its properties and is usually tied to a strong entity. The difference can be thought of as one having a key and the other not having one.

In contrast to the distinction between strong and weak by the uniqueness of an entity in its type, an associative entity is used to describe an association (relationship) between entities. Think of it as weak entities with multiple parents.

= Sources =

* https://www.lucidchart.com/pages/er-diagrams

Entity relationship diagram

2024-07-05T00:54:20Z

Rice:

[[Category:Computer Science]]
As the name suggests, an '''entity relationship diagram''' shows '''entities''', their properties, and their relationships with other entities. It is often used to illustrate relational databases graphically.

= Sources =

* https://www.lucidchart.com/pages/er-diagrams

Entity relationship diagram

2024-07-05T00:52:17Z

Rice: Created page with "Category:Computer Science"

[[Category:Computer Science]]

ERD

2024-07-05T00:52:00Z

Rice: Redirected page to Entity relationship diagram

#REDIRECT [[Entity relationship diagram]]

Diffusion model

2024-07-05T00:37:48Z

Rice: /* Forward diffusion */

Covariance

2024-07-05T00:37:25Z

Rice: Redirected page to Bivariate

#REDIRECT [[Bivariate]]

Multivariate normal distribution

2024-07-05T00:21:38Z

Rice: Created page with "A '''multivariate normal distribution''' is the normal distribution generalized into higher dimensions. == Definitions == The distribution is written as <math>\mathbf{x}\sim \mathcal{N} _k(\boldsymbol\mu,\, \boldsymbol\Sigma )</math>, where mu is a k-vector mean and sigma is the covariance matrix. = Sources = * https://en.wikipedia.org/wiki/Multivariate_normal_distribution Category:Statistics"

A '''multivariate normal distribution''' is the [[normal distribution]] generalized into higher dimensions.

== Definitions ==
The distribution is written as <math>\mathbf{x}\sim \mathcal{N} _k(\boldsymbol\mu,\, \boldsymbol\Sigma )</math>, where mu is a k-vector mean and sigma is the [[covariance]] matrix.

= Sources =

* https://en.wikipedia.org/wiki/Multivariate_normal_distribution

[[Category:Statistics]]

Diffusion model

2024-07-05T00:15:03Z

Rice: /* Forward diffusion */