Divyansh Chhabria

Course Project: Linux Kernel Programming (Jan'24 - April'24)

• Implemented a new system call in the Linux kernel designed to clone multi-threaded processes, enabling the creation of new processes that inherit the multi-threaded state of the original process, thereby improving process management and resource utilization in a multi-threaded environment.


• Modified the do_signal_stop and do_notify_parent_cldstop functions to ensure that when a SIGSTOP signal is sent by any thread to a sibling thread, all threads within the process, except the leader, are stopped. This change ensures consistent process suspension behavior across all threads within the process group.


• Cloned the process leader by hooking into the schedule_tail function and replicated the thread group by invoking the kernel_clone function with parameters similar to those used in pthread_create. This approach facilitated the accurate replication of thread states and attributes in the new process.


• Configured the new threads to match the execution states of the original threads, ensuring that the newly cloned threads retained the same operational state as their counterparts in the original process, thus maintaining the consistency and integrity of thread execution across the cloned process.

GitHub Repository

Course Project: Compiler Design (Jan'24 - April'24)

• Developed a compiler for a statically typed subset of Python, targeting x86_64 machine code. The compiler was designed to efficiently translate high-level Python code into low-level assembly, ensuring proper optimization for x86_64 architecture. This project involved in-depth knowledge of both Python semantics and the underlying hardware architecture to achieve a seamless translation from source code to machine code.


• Utilized Flex for lexical analysis to tokenize the input Python code, breaking it down into meaningful units such as keywords, variables, and symbols. Used Bison for syntactic analysis, building a parser to check for proper syntax and generate an Abstract Syntax Tree (AST). The AST served as an intermediate representation of the source code, capturing its structure and making it easier to traverse for further compilation steps.


• Implemented a comprehensive symbol table to keep track of variable declarations, scope, and types, ensuring that all identifiers were properly managed throughout the program's execution. Developed register allocation techniques to efficiently assign variables to CPU registers, optimizing performance. Additionally, implemented Three-Address Code (3AC) generation for an intermediate representation, followed by the generation of x86 assembly code, which was directly executable on x86_64 hardware.


• Extended support for object-oriented programming concepts such as classes and multilevel inheritance, enabling complex hierarchical structures in programs. Implemented function overloading to allow multiple functions with the same name but different signatures.

GitHub Repository

Course Project: Opearting Systems (Mar'23 - April'23)

• Implemented the du utility to display disk usage of files and directories, along with custom dynamic memory management functions memalloc and memfree to efficiently allocate and free memory blocks during runtime, ensuring optimal memory usage in programs.


• Developed a trace buffer mechanism, along with dynamic tracing tools such as strace and ftrace, to capture and log system call activity and function execution, providing detailed runtime information for debugging and performance analysis purposes.


• Implemented mmap, munmap, and mprotect system calls to handle memory mapping and protection of virtual memory regions, while adding support for lazy allocation, allowing memory pages to be allocated only when accessed, optimizing memory usage and reducing overhead.


• Implemented the cfork system call with a copy-on-write (CoW) policy, ensuring that memory pages are only duplicated when modified. Additionally, designed and implemented a CoW fault handler to efficiently manage page faults during process forking, optimizing memory management and process creation.

GitHub Repository

Course Project: Computer Organization (Mar'23 - April'23)

• Designed and developed the CSE Bubble Processor, focusing on key components such as the Arithmetic Logic Unit (ALU), which was responsible for executing arithmetic and logical operations. The ALU was implemented using a top-down design approach, supporting a range of instructions, including R-type (register), I-type (immediate), and J-type (jump) instructions, to ensure comprehensive functionality of the processor.


• Implemented a Finite State Machine (FSM) to efficiently generate the control signals required for smooth processor operations. The FSM played a crucial role in managing the flow of instructions, controlling the execution stages, and ensuring that each component received the appropriate signals for correct operation based on the processor's current state.


• Implemented the Bubble Sort algorithm in MIPS assembly code, translating the high-level logic into MIPS instructions. The MIPS code was then translated into machine code that adhered to the Instruction Set Architecture (ISA) of the CSE Bubble processor, ensuring the processor could understand and execute the instructions in a binary format, demonstrating the complete functionality of the processor.

GitHub Repository

Course Project: Software Development and Operations (Jan'23 - April'23)

• Collaborated in a 10-member team and developed a software for digitalizing mess, canteen operations, bookings, and housekeeping services in the halls of residence at IIT Kanpur, enhancing transparency and minimizing paperwork


• Developed the software project using the waterfall model, divided the project into distinct stages, such as requirements gathering, design, implementation, testing, and maintenance, with each stage building on the previous one ensuring that each stage was completed thoroughly before moving onto the next one, with focus on proper documentation.


• Utilized Figma to design the frontend and Django Framework of Python to develop the backend functionality, while also performing unit-testing using the Django-Test Framework and integration-testing using Selenium, to ensure quality and reliability of the software.


• Managed the project timeline, conducted regular team meetings to discuss over project progress, risks & opportunities, delegated tasks, ensured that all team members were on track to meet project goals, and successfully delivered the project on time.

GitHub Repository

Course Project: Introduction to Machine Learning (Jan'23 - Feb'23)

• Designed and implemented a machine learning model capable of cracking an Advanced XOR Ring Oscillator (XORRO) Physically Unclonable Function (PUF) with 16 XORROs, each comprising 64 XOR gates, by accurately predicting the XORRO with a higher frequency in any given pair.


• Devised a method for generating new, complete, and consistent 1040 feature vectors from the original set of feature vectors, which included both 64 config bits and 8 selection bits, resulting in a linear model over the new feature vectors that consistently delivers accurate results.


• Achieved outstanding results in accuracy using the LinearSVC model with L1 penalty, attaining a remarkable 99.82% accuracy on the training dataset and 99.2% accuracy on the testing dataset.

GitHub Repository

Course Project: Introduction to Machine Learning (March'23 - April'23)

• Developed a decision tree learning algorithm for a word guessing game, utilizing a dictionary of 5167 words and only 15 trials to accurately guess the correct word with the additional constraint that characters were only revealed if they were at the same location in both the secret and query word.


• Developed and implemented an efficient algorithm that utilized dynamic programming to determine the optimal query word at each node of a decision tree used for a word matching task that resulted in node splitting, with the query word selected to maximize the number of matching characters at corresponding positions among the words in the node.


• Learnt a decision tree that achieved 100% accuracy, with remarkable performance metrics including a fast training time of 0.23 seconds, a compact model size of 1551.7 Kb, and an impressive average of 3.706 queries per round.

Self Project (Oct'22 - Dec'22)

• Learnt techniques such as L2 and dropout regularization, hyperparameter tuning, batch normalization, and gradient checking and implemented and applied a variety of optimization algorithms, such as mini-batch gradient descent, Momentum, RMSprop and Adam, while checking for their convergence.


• Learnt to use best practices to train and develop test sets and analyzed bias/variance for building DL applications, used standard NN techniques, applied optimization algorithms, and implemented a neural network in TensorFlow.


• Diagnosed errors in a machine learning system; understood complex ML settings, such as mismatched training/test sets and applied end-to-end learning, transfer learning, and multi-task learning.

   

GitHub Repository

Mentor: Prof. Ashwani Thakur, Biological Sciences and Bioengineering, IIT Kanpur (Sept'22 - Oct'22)

• Conducted in-depth research on Nobel Laureates Dr. Hargobind Khorana, Dr. W. Stanley, and Dr. Marshall Nirenburg, reading and summarizing their research papers to gain a comprehensive understanding of their work and contributions to the field of genetics.


• Studied the transfer of genetic information, DNA replication, and the cracking of the genetic code through articles and transcribed interviews, deepening knowledge of these topics and their implications in genetics research.


• Demonstrated strong research skills and attention to detail, synthesizing complex information into clear and concise summaries and analyses for effective communication of scientific concepts to both technical and non-technical audiences.

Association of Computing Activities, IIT Kanpur (Aug'22 - Oct'22)

• Acquired fundamental knowledge on algorithms and data structures, including time complexity, binary search, graph algorithms like BFS and DFS, modular inverse, and binary exponentiation, through the project.


• Gained practical experience in solving problems efficiently in competitive programming, enhancing problem-solving skills.


• Developed a solid foundation in computer science concepts, equipping me with the necessary skills to tackle complex problems and find effective solutions.

Course Project: Manufacturing Processes - II(Jan'22 - April'22)

• Collaborated with a team of 10 members under the supervision of laboratory staff to manufacture a motor-driven model of an orrery using 4 pairs of gears, which involved milling, lathe work, assembling, and other machining procedures with a high degree of accuracy.


• Demonstrated expertise in precision machining techniques and strong teamwork skills to create a fully functional model of an orrery, showcasing the ability to work efficiently in a team-based environment while maintaining high quality standards.

Course Project: Manufacturing Processes - I(Aug'22 - Nov'22)

• Collaborated with a team of 9 members to design and construct a functional wheelchair model using various manufacturing techniques, including welding, brazing, moulding, casting, sheet-metal cutting, and folding.


• Supervised by laboratory staff, gained hands-on experience in wheelchair design and synthesis, demonstrating proficiency in practical skills such as assembly, measurement, and machining.


• Successfully completed the project, producing a fully functional wheelchair model that met the required specifications, highlighting strong problem-solving and teamwork abilities.