firstName

lastName

email

message

updatesConsent

Let’s talk... 💬

Ben House

This project focuses on collecting and analyzing public comment data from a popular website. By downloading and storing the data locally, I explored patterns in user activity and content through visualizations and data analysis.

### **A Journey Through Public Comment Data**

#### **Chapter 1: The Inception**

It all started with a question: *What can we learn from the vast ocean of public comments floating around the internet?* These comments—raw, unfiltered opinions shared by people across the world—are a treasure trove of insights waiting to be uncovered. As someone deeply fascinated by data, I decided to dive into this ocean and see what treasures I could find.

My project began with a simple idea: collect public comment data from a popular website, store it in a local database, and then analyze it to extract meaningful patterns. But like any good journey, the path was full of unexpected twists and turns, each adding to the richness of the experience.

#### **Chapter 2: The Hunt for Data**

The first challenge was finding the right data. Public comments are scattered across countless websites, each with its own structure and format. I chose to focus on a popular site where users freely share their thoughts on a wide range of topics. The site provided an API, which I used to systematically download the comments.

But downloading data is never as simple as it seems. I had to navigate through API rate limits, handle incomplete data, and ensure that the comments were downloaded in a structured format. After several iterations and tweaks to my script, I finally had a robust process in place.

```python
import requests

# Requesting comments from the API
response = requests.get("https://example.com/api/comments")
comments = response.json()

# Handling API rate limits and retries
while not response.ok:
    time.sleep(5)
    response = requests.get("https://example.com/api/comments")
    comments.extend(response.json())
```

With the data in hand, the next step was to figure out how to store it efficiently.

#### **Chapter 3: Building the Foundation**

Storing the comments presented its own set of challenges. With thousands of comments to manage, I needed a database that could handle the load while allowing me to easily query and analyze the data. I opted for SQLite, a lightweight yet powerful relational database.

Designing the database schema was crucial. Each comment needed to be associated with a user, a timestamp, and other metadata. Normalizing the data—splitting it into related tables—helped to ensure that the database was efficient and scalable.

```python
import sqlite3

# Establishing a connection to the SQLite database
conn = sqlite3.connect('comments.db')
cursor = conn.cursor()

# Creating tables for comments and users
cursor.execute('''CREATE TABLE users (
                    user_id INTEGER PRIMARY KEY,
                    username TEXT)''')

cursor.execute('''CREATE TABLE comments (
                    comment_id INTEGER PRIMARY KEY,
                    comment_text TEXT,
                    user_id INTEGER,
                    timestamp DATETIME,
                    FOREIGN KEY(user_id) REFERENCES users(user_id))''')

# Populating the database with downloaded comments
for comment in comments:
    cursor.execute('''INSERT INTO users (user_id, username)
                      VALUES (?, ?)''', (comment['user_id'], comment['username']))

    cursor.execute('''INSERT INTO comments (comment_id, comment_text, user_id, timestamp)
                      VALUES (?, ?, ?, ?)''', 
                   (comment['id'], comment['text'], comment['user_id'], comment['timestamp']))

conn.commit()
```

With the database set up, I felt like I had built the foundation of a house—now it was time to start constructing the walls and filling it with content.

#### **Chapter 4: Delving Into the Data**

With the data securely stored, I was eager to start analyzing it. I began with some basic queries to understand the structure of the comments—how many users were contributing, what times of day were most active, and which topics were generating the most discussion.

```python
# Query to find the most active users
cursor.execute('''SELECT user_id, COUNT(*) as comment_count 
                  FROM comments 
                  GROUP BY user_id 
                  ORDER BY comment_count DESC''')
most_active_users = cursor.fetchall()
```

One of the first insights was the distribution of comments over time. I created a histogram to visualize the number of comments posted at different times of the day. This revealed interesting patterns, such as peaks in activity during certain hours, which I hadn't anticipated.

![](/images/ALL.png)

The deeper I dug, the more fascinating the data became. I analyzed the text of the comments to identify common themes and topics. By counting word frequencies and analyzing word pairs, I began to see the underlying connections between different topics.

***

#### **Chapter 5: Visualizing the Story**

Understanding the data was one thing—communicating it was another. I knew that to truly tell the story of the data, I needed to visualize it. I turned to Python’s powerful visualization libraries, such as Matplotlib and Seaborn, to create graphs that could bring the data to life.

```python
import matplotlib.pyplot as plt

# Creating a histogram of comment times
plt.figure(figsize=(10, 5))
plt.hist(comment_times, bins=24, color='purple')
plt.title('Comment Activity Over 24 Hours')
plt.xlabel('Hour of the Day')
plt.ylabel('Number of Comments')
plt.grid(True)
plt.show()
```

#### **Chapter 6: Exploring Deeper Connections**

But I wanted to go further. Inspired by the connections I saw in the data, I decided to create a word graph—an interactive visualization that would show the relationships between words in the comments. This graph would highlight common word pairs, with the thickness of the lines indicating the strength of the connection.

```python
import networkx as nx
import matplotlib.pyplot as plt

# Building the word graph
G = nx.Graph()

# Adding nodes and edges based on word co-occurrences
for word1, word2, count in word_pairs:
    G.add_edge(word1, word2, weight=count)

# Drawing the graph
plt.figure(figsize=(12, 12))
nx.draw(G, with_labels=True, node_size=[G.degree(n) * 100 for n in G.nodes()],
        font_size=10, node_color='skyblue', edge_color='gray', linewidths=1, 
        font_weight='bold')
plt.title('Word Co-occurrence Graph')
plt.show()
```

This visualization was a game-changer. It not only provided insights into the common themes within the comments but also made the analysis process more engaging and interactive.

This visual is currently being process for display.

#### **Chapter 7: Refining the Visuals**

Creating visualizations is often an iterative process. As I developed more graphs, I refined them to better communicate the insights I was discovering. I experimented with different color schemes, layouts, and interactive features, aiming to make the graphs both informative and aesthetically pleasing.

***

![](/images/comments_per_hour_polar_plot.png)

***

Here's some notable trends for commenting of certain users:

![](/images/u_fDfQq5MTbe5U_time_schedule.png)
![](/images/u_irVPE208HfSb_time_schedule.png)
![](/images/u_Q3HuWuzdXfCR_time_schedule.png)

***

#### **Chapter 8: The Journey Continues**

This project has been a journey in every sense of the word—from the initial spark of curiosity to the final visualizations that brought the data to life. Along the way, I learned a great deal about data collection, storage, and analysis, as well as the art of storytelling through visualization.

But this is just the beginning. There are still more insights to uncover, more visualizations to create, and more stories to tell. I plan to continue exploring this data, refining my analyses, and sharing my findings with the world.

Stay tuned as I continue to dive deeper into the data and uncover more of the stories hidden within!

***

### **Conclusion**

This project has been a labor of love, combining my passion for data with the thrill of discovery. By methodically collecting, storing, and analyzing public comment data, I've been able to extract valuable insights and present them in a way that is both engaging and informative. I hope this story inspires others to explore the potential of data and to see the beauty in the patterns that lie beneath the surface.

***

### **References**

*   [Python Requests Library](https://requests.readthedocs.io/)
*   [SQLite Documentation](https://www.sqlite.org/docs.html)
*   [Matplotlib Documentation](https://matplotlib.org/stable/contents.html)
*   [NetworkX Documentation](https://networkx.github.io/documentation/stable/)

***


Online Forum Analyze

This project focuses on building custom implementations of malloc(), calloc(), free(), and realloc() in C. It optimizes memory management by reducing fragmentation and enhancing performance, offering deeper insight into low-level memory handling and C programming.

## Key Skills Acquired

Before diving into the project, it's essential to highlight some of the key skills and concepts that were central to this endeavor:

*   **Dynamic Memory Allocation**: Implementing and understanding `malloc()`, `calloc()`, `free()`, and `realloc()` functions in C.
*   **Memory Optimization**: Reducing fragmentation and improving allocation efficiency through various optimization techniques.
*   **C Programming**: Mastering low-level memory management in C, including pointer arithmetic and memory block management.
*   **System-Level Programming**: Gaining a deeper understanding of how the operating system interacts with dynamic memory allocation.

## The Goal: Recreating and Optimizing Core Memory Functions

Dynamic memory allocation is a cornerstone of system-level programming in C. The standard library provides several key functions—`malloc()`, `calloc()`, `free()`, and `realloc()`—to manage memory at runtime. However, these functions are often treated as black boxes by most developers. My goal was to recreate these functions from scratch, implementing them with a focus on performance and efficiency.

### Understanding the Basics

#### `malloc()`

The `malloc()` function allocates a specified amount of memory and returns a pointer to the beginning of the block. The memory is uninitialized, meaning it contains garbage data.

#### `calloc()`

Unlike `malloc()`, `calloc()` allocates memory for an array of elements and initializes all bytes to zero. This is particularly useful when you need a clean memory slate.

#### `free()`

The `free()` function deallocates previously allocated memory, making it available for future use. Properly implementing `free()` is crucial to avoid memory leaks and ensure efficient memory reuse.

#### `realloc()`

The `realloc()` function adjusts the size of a previously allocated memory block. It’s a versatile function that either expands or shrinks the memory while preserving the data.

## The Implementation: Recreating the Core Functions

### Building the Foundation

The first step was to set up a memory pool that our custom allocator could manage. I used the `sbrk()` system call to expand the program's data space, creating a large, contiguous block of memory to work with.

```c
void *memory_pool = sbrk(POOL_SIZE);
if (memory_pool == (void*) -1) {
    // Handle error
}
```

### Implementing `malloc()`

The custom `malloc()` function needed to find a free block of memory within our pool. I implemented a first-fit strategy to locate the first block large enough to satisfy the allocation request.

```c
void *my_malloc(size_t size) {
    Block *curr = free_list;
    while (curr) {
        if (curr->free && curr->size >= size) {
            curr->free = 0;
            // Split block if necessary
            return (void*)(curr + 1);
        }
        curr = curr->next;
    }
    // Allocate more memory if no suitable block is found
}
```

### Implementing `calloc()`

For `calloc()`, I built upon the `malloc()` function but added an initialization step to zero out the allocated memory.

```c
void *my_calloc(size_t num, size_t size) {
    size_t total_size = num * size;
    void *ptr = my_malloc(total_size);
    if (ptr) {
        memset(ptr, 0, total_size);
    }
    return ptr;
}
```

### Implementing `free()`

The `free()` function marked a block as free and attempted to merge adjacent free blocks to reduce fragmentation.

```c
void my_free(void *ptr) {
    if (!ptr) return;
    
    Block *block = (Block*)ptr - 1;
    block->free = 1;
    
    // Coalesce adjacent free blocks
    coalesce_free_blocks(block);
}
```

### Implementing `realloc()`

The `realloc()` function presented a unique challenge, as it needed to adjust the size of a block while preserving its content. If the block could not be resized in place, the function would allocate a new block, copy the data, and free the old block.

```c
void *my_realloc(void *ptr, size_t size) {
    if (!ptr) return my_malloc(size);
    if (size == 0) {
        my_free(ptr);
        return NULL;
    }
    
    Block *block = (Block*)ptr - 1;
    if (block->size >= size) {
        // Resize in place
        return ptr;
    } else {
        // Allocate new block
        void *new_ptr = my_malloc(size);
        if (new_ptr) {
            memcpy(new_ptr, ptr, block->size);
            my_free(ptr);
        }
        return new_ptr;
    }
}
```

## Optimizing Memory Allocation

### Fragmentation Reduction

One of the significant challenges with dynamic memory allocation is fragmentation, where small, unused memory blocks are scattered throughout the pool. To combat this, I implemented block coalescing in the `free()` function, which merged adjacent free blocks into a single larger block.

### Efficient Block Splitting

When a large block is split into a smaller block during allocation, the remainder of the block could be wasted. To avoid this, I ensured that any leftover memory after a split was added back to the free list, making it available for future allocations.

### Quick-Fit Arrays

For common allocation sizes, I implemented a quick-fit array. This array pre-allocated blocks of specific sizes, reducing the time needed to find a suitable block for these frequent requests.

## Conclusion: A Deeper Understanding of Memory Management

Recreating `malloc()`, `calloc()`, `free()`, and `realloc()` was a challenging and insightful project. It required a deep dive into how memory is managed at the system level and forced me to think critically about optimization techniques. The experience has not only enhanced my understanding of dynamic memory allocation but also improved my overall C programming skills.

This project serves as a reminder that sometimes, the best way to understand how something works is to build it yourself. Through this process, I gained valuable insights into the inner workings of memory management in C and developed a more profound respect for the complexities involved.


Dynamic Memory Allocator in C

Here are some of the graphs

Gallery

I led the development of a machine learning model to reduce Penn State's carbon emissions, winning $500 in the Nittany AI Challenge.

# My Journey with C0: Achieving Carbon Neutrality at Penn State

## Introduction

The journey to developing the C0 project was both challenging and rewarding. As the main developer, I had the opportunity to dive deep into the intersection of machine learning, data analysis, and environmental sustainability. Our goal was clear: to create a practical solution that would help Penn State achieve carbon neutrality, and our efforts ultimately led to winning $500 from the Nittany AI Challenge.

## The Problem

Penn State spends an enormous amount annually on energy, with the majority of it contributing to greenhouse gas emissions. With the global climate crisis becoming more urgent, it was essential to find a way to reduce these emissions efficiently. Our project aimed to address this by developing a predictive model that could help identify and mitigate emissions from various sectors on campus.

## The Development Process

### Getting Started

I began by gathering and cleaning a vast amount of weather and energy usage data from Penn State's databases. This data formed the backbone of our project, allowing us to train a neural network to predict future emissions. The data preparation process involved a lot of manual effort, but it was crucial to ensure the accuracy and reliability of our predictions.

### Building the Model

With the data ready, I used PyTorch to develop a neural network that could predict energy usage based on various factors such as temperature, humidity, wind speed, and more. Here's a snippet of the code that powered our model:

```python
import torch
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt

device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using {device} device")

data_path ="C:\\Users\\Ben House\\Documents\\C0\\NittanyAI_Weather&EnergyDataLimitedCleaned.csv"
train_data_np = np.genfromtxt(data_path,dtype=np.float32,delimiter=",")
heading = np.genfromtxt(data_path, np.unicode_,delimiter=",")[0]
print(heading)
train_data_np = np.delete(train_data_np, (0), axis=0)
df = pd.DataFrame(data = train_data_np, columns = heading)
print(df)
```

This code snippet demonstrates how I loaded and prepared the data for training. The model itself was a simple yet powerful neural network designed to learn the complex relationships between weather conditions and energy usage.

### Training the Neural Network

Training the model was an iterative process. I used a Stochastic Gradient Descent optimizer and Mean Squared Error loss function to minimize the prediction error. The process wasn't always smooth—there were moments of frustration when the loss value stagnated—but persistence paid off. Here's a glimpse of the training loop:

```python
for epoch in range(500):
    y_pred = model(x)
    loss = criterion(y_pred, y)
    print('epoch:', epoch, 'loss:', loss.item())

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
```

Despite the challenges, I was able to achieve a level of accuracy that was satisfactory for our goals. The model's predictions allowed us to identify key areas where emissions could be reduced, making it a valuable tool for Penn State's sustainability efforts.

### Visualization and Community Engagement

One of the project's key components was making the data accessible and understandable to a broader audience. I implemented visualizations that highlighted the correlation between different variables and energy usage. Additionally, we developed a mobile app that included a reward system to incentivize student participation in reducing carbon emissions.



### The Outcome

The hard work paid off when our proposal won $500 in the Nittany AI Challenge. It was a moment of pride for the entire team, and it validated the countless hours we had spent developing the project. But more importantly, it felt good to contribute something meaningful to the fight against climate change.

## Conclusion

The C0 project was a significant milestone in my journey as a developer. It taught me the value of persistence, teamwork, and the impact that technology can have on solving real-world problems. I'm proud of what we accomplished, and I look forward to continuing to develop solutions that make a difference.


C0 Nittany AI

A full-stack e-commerce developed for local deployment

## Introduction

The E-Commerece website was developed for a database management class in university for a fictitious customer that wanted an auction similar website for the local community. The development process was divided into two parts. First off, the goal was to create a feasibility study for the website which will outline how the website will be made from the code to the database design. The second stage was developing the website itself.

### **Deploying LionAuction: A Feasibility Study**

Here's a summary of the results of the study.

**Introduction**

The LionAuction project is designed to create an online auction platform specifically for the LSU community. Modeled after successful platforms like eBay, LionAuction aims to facilitate the buying and selling of used and new items, targeting a niche audience within LSU.

**Background**

The idea for LionAuction emerged from a market investigation at LSU, which identified a need for a local platform where students and staff could easily auction items, particularly textbooks. With a significant portion of college students sourcing their textbooks second-hand, this platform addresses a clear demand.

**Project Scope**

The scope of this feasibility study includes the design and implementation strategies for the LionAuction platform, focusing on the database design and technical considerations. However, aspects such as costs, data hosting, and promotional strategies were not covered.

**Requirement Analysis**

The project identified several user roles, including bidders, sellers, and help desk employees, each with distinct functionalities on the platform. The website is designed to be user-friendly, featuring registration, product listing, bidding, and customer support.

**Database Design**

A significant portion of the project was dedicated to designing a robust database. The conceptual database design includes an entity-relationship (ER) model that outlines the relationships between different entities like users, products, bids, and tickets. This model ensures that the platform can handle the complex interactions between various users and items efficiently.

![ER\_Diagram](/images/Project_431W%20-%20Page%201.jpeg)

**Technology Survey**

The project compared different technologies for implementation, such as PHP vs. Python for the backend and MySQL vs. SQLite for database management. After a thorough evaluation, recommendations were made to use technologies that align with industry standards and best practices.

**Conclusion**

The study concludes that developing the LionAuction platform is feasible from a technical standpoint. The proposed database design and technology choices provide a solid foundation for the platform's development. However, further analysis is required to address other aspects like cost, server infrastructure, and regulatory compliance.

**Next Steps**

Moving forward, the project will need to consider additional factors such as funding, regulatory requirements, and a detailed implementation plan. These will be crucial for turning the LionAuction concept into a fully functional platform. <embed src="/LionAuctionReport_House.pdf" width="100%" height="600px" type="application/pdf">

### **Building the LionAuction Website: A Developer's Journey**

**Technology Stack**

The website was developed using a combination of Flask for the backend, SQLite for the database, and basic HTML/CSS for the frontend. Flask was chosen for its simplicity and flexibility, making it ideal for this project. SQLite was selected as the database due to its lightweight nature, which is sufficient for the platform’s current needs.

**Backend Development**

The backend is the heart of LionAuction, managing user sessions, handling requests, and interacting with the database. Key functionalities were implemented in the `app.py` file, which serves as the entry point for the Flask application.

1. **User Authentication and Session Management**  
   The website supports multiple user roles, including bidders, sellers, and help desk employees. Session management was crucial for ensuring that users are correctly routed based on their roles. Upon logging in, users are redirected to the appropriate dashboard based on their role, with session data securely managed using Flask's session handling capabilities.

   ```python
   @app.route('/')
   def index():
       if 'email' not in session.keys():
           return redirect('/login')
       if 'user_type' not in session.keys():
           return redirect('/select_user_type')
       # Redirect based on user type
       if session['user_type'] == 'seller':
           return redirect('/seller')
       elif session['user_type'] == 'bidder':
           return redirect('/bidder')
       elif session['user_type'] == 'helpdesk':
           return redirect('/helpdesk')
   ```

2. **Database Interactions**  
   All interactions with the SQLite database are managed through a dedicated module (`dbManager.py`). This module handles everything from inserting new users and listings to retrieving auction details and processing bids. The use of parameterized queries ensures that the database operations are secure and efficient.

   ```python
   def insert_user(email, password):
       hashPassword = hashlib.md5(password.encode('utf-8')).hexdigest()
       connection = sql.connect('database.db')
       connection.execute('INSERT INTO Users (email, password) VALUES (?,?);', (email, hashPassword))
       connection.commit()
   ```

**Frontend Development**

The frontend of LionAuction was designed to be straightforward and intuitive, focusing on the core functionalities of listing items, placing bids, and managing user accounts. Templates were created using Flask's rendering engine, allowing for dynamic content to be displayed based on the user's actions.

1. **Responsive Design**  
   The platform includes multiple pages, such as the main bidding page, seller listings, and user profiles, all designed to be responsive and accessible on various devices. For example, the bidder’s homepage dynamically displays current auction listings based on the user’s search criteria.

   ```python
   @app.route('/bidder', methods=['POST', 'GET'])
   def bidder():
       value = dbm.get_categories()
       return render_template('listing.html', listings=dbm.get_auction_listings(), title="Home", rtn=value, home=True)
   ```

2. **Form Handling**  
   Form submissions are an integral part of the website, whether it's logging in, creating a new auction, or placing a bid. Each form is processed on the server side, with appropriate validation and error handling to ensure smooth user interactions.

   ```python
   @app.route('/create_user', methods=['POST', 'GET'])
   def create_user():
       if request.method == 'POST':
           email = request.form['email']
           password = request.form['password']
           if dbm.is_user(email):
               return render_template('create_user.html', msg="Account with this email already exists")
           dbm.insert_user(email, password)
           return redirect('/login')
       return render_template('create_user.html')
   ```

**REST API Integration**

As the project evolved, it became necessary to implement a REST API for handling requests more efficiently. This API was designed to support various operations such as retrieving auction listings, placing bids, and managing user profiles. Here's an example of a REST API endpoint that retrieves auction listings based on user input:

```python
@app.route('/api/auctions', methods=['GET'])
def get_auctions():
    search_input = request.args.get('search')
    listings = dbm.search_auction_listings(search_input)
    return jsonify(listings)
```

This API endpoint accepts GET requests with search parameters and returns a JSON response containing the relevant auction listings. The integration of REST APIs has enhanced the flexibility of the platform, enabling easier communication between the frontend and backend.

**Challenges and Solutions**

One of the primary challenges was ensuring the secure handling of user data, particularly during authentication and session management. This was addressed by using Flask's built-in session management along with hashing techniques for storing passwords securely in the database.

Another challenge was creating a scalable database design that could efficiently handle various user actions, from creating listings to placing bids. The database schema was carefully designed to manage these operations effectively, with indexing and query optimization techniques employed to enhance performance.

**Conclusion**

Building the LionAuction website was a complex yet rewarding experience. The project provided valuable insights into full-stack development, particularly in the context of creating a specialized auction platform. With the foundational elements in place, future iterations of the website can focus on scaling, additional features, and enhanced user experience.



E-commerce Website

I built a five-stage pipelined CPU using Verilog. The goal was to create a processor that can efficiently handle multiple instructions at once, improving performance by breaking down tasks into smaller steps. The CPU was developed with a focus on modular design, allowing each stage of the process to work independently and then connecting them to form a complete system. The final design was tested and successfully executed a set of instructions, demonstrating its ability to manage tasks quickly and efficiently.

***

## Introduction

In this project, I developed a five-stage pipelined CPU using Verilog. The design was focused on implementing a MIPS-based architecture with integrated forwarding to efficiently handle data hazards. Pipelining is a technique used in CPU design to increase instruction throughput by overlapping the execution of multiple instructions. This project aimed to explore and implement the key stages of a CPU pipeline: Instruction Fetch (IF), Instruction Decode (ID), Execute (EX), Memory Access (MEM), and Writeback (WB).

The CPU was designed to process instructions sequentially while minimizing delays caused by data dependencies between instructions. By integrating forwarding mechanisms, the CPU was able to pass results directly from one pipeline stage to another, reducing the need for stalls and improving performance. This project not only highlights the practical aspects of CPU design but also demonstrates the effectiveness of pipelining and hazard management in modern processors.

***

## The Architecture

![](/images/CPU_Structure$1$.png)

The above picture illustrated the 5 stages of the pipeline CPU. Starting with the first stage, IF, which fetched the MIPS instructions from instruction memory to be run. The next stage was the ID stage, where the instruction was read to determine the execution that should occur in the ALU, and the control signals were updated accordingly. At this stage, the register values were retrieved from register memory, but a multiplexer was also added to allow forwarding within the CPU. Writing back to registers only occurred at the negative edge of the clock cycle. It was also at this stage that the immediate value was extended.

The next stage of the CPU was the execute stage, where the ALU ran and performed the needed operations. At this stage, addition, subtraction, XOR, and other operations were executed. This was the stage where the actual values were calculated.

Depending on whether the control signal m2reg or mwmem was activated, the MEM stage would either load from memory, store to memory, or do neither based on the ALU value.

The last stage, Writeback, occurred where the values were written to the registers within register memory. This always occurred and was dependent on control signals.

This form of architecture benefited from a higher clock speed as the process was separated into stages, allowing each stage to run in less time than if all instructions ran at once. This architecture also had greater throughput of instructions since an instruction didn’t have to wait for the previous one to finish before it could start. The format also allowed for simplification, as each step could be optimized separately, with the stages being clearly defined. This enabled teams to work on different stages, like IF and ID, independently. Once both teams were finished, they could potentially improve the clock speed of the product as a whole.

***

## Implementation

The development of this five-stage pipelined CPU was carried out in Verilog, with a focus on modular design. Each stage of the pipeline—Instruction Fetch (IF), Instruction Decode (ID), Execute (EX), Memory Access (MEM), and Writeback (WB)—was implemented as a separate module. These modules were then integrated to form the complete CPU, with careful attention paid to the connections and data flow between stages.

Below is a graphical representation of the schematic of the final CPU:

![Schematic of the CPU](https://preview--houseben-3b1d0.stackbit.dev/images/Schematic_CPU.png)

This schematic illustrates the modular nature of the design, where each block represents a distinct stage of the CPU pipeline. The lines between modules represent the connections, implemented with wires, that allow for the transfer of data and control signals throughout the pipeline.

To ensure proper functionality, an I/O planning diagram was developed and implemented. This diagram details the input and output signals for each module, ensuring that data is correctly routed and that control signals are properly managed.

![Implementation's I/O Planning](/images/ImplimentationIOPlanning.PNG)

The I/O planning was crucial in the integration phase, ensuring that all components communicated effectively and that the CPU operated as intended. This methodical approach to design and integration enabled the successful implementation of the CPU, capable of executing a range of MIPS instructions with minimal delay and high efficiency.

***

## Conclusion

In this project, the forwarding integrated CPU was successfully implemented and verified using a series of MIPS instructions. Below is a sequence of instructions that the CPU executed:

```verilog
assign rom[6'h00] = 32'h00221820; // (00) add $3, $1, $2
assign rom[6'h01] = 32'h01232022; // (00) sub $4, $9, $3
assign rom[6'h02] = 32'h00692825; // (00) or $5, $3, $9
assign rom[6'h03] = 32'h00693026; // (00) xor $6, $3, $9
assign rom[6'h04] = 32'h00693824; // (00) and $7, $3, $9
```

The CPU was able to run these instructions back-to-back without stalling, thanks to the forwarding mechanism that allowed intermediate results to be passed directly between pipeline stages. For example, the result of the `add` instruction (`add $3, $1, $2`) was immediately forwarded to the subsequent `sub` instruction (`sub $4, $9, $3`), without waiting for the `add` instruction to complete fully through the pipeline.

This efficient handling of data hazards was further evidenced in the waveform below, which shows the signal states as the instructions were processed:

![Waveform of Signal States](https://preview--houseben-3b1d0.stackbit.dev/images/WaveForm.PNG)

The waveform illustrates the timing and control signals at various stages of the pipeline, demonstrating the correct functioning of the CPU as it processed each instruction in sequence. The successful execution of these instructions confirms the effectiveness of the forwarding integrated CPU design, achieving higher instruction throughput and better overall performance.

***



Projects

Online Forum Analyze

Dynamic Memory Allocator in C

C0 Nittany AI

E-commerce Website

Forwarding 5 Stage CPU

Let’s talk... 💬