Process Scheduling

• Multitasking operating systems come in two flavors: cooperative multitasking and preemptive multitasking
• preemptive multitasking
• The act of involuntarily suspending a running process is called preemption.
• Linux, like all Unix variants and most modern operating systems, provides preemptive multitasking.
• The time a process runs before it is preempted is predetermined, and it is called the timeslice of the process.

• cooperative multitasking
• The process does not stop running until it voluntary decides to do so.
• The act of a process voluntarily suspending itself is called yielding.

• I/O-Bound Versus Processor-Bound Processes
• runqueues
• 
  

Process Management

Process:

• Process states are

1. TASK_RUNNING 
2. TASK_INTERRUPTIBLE
3. TASK_UNINTERRUPTIBLE 
4. TASK_ZOMBIE
5. TASK_STOPPED

http://www.makelinux.net/books/lkd2/?u=ch09lev1sec1

• Normal program execution occurs in user-space. When a program executes a system call (see Chapter 5, "System Calls") or triggers an exception, it enters kernel-space. At this point, the kernel is said to be "executing on behalf of the process" and is in process context.

• The system call for fork() is clone().
• The kernel stores the list of processes in a circular doubly linked list called the task list.
• The process descriptor contains the data that describes the executing program—open files, the process’s address space, pending signals, the process’s state, and much more
• In linux, a thread is merely a process that shares certain resources with other processes.

Kernel Threads:

• The significant difference between kernel threads and normal processes is that kernel threads do not have an address space.
• They operate only in kernel-space and do not context switch into user-space.
• Kernel threads, however, are schedulable and preemptable, the same as normal processes.
• You can see the kernel threads on your Linux system by running the command ps -ef

Process family tree:

• All processes are descendents of the init process, whose PID is one. The kernel starts init in the last step of the boot process. The init process, in turn, reads the system initscripts and executes more programs, eventually completing the boot process.
• Every process on the system has exactly one parent. Likewise, every process has zero or more children. Processes that are all direct children of the same parent are called siblings. The relationship between processes is stored in the process descriptor. Each task_struct has a pointer to the parent's task_struct, named parent, and a list of children, named children.
• The init task's process descriptor is statically allocated as init_task. 

Process creation:

• The first, fork(), creates a child process that is a copy of the current task. It differs from the parent only in its PID (which is unique), its PPID (parent’s PID, which is set to the original process), and certain resources and statistics, such as pending signals, which are not inherited.

• copy-on-write
• The page tables of the process address space is not copied until a write operation.
• This is because in most of the cases, the fork() is followed by an exec() which will create a new address space after fork().
• By copy-on -write technique, the only thing which happens during fork() is to create a new process descriptor for the child process.

• fork - steps in forking
1. creates a new kernel stack, thread_info structure, and task_struct for the new process. The new values are identical to those of the current task. At this point, the child and parent process descriptors are identical.
2. It then checks that the new child will not exceed the resource limits on the number of processes for the current user.
3. Now the child needs to differentiate itself from its parent. Various members of the process descriptor are cleared or set to initial values
4. Next, the child's state is set to TASK_UNINTERRUPTIBLE, to ensure that it does not yet run.
5. Next, it calls get_pid() to assign an available PID to the new task.
6. Next, open files, filesystem information, signal handlers, process address space, and namespace are either shared or duplicated.
7. Next, the remaining timeslice between the parent and its child is split between the two.
8. Finally, the PID of the new child is returned to the caller.

Process Termination:

• Generally it occurs when the process calls the exit() system call, either explicitly when it is ready to terminate or implicitly on return from the main subroutine of any program. (That is, the C compiler places a call to exit() after main() returns.)
• A process can also terminate involuntarily.This occurs when the process receives a signal or exception it cannot handle or ignore.
• If the parent process exits before child, reparent a task's children on exit to either another process in the current thread group or, if that fails, the init process.

Data Structures

Time and Space complexities

http://stackoverflow.com/questions/18686121/differences-between-time-complexity-and-space-complexity

Sorting Methods

http://www.cprogramming.com/tutorial/computersciencetheory/sortcomp.html

https://www.hackerearth.com/notes/sorting-code-monk/

http://www.tutorialspoint.com/data_structures_algorithms/quick_sort_algorithm.htm

1. Bubble sort
2. Modified Bubble sort
3. Selection sort
4. Insertion sort
5. Heap sort
6. Merge sort - Program
7. Quick sort

Linked Lists

http://www.tutorialspoint.com/data_structures_algorithms/quick_sort_algorithm.htm

Stack

http://www.tutorialspoint.com/data_structures_algorithms/quick_sort_algorithm.htm

Graph

http://www.tutorialspoint.com/data_structures_algorithms/quick_sort_algorithm.htm

Tree

http://www.tutorialspoint.com/data_structures_algorithms/quick_sort_algorithm.htm

AVL Tree

http://www.geeksforgeeks.org/avl-tree-set-1-insertion/

Important linux commands

1. ulimit command is used to set and view the system resource(eg: stack size) for any process.
2. You can examine binary images using the nm and objdump commands to display symbols, their addresses, segments, and so on.
3. To check the info about the ports that are being used in a system, use netstat command

• http://www.cyberciti.biz/faq/what-process-has-open-linux-port/

Process Address Space

1. Process Address Space and how each section of address space is growing: http://duartes.org/gustavo/blog/post/anatomy-of-a-program-in-memory/
2. In Linux, if you request a large block of memory via malloc(), the C library will create an anonymous mapping instead of using heap memory. ‘Large’ means larger than MMAP_THRESHOLD bytes, 128 kB by default and adjustable via mallopt().
3. ulimit command is used to set and view the system resource(eg: stack size) for any process.
4. You can examine binary images using the nm and objdump commands to display symbols, their addresses, segments, and so on.

Things TODO for learning

1. Check how to compile with shared lib and basics of Makefile writing
2. How mmap works and why it is needed?
3. Learn where graphs are used
4. compiler optimization
5. why memory mapping
6. what is namespce
7. what is spinlocks.
8. How to create a deamon. Difference b/w a process and a deamon.
9. Mutex
10. Process stack and thread stack - what is shared and what is not
11. Where is ISR - on kernel stack?
12. How scheduler is running? is it a kernel process
13. C++
14. socket program, client -server
15. where is shared memory residing
16. compiler design
17. x86 addressing modes and basic operations. For example, how a value is assigned to a memory location.
18. User space mechanisms corresponding to the kernel space.
19. x86 resisters
20. check the register variable use
21. how to access the processor register in c program.
22. How to do timer, counters and handle signals.
23. basics of shell scripting.
24. Check supl, control plane specs
25. why volatile keyword
26. EXTERN C
27. where pointer type info is stored 
28.  Check assembly for function, static variable, register variable and all
29. Check the c++ symbols
30. x86 addressing mode
31. How an array is passed to a function
32. Serial communication
33. Inline functions
34.  Macro function
35. Order of precedence in C
36. Order of precedence in C++
37. Advantage of oops over structured programming.
38. How message queues will be notified when something is available in the queue.
39. signal, gdb, gdbserver, coredump, gdb with coredump, macro functions, return value of arithmetic operations involving two different datatypes.