Can you please name where to start my cs degree from this channel till end. I don't know where to start and finish can you please provide just chapter or topics names begining to end
@@rounak9099 usually the first course people recommend to start with is cs 50's course which acts as an introduction to computer science , you could start with that
@@rounak9099 I would recommend starting from maths, digital circuits (FPGA also), cpu architecture, assembly, C/C++, embedded programming, operating system(how it works and how to use an os), oop, data structure and algorithms, internet basics, web development (code a server and a site), sql, app development, AI/Machine learning, Computer vision, deep learning. If you learn all of this, you should theoretically be good enough for any entry job in cs, but in reality, you still probably need something to prove you know these, either a good degree or a really good portfolio.
@@rounak9099 chill out! first thing is first, why get a CS degree ( its a brilliant way of getting into tech dont get me wrong) but if you are not getting a conventional degree from a Uni there is simply no point of learning the entirity of degree unless you are genuinly interested in ALL subjects (which is rare), so choose what you want to do, get the fundamentals in order and you will be better off than CS grads. Good luck :)
7:03:18 Critical section must have bounded waiting for interested processes. 7:05:23 Differentiating synchronization mechanisms as solutions or not 7:09:41 Introduction to lock variable as a synchronization mechanism 7:11:56 Implementing locking mechanism for mutual exclusion 7:16:17 Understanding the critical section and entry process. 7:18:41 Explanation of lock variable implementation 7:23:14 Preemption and lock value changes in a multi-process scenario 7:25:27 Importance of Lock in Ensuring Mutual Exclusion 7:29:39 Lock variable leads to wastage of CPU time. 7:31:52 Importance of critical section and preventing wastage of CPU cycles 7:36:22 Strictly alternate process execution for critical section access 7:38:28 Understanding mutual exclusion and the turn variable 7:42:40 Uninterested processes hinder the progress of interested processes 7:44:41 Explanation of mutual exclusion and bounded waiting in synchronization mechanisms 7:48:53 Concept of flag and turn for process synchronization 7:51:03 Understanding the concept of turn and flag in the context of processes. 7:55:26 Peterson solution is about the critical section and updating turn value. 7:57:38 Discussing process scheduling and completion of sections 8:01:49 Peterson solution ensures non-interested processes do not hinder progress 8:03:57 Peterson solution ensures mutual exclusion 8:08:08 Ensuring mutual exclusion and progress in operating systems. 8:10:16 Understanding the impacts of initialization on process turns 8:14:35 Decker's algorithm in operating systems 8:16:45 Algorithm provides mutual exclusion and progress 8:21:01 Explanation of Deadlock in Operating Systems 8:23:11 Discussion on bounded waiting and strict alternation 8:27:15 Discussing Test and Set Lock functionality 8:29:27 Explanation of TSL operation and its impact on critical section execution. 8:33:24 Swap mechanism based on lock and key ensures atomic execution 8:35:20 Understanding the process of swapping using a temporary variable. 8:39:16 Swap mechanism guarantees Mutual exclusion and progress 8:41:17 Test and set provides mutual exclusion 8:45:22 Priority inheritance solves deadlock in critical sections 8:47:30 Fetch and add X, I is an atomic read modify write instruction. 8:51:39 Understanding synchronization mechanisms and problem-solving 8:53:35 Understanding how L=0 and L!=1 affect log value increments. 8:57:25 Demonstration of Mutual exclusion and prevention of overflow 8:59:14 Preemption strategy in entry section 9:03:06 Understanding overflow in processes 9:05:15 FCFS doesn't suffer from starvation except for infinite loops 9:09:32 Sleep and wake up is a blocking mechanism in multiprocess solutions 9:11:33 Solving the producer-consumer problem using non-busy waiting solution 9:15:38 Implementing consumer functionality in operating systems 9:17:37 Understanding preemptive process scheduling 9:21:38 Semaphore - Definition and Types 9:23:51 Explanation of the down operation in kernel mode 9:28:16 Positive value of SEMA 4 indicates successful down operations, negative value indicates blocked processes 9:30:09 Understanding how sema4 provides Mutual exclusion 9:34:03 The objective of up operation is to wake up a sleeping process 9:36:01 Understanding the conditions for waking up processes 9:40:04 Using SEMA 4 helps manage concurrent requests effectively. 9:42:10 Managing Processes with Counting Semaphores 9:46:05 Understanding down operation in binary semaphores 9:48:05 Understanding the process blocking and synchronization 9:51:58 Understanding value changes in critical sections 9:53:57 Explanation of binary semaphore operations 9:58:13 Semaphore 4 and its operations 10:00:07 Ensuring mutual exclusion and progress in critical section 10:04:17 Preemption in semaphores can lead to deadlock. 10:06:27 Preempting processes to prevent deadlock 10:10:53 Process synchronization using down and up operations 10:13:07 Implication of strict alternation for mutual exclusion 10:17:22 Demonstrating mutual exclusion and deadlock in operating systems. 10:19:24 Understanding a scenario leading to deadlock and semaphore initialization 10:23:44 Explaining the limitations of processes without a while loop. 10:26:03 Determining minimum and maximum value of variable C in a concurrent process scenario 10:30:29 Understanding deadlock in operating systems 10:32:29 Discussing synchronization and mutual exclusion in operating systems. 10:36:25 Concurrency issues in race condition 10:38:41 Processes changing values and storing them 10:42:56 Understanding implementation using semaphores 10:44:56 Operating System synchronization in producer-consumer scenario 10:49:16 Understanding the deadlock and order importance in synchronization problems. 10:51:21 Understanding synchronization problem in operating systems 10:55:26 Producer adds item to buffer but consumer can't consume 10:57:32 Consumer removing one item at a time from buffer 11:01:20 Reader Writer problem and its solution using semaphores 11:03:29 Starvation of writers in database access 11:07:47 Database locking mechanism for readers and writers 11:09:55 Understanding the use of mutex and database for accessing the critical section. 11:14:10 Solving reader-writer problem using Mutex 11:16:05 Semaphore used to solve reader-writer problem 11:19:55 Implementation of Dining Philosopher problem 11:21:59 Philosophers sharing forks for eating efficiency 11:26:06 Preventing deadlocks by changing philosopher pattern 11:28:07 Preventing deadlock by changing paths 11:32:26 Statements can be executed concurrently if they are independent. 11:34:49 Understanding concurrency and parallelism 11:39:01 Concurrency and parallelism in operating systems 11:41:05 Understanding concurrent execution in Operating Systems 11:45:28 Understanding read set and write set for concurrent statements 11:47:38 Understanding the difference between sequential and concurrent execution using pair begin and pair end 11:51:57 Dependent nodes cannot always be considered concurrent. 11:54:10 Exploration of handling dependencies and contradictions in program execution 11:58:17 Acquiring keys in executing statements
Power Cert Animated Videos has a great 4 hour introductory video for Networking here on RUclips. It's very broad without going into real-world applications, but is a very good general overview. It's animated, very easy to follow, and should get you comfortable with the terminology. Then I would recommend renting or getting the book Networking: A Top Down Approach by Jim Kurose. The Author has a RUclips channel and chapter modules uploaded to his channel to go along with the reading. This is what I'm doing. There are other boot camp style courses here on RUclips, but the instructors just seem to throw a ton of terminology at you without offering any substance or helping to build an intuition for the processes.
12:00:23 Understanding the dependency between locks in executing sequence of commands. 12:04:41 Understanding key requirements for locks in the given scenario. 12:06:52 Understand the importance of valid sequences in executing concurrent tasks 12:11:11 Updating values of x and y in a sequence 12:13:30 Understanding binary semaphore and sequentiality in execution. 12:17:51 Understanding the concepts of Fork and Join in operating systems. 12:20:00 Explaining how to branch instructions in Fork 12:23:48 Understanding control flow in Operating Systems. 12:25:53 The process synchronization section is over. 12:29:45 Value of counter depends on thread execution 12:31:40 Deadlock is when two or more processes are waiting for an event that is never going to happen. 12:35:51 Deadlock explained with a meme 12:38:00 Deadlock occurs when a process is blocked forever due to resource unavailability. 12:42:14 Four necessary conditions for deadlock 12:44:24 Circular wait is not a sufficient condition for deadlock 12:48:49 Understanding resource allocation and blocking in Operating Systems 12:50:53 Preventing Deadlocks by Resource Release 12:55:03 Deadlock prevention strategies are crucial for critical operating systems. 12:57:11 Deadlock prevention negates necessary conditions 13:01:32 Efficient resource utilization through protocol 2 13:03:52 Forceful preemption and self preemption prevent deadlock 13:08:11 Resource preemption is crucial for avoiding circularity and maintaining linearity. 13:10:07 Understanding the necessity of cycles in resource allocation 13:14:27 Resource allocation graph aims to maintain a safe state 13:16:40 Understanding safe and unsafe states in resource allocation 13:20:51 Understanding Safety Algorithm and Resource Request Algorithm Basics 13:23:36 Understanding resource allocation in operating systems 13:28:25 Resource allocation and satisfaction process summarized. 13:30:35 Understanding the Banker algorithm for multiple resources with multiple instances. 13:34:55 Proving the existence of multiple CF sequences 13:37:07 Multiple safe sequences can exist with Banker's algorithm 13:41:32 Updating resource allocation and running the safety algorithm 13:43:54 Resource allocation and availability 13:48:10 Applying safety algorithm to check system state based on resource values 13:50:28 Satisfied the need for resources 13:54:59 Deadlock in single instance and multi-instance resource allocation 13:57:13 Achieving safe state by satisfying process requests 14:01:40 Resource preemption and process recovery 14:03:49 Deadlock avoidance strategies 14:08:12 Maximum resources for deadlock is 36, minimum for deadlock freedom is 37 14:10:22 Understanding unsafe state vs deadlock in resource allocation graphs 14:15:02 Ensure system can satisfy minimum resource requests to avoid deadlock 14:17:05 Resource allocation using Bankers algorithm 14:21:23 Understanding the hierarchy of memory sizes and functions of RAM in operating systems 14:23:44 Memory size calculation based on number of words and word size 14:27:57 Understanding data representation using bits and bytes 14:30:11 Explaining memory size in bits and bytes 14:34:40 Addressing Memory Blocks in Operating Systems 14:36:45 Understanding memory size and word addressing 14:40:51 Understanding the purpose and operation of the bus, chip select, and address bus in a computer system 14:42:57 Static and dynamic loading in operating systems 14:47:13 Resolving External References 14:49:25 Linker module fills up blank addresses in program code. 14:53:53 Dynamic linking allows for flexibility and code reusability 14:56:10 Difference between static and dynamic linking 15:00:45 Understanding different types of binding in Operating Systems. 15:03:02 Static and dynamic binding in operating systems 15:07:23 Address binding provides relocation flexibility at runtime. 15:09:33 Static binding vs. dynamic binding 15:13:44 Memory management fundamentals from older theories 15:15:54 Memory manager goals to minimize wastage and utilize memory effectively 15:20:20 Understanding memory overlay and its application 15:22:41 Explaining partitioning in Operating Systems. 15:26:54 Base plus limit architecture to ensure protection 15:29:05 Overview of old and new techniques in Operating Systems 15:33:22 Fixed partition leads to internal fragmentation and limited multiprogramming. 15:35:25 Dynamic partitioning allows for flexible memory allocation 15:39:35 External Fragmentation and Solutions 15:41:39 Resolve external fragmentation by reallocating memory and creating a bigger free hole 15:45:35 Variable partitioning and best fit allocation in memory systems 15:47:35 Memory allocation strategies 15:51:55 Operating Systems manages process table and memory partitions 15:54:09 Process table size calculation for 500 processes. 15:58:31 Scheduling and memory management using FCFS 16:00:32 Explaining memory allocation based on program size 16:04:24 Understanding non-continuous allocation 16:06:27 Introduction to Variable Partitioning for memory management 16:10:41 Differences between logical address and physical address 16:12:53 Memory management involves converting logical addresses to physical addresses. 16:17:11 Memory management unit handles address translation 16:19:26 Pages and Page Size Calculation 16:24:18 Understanding page offset and page number in memory addressing 16:26:37 Logical address format explained with page number and page offset 16:31:02 Understanding the concept of frames and pages in memory management. 16:33:13 Understanding logical address space and physical address space division 16:37:42 Finding physical address space using page size and frame size. 16:39:53 Understanding address translation in Operating Systems 16:44:06 Page table contains the frame number where pages are stored. 16:46:21 Understanding Page Table in Operating Systems 16:50:37 Paging technique for accessing physical memory 16:52:51 Understanding virtual memory and page table size 16:57:30 Calculating page offset and physical address space size in a computer system using paging technique 16:59:47 Determining page size and number of pages in simple paging technique. 17:04:07 Page table size calculation and performance impacts 17:06:20 Main memory access time (M) is crucial for CPU operations 17:10:46 Cache memory access time is less than main memory access time 17:12:40 Introduction to cache memory and effective access time 17:16:55 Defined hit and miss ratio for effective memory access time 17:19:12 Understanding TLB and PSC in CPU processing 17:23:30 Optimizing memory access using TLB and physical address 17:25:37 Page table size can be reduced by increasing page size 17:30:07 Finding the optimal page size for minimal internal fragmentation and page table size. 17:32:17 Optimal page size affects page table size and internal fragmentation 17:37:10 Memory division into units and load time calculation 17:39:33 Calculating CPU Time Fraction for Loading Page Table 17:43:41 Dividing program into pages and calculating required pages for text, data, and stack sections 17:45:50 Calculating number of pages based on address space and page size 17:50:07 Introduction to Hashed Page Table 17:52:19 Collision resolution technique using chaining 17:56:31 VUM architecture involves tradeoff between space and time
did you make the notes from this video? if yes then can you please share it with me it will be helpful for me whilemaking notes the notes visible on the screen is very less and I'll have to rewind it again and again making the notes making process time consuming.
Who knows what the goal is for freeCodeCamp with anything they put out. Maybe this guy is poor and needs more money from all the information he stole. Maybe they are just stupid. But hey free information. Maybe all 9.77 million subscribers will make their own operating system. Their own crap operating system that can't compete with the other ones.
@@barry4207 true. but linux is open source. also all this information channels like these put out just kills everyone's future because they just tell all this information to millions of people. everyone on the planet can't sit at a computer for a job. especially for the next 100-1000 years.
17:58:35 Introduction to Simple Paging and Performance Analysis 18:03:04 Page table divided into chunks for reducing size 18:05:07 Handling memory paging and chunk storage in page table 18:09:19 Reduction in space overhead by using multi-level paging 18:11:41 Introduction to Paging in Operating Systems 18:15:56 Page table divided into chunks stored in main memory frames 18:18:08 Reducing space overhead through paging 18:22:23 Dividing logical address space into chunks and pages 18:24:29 Explanation of two-level paging system 18:28:35 Understanding multi-level paging in operating systems 18:30:36 Paging is about optimizing space while sacrificing time. 18:34:26 Introduction to paging in Operating Systems. 18:36:37 Understanding page storage and frame representation in inner and outer page tables. 18:40:42 Explanation of how addressing is done 18:42:49 Paging incurs memory overhead due to page tables 18:46:58 Understanding the virtual address format in page tables. 18:49:06 Dividing the address space into chunks to determine page and table size 18:53:00 Calculating number of entries in inner and outer page tables. 18:55:15 Determining the number of levels for virtual to physical address translation 18:59:19 Understanding multi-level paging for operating systems. 19:01:31 Users view of memory location is not preserved 19:05:42 Understanding page table and logical address generation 19:07:52 Addressing and converting logical to physical 19:11:56 Understanding Segmentation in Operating Systems 19:13:55 Segmentation converting logical address to physical address 19:18:15 External fragmentation in segmentation and its solutions 19:20:21 Virtual memory illusion of having more memory available than physical memory 19:24:36 Understanding Page Hit and Page Miss in Memory Management 19:26:32 Process gets blocked due to page not present in memory 19:30:21 Demand paging is used in all operating systems like Windows, Mac, and Unix. 19:32:25 Understanding the memory hierarchy and virtual memory management 19:36:53 Effective access time calculation 19:38:59 Handling page faults in memory management. 19:43:15 Understanding effective instruction time calculation 19:45:34 Replacing victim frames with modified pages and handling different cases. 19:49:55 Understanding paging system and memory access in operating systems 19:52:11 Explanation of effective memory access time and handling TLB miss and page fault 19:56:34 Understanding frame allocation policies and calculation of demand frames 19:58:52 Policies ensure fair allocation based on demand and availability 20:03:18 Understanding page faults and memory allocation in Operating Systems 20:05:37 Calculation of page faults and fault rate 20:10:02 Increasing frames may increase page faults 20:12:14 Page faults due to Pure Demand Paging 20:16:34 Using pure demand paging to manage page faults. 20:18:45 Increasing frames reduces page faults, optimal replacement necessary. 20:23:01 Page replacement algorithms in operating systems 20:25:14 Replacement process in an operating system 20:29:17 Understanding page table entry attributes and epoch in operating systems. 20:31:38 LRU approximation using reference bit 20:35:48 Understanding how the second chance or clock algorithm selects victims based on time of loading and reference bit. 20:37:54 Implementing victimization and reference bit in page replacement algorithms 20:41:57 Exploring page table structure and selection of victim pages based on different algorithms 20:44:01 Increasing page frames may increase or decrease page faults 20:48:20 Threshing is a consequence of excessive paging activity. 20:50:23 High page fault rate leads to process blocking 20:54:25 Threshing is a result of high disk utilization and degree of multiprogramming 20:56:53 Understanding row major order in storing matrices 21:01:20 Explanation of page faults and memory storage 21:03:35 Swapping variables affects page faults 21:07:49 Writing program, data structures, algorithms affect thrashing rate 21:09:55 Understanding Working Set Window 21:14:16 Choosing the right Delta value is crucial for effective memory utilization. 21:16:22 Calculating working set window for page faults 21:21:07 Understanding the physical structure of a disk in an operating system. 21:23:17 Disk storage consists of rotating platters and read/write heads 21:27:33 Understanding seek time and track time in disk IO 21:29:42 Explaining seek time and rotational latency in disk operations 21:34:01 Understanding the disk specifications and calculating uniform capacity 21:36:20 Calculating transfer time and data transfer rate in disk I/O 21:40:44 Utilizing maximum density for varying track lengths 21:42:53 Calculating transfer time for loading a program from disk to memory 21:47:29 Analyzing page load times based on distribution and continuity 21:49:33 Disk rotation is minimized for continuous data layout on disk. 21:53:51 Importance of formatting disk for effective storage and retrieval 21:55:51 Understanding Primary and Extended/Logical Drives in Operating Systems 22:00:00 Understanding booting and partition structures 22:02:12 Understanding partitioning and boot control 22:06:38 Understanding directory structure and metadata in operating systems 22:08:45 Understanding multi-level directories in operating systems 22:12:51 File system implementation in a layered fashion 22:15:07 The I/O control level and basic file system operations in an operating system. 22:19:26 Methods of disk space allocation 22:21:41 Increasing file size is inflexible due to external fragmentation 22:25:56 Understanding indexed allocation in file systems 22:28:14 File management in Unix/Linux using i-nodes 22:32:57 Master file table stores block address information for file storage 22:35:03 Understanding the hierarchy of direct, single indirect, double indirect, and triple indirect disk block addresses. 22:39:43 Using larger block size improves disk throughput but increases internal fragmentation 22:41:56 Understanding file allocation table and its impact on maximum file size 22:46:35 Understanding file allocation and maximum file size calculation 22:48:45 Calculating maximum file size and number of blocks 22:53:18 Understanding the concept of free list and bit map in operating systems. 22:55:30 Allocating blocks for storage 22:59:53 The size of the free list is determined by the address size and the number of free blocks. 23:02:17 Understanding file allocation with bit maps and hex codes 23:06:39 Smallest cache required for average read latency < 6ms 23:08:51 Page storage space related to maximum processes, virtual address space, and RAM 23:13:14 Choosing the closest track for least seek time 23:15:30 Discussing disk scheduling algorithms 23:19:50 C-LOOK algorithm serves requests in one direction only 23:22:02 Algorithm focuses on efficient disk request servicing without needing extreme movements. 23:26:21 Power dissipation negligible due to rotational latency and head switching 23:28:19 Efficient track switching and power dissipation in operating system course 23:32:42 Calculating total power dissipation for seek time 23:34:51 Understanding disk access scheduling algorithms 23:39:23 Calculating decision time for pending requests using FCFS algorithm 23:41:24 Disk scheduling algorithms discussed for Operating Systems course 23:45:50 Sharing code and resources via threads to avoid redundancy 23:48:01 Threads share resources but have separate registers and stacks 23:52:18 Multi-threading brings responsiveness and resource sharing. 23:54:28 Multi-threading is more economical and efficient than multiprocessing. 23:58:50 Threads vs Process 24:01:12 Global variables for inter-thread communication 24:05:29 Benefits and drawbacks of user level threads independence on operating system 24:07:38 Kernel level threads provide true parallelism 24:11:49 Methods to Pass Parameters from User to Kernel 24:13:48 Understanding system calls related to process, file, and directory management. 24:18:05 Understanding the execution flow after fork statement 24:20:14 Understanding the execution order in fork process 24:24:34 Explaining the creation of child processes based on return value 24:26:46 Working with if block in an Operating System course 24:31:21 Discussing the execution of a for loop and creation of child processes based on conditions. 24:33:41 Understanding fork process in operating systems 24:38:06 Relation between virtual and physical addresses in child and parent processes 24:40:17 Virtual address space and paging concept 24:44:31 Comparing traditional vs. inverted page table sizes 24:46:40 Designing a global page table for memory management 24:50:38 Comparison between traditional and inverted page table sizes Crafted by Merlin AI.
18:10:19 Reduction in space overhead by using multi-level paging 18:11:41 Introduction to Paging in Operating Systems 18:15:56 Page table divided into chunks stored in main memory frames 18:18:08 Reducing space overhead through paging 18:22:23 Dividing logical address space into chunks and pages 18:24:29 Explanation of two-level paging system 18:28:35 Understanding multi-level paging in operating systems 18:30:36 Paging is about optimizing space while sacrificing time. 18:34:26 Introduction to paging in Operating Systems. 18:36:37 Understanding page storage and frame representation in inner and outer page tables. 18:40:42 Explanation of how addressing is done 18:42:49 Paging incurs memory overhead due to page tables 18:46:58 Understanding the virtual address format in page tables. 18:49:06 Dividing the address space into chunks to determine page and table size 18:53:00 Calculating number of entries in inner and outer page tables. 18:55:15 Determining the number of levels for virtual to physical address translation 18:59:19 Understanding multi-level paging for operating systems. 19:01:31 Users view of memory location is not preserved 19:05:42 Understanding page table and logical address generation 19:07:52 Addressing and converting logical to physical 19:11:56 Understanding Segmentation in Operating Systems 19:13:55 Segmentation converting logical address to physical address 19:18:15 External fragmentation in segmentation and its solutions 19:20:21 Virtual memory illusion of having more memory available than physical memory 19:24:36 Understanding Page Hit and Page Miss in Memory Management 19:26:32 Process gets blocked due to page not present in memory 19:30:21 Demand paging is used in all operating systems like Windows, Mac, and Unix. 19:32:25 Understanding the memory hierarchy and virtual memory management 19:36:53 Effective access time calculation 19:38:59 Handling page faults in memory management. 19:43:15 Understanding effective instruction time calculation 19:45:34 Replacing victim frames with modified pages and handling different cases. 19:49:55 Understanding paging system and memory access in operating systems 19:52:11 Explanation of effective memory access time and handling TLB miss and page fault 19:56:34 Understanding frame allocation policies and calculation of demand frames 19:58:52 Policies ensure fair allocation based on demand and availability 20:03:18 Understanding page faults and memory allocation in Operating Systems 20:05:37 Calculation of page faults and fault rate 20:10:02 Increasing frames may increase page faults 20:12:14 Page faults due to Pure Demand Paging 20:16:34 Using pure demand paging to manage page faults. 20:18:45 Increasing frames reduces page faults, optimal replacement necessary. 20:23:01 Page replacement algorithms in operating systems 20:25:14 Replacement process in an operating system 20:29:17 Understanding page table entry attributes and epoch in operating systems. 20:31:38 LRU approximation using reference bit 20:35:48 Understanding how the second chance or clock algorithm selects victims based on time of loading and reference bit. 20:37:54 Implementing victimization and reference bit in page replacement algorithms 20:41:57 Exploring page table structure and selection of victim pages based on different algorithms 20:44:01 Increasing page frames may increase or decrease page faults 20:48:20 Threshing is a consequence of excessive paging activity. 20:50:23 High page fault rate leads to process blocking 20:54:25 Threshing is a result of high disk utilization and degree of multiprogramming 20:56:53 Understanding row major order in storing matrices 21:01:20 Explanation of page faults and memory storage 21:03:35 Swapping variables affects page faults 21:07:49 Writing program, data structures, algorithms affect thrashing rate 21:09:55 Understanding Working Set Window 21:14:16 Choosing the right Delta value is crucial for effective memory utilization. 21:16:22 Calculating working set window for page faults 21:21:07 Understanding the physical structure of a disk in an operating system. 21:23:17 Disk storage consists of rotating platters and read/write heads 21:27:33 Understanding seek time and track time in disk IO 21:29:42 Explaining seek time and rotational latency in disk operations 21:34:01 Understanding the disk specifications and calculating uniform capacity 21:36:20 Calculating transfer time and data transfer rate in disk I/O 21:40:44 Utilizing maximum density for varying track lengths 21:42:53 Calculating transfer time for loading a program from disk to memory 21:47:29 Analyzing page load times based on distribution and continuity 21:49:33 Disk rotation is minimized for continuous data layout on disk. 21:53:51 Importance of formatting disk for effective storage and retrieval 21:55:51 Understanding Primary and Extended/Logical Drives in Operating Systems 22:00:00 Understanding booting and partition structures 22:02:12 Understanding partitioning and boot control 22:06:38 Understanding directory structure and metadata in operating systems 22:08:45 Understanding multi-level directories in operating systems 22:12:51 File system implementation in a layered fashion 22:15:07 The I/O control level and basic file system operations in an operating system. 22:19:26 Methods of disk space allocation 22:21:41 Increasing file size is inflexible due to external fragmentation 22:25:56 Understanding indexed allocation in file systems 22:28:14 File management in Unix/Linux using i-nodes 22:32:57 Master file table stores block address information for file storage 22:35:03 Understanding the hierarchy of direct, single indirect, double indirect, and triple indirect disk block addresses. 22:39:43 Using larger block size improves disk throughput but increases internal fragmentation 22:41:56 Understanding file allocation table and its impact on maximum file size 22:46:35 Understanding file allocation and maximum file size calculation 22:48:45 Calculating maximum file size and number of blocks 22:53:18 Understanding the concept of free list and bit map in operating systems. 22:55:30 Allocating blocks for storage 22:59:53 The size of the free list is determined by the address size and the number of free blocks. 23:02:17 Understanding file allocation with bit maps and hex codes 23:06:39 Smallest cache required for average read latency < 6ms 23:08:51 Page storage space related to maximum processes, virtual address space, and RAM 23:13:14 Choosing the closest track for least seek time 23:15:30 Discussing disk scheduling algorithms 23:19:50 C-LOOK algorithm serves requests in one direction only 23:22:02 Algorithm focuses on efficient disk request servicing without needing extreme movements. 23:26:21 Power dissipation negligible due to rotational latency and head switching 23:28:19 Efficient track switching and power dissipation in operating system course 23:32:42 Calculating total power dissipation for seek time 23:34:51 Understanding disk access scheduling algorithms 23:39:23 Calculating decision time for pending requests using FCFS algorithm 23:41:24 Disk scheduling algorithms discussed for Operating Systems course 23:45:50 Sharing code and resources via threads to avoid redundancy 23:48:01 Threads share resources but have separate registers and stacks 23:52:18 Multi-threading brings responsiveness and resource sharing. 23:54:28 Multi-threading is more economical and efficient than multiprocessing. 23:58:50 Threads vs Process 24:01:12 Global variables for inter-thread communication 24:05:29 Benefits and drawbacks of user level threads independence on operating system 24:07:38 Kernel level threads provide true parallelism 24:11:49 Methods to Pass Parameters from User to Kernel 24:13:48 Understanding system calls related to process, file, and directory management. 24:18:05 Understanding the execution flow after fork statement 24:20:14 Understanding the execution order in fork process 24:24:34 Explaining the creation of child processes based on return value 24:26:46 Working with if block in an Operating System course 24:31:21 Discussing the execution of a for loop and creation of child processes based on conditions. 24:33:41 Understanding fork process in operating systems 24:38:06 Relation between virtual and physical addresses in child and parent processes 24:40:17 Virtual address space and paging concept 24:44:31 Comparing traditional vs. inverted page table sizes 24:46:40 Designing a global page table for memory management 24:50:38 Comparison between traditional and inverted page table sizes
I've fixed the timestamps so they work properly. Copy paste this FCC and thank you so much for your arduous work! 💓 ⌨ (00:00:00) Welcome to the Course ⌨(00:03:43) Introduction and Background ⌨(01:28:56) Process Management ⌨ (02:47:34) CPU Scheduling ⌨(06:12:23) Process Synchronization ⌨(12:32:14) Deadlock ⌨(14:20:29) Memory Management ⌨(21:20:28) File Management ⌨(23:43:16) Miscellaneous Topics
This has quickly become one of my favorite RUclips channels. What you're doing is very important and the fact you're offering these courses for free is very generous. Thank you for your huge contribution in offering an affordable education.
Absolutely!!!! You can learn so much from DC, But you have to be passionate to go watch, learn and lab their courses. No symuch thing as a free lunch. It's still up to you to put the leg work in.
@@purplemonkeydishwasher5269 just like the instructor says in the beginning, "you can't just watch this like Netflix." He's completely right. I've got the textbook he mentioned have read the first few chapters and have watched the first several hours of this video maybe 3-4 times. But I'm also reading like 3 other books on digital logic/electronics. And watching two other crash courses on operating systems. Thus is really complex stuff and you really need to put in a lot of effort to understand, and make the concepts feel more familiar.
Qualities of this course : Crisp and to the point explanation, all important topics covered, Multiple analogies, amazing practice problems, whatever this guy promised, he has delivered it.
It's too easy to comment on anything, but it needs hundreds of hours to create a massive video of 25 hours. No one can fulfill the expectations of every one because these courses are not based on individual's demand and their plus n minuses. These are for masses. I salute the person who made this video n his video's usefulness for millions.
00:02 Comprehensive operating system course covering fundamental and advanced concepts. 02:41 Operating Systems Course overview and guidelines 07:28 ALU performs arithmetic and logical functions. 09:44 Operating system loads the executable file from hard disk to main memory for CPU execution. 14:33 Operating system acts as a resource manager 16:51 Operating system controls everything in the computer. 21:07 Operating system acts as a resource manager and government in controlling program applications. 23:05 Uni programming OS allows only one program in memory, leading to CPU idle time. 27:26 Multiprocessor systems run one program at a time 29:33 Schematic view of multiprogramming operating system 33:30 Difference between uniprocessor and multiprocessor systems 35:22 Multiprogramming increases CPU utilization and efficiency 39:25 Process Management in Operating Systems 41:30 Secondary storage devices need to be DMA compatible and support address translation for efficient data transfer. 45:49 Privileged processes in operating systems 47:57 Mode shifting is necessary for user applications to access OS kernel level services. 52:05 Multiprogramming increases CPU utilization and efficiency. 53:47 Architectural requirements for operating systems 57:41 Operating System Booting and Memory 59:39 Non-preemptive processes have better response time 1:03:42 Learn about mode shifting via API and SCI 1:05:57 Understanding the difference between print F in header and library files 1:10:28 Shift mode from user to kernel to access fork services 1:12:39 SVC and Interrupts in Operating Systems 1:16:58 Understanding how mode shifting is essential in operating systems. 1:18:51 Operating system mode shifting and system calls 1:22:39 Understanding kernel mode and user mode operation 1:24:33 Explanation of child process creation using Fork 1:28:52 Difference between a program and a process 1:30:58 Compilation process converts high-level code into low-level instructions 1:35:20 Dynamic array implementation in C using Maloc 1:37:31 Process is the program in execution using computer resources. 1:41:34 Program consists of instruction and data, with data types static and dynamic. 1:43:36 Activation records in function calls 1:47:40 Learning VSS extension and process operations 1:49:40 Transition diagram states and process attributes 1:53:47 Understanding Process Control Block (PCB) and Process Lifetime Stages 1:56:02 Understanding resource deallocation and process states 2:00:15 Operating systems shift processes from main memory to hard disk to manage clutter. 2:02:35 Process transitions from ready to waiting to running state in an OS 2:06:58 Processes go directly to running state with no ready stage 2:09:16 Resource allocation and deallocation in main memory 2:13:42 Transferring processes from Main memory to disk 2:15:47 Ready state is the most desirable for suspension 2:20:07 Understanding process states in Operating Systems 2:22:03 Processes transitioning in the operating system 2:25:53 Transition from suspended block to ready state involves swapping/loading to bring process back to main memory 2:27:46 Operating system resumes process based on resource availability 2:32:03 Explaining the concept of block and device queues in memory management. 2:34:12 Overview of Scheduling Cues in Operating Systems 2:38:16 Dispatcher controls CPU execution for selected process. 2:40:23 Schedulers in Operating Systems 2:44:46 Process Switching 2:46:53 Overview of schedulers and dispatcher in Operating Systems 2:50:58 Understanding arrival time and waiting time in an Operating System 2:52:48 Understanding process state transitions and timing 2:56:56 Preemptive scheduling allows for infinite possible ways to schedule processes. 2:58:50 Schedule Length Calculation 3:02:38 Understanding turnaround time in process scheduling 3:04:32 Discussing scheduling and its types 3:08:44 Introduction to Process Scheduling 3:10:49 The Gant chart always starts from zero. 3:15:02 Calculating waiting time in Operating Systems 3:17:00 Scheduling processes based on arrival time and execution time 3:21:04 Understanding Gantt chart and CPU idleness 3:23:07 Calculate percentage CPU idleness over schedule length 3:27:11 Understanding the life cycle of a process in Operating Systems 3:29:22 Process scheduling involved loading from ready to running via dispatcher 3:33:38 Understanding process scheduling and completion times in operating systems 3:35:48 Understanding the distinction between transit time and waiting time is crucial. 3:40:17 Calculate waiting time from chart, not formula 3:42:22 Understanding process transition from ready to running and then block in Operating Systems 3:46:38 Process scheduling and termination process in an operating system 3:48:37 Dispatcher time and process scheduling overview 3:52:46 Tips for solving process transition questions 3:54:47 Understanding CPU idleness and scheduling processes 3:58:47 Calculate CPU overhead for given process scheduling 4:00:45 Homework questions for CPU efficiency and scheduling overhead 4:04:54 Process transitions in an operating system 4:06:48 Scheduling processes with single IO device 4:10:32 Shortest Job First (SJF) prioritizes processes with the least burst time. 4:12:26 Scheduling in non-preemptive algorithms 4:16:18 Scheduling processes based on burst time and process ID. 4:18:09 Understanding the shortest job first (SJF) algorithm and its preemptive version (SRTF) 4:22:02 SRTF scheduling preempt shorter burst times 4:23:49 Understanding Preemption in SRTF Scheduling 4:27:34 SRTF scheduling algorithm involves checking every time a new process arrives 4:29:33 Scheduling and preemption in operating systems 4:33:32 SGF and SRTF algorithms are optimal 4:35:39 Calculating optimal average waiting time using Shortest Job First algorithm (SJF) 4:39:28 Calculate waiting time for processes based on scheduling order. 4:41:23 Predicting burst time using static and dynamic techniques 4:45:48 Explaining recurrence relation and initial guess concept 4:47:43 Prediction techniques for CPU burst time 4:51:55 Processes with high response ratio are given priority in HRR algorithm 4:54:02 Discussing unfairness in process scheduling based on bus time 4:58:11 Longest remaining time first (LRTF) algorithm is the opposite of SRTF, scheduling the longest process first. 5:00:13 SRTF scheduling prioritizes processes based on remaining burst time 5:04:32 Processes scheduling based on remaining burst time and process ID 5:06:23 Scheduling based on burst time and process IDs 5:10:04 Scheduling jobs using Shortest Job First algorithm 5:12:03 Introduction to priority-based scheduling algorithm 5:16:06 Priority scheduling in Operating Systems 5:18:10 Scheduling processes based on priority levels 5:22:12 Scheduling based on priority and completion time 5:24:08 Understanding the priority and scheduling of processes 5:28:10 Introduction to Round Robin algorithm 5:30:13 In round robin scheduling, processes have to leave after the time quantum 5:34:20 Scheduling multiple processes based on time Quantum 5:36:28 Scheduling new and preemptive processes 5:40:20 Scheduling processes based on arrival times and time quantum in round-robin algorithm. 5:42:16 Schedule of processes in the RQ 5:46:22 Efficiency drops to zero with small time Quantum in operating systems 5:48:32 Determining the suitable time quantum for round-robin scheduling 5:53:05 Understanding the implications of different values of Q in the context of CPU scheduling 5:55:39 Understanding CPU scheduling and time quantum 6:00:00 Explaining CPU scheduling and response time calculation 6:02:18 Calculation of response time in CPU scheduling 6:06:37 Different scheduling algorithms applied to different queues based off priorities 6:08:44 Processes penalized based on running time 6:12:46 Interprocess communication (IPC) is essential for communication between processes. 6:14:48 Synchronization is performing an agreed action. 6:19:00 Synchronization is the coordination of concurrent processes. 6:21:07 Synchronization in Operating Systems 6:25:20 Understanding the producer-consumer problem 6:27:29 Understanding process synchronization and deadlock 6:31:49 Understanding preemption and process execution 6:33:49 Understanding race conditions and synchronization 6:38:03 Importance of Correct Results in Processes 6:40:09 Producer places item onto buffer when buffer is not full 6:44:25 Understanding the circular buffer concept in operating systems. 6:46:20 Implementation of producer and consumer in C language 6:50:35 Stagnant water and mosquitoes are the main culprits for malaria spreading. 6:52:32 Synchronization requires critical sections and race conditions. 6:56:49 Security guard manages access to critical section 6:58:55 Requirements of Critical Section Problem
My respect to ALL teachers that give knowledge for free. This 25 hour course is an absolute gold mine for CS students like me and others who will tread on the path or wants to learn.
This is interesting, a whole course on computer operating systems available on RUclips. Computer operating systems have changed a lot over the years and have gotten a lot larger and a lot more loaded with features as the computer hardware has advanced over the years. The simplest operating system I ever worked with many years ago was CP/M on a Heathkit H89 computer with a Z80 cpu. That operating system only took up about 8k of memory. I am now using an Apple Mac Studio computer with Mac OS Sonoma that the Activity Monitor program says has 1.6 gb of wired memory.
Thanks to freecodecamp and Kshitij Sharma Sir for providing such a wonderful lecture on Operating Systems. This lecture covers all the topics of Operating systems in depth and the way you explained is commendable and would look after for more such videos to gain valuable lessons..
I will keep editing as I complete this video 0:0:32 lecture starts 0:21:39 uniprogramming vs multiprogramming in os 00:51:15 LECTURE 2 REVISION 00:54:55 DPP 1 answers 01:00:52 lecture 3 01:21:21 DPP 2 answers -------------------------------------- 01:29:00 section 2 process management 02:29:30 lecture 8(acc to vid) revision 2:30:34 lect 10 first come first serve 4:10:56 shortest job first
I am seven hours in and I can see why this course is 25 hours. Don't get me wrong it is a good course and covers a lot of material but there is lots of repetition and use of analogies that I don't think are necessary to get the point across. Thank you for making this great free resource!
Disagree. The analogies helped. I think the repetition was a bit much at some points but you can always 2x or fast-forward if it feels like hes rambling or you immediately grasp a concept, because I appreciated the repetition on concepts I didn't fully understand right away...
Timestamps for this video (put all in one place, thanks to others for doing the hardwork making the stamps. Overview ⌨ (00:00:00) Welcome to the Course ⌨(00:03:43) Introduction and Background ⌨(01:28:56) Process Management ⌨ (02:47:34) CPU Scheduling ⌨(06:12:23) Process Synchronization ⌨(12:32:14) Deadlock ⌨(14:20:29) Memory Management ⌨(21:20:28) File Management ⌨(23:43:16) Miscellaneous Topics
00:02 Comprehensive operating system course covering fundamental and advanced concepts. 02:41 Operating Systems Course overview and guidelines 07:28 ALU performs arithmetic and logical functions. 09:44 Operating system loads the executable file from hard disk to main memory for CPU execution. 14:33 Operating system acts as a resource manager 16:51 Operating system controls everything in the computer. 21:07 Operating system acts as a resource manager and government in controlling program applications. 23:05 Uni programming OS allows only one program in memory, leading to CPU idle time. 27:26 Multiprocessor systems run one program at a time 29:33 Schematic view of multiprogramming operating system 33:30 Difference between uniprocessor and multiprocessor systems 35:22 Multiprogramming increases CPU utilization and efficiency 39:25 Process Management in Operating Systems 41:30 Secondary storage devices need to be DMA compatible and support address translation for efficient data transfer. 45:49 Privileged processes in operating systems 47:57 Mode shifting is necessary for user applications to access OS kernel level services. 52:05 Multiprogramming increases CPU utilization and efficiency. 53:47 Architectural requirements for operating systems 57:41 Operating System Booting and Memory 59:39 Non-preemptive processes have better response time 1:03:42 Learn about mode shifting via API and SCI 1:05:57 Understanding the difference between print F in header and library files 1:10:28 Shift mode from user to kernel to access fork services 1:12:39 SVC and Interrupts in Operating Systems 1:16:58 Understanding how mode shifting is essential in operating systems. 1:18:51 Operating system mode shifting and system calls 1:22:39 Understanding kernel mode and user mode operation 1:24:33 Explanation of child process creation using Fork 1:28:52 Difference between a program and a process 1:30:58 Compilation process converts high-level code into low-level instructions 1:35:20 Dynamic array implementation in C using Maloc 1:37:31 Process is the program in execution using computer resources. 1:41:34 Program consists of instruction and data, with data types static and dynamic. 1:43:36 Activation records in function calls 1:47:40 Learning VSS extension and process operations 1:49:40 Transition diagram states and process attributes 1:53:47 Understanding Process Control Block (PCB) and Process Lifetime Stages 1:56:02 Understanding resource deallocation and process states 2:00:15 Operating systems shift processes from main memory to hard disk to manage clutter. 2:02:35 Process transitions from ready to waiting to running state in an OS 2:06:58 Processes go directly to running state with no ready stage 2:09:16 Resource allocation and deallocation in main memory 2:13:42 Transferring processes from Main memory to disk 2:15:47 Ready state is the most desirable for suspension 2:20:07 Understanding process states in Operating Systems 2:22:03 Processes transitioning in the operating system 2:25:53 Transition from suspended block to ready state involves swapping/loading to bring process back to main memory 2:27:46 Operating system resumes process based on resource availability 2:32:03 Explaining the concept of block and device queues in memory management. 2:34:12 Overview of Scheduling Cues in Operating Systems 2:38:16 Dispatcher controls CPU execution for selected process. 2:40:23 Schedulers in Operating Systems 2:44:46 Process Switching 2:46:53 Overview of schedulers and dispatcher in Operating Systems 2:50:58 Understanding arrival time and waiting time in an Operating System 2:52:48 Understanding process state transitions and timing 2:56:56 Preemptive scheduling allows for infinite possible ways to schedule processes. 2:58:50 Schedule Length Calculation 3:02:38 Understanding turnaround time in process scheduling 3:04:32 Discussing scheduling and its types 3:08:44 Introduction to Process Scheduling 3:10:49 The Gant chart always starts from zero. 3:15:02 Calculating waiting time in Operating Systems 3:17:00 Scheduling processes based on arrival time and execution time 3:21:04 Understanding Gantt chart and CPU idleness 3:23:07 Calculate percentage CPU idleness over schedule length 3:27:11 Understanding the life cycle of a process in Operating Systems 3:29:22 Process scheduling involved loading from ready to running via dispatcher 3:33:38 Understanding process scheduling and completion times in operating systems 3:35:48 Understanding the distinction between transit time and waiting time is crucial. 3:40:17 Calculate waiting time from chart, not formula 3:42:22 Understanding process transition from ready to running and then block in Operating Systems 3:46:38 Process scheduling and termination process in an operating system 3:48:37 Dispatcher time and process scheduling overview 3:52:46 Tips for solving process transition questions 3:54:47 Understanding CPU idleness and scheduling processes 3:58:47 Calculate CPU overhead for given process scheduling 4:00:45 Homework questions for CPU efficiency and scheduling overhead 4:04:54 Process transitions in an operating system 4:06:48 Scheduling processes with single IO device 4:10:32 Shortest Job First (SJF) prioritizes processes with the least burst time. 4:12:26 Scheduling in non-preemptive algorithms 4:16:18 Scheduling processes based on burst time and process ID. 4:18:09 Understanding the shortest job first (SJF) algorithm and its preemptive version (SRTF) 4:22:02 SRTF scheduling preempt shorter burst times 4:23:49 Understanding Preemption in SRTF Scheduling 4:27:34 SRTF scheduling algorithm involves checking every time a new process arrives 4:29:33 Scheduling and preemption in operating systems 4:33:32 SGF and SRTF algorithms are optimal 4:35:39 Calculating optimal average waiting time using Shortest Job First algorithm (SJF) 4:39:28 Calculate waiting time for processes based on scheduling order. 4:41:23 Predicting burst time using static and dynamic techniques 4:45:48 Explaining recurrence relation and initial guess concept 4:47:43 Prediction techniques for CPU burst time 4:51:55 Processes with high response ratio are given priority in HRR algorithm 4:54:02 Discussing unfairness in process scheduling based on bus time 4:58:11 Longest remaining time first (LRTF) algorithm is the opposite of SRTF, scheduling the longest process first. 5:00:13 SRTF scheduling prioritizes processes based on remaining burst time 5:04:32 Processes scheduling based on remaining burst time and process ID 5:06:23 Scheduling based on burst time and process IDs 5:10:04 Scheduling jobs using Shortest Job First algorithm 5:12:03 Introduction to priority-based scheduling algorithm 5:16:06 Priority scheduling in Operating Systems 5:18:10 Scheduling processes based on priority levels 5:22:12 Scheduling based on priority and completion time 5:24:08 Understanding the priority and scheduling of processes 5:28:10 Introduction to Round Robin algorithm 5:30:13 In round robin scheduling, processes have to leave after the time quantum 5:34:20 Scheduling multiple processes based on time Quantum 5:36:28 Scheduling new and preemptive processes 5:40:20 Scheduling processes based on arrival times and time quantum in round-robin algorithm. 5:42:16 Schedule of processes in the RQ 5:46:22 Efficiency drops to zero with small time Quantum in operating systems 5:48:32 Determining the suitable time quantum for round-robin scheduling 5:53:05 Understanding the implications of different values of Q in the context of CPU scheduling 5:55:39 Understanding CPU scheduling and time quantum 6:00:00 Explaining CPU scheduling and response time calculation 6:02:18 Calculation of response time in CPU scheduling 6:06:37 Different scheduling algorithms applied to different queues based off priorities 6:08:44 Processes penalized based on running time 6:12:46 Interprocess communication (IPC) is essential for communication between processes. 6:14:48 Synchronization is performing an agreed action. 6:19:00 Synchronization is the coordination of concurrent processes. 6:21:07 Synchronization in Operating Systems 6:25:20 Understanding the producer-consumer problem 6:27:29 Understanding process synchronization and deadlock 6:31:49 Understanding preemption and process execution 6:33:49 Understanding race conditions and synchronization 6:38:03 Importance of Correct Results in Processes 6:40:09 Producer places item onto buffer when buffer is not full 6:44:25 Understanding the circular buffer concept in operating systems. 6:46:20 Implementation of producer and consumer in C language 6:50:35 Stagnant water and mosquitoes are the main culprits for malaria spreading. 6:52:32 Synchronization requires critical sections and race conditions. 6:56:49 Security guard manages access to critical section 6:58:55 Requirements of Critical Section Problem
7:03:18 Critical section must have bounded waiting for interested processes. 7:05:23 Differentiating synchronization mechanisms as solutions or not 7:09:41 Introduction to lock variable as a synchronization mechanism 7:11:56 Implementing locking mechanism for mutual exclusion 7:16:17 Understanding the critical section and entry process. 7:18:41 Explanation of lock variable implementation 7:23:14 Preemption and lock value changes in a multi-process scenario 7:25:27 Importance of Lock in Ensuring Mutual Exclusion 7:29:39 Lock variable leads to wastage of CPU time. 7:31:52 Importance of critical section and preventing wastage of CPU cycles 7:36:22 Strictly alternate process execution for critical section access 7:38:28 Understanding mutual exclusion and the turn variable 7:42:40 Uninterested processes hinder the progress of interested processes 7:44:41 Explanation of mutual exclusion and bounded waiting in synchronization mechanisms 7:48:53 Concept of flag and turn for process synchronization 7:51:03 Understanding the concept of turn and flag in the context of processes. 7:55:26 Peterson solution is about the critical section and updating turn value. 7:57:38 Discussing process scheduling and completion of sections 8:01:49 Peterson solution ensures non-interested processes do not hinder progress 8:03:57 Peterson solution ensures mutual exclusion 8:08:08 Ensuring mutual exclusion and progress in operating systems. 8:10:16 Understanding the impacts of initialization on process turns 8:14:35 Decker's algorithm in operating systems 8:16:45 Algorithm provides mutual exclusion and progress 8:21:01 Explanation of Deadlock in Operating Systems 8:23:11 Discussion on bounded waiting and strict alternation 8:27:15 Discussing Test and Set Lock functionality 8:29:27 Explanation of TSL operation and its impact on critical section execution. 8:33:24 Swap mechanism based on lock and key ensures atomic execution 8:35:20 Understanding the process of swapping using a temporary variable. 8:39:16 Swap mechanism guarantees Mutual exclusion and progress 8:41:17 Test and set provides mutual exclusion 8:45:22 Priority inheritance solves deadlock in critical sections 8:47:30 Fetch and add X, I is an atomic read modify write instruction. 8:51:39 Understanding synchronization mechanisms and problem-solving 8:53:35 Understanding how L=0 and L!=1 affect log value increments. 8:57:25 Demonstration of Mutual exclusion and prevention of overflow 8:59:14 Preemption strategy in entry section 9:03:06 Understanding overflow in processes 9:05:15 FCFS doesn't suffer from starvation except for infinite loops 9:09:32 Sleep and wake up is a blocking mechanism in multiprocess solutions 9:11:33 Solving the producer-consumer problem using non-busy waiting solution 9:15:38 Implementing consumer functionality in operating systems 9:17:37 Understanding preemptive process scheduling 9:21:38 Semaphore - Definition and Types 9:23:51 Explanation of the down operation in kernel mode 9:28:16 Positive value of SEMA 4 indicates successful down operations, negative value indicates blocked processes 9:30:09 Understanding how sema4 provides Mutual exclusion 9:34:03 The objective of up operation is to wake up a sleeping process 9:36:01 Understanding the conditions for waking up processes 9:40:04 Using SEMA 4 helps manage concurrent requests effectively. 9:42:10 Managing Processes with Counting Semaphores 9:46:05 Understanding down operation in binary semaphores 9:48:05 Understanding the process blocking and synchronization 9:51:58 Understanding value changes in critical sections 9:53:57 Explanation of binary semaphore operations 9:58:13 Semaphore 4 and its operations 10:00:07 Ensuring mutual exclusion and progress in critical section 10:04:17 Preemption in semaphores can lead to deadlock. 10:06:27 Preempting processes to prevent deadlock 10:10:53 Process synchronization using down and up operations 10:13:07 Implication of strict alternation for mutual exclusion 10:17:22 Demonstrating mutual exclusion and deadlock in operating systems. 10:19:24 Understanding a scenario leading to deadlock and semaphore initialization 10:23:44 Explaining the limitations of processes without a while loop. 10:26:03 Determining minimum and maximum value of variable C in a concurrent process scenario 10:30:29 Understanding deadlock in operating systems 10:32:29 Discussing synchronization and mutual exclusion in operating systems. 10:36:25 Concurrency issues in race condition 10:38:41 Processes changing values and storing them 10:42:56 Understanding implementation using semaphores 10:44:56 Operating System synchronization in producer-consumer scenario 10:49:16 Understanding the deadlock and order importance in synchronization problems. 10:51:21 Understanding synchronization problem in operating systems 10:55:26 Producer adds item to buffer but consumer can't consume 10:57:32 Consumer removing one item at a time from buffer 11:01:20 Reader Writer problem and its solution using semaphores 11:03:29 Starvation of writers in database access 11:07:47 Database locking mechanism for readers and writers 11:09:55 Understanding the use of mutex and database for accessing the critical section. 11:14:10 Solving reader-writer problem using Mutex 11:16:05 Semaphore used to solve reader-writer problem 11:19:55 Implementation of Dining Philosopher problem 11:21:59 Philosophers sharing forks for eating efficiency 11:26:06 Preventing deadlocks by changing philosopher pattern 11:28:07 Preventing deadlock by changing paths 11:32:26 Statements can be executed concurrently if they are independent. 11:34:49 Understanding concurrency and parallelism 11:39:01 Concurrency and parallelism in operating systems 11:41:05 Understanding concurrent execution in Operating Systems 11:45:28 Understanding read set and write set for concurrent statements 11:47:38 Understanding the difference between sequential and concurrent execution using pair begin and pair end 11:51:57 Dependent nodes cannot always be considered concurrent. 11:54:10 Exploration of handling dependencies and contradictions in program execution 11:58:17 Acquiring keys in executing statements
12:00:23 Understanding the dependency between locks in executing sequence of commands. 12:04:41 Understanding key requirements for locks in the given scenario. 12:06:52 Understand the importance of valid sequences in executing concurrent tasks 12:11:11 Updating values of x and y in a sequence 12:13:30 Understanding binary semaphore and sequentiality in execution. 12:17:51 Understanding the concepts of Fork and Join in operating systems. 12:20:00 Explaining how to branch instructions in Fork 12:23:48 Understanding control flow in Operating Systems. 12:25:53 The process synchronization section is over. 12:29:45 Value of counter depends on thread execution 12:31:40 Deadlock is when two or more processes are waiting for an event that is never going to happen. 12:35:51 Deadlock explained with a meme 12:38:00 Deadlock occurs when a process is blocked forever due to resource unavailability. 12:42:14 Four necessary conditions for deadlock 12:44:24 Circular wait is not a sufficient condition for deadlock 12:48:49 Understanding resource allocation and blocking in Operating Systems 12:50:53 Preventing Deadlocks by Resource Release 12:55:03 Deadlock prevention strategies are crucial for critical operating systems. 12:57:11 Deadlock prevention negates necessary conditions 13:01:32 Efficient resource utilization through protocol 2 13:03:52 Forceful preemption and self preemption prevent deadlock 13:08:11 Resource preemption is crucial for avoiding circularity and maintaining linearity. 13:10:07 Understanding the necessity of cycles in resource allocation 13:14:27 Resource allocation graph aims to maintain a safe state 13:16:40 Understanding safe and unsafe states in resource allocation 13:20:51 Understanding Safety Algorithm and Resource Request Algorithm Basics 13:23:36 Understanding resource allocation in operating systems 13:28:25 Resource allocation and satisfaction process summarized. 13:30:35 Understanding the Banker algorithm for multiple resources with multiple instances. 13:34:55 Proving the existence of multiple CF sequences 13:37:07 Multiple safe sequences can exist with Banker's algorithm 13:41:32 Updating resource allocation and running the safety algorithm 13:43:54 Resource allocation and availability 13:48:10 Applying safety algorithm to check system state based on resource values 13:50:28 Satisfied the need for resources 13:54:59 Deadlock in single instance and multi-instance resource allocation 13:57:13 Achieving safe state by satisfying process requests 14:01:40 Resource preemption and process recovery 14:03:49 Deadlock avoidance strategies 14:08:12 Maximum resources for deadlock is 36, minimum for deadlock freedom is 37 14:10:22 Understanding unsafe state vs deadlock in resource allocation graphs 14:15:02 Ensure system can satisfy minimum resource requests to avoid deadlock 14:17:05 Resource allocation using Bankers algorithm 14:21:23 Understanding the hierarchy of memory sizes and functions of RAM in operating systems 14:23:44 Memory size calculation based on number of words and word size 14:27:57 Understanding data representation using bits and bytes 14:30:11 Explaining memory size in bits and bytes 14:34:40 Addressing Memory Blocks in Operating Systems 14:36:45 Understanding memory size and word addressing 14:40:51 Understanding the purpose and operation of the bus, chip select, and address bus in a computer system 14:42:57 Static and dynamic loading in operating systems 14:47:13 Resolving External References 14:49:25 Linker module fills up blank addresses in program code. 14:53:53 Dynamic linking allows for flexibility and code reusability 14:56:10 Difference between static and dynamic linking 15:00:45 Understanding different types of binding in Operating Systems. 15:03:02 Static and dynamic binding in operating systems 15:07:23 Address binding provides relocation flexibility at runtime. 15:09:33 Static binding vs. dynamic binding 15:13:44 Memory management fundamentals from older theories 15:15:54 Memory manager goals to minimize wastage and utilize memory effectively 15:20:20 Understanding memory overlay and its application 15:22:41 Explaining partitioning in Operating Systems. 15:26:54 Base plus limit architecture to ensure protection 15:29:05 Overview of old and new techniques in Operating Systems 15:33:22 Fixed partition leads to internal fragmentation and limited multiprogramming. 15:35:25 Dynamic partitioning allows for flexible memory allocation 15:39:35 External Fragmentation and Solutions 15:41:39 Resolve external fragmentation by reallocating memory and creating a bigger free hole 15:45:35 Variable partitioning and best fit allocation in memory systems 15:47:35 Memory allocation strategies 15:51:55 Operating Systems manages process table and memory partitions 15:54:09 Process table size calculation for 500 processes. 15:58:31 Scheduling and memory management using FCFS 16:00:32 Explaining memory allocation based on program size 16:04:24 Understanding non-continuous allocation 16:06:27 Introduction to Variable Partitioning for memory management 16:10:41 Differences between logical address and physical address 16:12:53 Memory management involves converting logical addresses to physical addresses. 16:17:11 Memory management unit handles address translation 16:19:26 Pages and Page Size Calculation 16:24:18 Understanding page offset and page number in memory addressing 16:26:37 Logical address format explained with page number and page offset 16:31:02 Understanding the concept of frames and pages in memory management. 16:33:13 Understanding logical address space and physical address space division 16:37:42 Finding physical address space using page size and frame size. 16:39:53 Understanding address translation in Operating Systems 16:44:06 Page table contains the frame number where pages are stored. 16:46:21 Understanding Page Table in Operating Systems 16:50:37 Paging technique for accessing physical memory 16:52:51 Understanding virtual memory and page table size 16:57:30 Calculating page offset and physical address space size in a computer system using paging technique 16:59:47 Determining page size and number of pages in simple paging technique. 17:04:07 Page table size calculation and performance impacts 17:06:20 Main memory access time (M) is crucial for CPU operations 17:10:46 Cache memory access time is less than main memory access time 17:12:40 Introduction to cache memory and effective access time 17:16:55 Defined hit and miss ratio for effective memory access time 17:19:12 Understanding TLB and PSC in CPU processing 17:23:30 Optimizing memory access using TLB and physical address 17:25:37 Page table size can be reduced by increasing page size 17:30:07 Finding the optimal page size for minimal internal fragmentation and page table size. 17:32:17 Optimal page size affects page table size and internal fragmentation 17:37:10 Memory division into units and load time calculation 17:39:33 Calculating CPU Time Fraction for Loading Page Table 17:43:41 Dividing program into pages and calculating required pages for text, data, and stack sections 17:45:50 Calculating number of pages based on address space and page size 17:50:07 Introduction to Hashed Page Table 17:52:19 Collision resolution technique using chaining 17:56:31 VUM architecture involves tradeoff between space and time
17:58:35 Introduction to Simple Paging and Performance Analysis 18:03:04 Page table divided into chunks for reducing size 18:05:07 Handling memory paging and chunk storage in page table 18:09:19 Reduction in space overhead by using multi-level paging 18:11:41 Introduction to Paging in Operating Systems 18:15:56 Page table divided into chunks stored in main memory frames 18:18:08 Reducing space overhead through paging 18:22:23 Dividing logical address space into chunks and pages 18:24:29 Explanation of two-level paging system 18:28:35 Understanding multi-level paging in operating systems 18:30:36 Paging is about optimizing space while sacrificing time. 18:34:26 Introduction to paging in Operating Systems. 18:36:37 Understanding page storage and frame representation in inner and outer page tables. 18:40:42 Explanation of how addressing is done 18:42:49 Paging incurs memory overhead due to page tables 18:46:58 Understanding the virtual address format in page tables. 18:49:06 Dividing the address space into chunks to determine page and table size 18:53:00 Calculating number of entries in inner and outer page tables. 18:55:15 Determining the number of levels for virtual to physical address translation 18:59:19 Understanding multi-level paging for operating systems. 19:01:31 Users view of memory location is not preserved 19:05:42 Understanding page table and logical address generation 19:07:52 Addressing and converting logical to physical 19:11:56 Understanding Segmentation in Operating Systems 19:13:55 Segmentation converting logical address to physical address 19:18:15 External fragmentation in segmentation and its solutions 19:20:21 Virtual memory illusion of having more memory available than physical memory 19:24:36 Understanding Page Hit and Page Miss in Memory Management 19:26:32 Process gets blocked due to page not present in memory 19:30:21 Demand paging is used in all operating systems like Windows, Mac, and Unix. 19:32:25 Understanding the memory hierarchy and virtual memory management 19:36:53 Effective access time calculation 19:38:59 Handling page faults in memory management. 19:43:15 Understanding effective instruction time calculation 19:45:34 Replacing victim frames with modified pages and handling different cases. 19:49:55 Understanding paging system and memory access in operating systems 19:52:11 Explanation of effective memory access time and handling TLB miss and page fault 19:56:34 Understanding frame allocation policies and calculation of demand frames 19:58:52 Policies ensure fair allocation based on demand and availability 20:03:18 Understanding page faults and memory allocation in Operating Systems 20:05:37 Calculation of page faults and fault rate 20:10:02 Increasing frames may increase page faults 20:12:14 Page faults due to Pure Demand Paging 20:16:34 Using pure demand paging to manage page faults. 20:18:45 Increasing frames reduces page faults, optimal replacement necessary. 20:23:01 Page replacement algorithms in operating systems 20:25:14 Replacement process in an operating system 20:29:17 Understanding page table entry attributes and epoch in operating systems. 20:31:38 LRU approximation using reference bit 20:35:48 Understanding how the second chance or clock algorithm selects victims based on time of loading and reference bit. 20:37:54 Implementing victimization and reference bit in page replacement algorithms 20:41:57 Exploring page table structure and selection of victim pages based on different algorithms 20:44:01 Increasing page frames may increase or decrease page faults 20:48:20 Threshing is a consequence of excessive paging activity. 20:50:23 High page fault rate leads to process blocking 20:54:25 Threshing is a result of high disk utilization and degree of multiprogramming 20:56:53 Understanding row major order in storing matrices 21:01:20 Explanation of page faults and memory storage 21:03:35 Swapping variables affects page faults 21:07:49 Writing program, data structures, algorithms affect thrashing rate 21:09:55 Understanding Working Set Window 21:14:16 Choosing the right Delta value is crucial for effective memory utilization. 21:16:22 Calculating working set window for page faults 21:21:07 Understanding the physical structure of a disk in an operating system. 21:23:17 Disk storage consists of rotating platters and read/write heads 21:27:33 Understanding seek time and track time in disk IO 21:29:42 Explaining seek time and rotational latency in disk operations 21:34:01 Understanding the disk specifications and calculating uniform capacity 21:36:20 Calculating transfer time and data transfer rate in disk I/O 21:40:44 Utilizing maximum density for varying track lengths 21:42:53 Calculating transfer time for loading a program from disk to memory 21:47:29 Analyzing page load times based on distribution and continuity 21:49:33 Disk rotation is minimized for continuous data layout on disk. 21:53:51 Importance of formatting disk for effective storage and retrieval 21:55:51 Understanding Primary and Extended/Logical Drives in Operating Systems 22:00:00 Understanding booting and partition structures 22:02:12 Understanding partitioning and boot control 22:06:38 Understanding directory structure and metadata in operating systems 22:08:45 Understanding multi-level directories in operating systems 22:12:51 File system implementation in a layered fashion 22:15:07 The I/O control level and basic file system operations in an operating system. 22:19:26 Methods of disk space allocation 22:21:41 Increasing file size is inflexible due to external fragmentation 22:25:56 Understanding indexed allocation in file systems 22:28:14 File management in Unix/Linux using i-nodes 22:32:57 Master file table stores block address information for file storage 22:35:03 Understanding the hierarchy of direct, single indirect, double indirect, and triple indirect disk block addresses. 22:39:43 Using larger block size improves disk throughput but increases internal fragmentation 22:41:56 Understanding file allocation table and its impact on maximum file size 22:46:35 Understanding file allocation and maximum file size calculation 22:48:45 Calculating maximum file size and number of blocks 22:53:18 Understanding the concept of free list and bit map in operating systems. 22:55:30 Allocating blocks for storage 22:59:53 The size of the free list is determined by the address size and the number of free blocks. 23:02:17 Understanding file allocation with bit maps and hex codes 23:06:39 Smallest cache required for average read latency < 6ms 23:08:51 Page storage space related to maximum processes, virtual address space, and RAM 23:13:14 Choosing the closest track for least seek time 23:15:30 Discussing disk scheduling algorithms 23:19:50 C-LOOK algorithm serves requests in one direction only 23:22:02 Algorithm focuses on efficient disk request servicing without needing extreme movements. 23:26:21 Power dissipation negligible due to rotational latency and head switching 23:28:19 Efficient track switching and power dissipation in operating system course 23:32:42 Calculating total power dissipation for seek time 23:34:51 Understanding disk access scheduling algorithms 23:39:23 Calculating decision time for pending requests using FCFS algorithm 23:41:24 Disk scheduling algorithms discussed for Operating Systems course 23:45:50 Sharing code and resources via threads to avoid redundancy 23:48:01 Threads share resources but have separate registers and stacks 23:52:18 Multi-threading brings responsiveness and resource sharing. 23:54:28 Multi-threading is more economical and efficient than multiprocessing. 23:58:50 Threads vs Process 24:01:12 Global variables for inter-thread communication 24:05:29 Benefits and drawbacks of user level threads independence on operating system 24:07:38 Kernel level threads provide true parallelism 24:11:49 Methods to Pass Parameters from User to Kernel 24:13:48 Understanding system calls related to process, file, and directory management. 24:18:05 Understanding the execution flow after fork statement 24:20:14 Understanding the execution order in fork process 24:24:34 Explaining the creation of child processes based on return value 24:26:46 Working with if block in an Operating System course 24:31:21 Discussing the execution of a for loop and creation of child processes based on conditions. 24:33:41 Understanding fork process in operating systems 24:38:06 Relation between virtual and physical addresses in child and parent processes 24:40:17 Virtual address space and paging concept 24:44:31 Comparing traditional vs. inverted page table sizes 24:46:40 Designing a global page table for memory management 24:50:38 Comparison between traditional and inverted page table size
- **Defining an OS:** - 5 Definitions of an Operating System - Von Neumann Architecture - Stored Program Concept - Significance of Main Memory - OS as Interface - OS Kernel - OS as Resource Manager - OS as Control Program - **Types of OS:** - Uni-programming vs. Multiprogramming - Degree of Multiprogramming - Addressing CPU Idleness - Throughput - Schematic View of Multiprogramming - Types of Multiprogramming OS - Comparison between Multiprogramming and Multitasking OS - Architectural Requirements for Implementing Multitasking OS - Kernel & User Mode - **User and Kernel Mode Shifting:** - APIs - Fork System Call - Interrupts - ISR - PSW - Types of Functions - Perspective on Mode Shifting --- **Process Management:** - **Understanding Processes:** - Distinguishing Between Program and Process - Key C Concepts - 7 Definitions of Process - Treating Process as an ADT (Abstract Data Type) - Various Process Operations - Process Attributes and PCB - **Process Transition Diagram:** - Different Process States - Process State Transition Diagram - Introduction to Schedulers and Dispatchers - Addressing Common Doubts - **Scheduling Queues and State Queuing Diagrams:** - Detailed Examination of Schedulers and Dispatchers - Context Switching --- **CPU Scheduling:** - **Introduction and Process Times:** - Implementation of Short-Term Schedulers - Functions and Objectives - Understanding Process Times (AT, BT, TAT, IOBT, CT, Schedule Length) - **FCFS:** - Selection Criteria - Operational Mode - Conflict Resolution - Assumptions - Challenges with FCFS Scheduling - Gantt Chart - % CPU Idleness and Efficiency - **FCFS with Dispatch Latency and IOBT:** - Addressing Complex FCFS Problems - Regular Discussion of Homework Problems - **Shortest Job First (Preemptive and Non-Preemptive):** - Selection Criteria - Operational Mode - Conflict Resolution - Assumptions - Challenges with FCFS Scheduling - Gantt Chart - % CPU Idleness and Efficiency - **Other Scheduling Algorithms:** - HRRN - LRTF - Round Robin and Performance Discussion - Priority Based Scheduling - Multilevel Queue Feedback Scheduling --- **Process Synchronization / Coordination:** - IPC and Introduction To Synchronization - Exploring Race Condition - Producer and Consumer Problem Implementation - Types of Sync in Producer & Consumer Problem - Necessary Conditions for Sync Problems - Introduction to Sync Mechanism - Lock Variables and Strict Alternation - Implementation of Peterson Solution - Dekker's Algorithm - Introduction to Hardware Solutions - Test & Set Lock, SWAP Lock and Key - Priority Inversion Problem Solutions - Blocking Mechanisms / Non-Busy Wait Solutions - Semaphores --- **Deadlock:** - What's Deadlock? - Resource Allocation Graph - Deadlock Handling Strategies - Banker's Algorithm and Problem Solving - Deadlock Detection and Recovery --- **Memory Management:** - Byte and Word Addressable View - RAM Architecture - Static vs. Dynamic Loading - Memory Management Techniques - Paging, Segmentation, and Virtual Memory - Page Replacement Algorithms - Thrashing and Working Set Model --- **File Management:** - Disk Structure and Logical Structure of the Disk - File vs. Directory - File System Implementation - Allocation Methods and Disk Free Space Management - Disk Scheduling Algorithms --- Feel free to ask any questions or share your thoughts on these topics!
Wow! This is a great introduction to operating systems. I learned so much about the basics of computer systems and how they work. I can't wait to learn more!
I wish they’d breakup these videos into smaller chunks, and then create a playlist. It’s much less daunting to start a 1 hour video, finish it, and feel like you’re getting some momentum
God bless everyone who shares information, and God bless RUclips and other apps that facilitate knowledge transfer.☕️🗣️ my brain is crying cus i know the book shelf behind him is pure learning goodness.😢😓 all never know.
wowwww awesome man plz also do a complete python dsa long in depth course it would be gd for me if that course would take 100 hours or beyond and also do a Wordpress course complete development and designing
My advice while I learnt this sub in past sem the book is better than any yt tutorials / courses for this the author name was Operating Systems Abraham Silberschatz
Also. I'm studying in ML in a university but I learn most of things in yt but some things I learnt from uni was DAA , COA , TOC etc Also start from basics for AI First try studying Calculus , linear algebra, probability and discrete math etc
![[#2024MAMA] BIGBANG (빅뱅) - 뱅뱅뱅 (BANG BANG BANG) + FANTASTIC BABY | Mnet 241123 방송](http://i.ytimg.com/vi/EQsYfiPR9uM/mqdefault.jpg)
Wow. I see what you guys are doing. We basically have a full cs degree on this channel
Can you please name where to start my cs degree from this channel till end. I don't know where to start and finish can you please provide just chapter or topics names begining to end
@@rounak9099 usually the first course people recommend to start with is cs 50's course which acts as an introduction to computer science , you could start with that
@@rounak9099 I would recommend starting from maths, digital circuits (FPGA also), cpu architecture, assembly, C/C++, embedded programming, operating system(how it works and how to use an os), oop, data structure and algorithms, internet basics, web development (code a server and a site), sql, app development, AI/Machine learning, Computer vision, deep learning.
If you learn all of this, you should theoretically be good enough for any entry job in cs, but in reality, you still probably need something to prove you know these, either a good degree or a really good portfolio.
@@rounak9099 chill out! first thing is first, why get a CS degree ( its a brilliant way of getting into tech dont get me wrong) but if you are not getting a conventional degree from a Uni there is simply no point of learning the entirity of degree unless you are genuinly interested in ALL subjects (which is rare), so choose what you want to do, get the fundamentals in order and you will be better off than CS grads. Good luck :)
@@rounak9099 Should give more context bro, why do you wanna learn it.
7:03:18 Critical section must have bounded waiting for interested processes.
7:05:23 Differentiating synchronization mechanisms as solutions or not
7:09:41 Introduction to lock variable as a synchronization mechanism
7:11:56 Implementing locking mechanism for mutual exclusion
7:16:17 Understanding the critical section and entry process.
7:18:41 Explanation of lock variable implementation
7:23:14 Preemption and lock value changes in a multi-process scenario
7:25:27 Importance of Lock in Ensuring Mutual Exclusion
7:29:39 Lock variable leads to wastage of CPU time.
7:31:52 Importance of critical section and preventing wastage of CPU cycles
7:36:22 Strictly alternate process execution for critical section access
7:38:28 Understanding mutual exclusion and the turn variable
7:42:40 Uninterested processes hinder the progress of interested processes
7:44:41 Explanation of mutual exclusion and bounded waiting in synchronization mechanisms
7:48:53 Concept of flag and turn for process synchronization
7:51:03 Understanding the concept of turn and flag in the context of processes.
7:55:26 Peterson solution is about the critical section and updating turn value.
7:57:38 Discussing process scheduling and completion of sections
8:01:49 Peterson solution ensures non-interested processes do not hinder progress
8:03:57 Peterson solution ensures mutual exclusion
8:08:08 Ensuring mutual exclusion and progress in operating systems.
8:10:16 Understanding the impacts of initialization on process turns
8:14:35 Decker's algorithm in operating systems
8:16:45 Algorithm provides mutual exclusion and progress
8:21:01 Explanation of Deadlock in Operating Systems
8:23:11 Discussion on bounded waiting and strict alternation
8:27:15 Discussing Test and Set Lock functionality
8:29:27 Explanation of TSL operation and its impact on critical section execution.
8:33:24 Swap mechanism based on lock and key ensures atomic execution
8:35:20 Understanding the process of swapping using a temporary variable.
8:39:16 Swap mechanism guarantees Mutual exclusion and progress
8:41:17 Test and set provides mutual exclusion
8:45:22 Priority inheritance solves deadlock in critical sections
8:47:30 Fetch and add X, I is an atomic read modify write instruction.
8:51:39 Understanding synchronization mechanisms and problem-solving
8:53:35 Understanding how L=0 and L!=1 affect log value increments.
8:57:25 Demonstration of Mutual exclusion and prevention of overflow
8:59:14 Preemption strategy in entry section
9:03:06 Understanding overflow in processes
9:05:15 FCFS doesn't suffer from starvation except for infinite loops
9:09:32 Sleep and wake up is a blocking mechanism in multiprocess solutions
9:11:33 Solving the producer-consumer problem using non-busy waiting solution
9:15:38 Implementing consumer functionality in operating systems
9:17:37 Understanding preemptive process scheduling
9:21:38 Semaphore - Definition and Types
9:23:51 Explanation of the down operation in kernel mode
9:28:16 Positive value of SEMA 4 indicates successful down operations, negative value indicates blocked processes
9:30:09 Understanding how sema4 provides Mutual exclusion
9:34:03 The objective of up operation is to wake up a sleeping process
9:36:01 Understanding the conditions for waking up processes
9:40:04 Using SEMA 4 helps manage concurrent requests effectively.
9:42:10 Managing Processes with Counting Semaphores
9:46:05 Understanding down operation in binary semaphores
9:48:05 Understanding the process blocking and synchronization
9:51:58 Understanding value changes in critical sections
9:53:57 Explanation of binary semaphore operations
9:58:13 Semaphore 4 and its operations
10:00:07 Ensuring mutual exclusion and progress in critical section
10:04:17 Preemption in semaphores can lead to deadlock.
10:06:27 Preempting processes to prevent deadlock
10:10:53 Process synchronization using down and up operations
10:13:07 Implication of strict alternation for mutual exclusion
10:17:22 Demonstrating mutual exclusion and deadlock in operating systems.
10:19:24 Understanding a scenario leading to deadlock and semaphore initialization
10:23:44 Explaining the limitations of processes without a while loop.
10:26:03 Determining minimum and maximum value of variable C in a concurrent process scenario
10:30:29 Understanding deadlock in operating systems
10:32:29 Discussing synchronization and mutual exclusion in operating systems.
10:36:25 Concurrency issues in race condition
10:38:41 Processes changing values and storing them
10:42:56 Understanding implementation using semaphores
10:44:56 Operating System synchronization in producer-consumer scenario
10:49:16 Understanding the deadlock and order importance in synchronization problems.
10:51:21 Understanding synchronization problem in operating systems
10:55:26 Producer adds item to buffer but consumer can't consume
10:57:32 Consumer removing one item at a time from buffer
11:01:20 Reader Writer problem and its solution using semaphores
11:03:29 Starvation of writers in database access
11:07:47 Database locking mechanism for readers and writers
11:09:55 Understanding the use of mutex and database for accessing the critical section.
11:14:10 Solving reader-writer problem using Mutex
11:16:05 Semaphore used to solve reader-writer problem
11:19:55 Implementation of Dining Philosopher problem
11:21:59 Philosophers sharing forks for eating efficiency
11:26:06 Preventing deadlocks by changing philosopher pattern
11:28:07 Preventing deadlock by changing paths
11:32:26 Statements can be executed concurrently if they are independent.
11:34:49 Understanding concurrency and parallelism
11:39:01 Concurrency and parallelism in operating systems
11:41:05 Understanding concurrent execution in Operating Systems
11:45:28 Understanding read set and write set for concurrent statements
11:47:38 Understanding the difference between sequential and concurrent execution using pair begin and pair end
11:51:57 Dependent nodes cannot always be considered concurrent.
11:54:10 Exploration of handling dependencies and contradictions in program execution
11:58:17 Acquiring keys in executing statements
@studynewthings1727
Really needed Thanks
@@praveensam5592 It was nothing, AI makes it easy to do these things
@@hsabatino still thanks
@@TechnoSan09 has we said in latam: de nada hermano!
We need something like this for computer networking !!
There are plenty of good networking courses on this channel! 👍🏻 The least effort you can at least do, is LOOK for it in their videos, use search 😬😉🤘🏻
+ Databases (which I believe already exists) and you have the trifecta for lower tier godhood 💀
Power Cert Animated Videos has a great 4 hour introductory video for Networking here on RUclips.
It's very broad without going into real-world applications, but is a very good general overview. It's animated, very easy to follow, and should get you comfortable with the terminology.
Then I would recommend renting or getting the book Networking: A Top Down Approach by Jim Kurose. The Author has a RUclips channel and chapter modules uploaded to his channel to go along with the reading.
This is what I'm doing. There are other boot camp style courses here on RUclips, but the instructors just seem to throw a ton of terminology at you without offering any substance or helping to build an intuition for the processes.
@@borisdorofeev5602 thanks man , I'll check it out
With Linux please!!!
12:00:23 Understanding the dependency between locks in executing sequence of commands.
12:04:41 Understanding key requirements for locks in the given scenario.
12:06:52 Understand the importance of valid sequences in executing concurrent tasks
12:11:11 Updating values of x and y in a sequence
12:13:30 Understanding binary semaphore and sequentiality in execution.
12:17:51 Understanding the concepts of Fork and Join in operating systems.
12:20:00 Explaining how to branch instructions in Fork
12:23:48 Understanding control flow in Operating Systems.
12:25:53 The process synchronization section is over.
12:29:45 Value of counter depends on thread execution
12:31:40 Deadlock is when two or more processes are waiting for an event that is never going to happen.
12:35:51 Deadlock explained with a meme
12:38:00 Deadlock occurs when a process is blocked forever due to resource unavailability.
12:42:14 Four necessary conditions for deadlock
12:44:24 Circular wait is not a sufficient condition for deadlock
12:48:49 Understanding resource allocation and blocking in Operating Systems
12:50:53 Preventing Deadlocks by Resource Release
12:55:03 Deadlock prevention strategies are crucial for critical operating systems.
12:57:11 Deadlock prevention negates necessary conditions
13:01:32 Efficient resource utilization through protocol 2
13:03:52 Forceful preemption and self preemption prevent deadlock
13:08:11 Resource preemption is crucial for avoiding circularity and maintaining linearity.
13:10:07 Understanding the necessity of cycles in resource allocation
13:14:27 Resource allocation graph aims to maintain a safe state
13:16:40 Understanding safe and unsafe states in resource allocation
13:20:51 Understanding Safety Algorithm and Resource Request Algorithm Basics
13:23:36 Understanding resource allocation in operating systems
13:28:25 Resource allocation and satisfaction process summarized.
13:30:35 Understanding the Banker algorithm for multiple resources with multiple instances.
13:34:55 Proving the existence of multiple CF sequences
13:37:07 Multiple safe sequences can exist with Banker's algorithm
13:41:32 Updating resource allocation and running the safety algorithm
13:43:54 Resource allocation and availability
13:48:10 Applying safety algorithm to check system state based on resource values
13:50:28 Satisfied the need for resources
13:54:59 Deadlock in single instance and multi-instance resource allocation
13:57:13 Achieving safe state by satisfying process requests
14:01:40 Resource preemption and process recovery
14:03:49 Deadlock avoidance strategies
14:08:12 Maximum resources for deadlock is 36, minimum for deadlock freedom is 37
14:10:22 Understanding unsafe state vs deadlock in resource allocation graphs
14:15:02 Ensure system can satisfy minimum resource requests to avoid deadlock
14:17:05 Resource allocation using Bankers algorithm
14:21:23 Understanding the hierarchy of memory sizes and functions of RAM in operating systems
14:23:44 Memory size calculation based on number of words and word size
14:27:57 Understanding data representation using bits and bytes
14:30:11 Explaining memory size in bits and bytes
14:34:40 Addressing Memory Blocks in Operating Systems
14:36:45 Understanding memory size and word addressing
14:40:51 Understanding the purpose and operation of the bus, chip select, and address bus in a computer system
14:42:57 Static and dynamic loading in operating systems
14:47:13 Resolving External References
14:49:25 Linker module fills up blank addresses in program code.
14:53:53 Dynamic linking allows for flexibility and code reusability
14:56:10 Difference between static and dynamic linking
15:00:45 Understanding different types of binding in Operating Systems.
15:03:02 Static and dynamic binding in operating systems
15:07:23 Address binding provides relocation flexibility at runtime.
15:09:33 Static binding vs. dynamic binding
15:13:44 Memory management fundamentals from older theories
15:15:54 Memory manager goals to minimize wastage and utilize memory effectively
15:20:20 Understanding memory overlay and its application
15:22:41 Explaining partitioning in Operating Systems.
15:26:54 Base plus limit architecture to ensure protection
15:29:05 Overview of old and new techniques in Operating Systems
15:33:22 Fixed partition leads to internal fragmentation and limited multiprogramming.
15:35:25 Dynamic partitioning allows for flexible memory allocation
15:39:35 External Fragmentation and Solutions
15:41:39 Resolve external fragmentation by reallocating memory and creating a bigger free hole
15:45:35 Variable partitioning and best fit allocation in memory systems
15:47:35 Memory allocation strategies
15:51:55 Operating Systems manages process table and memory partitions
15:54:09 Process table size calculation for 500 processes.
15:58:31 Scheduling and memory management using FCFS
16:00:32 Explaining memory allocation based on program size
16:04:24 Understanding non-continuous allocation
16:06:27 Introduction to Variable Partitioning for memory management
16:10:41 Differences between logical address and physical address
16:12:53 Memory management involves converting logical addresses to physical addresses.
16:17:11 Memory management unit handles address translation
16:19:26 Pages and Page Size Calculation
16:24:18 Understanding page offset and page number in memory addressing
16:26:37 Logical address format explained with page number and page offset
16:31:02 Understanding the concept of frames and pages in memory management.
16:33:13 Understanding logical address space and physical address space division
16:37:42 Finding physical address space using page size and frame size.
16:39:53 Understanding address translation in Operating Systems
16:44:06 Page table contains the frame number where pages are stored.
16:46:21 Understanding Page Table in Operating Systems
16:50:37 Paging technique for accessing physical memory
16:52:51 Understanding virtual memory and page table size
16:57:30 Calculating page offset and physical address space size in a computer system using paging technique
16:59:47 Determining page size and number of pages in simple paging technique.
17:04:07 Page table size calculation and performance impacts
17:06:20 Main memory access time (M) is crucial for CPU operations
17:10:46 Cache memory access time is less than main memory access time
17:12:40 Introduction to cache memory and effective access time
17:16:55 Defined hit and miss ratio for effective memory access time
17:19:12 Understanding TLB and PSC in CPU processing
17:23:30 Optimizing memory access using TLB and physical address
17:25:37 Page table size can be reduced by increasing page size
17:30:07 Finding the optimal page size for minimal internal fragmentation and page table size.
17:32:17 Optimal page size affects page table size and internal fragmentation
17:37:10 Memory division into units and load time calculation
17:39:33 Calculating CPU Time Fraction for Loading Page Table
17:43:41 Dividing program into pages and calculating required pages for text, data, and stack sections
17:45:50 Calculating number of pages based on address space and page size
17:50:07 Introduction to Hashed Page Table
17:52:19 Collision resolution technique using chaining
17:56:31 VUM architecture involves tradeoff between space and time
did you make the notes from this video?
if yes then can you please share it with me it will be helpful for me whilemaking notes the notes visible on the screen is very less and I'll have to rewind it again and again making the notes making process time consuming.
@@aspiredifferent8085 u have to pay for it
@studynewthings1727
Your attention span is superb bro 👌🏽👌🏽👌🏽
@@musonobari2560 I don't do it, just use Merlin IA hehe
This guy talking from his deepest heart. I trust this guy.
25 hours is crazy
Who knows what the goal is for freeCodeCamp with anything they put out. Maybe this guy is poor and needs more money from all the information he stole. Maybe they are just stupid. But hey free information. Maybe all 9.77 million subscribers will make their own operating system. Their own crap operating system that can't compete with the other ones.
I think you'll be allowed to take breaks through it if you really need to.
@@GrahamPointer1972 Look how long it took to create windows with all of those employees.
@@itzhexen0 Tbf this isn't going to teach you to make something as big as windows. Good luck doing that by yourself.
@@barry4207 true. but linux is open source. also all this information channels like these put out just kills everyone's future because they just tell all this information to millions of people. everyone on the planet can't sit at a computer for a job. especially for the next 100-1000 years.
17:58:35 Introduction to Simple Paging and Performance Analysis
18:03:04 Page table divided into chunks for reducing size
18:05:07 Handling memory paging and chunk storage in page table
18:09:19 Reduction in space overhead by using multi-level paging
18:11:41 Introduction to Paging in Operating Systems
18:15:56 Page table divided into chunks stored in main memory frames
18:18:08 Reducing space overhead through paging
18:22:23 Dividing logical address space into chunks and pages
18:24:29 Explanation of two-level paging system
18:28:35 Understanding multi-level paging in operating systems
18:30:36 Paging is about optimizing space while sacrificing time.
18:34:26 Introduction to paging in Operating Systems.
18:36:37 Understanding page storage and frame representation in inner and outer page tables.
18:40:42 Explanation of how addressing is done
18:42:49 Paging incurs memory overhead due to page tables
18:46:58 Understanding the virtual address format in page tables.
18:49:06 Dividing the address space into chunks to determine page and table size
18:53:00 Calculating number of entries in inner and outer page tables.
18:55:15 Determining the number of levels for virtual to physical address translation
18:59:19 Understanding multi-level paging for operating systems.
19:01:31 Users view of memory location is not preserved
19:05:42 Understanding page table and logical address generation
19:07:52 Addressing and converting logical to physical
19:11:56 Understanding Segmentation in Operating Systems
19:13:55 Segmentation converting logical address to physical address
19:18:15 External fragmentation in segmentation and its solutions
19:20:21 Virtual memory illusion of having more memory available than physical memory
19:24:36 Understanding Page Hit and Page Miss in Memory Management
19:26:32 Process gets blocked due to page not present in memory
19:30:21 Demand paging is used in all operating systems like Windows, Mac, and Unix.
19:32:25 Understanding the memory hierarchy and virtual memory management
19:36:53 Effective access time calculation
19:38:59 Handling page faults in memory management.
19:43:15 Understanding effective instruction time calculation
19:45:34 Replacing victim frames with modified pages and handling different cases.
19:49:55 Understanding paging system and memory access in operating systems
19:52:11 Explanation of effective memory access time and handling TLB miss and page fault
19:56:34 Understanding frame allocation policies and calculation of demand frames
19:58:52 Policies ensure fair allocation based on demand and availability
20:03:18 Understanding page faults and memory allocation in Operating Systems
20:05:37 Calculation of page faults and fault rate
20:10:02 Increasing frames may increase page faults
20:12:14 Page faults due to Pure Demand Paging
20:16:34 Using pure demand paging to manage page faults.
20:18:45 Increasing frames reduces page faults, optimal replacement necessary.
20:23:01 Page replacement algorithms in operating systems
20:25:14 Replacement process in an operating system
20:29:17 Understanding page table entry attributes and epoch in operating systems.
20:31:38 LRU approximation using reference bit
20:35:48 Understanding how the second chance or clock algorithm selects victims based on time of loading and reference bit.
20:37:54 Implementing victimization and reference bit in page replacement algorithms
20:41:57 Exploring page table structure and selection of victim pages based on different algorithms
20:44:01 Increasing page frames may increase or decrease page faults
20:48:20 Threshing is a consequence of excessive paging activity.
20:50:23 High page fault rate leads to process blocking
20:54:25 Threshing is a result of high disk utilization and degree of multiprogramming
20:56:53 Understanding row major order in storing matrices
21:01:20 Explanation of page faults and memory storage
21:03:35 Swapping variables affects page faults
21:07:49 Writing program, data structures, algorithms affect thrashing rate
21:09:55 Understanding Working Set Window
21:14:16 Choosing the right Delta value is crucial for effective memory utilization.
21:16:22 Calculating working set window for page faults
21:21:07 Understanding the physical structure of a disk in an operating system.
21:23:17 Disk storage consists of rotating platters and read/write heads
21:27:33 Understanding seek time and track time in disk IO
21:29:42 Explaining seek time and rotational latency in disk operations
21:34:01 Understanding the disk specifications and calculating uniform capacity
21:36:20 Calculating transfer time and data transfer rate in disk I/O
21:40:44 Utilizing maximum density for varying track lengths
21:42:53 Calculating transfer time for loading a program from disk to memory
21:47:29 Analyzing page load times based on distribution and continuity
21:49:33 Disk rotation is minimized for continuous data layout on disk.
21:53:51 Importance of formatting disk for effective storage and retrieval
21:55:51 Understanding Primary and Extended/Logical Drives in Operating Systems
22:00:00 Understanding booting and partition structures
22:02:12 Understanding partitioning and boot control
22:06:38 Understanding directory structure and metadata in operating systems
22:08:45 Understanding multi-level directories in operating systems
22:12:51 File system implementation in a layered fashion
22:15:07 The I/O control level and basic file system operations in an operating system.
22:19:26 Methods of disk space allocation
22:21:41 Increasing file size is inflexible due to external fragmentation
22:25:56 Understanding indexed allocation in file systems
22:28:14 File management in Unix/Linux using i-nodes
22:32:57 Master file table stores block address information for file storage
22:35:03 Understanding the hierarchy of direct, single indirect, double indirect, and triple indirect disk block addresses.
22:39:43 Using larger block size improves disk throughput but increases internal fragmentation
22:41:56 Understanding file allocation table and its impact on maximum file size
22:46:35 Understanding file allocation and maximum file size calculation
22:48:45 Calculating maximum file size and number of blocks
22:53:18 Understanding the concept of free list and bit map in operating systems.
22:55:30 Allocating blocks for storage
22:59:53 The size of the free list is determined by the address size and the number of free blocks.
23:02:17 Understanding file allocation with bit maps and hex codes
23:06:39 Smallest cache required for average read latency < 6ms
23:08:51 Page storage space related to maximum processes, virtual address space, and RAM
23:13:14 Choosing the closest track for least seek time
23:15:30 Discussing disk scheduling algorithms
23:19:50 C-LOOK algorithm serves requests in one direction only
23:22:02 Algorithm focuses on efficient disk request servicing without needing extreme movements.
23:26:21 Power dissipation negligible due to rotational latency and head switching
23:28:19 Efficient track switching and power dissipation in operating system course
23:32:42 Calculating total power dissipation for seek time
23:34:51 Understanding disk access scheduling algorithms
23:39:23 Calculating decision time for pending requests using FCFS algorithm
23:41:24 Disk scheduling algorithms discussed for Operating Systems course
23:45:50 Sharing code and resources via threads to avoid redundancy
23:48:01 Threads share resources but have separate registers and stacks
23:52:18 Multi-threading brings responsiveness and resource sharing.
23:54:28 Multi-threading is more economical and efficient than multiprocessing.
23:58:50 Threads vs Process
24:01:12 Global variables for inter-thread communication
24:05:29 Benefits and drawbacks of user level threads independence on operating system
24:07:38 Kernel level threads provide true parallelism
24:11:49 Methods to Pass Parameters from User to Kernel
24:13:48 Understanding system calls related to process, file, and directory management.
24:18:05 Understanding the execution flow after fork statement
24:20:14 Understanding the execution order in fork process
24:24:34 Explaining the creation of child processes based on return value
24:26:46 Working with if block in an Operating System course
24:31:21 Discussing the execution of a for loop and creation of child processes based on conditions.
24:33:41 Understanding fork process in operating systems
24:38:06 Relation between virtual and physical addresses in child and parent processes
24:40:17 Virtual address space and paging concept
24:44:31 Comparing traditional vs. inverted page table sizes
24:46:40 Designing a global page table for memory management
24:50:38 Comparison between traditional and inverted page table sizes
Crafted by Merlin AI.
Thank you!
21:38 Lecture 2 Uni/Multi Programming OS, Pre/Non-emptive, User/Kernel Mode
55:05 Exercises
1:00:52 Lecture 3 User/Kernel Mode Shifting
1:21:17 Exercises
1:28:56 Section 2 Process Management, 1:40:08 4 parts of Data Structure, Process Control Block(Process Descriptor)
1:53:10 Lecture 8 Process State Transition Diagram 2:11:40 Suspension(Swapping)
2:30:29 Lecture 10 Scheduling Queue 2:43:14 Dispatcher
2:47:35 Section 3 CPU Scheduling 3:06:40 CPU Scheduling Algorithm (FCFS)
3:25:45 CPU Scheduling Part-2 Load time, IOBT 3:34:53 Wating Time 3:59:19 CPU Overhead 4:01:03 Homework
4:10:42 CPU Scheduling Part-3 Algorithm (SJF) 4:19:25 Algorithm (SRTF) 4:28:20 Homework
18:10:19 Reduction in space overhead by using multi-level paging
18:11:41 Introduction to Paging in Operating Systems
18:15:56 Page table divided into chunks stored in main memory frames
18:18:08 Reducing space overhead through paging
18:22:23 Dividing logical address space into chunks and pages
18:24:29 Explanation of two-level paging system
18:28:35 Understanding multi-level paging in operating systems
18:30:36 Paging is about optimizing space while sacrificing time.
18:34:26 Introduction to paging in Operating Systems.
18:36:37 Understanding page storage and frame representation in inner and outer page tables.
18:40:42 Explanation of how addressing is done
18:42:49 Paging incurs memory overhead due to page tables
18:46:58 Understanding the virtual address format in page tables.
18:49:06 Dividing the address space into chunks to determine page and table size
18:53:00 Calculating number of entries in inner and outer page tables.
18:55:15 Determining the number of levels for virtual to physical address translation
18:59:19 Understanding multi-level paging for operating systems.
19:01:31 Users view of memory location is not preserved
19:05:42 Understanding page table and logical address generation
19:07:52 Addressing and converting logical to physical
19:11:56 Understanding Segmentation in Operating Systems
19:13:55 Segmentation converting logical address to physical address
19:18:15 External fragmentation in segmentation and its solutions
19:20:21 Virtual memory illusion of having more memory available than physical memory
19:24:36 Understanding Page Hit and Page Miss in Memory Management
19:26:32 Process gets blocked due to page not present in memory
19:30:21 Demand paging is used in all operating systems like Windows, Mac, and Unix.
19:32:25 Understanding the memory hierarchy and virtual memory management
19:36:53 Effective access time calculation
19:38:59 Handling page faults in memory management.
19:43:15 Understanding effective instruction time calculation
19:45:34 Replacing victim frames with modified pages and handling different cases.
19:49:55 Understanding paging system and memory access in operating systems
19:52:11 Explanation of effective memory access time and handling TLB miss and page fault
19:56:34 Understanding frame allocation policies and calculation of demand frames
19:58:52 Policies ensure fair allocation based on demand and availability
20:03:18 Understanding page faults and memory allocation in Operating Systems
20:05:37 Calculation of page faults and fault rate
20:10:02 Increasing frames may increase page faults
20:12:14 Page faults due to Pure Demand Paging
20:16:34 Using pure demand paging to manage page faults.
20:18:45 Increasing frames reduces page faults, optimal replacement necessary.
20:23:01 Page replacement algorithms in operating systems
20:25:14 Replacement process in an operating system
20:29:17 Understanding page table entry attributes and epoch in operating systems.
20:31:38 LRU approximation using reference bit
20:35:48 Understanding how the second chance or clock algorithm selects victims based on time of loading and reference bit.
20:37:54 Implementing victimization and reference bit in page replacement algorithms
20:41:57 Exploring page table structure and selection of victim pages based on different algorithms
20:44:01 Increasing page frames may increase or decrease page faults
20:48:20 Threshing is a consequence of excessive paging activity.
20:50:23 High page fault rate leads to process blocking
20:54:25 Threshing is a result of high disk utilization and degree of multiprogramming
20:56:53 Understanding row major order in storing matrices
21:01:20 Explanation of page faults and memory storage
21:03:35 Swapping variables affects page faults
21:07:49 Writing program, data structures, algorithms affect thrashing rate
21:09:55 Understanding Working Set Window
21:14:16 Choosing the right Delta value is crucial for effective memory utilization.
21:16:22 Calculating working set window for page faults
21:21:07 Understanding the physical structure of a disk in an operating system.
21:23:17 Disk storage consists of rotating platters and read/write heads
21:27:33 Understanding seek time and track time in disk IO
21:29:42 Explaining seek time and rotational latency in disk operations
21:34:01 Understanding the disk specifications and calculating uniform capacity
21:36:20 Calculating transfer time and data transfer rate in disk I/O
21:40:44 Utilizing maximum density for varying track lengths
21:42:53 Calculating transfer time for loading a program from disk to memory
21:47:29 Analyzing page load times based on distribution and continuity
21:49:33 Disk rotation is minimized for continuous data layout on disk.
21:53:51 Importance of formatting disk for effective storage and retrieval
21:55:51 Understanding Primary and Extended/Logical Drives in Operating Systems
22:00:00 Understanding booting and partition structures
22:02:12 Understanding partitioning and boot control
22:06:38 Understanding directory structure and metadata in operating systems
22:08:45 Understanding multi-level directories in operating systems
22:12:51 File system implementation in a layered fashion
22:15:07 The I/O control level and basic file system operations in an operating system.
22:19:26 Methods of disk space allocation
22:21:41 Increasing file size is inflexible due to external fragmentation
22:25:56 Understanding indexed allocation in file systems
22:28:14 File management in Unix/Linux using i-nodes
22:32:57 Master file table stores block address information for file storage
22:35:03 Understanding the hierarchy of direct, single indirect, double indirect, and triple indirect disk block addresses.
22:39:43 Using larger block size improves disk throughput but increases internal fragmentation
22:41:56 Understanding file allocation table and its impact on maximum file size
22:46:35 Understanding file allocation and maximum file size calculation
22:48:45 Calculating maximum file size and number of blocks
22:53:18 Understanding the concept of free list and bit map in operating systems.
22:55:30 Allocating blocks for storage
22:59:53 The size of the free list is determined by the address size and the number of free blocks.
23:02:17 Understanding file allocation with bit maps and hex codes
23:06:39 Smallest cache required for average read latency < 6ms
23:08:51 Page storage space related to maximum processes, virtual address space, and RAM
23:13:14 Choosing the closest track for least seek time
23:15:30 Discussing disk scheduling algorithms
23:19:50 C-LOOK algorithm serves requests in one direction only
23:22:02 Algorithm focuses on efficient disk request servicing without needing extreme movements.
23:26:21 Power dissipation negligible due to rotational latency and head switching
23:28:19 Efficient track switching and power dissipation in operating system course
23:32:42 Calculating total power dissipation for seek time
23:34:51 Understanding disk access scheduling algorithms
23:39:23 Calculating decision time for pending requests using FCFS algorithm
23:41:24 Disk scheduling algorithms discussed for Operating Systems course
23:45:50 Sharing code and resources via threads to avoid redundancy
23:48:01 Threads share resources but have separate registers and stacks
23:52:18 Multi-threading brings responsiveness and resource sharing.
23:54:28 Multi-threading is more economical and efficient than multiprocessing.
23:58:50 Threads vs Process
24:01:12 Global variables for inter-thread communication
24:05:29 Benefits and drawbacks of user level threads independence on operating system
24:07:38 Kernel level threads provide true parallelism
24:11:49 Methods to Pass Parameters from User to Kernel
24:13:48 Understanding system calls related to process, file, and directory management.
24:18:05 Understanding the execution flow after fork statement
24:20:14 Understanding the execution order in fork process
24:24:34 Explaining the creation of child processes based on return value
24:26:46 Working with if block in an Operating System course
24:31:21 Discussing the execution of a for loop and creation of child processes based on conditions.
24:33:41 Understanding fork process in operating systems
24:38:06 Relation between virtual and physical addresses in child and parent processes
24:40:17 Virtual address space and paging concept
24:44:31 Comparing traditional vs. inverted page table sizes
24:46:40 Designing a global page table for memory management
24:50:38 Comparison between traditional and inverted page table sizes
Best operating system course available on RUclips ❤
I've fixed the timestamps so they work properly. Copy paste this FCC and thank you so much for your arduous work! 💓
⌨ (00:00:00) Welcome to the Course
⌨(00:03:43) Introduction and Background
⌨(01:28:56) Process Management
⌨ (02:47:34) CPU Scheduling
⌨(06:12:23) Process Synchronization
⌨(12:32:14) Deadlock
⌨(14:20:29) Memory Management
⌨(21:20:28) File Management
⌨(23:43:16) Miscellaneous Topics
You are a blessing 😭🙌🏾
Thnk you😊
This has quickly become one of my favorite RUclips channels. What you're doing is very important and the fact you're offering these courses for free is very generous.
Thank you for your huge contribution in offering an affordable education.
One of the few youtube channels that really deserve the success it has
Absolutely!!!! You can learn so much from DC, But you have to be passionate to go watch, learn and lab their courses.
No symuch thing as a free lunch. It's still up to you to put the leg work in.
@@purplemonkeydishwasher5269 just like the instructor says in the beginning, "you can't just watch this like Netflix."
He's completely right. I've got the textbook he mentioned have read the first few chapters and have watched the first several hours of this video maybe 3-4 times. But I'm also reading like 3 other books on digital logic/electronics. And watching two other crash courses on operating systems.
Thus is really complex stuff and you really need to put in a lot of effort to understand, and make the concepts feel more familiar.
@@borisdorofeev5602 if you know, can u please recommend me some courses that goes further deep in details of os 🙂
Completed till
Sitting 1 (25/10 Noon) -> 1:53:14
Sitting 2 (25/10 Evening 8PM) -> 6:04:02
Sitting 3 (28/10 - 10PM) -> 8:05:40
Sitting 4 (2/11 - 2PM) -> 9:44:27
Sitting 5 (14/11 - 1:30 PM) -> 13:10:24
Sitting 6 (17/11 - 4:30 PM) -> 16:18:40
Qualities of this course : Crisp and to the point explanation, all important topics covered, Multiple analogies, amazing practice problems, whatever this guy promised, he has delivered it.
Imagine planning, recording, explaining, editing 25 hours of content... Thank you is not enough, but thank you! ❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️
THE ULTIMATE COURSE FOR HIGH TECH INTERVIEWS CS FUNDAMENTALS
sir...the video released 7 minutes before your comment...
@@pitchblack5422
he is the fastest reader in the world
@@thehustlersarena1401 have i purchased their notes ?
@@pitchblack5422😂😂
@@pitchblack5422lmao
It's too easy to comment on anything, but it needs hundreds of hours to create a massive video of 25 hours. No one can fulfill the expectations of every one because these courses are not based on individual's demand and their plus n minuses. These are for masses.
I salute the person who made this video n his video's usefulness for millions.
00:02 Comprehensive operating system course covering fundamental and advanced concepts.
02:41 Operating Systems Course overview and guidelines
07:28 ALU performs arithmetic and logical functions.
09:44 Operating system loads the executable file from hard disk to main memory for CPU execution.
14:33 Operating system acts as a resource manager
16:51 Operating system controls everything in the computer.
21:07 Operating system acts as a resource manager and government in controlling program applications.
23:05 Uni programming OS allows only one program in memory, leading to CPU idle time.
27:26 Multiprocessor systems run one program at a time
29:33 Schematic view of multiprogramming operating system
33:30 Difference between uniprocessor and multiprocessor systems
35:22 Multiprogramming increases CPU utilization and efficiency
39:25 Process Management in Operating Systems
41:30 Secondary storage devices need to be DMA compatible and support address translation for efficient data transfer.
45:49 Privileged processes in operating systems
47:57 Mode shifting is necessary for user applications to access OS kernel level services.
52:05 Multiprogramming increases CPU utilization and efficiency.
53:47 Architectural requirements for operating systems
57:41 Operating System Booting and Memory
59:39 Non-preemptive processes have better response time
1:03:42 Learn about mode shifting via API and SCI
1:05:57 Understanding the difference between print F in header and library files
1:10:28 Shift mode from user to kernel to access fork services
1:12:39 SVC and Interrupts in Operating Systems
1:16:58 Understanding how mode shifting is essential in operating systems.
1:18:51 Operating system mode shifting and system calls
1:22:39 Understanding kernel mode and user mode operation
1:24:33 Explanation of child process creation using Fork
1:28:52 Difference between a program and a process
1:30:58 Compilation process converts high-level code into low-level instructions
1:35:20 Dynamic array implementation in C using Maloc
1:37:31 Process is the program in execution using computer resources.
1:41:34 Program consists of instruction and data, with data types static and dynamic.
1:43:36 Activation records in function calls
1:47:40 Learning VSS extension and process operations
1:49:40 Transition diagram states and process attributes
1:53:47 Understanding Process Control Block (PCB) and Process Lifetime Stages
1:56:02 Understanding resource deallocation and process states
2:00:15 Operating systems shift processes from main memory to hard disk to manage clutter.
2:02:35 Process transitions from ready to waiting to running state in an OS
2:06:58 Processes go directly to running state with no ready stage
2:09:16 Resource allocation and deallocation in main memory
2:13:42 Transferring processes from Main memory to disk
2:15:47 Ready state is the most desirable for suspension
2:20:07 Understanding process states in Operating Systems
2:22:03 Processes transitioning in the operating system
2:25:53 Transition from suspended block to ready state involves swapping/loading to bring process back to main memory
2:27:46 Operating system resumes process based on resource availability
2:32:03 Explaining the concept of block and device queues in memory management.
2:34:12 Overview of Scheduling Cues in Operating Systems
2:38:16 Dispatcher controls CPU execution for selected process.
2:40:23 Schedulers in Operating Systems
2:44:46 Process Switching
2:46:53 Overview of schedulers and dispatcher in Operating Systems
2:50:58 Understanding arrival time and waiting time in an Operating System
2:52:48 Understanding process state transitions and timing
2:56:56 Preemptive scheduling allows for infinite possible ways to schedule processes.
2:58:50 Schedule Length Calculation
3:02:38 Understanding turnaround time in process scheduling
3:04:32 Discussing scheduling and its types
3:08:44 Introduction to Process Scheduling
3:10:49 The Gant chart always starts from zero.
3:15:02 Calculating waiting time in Operating Systems
3:17:00 Scheduling processes based on arrival time and execution time
3:21:04 Understanding Gantt chart and CPU idleness
3:23:07 Calculate percentage CPU idleness over schedule length
3:27:11 Understanding the life cycle of a process in Operating Systems
3:29:22 Process scheduling involved loading from ready to running via dispatcher
3:33:38 Understanding process scheduling and completion times in operating systems
3:35:48 Understanding the distinction between transit time and waiting time is crucial.
3:40:17 Calculate waiting time from chart, not formula
3:42:22 Understanding process transition from ready to running and then block in Operating Systems
3:46:38 Process scheduling and termination process in an operating system
3:48:37 Dispatcher time and process scheduling overview
3:52:46 Tips for solving process transition questions
3:54:47 Understanding CPU idleness and scheduling processes
3:58:47 Calculate CPU overhead for given process scheduling
4:00:45 Homework questions for CPU efficiency and scheduling overhead
4:04:54 Process transitions in an operating system
4:06:48 Scheduling processes with single IO device
4:10:32 Shortest Job First (SJF) prioritizes processes with the least burst time.
4:12:26 Scheduling in non-preemptive algorithms
4:16:18 Scheduling processes based on burst time and process ID.
4:18:09 Understanding the shortest job first (SJF) algorithm and its preemptive version (SRTF)
4:22:02 SRTF scheduling preempt shorter burst times
4:23:49 Understanding Preemption in SRTF Scheduling
4:27:34 SRTF scheduling algorithm involves checking every time a new process arrives
4:29:33 Scheduling and preemption in operating systems
4:33:32 SGF and SRTF algorithms are optimal
4:35:39 Calculating optimal average waiting time using Shortest Job First algorithm (SJF)
4:39:28 Calculate waiting time for processes based on scheduling order.
4:41:23 Predicting burst time using static and dynamic techniques
4:45:48 Explaining recurrence relation and initial guess concept
4:47:43 Prediction techniques for CPU burst time
4:51:55 Processes with high response ratio are given priority in HRR algorithm
4:54:02 Discussing unfairness in process scheduling based on bus time
4:58:11 Longest remaining time first (LRTF) algorithm is the opposite of SRTF, scheduling the longest process first.
5:00:13 SRTF scheduling prioritizes processes based on remaining burst time
5:04:32 Processes scheduling based on remaining burst time and process ID
5:06:23 Scheduling based on burst time and process IDs
5:10:04 Scheduling jobs using Shortest Job First algorithm
5:12:03 Introduction to priority-based scheduling algorithm
5:16:06 Priority scheduling in Operating Systems
5:18:10 Scheduling processes based on priority levels
5:22:12 Scheduling based on priority and completion time
5:24:08 Understanding the priority and scheduling of processes
5:28:10 Introduction to Round Robin algorithm
5:30:13 In round robin scheduling, processes have to leave after the time quantum
5:34:20 Scheduling multiple processes based on time Quantum
5:36:28 Scheduling new and preemptive processes
5:40:20 Scheduling processes based on arrival times and time quantum in round-robin algorithm.
5:42:16 Schedule of processes in the RQ
5:46:22 Efficiency drops to zero with small time Quantum in operating systems
5:48:32 Determining the suitable time quantum for round-robin scheduling
5:53:05 Understanding the implications of different values of Q in the context of CPU scheduling
5:55:39 Understanding CPU scheduling and time quantum
6:00:00 Explaining CPU scheduling and response time calculation
6:02:18 Calculation of response time in CPU scheduling
6:06:37 Different scheduling algorithms applied to different queues based off priorities
6:08:44 Processes penalized based on running time
6:12:46 Interprocess communication (IPC) is essential for communication between processes.
6:14:48 Synchronization is performing an agreed action.
6:19:00 Synchronization is the coordination of concurrent processes.
6:21:07 Synchronization in Operating Systems
6:25:20 Understanding the producer-consumer problem
6:27:29 Understanding process synchronization and deadlock
6:31:49 Understanding preemption and process execution
6:33:49 Understanding race conditions and synchronization
6:38:03 Importance of Correct Results in Processes
6:40:09 Producer places item onto buffer when buffer is not full
6:44:25 Understanding the circular buffer concept in operating systems.
6:46:20 Implementation of producer and consumer in C language
6:50:35 Stagnant water and mosquitoes are the main culprits for malaria spreading.
6:52:32 Synchronization requires critical sections and race conditions.
6:56:49 Security guard manages access to critical section
6:58:55 Requirements of Critical Section Problem
Please move ahead and make this for all remaining parts of the lecture. This is very helpful for understanding a particular topic while revising.
My respect to ALL teachers that give knowledge for free. This 25 hour course is an absolute gold mine for CS students like me and others who will tread on the path or wants to learn.
Sir u are the man u gives course for free without any expectation from us tq
It's because all of the subscribers they have. They still make money off of this.
38:00-40:46 preemption
55:30 DPP
1:03:57 implementation of mode shifting via api/sci
1:09:00 mode shifting 1:18:53 flowchart
1:21:12 DPP
1:29:00 section2
1:40:39 developer perspective
1:49:40 transaction state dig
2:30:30 scheduling queue
2:35:20 state queueing dig
this channel is truly a gem for those who wanna gain knowledge as much as they can
I have started watching it, I will also add timestamps.
00:00 Intro to OS
21:40 Types of OS
// I think its a good lecture:)
01:00:53 mode shifting
This is interesting, a whole course on computer operating systems available on RUclips. Computer operating systems have changed a lot over the years and have gotten a lot larger and a lot more loaded with features as the computer hardware has advanced over the years. The simplest operating system I ever worked with many years ago was CP/M on a Heathkit H89 computer with a Z80 cpu. That operating system only took up about 8k of memory. I am now using an Apple Mac Studio computer with Mac OS Sonoma that the Activity Monitor program says has 1.6 gb of wired memory.
Thanks!
rightnow iam doing this course in the uni but don't know why i wanna learn from u its easy when u teach it
I'm ready for that course thank you for that free course ❤
❤
Amazing🎉 need more like this on RDBMS and Computer Networking. Guys please suggest if you know someone
Thanks bro @@thehustlersarena1401
One of the best os course on RUclips
Thanks to freecodecamp and Kshitij Sharma Sir for providing such a wonderful lecture on Operating Systems. This lecture covers all the topics of Operating systems in depth and the way you explained is commendable and would look after for more such videos to gain valuable lessons..
well, this is the most insane Dev & tech place on internet. great job masters
Just finished all of it
Loved it thanks
😂😂
Impressive, how can you follow the Video in 200x
😁🤣
Don't flex like this 😂
This course is amazing. Thank you very much!
thank you. this is extremly helpful for my exam and understanding about os
Chapter-01
0:03:43 Lecture 01
0:21:38 Lecture 02
0:55:05 Question Solve
1:00:51 Lecture 03
Respect to this teacher who uploaded whole course in one video instead of making 50 videos for views
Knowledge worthing 1000 hours.
Thank god. bro pulled up when i needed him the most!
Really appreciate the course, lecturer's why why analysis is very helpful in understanding the concept clearly.
You are uploading so many great courses here, how many more lifetimes will I have to live to see them all?😢
This is why I donated . Goated content. If yall got an extra 5 bucks a month donate
I will keep editing as I complete this video
0:0:32 lecture starts
0:21:39 uniprogramming vs multiprogramming in os
00:51:15 LECTURE 2 REVISION
00:54:55 DPP 1 answers
01:00:52 lecture 3
01:21:21 DPP 2 answers
--------------------------------------
01:29:00 section 2 process management
02:29:30 lecture 8(acc to vid) revision
2:30:34 lect 10 first come first serve
4:10:56 shortest job first
wow amazing for indians aspiring students for gate exam
Please don't stop posting videos😊😊. Love this channel.
Guys ..the sir is from IIT bambay and from electrical engineering branch
oo
❤
I am 1 hour in, and I gotta say this is so fire🔥the way he explains it is awesome
Let's challenge ourselves to finish it😊
I am seven hours in and I can see why this course is 25 hours. Don't get me wrong it is a good course and covers a lot of material but there is lots of repetition and use of analogies that I don't think are necessary to get the point across. Thank you for making this great free resource!
Disagree. The analogies helped. I think the repetition was a bit much at some points but you can always 2x or fast-forward if it feels like hes rambling or you immediately grasp a concept, because I appreciated the repetition on concepts I didn't fully understand right away...
25 hours is overwhelming, but worth watching, thank you!
16:18:39 download class notes from here
Like how possible is someone uploading 25 hours of pure knowledge for free
You're a legend for this!
😆 Preemption and Rollback as Aryurvedic Doctors . I love you man you made so easy, you the goat fr 14:00:47
Timestamps for this video (put all in one place, thanks to others for doing the hardwork making the stamps.
Overview
⌨ (00:00:00) Welcome to the Course
⌨(00:03:43) Introduction and Background
⌨(01:28:56) Process Management
⌨ (02:47:34) CPU Scheduling
⌨(06:12:23) Process Synchronization
⌨(12:32:14) Deadlock
⌨(14:20:29) Memory Management
⌨(21:20:28) File Management
⌨(23:43:16) Miscellaneous Topics
00:02 Comprehensive operating system course covering fundamental and advanced concepts.
02:41 Operating Systems Course overview and guidelines
07:28 ALU performs arithmetic and logical functions.
09:44 Operating system loads the executable file from hard disk to main memory for CPU execution.
14:33 Operating system acts as a resource manager
16:51 Operating system controls everything in the computer.
21:07 Operating system acts as a resource manager and government in controlling program applications.
23:05 Uni programming OS allows only one program in memory, leading to CPU idle time.
27:26 Multiprocessor systems run one program at a time
29:33 Schematic view of multiprogramming operating system
33:30 Difference between uniprocessor and multiprocessor systems
35:22 Multiprogramming increases CPU utilization and efficiency
39:25 Process Management in Operating Systems
41:30 Secondary storage devices need to be DMA compatible and support address translation for efficient data transfer.
45:49 Privileged processes in operating systems
47:57 Mode shifting is necessary for user applications to access OS kernel level services.
52:05 Multiprogramming increases CPU utilization and efficiency.
53:47 Architectural requirements for operating systems
57:41 Operating System Booting and Memory
59:39 Non-preemptive processes have better response time
1:03:42 Learn about mode shifting via API and SCI
1:05:57 Understanding the difference between print F in header and library files
1:10:28 Shift mode from user to kernel to access fork services
1:12:39 SVC and Interrupts in Operating Systems
1:16:58 Understanding how mode shifting is essential in operating systems.
1:18:51 Operating system mode shifting and system calls
1:22:39 Understanding kernel mode and user mode operation
1:24:33 Explanation of child process creation using Fork
1:28:52 Difference between a program and a process
1:30:58 Compilation process converts high-level code into low-level instructions
1:35:20 Dynamic array implementation in C using Maloc
1:37:31 Process is the program in execution using computer resources.
1:41:34 Program consists of instruction and data, with data types static and dynamic.
1:43:36 Activation records in function calls
1:47:40 Learning VSS extension and process operations
1:49:40 Transition diagram states and process attributes
1:53:47 Understanding Process Control Block (PCB) and Process Lifetime Stages
1:56:02 Understanding resource deallocation and process states
2:00:15 Operating systems shift processes from main memory to hard disk to manage clutter.
2:02:35 Process transitions from ready to waiting to running state in an OS
2:06:58 Processes go directly to running state with no ready stage
2:09:16 Resource allocation and deallocation in main memory
2:13:42 Transferring processes from Main memory to disk
2:15:47 Ready state is the most desirable for suspension
2:20:07 Understanding process states in Operating Systems
2:22:03 Processes transitioning in the operating system
2:25:53 Transition from suspended block to ready state involves swapping/loading to bring process back to main memory
2:27:46 Operating system resumes process based on resource availability
2:32:03 Explaining the concept of block and device queues in memory management.
2:34:12 Overview of Scheduling Cues in Operating Systems
2:38:16 Dispatcher controls CPU execution for selected process.
2:40:23 Schedulers in Operating Systems
2:44:46 Process Switching
2:46:53 Overview of schedulers and dispatcher in Operating Systems
2:50:58 Understanding arrival time and waiting time in an Operating System
2:52:48 Understanding process state transitions and timing
2:56:56 Preemptive scheduling allows for infinite possible ways to schedule processes.
2:58:50 Schedule Length Calculation
3:02:38 Understanding turnaround time in process scheduling
3:04:32 Discussing scheduling and its types
3:08:44 Introduction to Process Scheduling
3:10:49 The Gant chart always starts from zero.
3:15:02 Calculating waiting time in Operating Systems
3:17:00 Scheduling processes based on arrival time and execution time
3:21:04 Understanding Gantt chart and CPU idleness
3:23:07 Calculate percentage CPU idleness over schedule length
3:27:11 Understanding the life cycle of a process in Operating Systems
3:29:22 Process scheduling involved loading from ready to running via dispatcher
3:33:38 Understanding process scheduling and completion times in operating systems
3:35:48 Understanding the distinction between transit time and waiting time is crucial.
3:40:17 Calculate waiting time from chart, not formula
3:42:22 Understanding process transition from ready to running and then block in Operating Systems
3:46:38 Process scheduling and termination process in an operating system
3:48:37 Dispatcher time and process scheduling overview
3:52:46 Tips for solving process transition questions
3:54:47 Understanding CPU idleness and scheduling processes
3:58:47 Calculate CPU overhead for given process scheduling
4:00:45 Homework questions for CPU efficiency and scheduling overhead
4:04:54 Process transitions in an operating system
4:06:48 Scheduling processes with single IO device
4:10:32 Shortest Job First (SJF) prioritizes processes with the least burst time.
4:12:26 Scheduling in non-preemptive algorithms
4:16:18 Scheduling processes based on burst time and process ID.
4:18:09 Understanding the shortest job first (SJF) algorithm and its preemptive version (SRTF)
4:22:02 SRTF scheduling preempt shorter burst times
4:23:49 Understanding Preemption in SRTF Scheduling
4:27:34 SRTF scheduling algorithm involves checking every time a new process arrives
4:29:33 Scheduling and preemption in operating systems
4:33:32 SGF and SRTF algorithms are optimal
4:35:39 Calculating optimal average waiting time using Shortest Job First algorithm (SJF)
4:39:28 Calculate waiting time for processes based on scheduling order.
4:41:23 Predicting burst time using static and dynamic techniques
4:45:48 Explaining recurrence relation and initial guess concept
4:47:43 Prediction techniques for CPU burst time
4:51:55 Processes with high response ratio are given priority in HRR algorithm
4:54:02 Discussing unfairness in process scheduling based on bus time
4:58:11 Longest remaining time first (LRTF) algorithm is the opposite of SRTF, scheduling the longest process first.
5:00:13 SRTF scheduling prioritizes processes based on remaining burst time
5:04:32 Processes scheduling based on remaining burst time and process ID
5:06:23 Scheduling based on burst time and process IDs
5:10:04 Scheduling jobs using Shortest Job First algorithm
5:12:03 Introduction to priority-based scheduling algorithm
5:16:06 Priority scheduling in Operating Systems
5:18:10 Scheduling processes based on priority levels
5:22:12 Scheduling based on priority and completion time
5:24:08 Understanding the priority and scheduling of processes
5:28:10 Introduction to Round Robin algorithm
5:30:13 In round robin scheduling, processes have to leave after the time quantum
5:34:20 Scheduling multiple processes based on time Quantum
5:36:28 Scheduling new and preemptive processes
5:40:20 Scheduling processes based on arrival times and time quantum in round-robin algorithm.
5:42:16 Schedule of processes in the RQ
5:46:22 Efficiency drops to zero with small time Quantum in operating systems
5:48:32 Determining the suitable time quantum for round-robin scheduling
5:53:05 Understanding the implications of different values of Q in the context of CPU scheduling
5:55:39 Understanding CPU scheduling and time quantum
6:00:00 Explaining CPU scheduling and response time calculation
6:02:18 Calculation of response time in CPU scheduling
6:06:37 Different scheduling algorithms applied to different queues based off priorities
6:08:44 Processes penalized based on running time
6:12:46 Interprocess communication (IPC) is essential for communication between processes.
6:14:48 Synchronization is performing an agreed action.
6:19:00 Synchronization is the coordination of concurrent processes.
6:21:07 Synchronization in Operating Systems
6:25:20 Understanding the producer-consumer problem
6:27:29 Understanding process synchronization and deadlock
6:31:49 Understanding preemption and process execution
6:33:49 Understanding race conditions and synchronization
6:38:03 Importance of Correct Results in Processes
6:40:09 Producer places item onto buffer when buffer is not full
6:44:25 Understanding the circular buffer concept in operating systems.
6:46:20 Implementation of producer and consumer in C language
6:50:35 Stagnant water and mosquitoes are the main culprits for malaria spreading.
6:52:32 Synchronization requires critical sections and race conditions.
6:56:49 Security guard manages access to critical section
6:58:55 Requirements of Critical Section Problem
7:03:18 Critical section must have bounded waiting for interested processes.
7:05:23 Differentiating synchronization mechanisms as solutions or not
7:09:41 Introduction to lock variable as a synchronization mechanism
7:11:56 Implementing locking mechanism for mutual exclusion
7:16:17 Understanding the critical section and entry process.
7:18:41 Explanation of lock variable implementation
7:23:14 Preemption and lock value changes in a multi-process scenario
7:25:27 Importance of Lock in Ensuring Mutual Exclusion
7:29:39 Lock variable leads to wastage of CPU time.
7:31:52 Importance of critical section and preventing wastage of CPU cycles
7:36:22 Strictly alternate process execution for critical section access
7:38:28 Understanding mutual exclusion and the turn variable
7:42:40 Uninterested processes hinder the progress of interested processes
7:44:41 Explanation of mutual exclusion and bounded waiting in synchronization mechanisms
7:48:53 Concept of flag and turn for process synchronization
7:51:03 Understanding the concept of turn and flag in the context of processes.
7:55:26 Peterson solution is about the critical section and updating turn value.
7:57:38 Discussing process scheduling and completion of sections
8:01:49 Peterson solution ensures non-interested processes do not hinder progress
8:03:57 Peterson solution ensures mutual exclusion
8:08:08 Ensuring mutual exclusion and progress in operating systems.
8:10:16 Understanding the impacts of initialization on process turns
8:14:35 Decker's algorithm in operating systems
8:16:45 Algorithm provides mutual exclusion and progress
8:21:01 Explanation of Deadlock in Operating Systems
8:23:11 Discussion on bounded waiting and strict alternation
8:27:15 Discussing Test and Set Lock functionality
8:29:27 Explanation of TSL operation and its impact on critical section execution.
8:33:24 Swap mechanism based on lock and key ensures atomic execution
8:35:20 Understanding the process of swapping using a temporary variable.
8:39:16 Swap mechanism guarantees Mutual exclusion and progress
8:41:17 Test and set provides mutual exclusion
8:45:22 Priority inheritance solves deadlock in critical sections
8:47:30 Fetch and add X, I is an atomic read modify write instruction.
8:51:39 Understanding synchronization mechanisms and problem-solving
8:53:35 Understanding how L=0 and L!=1 affect log value increments.
8:57:25 Demonstration of Mutual exclusion and prevention of overflow
8:59:14 Preemption strategy in entry section
9:03:06 Understanding overflow in processes
9:05:15 FCFS doesn't suffer from starvation except for infinite loops
9:09:32 Sleep and wake up is a blocking mechanism in multiprocess solutions
9:11:33 Solving the producer-consumer problem using non-busy waiting solution
9:15:38 Implementing consumer functionality in operating systems
9:17:37 Understanding preemptive process scheduling
9:21:38 Semaphore - Definition and Types
9:23:51 Explanation of the down operation in kernel mode
9:28:16 Positive value of SEMA 4 indicates successful down operations, negative value indicates blocked processes
9:30:09 Understanding how sema4 provides Mutual exclusion
9:34:03 The objective of up operation is to wake up a sleeping process
9:36:01 Understanding the conditions for waking up processes
9:40:04 Using SEMA 4 helps manage concurrent requests effectively.
9:42:10 Managing Processes with Counting Semaphores
9:46:05 Understanding down operation in binary semaphores
9:48:05 Understanding the process blocking and synchronization
9:51:58 Understanding value changes in critical sections
9:53:57 Explanation of binary semaphore operations
9:58:13 Semaphore 4 and its operations
10:00:07 Ensuring mutual exclusion and progress in critical section
10:04:17 Preemption in semaphores can lead to deadlock.
10:06:27 Preempting processes to prevent deadlock
10:10:53 Process synchronization using down and up operations
10:13:07 Implication of strict alternation for mutual exclusion
10:17:22 Demonstrating mutual exclusion and deadlock in operating systems.
10:19:24 Understanding a scenario leading to deadlock and semaphore initialization
10:23:44 Explaining the limitations of processes without a while loop.
10:26:03 Determining minimum and maximum value of variable C in a concurrent process scenario
10:30:29 Understanding deadlock in operating systems
10:32:29 Discussing synchronization and mutual exclusion in operating systems.
10:36:25 Concurrency issues in race condition
10:38:41 Processes changing values and storing them
10:42:56 Understanding implementation using semaphores
10:44:56 Operating System synchronization in producer-consumer scenario
10:49:16 Understanding the deadlock and order importance in synchronization problems.
10:51:21 Understanding synchronization problem in operating systems
10:55:26 Producer adds item to buffer but consumer can't consume
10:57:32 Consumer removing one item at a time from buffer
11:01:20 Reader Writer problem and its solution using semaphores
11:03:29 Starvation of writers in database access
11:07:47 Database locking mechanism for readers and writers
11:09:55 Understanding the use of mutex and database for accessing the critical section.
11:14:10 Solving reader-writer problem using Mutex
11:16:05 Semaphore used to solve reader-writer problem
11:19:55 Implementation of Dining Philosopher problem
11:21:59 Philosophers sharing forks for eating efficiency
11:26:06 Preventing deadlocks by changing philosopher pattern
11:28:07 Preventing deadlock by changing paths
11:32:26 Statements can be executed concurrently if they are independent.
11:34:49 Understanding concurrency and parallelism
11:39:01 Concurrency and parallelism in operating systems
11:41:05 Understanding concurrent execution in Operating Systems
11:45:28 Understanding read set and write set for concurrent statements
11:47:38 Understanding the difference between sequential and concurrent execution using pair begin and pair end
11:51:57 Dependent nodes cannot always be considered concurrent.
11:54:10 Exploration of handling dependencies and contradictions in program execution
11:58:17 Acquiring keys in executing statements
12:00:23 Understanding the dependency between locks in executing sequence of commands.
12:04:41 Understanding key requirements for locks in the given scenario.
12:06:52 Understand the importance of valid sequences in executing concurrent tasks
12:11:11 Updating values of x and y in a sequence
12:13:30 Understanding binary semaphore and sequentiality in execution.
12:17:51 Understanding the concepts of Fork and Join in operating systems.
12:20:00 Explaining how to branch instructions in Fork
12:23:48 Understanding control flow in Operating Systems.
12:25:53 The process synchronization section is over.
12:29:45 Value of counter depends on thread execution
12:31:40 Deadlock is when two or more processes are waiting for an event that is never going to happen.
12:35:51 Deadlock explained with a meme
12:38:00 Deadlock occurs when a process is blocked forever due to resource unavailability.
12:42:14 Four necessary conditions for deadlock
12:44:24 Circular wait is not a sufficient condition for deadlock
12:48:49 Understanding resource allocation and blocking in Operating Systems
12:50:53 Preventing Deadlocks by Resource Release
12:55:03 Deadlock prevention strategies are crucial for critical operating systems.
12:57:11 Deadlock prevention negates necessary conditions
13:01:32 Efficient resource utilization through protocol 2
13:03:52 Forceful preemption and self preemption prevent deadlock
13:08:11 Resource preemption is crucial for avoiding circularity and maintaining linearity.
13:10:07 Understanding the necessity of cycles in resource allocation
13:14:27 Resource allocation graph aims to maintain a safe state
13:16:40 Understanding safe and unsafe states in resource allocation
13:20:51 Understanding Safety Algorithm and Resource Request Algorithm Basics
13:23:36 Understanding resource allocation in operating systems
13:28:25 Resource allocation and satisfaction process summarized.
13:30:35 Understanding the Banker algorithm for multiple resources with multiple instances.
13:34:55 Proving the existence of multiple CF sequences
13:37:07 Multiple safe sequences can exist with Banker's algorithm
13:41:32 Updating resource allocation and running the safety algorithm
13:43:54 Resource allocation and availability
13:48:10 Applying safety algorithm to check system state based on resource values
13:50:28 Satisfied the need for resources
13:54:59 Deadlock in single instance and multi-instance resource allocation
13:57:13 Achieving safe state by satisfying process requests
14:01:40 Resource preemption and process recovery
14:03:49 Deadlock avoidance strategies
14:08:12 Maximum resources for deadlock is 36, minimum for deadlock freedom is 37
14:10:22 Understanding unsafe state vs deadlock in resource allocation graphs
14:15:02 Ensure system can satisfy minimum resource requests to avoid deadlock
14:17:05 Resource allocation using Bankers algorithm
14:21:23 Understanding the hierarchy of memory sizes and functions of RAM in operating systems
14:23:44 Memory size calculation based on number of words and word size
14:27:57 Understanding data representation using bits and bytes
14:30:11 Explaining memory size in bits and bytes
14:34:40 Addressing Memory Blocks in Operating Systems
14:36:45 Understanding memory size and word addressing
14:40:51 Understanding the purpose and operation of the bus, chip select, and address bus in a computer system
14:42:57 Static and dynamic loading in operating systems
14:47:13 Resolving External References
14:49:25 Linker module fills up blank addresses in program code.
14:53:53 Dynamic linking allows for flexibility and code reusability
14:56:10 Difference between static and dynamic linking
15:00:45 Understanding different types of binding in Operating Systems.
15:03:02 Static and dynamic binding in operating systems
15:07:23 Address binding provides relocation flexibility at runtime.
15:09:33 Static binding vs. dynamic binding
15:13:44 Memory management fundamentals from older theories
15:15:54 Memory manager goals to minimize wastage and utilize memory effectively
15:20:20 Understanding memory overlay and its application
15:22:41 Explaining partitioning in Operating Systems.
15:26:54 Base plus limit architecture to ensure protection
15:29:05 Overview of old and new techniques in Operating Systems
15:33:22 Fixed partition leads to internal fragmentation and limited multiprogramming.
15:35:25 Dynamic partitioning allows for flexible memory allocation
15:39:35 External Fragmentation and Solutions
15:41:39 Resolve external fragmentation by reallocating memory and creating a bigger free hole
15:45:35 Variable partitioning and best fit allocation in memory systems
15:47:35 Memory allocation strategies
15:51:55 Operating Systems manages process table and memory partitions
15:54:09 Process table size calculation for 500 processes.
15:58:31 Scheduling and memory management using FCFS
16:00:32 Explaining memory allocation based on program size
16:04:24 Understanding non-continuous allocation
16:06:27 Introduction to Variable Partitioning for memory management
16:10:41 Differences between logical address and physical address
16:12:53 Memory management involves converting logical addresses to physical addresses.
16:17:11 Memory management unit handles address translation
16:19:26 Pages and Page Size Calculation
16:24:18 Understanding page offset and page number in memory addressing
16:26:37 Logical address format explained with page number and page offset
16:31:02 Understanding the concept of frames and pages in memory management.
16:33:13 Understanding logical address space and physical address space division
16:37:42 Finding physical address space using page size and frame size.
16:39:53 Understanding address translation in Operating Systems
16:44:06 Page table contains the frame number where pages are stored.
16:46:21 Understanding Page Table in Operating Systems
16:50:37 Paging technique for accessing physical memory
16:52:51 Understanding virtual memory and page table size
16:57:30 Calculating page offset and physical address space size in a computer system using paging technique
16:59:47 Determining page size and number of pages in simple paging technique.
17:04:07 Page table size calculation and performance impacts
17:06:20 Main memory access time (M) is crucial for CPU operations
17:10:46 Cache memory access time is less than main memory access time
17:12:40 Introduction to cache memory and effective access time
17:16:55 Defined hit and miss ratio for effective memory access time
17:19:12 Understanding TLB and PSC in CPU processing
17:23:30 Optimizing memory access using TLB and physical address
17:25:37 Page table size can be reduced by increasing page size
17:30:07 Finding the optimal page size for minimal internal fragmentation and page table size.
17:32:17 Optimal page size affects page table size and internal fragmentation
17:37:10 Memory division into units and load time calculation
17:39:33 Calculating CPU Time Fraction for Loading Page Table
17:43:41 Dividing program into pages and calculating required pages for text, data, and stack sections
17:45:50 Calculating number of pages based on address space and page size
17:50:07 Introduction to Hashed Page Table
17:52:19 Collision resolution technique using chaining
17:56:31 VUM architecture involves tradeoff between space and time
17:58:35 Introduction to Simple Paging and Performance Analysis
18:03:04 Page table divided into chunks for reducing size
18:05:07 Handling memory paging and chunk storage in page table
18:09:19 Reduction in space overhead by using multi-level paging
18:11:41 Introduction to Paging in Operating Systems
18:15:56 Page table divided into chunks stored in main memory frames
18:18:08 Reducing space overhead through paging
18:22:23 Dividing logical address space into chunks and pages
18:24:29 Explanation of two-level paging system
18:28:35 Understanding multi-level paging in operating systems
18:30:36 Paging is about optimizing space while sacrificing time.
18:34:26 Introduction to paging in Operating Systems.
18:36:37 Understanding page storage and frame representation in inner and outer page tables.
18:40:42 Explanation of how addressing is done
18:42:49 Paging incurs memory overhead due to page tables
18:46:58 Understanding the virtual address format in page tables.
18:49:06 Dividing the address space into chunks to determine page and table size
18:53:00 Calculating number of entries in inner and outer page tables.
18:55:15 Determining the number of levels for virtual to physical address translation
18:59:19 Understanding multi-level paging for operating systems.
19:01:31 Users view of memory location is not preserved
19:05:42 Understanding page table and logical address generation
19:07:52 Addressing and converting logical to physical
19:11:56 Understanding Segmentation in Operating Systems
19:13:55 Segmentation converting logical address to physical address
19:18:15 External fragmentation in segmentation and its solutions
19:20:21 Virtual memory illusion of having more memory available than physical memory
19:24:36 Understanding Page Hit and Page Miss in Memory Management
19:26:32 Process gets blocked due to page not present in memory
19:30:21 Demand paging is used in all operating systems like Windows, Mac, and Unix.
19:32:25 Understanding the memory hierarchy and virtual memory management
19:36:53 Effective access time calculation
19:38:59 Handling page faults in memory management.
19:43:15 Understanding effective instruction time calculation
19:45:34 Replacing victim frames with modified pages and handling different cases.
19:49:55 Understanding paging system and memory access in operating systems
19:52:11 Explanation of effective memory access time and handling TLB miss and page fault
19:56:34 Understanding frame allocation policies and calculation of demand frames
19:58:52 Policies ensure fair allocation based on demand and availability
20:03:18 Understanding page faults and memory allocation in Operating Systems
20:05:37 Calculation of page faults and fault rate
20:10:02 Increasing frames may increase page faults
20:12:14 Page faults due to Pure Demand Paging
20:16:34 Using pure demand paging to manage page faults.
20:18:45 Increasing frames reduces page faults, optimal replacement necessary.
20:23:01 Page replacement algorithms in operating systems
20:25:14 Replacement process in an operating system
20:29:17 Understanding page table entry attributes and epoch in operating systems.
20:31:38 LRU approximation using reference bit
20:35:48 Understanding how the second chance or clock algorithm selects victims based on time of loading and reference bit.
20:37:54 Implementing victimization and reference bit in page replacement algorithms
20:41:57 Exploring page table structure and selection of victim pages based on different algorithms
20:44:01 Increasing page frames may increase or decrease page faults
20:48:20 Threshing is a consequence of excessive paging activity.
20:50:23 High page fault rate leads to process blocking
20:54:25 Threshing is a result of high disk utilization and degree of multiprogramming
20:56:53 Understanding row major order in storing matrices
21:01:20 Explanation of page faults and memory storage
21:03:35 Swapping variables affects page faults
21:07:49 Writing program, data structures, algorithms affect thrashing rate
21:09:55 Understanding Working Set Window
21:14:16 Choosing the right Delta value is crucial for effective memory utilization.
21:16:22 Calculating working set window for page faults
21:21:07 Understanding the physical structure of a disk in an operating system.
21:23:17 Disk storage consists of rotating platters and read/write heads
21:27:33 Understanding seek time and track time in disk IO
21:29:42 Explaining seek time and rotational latency in disk operations
21:34:01 Understanding the disk specifications and calculating uniform capacity
21:36:20 Calculating transfer time and data transfer rate in disk I/O
21:40:44 Utilizing maximum density for varying track lengths
21:42:53 Calculating transfer time for loading a program from disk to memory
21:47:29 Analyzing page load times based on distribution and continuity
21:49:33 Disk rotation is minimized for continuous data layout on disk.
21:53:51 Importance of formatting disk for effective storage and retrieval
21:55:51 Understanding Primary and Extended/Logical Drives in Operating Systems
22:00:00 Understanding booting and partition structures
22:02:12 Understanding partitioning and boot control
22:06:38 Understanding directory structure and metadata in operating systems
22:08:45 Understanding multi-level directories in operating systems
22:12:51 File system implementation in a layered fashion
22:15:07 The I/O control level and basic file system operations in an operating system.
22:19:26 Methods of disk space allocation
22:21:41 Increasing file size is inflexible due to external fragmentation
22:25:56 Understanding indexed allocation in file systems
22:28:14 File management in Unix/Linux using i-nodes
22:32:57 Master file table stores block address information for file storage
22:35:03 Understanding the hierarchy of direct, single indirect, double indirect, and triple indirect disk block addresses.
22:39:43 Using larger block size improves disk throughput but increases internal fragmentation
22:41:56 Understanding file allocation table and its impact on maximum file size
22:46:35 Understanding file allocation and maximum file size calculation
22:48:45 Calculating maximum file size and number of blocks
22:53:18 Understanding the concept of free list and bit map in operating systems.
22:55:30 Allocating blocks for storage
22:59:53 The size of the free list is determined by the address size and the number of free blocks.
23:02:17 Understanding file allocation with bit maps and hex codes
23:06:39 Smallest cache required for average read latency < 6ms
23:08:51 Page storage space related to maximum processes, virtual address space, and RAM
23:13:14 Choosing the closest track for least seek time
23:15:30 Discussing disk scheduling algorithms
23:19:50 C-LOOK algorithm serves requests in one direction only
23:22:02 Algorithm focuses on efficient disk request servicing without needing extreme movements.
23:26:21 Power dissipation negligible due to rotational latency and head switching
23:28:19 Efficient track switching and power dissipation in operating system course
23:32:42 Calculating total power dissipation for seek time
23:34:51 Understanding disk access scheduling algorithms
23:39:23 Calculating decision time for pending requests using FCFS algorithm
23:41:24 Disk scheduling algorithms discussed for Operating Systems course
23:45:50 Sharing code and resources via threads to avoid redundancy
23:48:01 Threads share resources but have separate registers and stacks
23:52:18 Multi-threading brings responsiveness and resource sharing.
23:54:28 Multi-threading is more economical and efficient than multiprocessing.
23:58:50 Threads vs Process
24:01:12 Global variables for inter-thread communication
24:05:29 Benefits and drawbacks of user level threads independence on operating system
24:07:38 Kernel level threads provide true parallelism
24:11:49 Methods to Pass Parameters from User to Kernel
24:13:48 Understanding system calls related to process, file, and directory management.
24:18:05 Understanding the execution flow after fork statement
24:20:14 Understanding the execution order in fork process
24:24:34 Explaining the creation of child processes based on return value
24:26:46 Working with if block in an Operating System course
24:31:21 Discussing the execution of a for loop and creation of child processes based on conditions.
24:33:41 Understanding fork process in operating systems
24:38:06 Relation between virtual and physical addresses in child and parent processes
24:40:17 Virtual address space and paging concept
24:44:31 Comparing traditional vs. inverted page table sizes
24:46:40 Designing a global page table for memory management
24:50:38 Comparison between traditional and inverted page table size
Thank you indian tech people for all that you do 🙏🏻
U r great man❤❤
Hats off for your selfless contribution
- **Defining an OS:**
- 5 Definitions of an Operating System
- Von Neumann Architecture
- Stored Program Concept
- Significance of Main Memory
- OS as Interface
- OS Kernel
- OS as Resource Manager
- OS as Control Program
- **Types of OS:**
- Uni-programming vs. Multiprogramming
- Degree of Multiprogramming
- Addressing CPU Idleness
- Throughput
- Schematic View of Multiprogramming
- Types of Multiprogramming OS
- Comparison between Multiprogramming and Multitasking OS
- Architectural Requirements for Implementing Multitasking OS
- Kernel & User Mode
- **User and Kernel Mode Shifting:**
- APIs
- Fork System Call
- Interrupts
- ISR
- PSW
- Types of Functions
- Perspective on Mode Shifting
---
**Process Management:**
- **Understanding Processes:**
- Distinguishing Between Program and Process
- Key C Concepts
- 7 Definitions of Process
- Treating Process as an ADT (Abstract Data Type)
- Various Process Operations
- Process Attributes and PCB
- **Process Transition Diagram:**
- Different Process States
- Process State Transition Diagram
- Introduction to Schedulers and Dispatchers
- Addressing Common Doubts
- **Scheduling Queues and State Queuing Diagrams:**
- Detailed Examination of Schedulers and Dispatchers
- Context Switching
---
**CPU Scheduling:**
- **Introduction and Process Times:**
- Implementation of Short-Term Schedulers
- Functions and Objectives
- Understanding Process Times (AT, BT, TAT, IOBT, CT, Schedule Length)
- **FCFS:**
- Selection Criteria
- Operational Mode
- Conflict Resolution
- Assumptions
- Challenges with FCFS Scheduling
- Gantt Chart
- % CPU Idleness and Efficiency
- **FCFS with Dispatch Latency and IOBT:**
- Addressing Complex FCFS Problems
- Regular Discussion of Homework Problems
- **Shortest Job First (Preemptive and Non-Preemptive):**
- Selection Criteria
- Operational Mode
- Conflict Resolution
- Assumptions
- Challenges with FCFS Scheduling
- Gantt Chart
- % CPU Idleness and Efficiency
- **Other Scheduling Algorithms:**
- HRRN
- LRTF
- Round Robin and Performance Discussion
- Priority Based Scheduling
- Multilevel Queue Feedback Scheduling
---
**Process Synchronization / Coordination:**
- IPC and Introduction To Synchronization
- Exploring Race Condition
- Producer and Consumer Problem Implementation
- Types of Sync in Producer & Consumer Problem
- Necessary Conditions for Sync Problems
- Introduction to Sync Mechanism
- Lock Variables and Strict Alternation
- Implementation of Peterson Solution
- Dekker's Algorithm
- Introduction to Hardware Solutions
- Test & Set Lock, SWAP Lock and Key
- Priority Inversion Problem Solutions
- Blocking Mechanisms / Non-Busy Wait Solutions
- Semaphores
---
**Deadlock:**
- What's Deadlock?
- Resource Allocation Graph
- Deadlock Handling Strategies
- Banker's Algorithm and Problem Solving
- Deadlock Detection and Recovery
---
**Memory Management:**
- Byte and Word Addressable View
- RAM Architecture
- Static vs. Dynamic Loading
- Memory Management Techniques
- Paging, Segmentation, and Virtual Memory
- Page Replacement Algorithms
- Thrashing and Working Set Model
---
**File Management:**
- Disk Structure and Logical Structure of the Disk
- File vs. Directory
- File System Implementation
- Allocation Methods and Disk Free Space Management
- Disk Scheduling Algorithms
---
Feel free to ask any questions or share your thoughts on these topics!
thx helped me a lot with my test!
thanks your brother, words can not express my gratitude
Wow! This is a great introduction to operating systems. I learned so much about the basics of computer systems and how they work. I can't wait to learn more!
Thank you for your continuous contribution in enriching people’s knowledge ❤
Again with a banger course
I wish they’d breakup these videos into smaller chunks, and then create a playlist. It’s much less daunting to start a 1 hour video, finish it, and feel like you’re getting some momentum
Thanks. Now I align my Cs timetable to free code camps
I am taking this course as challenge
The challenge is to remember 50% of it
@@JS-kb4bk real.but If I can complete the course I can at least remember 50 %
You are extraordinary skilled guy👍🏻❤
I really need a subtitle in order for me to follow along this course effectively. Thank you.
@@aspiredifferent8085 but it's quite nonsense with this accent personally. Btw thanks.
@@Tran_Quang_Dao he talks so fast and the accent is barely understandable
It is how we Indians feel when we get some American accent lmao
You are amazing, Thank you for sharing this for free
we need something like this for DBMS
Heartfelt gratitude for your efforts!!
A great way to deeply understand the recent CrowdStrike outage, thank youc❤
Explain?
These guys are doing great job and making tremendous efforts. But them decent material like a microphone at least. Thanks for your efforts any way.
Thanks 👍🏻👍🏻 From Nepal 🇳🇵
Thank you so much for this free course
25 hour free course on OS is crazy
Dammit I really needed this when I was into osdev
6 months syllabus in 24 hours... Crazy
Tq Mr jeet, I love this course!
Great Job bro Heartly thanks ❤❤❤❤❤❤
Finally I have seen a os course on youtube
Great refreshments, cheers for this content!
Was Waiting for a videos like these! Thank you!
I have completed 1 hour 30 minutes.
This is amazing
0.75 speed recommended. This guy is the LZMA algorithm himself, there's a lot more to unpack here.
😂😂😂
I am challenging myself to watch at 1.5x speed
hooold on, let me get my popcorn first, this will i enjoy. Thanks!!!
God bless everyone who shares information, and God bless RUclips and other apps that facilitate knowledge transfer.☕️🗣️ my brain is crying cus i know the book shelf behind him is pure learning goodness.😢😓 all never know.
Please make a complete video on Computer Network DBMS
25 hours - it suits me :)
wowwww awesome man plz also do a complete python dsa long in depth course it would be gd for me if that course would take 100 hours or beyond and also do a Wordpress course complete development and designing
he has books and also a second pc in the background... he must be intelligent and educated.
I'm just here for Beau. Oh and the great content.
Superb course, 🎆👍🏻
thanks man for the video
qualified for the longest video I've ever watched on RUclips 😀
Another big boom just dropped on the internet. hats off FCC
Thanks much needed ‼️
they did it again 💯🙌
So we know Kshitij doesn't have any issues finalizing lengthy tasks and projects.
the legendary 7 state process transition diagram
My advice while I learnt this sub in past sem the book is better than any yt tutorials / courses for this the author name was Operating Systems
Abraham Silberschatz
Hey thanks for the advice. Can you please tell, if os course can be helpful for learning AI?
Bruh not everything is related to ai but this mandatory because you will come to how computer works internally when we work with it@@SarkarAniruddha
Also. I'm studying in ML in a university but I learn most of things in yt but some things I learnt from uni was
DAA , COA , TOC etc
Also start from basics for AI First try studying Calculus , linear algebra, probability and discrete math etc
But I think most of the resources for the courses can be found for free in pdfdrive, internetarchive ,GitHub ,yt etc
@@sarankumar13 are you doing masters or PhD??
Thanks for the heads-up
Sometimes I'm just too curious. Thank you.