Operating System - Learn Process with C/C++, Python

-

 Learn Process with c/c++, python

What is Process ?

A process is a execution unit of application(an application is static entity which is stored in storage devices) that is loaded on memory and is being executed. This means that a process is something that is actually doing something on our computer and is a basic unit of execution in an operating system. Process address space is not directly mapped to the physical memory, but they utilize the concept of virtual memory. This is done by the help of MMU(hardware component that translates virtual memory to physical memory). 

Benefits of using virtual memory 

  • Large programs can be written, as available virtual address space size can be larger than actual physical memory size 
  • Less I/O required and this leads to faster and easier way of swapping processes

Anatomy of a Process 

Let's look at the basic structure of a process 
Process structure

Process address space (virtual memory) 

  • Address space of a process consists of all linear addresses that the process is allowed to used. 
  • The address used by one process must have no relation to the address used by another(except for the shared memory during inter-process communication) 
  • Physical memory addresses that are mapped to the virtual memory are not continuous. 
  • Code, Initialized data : stores the data of written code  
  • Stack : keep track of where the process currently is in the function call chain, as well as to allocate local variables and pass parameters and return values to and from routines 
  • Heap : used for dynamically allocating user-managed memory. 
    • ex ) malloc() in C or new in C++ 

Process control block (PCB) 

  • Operating system holds most of active processes in data structures called PCB. 
  • PCB is created when a process is being created and removed when process terminates. 
  • Each process has a single PCB 
  • Information on PCB is updated when process's state changes 

Process states 

Process state

  • New : Process being created 
  • Ready : Process is waiting to be assigned to a processor 
  • Running : Instructions are being executed 
  • Waiting : Process is waiting for some event to occur(I/O completion or reception of signal) 
  • Terminated : Process has finished execution. 

PCB structure 

  • Pointer : It is a stack pointer which is required to be saved when the process is switched from one state to another to retain the current position of the process 
  • Process state : stores the state of the process 
  • Process ID : PID of current process and parent process
  • CPU registers : accumulator, base, registers and general purpose registers  
  • Program counter : holds the address of the next instruction to be executed for that process 
  • CPU scheduling : priority information and pointers to scheduling queues 
  • Memory management information : page tables or segment tables 
  • Accounting information : user and kernel CPU time consumed, account numbers, limits, etc 
  • I/O status information : devices allocated, open file tables, etc

Multitasking and Multiprocessing 

  • Multitasking : switching between multiple processes frequently so that the user can interact with each program while it is running. 
  • Multiprocessing : a system that has 2 or more processors. Because there are more than 2 processors, processes can run in parallel. 

Multiprocessing in C/C++

  • We can use the fork() command (from <unistd.h>) to duplicate the parent process and create a child process. The child process and parent process run in separate memory space. 

Multiprocessing in python 

  • Multiprocessing in python is to spawning up multiple python processes with an API.  
  • There are 2 methods to enable multiprocessing in python 
    • using multiprocessing module 
    • using concurrent.futures module 

Multiprocessing module 

  • Let's see first, how long it will take to accomplish certain tasks
  • We can see that the result it takes approximate 0 + 1 + 2 = 3 seconds without multiprocessing. 
  • Now let's execute this with multiprocessing. 
  • Now the program returned in approximately 2 seconds which is the longest execution of time.sleep(2). By using multiprocessing, we can expect improved performance on either  I/O bound or CPU bound operations. 

Multiprocessing with concurrent.futures module 

  • This module is convenient in that it can also be used to execute multi-threads. 
  • This code illustrates basic usage of concurrent.futures in multiprocessing 
  • Let's look at CPU_bound execution whose performance can be increased with multiprocessing.
  • Without multiprocessing 
  • With multiprocessing


REFERENCE 

Comments

Post a Comment

Popular posts from this blog

TCP with Python

-
Image
TCP with socket programming in python  TCP (Transmission Control Protocol)  Connection-oriented : Client and Server connection must be established before transferring data  Three way handshake, re-transmission, error-detection increases the reliability but lengthens latency TCP abstracts the application's communication from the underlying networking details  Used by : WWW, email, FTP, secure shell, peer to peer file sharing, streaming media  Optimized for reliability, and this may require long delivery time  Functions provided by TCP  Three way handshake  Requesting re-transmission of lost data  Rearrange out of order data Helps minimize network congestion to reduce the occurrence of other problems
Read more

Operating System - Learn Thread with C/C++, Python

-
Image
Learn Thread with C/C++, Python  What is Thread ?  Thread is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically a part of the operating system. Multiple threads can reside in a process, executing concurrently and sharing resources such as memory. While processes do not share resources, thread share resources in a process, and this leads to smaller overhead between context switching compared to processes.  Program VS Process VS Thread Comparing process with thread  Process   Heavyweight unit of kernel scheduling due to their resources  Resources include memory, file handles, sockets, device handles, windows and PCB Creating or destroying a process is relatively expensive as resources must be acquired or released.  Thread  Kernel Thread 
Read more

UDP with Python

-
  UDP with socket programming in python UDP(User Datagram Protocol) Applications send messages(datagrams) to other hosts on an IP network.   Prior communications are not required to set up communication channels  Is a simple connection-less communication model(no handshakes) with a minimum of protocol mechanism.  There is no guarantee of delivery, ordering, or duplicate protection. Suitable for purposes where error checking and connections are not necessary.   TCP vs UDP  TCP  Reliable : TCP manages message acknowledgment, re-transmission and timeouts. If data gets lost along the way, data will be re-sent.  Ordered : even if data segments arrive in wrong order, TCP buffers the out of order data until all data can be properly reordered and delivered to the application  Heavy Weight :
Read more