GATE CS Notes (According to GATE 2025 Syllabus)

Engineering Mathematics Notes for GATE CSE

Linear Algebra

Introduction to Matrix

Different operations on matrices

Properties of Determinants of Matrices

Determinant of a Matrix – Formula, Properties, Examples

Program for Rank of Matrix

Row Echelon Form

L U Decomposition

Null Space and Nullity of a Matrix

System of Linear Equations

Eigen Values and Eigen Vectors

Matrix Diagonalization

Finding Inverse of a Square Matrix using Cayley Hamilton

Probability

Introduction to Probability

Random Variables

Mean, Variance, and Standard Deviation

Law of total probability

Conditional Probability

Bayes’s formula for Conditional Probability

Probability Distribution

Uniform Distribution

Exponential Distribution

Normal Distribution

Binomial Distribution

Poisson Distribution

Covariance and Correlation

Calculus

Limits, Continuity and Differentiability

Introduction to Limits

Indeterminate Forms

Logarithmic Differentiation – Continuity and Differentiability

Lagrange’s Mean Value Theorem

Rolle’s Mean Value Theorem

Cauchy’s mean value theorem

Taylor’s Theorem and Taylor series

Maclaurin series

Euler’s Formula

Chain Rule Derivative – Theorem, Proof & Examples

Indefinite Integrals

Finding the Various nth term of any polynomial sequence

Application of Derivative – Maxima and Minima | Mathematics

Absolute Minima and Maxima

Sequence and Series

Summation Formula

Misc

CATEGORY ARCHIVES: ENGINEERING MATHEMATICS

Last Minute Notes – Engineering Mathematics

Propositional and First-Order Logic

Introduction to Propositional Logic

Proposition Laws and Algebra

Propositional Equivalence

Predicates and Quantifiers Set 1

Predicates and Quantifiers Set 2

Some theorems on Nested Quantifiers

Rules of Inference

Consensus theorem

Sets, Relations, Functions, Partial orders, 
and Lattices. Monoids, Groups

Introduction to Set Theory

Set Operations in Set Theory

Power Set and its Properties

Cartesian Product of Two Sets

Relations and their types

Relations and their representations

Representing Relations

Closure of Relations and Equivalence Relations

Properties and Types of Functions

Inverse functions and composition of functions

Total number of possible functions

Number of possible equivalence relations

Groups

Sub-group and Order of Group

Modular Addition

Multiplication Modulo

Partial Orders and Lattices

Types of Lattices

Hasse Diagrams

Combinatorics: Counting, Recurrence 
Relations, Generating Functions

Introduction to Proofs

Combinatorics Basics

Pigeonhole Principle

PnC and Binomial Coefficients

Generalized PnC Set 1

Generalized PnC Set 2

Inclusion-Exclusion and its various Applications

Corollaries of Binomial Theorem

Introduction of Generating Functions

Graphs: Connectivity, Matching, Coloring

Introduction to Graph Theory

Graph Theory Basics

Walks, Trails, Paths, Cycles, and Circuits in Graph

Number of nodes and height of a binary tree

Havel-Hakimi Theorem

Graph measurements: length, distance, diameter, eccentricity, radius, center

Graph Isomorphisms and Connectivity

Planar Graphs and Graph Coloring

Euler and Hamiltonian Paths

Independent Sets, Covering,, and Matching

Matching in Graph Theory

Graph theory practice questions

Programming in C

Introduction to C Programming

Data Types in C

Variables in C

Operators in C

Functions in C

Scope of a Variable

Pointers in C

Enum, Struct & Union in C

Type Casting in C

Recursion

Introduction to Recursion

Types of Recursion

Arrays

Introduction to Arrays

1D, 2D and 3D Arrays

Row Major Order and Column Major Order

Stacks

Introduction to Stack

Implementation of Stack using SLL

Applications, Advantages and Disadvantages of Stack

Infix to Postfix

Postfix Evaluation

Towers of Hanoi

Fibonaaci Series

Queues

Introduction to Queue

Implementation of Queue using Array

Implementation of Queue using Linked List

Implementation of Queue using Stack

Circular Queue

Priority Queue

Double Ended Queue

Linked List

Introduction to Linked List

Single Linked List(SLL)

Double Linked List(DLL)

Circular Linked List

Trees

Binary Search Trees

Introduction to Binary Search Tree

BST Insertion

BST Deletion

AVL Trees

Tree Traversal

Binary Heaps

Introduction to Heap

Time Complexity of Building a Heap

Advanatges and Disadvanatges of Heap

Graphs               

Introduction to Graphs

BFS in Graph

DFS in Graph

Types of Graph and Examples

Graph and its Representations

Basic Properties of Graph

Applications, Advanatges and Disadvantages of Graph

Hashing

Introduction to Hashing

Hash Function and Types

Collision Resolution Technique

Chaining

Open Addressing (Linear Probing, Quadratic Probing, Double Hashing)

Quadratic Probing

Double Hashing

Misc

CATEGORY ARCHIVES: DATA STRUCTURES

CATEGORY ARCHIVES: C

Last Minute Notes – DATA STRUCTURE

Last Minute Notes – C/C++

Asymptotic Analysis of Algorithms     

Introduction of Algorithms

Asymptotic Analysis

Worst, Average and Best Cases

Asymptotic Notations

Analysis of Loops

Small ‘o’ and Small ‘Omega’ Notation

What does ‘Space Complexity’ mean?

Recurrence Relations

Introduction to Recurrence Relations

Master Theorem

Different types of recurrence relations and their solutions

Divide and Conquer

Introduction to Divide and Conquer

Binary Search

Merge Sort

Merge Sort for Linked Lists

How to make Mergesort to perform O(n) comparisons in best case?

QuickSort

Iterative Quick Sort

QuickSort on Singly Linked List

Median of two sorted arrays

Count Inversions in an array Using Merge Sort

Closest Pair of Points

Strassen’s Matrix Multiplication

Sort a nearly sorted (or K sorted) array

Search in an almost sorted array

K-th Element of Two Sorted Arrays

K’th Smallest/Largest Element in Unsorted Array

Greedy Techniques

Introduction to Greedy Algorithms

Activity Selection Problem

Job Sequencing Problem

Huffman Coding

Efficient Huffman Coding for Sorted Input

Fractional Knapsack Problem

Optimal File Merge Patterns

Kruskal’s Minimum Spanning Tree Algorithm

Prim’s Minimum Spanning Tree (MST)

Prim’s MST for Adjacency List Representation

Dijkstra’s shortest path algorithm

Dijkstra’s Algorithm for Adjacency List Representation

Introduction to Graph Algorithms

Breadth First Traversal or BFS for a Graph

Depth First Traversal or DFS for a Graph

Applications of Depth First Search

Detect Cycle in a Directed Graph

Topological Sorting

Bellman–Ford Algorithm

Floyd Warshall Algorithm

Shortest path with exactly k edges in a directed and weighted graph

Biconnected graph

Articulation Points (or Cut Vertices) in a Graph

Check if a graph is strongly connected (Kosaraju’s Theoram)

Bridges in a graph

Transitive closure of a graph

Dynamic Programming

Introduction to Dynamic Programming

Overlapping Subproblems Property

Optimal Substructure Property

Longest Common Subsequence

Matrix Chain Multiplication

0-1 Knapsack Problem

Min Cost Path

Subset Sum Problem

Bellman–Ford Algorithm

Floyd Warshall Algorithm

Total number of non-decreasing numbers with n digits

Smallest power of 2 greater than or equal to n

Searching, Sorting, Technique-based
Theorem and Hashing

Introduction to Searching Algorithms

Introduction to Sorting Algorithm

Linear Search

Linear Search vs Binary Search

Binary Search

Selection Sort

Bubble Sort

Insertion Sort

Merge Sort

QuickSort

Heap Sort

Counting Sort

Misc

Top 20 Hashing Technique based Interview Questions

CATEGORY ARCHIVES: ALGORITHMS

Last Minute Notes – Algorithms

Regular Expression, Languages,

Grammar, and Finite Automata        

Introduction of Theory of Computation

Introduction to Finite Automata

Designing Deterministic Finite Automata Set 1

Designing Deterministic Finite Automata Set 2

Designing Deterministic Finite Automata (Set 3)

DFA machines accepting odd number of 0’s or/and even number of 1’s

DFA for accepting the language L = {anbm | n+m=even}

DFA for Strings not ending with “THE”

Union process in DFA

Concatenation process in DFA

Minimization of DFA

Designing Non-Deterministic Finite Automata (Set 1)

Designing Non-Deterministic Finite Automata (Set 3)

Conversion from NFA to DFA

NFA with epsilon move to DFA Conversion

Regular Expressions, Regular Grammar and Regular Languages

How to write Regular Expressions?

How to identify if a language is regular or not

Generating regular expression from finite automata

Designing Finite Automata from Regular Expression

Closure properties of Regular languages

Introduction To Grammar in Theory of Computation

Chomsky Hierarchy

Pumping Lemma

Mealy and Moore Machines

Difference between Mealy machine and Moore machine

Union & Intersection of Regular languages with CFL

Context Sensitive Language

Turing Machines and Undecidability

Introduction to Recursive and Recursive Enumerable Languages

Introduction to Turing Machine

Halting Problem

Turing Machine for addition

Turing machine for subtraction

Turing machine for multiplication

Turing machine for copying data

Construct a Turing Machine for language L = {0n1n2n | n≥1}

Construct a Turing Machine for language L = {wwr | w ∈ {0, 1}}

Construct a Turing Machine for language L = {ww | w ∈ {0,1}}

Construct a Turing machine for L = {aibjck | i*j = k; i, j, k ≥ 1}

Types of Complexity Classes | P, NP, CoNP, and NP hard

Introduction to NP-Completeness

Decidability

Decidable and undecidable problems

Undecidability and Reducibility

Computable and non-computable problems

Misc

CATEGORY ARCHIVES: THEORY OF COMPUTATION & AUTOMATA

Last Minute Notes – Theory of Computation

Lexical Analysis, Parsing, Syntax-directed   

Introduction of Compiler design

Phases of a Compiler

Introduction to Compiler

Symbol Table in Compiler

Static and Dynamic Scoping

Generation of Programming Languages

Error Handling in Compiler Design

Error detection and Recovery in Compiler

Linker

Lexical Analysis

Fast Lexical Analyzer Generator

Classification of Context Free Grammars

Ambiguous Grammar

Removal of ambiguity

Why FIRST and FOLLOW?

FIRST Set in Syntax Analysis

FOLLOW Set in Syntax Analysis

Program to calculate First and Follow sets of given grammar

Introduction to Syntax Analysis

Parsing Set 1

Bottom Up or Shift Reduce Parsers

SLR, CLR and LALR Parsers

Shift Reduce Parser in Compiler

Classification of top down parsers

Backtracking(Top down parser)

Recursive descent

Operator grammar and precedence parser

Practice Question on Lexical analysis, parsing, syntax-directed

Runtime Environment

Runtime Environments

Stack Allocation

Heap Allocation

Parameters Passing

Pass by Value

Pass by Reference

Pass by Copy-restore

Pass by Name

Intermediate Code Generation

Intermediate Code Generation

Three address code in Compiler

Detection of a Loop in Three Address Code

Code Optimization

Introduction of Object Code

Data flow analysis in Compiler

CATEGORY ARCHIVES: COMPILER DESIGN

Last Minute Notes – Compiler Design

Local Optimization

Compile Time Evaluation

Variable Propagation

Constant Propagation

Constant Folding

Copy Propagation

Common Sub Expression Elimination

Dead Code Elimination

Unreachable Code Elimination

Function Inlining

Induction Variable and Strength Reduction

Code Motion or Frequency Reduction

Loop Jamming

Data Flow Analysis

USE, IN & OUT

Data flow analysis

Introduction

Introduction to Database Management System

DBMS 3-Tier Architecture

DBMS 2-Level, 3-Level Architecture

Need for DBMS

Challenges of Database Security in DBMS

Advantages of DBMS over File system

Data Abstraction and Data Independence

ER-Model

Introduction to ER Model

Recursive Relationships

Minimization of ER Diagram

Enhanced ER Model

Mapping from ER Model to Relational Model

Relational Model (relational algebra, tuple calculus)

Introduction to Relational Model

Relational Algebra – Overview

Anomalies in Relational Model

Relational Model Introduction and Codd Rules

Keys in Relational Model (Candidate, Super, Primary, Alternate and Foreign)

Relational Algebra – Extended Operators

Tuple Relational Calculus

How to solve Relational Algebra problems for GATE

Database Design (integrity constraints, normal forms)

Introduction to Database Normalization

Normal Forms in Database Normalization

Functional Dependency and Attribute Closure

Types of Functional Dependency

Finding Attribute Closure and Candidate Keys using Functional Dependencies

Number of possible Superkeys

Lossy and Lossless Decomposition

Dependency Preserving Decomposition

Lossless Join and Dependency Preserving Decomposition

DBMS | How to find the highest normal form of a relation

Minimum relations satisfying 1NF

Equivalence of Functional Dependencies

Canonical Cover

Multivalued Dependency

Structured Query Languages (SQL)

Introduction to Structured Query Language (SQL)

Parts of SQL

Data Manipulation Language in SQL

Data Definition in SQL

Joins in SQL

Inner VS Outer Join

Having Vs Where Clause

Database Objects

Nested Queries in SQL

Join operation Vs nested query

Indexing in Databases 

SQL Clauses

SQL Views

SQL Indexes

SQL queries on clustered and non-clustered Indexes

SQL Tutorial

Transactions and Concurrency Control

Introduction to Concurrency Control

Database Recovery Techniques

ACID Properties in DBMS

Log based recovery

Why recovery is needed?

Transaction Isolation Levels in DBMS

Types of Schedules in Concurrency Control

Types of Recoverability of Schedules in DBMS

Conflict Serializability

Precedence Graph For Testing Conflict Serializability

How to test if two schedules are View Equal or not ?

Recoverability of Schedules

Cascadeless in DBMS

Deadlock in DBMS

Starvation in DBMS

Transaction and Concurrency Control

Lock Based Protocol

Concurrency Control Techniques

Two Phase Locking (2-PL)

Categories of Two Phase Locking (2-PL)

Thomas Write Rule

Timestamp Ordering Protocols

Multiple Granularity Locking

Graph Based Protocol

Introduction to TimeStamp and Deadlock Prevention Schemes

Implementation of Locking in DBMS

File Structures (sequential files, indexing, B and B+ trees)

Introduction to Indexing in Databases

File Organization

Hashing in DBMS

Introduction to B-Tree

Insertion in B-Tree

Deletion in B-Tree

Introduction to B+ Trees

Insertion in a B+ tree

Difference between B tree and B+ tree

Misc

CATEGORY ARCHIVES: DBMS

Last Minute Notes – DBMS

Network Fundamental and

Physical Layer 

Basics of Computer Networking

Network goals

Network Topologies

Types of area networks – LAN, MAN and WAN

Types of Transmission Media

Transmission Modes in Computer Networks 
(Simplex, Half-Duplex and Full-Duplex)

Redundant link problems

Difference between Unipolar, Polar and 
Bipolar Line Coding Schemes

Difference between Broadband and 
Baseband Transmission

Let’s experiment with Networking

Layers of OSI Model

TCP/IP Model

Data Link Layer

Multiple Access Protocols

P2P(Peer To Peer) File Sharing

Framing In Data Link Layer

LAN Technologies | ETHERNET

Ethernet Frame Format

Token Ring frame format

Bit Stuffing

Difference between Byte stuffing and Bit stuffing

Hamming Code

Aloha

Slotted Aloha

Pure Aloha

Carrier sense multiple access (CSMA)

Controlled Access Protocols

Back-off Algorithm for CSMA/CD

Collision Detection in CSMA/CD

Efficiency of CSMA/CD

Efficiency of Token Ring

Computer Networks | Error Detection

Stop and Wait ARQ

Sliding Window Protocol | Set 1 (Sender Side)

Sliding Window Protocol | Set 2 (Receiver Side)

Sliding Window Protocol | Set 3 (Selective Repeat)

Sliding Window protocols Summary With Questions

Program to remotely Power On a PC over the internet using the Wake-on-LAN protocol

Program to calculate the Round Trip Time (RTT)

To calculate the expected Round Trip Time

Introduction of MAC Address

Collision Avoidance in wireless networks

Maximum data rate (channel capacity) for noiseless and noisy channels

Switches

Routers

Types of switches

Network Layer

Internetworking

Line Configuration in Computer Networks

Difference between Unicast, Broadcast and Multicast

Collision Domain and Broadcast Domain

IP Addressing | Introduction and Classful Addressing

Network Layer | Introduction and IPv4 Datagram Header

Network Layer | Ipv4 Datagram Fragmentation and Delays

Fragmentation at Network Layer

Internet Protocol v6 | IPv6

Internet Protocol version 6 (IPv6) Header

IP Addressing | Classless Addressing

Subnetting in Computer Network

Supernetting

Computer Networks | Longest Prefix Matching in Routers

Program to determine class, Network and Host ID of an IPv4 address

C Program to find IP Address, Subnet Mask & Default Gateway

IPv4 classless Subnet equation

Introduction to variable length subnet mask (VLSM)

Network address translation (NAT)

Types of Network address translation (NAT)

Classification of Routing Algorithms – Set 1

Types of routing – Set 2

Classes of routing protocols – Set 3

Distance vector routing v/s Link state routing

Fixed and Flooding Routing algorithms

Routing v/s Routed Protocols

Unicast Routing – Link State Routing

Routing Protocols Set 1 (Distance Vector Routing)

Route Poisoning and Count to infinity problem

Internet Control Message Protocol (ICMP) | Computer Networks

OSPF protocol fundamentals

OSPF protocol States

OSPF router roles and configuration

Root Bridge Election in Spanning Tree Protocol

Types of Spanning Tree Protocol (STP)

Routing Information Protocol (RIP)

Routing Interface Protocol (RIP) V1 & V2

Link state advertisement (LSA)

Administrative Distance (AD) and Autonomous System (AS)

Circuit Switching

Packet Switching and Delays

Differences between Virtual Circuits & Datagram Networks

Computer Network | Circuit Switching VS Packet Switching

RARP

Traceroute

How ARP works?

ARP, Reverse ARP(RARP), Inverse ARP(InARP), Proxy ARP and Gratuitous ARP

Packet flow in the same network

Packet flow in different network

Difference between layer-2 and layer-3 switches

What’s difference between Ping and Traceroute?

Computer Network | Servers

What is Local Host?

Transport Layer

Transport Layer responsibilities

Congestion Control

Leaky Bucket Algorithm

TCP | Services and Segment structure

TCP Congestion Control

TCP 3-Way Handshake Process

TCP Connection Establishment

TCP Connection Termination

Error Control in TCP

TCP Timers

TCP flags

TCP Server-Client implementation in C

User Datagram Protocol (UDP)

Differences between TCP and UDP

Multiplexing and Demultiplexing in Transport Layer

Application Layer

Protocols in Application Layer

DNS (Domain Name Server) | NetWorking

Address Resolution in DNS

DNS Spoofing or DNS Cache poisoning

Why does DNS use UDP and not TCP?

Dynamic Host Configuration Protocol (DHCP)

DHCP Relay Agent

How DHCP server dynamically assigns IP address to a host?

Simple network management protocol (SNMP)

Simple Mail Transfer Protocol (SMTP)

File Transfer Protocol (FTP)

HTTP Non-Persistent & Persistent Connection

HTTP parallel and non parallel

Multipurpose Internet mail extension (MIME)

What’s difference between http:// and https:// ?

What’s difference between HTML and HTTP ?

What’s difference between The Internet and The Web ?

Basics of Wi-Fi

Wifi protected setup (WPS)

Wifi protected access (WPA)

LiFi vs. WiFi

Network Devices (Hub, Repeater, Bridge, Switch, Router and Gateways)

Misc

Processes, Threads, CPU Scheduling

Introduction of System Call

Operating System | Thread

Threads and its types

Difference between thread and process

Multithreading

Multi threading models

Benefits of Multithreading

Process-based and Thread-based Multitasking

User Level thread Vs Kernel Level thread

Microkernel

Monolithic Kernel and key differences from Microkernel

Difference between multitasking, multithreading and multiprocessing

Context Switching in OS

Fork function call

fork() in C  

Inter‐process Communication,

Concurrency, and Synchronization

Process Synchronization | Introduction

Operating System | Process Synchronization | Set 2

Critical Section

Inter Process Communication

IPC using Message Queues

IPC through shared memory

Interprocess Communication: Methods

Semaphores in operating system

Mutex vs Semaphore

Lock variable synchronization mechanism

Peterson’s Algorithm for Mutual Exclusion | Set 1 (Basic C implementation)

Peterson’s Algorithm for Mutual Exclusion | Set 2 (CPU Cycles and Memory Fence)

Peterson’s Algorithm (Using processes and shared memory)

Readers-Writers Problem | Set 1 (Introduction and Readers Preference Solution)

Reader-Writers solution using Monitors

Producer Consumer Problem using Semaphores | Set 1

Producer-Consumer solution using Semaphores in Java | Set 2

Process Synchronization | Monitors

Dining Philosopher Problem

Dining-Philosophers Solution Using Monitors

Dining Philosopher Problem Using Semaphores

Priority Inversion : What the heck !

What’s difference between Priority Inversion and Priority Inheritance ?

Deadlock, Starvation, and Livelock

Deadlock

Process Management | Deadlock Introduction

Program for Deadlock free condition

Deadlock Prevention And Avoidance

Deadlock Detection And Recovery

Resource Allocation Graph (RAG)

Banker’s Algorithm

Program for Banker’s Algorithm | Set 1 (Safety Algorithm)

Banker’s Algorithm : Print all the safe state

Deadlock detection algorithm

Methods of resource allocation to processes by operating system

Main Memory Management 

Mapping virtual address to physical addresses

Logical vs Physical Address in Operating System

Paging

Page Table Entries

Multilevel Paging

Inverted Page Table

Segmentation

Demand Paging

Memory Management | Partition Allocation Method

Non-Contiguous Allocation

Fixed (or static) Partitioning

Variable (or dynamic) Partitioning

Working with Shared Libraries | Set 1

Static and Dynamic Libraries | Set 1

Buddy System

Buddy System Memory Allocation

Buddy System Memory Deallocation

Allocating kernel memory

Requirements of memory management system

Virtual Memory

Virtual Memory

Secondary memory – Hard disk drive

Page Fault Handling

Page Replacement Algorithms

Belady’s Anomaly

Program for Optimal Page Replacement Algorithm

Techniques to handle Thrashing

What exactly Spooling is all about?

Difference between Spooling and Buffering

Overlays in Memory Management

Swap Space

File System and Disk Scheduling

File Systems

Structures of Directory

File Directory | Path Name

File Access Methods

File Allocation Methods

Operating System | Free space management

Difference between FAT32, exFAT, and NTFS File System

Disk Scheduling Algorithms

Program for SSTF disk scheduling algorithm

CATEGORY ARCHIVES: OPERATING SYSTEMS

Last Minute Notes – Operating Systems

Introduction of Boolean Algebra and Logic Gates 

Logic Gates

Properties of Boolean algebra

Logical gates in logic design

Boolean functions

Minimization of Boolean Functions

Representation of Boolean Functions

Canonical and Standard Form

Functional Completeness

K-Map

Implicants in K-Map

Prime implicants and Explicit implicants

PDNF and PCNF

Variable entrant map (VEM)

Consensus theorem

Combinational Circuit

Grey Code

Half Adder

Full Adder

Half Subtractor

Full Subtractor

Half Adder and Half Subtractor using NAND NOR gates

Encoders and Decoders

Encoder

Binary Decoder

Combinational circuits using Decoder

Multiplexers

De-MUX

Carry Look-Ahead Adder

Parallel Adder & Parallel Subtractor

BCD Adder

Magnitude Comparator

BCD to 7 Segment Decoder

Programmable Logic Array

Programming Array Logic

Read-Only Memory (ROM)

Static Hazards

Sequential Circuit

Introduction of Sequential Circuits

Flip-flop types and their Conversion

Synchronous Sequential Circuits

Counters

Ring Counter

n-bit Johnson Counter

Ripple Counter

Design counter for given sequence

Master Slave JK Flip Flop

S-R FlipFlop

T Flipflop

D Flipflop

Asynchronous Sequential Circuits

Shift Registers

Design 101 sequence detector

Amortized analysis for increment in counter

Number Representation and Computer Arithmetic 

Number System and base conversions

Code Converters – BCD(8421) to/from Excess-3

Code Converters – Binary to/from Gray Code

Program for Decimal to Binary Conversion

Program for Binary To Decimal Conversion

Program for Decimal to Octal Conversion

Program for Octal to Decimal Conversion

Program for Hexadecimal to Decimal Conversion

Computer Arithmetic | Set – 1

Computer Arithmetic | Set – 2

Floating Point Representation

What’s difference between 1’s Complement and 2’s Complement?

Booth’s Algorithm

Restoring Division Algorithm For Unsigned Integer

Non-Restoring Division For Unsigned Integer

CATEGORY ARCHIVES: DIGITAL ELECTRONICS & LOGIC DESIGN

Last Minute Notes – Digital Electronics

Machine Instructions and Addressing Modes

Introduction to Computer Organization and Architecture

Basic Computer Instructions

Instruction Design and Format

Computer Arithmetic

Microprogrammed Control

Memory Organization

A simple understanding of Computer

Issues in Computer Design

Computer System Level Hierarchy

Computer Architecture and Computer Organization

Basic Computer Instructions

Von Neumann architecture

Harvard Architecture

Von Neumann architecture vs Harvard Architecture

Basic Computer Instructions

Instruction Formats (Zero, One, Two and Three Address Instruction)

Stack based CPU Organization

General Register based CPU Organization

Single Accumulator based CPU organization

Problem Solving on Instruction Format

Addressing Modes

Machine Instructions

Difference between CALL and JUMP instructions

Simplified Instructional Computer (SIC)

Hardware architecture (parallel computing)

Flynn’s taxonomy

Generations of computer

Amdahl’s law and its proof

ALU, Data‐Path and Control Unit 

Control Unit and design

Hardwired v/s Micro-programmed Control Unit

Hardwired Vs Micro-programmed Control unit | Set 2

Horizontal micro-programmed Vs Vertical micro-programmed control unit

Synchronous Data Transfer

Asynchronous Data Transfer

Instruction Pipelining

Pipelining

Types of pipelining

Pipelining | Set 1 (Execution, Stages and Throughput)

Pipelining | Set 2 (Dependencies and Data Hazard)

Pipelining | Set 3 (Types and Stalling)

Different Instruction Cycles

Performance of Computer

Micro-Operation

RISC and CISC

RISC and CISC | Set 2

Cache Memory

Memory Hierarchy Design and its Characteristics

Cache Memory

Cache Organization | Introduction

Locality and Cache friendly code

What’s difference between CPU Cache and TLB?

Read and Write operations in memory

Memory Interleaving

Introduction to memory and memory units

2D and 2.5D Memory organization

Types of computer memory (RAM and ROM)

Different Types of RAM

RAM vs ROM

I/O interface (Interrupt and DMA mode) 

I/O Interface (Interrupt and DMA Mode)

Input-Output Processor

Kernel I/O Subsystem

Memory mapped I/O and Isolated I/O

BUS Arbitration

Priority Interrupts | (S/W Polling and Daisy Chaining)

Asynchronous input output synchronization

Computer Ports

Clusters In Computer Organisation

Human – Computer interaction through the ages

CATEGORY ARCHIVES: COMPUTER ORGANIZATION & ARCHITECTURE