Category: linux

Resource limitation of processes

Posted on by lechuck park

From DALL-E with some prompting

This image represents a concept diagram for ‘Control Groups’ (Cgroups) used in the Linux operating system. Cgroups provide the capability to manage and limit system resource usage for groups of processes. Each control group can have limits set for various resources such as CPU, memory, block I/O, and network bandwidth.

Groups A, B, C: Each circle represents a separate control group, and the gear icons within each group symbolize the processes assigned to that group.

The central graphical elements represent various system resources:

CPU: Represents CPU time and usage (milliseconds, percentage).
Memory (RAM): Shows total memory usage, memory usage ratio, and memory usage limit.
Block I/O: Illustrates disk read/write speed, number of input/output operations per second (IOPS), and latency.
Network Bandwidth: Displays transmission speed and bandwidth usage ratio.
In the upper right, there’s a section with the text “Resource limits per group” alongside icons for each resource and a question-marked group. This likely illustrates the resource limitations that can be set for each control group.

At the bottom, “Linux 2.6.24 +” indicates that the Cgroups feature is available from Linux kernel version 2.6.24 onwards.

Overall, the image seems to have been created to explain the concept of Cgroups and how resources can be managed for different groups within a system.


Linux RUN LEVEL

Posted on by lechuck park

From DALL-E with some prompting
The image describes the Linux Run Levels, which are modes of operation in Unix-like operating systems. It explains the directories /etc/rcX.d where X is the run level number, and /etc/init.d which contains the original script files. The various levels are highlighted:

  • Level 0: Halt the system.
  • Level 1: Single user mode.
  • Level 2: Single user mode without networking.
  • Level 3: Single user mode with networking.
  • Level 4: Unused.
  • Level 5: Multi-user mode with networking and GUI.
  • Level 6: Reboot.

Scripts starting with S are used to start services, and those starting with K are used to stop services. The scripts are symbolically linked and have a naming convention that usually starts with S or K followed by a number indicating the order of execution.

Kernel Same-page Merging

Posted on by lechuck park

From DALL-E with some prompting
Kernel Same-page Merging (KSM) is a feature within an operating system’s kernel that enhances memory efficiency by identifying and merging identical memory pages. Typically, this process is beneficial for duplicated pages from executable files and shared libraries, which are common across different processes. KSM is also advantageous in environments where there is a significant amount of shared data and memory-mapped files, such as virtualization systems where multiple virtual machines may be running the same operating system or similar applications. By merging these pages, KSM allows for a reduction in physical memory usage, leading to better memory management and potentially improved performance for the system.

Read-copy update

Posted on by lechuck park

From DALL-E with some prompting
The image explains the “Read-Copy Update” mechanism, illustrating the process of reading and writing data in concurrent programming divided into two parts.

The left section, accompanied by the phrase “Easy to Read,” shows arrows from three gear icons pointing towards a document icon. This represents the “Wait-Free Reads” process, indicating that multiple threads can read data simultaneously without waiting.

The right section, labeled “Complex to Write,” demonstrates that the writing process is more complicated. During the “Grace Period,” the old data can still be read, but after copying is finished, the new data is read. During this period, the old data is subject to “Old → Garbage Collection,” meaning it will be discarded through garbage collection. This mechanism ensures that data reads are not blocked while the data is being updated.

The Read-Copy Update is a strategy used in systems handling concurrency to maintain data consistency while optimizing the performance of read operations. Although the process of writing data is complex, the mechanism is designed to allow reads to be simple and fast.

System Call

Posted on by lechuck park

From DALL-E with some prompting
This diagram illustrates the process by which an application process requests services from the operating system through a system call. Applications running in user space cannot directly access hardware resources and must go through the operating system located in kernel space to perform necessary operations. System calls act as an interface between user space and kernel space, which is crucial for the system’s stability and security. The operating system abstracts hardware resources, facilitating easy access for applications.

Jiffies

Posted on by lechuck park

From DALL-E with some prompting

The image provides an explanation of how time updates are handled in computer systems. The key points include:

  • “Jiffies” refers to a global variable used by the kernel to keep track of time.
  • Time updates are performed at the hardware level through “timer interrupts,” which are initiated periodically by the system’s real-time clock.
  • The “HW_TIMER_INTERRUPT” increments the jiffies value by one, and this can be set to various frequencies such as 100, 250, or 1000 Hertz (HZ).
  • There is a question about whether there is a delay when using “datetime,” which is crucial as time updates need to be processed in real-time.
  • The jiffies value can be read using the read() function, and functions like sleep(), usleep(), msleep(), nsleep(), and nanosleep() utilize this jiffies value to pause the execution of a program for a certain amount of time.

The image visually represents the concept of how the operating system’s kernel manages time and how time-related functions use the system’s “jiffies” value.

Critical Section

Posted on by lechuck park

From DALL-E with some prompting
The provided image delineates the concept of a “Critical Section” in process execution, where certain areas of the program code are designated as sensitive or exclusive zones to prevent concurrent access. This is not merely a matter of securing a memory location but rather about managing access to specific code blocks that interact with shared variables or addresses.

In the diagram, the “Critical Sections” are highlighted to signify that these blocks of code are where ‘blocking’ occurs, allowing only one thread or process to operate on the shared resources at a time, thus ensuring data integrity and preventing race conditions. The transition from code lines to data, through variable addresses and virtual address mapping to the actual data in hardware, suggests a layered approach to security and access control.

Moreover, the image hints at the abstraction layers from a virtual address space to the physical hardware address, underlining the importance of security protocols at each layer. These critical sections act as a checkpoint not only to enforce sequential access to shared resources but also to facilitate a systematic flow of operations, from programming syntax to system calls, and from understanding the computer architecture to the actual hardware operations. This systematic control is crucial for maintaining security and operational efficiency in digital systems.