Projects

A listing of some of the projects I completed during the course of my professional career, graduate and undergraduate studies, and high school

CS-6515 Graduate Algoithms
Dr. Eric Vigoda (Ph.D. UC Berkeley), Dr. Gerandy Brito (Ph.D. UW)
Summer 2023

Dynamic Programming for Optimal Substructure Problems

Objective: To develop efficient algorithms using dynamic programming to solve problems with overlapping subproblems and optimal substructure.
Implementation: Designed and implemented algorithms for classic problems like the Longest Increasing Subsequence (LIS), Knapsack Problem, and Matrix Chain Multiplication. Each solution was optimized to reduce time complexity, demonstrating significant performance improvements over naive approaches.
Outcome: Gained expertise in identifying and applying dynamic programming techniques to real-world problems, enhancing algorithm efficiency and effectiveness.

Graph Algorithms for Network Optimization

Objective: To explore and implement algorithms for network flow and shortest path problems in weighted and unweighted graphs.
Implementation: Implemented Dijkstra’s and Bellman-Ford algorithms for single-source shortest paths, and the Ford-Fulkerson method for computing maximum flow in a network. Tested these algorithms on various graph datasets to ensure robustness and scalability.
Outcome: Strengthened my understanding of graph theory and its practical applications in network design and optimization, particularly in scenarios involving complex routing and resource allocation.

Approximation Algorithms for NP-Hard Problems

Objective: To devise approximation algorithms for NP-hard problems where exact solutions are computationally infeasible.
Implementation: Focused on problems such as the Traveling Salesman Problem (TSP) and Vertex Cover. Developed and analyzed approximation algorithms that provide near-optimal solutions within a guaranteed factor of the optimal solution.
Outcome: Enhanced problem-solving skills by exploring the trade-offs between computational efficiency and solution accuracy, and learned how to apply these principles to large-scale, real-world problems.

Randomized Algorithms and Probabilistic Analysis

Objective: To understand and implement randomized algorithms and perform probabilistic analysis for problems where deterministic approaches are either too slow or complicated.
Implementation: Worked on algorithms like the Randomized QuickSort and Monte Carlo algorithms for primality testing. Evaluated their performance through rigorous statistical analysis and compared it with deterministic counterparts.
Outcome: Gained insight into the power of randomness in algorithms, particularly in scenarios where performance can be significantly improved by incorporating probabilistic methods.

CS-7641 Machine Learning
Dr. Charles Isbell (Ph.D. MIT), Dr. Michael Littman (Ph.D. Brown)
Spring 2023 (Expected)

Supervised Learning

Implemented of Decision Trees (pruned), Neural Networks, Boosting, Support Vector Machines, and K-nearest neighbours
Training the aforementioned algorithms on two large datasets in order to analyse how they perform in testing and validation phases
Performed hyperparamter tuning to achieve optimal accuracy
Learning curves generated in order to compare their performance

Randomized Optimization

The aim of this assignment is to get acquainted with localized random search algorithms, namely, Randomized Hill Climbing (RHC), Simulated Annealing (SA), Genetic Algorithms (GA), and Mutual Information Maximizing Input Clustering (MIMIC). I solved fives problems of mathematical and discrete nature (that can be solved using randomized optimization techniques) with the aforementioned algorithms (randomized optimization techniques for choice of a better phrase) in order to find the maximum fitness function
Problems solved and analysed:
- Four-Peaks
- N-Queens
- Knapsack
- One-Max
- Max-K-Color

Unsupervised Learning and Dimensionality Reduction

The aim of this assignment is to acquaint oneself with a couple of unsupervised learning and dimensionality reduction techniques on two large datasets of our choice (with multiple features so that we have enough features to select/reduce)
Implemented K-Means Clustering and Expectation Maximization as clustering algorithms for unsupervised learning
Implemented PCA (Principal Component Analysis), ICA (Independent Component Analysis), Randomized Projects, and Feature Variance Thresholding as dimensionality reducation algorithms
Analysed the performance of combinations of the aforementioned clustering and dimensionality techniques on the chosen datasets and performed hyperparameter tuning in order to yield accurate modeling results

Markov Decision Processes

Explored various reinforcement learning techniques an agent can use to make decisions.
An analysis of two interesting Markov Decision Processes (MDPs) is conducted using two planning algorithms, namely, value iteration and policy iteration, along with one reinforcement learning algorithm, namely, Q-Learning.
The MDPs are selected carefully to be able to draw conclusions as to which algorithm suits what type of problem best (non-grid world, grid world, number of states, etc.).
Chosen MDPs:

Frozen Lake 4x4
Frozen Lake 16x16
Taxi

Experiments conducted using Gymnasium (a maintained fork of OpenAI's Gym library)

CS-6601 Artificial Intelligence
Dr. Thad Starner (Ph.D. MIT)
Summer 2022

Isolation Player

Use the MINIMAX and alpha-beta pruning techniques and experiment with evaluation functions to create a program that can play a variant of the game Isolation better than a human

Search

Experiment with various search techniques to discover the most efficient way to find the shortest path between three places in a city

Bayes Nets

Implement Bayesian networks and sampling algorithms to gain a better understanding of probabilistic systems

Decision Trees

Build, train, and test several decision tree models to perform basic classification tasks

Gaussian Mixture Models

Implement k-means clustering and Gaussian mixture models to perform basic image segmentation. Research, implement, and test the Bayesian Information Criterion to guarantee a more robust image segmentation

Hidden Markov Models

Implement the Viterbi and Forward-Backward algorithm to recognize signals using HMMs

CS-6263/ECE-8813 Introduction to Cyber-Physical Systems Security
Dr. Raheem A Beyah (Ph.D. Georgia Tech), Dr. David Joyner (Ph.D. Georgia Tech)
Fall 2021

Paper Presentation

Secure and Efficient Software-based Attestation for Industrial Control Devices with ARM Processors

Design and Implementation of Controllers for Industrial Control Systems using Factory I/O, Control I/O, and block-diagram logic programming

Ladder Logic Programming using OpenPLC

Robot Path
Traffic Lights
Tank Balancer
Stirring Systems
Car Parking

Reconnaissance and Attack on ICS Networks

Understanding the Modbus protocol
Interfacing with Industrial Control Systems using Mininet, Python and Wireshark

Vulnerability Exploitation in Industrial Control Systems Protocol

Implementation of buffer overflow exploits using x86 Assembly, C, and GDB

CS-6210 Advanced Operating Systems
Dr. Umakishore Ramachandran (Ph.D. University of Wisconsin, Madison)
Fall 2021

Virtual Machine Scheduling in KVM

Implemented a vCPU scheduler and a memory coordinator to dynamically manage resources assigned to each guest virtual machine
Memory ballooning driver implementation

Barrier Synchronization

Implementation of barrier synchronization algorithms from the paper titled "Algorithms for Scalable Synchronization on Shared-Memory Multiprocessors, by John M. Mellor-Crummey (Rice University) and Michael L. Scott (University of Rochester), ACM Transactions on Computer Systems Vol. 9, No. 1, February, 1991"
Barriers implemented using OpenMP: Sense-Reversing Centralized Barrier and the MCS Tree Barrier
Barriers implemented using Open MPI: MCS Tree Barrier and Dissemination Barrier
Barriers benchmarked on Georgia Tech's Supercomputing cluster, PACE (Partnership for an Advanced Computing Environment)
Simulations carried out on 1-12 CPUs with each CPU capable of executing upto 12 simultaneous threads

A multi-threaded e-Commerce Store in a distributed service

Distributed service implementation using gRPC (Google RPC) for RPC services and Protocol Buffers as the IDL (Interface Definition Language
Asynchronous RPC communication model: Clients <---> Store Service <---> Vendors

Implementation of the MapReduce programming model in a distributed service

Distributed service implementation using gRPC (Google RPC) for RPC services and Protocol Buffers as the IDL (Interface Definition Language
In line with the specifications as per the paper titled "MapReduce: Simplified Data Processing on Large Clusters, J. Dean, S. Ghemawat, Google Inc. OSDI 2004"
Creation of file shards/partitions for mapping
Implementation of a Mapper and a Reducer service

CS-6200 Graduate Introduction to Operating Systems
Dr. Ada Gavrilovska (Ph.D. Georgia Tech)
Summer 2021

File-server

Implementation of a multi-threaded (boss-worker pattern) file server servicing a pool of clients in C

Proxy server using Inter-Process Communication

Implementation of a proxy server to act as an intermediary between a file server and its clients using libcurl's Easy Interface
Implementation of a cache server to act as an alternate file source in a client-proxy-server setup
Support for multiple proxy servers by incorporating multi-threading constructs in addition to shared memory and message queues (POSIX and SystemV)

Distributed File System using RPC (Remote Procedure Call) protocol service

Built a series of remote procedure calls (RPCs) and message types that fetch, store, list, and delete files in addition to getting file attributes/statistics in a distributed file system (one file server and multiple clients)
Used gRPC (Google RPC) for RPC services and Protocol Buffers as the IDL (Interface Definition Language)
Watcher thread implemented to be on a lookout for changes in the mounted directories
File content synced between clients and servers using asynchronous calls between server and clients to update the client/clients in case a file/files/directory changes on the server and vice versa
Mutexes and condition variables set in place in order to avoid race conditions and to avoid multiple writers from accessing the same file/directory

CS-6250 Computer Networks
Dr. Maria Konte (Ph.D. Georgia Tech)
Spring 2021

Simulating networks and topologies (simple, complex, datacenter) in Mininet
Spanning tree protocol implementation
Distance Vector Routing protocol implementation
SDN firewall (using POX OpenFlow Controller) implementation
BGP hijacking in a sandbox environment
BGP measurements

CS-6290 High Performance Computer Architecture
Dr. Milos Prvulovic (Ph.D. UIUC)
Fall 2020

SESC (Super ESCalar) Simulator

Benchmarks: splash2 suite (Stanford Parallel Applications for Shared-Memory), lu decomposition, raytrace, fmm
Profiling MIPS compatible binaries and tweaking CPU and cache configuration parameters in order to achieve optimal branch prediction accuracy and execution times in out-of-order processors
Implemented a new cache policy (Next-to-LRU) in the SESC simulator
Implemented new profiling counters for read/write cache misses (compulsory, conflict, capacity, replacement, coherence) in the SECS simulator
Modified cache policy (Random, LRU, Next-to-LRU), cache size, associativity (4-way set associative, direct mapped), latency
Modified branch predictors (Not-taken, Hybrid)
Conclusions drawn by comparing compulsory, conflict, and capacity read/write misses in 4-way set-associative and direct-mapped caches
In multi-core processors, conclusions drawn by comparing compulsory, replacement, and coherence read/write misses after tweaking number of threads in CPU configurations

CS-6023 Introduction to Information Security
Dr. Mustaque Ahamad (Ph.D. SUNY Stony Brook), Dr. Wenke Lee (Ph.D. Columbia)
Fall 2020

Software security Buffer overflow - implement a stack overflow attack and a return-to-libc buffer overflow attack in a sandbox environment
Malware analysis Analyze malware samples using Cuckoo and report the findings of various malware behaviors
Cryptography Exploiting RSA vulnerabilities using Python scripting (Broadcast RSA attack, detection of weak keys in network devices, get private key in a small key-space)
Web security Implement SQL Injection, XSS, and XSRF attacks in a sandbox environment

CS-6291 Embedded Software Optimization (also referred to as Embedded System Optimization)
Dr. Santosh Pande (Ph.D. NC State)
Summer 2020

VLIW Scheduler

Developed a VLIW Scheduler to convert 1-wide into 4-wide VEX ISA instructions
Handled shared resource accesses and computed data dependence graphs i.e. memory and register dependencies
Computed schedules with the least number of cycles using various tie-breaking (to decide which instruction goes next) heuristics

ARM and THUMB partitioning in RISC programs

Convert CISC programs into RISC programs to be executed and benchmarked on an ARMv8 (Cortex-A53) platform
Benchmarks: jpeg-6b, mpeg2enc, mpeg2dec
Libraries divided into ARM and THUMB partitions (procedure, file, library scope) after profiling
Partitions tweaked to achieve optimal execution times and binary sizes

Enterprise Network Messaging System
(circa 2017)

A messaging system in object oriented paradigms with a load balancer scalable to ‘n’ number of servers distributed across the enterprise network with over a hundred thousand clients TPKT Packet Handler for TCP Sockets in line with RFC 1006 and RFC 2126 A wrapper for UDP Sockets for the reliable delivery of datagrams Message Rate of ~1000+ messages per server Asynchronous Socket Model