DEV Community: ivinieon

Review posting 2

ivinieon — Mon, 03 Apr 2023 20:32:43 +0000

5. How to decide the number of threads based on CPU bound/IO bound

Burst is a phenomenon that occurs intensively within a short time.

CPU burst refers to the time a process is continuously executed on the CPU.

IO burst refers to the time a process waits for an IO operation to complete after requesting it.

The life of a process is a continuous sequence of CPU and IO bursts.

CPU bound process
A process that has many CPU bursts.
ex) video editing software, machine learning programs

IO bound process
A process that has many IO bursts.
ex) typical backend API servers

CPU bound 프로그램이 dual-core CPU에서 실행될 때 몇 개의 thread가 사용되어야 할까?

→ Thread 개수 = CPU 개수 +1
너무 많은 thread가 있으면 쓸데없이 context switching이 발생해서 CPU 사용이 낭비되고 늘어나기 때문에.

6. Synchronization, Race Condition, Critical Section

What happens when two threads access one object?

The result can be different depending on when the context switching occurs.

Race condition: A situation where the result may vary depending on the timing or access order when multiple processes/threads manipulate the same data.

Synchronization: Maintaining the consistency of shared data even when multiple processes/threads are executed simultaneously.

How to synchronize?

Critical section: An area that only one process/thread can enter and execute to ensure the consistency of shared data.

Conditions for solving the critical section problem

1. Mutual exclusion
→ Only one process/thread can execute the critical section at a time.

2. Progress
→ If the critical section is empty and multiple processes/threads want to enter the critical section, one of them must be executed.

3. Bounded waiting
→ Waiting indefinitely to enter the critical section should not be allowed.

7. Features and Differences of Spinlock, Mutex, and Semaphore

do {
    acquire lock
        critical section
    release lock
        remainder section
} while (TRUE)
-------------------------
volatile int lock = 0; //global

void critical() {
    while (test_and_set(&lock) == 1);
// int TestAndSet(int*lockPtr) {
//     int oldLock = *lockPtr;
//     *lockPtr = 1;
//     return oldLock;
}
    ... critical section
    lock = 0;
}

두 개의 thread가 있다고 가정할 때, T1이 while loop에 먼저 들어간다.
test_and_set(&lock) 함수에서, lock의 value인 0은 oldLock에 저장되고 새롭게 1이라는 value를 가지게 된다.
그리고 이 함수는 oldLock, 즉 0을 리턴하게 되면서 while이 false이기 때문에 T1은 while을 종료하고 critical section으로 진입한다.
T2가 이때 while에 접근하지만, test_and_set(&lock)은 계속해서 1을 리턴하기 때문에 true라서 while에 갇히게 된다.
T1이 critical section에서 나오면 lock은 0이 되고 그 때 T2는 while에서 나오게 되어 critical section에 진입하게 된다.

What if both enter the while loop at the same time?

CPU가 오직 하나만 들어올 수 있게 해준다.

이 방법은 CPU를 낭비하게 된다.
Spinlock: Repeatedly try until you can have the lock (while loop).

class Mutex {
        int value = 1;
        int guard = 0;
}
------------------
Mutex::lock() {
        while(test_and_set(&guard));
        if(value == 0) {
             ...현재 스레드를 큐에 넣음;
             guard = 0; & go to sleep
        } else {
             value = 0;
             guard = 0;
        }
}
--------------------
Mutex::unlock(){
    while(test_and_set(&guard));
    if(큐에 하나라도 대기중이라면){
            그 중에 하나를 깨운다;
    } else {
            value = 1;
  }
    guard = 0;
}
---------------
mutex -> lock();
...critical section
mutex -> unlock();

Critical section에 들어가기 위해 경쟁할 때, lock이 실행된다.
value가 0일 때, 현재 thread를 queue에 넣는다.
unlock이 queue에 하나라도 대기중이라면 그 중 하나를 깨운다. &arr; CPU 사용율를 줄일 수 있음
guard는 여러 개의 process나 thread가 접근할 때 value를 보호하는 장치이다.

Is a mutex always better than a spinlock?

If the multi-core environment and the operation in the critical section are completed faster than context switching, then spinlock has more advantages than mutex.
Context switching occurs during sleeping and awakening in mutex.

Semaphore: A device that allows one or more processes/threads to access the critical section using signal mechanisms.
The semaphore consists of an integer variable that can have a value of 0 or higher.

class Semaphore {
        int value = 1; //0,1,2,3 이 될 수도 있음
        int guard = 0;
}
------------------
Semaphore::wait() {
        while(test_and_set(&guard));
        if(value == 0) {
             ...현재 스레드를 큐에 넣음;
             guard = 0; & go to sleep
        } else {
             value -= 1;
             guard = 0;
        }
}
--------------------
Semaphore::signal(){
    while(test_and_set(&guard));
    if(큐에 하나라도 대기중이라면){
            그 중에 하나를 깨운다;
    } else {
            value += 1;
  }
    guard = 0;
}
---------------
semaphore -> wait();
...critical section
semaphore -> signal();

Multi-core environment
Multi-core environment에서 value가 0으로 세팅되어 있을 때, P1과 P2는 동시에 실행되기 위해 할당되고 task3는 task1 다음에 실행되게 한다.

만약 P1이 signal을 먼저 호출하고 value가 1이 되면, P2는 wait를 호출하고 value를 0으로 만든다. 그런 다음 task3가 실행된다.
만약 P2가 먼저 wait를 호출하고 value가 여전히 0이면, queue에 들어가게 된다. P1이 signal을 호출하고 나면 value는 1이 되고 P2는 wait에서 나올 수 있게 되고 task3이 실행된다.

mutex와 binary의 차이점

Mutex에서는 오직 lock을 가지고 있는 것만 lock을 해제 할 수 있지만 semaphore에서는 그렇지 않다. 하지만 semaphore에서는 wait와 signal이 꼭 같은 프로세스, 스레드에서 실행될 필요가 없다.
Mutex는 priority inheritance 속성을 가진다. 여러 프로세스나 스레드가 동시에 실행이 되면 우선순위에 따라 실행시키게 되는데 이를 스케줄링이라고 한다.

Review posting

ivinieon — Mon, 20 Mar 2023 20:29:43 +0000

1. Basic coding words

Object has states and behaviors.
Class describes the attributes and behaviors of the object.
instantiate: creating an object using the "new" keyword.
(Class는 새로운 object를 만드는 것이고 그 만드는 것을 instantiate라고 한다.)
Class 안에는 attributes, methods 들이 있고, 이 class에서 만든 object들은 이 attributes들과 methods를 가진다.

primitive type is predefined by the language such as int or boolean. If the Class creates a new object, it has the class type which was defined in the Class.

2. Relationship between Variables, Objects, and Memory

Application is a set of commands that a computer can execute to provide functions for the users.
Memory is the place where the executed application resides. Memory allocated to the application is internally divided into several areas.
→Identifier: name given to entity(이름)
→Variable: name given to location(실제 메모리 위치)
CPU is the computational unit that executes commands.

Stack memory
Whenever a function or method is called, a stack frame is stacked in the stack memory.

Heap memory
Heap memory is used during the creation of an object, and stack memory is also used for it. However, in the stack memory, there is "this" which points to the heap memory's address.

3. How can multiple programs be executed?

Process is a program that is running on a computer. Each process is assigned an independent memory space.
Thread is a unit of execution. A process can have more than one thread.

Multi-tasking: The multiple processes and threads are sharing a core and executing very short CPU time slices alternatively.
Multi-processing: A system that utilizes two or more processors or cores.
Multi threading: A single process executes multiple tasks(dual threads) simultaneously. Each core executes one task in parallel.

4. What is context switching?

Context Switching
The process of replacing a running process/thread with another process/thread on a CPU/core.
- Process context switching
→ additional processing related to virtual memory addresses is performed. MMU TLB

- Thread context switching
→ memory-related processing is not needed because memory is shared within the same process

Concepts and Use Cases of Stack and Queue

ivinieon — Mon, 20 Mar 2023 04:42:05 +0000

1. Concepts and Use Cases of Stack and Queue

2. Tips When Encountering a Queue in Technical Documents

3. Troubleshooting Errors Related to Stack and Queue

Abstract Data Type (ADT)

Defines only what operations should be performed without specifying how they should be implemented
Does not cover implementation details

Data structure (DS)

A concrete implementation of the ADT
Implements the operations defined in the ADT

Stack and Queue from the perspective of ADT

Stack: A structure that stores data in Last In First Out (LIFO) order

push: Adds an item to the stack
pop: Removes an item from the stack
peek: Retrieves the value of the topmost item in the stack

Since the item that is inserted first is placed at the bottom of the stack, the item that is inserted last is the first to be removed.

Queue: A structure that stores data in First In First Out (FIFO) order

enqueue: Adds an item to the queue
dequeue: Removes an item from the queue
peek: Retrieves the value of the frontmost item in the queue

The item that is inserted first is the first to be removed.

Use Cases for Stack: Stack Memory and Stack Frame

python
Copy code
def a():
        b()
def b():
        c()
def c():
        print("wow")

When a() is called, a stack for a() is created in the stack memory. Since b() is called inside a(), a stack for b() is also created. Similarly, when b() is called, a stack for c() is created. After the "wow" is printed, c() is removed from the stack, followed by b(), and finally a().

Use Cases for Queue: Producer/Consumer Architecture

The producer creates and the consumer consumes.

Tips When Encountering a Queue in Technical Documents

FIFO is not always implied: In a priority queue, items with higher priority are removed first.

Stack/Queue Related Errors and Troubleshooting Methods

StackOverflowError
An error that occurs when the stack memory is exhausted. This error occurs when a recursive function cannot exit.

Recursive Function: Calling a function within itself.

python
Copy code
def recur_fibo(n):
    if n<=1:
        return n
    else:
        return(Recur_fino(n-1)+recur_fibo(n-2))

OutOfMemoryError
An error that occurs when the Java heap memory is exhausted. This error occurs when the queue is constantly being filled with data.

Heap: The area where objects reside.

The queue size should be fixed. What if the queue is full?

Throw an exception
Return a special value (null or false)
Block the thread indefinitely until success
Block the thread for a limited amount of time and then give up

LinkedBlockingQueue

This posting is just a study note which was written after watching youtube videos in Korean.
Youtube

How is the monitor used for synchronization?

ivinieon — Thu, 16 Mar 2023 04:23:07 +0000

Monitor

Ensures mutual exclusion
Allows threads to wait based on conditions

When is it used?

When only one thread should be executing at a time
When collaboration between multiple threads is needed

Components of the monitor

- Mutex: A device that ensures mutual exclusion in critical sections. A thread must acquire a mutex lock to enter a critical section. If a thread cannot acquire the mutex lock, it goes into a waiting state in the queue. When a thread holding the mutex lock releases it, one of the waiting threads in the queue is selected to execute.

- Condition variables: Have a waiting queue. Where threads wait for a condition to be met in a waiting state.

Operations on condition variables:

wait: The thread puts itself in the waiting queue of the condition variable and goes into a waiting state.
signal: Wakes up one of the threads waiting in the waiting queue.
broadcast: Wakes up all threads waiting in the waiting queue.

acquire(m) // Acquire the lock of the monitor
while(!p) { // Check the condition
    wait(m, cv); // If the condition is not met, wait
}
...
signal(cv2); --OR-- broadcast(cv2); //cv2 can be the same as cv
release(m); // Release the lock of the monitor

When a thread enters the waiting queue, it must release the lock.

Two queues

- Entry queue: The queue of threads waiting to enter the critical section. Managed by the mutex.
- Waiting queue: The queue of threads waiting for a condition to be met. Managed by the condition variable.

Bounded producer/consumer problem:

The producer creates goods and fills them in a buffer, while the consumer consumes the goods.

Problem scenario 1: The producer keeps creating goods, but the buffer is full and there is no room left.

Problem scenario 2: The consumer tries to consume goods, but the buffer is empty and there is nothing to consume.

global volatile Buffer q;
global Lock lock;
global CV fullCV;
global CV emptyCV;
-------------------------------------------------------
public method producer() {
    while(true) {
        task myTask = ...'

        lock.acquire(); 
        // A mutex lock is required to enter the CV. If there is no lock, enter the entry queue and wait.

        while(q.isFull()) {
            wait(lock, fullCV); // Check if the buffer is full. If it is full, wait in the waiting queue.
        }

        q.enqueue(myTask);

        signal(emptyCV); --or-- broadcast(emptyCV);

        lock.release();
        }
    }

--------------------------------------------------------

public method consumer() {
    while(true) {
        lock.acquire();
        // The producer and consumer compete for one lock.
        while(q.isEmpty()) {{
            wait(lock, emptyCV);
        } // Always wait in the while loop so that when awakened, it can check if the condition is met.
            // If the buffer is empty, wait in the waiting queue.
        myTask = q.dequeue();

        signal(fullCV); --or-- broadcast(fullCV);

        lock.release();

        doStuff(myTask);
    }
}

What is a Java monitor?

In Java, every object has an internal monitor.

The mutual exclusion functionality of the monitor is used with the synchronized keyword.

Java monitors have only one condition variable.

Three operations of the Java monitor:

wait
notify(signal)
notifyAll(broadcast)

This posting is just a study note which was written after watching youtube videos in Korean.
https://youtu.be/Dms1oBmRAlo

Features and Differences of Spinlock, Mutex, and Semaphore

ivinieon — Fri, 10 Mar 2023 21:45:33 +0000

Review

Race condition: A situation where multiple processes/threads manipulate the same data at the same time, and the result can vary depending on the timing or access order.

Synchronization: Maintaining the consistency of shared data even when multiple processes/threads are executed simultaneously.

Critical section: An area that can only be entered and executed by one process/thread to ensure the consistency of shared data.

→ Mutual exclusion: Allowing only one process/thread to enter and execute.

How can we ensure mutual exclusion?

→ Let's use locks!

do {
    acquire lock
        critical section
    release lock
        remainder section
} while (TRUE)

volatile int lock = 0; //global

void critical() {
    while (test_and_set(&lock) == 1);
// int TestAndSet(int*lockPtr) {
//     int oldLock = *lockPtr;
//     *lockPtr = 1;
//     return oldLock;
    ... critical section
    lock = 0;
}

Process:

Assuming there are two threads, T1 and T2, and T1 executes the while loop first.
In the test_and_set(&lock) function, the value of lock(lockPtr), which is 0, is stored in oldLock, and lock(lockPtr) is changed to 1.
Since this function returns lodLock, which is 0, the while loop becomes false, and T1 exits the while loop and enters the critical section.
At this point, T2 executes, and enters the while loop (T1 is still in the critical section). Since the value of lock is 1, test_and_set(&lock) returns 1.
When you look inside the function, lock(lockPtr) has a value of 1, and this value is stored in oldLock. Then, lock(lockPtr) remains 1 and oldLock, which is 1, is returned. T6. herefore, the while loop is true, and T2 continues to run the while loop.
After that, when T1 exits the critical section and the value of lock changes to 0, T2 inside the while loop can exit and enter the critical section.

→ In other words, simultaneous execution is not possible.

What if both enter the while loop at the same time?

The TestAndSet function uses the help of the CPU.

→ CPU atomic instructions

They are not interfered with or interrupted during execution.
They are not executed simultaneously for the same memory area. → Even if two or more processes/threads access it, the CPU allows only one to come. It synchronizes two processes so that they cannot run simultaneously.

Note: The TestAndSet function does not necessarily have to have that body, but it proceeds in such a form.

Spinlock: Repeatedly try until you can have the lock (while loop).

→ Waste CPU while waiting.

class Mutex {
        int value = 1;
        int guard = 0;
}
------------------
Mutex::lock() {
        while(test_and_set(&guard));
        if(value == 0) {
             ...현재 스레드를 큐에 넣음;
             guard = 0; & go to sleep
        } else {
             value = 0;
             guard = 0;
        }
}
--------------------
Mutex::unlock(){
    while(test_and_set(&guard));
    if(큐에 하나라도 대기중이라면){
            그 중에 하나를 깨운다;
    } else {
            value = 1;
  }
    guard = 0;
}
---------------
mutex -> lock();
...critical section
mutex -> unlock();

Process:

When competing to access the critical section, a lock is executed based on whether or not the value can have a value.
If the value cannot have a value (value == 0), it goes into a queue and later one of the threads in the queue is awakened in the unlock phase. → This minimizes unnecessary CPU cycles.
The guard is a device installed in test_and_set to protect the value in case multiple processes/threads access it (an atomic device at the CPU level).

Mutex: Rest until you can have the lock.

Is a mutex always better than a spinlock?

If the multi-core environment and the operation in the critical section are completed faster than context switching, then spinlock has more advantages than mutex.

Context switching occurs during sleeping and awakening in mutex.

In a CPU with two cores, if T1 is executing in C1's critical section and T2 continues to spinlock in C2, T2 can execute immediately when T1 exits the critical section.

Semaphore: A device that allows one or more processes/threads to access the critical section using signal mechanisms.

A semaphore is a synchronization tool that allows one or more processes or threads to access the critical section. The semaphore consists of an integer variable that can have a value of 0 or higher.

class Semaphore {
        int value = 1; //0,1,2,3 이 될 수도 있음
        int guard = 0;
}
------------------
Semaphore::wait() {
        while(test_and_set(&guard));
        if(value == 0) {
             ...현재 스레드를 큐에 넣음;
             guard = 0; & go to sleep
        } else {
             value -= 1;
             guard = 0;
        }
}
--------------------
Semaphore::signal(){
    while(test_and_set(&guard));
    if(큐에 하나라도 대기중이라면){
            그 중에 하나를 깨운다;
    } else {
            value += 1;
  }
    guard = 0;
}
---------------
semaphore -> wait();
...critical section
semaphore -> signal();

In the class Semaphore, the value determines how many threads/processes can run simultaneously.

value = 1; binary semaphore.
When Semaphore::wait is called and value is not 0, value -= 1 is executed, and value becomes 0. Subsequently, threads/processes after that point will enter a queue because value is 0.
When value is set to 2 or more, counting semaphore

signal mechanisms : for order

In a multi-core environment where value is set to 0, P1 and P2 are allocated to run simultaneously, and task3 is scheduled to run after task1 finishes.

If P1 calls signal first, value becomes 1, P2 calls wait, and value becomes 0. Then, task3 can start running.
If P2 calls wait first, value is still 0, so it enters the queue in the if statement. When P1 finishes calling signal and value becomes 1, P2 can exit wait and task3 can start running.

→ Therefore, in Semaphore, it is not necessary for wait and signal to be executed in the same process/thread.

The difference between mutex and binary

Semaphore is that only the lock holder can release the lock in mutex, while in semaphore, it is not necessary. However, in semaphore, it is not necessary for wait and signal to be executed in the same process/thread.
Mutex has the property of priority inheritance. When multiple processes/threads are executed at the same time, the scheduling is done based on priority. → If P2 has a lower priority than P1 and P2 holds the lock and executes first, P1 has to wait until P2 finishes. This slows down the speed of leaving the critical section, and P1 continues to wait. To solve this, P2's priority can be increased to match P1's, allowing for faster exit from the critical section.

If only mutual exclusion is required, it is recommended to use mutex. If synchronization of execution order between tasks is required, it is recommended to use semaphore.

This posting is just a study note which was written after watching youtube videos in Korean.
https://youtu.be/gTkvX2Awj6g

Synchronization, Race Condition, Critical Section

ivinieon — Tue, 07 Mar 2023 05:06:14 +0000

What happens when two threads access one object?

→ Why is synchronization important?

java
Copy code
for(apple for appleBox) {
    if(apple status is bad) {
        badCounter.increment(); 
    }
}

public class Counter {
    private int state = 0;
    public void increment() {state++;}
//1. LOAD state to R1 // Load state into R1
//2. R1 = R1 + 1 // Add 1 to R1 and store the result in R1
//3. STORE R1 to state // Store R1 back into state
    public int get() {return state;}
}

Assuming that two threads check for bad apples in one appleBox respectively using this code, if T1 finds 2 bad apples and T2 finds 5 bad apples, the value of memory's state, which is initially 0, is expected to be 7, but that's not always the case.

The result can be different depending on when the context switching occurs.

For example, when T1 loads the state from memory to R1, R1 becomes 0. Then, when T1 stores the result of adding 1 to R1 in R1, R1 becomes 1. If a context switching occurs at this point, T2 executes steps 1 and 2, and stores the value of R1 in memory's state. Then, when context switching occurs again and T1 stores R1 in state, the value remains 1 because T2 already stored it as 1. (It should have been 2 originally.)
→Race condition

Race condition: A situation where the result may vary depending on the timing or access order when multiple processes/threads manipulate the same data.

Synchronization: Maintaining the consistency of shared data even when multiple processes/threads are executed simultaneously.

How to synchronize?

Critical section: An area that only one process/thread can enter and execute to ensure the consistency of shared data.

java
Copy code
do{
    entry section
        critical section
    exit section
        reminder section
} while(TRUE)

Conditions for solving the critical section problem

1. Mutual exclusion
→ Only one process/thread can execute the critical section at a time.

2. Progress
→ If the critical section is empty and multiple processes/threads want to enter the critical section, one of them must be executed.

3. Bounded waiting
→ Waiting indefinitely to enter the critical section should not be allowed.

This posting is just a study note which was written after watching youtube videos in Korean.

Youtube Link

How to decide the number of threads based on CPU bound/ IO bound

ivinieon — Sat, 04 Mar 2023 23:04:25 +0000

How to decide the number of threads based on CPU bound/ IO bound

Review/Preview words

CPU(Central Processing Unit) is the device that interprets and executes the commands of a process.

IO(Input/Output) involves reading and writing files, sending and receiving data with a network, and interacting with input/output devices.

Burst is a phenomenon that occurs intensively within a short time.

CPU burst refers to the time a process is continuously executed on the CPU.

IO burst refers to the time a process waits for an IO operation to complete after requesting it.

The life of a process is a continuous sequence of CPU and IO bursts.

The frequency of CPU bursts depends on their length.

CPU bound process
A process that has many CPU bursts.
ex) video editing software, machine learning programs

IO bound process
A process that has many IO bursts.
ex) typical backend API servers

If implementing a CPU bound program to run on a dual-core CPU, how many threads should be used?

→ The number of threads = The number of CPUs + 1

In actual execution:

→ Context switching(CS) is overhead, tasks that use the CPU.
In this picture, unnecessary context-switching occurs, the CPU usage increases.

Dual-core & 2 threads:

Since there is no context switching, CPU usage is not wasted, and the appropriate number of threads is one more than the number of CPU cores.

If implementing an IO bound program to run on a dual-core CPU, how many threads should be used?

→ It depends on the situation.

If the API server is a thread-per-request model? → The number of threads to be created in advance should be determined by considering various situations.

This posting is just a study note which was written after watching youtube videos in Korean.
Youtube link

What is a context switching?

ivinieon — Thu, 02 Mar 2023 06:03:22 +0000

What is context switching?

Context Switching

The process of replacing a running process/thread with another process/thread on a CPU/core.
Each process has a thread, which is the basic unit executed on a CPU/core.

What is a context?

The status of a process/thread, CPU, memory, etc.

Why is context switching necessary?

To execute multiple processes/threads simultaneously.

When does context switching occur?

When the given time slice(quantum) has been used up, when IO operations are required, when using other resources, etc.

Context switching in a multitasking system

→ Since the program is executed by dividing it into short periods, the user feels like programs are being executed simultaneously.

Who executes context switching?

OK kurnel: manages/supervises various resources.

How does context switching occur?

Process context switching: switching between different processes.
Thread context switching: switching between threads in the same process.

Commonalities:

Executed in kernel mode
→ control is transferred from the process to the kernel.
Registers of the CPU are replaced
→ the register state of the process being executed is saved somewhere, and another process is executed. Later, the saved register state of the first process is used to execute it again.

Registers: a location where data necessary to execute instructions is stored.

Differences:

Process context switching
→ additional processing related to virtual memory addresses is performed. MMU TLB
Thread context switching
→ memory-related processing is not needed because memory is shared within the same process.

Summary

Memory processing must be performed to prevent incorrect access to each other's memory areas.
Thread context switching is faster than process context switching.(sharing a memory)
Indirect effects of context switching: cache pollution.
Since the previous thread's information may be stored in the cache, when the thread is switched, it becomes useless.
From the user's perspective: pure overhead.

This posting is just a study note which was written after watching youtube videos in Korean.
Youtube Link

How can multiple programs be executed?

ivinieon — Mon, 27 Feb 2023 21:00:32 +0000

How can multiple programs be executed?

Program: A collection of commands that a computer can execute.
Process: A program that is running on a computer. Each process is assigned an independent memory space.
CPU: The computational unit that executes commands.
Main Memory: Where processes wait to be executed by the CPU.
I/O(Input/Output): Reading and writing files, sending and receiving data somewhere on the network. Handling input and output devices and sending or receiving data.

Single process system

Only one program runs at a time. CPU usage is not efficient because when a program performs an IO operation, the CPU is idle.
→ Load multiple programs into memory and execute them simultaneously. When IO operation occurs, another process runs on the CPU:

Multiprogramming

To maximize CPU usage.

Disadvantages
If the CPU usage time is long, the processes continue to wait.
→ Let the process run for a very short time(quantum) when using the CPU. Alternatively executing very short periods of time.

Multitasking

To minimize the response time of the process.

Disadvantages

A single process cannot perform multiple tasks simultaneously.
Context switching between processes is a heavy task(programs cross over.)
Data sharing between processes is difficult. → the memory space they occupy is independent.
Dual-core processors have been released. &raar; improving the performance of a single CPU has trouble such as overheating.

Thread

A process can have more than one thread.
Unit of execution(CPU).
Context switching between threads of the same process is lightweight.
Threads share the memory space of the process they belong to.
→ Threads also have. their unique areas as well.(such as stacks)

Multithreading

A single process executes multiple tasks simultaneously.
Each core executes one task in parallel.

Extended multitasking concept: Multiple processes and threads share very short CPU time slices.

Multiprocessing

A system that utilizes two or more processors or cores.

Summary
Multitasking: Sharing cores
Multithreading: Dual Threads
Multiprocessing: More than 2 cores.

This posting is just a study note which was written after watching youtube videos in Korean.

Youtube Link

Relationship between Variables, Objects, and Memory

ivinieon — Sat, 25 Feb 2023 22:41:45 +0000

Relationship between Variables, Objects, and Memory

What is an Application
→ A set of commands that a computer can execute to provide functions for general users.
What is a Memory?
→ The place where the executed application resides. Memory allocated to the application is internally divided into several areas.
An identifier is a “name given to entity” in a program whereas, a variable is a “name given to memory location”.
What is a CPU?
→ The hardware component of a computer performs most of the processing tasks, executing instructions or commands that are stored in memory based on the instructions it receives from software.

## Stack Memory
Local variables and parameters of functions or methods are stored. A stack frame is stacked each time a function or method is called.

public class Main {
    public static void main(String[] args) {
            int a = 100;
            a = wow(a);
    }
    public static int wow(int num) {
            int b = num * 4;
            return b;
    }
}

When the main(String[] args) method is called, a stack frame for main() is created in the stack memory, and each parameter (args) and the value (100) for each local variable are stored, and a name (a) is attached.

When wow(a) is called, a stack frame for wow() is created again in the stack memory, and the parameter int num is stored in it, and since num = a, num becomes 100, b becomes 400, and that value is returned. Since the wow method call is over, the wow stack frame will be deleted, and the returned 400 will become the value of a.
In addition, if this stack memory is full, the application will terminate.

## Heap Memory
Objects are stored.

public class Main{
    public static void main(String[] args) {
            Counter c = new Counter();
            tow(c);
            int count = c.get();
    }
    public static void two(Counter C) {
            c.increment();
            c.increment();
    }
}
public class Counter {
    private int state = 0;
    public void increment() { state++;}
    public int get() {return state;}
}

args is a parameter.
c is a local variable.
state is an instance variable.

When the main() method is called, a stack frame for main() is created in the stack, and the args parameter and variable c are stored. c is a variable of Counter type, and when this class is created, i.e., when an object is created, it will be stored in the heap memory. Of course, a stack frame for the Counter() method is also created in the stack, and a variable called "this" is created inside it, and the value of this stores the address of the data stored in the heap memory. After the object creation is complete, the Counter stack frame in the stack disappears.

Then, the two(c) method is called, and a stack frame for two() is created in the stack memory, and c as a parameter is stored in it. This method calls the increment() method of c, and another stack frame is created for this, and state becomes 1. Then, another increment is called, and a stack frame is created for it, and state becomes 2, and then it disappears.

The variable count creates a stack frame for calling c's get() method, so it retrieves the state value (2). Therefore, the count value in the main method's stack frame becomes 2.

## Garbage Object

public class Main {
    public static void main(String[] args) {
            Counter c = make();
    }

    public static Counter make() {
            Counter c = new Counter();//Object creation
            return new Counter(); //Creating a new object again
    }
}

    public class Counter {
        private int state = 0;
        public void increment() {state++;}
        public int get() {return state;}
}

The make() method creates two objects. Since an object has been created, the two objects are stored in the heap memory. However, the object that variable c points to is the second object created by the return. Therefore, there is no way to access the first object created. Thus, it wastes the heap memory. Depending on the language, there is a Garbage Collector that cleans up and removes these objects. This is usually referred to as GC.

This posting is just a study note which was written after watching youtube videos in Korean.

Youtube Link

Basic coding words

ivinieon — Fri, 24 Feb 2023 21:41:18 +0000

Basic coding words

1. What is an Object?
→ An entity that has states and behaviors.

Example of an Object:

//python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
person1 = Person("John", 30)

In this code, Person is a class that represents a person. An object person1 is created from the class with the name "John" and age 30.

2. What is a Class?
→ A blueprint that describes the attributes and behavior of an entity. It is not an object, but objects are created from it.

instantiate : creating an object using the "new" keyword

Example of a Class:

class Car {
    private String name;
    private double speed;
    private Size size;

    public void start() { ... }
    public void stop() { ... }
}

This class represents a car and has three attributes: name, speed, and size. It also has two methods: start() and stop(), which represent the behaviors of a car.

Next, we create three Car objects using the following code:

Car myCar = new Car("niro");
Car yourCar = new Car("sonata");
Car ourCar = new Car("spotage");

These lines of code create three Car objects named myCar, yourCar, and ourCar, respectively. We use the new keyword to instantiate these objects, and we pass in a string argument to set the name attribute of each object.

3. What is a Variable?
→ A named container that holds a value. The value can be changed.

Example of a Variable:

int age = 36;
Boolean success = true;
Car myCar = new Car("niro");
String channelName = "easyCode";

We define four variables named age, success, myCar, and channelName. The first two variables are of the primitive types int and Boolean, respectively. The third variable is of the Car class type, and we instantiate a new Car object and assign it to this variable. The fourth variable is of the String class type.

4. What is a Function?
→ A set of independent code that performs a task. It can be called by its name, and may or not may receive parameters or return values. It is resuable.

Example of a Function:

age = 37;
myCar = new Car("bmw");

We change the value of the age variable from 36 to 37. We also create a new Car object with the name "bmw" and assign it to the myCar variable, effectively replacing the previous Car object that was assigned to it.

5. What is a Method?
→ A set of code that performs a task and is dependent on a class or object. It can access the state of the object or class.

Example of a Method:

class Counter {
    private int count = 0;

    public void increment() {
        count++;
    }

    public int get() {
        return count;
    }
}

Counter c1 = new Counter(); // create an object first
c1.increment(); // call the increment method twice
c1.increment();
int result1 = c1.get(); // call the get method to get the result

Counter c2 = new Counter();
c2.increment();
int result2 = c2.get();

This class represents a counter and has one attribute count and two methods increment() and get(). The increment() method increments the count attribute by 1, and the get() method returns the current value of the count attribute.

We then create two Counter objects named c1 and c2, respectively. The c1 calls the increment() method twice and then calls the get() method and the c2 calls the increment() method once and then calls the get() method. The values of result1 should be 2, and result2 should be 1, respectively.

This posting is just a study note which was written after watching youtube videos in Korean.

Youtube video what I watched