Projects

  • 2017

  • Implementing Unified Memory on GPGPU-Sim : GPGPU-Sim is a functional and timing simulator working with CUDA 4.0 which lacks a memory management unit. This is an attempt to implement unified memory on GPGPUSim in both functional and timing simulation perspective and make it work with CUDA 8.0 which ships with unified memory implementation cudaMallocManaged() compatible with NVIDIA Pascal predecessors. code report
  • Scanning Linux Kernel source directory: Kernel scanner is an attempt to scan the Linux kernel directory and divide all the existing functions into two distinct categories of safe and unsafe i.e. starting from a system call, a process will be preempted if it uses one of the unsafe system calls. code
  • Genomics of Drug Sensitivity in Cancer (GDSC): Using machine learning, we try to create a model to identify the response of cell lines (cancer tissues) applying anti-cancer drugs. The trained model has 0.75 percent accuracy and 0.57 AUROC. The dataset contains 140 drugs applied on 624 cell lines and each cell line has 22712 features. code

  • 2016

  • Adaptive Intelligence Optimizer (AIO): In this project, we forge the Adaptive Intelligence Optimizer (AIO) which harnesses the advantages of a bi-population Particle Swarm Optimization (PSO) to escape from the local minimum and avoid premature convergence. Furthermore, using the rich framework of Slow Intelligence System (SIS) and the nifty control theory that Learning Automata (LA) derived from, we find the perfect matching between SIS and LA where acting slowly is the pillar of both of them. Both SIS and LA need time to converge to the optimal decision where this enables AIO to outperform standard PSO having an incomparable performance on evolutionary optimization benchmark functions. presentation code
  • Filesystem in Userspace (FUSE): Writing a user space program in C language which is able to process the most of file-related system calls in the user space such as create/read a directory and create/read/write a file. This newly created file system interacts with UNIX/Linux programs in a transparent way using a single file that represents the disk drive.
  • Virtual Memory Implementation: Implementing a 32-bit virtual memory in C language. This program simulates the entire process of performing a page walk starts from querying the value of CR3 register and looking for the faulted Page Directory Entry and Page Table Entry and ends with returning the physical memory address. Along with this program four page replacement algorithms including Optimal, Clock, LRU, and Aging are implemented. report
  • InterProcess Communication (IPC): Implementing the producer/consumer problem using three processes which are created by fork() and communicating with each other via shared memory. For synchronization purpose, a new system call is added to the Linux kernel that creates a semaphore data type supporting up() and down() mutual exclusion operations.
  • Graphics Library: A small graphic library that can set a pixel to a particular color, draw some basic shapes, and read key presses. This library uses the mmap() system call to map the file descriptor of the Linux video display which is called framebuffer to a memory region and then uses the pointer arithmetic to set each individual pixel.
  • Mini Java Compiler: A tiny compiler for a tiny language. The Mini Java Compiler is a simple compiler for the simple educational language of Mini Java. The projects follows the standard process of creating a compiler for C/C++ and JAVA. First, a Lexer is written in LEX for tokenizing the input program and initializing a String Table. Next, a Parser is written in YACC for communicating with the lexer and producing the Parse Tree. After that, a Semantic Analyzer creates a Symbol Table and performs the semantic actions by traversing the parse tree and manipulating the symbol table. Then, a Code Generator parses the parse tree and generates the corresponding codes compatible with MIPS R2000 architecture. Finally, the generated code is executed on a bare metal machine using SPIM S20 simulator.

  • 2015

  • Mini Google: This project presents mini Google which is a full stack implementation of a search engine. Mini Google is built on top of an inverted index which is the central data structure of a search engine indexing algorithm. It allows fast full-text searches and retrieves by following the in-memory computing paradigm. Mini Google follows the client/server architecture and keeps the computation in helper nodes while serving trivial index/retrieve operations in master node. It is designed around master/slave architecture to provide high availability feature by failure detection and data replication. Furthermore, it is a multithread implementation of a system software in C language which allows concurrent and resilient index/retrieve operations. Finally, mini Google accepts index/retrieve operations via both SSH session and web browser. report
  • Simple Remote Procedure Call (SRPC): The Remote Procedure Call (RPC) is a technology for creating distributed client/server applications. As an inter-process communication technique, RPC enables client program to request a service from server program that is located in another machine from another network. In this project, the systematic and implementation details of a Simple RPC (SRPC) in C language is discussed. The SRPC is armed with a directory service which is responsible for storing servers’ endpoint addresses and verifying clients' endpoint queries. The directory service act as a central information repository for servers and clients while addressing the scalability issue of client/server architecture. The current SRPC implementation utilizes a well-defined message passing convention for parameter marshaling along with upper and lower levels data structures for efficient integration of various logical components of SRPC. The SRPC uses a simple 4 steps register, resolve, verify, check processes for server registration, server resolution, client verification and client checking. Also, it implements a common marshaling interface that is purely data type driven and optimizes the buffer size and number of send/receive attempts. report
  • Planning System: A Partial Order Planner (POP) algorithm in Python that tries to automate the planning process and leaves decisions about the ordering of actions as open as possible. The developed POP algorithm is able to solve any planning problems with a set of initial and goal conditions, and a set of actions with some preconditions and effects. report