COMPUTER SCIENCE AND ENGINEERING

COMPLEX ENGINEERING PROBLEM SOLVING

PROGRAM B.TECH
PROJECT CO-ORDINATOR Dr. CH. SRINIVASULU
COURSE NAME Operating Systems
COURSE CODE ACSD09
SEMESTER III
BRANCH AND SECTION CSE, Section - A
ACADEMIC YEAR 2024-25
NATURE OF ACTIVITY Course Side Project
TEACHING AND LEARNING This is a one piece of assessed course work, involving a mixture of
METHOD theatrical work and programming. This should take around 15 hours

Engineering Competence (EC) Profiles - Complex Engineering Problem and Activities

These projects are designed in such a way that the students solve complex engineering problem. Following are
characteristics of complex engineering problem targeted in this semester towards course side project.

Following characteristics of complex engineering problems are targeted:

EC Attributes Descriptors for Rubric Design

EC 1 Depth of knowledge required Ensures that all aspects of an engineering activity are soundly based on
fundamental principles - by diagnosing, and taking appropriate action with
data, algorithm, implementation, results, and documented information that
may be ill-founded, illogical, erroneous, unreliable or unrealistic
requirements applicable to the engineering discipline.
EC 2 Depth of analysis required Have no obvious solution and require abstract thinking, originality in
analysis to formulate suitable models.
EC 3 Design and development of Support sustainable development solutions by ensuring functional
solutions requirements, minimize environmental impact and optimize resource
utilization throughout the life cycle, while balancing performance and cost
effectiveness.

Course Side Project is carried out in four phases:

1. Problem Identification:
In the first phase of the course, students are required to identify and present the problems they intend to address. During lab
and contact hours, counseling sessions are conducted to guide students in refining their ideas and preparing a formal
proposal. Students are encouraged to explore real-world problems or challenges that can be solved using data structure
algorithms. If the proposed problem is deemed irrelevant to the course content or beyond the students' current level of
expertise, they are advised to select a more appropriate problem. Once the ideas are finalized, the Course Coordinator and
Course Instructor provides ongoing support and counseling to address requirements and resource-related concerns.
1
2. Project Proposal
In the initial study phase, students have to explore the literature or existing solutions for their selected project idea. In this
phase, students are also encouraged to have a detailed analysis of the problem to solve it in a better way. Each student’s
project is unique, may have many possible solutions as well as may be explored and developed in a different way. After
discussion, students are asked to submit a proposal on one idea approved by the instructor.

3. Design / Simulation of Project

Every project is evaluated by running the program and observing its output. Students are required to develop their projects
in the data structures laboratory. The projects are designed to encourage the application of in-depth engineering knowledge
(EC1) to achieve successful outcomes. During the initial study and formulation of the proposed solution, emphasized
sustainable development by ensuring functional requirements while minimizing environmental impact (EC2), and
conducted comprehensive analyses to ensure robust solutions (EC3).

4. Implementation of Project
Each project was assessed through practical implementation and observation of outcomes. Students undertook the task of
developing projects for the data structures laboratory, applying their in-depth engineering knowledge (EC1) to achieve
successful completion. During the initial stages of study and solution formulation, designing sustainable development
solutions that fulfilled functional needs while minimizing environmental impact (EC2), and conducting thorough analyses
(EC3).

Projects were evaluated on the following criteria.

Project Proposal 20%

Design / Simulation 30%
Implementation of Project 30%
Report 20%

Summary
Following is salient outcome of the semester project in terms of complex engineering problem:

• Brainstorming exercise forced them to explore the surrounding environment to sort out the problems.
• Problem formulation enhances their ability to gather real-time requirements and address conflicts / constraints.
• Design / Simulation / Implementation gave them a chance to go through the in-depth engineering knowledge to solve
the problem and analyse in an effective way.

List of Course Side Projects:

Batch
Roll Number Student Name Title Code
No
23951A0501 Boga Aashritha
1. Operating System for Digital Twins OSCSP01
23951A0504 N Abhinaya

23951A0502 Nizampuram Abhinav Operating System for Autonomous Cyber

2. OSCSP02
Défense
23951A0503 Aieleni Abhinav Reddy

23951A0505 N Abhindra Varma Real-Time Operating System for

3. OSCSP03
Autonomous Systems
23951A0506 B Abhishekvardhan

2
 23951A0507 Boddu Achyuth Edge Operating System for Augmented
4. OSCSP04
Reality (AR)
23951A0508 Malyala Adharsh
Rathod Aditya
23951A0509 Operating System for Smart Healthcare
5. OSCSP05
Devices
23951A050A Kamadula Ajay

23951A050B Male Ajay Kumar

6. Operating System for Quantum Computing OSCSP06
23951A050C Cheela Akhil
Mudunuri Akhil Varma
23951A050D Operating System for Smart Manufacturing
7. OSCSP07
(Industry 4.0)
23951A050E Eragolla Akhilesh

23951A050F Akhilesh Bhaskar Gupta

Operating System for Augmented Reality
8. OSCSP08
(AR) Cloud Infrastructure
23951A050J Narra Akshith Sai

23951A050H M Akshaya Varshini

Operating System for Secure Multi-Party
9. OSCSP09
Computation (MPC)
23951A050G K Velma Akshaya

23951A050K Duddagonda Aman Goud

Energy-Efficient Operating System for
10. OSCSP10
Green Data Centers
23951A050L Kasarla Amitej

23951A050M Karuturi Amitha

Operating System for Autonomous Maritime
11. OSCSP11
Vehicles
23951A050R Vallepu Anitha

23951A050P Gurram Anand Sagar Operating System for Hyper-Converged

12. OSCSP12
Infrastructure (HCI)
23951A050Q Sabavat Anil

23951A050S Anurag Bera Operating System for Secure IoT

13. OSCSP13
Ecosystems
23951A050N Aravally Amogh

23951A050T Edigi Anurag Operating System for Space Exploration

14. OSCSP14
Missions
23951A0514 Gunti Ashok

23951A050V Veltoori Archana Operating System for Cognitive Computing

15. OSCSP15
Systems
23951A050W R Archana

16. 23951A050X Archishman Ghosh Operating System for Digital Identity and OSCSP16

3
 Trust Management
23951A050Y Arijit Karmakar

23951A050Z Agam Arnav Goud

Multi-Modal User Interface Operating
17. OSCSP17
System for Mixed Reality
23951A0511 Panga Arun

23951A0512 Myakala Arunkumar

Blockchain-Based Operating System for
18. OSCSP18
Secure Digital Transactions
23951A0513 Sriramula Ashish Shiva

23951A0515 Nacham Ashruja

Operating System for 5G Network
19. OSCSP19
Management
23951A050U Rekandar Anushka

23951A0516 Asma Begum

Operating System for Hybrid Cloud and On-
20. OSCSP20
Premise Environments
23951A0517 Audhagiri Joy Rachel

23951A0518 Naidu Bhageeratha

Design an OS Kernel for Autonomous
21. OSCSP21
Vehicles
23951A0519 Sadhu Bhanu Prasad

23951A051A Thota Bhanu Teja Reddy

Design a Hybrid CPU Scheduler for Multi-
22. OSCSP22
Core Systems
23951A051B Mittapelly Bharadwaj

23951A051D Pulloju Bhargavi

Build a simple virtual memory system that
23. OSCSP23
simulates paging
23951A051P Pantangi Charitha

23951A051E Juluri Bhavani Koushik

Develop an approach for efficiently
24. OSCSP24
managing memory fragmentation
23951A051F Gouda Bhoomesh
23951A051G Bibek Behera
25. Create a simulation of demand paging OSCSP25
23951A051H Bipin Yadav
23951A051J Mallam Chaitanya
Calculate average seek time using a disk
26. OSCSP26
scheduling simulator
23951A051K Chandan Patel
23951A051L Palaparthi Chandan Sai
Simulate the performance of RAID levels in
27. OSCSP27
terms of read/write operations
23951A051M Kothagattu Charan

4
 23951A051N Nagisetti Charan
Simulate indexed, contiguous, and linked
28. OSCSP28
file allocation methods
23951A051C S Bharath Chandra

23951A051Q Pandiri Charitharth

Develop Memory Management for Large-
29. OSCSP29
Scale Virtualization
23951A051R T C V Sai Kowshik Kumar

23951A051T Kotha Dalvika

Design a virtual memory system that
30. OSCSP30
minimizes page faults
23951A051U Telugu Darshini

23951A051V Miriyala Dasharatham Optimization of Advanced Page

31. Replacement Algorithms for Real-World OSCSP31
23951A051S Memory Access Patterns
Palepogu Chinna Babu

23951A051W Thudi Deekshith

32. Develop a real-time process scheduler OSCSP32
23951A051X Bhanavath Deekshith Ram

24955A0501 Udatha Akhil

Design a multi-level queue scheduling
33. OSCSP33
algorithm for multiprocessor systems
24955A0502 Nallavelly Akhil Reddy

24955A0503 Nalam Akshaya

Design an indexing method that allows fast
34. search and retrieval of files in a distributed OSCSP34
24955A0506 Chintharla Archana system

24955A0507 Aeligeti Dheeraj Sai

Create a system that handles page faults
35. OSCSP35
efficiently in a real-time environment
24955A0505 Kagada Aniketh

5
Project Descriptions:
OSCSP 01: OPERATING SYSTEM FOR DIGITAL TWINS

I. PROJECT OVERVIEW:

An Operating System for Digital Twins is designed to manage and optimize the creation, simulation, and interaction
of digital representations of physical assets or systems. A digital twin is a virtual model that mirrors a physical object,
process, or system in real-time. The operating system facilitates data collection, processing, and analysis from real-world
devices or sensors, enabling simulation, monitoring, and predictive maintenance.

II. OBJECTIVES:

1. Real-Time Synchronization: Enable real-time data integration and updates between physical assets and their
digital twins.
2. Simulation and Optimization: Support the creation and simulation of virtual models to optimize real-world
processes and systems.
3. Advanced Analytics: Provide data analytics and AI-driven insights for predictive maintenance, performance
monitoring, and decision-making.
4. System Interoperability: Ensure seamless integration and communication with other systems and devices to
enable collaborative data sharing.

III. PREREQUISITES AND REQUIREMENTS:

1. Real-Time Data Processing: The OS must support fast data collection, processing, and synchronization
between physical systems and digital twins.
2. Scalable Infrastructure: The OS should handle large-scale data from multiple sensors and devices, enabling
the management of complex digital twin models.
3. Advanced Simulation and Modeling Tools: The OS must provide tools for creating accurate virtual models
and running simulations for optimization and testing.
4. Interoperability and Integration: The OS should enable seamless communication with different platforms,
devices, and systems to ensure effective data sharing and collaboration.

IV. TECHNOLOGIES USED:

1 . Programming Languages: Python for logic implementation and GUI development (Tkinter or PyQt for
graphical interfaces).
2. Visualization Tools:
a. Matplotlib or Seaborn for generating Gantt charts, bar graphs, and other visual
representations.
b. D3.js for web-based dynamic visualizations.
3. Database (Optional):
a. SQLite or JSON for storing simulation results or configurations.
4. Development Environment:
a. Visual Studio Code, PyCharm, or Eclipse for code development.
b. Git for version control.

6
OSCSP02: OPERATING SYSTEM FOR AUTONOMOUS CYBER DÉFENSE

I. PROJECT OVERVIEW:

An Operating System for Autonomous Cyber Defense is designed to proactively protect computer systems and
networks from cyber threats without requiring human intervention. This OS uses advanced artificial intelligence (AI),
machine learning (ML), and automation to detect, prevent, and respond to cyberattacks in real-time. It leverages
continuous monitoring, behavior analysis, and anomaly detection to identify potential threats, automate defensive actions,
and adapt to evolving security risks.

II. OBJECTIVES:

1. Real-Time Threat Detection: Continuously monitor systems for anomalies and potential cyber threats,
providing instant detection.
2. Automated Response: Automatically deploy defense measures, such as blocking malicious traffic or isolating
compromised systems, without human intervention.
3. AI-Powered Analysis: Use AI and machine learning to analyze data, predict attacks, and improve defense
strategies over time.
4. Self-Healing and Adaptability: Enable the system to recover from attacks, adapt security measures, and patch
vulnerabilities autonomously.

III. PREREQUISITES AND REQUIREMENTS:

1. Advanced Threat Detection Capabilities: The OS must support continuous monitoring and real-time anomaly
detection using AI/ML to identify emerging cyber threats.
2. Automated Defense Mechanisms: The OS should be capable of autonomously deploying countermeasures,
such as blocking malicious activities or isolating compromised systems.
3. Scalable and Adaptive Security Framework: The OS must adapt to evolving cyber threats by updating and
refining security protocols based on new attack patterns.
4. High Performance and Low Latency: To ensure rapid threat response, the OS must operate with minimal
delays and maintain system performance under heavy load.

IV. TECHNOLOGIES USED:

1. Algorithm Libraries: Python (NetworkX, Dijkstra), Java (JGraphT).

2. Visualization: D3.js, Plotly.
3. Backend: Flask or Django for web integration.
4. Database: SQLite for storing graph data.

7
OSCSP0 3: REAL-TIME OPERATING SYSTEM FOR AUTONOMOUS SYSTEMS

I. PROJECT OVERVIEW:

A Real-Time Operating System (RTOS) for Autonomous Systems manages time-critical tasks in autonomous devices
like vehicles, drones, and robots. It ensures deterministic task execution, minimal latency, and reliable responses to sensor
inputs for safety and decision-making. The OS supports multi-tasking, resource management, and fault tolerance to ensure
stable, real-time performance in dynamic environments.

II. OBJECTIVES:

1. Deterministic Task Execution: Ensure tasks are completed within strict time constraints for reliable system
performance.
2. Low Latency: Minimize response time to ensure immediate actions in time-sensitive situations.
3. Efficient Resource Management: Manage system resources effectively to handle multiple tasks
simultaneously.
4. Fault Tolerance and Reliability: Maintain system stability and recovery in case of hardware or software
failures.

III. PREREQUISITES AND REQUIREMENTS:

1. Real-Time Scheduling: Support for deterministic scheduling to ensure tasks meet strict deadlines.
2. Low Latency and High Performance: Ability to process data and respond to events with minimal delay.
3. Robust Resource Management: Efficient handling of CPU, memory, and sensors to support multiple
concurrent tasks.
4. Fault Tolerance and Reliability: Mechanisms for error detection, recovery, and ensuring continuous system
operation under failure conditions.

IV. TECHNOLOGIES USED:

1. Binary Heap Implementation in Python/Java.

2. APIs: Alpha Vantage, Yahoo Finance API.
3. Frontend: React.js for stock price visualization.
4. Database: MongoDB or MySQL for storing stock price history.

8
OSCSP04: EDGE OPERATING SYSTEM FOR AUGMENTED REALITY (AR)

I. PROJECT OVERVIEW:

An Edge Operating System for Augmented Reality (AR) enables real-time AR experiences by processing data locally
on edge devices, reducing latency and improving performance. It optimizes hardware resources like CPU, GPU, and
sensors, manages real-time data, and minimizes reliance on cloud services, ensuring faster, seamless interactions in AR
applications.

II. OBJECTIVES:

1. Low-Latency Processing: Ensure real-time AR content rendering with minimal delay.

2. Efficient Resource Utilization: Optimize CPU, GPU, and sensor resources for seamless AR experiences.
3. Real-Time Data Handling: Manage and process sensor data for accurate AR interactions.
4. Reduce Cloud Dependency: Minimize reliance on cloud services by processing data locally for improved
performance.

III. PREREQUISITES AND REQUIREMENTS:

1. Low-Latency Data Processing: Support for real-time, local processing of AR data to minimize delays.
2. High Resource Efficiency: Ability to manage and optimize CPU, GPU, and sensor resources for AR tasks.
3. Robust Network Connectivity: Ensure reliable communication between devices and seamless integration with
cloud services when necessary.
4. Real-Time Sensor Integration: Capability to handle data from multiple sensors (e.g., cameras, accelerometers)
for accurate AR content rendering.

IV. TECHNOLOGIES USED:

1. Algorithms: A* and Dijkstra’s Algorithm.

2. Map APIs: Google Maps API, OpenStreetMap.
3. Backend: Node.js/Flask for real-time data handling.
4. Sensors: LIDAR and camera systems for obstacle detection.

9
OSCSP05: OPERATING SYSTEM FOR SMART HEALTHCARE DEVICES

I. PROJECT OVERVIEW:

An Operating System for Smart Healthcare Devices manages healthcare devices like wearables and diagnostic tools,
ensuring real-time data processing, secure transmission of health data, and integration with healthcare networks. It
prioritizes patient privacy, compliance with healthcare regulations, and seamless operation across various devices for
efficient remote monitoring and health tracking.

II. OBJECTIVES:

1. Real-Time Health Data Processing: Efficiently collect and analyze health data from various devices.
2. Secure Data Transmission: Ensure encrypted and protected transmission of sensitive patient information.
3. Seamless Integration: Enable interoperability with healthcare systems for comprehensive monitoring.
4. Regulatory Compliance: Adhere to healthcare standards like HIPAA to ensure data privacy and security.

III. PREREQUISITES AND REQUIREMENTS:

1. Real-Time Data Handling: Ability to process health data continuously with minimal delay.
2. Data Security and Encryption: Implement strong encryption for secure transmission and storage of sensitive
health data.
3. Interoperability: Support integration with various healthcare systems and devices for comprehensive patient
monitoring.
4. Compliance with Regulations: Ensure adherence to healthcare regulations (e.g., HIPAA) for data protection
and privacy.

IV. TECHNOLOGIES USED:

1. Backend: Django, Node.js for handling patient records and triage logic.
2. Database: MySQL, PostgreSQL for storing patient data.
3. Frontend: React.js for patient and admin interfaces.
4. Queue Implementation: Custom implementation for multi-level queues.

10
OSCSP06: OPERATING SYSTEM FOR QUANTUM COMPUTING

I. PROJECT OVERVIEW:

An Operating System for Quantum Computing manages quantum hardware and software, enabling the execution of
quantum algorithms. It handles quantum resources like qubits, supports quantum circuit execution, implements error
correction, and ensures seamless integration between quantum and classical systems for hybrid workloads.

II. OBJECTIVES:

1. Manage Quantum Resources: Efficiently handle qubits and quantum gates for computation.
2. Support Quantum Circuit Execution: Facilitate the creation and execution of quantum algorithms.
3. Error Correction: Implement techniques to minimize errors and noise in quantum computations.
4. Enable Hybrid Computing: Ensure smooth interaction between quantum and classical systems for integrated
processing.

III. PREREQUISITES AND REQUIREMENTS:

1. Quantum Hardware Support: Must support the management of quantum processors, qubits, and quantum
gates.
2. Error Correction Mechanisms: Require advanced error correction techniques to mitigate noise and ensure
stable quantum computations.
3. Interfacing with Classical Systems: Ability to seamlessly integrate with classical computing systems for hybrid
workloads.
4. High-Performance Scheduling: Efficient scheduling and execution of quantum algorithms, balancing quantum
and classical resources.

IV. TECHNOLOGIES USED:

1. Real-Time Communication: WebSockets, Socket.io.

2. Data Structures: Stacks, Queues.
3. Backend: Node.js with Express.js.
4. Database: MongoDB for storing message history.

11
OSCSP07: OPERATING SYSTEM FOR SMART MANUFACTURING (INDUSTRY 4.0)

I. PROJECT OVERVIEW:

An Operating System for Smart Manufacturing (Industry 4.0) manages and optimizes smart factory operations by
integrating IoT, AI, robotics, and data analytics. It enables real-time monitoring, predictive maintenance, and automation,
improving efficiency, reducing costs, and enhancing decision-making in production processes.

II. OBJECTIVES:

1. IoT Integration: Enable seamless connection and communication between machines, sensors, and devices.
2. Data-Driven Optimization: Utilize analytics and AI for process optimization and predictive maintenance.
3. Automation Management: Coordinate automated machinery and robotics for efficient workflows.
4. Real-Time Monitoring: Provide live tracking and control for dynamic decision-making and operational
adjustments.

III. PREREQUISITES AND REQUIREMENTS:

1. IoT and Sensor Integration: Support for connecting and managing IoT devices and sensors for real-time data
collection.
2. Data Analytics and AI Capabilities: Ability to process large datasets and apply machine learning for
optimization and predictive maintenance.
3. Automation and Robotics Support: Integration with automated systems and robotics for streamlined
production processes.
4. Scalability and Reliability: Ensure the OS can scale with growing manufacturing demands and operate reliably
in real-time environments.

IV. TECHNOLOGIES USED:

1. Frontend: HTML/CSS for basic UI.

2. Backend: Python/Java for backend logic.
3. Database: SQLite or simple file storage for data persistence.
4. Data Structures: Binary Search Tree.
5. IDE: Visual Studio Code or Eclipse.

12
OSCSP08: OPERATING SYSTEM FOR AUGMENTED REALITY (AR) CLOUD INFRASTRUCTURE

I. PROJECT OVERVIEW:

An Operating System for Augmented Reality (AR) Cloud Infrastructure manages cloud resources to support real-
time AR applications, offloading heavy tasks like 3D rendering and object recognition from local devices. It ensures low-
latency content delivery, scalability for growing demand, and seamless cross-platform integration, providing efficient
and enhanced AR experiences.

II. OBJECTIVES:

1. Cloud-Based AR Processing: Offload heavy AR computations to the cloud for improved device performance.
2. Low-Latency Delivery: Ensure real-time, fast delivery of AR content to users with minimal delay.
3. Scalability: Support the scaling of AR applications to accommodate increasing data and user demand.
4. Cross-Platform Compatibility: Provide seamless AR experiences across various devices and platforms.

III. PREREQUISITES AND REQUIREMENTS:

1. Cloud Computing Capabilities: Robust infrastructure to handle AR processing, storage, and real-time data
management.
2. Low-Latency Communication: Fast and reliable network connectivity for seamless delivery of AR content to
end users.
3. Scalability: Ability to scale resources dynamically to support growing data and user traffic.
4. Cross-Platform Support: Ensure compatibility with multiple devices and AR platforms for a consistent user
experience.

IV. TECHNOLOGIES USED:

1. Frontend: HTML/CSS, JavaScript for user interface.

2. Backend: Node.js or Python Flask for server-side logic.
3. Database: MySQL or MongoDB for storing quiz data.
4. Data Structures: Stack for managing quiz flow.

13
OSCSP09: OPERATING SYSTEM FOR SECURE MULTI-PARTY COMPUTATION (MPC)

I. PROJECT OVERVIEW:

An Operating System for Secure Multi-Party Computation (MPC) enables multiple parties to compute a function
collaboratively while keeping their inputs private. It supports cryptographic techniques like secret sharing and
homomorphic encryption to protect data. The OS ensures secure, distributed computation, scalability, and efficiency,
making it ideal for privacy-preserving applications like secure voting and collaborative data analysis.

II. OBJECTIVES:

1. Privacy Preservation: Ensure that participants' inputs remain confidential during computation.
2. Cryptographic Security: Implement cryptographic techniques like secret sharing and homomorphic encryption
to safeguard data.
3. Secure Distributed Execution: Enable secure computation across multiple parties or systems.
4. Scalability and Efficiency: Ensure the system can handle large datasets and numerous participants without
compromising performance.

III. PREREQUISITES AND REQUIREMENTS:

1. Advanced Cryptographic Support: Capability to implement and manage cryptographic protocols like secret
sharing and homomorphic encryption.
2. Secure Communication Channels: Ensure encrypted and authenticated communication between all
participating parties.
3. Distributed Computing Infrastructure: Ability to manage and coordinate computation across multiple
systems or parties securely.
4. High Performance and Scalability: Handle large-scale computations and multiple participants efficiently
without compromising security.

IV. TECHNOLOGIES USED:

1. Frontend: React or Angular for the user interface.

2. Backend: Node.js, Flask, or Django for managing patient data.
3. Database: PostgreSQL or MongoDB.
4. Data Structures: Priority Queue.

14
OSCSP10:: ENERGY-EFFICIENT OPERATING SYSTEM FOR GREEN DATA CENTRES

I. PROJECT OVERVIEW:

An Energy-Efficient Operating System for Green Data Centres optimizes energy use while maintaining performance
and reliability. It manages power consumption through dynamic power scaling, intelligent workload allocation,
virtualization, and efficient cooling systems, reducing energy costs and environmental impact in data centers.

II. OBJECTIVES:

1. Optimize Power Consumption: Reduce energy usage by dynamically managing hardware power based on
demand.
2. Workload Efficiency: Distribute workloads intelligently to balance performance and energy usage.
3. Support Virtualization: Use virtual machines to consolidate resources and minimize energy waste.
4. Energy-Efficient Cooling: Optimize cooling systems to lower energy consumption and maintain optimal
temperature.

III. PREREQUISITES AND REQUIREMENTS:

1. Advanced Power Management: Support for dynamic power scaling and efficient energy usage across hardware
components.
2. Workload Scheduling: Ability to intelligently allocate workloads to balance energy consumption and
performance.
3. Virtualization Support: Integration with virtualization technologies for resource consolidation and
optimization.
4. Efficient Cooling Systems: Integration with cooling systems to optimize energy use based on temperature and
workload demands.

IV. TECHNOLOGIES USED:

1. Frontend: HTML5 Video Player for rendering the stream.

2. Backend: Python or Java for buffer management.
3. Data Structures: Double-ended Queue (Deque).
4. Streaming Protocol: HLS or RTSP for video streaming.

15
OSCSP11: OPERATING SYSTEM FOR AUTONOMOUS MARITIME VEHICLES

I. PROJECT OVERVIEW:

An Operating System for Autonomous Maritime Vehicles manages navigation, sensor integration, real-time decision-
making, and communication for autonomous vessels. It enables features like collision avoidance, route optimization, and
obstacle detection, ensuring safe and efficient operation in maritime environments.

II. OBJECTIVES:

1. Autonomous Navigation: Ensure safe, efficient route planning and navigation.

2. Sensor Integration: Integrate data from sensors like GPS, radar, and sonar for situational awareness.
3. Collision Avoidance: Detect and avoid obstacles or other vessels in real-time.
4. Reliable Communication: Maintain continuous communication with shore stations or other vessels.

III. PREREQUISITES AND REQUIREMENTS:

1. Advanced Navigation Systems: Support for GPS, radar, and other navigation technologies for accurate route
planning.
2. Sensor Integration: Capability to integrate various sensors for real-time environmental monitoring and
situational awareness.
3. Real-Time Processing: Ability to process data and make decisions rapidly for collision avoidance and dynamic
navigation.
4. Robust Communication: Reliable communication protocols for continuous interaction with shore stations or
other vessels.

IV. TECHNOLOGIES USED:

1. Global Navigation Satellite System (GNSS): Provides precise positioning and navigation, ensuring accurate
route planning and travel.
2. Radar and Sonar Systems: Essential for real-time detection of obstacles, underwater mapping, and ensuring
safe navigation.
3. Artificial Intelligence (AI) and Machine Learning: Powers real-time decision-making, path optimization, and
adaptation to changing environments.
4. Computer Vision: Utilizes cameras and image processing for object recognition and hazard detection in the
maritime environment.
5. Communication Protocols: Enables reliable communication between the vessel, shore stations, and other
vessels using technologies like satellite communication and VHF radio.

16
OSCSP12: OPERATING SYSTEM FOR HYPER-CONVERGED INFRASTRUCTURE (HCI)

I. PROJECT OVERVIEW:

An Operating System for Hyper-Converged Infrastructure (HCI) integrates computing, storage, and networking into
a unified platform for simplified management. It supports virtualization, automates orchestration, and allows easy
scalability, optimizing resource usage and enhancing operational efficiency in modern data centers.

II. OBJECTIVES:

1. Unified Resource Management: Integrate computing, storage, and networking for simplified management.
2. Virtualization Support: Enable efficient resource virtualization for better utilization and scalability.
3. Automated Orchestration: Automate deployment, scaling, and management of infrastructure to reduce manual
tasks.
4. Scalability: Provide seamless horizontal scalability by adding new nodes without disruptions.

III. PREREQUISITES AND REQUIREMENTS:

1. Hardware Compatibility: Support for diverse hardware platforms, including compute, storage, and networking
components.
2. Virtualization Technologies: Integration with hypervisors and virtual machines for resource virtualization and
management.
3. High-Performance Networking: Robust networking capabilities to handle high data throughput and low-
latency communication across nodes.
4. Scalability and Flexibility: Ability to scale seamlessly by adding new nodes and resources without downtime
or performance degradation.

IV. TECHNOLOGIES USED:

1. Programming Languages: Python/C++.

2. Data Structures: Binary heap, priority queue.
3. Visualization Tools: Tkinter (for Python GUI) or OpenGL for C++.
4. Algorithms: Scheduling algorithms (SJF, Priority Scheduling, etc.).

17
OSCSP13: OPERATING SYSTEM FOR SECURE IOT ECOSYSTEMS

I. PROJECT OVERVIEW:

An Operating System for Secure IoT Ecosystems ensures the security, management, and integration of IoT devices by
providing device authentication, data encryption, secure communication protocols, and efficient resource management.
It protects sensitive data, enables safe interactions between devices, and optimizes system performance in IoT
environments.

II. OBJECTIVES:

1. Device Authentication and Authorization: Securely manage device identity and access control.
2. Data Encryption: Protect data exchanged between devices and networks through encryption.
3. Secure Communication: Implement robust security protocols to ensure data integrity and confidentiality.
4. Efficient Resource Management: Optimize power, memory, and processing resources for IoT devices.

III. PREREQUISITES AND REQUIREMENTS:

1. Strong Security Framework: Support for encryption, secure authentication, and access control protocols.
2. Interoperability: Compatibility with a wide range of IoT devices, communication standards, and network
protocols.
3. Real-Time Processing: Ability to process data in real-time to ensure efficient and responsive IoT operations.
4. Scalability: Capability to manage a large number of IoT devices while maintaining performance and security.

IV. TECHNOLOGIES USED:

1. Programming Languages: Python, JavaScript.

2. Data Structures: Hash maps for counting word frequency.
3. Libraries/Frameworks: Matplotlib (Python), D3.js (JavaScript), WordCloud (Python).

18
OSCSP14: OPERATING SYSTEM FOR SPACE EXPLORATION MISSIONS

I. PROJECT OVERVIEW:

An Operating System for Space Exploration Missions supports space vehicles, satellites, and rovers by ensuring fault
tolerance, real-time data processing, autonomous operation, and efficient communication. It is designed to handle harsh
space environments and ensure mission-critical systems run reliably while maintaining communication with Earth.

II. OBJECTIVES:

1. Fault Tolerance: Ensure continuous operation despite hardware or environmental failures.

2. Real-Time Data Processing: Manage and process sensor data in real-time for mission decisions.
3. Autonomous Operation: Enable autonomous functionality for space vehicles during communication gaps.
4. Efficient Communication: Ensure reliable and secure communication with mission control on Earth.

III. PREREQUISITES AND REQUIREMENTS:

1. Radiation-Hardened Hardware: Ability to operate reliably in high-radiation environments typical in space.

2. Real-Time Processing Capabilities: Ensure the OS can handle real-time data processing for mission-critical
tasks.
3. Fault-Tolerant Design: Must include redundancy, error detection, and recovery mechanisms to ensure
continuous operation despite failures.
4. Efficient Communication Protocols: Support for secure and reliable communication with Earth, accounting
for long distances and time delays.

IV. TECHNOLOGIES USED:

1. Programming Languages: Python, Java.

2. Data Structures: Min-Max heaps for managing bids.
3. Database: MySQL or MongoDB for storing user and auction data.
4. Web Frameworks: Flask (Python), Spring Boot (Java).

19
OSCSP 15: OPERATING SYSTEM FOR COGNITIVE COMPUTING SYSTEMS

I. PROJECT OVERVIEW:

An Operating System for Cognitive Computing Systems manages AI, machine learning, and data analytics tasks,
enabling real-time learning and decision-making. It facilitates adaptive learning, efficient resource management, and
processes large datasets to support continuous system improvement and performance optimization.

II. OBJECTIVES:

1. AI and Machine Learning Integration: Support seamless integration of AI and machine learning algorithms.
2. Data Processing and Analytics: Efficiently manage and analyze large datasets for real-time insights.
3. Adaptive Learning: Enable systems to learn, adapt, and improve based on incoming data.
4. Resource Optimization: Optimize computational resources for handling complex cognitive tasks.

III. PREREQUISITES AND REQUIREMENTS:

1. AI and Machine Learning Frameworks: Support for popular AI and ML libraries and frameworks like
TensorFlow, PyTorch, or other cognitive tools.
2. High-Performance Computing: Sufficient computational power and memory to handle intensive data
processing and complex algorithms.
3. Scalable Architecture: Ability to scale efficiently to handle large datasets and growing computational demands.
4. Data Storage and Management: Robust systems for storing, retrieving, and managing vast amounts of
structured and unstructured data.

IV. TECHNOLOGIES USED:

1. Programming Languages: Java, C++.

2. Data Structures: Binary Search Trees.
3. Database: Optional integration with MySQL or SQLite for persistent storage.

20
OSCSP16: OPERATING SYSTEM FOR DIGITAL IDENTITY AND TRUST MANAGEMENT

I. PROJECT OVERVIEW:

An Operating System for Digital Identity and Trust Management ensures secure authentication, protects user privacy,
and manages trust relationships through cryptography and access control. It enables trusted online interactions, preventing
fraud and securing digital identities in applications like e-commerce and banking.

II. OBJECTIVES:

1. Secure Authentication: Ensure reliable user identification through methods like biometrics and multi-factor
authentication.
2. Trust Relationship Management: Verify and manage trust between users, devices, and services using
cryptographic techniques.
3. Privacy Protection: Safeguard sensitive personal data and ensure privacy in digital interactions.
4. Access Control: Enforce secure access policies based on roles, permissions, and security protocols.

III. PREREQUISITES AND REQUIREMENTS:

1. Advanced Cryptographic Algorithms: Support for encryption and digital signatures to secure identities and
data.
2. Multi-Factor Authentication: Integration with biometrics, hardware tokens, or other authentication methods
to enhance security.
3. Secure Communication Protocols: Use of protocols like TLS/SSL to ensure secure data transmission and
interaction.
4. Privacy Compliance: Adherence to privacy regulations (e.g., GDPR) to protect personal data and user privacy.

IV. TECHNOLOGIES USED:

1. Programming Languages: Python, Java.

2. Data Structures: Stack and Queue.
3. GUI Frameworks: Tkinter (Python) for a graphical user interface.

21
OSCSP 17: MULTI-MODAL USER INTERFACE OPERATING SYSTEM FOR MIXED REALITY

I. PROJECT OVERVIEW:

A Multi-Modal User Interface Operating System for Mixed Reality enables intuitive interactions through various
input methods like voice, gestures, touch, and eye-tracking. It integrates real-world and virtual elements in real-time,
ensuring a smooth, immersive experience. The OS combines data from multiple sensors and adapts to the user's
environment for dynamic, context-aware interactions.

II. OBJECTIVES:

1. Support Multiple Input Methods: Enable interactions through voice, gestures, touch, and eye-tracking.
2. Seamless Real-Time Integration: Integrate virtual objects with the physical environment smoothly.
3. Sensor Fusion: Combine data from various sensors for accurate user tracking and interaction.
4. Context-Aware Adaptation: Adapt to the user’s environment and context for a dynamic MR experience.

III. PREREQUISITES AND REQUIREMENTS:

1. Advanced Sensor Technologies: Integration with sensors such as cameras, accelerometers, gyroscopes, and
eye-tracking devices.
2. High-Performance Computing: Sufficient computational power for real-time rendering and processing of
immersive MR experiences.
3. Cross-Platform Compatibility: Ability to support various MR hardware (e.g., headsets, controllers) and
software platforms.
4. Low-Latency Communication: Ensure minimal delay in user input and system response to maintain immersion
and smooth interaction.

IV. TECHNOLOGIES USED:

1. Programming Languages: Python, C.

2. Data Structures: Circular Queues.
3. Data Storage: Optional database for persistent logging.

22
OSCSP 18: BLOCKCHAIN-BASED OPERATING SYSTEM FOR SECURE DIGITAL TRANSACTIONS

I. PROJECT OVERVIEW:

A Blockchain-Based Operating System for Secure Digital Transactions uses decentralized blockchain technology to
ensure secure, transparent, and immutable transaction records. It integrates smart contracts for automation, cryptographic
security for data protection, and real-time transaction verification to enhance trust and efficiency in digital transactions.

II. OBJECTIVES:

1. Decentralized Security: Ensure secure, tamper-proof transactions through blockchain’s distributed ledger.
2. Smart Contract Automation: Automate transaction processes and enforce rules without intermediaries.
3. Data Protection: Use cryptographic methods to safeguard sensitive transaction data.
4. Real-Time Verification: Provide fast, reliable transaction validation using consensus algorithms.

III. PREREQUISITES AND REQUIREMENTS:

1. Blockchain Infrastructure: A robust blockchain network with consensus algorithms (e.g., Proof of Work,
Proof of Stake) for transaction validation.
2. Cryptographic Tools: Support for strong encryption and cryptographic protocols (e.g., public-key
infrastructure) to ensure data security and privacy.
3. Smart Contract Capabilities: Integration of smart contract frameworks to automate and enforce transaction
terms.
4. High-Performance Computing: Sufficient computational resources to handle real-time transaction processing,
verification, and network maintenance.

IV. TECHNOLOGIES USED:

1. Programming Languages: Python, Java.

2. Algorithms: BFS, DFS for friend suggestions.
3. Frameworks: NetworkX (Python) for graph processing.

23
OSCSP 19: OPERATING SYSTEM FOR 5G NETWORK MANAGEMENT

I. PROJECT OVERVIEW:

An Operating System for 5G Network Management is designed to optimize and manage 5G networks, supporting
network slicing, real-time monitoring, and low-latency performance. It ensures scalability, flexibility, and efficient
resource allocation to meet the high demands of 5G technologies, enabling applications like autonomous vehicles and
IoT.

II. OBJECTIVES:

1. Network Slicing: Enable the creation of customizable virtual networks for different services.
2. Real-Time Monitoring: Continuously track and manage network performance and resources.
3. Low-Latency Optimization: Ensure minimal delay for critical applications.
4. Scalability and Flexibility: Support large-scale network operations and adapt to changing requirements.

III. PREREQUISITES AND REQUIREMENTS:

1. Advanced Network Protocols: Support for 5G-specific protocols like NR (New Radio), SDN (Software-
Defined Networking), and NFV (Network Functions Virtualization).
2. High-Performance Hardware: Scalable infrastructure to handle the high throughput and low latency demands
of 5G networks.
3. Real-Time Processing Capabilities: Ability to process large volumes of data with minimal delay to ensure
optimal performance.
4. Security Framework: Robust security measures to protect the network, including encryption, authentication,
and access control.

IV. TECHNOLOGIES USED:

1. Programming Languages: C, C++, Python.

2. Data Structures: Hash maps.
3. Caching Algorithms: Least Recently Used (LRU), Least Frequently Used (LFU).

24
OSCSP 20 : OPERATING SYSTEM FOR HYBRID CLOUD AND ON-PREMISE ENVIRONMENTS

I. PROJECT OVERVIEW:

An Operating System for Hybrid Cloud and On-Premise Environments enables seamless integration and
management of workloads across both on-premise infrastructure and cloud platforms. It offers resource orchestration,
and unified management, and ensures data security and compliance, allowing businesses to optimize performance,
scalability, and flexibility.

II. OBJECTIVES:

1. Seamless Integration: Enable smooth interoperability between on-premise and cloud infrastructures.
2. Resource Optimization: Dynamically allocate resources across hybrid environments for efficient workload
management.
3. Unified Management: Centralize control and monitoring of both on-premise and cloud-based resources.
4. Data Security and Compliance: Ensure secure data handling and regulatory compliance across environments.

III. PREREQUISITES AND REQUIREMENTS:

1. Cloud Integration Tools: Support for cloud services and APIs to enable smooth communication between on-
premise systems and cloud environments.
2. Scalable Infrastructure: Robust hardware and network architecture capable of handling both on-premise and
cloud-based workloads.
3. Virtualization and Containerization: Use of technologies like virtual machines and containers to ensure
portability and flexibility across environments.
4. Security Framework: Comprehensive security protocols, including encryption, identity management, and
access control, to protect data and ensure compliance.

IV. TECHNOLOGIES USED:

1. Programming Languages: Python, Java.

2. Data Structures: Stacks.
3. Security Libraries: Regex for pattern matching, bcrypt for hashing.

25
OSCSP 21: DESIGN AN OS KERNEL FOR AUTONOMOUS VEHICLES

I. PROJECT OVERVIEW:

The Autonomous Vehicle Operating System (AVOS) Kernel is designed to manage critical system operations for
autonomous vehicles. It provides real-time capabilities, ensuring safe, efficient, and reliable vehicle operation by
integrating sensor data, decision-making algorithms, and vehicle control systems. The kernel is responsible for resource
allocation, scheduling, and hardware abstraction, acting as the bridge between the vehicle's software stack and hardware.

II. OBJECTIVES:

1. Ensure real-time, high-priority task management for autonomous vehicle operations.

2. Enable seamless integration with diverse sensors (LiDAR, radar, cameras) and actuators.
3. Maintain system stability and fault tolerance in dynamic environments.
4. Provide robust security and safety protocols for operational integrity.
5. Facilitate vehicle decision-making processes via efficient communication between hardware and software
components.

III. PREREQUISITES AND REQUIREMENTS:

1. Hardware Requirements: High-performance processors, integrated sensors (e.g., cameras, LiDAR, GPS,
IMUs), and actuators.
2. Software Requirements: Real-time operating system capabilities, multitasking support, and low-level device
drivers.
3. Skill Requirements: Expertise in embedded systems programming, real-time systems, and autonomous
vehicle software development.
4. Safety Standards: Compliance with industry standards such as ISO 26262 for functional safety and SAE
J3016 for autonomous vehicle classification

IV. TECHNOLOGIES USED:

1. Programming Languages: C/C++ for low-level programming, Python for higher-level scripting.
2. Real-Time Operating System (RTOS): VxWorks, QNX, or custom RTOS for time-critical task management.
3. Sensor Integration: ROS (Robot Operating System) for sensor fusion and communication.
4. Security: AES encryption for secure communication between vehicle systems and edge devices.
5. Machine Learning: TensorFlow or PyTorch for implementing AI-driven decision-making algorithms.

26
OSCSP 22: DESIGN A HYBRID CPU SCHEDULER FOR MULTI-CORE SYSTEMS

I. PROJECT OVERVIEW:

The Hybrid CPU Scheduler for Multi-Core Systems is a sophisticated scheduling mechanism designed to optimize the
distribution of computational tasks across multiple CPU cores. The scheduler combines both Preemptive and Non-
preemptive scheduling techniques, offering flexibility to efficiently handle different types of workloads. This hybrid
approach ensures balanced resource utilization, minimizes context switching overhead, and improves system
responsiveness and throughput, especially in high-performance or real-time computing environments.
II. OBJECTIVES:

1.Optimal Load Balancing: Ensure efficient task distribution across all available cores to maximize parallelism
and minimize idle times.
2. Task Priority Management: Incorporate dynamic adjustment of task priorities to adapt to changing system
conditions, ensuring high-priority tasks receive adequate CPU time.
3. Reduced Context Switching: Minimize context switching overhead, which can negatively impact system
performance, especially in multi-core systems.
4. Support for Mixed Workloads: Handle both CPU-bound and I/O-bound tasks, optimizing for different
workload characteristics.
5. Real-Time Capabilities: Provide mechanisms for meeting deadlines for real-time tasks, maintaining both
fairness and responsiveness.
III. PREREQUISITES AND REQUIREMENTS:

1.
Hardware Requirements: Multi-core processor (quad-core, hexa-core, or higher), memory management unit
(MMU), and system support for parallel processing.
2. Software Requirements: A kernel capable of multi-core scheduling, support for inter-core communication, and
synchronization primitives (e.g., semaphores, mutexes).
3. Skill Requirements: Expertise in low-level system programming, OS internals (scheduling algorithms), multi-
threading, and performance optimization.
4. Performance Metrics: Tools to measure CPU utilization, task latency, throughput, and context switch overhead.
IV. TECHNOLOGIES USED:

1. Programming Languages: C/C++ for low-level OS kernel modifications, Python for simulation and
performance testing.
2. Multi-Core Synchronization: POSIX threads (pthreads) for inter-thread communication, locks, and barriers.
3. Preemptive Scheduling: Round Robin (RR), Shortest Job Next (SJN), or Priority Scheduling for time-sensitive
tasks.
4. Non-preemptive Scheduling: First-Come, First-Served (FCFS) or Longest Job First (LJF) for longer or less
time-sensitive tasks.
5. System Calls and Kernel Integration: Custom system calls for task migration between cores and dynamic
priority adjustment based on workload characteristics.
6. Performance Monitoring Tools: Intel VTune, perf, or custom profiling tools for real-time performance analysis
and optimization.

27
OSCSP 23: BUILD A SIMPLE VIRTUAL MEMORY SYSTEM THAT SIMULATES PAGING

I. PROJECT OVERVIEW:

This project involves developing a simple virtual memory system that simulates paging. Paging is a memory management
scheme that eliminates the need for contiguous allocation of physical memory. This system will manage the mapping
between virtual addresses used by a program and the physical addresses in the computer's memory.

II. OBJECTIVES:

1. Understand Virtual Memory: Gain a thorough understanding of how virtual memory works and the role of
paging in memory management.
2. Implement Paging: Create a simulation of a paging system to manage virtual and physical memory addresses.
3. Memory Management: Learn about various memory management techniques and their implementations.
4. Simulation: Develop a system that can simulate the behavior of a virtual memory system using paging.

III. PREREQUISITES AND REQUIREMENTS:

1. Basic Knowledge of Operating Systems: Understanding of basic operating system concepts, including
memory management.
2. Programming Skills: Proficiency in a programming language suitable for system-level programming, such as
C or C++.
3. Development Environment: Access to a development environment capable of compiling and running system-
level code.
4. Mathematics: Basic understanding of computer mathematics, including binary arithmetic.

IV. TECHNOLOGIES USED:

1. Programming Language: C or C++ for implementing the virtual memory system.

2. Development Tools: GCC (GNU Compiler Collection) or any other suitable compiler for compiling the code.
3. Version Control: Git for version control to manage code changes and collaboration.
4. Simulation Tools: Any additional tools required for simulating and testing the virtual memory system, such as
debugging tools and memory analysis tools.

28
OSCSP 24: DEVELOP AN APPROACH FOR EFFICIENTLY MANAGING MEMORY FRAGMENTATION

I. PROJECT OVERVIEW:

This project involves developing an approach for efficiently managing memory fragmentation. Memory fragmentation
occurs when free memory is scattered in small blocks throughout the system, making it difficult to allocate contiguous
blocks of memory to programs. This project aims to implement techniques to minimize and manage fragmentation,
improving overall memory utilization and performance.

II. OBJECTIVES:

1. Understand Memory Fragmentation: Gain a thorough understanding of the causes and types of memory
fragmentation (internal and external).
2. Implement Management Techniques: Develop and implement techniques to manage and reduce memory
fragmentation.
3. Improve Memory Utilization: Enhance memory utilization by efficiently allocating and deallocating memory
blocks.
4. Simulation and Testing: Simulate memory allocation scenarios to test the effectiveness of the implemented
fragmentation management techniques.

III. PREREQUISITES AND REQUIREMENTS:

1. Knowledge of Operating Systems: Understanding of basic operating system concepts, including memory
management and allocation techniques.
2. Programming Skills: Proficiency in a programming language suitable for system-level programming, such as
C or C++.
3. Development Environment: Access to a development environment capable of compiling and running system-
level code.
4. Algorithms and Data Structures: Knowledge of algorithms and data structures used in memory management,
such as linked lists and binary trees.

IV. TECHNOLOGIES USED:

1. Programming Language: C or C++ for implementing the memory fragmentation management techniques.
2. Development Tools: GCC (GNU Compiler Collection) or any other suitable compiler for compiling the code.
3. Version Control: Git for version control to manage code changes and collaboration.
4. Simulation Tools: Tools required for simulating and testing memory allocation and fragmentation scenarios,
such as debugging tools and memory analysis tools.

29
OSCSP 25: CREATE A SIMULATION OF DEMAND PAGING

I. PROJECT OVERVIEW:

Demand paging is a memory management scheme that loads pages into memory only when they are needed, reducing
memory usage and improving efficiency. This project aims to create a simulation of demand paging to demonstrate its
functionality and effectiveness.

II. OBJECTIVES:

1. Understand the concept of demand paging: Study the theory behind demand paging and its role in memory
management.
2. Simulate demand paging: Develop a program that simulates the demand paging process, including page faults,
page replacement algorithms, and memory allocation.
3. Analyze performance: Evaluate the performance of the simulation by measuring metrics such as page fault
rate, memory usage, and execution time.
4. Compare algorithms: Implement and compare different page replacement algorithms, such as FIFO (First-In-
First-Out), LRU (Least Recently Used), and Optimal Page Replacement.

III. PREREQUISITES AND REQUIREMENTS:

1. Knowledge of Operating Systems: A basic understanding of operating system concepts, particularly memory
management and paging.
2. Programming Skills: Proficiency in a programming language suitable for simulation, such as Python, C++, or
Java.
3. Mathematical Understanding: Familiarity with basic mathematical and statistical concepts to analyze
performance metrics.
4. Development Environment: A computer with an appropriate development environment set up (e.g., IDE,
compilers, libraries).

IV. TECHNOLOGIES USED:

1. Programming Language: The simulation can be developed using languages such as Python, C++, or Java,
depending on the developer's preference and expertise.
2. Development Tools: IDEs like Visual Studio Code, Eclipse, or PyCharm can be used to write and debug the
code.
3. Version Control: Git can be used for version control to manage changes and collaborate with others.
4. Libraries and Frameworks: Depending on the chosen language, relevant libraries and frameworks for
simulations and data analysis can be utilized.

30
OSCSP 26: CALCULATE AVERAGE SEEK TIME USING A DISK SCHEDULING SIMULATOR

I. PROJECT OVERVIEW:

Disk scheduling is crucial for optimizing the performance of a computer's storage system. This project aims to create a
disk scheduling simulator that can calculate the average seek time for different disk scheduling algorithms. The simulator
will help in understanding how various algorithms affect the performance of disk operations.

II. OBJECTIVES:

1. Understand disk scheduling algorithms: Study and understand different disk scheduling algorithms such as
FCFS (First-Come-First-Serve), SSTF (Shortest Seek Time First), SCAN, C-SCAN, and LOOK.
2. Simulate disk scheduling: Develop a simulator that implements these disk scheduling algorithms to handle
disk requests.
3. Calculate average seek time: Implement functionality in the simulator to calculate and report the average seek
time for each algorithm.
4. Compare performance: Compare the performance of different disk scheduling algorithms based on the average
seek time and other relevant metrics.

III. PREREQUISITES AND REQUIREMENTS:

1. Knowledge of Operating Systems: A basic understanding of operating system concepts, particularly disk
management and scheduling.
2. Programming Skills: Proficiency in a programming language suitable for simulation, such as Python, C++, or
Java.
3. Mathematical Understanding: Familiarity with basic mathematical and statistical concepts to calculate and
analyze performance metrics.
4. Development Environment: A computer with an appropriate development environment set up (e.g., IDE,
compilers, libraries).

IV. TECHNOLOGIES USED:

1. Programming Language: The simulator can be developed using languages such as Python, C++, or Java,
depending on the developer's preference and expertise.
2. Development Tools: IDEs like Visual Studio Code, Eclipse, or PyCharm can be used to write and debug the
code.
3. Version Control: Git can be used for version control to manage changes and collaborate with others.
4. Libraries and Frameworks: Depending on the chosen language, relevant libraries and frameworks for
simulations and data analysis can be utilized.

31
OSCSP 27: SIMULATE THE PERFORMANCE OF RAID LEVELS IN TERMS OF READ/WRITE
OPERATIONS

I. PROJECT OVERVIEW:

RAID (Redundant Array of Independent Disks) is a data storage virtualization technology that combines multiple physical
disk drives into one or more logical units for redundancy or performance improvement. This project aims to simulate the
performance of different RAID levels in terms of read/write operations to understand their impact on performance and
reliability.

II. OBJECTIVES:

1. Understand RAID levels: Study and understand different RAID levels such as RAID 0, RAID 1, RAID 5,
RAID 6, and RAID 10, including their architectures and benefits.
2. Simulate RAID performance: Develop a simulator to model the read/write operations for each RAID level.
3. Measure performance metrics: Implement functionality to measure and report performance metrics such as
read/write speed, fault tolerance, and disk utilization.
4. Compare RAID levels: Compare the performance and reliability of different RAID levels based on the collected
metrics.

III. PREREQUISITES AND REQUIREMENTS:

1. Knowledge of Storage Systems: A basic understanding of storage systems, disk operations, and RAID
concepts.
2. Programming Skills: Proficiency in a programming language suitable for simulation, such as Python, C++, or
Java.
3. Mathematical Understanding: Familiarity with basic mathematical and statistical concepts to calculate and
analyze performance metrics.
4. Development Environment: A computer with an appropriate development environment set up (e.g., IDE,
compilers, libraries).

IV. TECHNOLOGIES USED:

1. Programming Language: The simulator can be developed using languages such as Python, C++, or Java,
depending on the developer's preference and expertise.
2. Development Tools: IDEs like Visual Studio Code, Eclipse, or PyCharm can be used to write and debug the
code.
3. Version Control: Git can be used for version control to manage changes and collaborate with others.
4. Libraries and Frameworks: Depending on the chosen language, relevant libraries and frameworks for
simulations and data analysis can be utilized.

32
OSCSP 28: SIMULATE INDEXED, CONTIGUOUS, AND LINKED FILE ALLOCATION METHODS

I. PROJECT OVERVIEW:
File allocation methods are critical to understanding how file systems manage storage space on disks. This project aims
to simulate three fundamental file allocation methods: indexed, contiguous, and linked. Each method has unique
characteristics and advantages, impacting performance, space utilization, and complexity. By simulating these methods,
we will gain insights into their operational dynamics and practical implications in file systems.
II. OBJECTIVES:
1. Understand File Allocation Methods: Explore the principles and mechanisms of indexed, contiguous, and
linked file allocation methods.
2. Develop Simulations: Create software simulations for each file allocation method to demonstrate their working.
3. Analyze Performance: Evaluate the performance of each method in terms of access time, space utilization, and
complexity.
4. Compare and Contrast: Highlight the strengths and weaknesses of each allocation method based on the
simulation results.
5. Documentation and Reporting: Document the simulation process, results, and analyses in a comprehensive
project report.
III. PREREQUISITES AND REQUIREMENTS:
1. Basic Knowledge of File Systems: Understanding of how file systems manage and organize files on disk.
2. Programming Skills: Proficiency in a programming language such as Python, C++, or Java for developing
the simulations.
3. Data Structures and Algorithms: Familiarity with data structures (e.g., arrays, linked lists) and algorithms
for file management.
4. Development Environment: A suitable development environment with necessary compilers/interpreters
and libraries.
5. Simulation Specifications: Detailed specifications for each file allocation method to guide the simulation
development.
6. Performance Metrics: Criteria for evaluating the performance of each allocation method, including access
time and space efficiency.
IV. TECHNOLOGIES USED:
1. Programming Language: The simulations will be developed using a programming language such as
Python, C++, or Java.
2. Development Tools: Integrated Development Environments (IDEs) like Visual Studio Code, Eclipse, or
PyCharm.
3. Version Control: Git for version control and collaboration.
4. Data Visualization: Libraries or tools for visualizing performance metrics and simulation results (e.g.,
Matplotlib for Python).
5. Documentation: Tools for creating the project report, such as Microsoft Word.

33
OSCSP 29: DEVELOP MEMORY MANAGEMENT FOR LARGE-SCALE VIRTUALIZATION

I. PROJECT OVERVIEW:

Memory management is a crucial aspect of virtualization, particularly in large-scale environments where efficient use of
resources can significantly impact performance and scalability. This project focuses on developing advanced memory
management techniques tailored for large-scale virtualization. By exploring and implementing various strategies, the
project aims to optimize memory usage, enhance system performance, and ensure stability in virtualized environments.

II. OBJECTIVES:

1. Understand Virtualization Memory Management: Study the principles and techniques of memory
management in virtualized environments.
2. Develop Memory Management Strategies: Implement advanced memory management strategies, including
paging, segmentation, and memory overcommitment.
3. Optimize Performance: Enhance the performance and efficiency of virtual machines through optimized
memory allocation and management.
4. Ensure Stability and Scalability: Develop solutions to maintain system stability and scalability under heavy
workloads and high levels of virtualization.

III. PREREQUISITES AND REQUIREMENTS:

1. Knowledge of Virtualization: Understanding of virtualization concepts, hypervisors, and virtual machine

operations.
2. Operating Systems: Familiarity with operating system concepts, particularly memory management.
3. Programming Skills: Proficiency in programming languages such as C, C++, or Python for developing
memory management algorithms.
4. Data Structures and Algorithms: Knowledge of data structures and algorithms relevant to memory
management.
5. Development Environment: A suitable development environment with necessary compilers/interpreters and
libraries.
6. Simulation Tools: Tools for simulating virtualized environments and testing memory management strategies.
7. Performance Metrics: Criteria for evaluating the performance of memory management strategies, including
latency, throughput, and resource utilization.

V. TECHNOLOGIES USED:

1. Programming Languages: The project will utilize programming languages such as C, C++, or Python for
algorithm development.
2. Virtualization Platforms: Hypervisors like VMware, KVM, or Hyper-V for testing and evaluating memory
management strategies.
3. Development Tools: Integrated Development Environments (IDEs) like Visual Studio, Eclipse, or PyCharm.
4. Version Control: Git for version control and collaboration.
5. Data Visualization: Libraries or tools for visualizing performance metrics and results (e.g., Matplotlib for
Python).

34
OSCSP 30: DESIGN A VIRTUAL MEMORY SYSTEM THAT MINIMIZES PAGE FAULTS

I. PROJECT OVERVIEW:

Virtual memory systems are essential for managing the memory resources of modern operating systems, allowing for
efficient use of physical memory while providing the illusion of a large, continuous address space to applications. This
project aims to design a virtual memory system that minimizes page faults, which occur when a program tries to access
data not currently in physical memory. By implementing and optimizing various page replacement algorithms, the project
seeks to reduce the frequency of page faults, thereby enhancing system performance and application responsiveness.

II. OBJECTIVES:

1. Understand Virtual Memory Concepts: Explore the principles of virtual memory, including paging,
segmentation, and address translation.
2. Develop Page Replacement Algorithms: Implement and evaluate various page replacement algorithms such
as FIFO, LRU, and Optimal Page Replacement.
3. Minimize Page Faults: Optimize the virtual memory system to minimize the occurrence of page faults.
4. Performance Analysis: Analyze the performance of different algorithms in terms of page fault rates, memory
utilization, and execution time.
5. Documentation and Reporting: Document the design, implementation, and evaluation of the virtual memory
system in a comprehensive project report.

III. PREREQUISITES AND REQUIREMENTS:

1. Knowledge of Operating Systems: Understanding of operating system concepts, particularly memory

management and virtual memory.
2. Programming Skills: Proficiency in programming languages such as C, C++, or Python for developing and
simulating page replacement algorithms.
3. Data Structures and Algorithms: Knowledge of data structures and algorithms relevant to memory
management and page replacement
4. Development Environment: A suitable development environment with necessary compilers/interpreters and
libraries.
5. Simulation Tools: Tools for simulating virtual memory systems and testing page replacement algorithms.
6. Performance Metrics: Criteria for evaluating the performance of the virtual memory system, including page
fault rates and execution time.

V. TECHNOLOGIES USED:

1. Programming Languages: The project will utilize programming languages such as C, C++, or Python for
algorithm development and simulation.
2. Development Tools: Integrated Development Environments (IDEs) like Visual Studio, Eclipse, or PyCharm.
3. Version Control: Git for version control and collaboration.
4. Simulation Frameworks: Frameworks or libraries for simulating virtual memory and page replacement
algorithms (e.g., SimPy for Python).
5. Data Visualization: Libraries or tools for visualizing performance metrics and results (e.g., Matplotlib for
Python).

35
OSCSP 31: OPTIMIZATION OF ADVANCED PAGE REPLACEMENT ALGORITHMS FOR REAL-WORLD
MEMORY ACCESS PATTERNS.

I. PROJECT OVERVIEW:

Page replacement algorithms are vital in managing the limited physical memory in computer systems by deciding which
pages to swap in and out of memory. Advanced page replacement algorithms aim to improve system performance by
reducing page faults, especially under real-world memory access patterns, which can be unpredictable and complex. This
project focuses on implementing advanced page replacement algorithms and optimizing them for real-world scenarios to
enhance efficiency and performance in memory management.

II. OBJECTIVES:

1. Understand Page Replacement Fundamentals: Study the fundamental principles of page replacement
algorithms and their impact on system performance.
2. Implement Advanced Algorithms: Develop and implement advanced page replacement algorithms such as
LRU-K, ARC (Adaptive Replacement Cache), and CLOCK-Pro.
3. Optimize for Real-World Patterns: Analyze and optimize these algorithms for real-world memory access
patterns, ensuring they perform efficiently under varying workloads.
4. Performance Evaluation: Evaluate the performance of the implemented algorithms using metrics like page
fault rate, execution time, and memory utilization.

III. PREREQUISITES AND REQUIREMENTS:

1. Operating Systems Knowledge: Understanding of core operating system concepts, particularly memory
management and page replacement.
2. Programming Skills: Proficiency in programming languages such as C, C++, or Python for developing and
optimizing algorithms.
3. Data Structures and Algorithms: Knowledge of relevant data structures and algorithms used in memory
management.
4. Development Environment: A robust development environment equipped with necessary compilers,
interpreters, and libraries.
5. Simulation Tools: Tools or frameworks for simulating memory management and testing page replacement
algorithms.
6. Performance Metrics: Defined criteria for evaluating the performance of page replacement algorithms,
focusing on real-world memory access patterns.

IV. TECHNOLOGIES USED:

1. Programming Languages: The project will use languages such as C, C++, or Python for developing and
simulating page replacement algorithms.
2. Development Tools: Integrated Development Environments (IDEs) like Visual Studio, Eclipse, or PyCharm for
coding and debugging.
3. Version Control Systems: Git for managing code versions and collaborative development.
4. Simulation Frameworks: Libraries or frameworks for simulating memory management operations and page
replacement algorithms (e.g., SimPy for Python).
5. Data Visualization: Tools for visualizing performance data, such as Matplotlib

36
OSCSP 32: DEVELOP A REAL-TIME PROCESS SCHEDULER PROJECT.

I. PROJECT OVERVIEW:

A real-time process scheduler is crucial for systems that require timely and predictable execution of tasks. Unlike
traditional schedulers, real-time schedulers must ensure that critical tasks meet their deadlines, which is essential in
applications such as embedded systems, industrial control systems, and multimedia applications. This project aims to
develop a real-time process scheduler that can efficiently manage and schedule tasks to meet their real-time requirements.

II. OBJECTIVES:

1. Understand Real-Time Scheduling Principles: Study the fundamental concepts of real-time systems and
scheduling algorithms.
2. Develop a Real-Time Scheduler: Implement a real-time process scheduler using algorithms such as Rate
Monotonic Scheduling (RMS), Earliest Deadline First (EDF), and Least Laxity First (LLF).
3. Ensure Deadline Adherence: Optimize the scheduler to ensure that tasks meet their deadlines, minimizing
latency and maximizing predictability.
4. Performance Evaluation: Evaluate the performance of the scheduler using metrics such as task completion
rate, deadline miss rate, and system overhead.
5. Documentation and Reporting: Document the design, implementation, and evaluation of the real-time process
scheduler in a comprehensive project report.

III. PREREQUISITES AND REQUIREMENTS:

1. Knowledge of Operating Systems: Understanding of operating system concepts, particularly process

scheduling and real-time systems.
2. Programming Skills: Proficiency in programming languages such as C, C++, or Python for developing the
scheduler.
3. Algorithms and Data Structures: Knowledge of data structures and algorithms relevant to process scheduling
and real-time systems.
4. Development Environment: A robust development environment equipped with necessary compilers,
interpreters, and libraries.
5. Simulation Tools: Tools or frameworks for simulating real-time systems and testing the scheduler.
6. Performance Metrics: Defined criteria for evaluating the performance of the scheduler, focusing on real-time
requirements.

IV. TECHNOLOGIES USED:

1. Programming Languages: The project will use languages such as C, C++, or Python for developing and
simulating the real-time scheduler.
2. Development Tools: Integrated Development Environments (IDEs) like Visual Studio, Eclipse, or PyCharm for
coding and debugging.
3. Version Control Systems: Git for managing code versions and collaborative development.
4. Simulation Frameworks: Libraries or frameworks for simulating real-time systems and process scheduling
algorithms (e.g., SimPy for Python).

37
OSCSP 33: DESIGN A MULTI-LEVEL QUEUE SCHEDULING ALGORITHM FOR MULTIPROCESSOR
SYSTEMS

I. PROJECT OVERVIEW:

Multi-level queue scheduling is a process scheduling algorithm that partitions the ready queue into several separate
queues, each with its own scheduling algorithm. This project aims to design and implement a multi-level queue scheduling
algorithm tailored for multiprocessor systems. The focus will be on balancing the load across multiple processors while
ensuring efficient and fair scheduling of tasks in different priority queues.

II. OBJECTIVES:

1. Understand Multi-Level Queue Scheduling: Study the principles and benefits of multi-level queue scheduling
in multiprocessor environments.
2. Design the Scheduling Algorithm: Develop a multi-level queue scheduling algorithm that can effectively
manage tasks across multiple processors.
3. Implement Load Balancing: Ensure that the load is evenly distributed among processors to maximize system
performance and minimize idle time.
4. Optimize for Fairness and Efficiency: Optimize the algorithm to ensure fairness among tasks and efficient
utilization of processing resources.
5. Performance Evaluation: Evaluate the performance of the scheduling algorithm using metrics such as CPU
utilization, task throughput, and average waiting time.
6. Documentation and Reporting: Document the design, implementation, and performance evaluation processes
in a comprehensive project report.

III. PREREQUISITES AND REQUIREMENTS:

1. Operating Systems Knowledge: Understanding of operating system concepts, particularly process

scheduling and multiprocessor systems.
2. Programming Skills: Proficiency in programming languages such as C, C++, or Python for developing
and testing the scheduling algorithm.
3. Data Structures and Algorithms: Knowledge of data structures and algorithms relevant to process
scheduling and load balancing.
4. Development Environment: A robust development environment equipped with necessary compilers,
interpreters, and libraries.
5. Simulation Tools: Tools or frameworks for simulating multiprocessor systems and testing the scheduling
algorithm.
6. Performance Metrics: Defined criteria for evaluating the performance of the scheduling algorithm,
focusing on multiprocessor efficiency.
7.
IV. TECHNOLOGIES USED:

1. Programming Languages: The project will use languages such as C, C++, or Python for developing and
simulating the scheduling algorithm.
2. Development Tools: Integrated Development Environments (IDEs) like Visual Studio, Eclipse, or PyCharm for
coding and debugging.
3. Version Control Systems: Git for managing code versions and collaborative development.
4. Simulation Frameworks: Libraries or frameworks for simulating multiprocessor systems and scheduling
algorithms (e.g., SimPy for Python).

38
OSCSP 34: DESIGN AN INDEXING METHOD THAT ALLOWS FAST SEARCH AND RETRIEVAL OF
FILES IN A DISTRIBUTED SYSTEM

I. PROJECT OVERVIEW:

In distributed systems, where files are spread across multiple nodes or servers, efficient indexing is essential for fast
search and retrieval operations. A well-designed indexing method ensures that users can quickly locate and retrieve the
desired files, even as the system scales. This project aims to design an indexing method for a distributed file system that
allows for fast, efficient, and reliable search and retrieval of files. The indexing method will optimize for factors such as
latency, scalability, and fault tolerance while ensuring the system remains flexible for large-scale use cases.

II. OBJECTIVES:

1. Understand Distributed File Systems: Study the architecture and challenges of distributed file systems,
particularly in terms of indexing and file retrieval.
2. Design Efficient Indexing Method: Develop a robust indexing structure that ensures fast search and retrieval
of files in a distributed system.
3. Scalability: Ensure that the indexing method scales efficiently as the size of the file system and number of nodes
in the distributed environment grows.
4. Fault Tolerance: Incorporate mechanisms for fault tolerance and data redundancy to ensure that files can still
be retrieved even if a node or server goes down.
5. Optimization for Search and Retrieval: Focus on minimizing query latency and ensuring optimal file retrieval
times, even with a large number of files.

III. PREREQUISITES AND REQUIREMENTS:

1. Distributed Systems Knowledge: Understanding of the principles behind distributed systems, including file
storage, replication, and fault tolerance.
2. Database and Indexing Concepts: Knowledge of indexing techniques (such as B-trees, hash indexing, and
inverted indexing) and database management systems.
3. Programming Proficiency: Proficiency in programming languages like Python, Java, or C++ for implementing
the indexing algorithm and building the distributed system simulation.
4. Development Environment: An environment that supports distributed system simulation (e.g., Docker for
containerization, or cloud platforms like AWS or GCP for distributed node deployment).
5. Distributed System Simulation Tools: Tools to simulate file distribution across multiple nodes (e.g., Apache
Hadoop, Apache Spark, or custom node simulation).

IV. TECHNOLOGIES USED:

1. Programming Languages: Python, Java, or C++ will be used to implement the indexing method and build the
distributed file system.
2. Distributed Frameworks: Apache Hadoop, Apache Spark, or custom server and node simulation to create and
manage distributed systems for testing the indexing method.
3. Database Technologies: NoSQL databases like MongoDB or key-value stores like Redis to manage and retrieve
files in a distributed environment.
4. Networking: Use of networking protocols and tools like gRPC, REST APIs, or sockets to simulate
communication between distributed nodes.

39
OSCSP 35: CREATE A SYSTEM THAT HANDLES PAGE FAULTS EFFICIENTLY IN A REAL-TIME
ENVIRONMENT

I. PROJECT OVERVIEW:

In a real-time environment, where tasks must be executed within strict timing constraints, managing memory efficiently
becomes crucial for ensuring that processes meet deadlines. One of the key challenges in memory management is
handling page faults, which occur when a program attempts to access data that is not currently in physical memory. This
project aims to design and implement a system that minimizes page faults and handles them efficiently in real-time
environments. The system will focus on reducing the latency caused by page faults and ensuring that memory
management does not interfere with the time-critical operations required in real-time systems.

II. OBJECTIVES:

1. Minimize Page Faults: Develop strategies to minimize the occurrence of page faults in a real-time environment,
including preemptive and non-preemptive memory management techniques.
2. Optimize Page Fault Handling: Implement algorithms for fast page fault handling, ensuring that tasks are not
delayed significantly by the page replacement process.
3. Real-Time Priority Management: Ensure that real-time tasks are prioritized during page fault handling to
avoid missing deadlines.
4. Evaluate Algorithms: Compare different page replacement algorithms (e.g., Least Recently Used, Optimal,
Clock) in the context of real-time systems, measuring performance in terms of latency and task completion.
5. Memory Efficiency: Ensure that the memory system can handle a large number of processes while optimizing
memory usage and minimizing overhead.

III. PREREQUISITES AND REQUIREMENTS:

1. Real-Time Operating Systems (RTOS): Understanding of the fundamentals of real-time operating systems,
scheduling algorithms, and memory management techniques.
2. Memory Management Techniques: Familiarity with concepts like virtual memory, page tables, page
replacement algorithms, and their impact on system performance.
3. Programming Skills: Proficiency in low-level programming languages such as C or C++ to implement memory
management and system algorithms.
4. Development Tools: An environment that supports low-level system programming, such as GCC for C/C++ or
an RTOS like FreeRTOS for simulation.
5. Simulation Tools: Tools for simulating a real-time environment with varying task loads and memory access
patterns, such as real-time scheduling simulators or custom testing frameworks.

IV. TECHNOLOGIES USED:

• Programming Languages: C or C++ will be used to implement the memory management system and the page
fault handling mechanism, as they provide direct control over memory and system resources.
• Real-Time Operating System (RTOS): FreeRTOS or a similar RTOS will be used for managing real-time
scheduling and task execution, ensuring that tasks are given priorities and executed within specified time
constraints.

40