Datasets:

architect-ubc-capstone
/

rtl-augmented-v3

	`timescale 1ns / 1ps
	//////////////////////////////////////////////////////////////////////////////////
	// Create Date: 18/04/2025 1:15 AM
	// Last Update: 03/05/2025 6:20 PM
	// Module Name: Hash Table
	// Author: https://www.linkedin.com/in/wei-yet-ng-065485119/
	// Description: Support coliision method of Chaining and Hash Algorithm FNV1A and SHA1
	// Additional Comments: .
	//
	//////////////////////////////////////////////////////////////////////////////////

	module hash_table #(
	parameter KEY_WIDTH = 32,
	parameter VALUE_WIDTH = 32,
	parameter TOTAL_INDEX = 8, // Total index of the hash table
	parameter CHAINING_SIZE = 4, // Number of chains for SINGLE_CYCLE_CHAINING and MULTI_STAGE_CHAINING only
	parameter COLLISION_METHOD = "MULTI_STAGE_CHAINING", // "MULTI_STAGE_CHAINING", "LINEAR_PROBING"
	parameter HASH_ALGORITHM = "MODULUS" // "MODULUS", "SHA1", "FNV1A"
	)(

	input wire clk,
	input wire rst,
	input wire [KEY_WIDTH-1:0] key_in,
	input wire [VALUE_WIDTH-1:0] value_in,
	input wire [1:0] op_sel, // 00: Insert, 01: Delete, 10: Search
	input wire op_en,
	output reg [VALUE_WIDTH-1:0] value_out,
	output reg op_done,
	output reg op_error, // FULL when insert FAIL, KEY_NOT_FOUND when delete or search FAIL
	output reg [$clog2(CHAINING_SIZE-1)-1:0] collision_count
	);

	parameter CHAINING_SIZE_WIDTH = $clog2(CHAINING_SIZE+1);
	parameter INDEX_WIDTH = $clog2(TOTAL_INDEX);

	reg [2:0] current_state;
	//reg [2:0] next_state;
	reg [KEY_WIDTH*CHAINING_SIZE-1:0] hash_key_stored [0:TOTAL_INDEX-1];
	reg [VALUE_WIDTH*CHAINING_SIZE-1:0] hash_value_stored [0:TOTAL_INDEX-1];
	reg [CHAINING_SIZE_WIDTH-1:0] hash_chain_count [0:TOTAL_INDEX-1]; // for collision count
	reg [CHAINING_SIZE_WIDTH-1:0] search_ptr; // for searching the key in the chain
	reg [CHAINING_SIZE_WIDTH-1:0] next_search_ptr; // for searching the key in the chain
	integer i;

	localparam IDLE = 3'b000;
	localparam SEARCH_KEY = 3'b001;
	localparam INSERT = 3'b010;
	localparam DELETE = 3'b011;
	localparam READ = 3'b100;
	localparam OP_DONE = 3'b101;

	// Hash function selector
	function integer get_hash_index;
	input integer key;
	reg [31:0] hash_value;
	begin
	if (HASH_ALGORITHM == "MODULUS")
	hash_value = key % TOTAL_INDEX;
	else // for future implentation of other hash algorithm
	hash_value = key;

	get_hash_index = hash_value[INDEX_WIDTH-1:0];
	end
	endfunction

	// Collision resolution method
	always @ (posedge clk, posedge rst) begin
	if(rst) begin
	current_state <= IDLE;
	search_ptr <= 0;
	value_out <= 0;
	collision_count <= 0;
	op_done <= 0;
	op_error <= 0;
	for (i = 0; i < TOTAL_INDEX; i++) begin
	hash_key_stored[i] <= 0;
	hash_value_stored[i] <= 0;
	hash_chain_count[i] <= 0;
	end
	end else begin
	case(current_state)
	IDLE: begin
	if (op_en) begin
	case (op_sel)
	2'b00: current_state <= SEARCH_KEY; //INSERT
	2'b01: current_state <= SEARCH_KEY; //DELETE
	2'b10: current_state <= SEARCH_KEY; //SEARCH
	default: begin
	current_state <= OP_DONE;
	op_done <= 1;
	op_error <= 1; // Invalid operation
	end
	endcase
	end else begin
	current_state <= IDLE;
	op_done <= 0;
	op_error <= 0;
	end
	search_ptr <= 0;
	value_out <= 0;
	collision_count <= 0;
	end

	INSERT: begin
	// Insert logic here
	hash_key_stored[get_hash_index(key_in)][search_ptr*KEY_WIDTH +: KEY_WIDTH] <= key_in;
	hash_value_stored[get_hash_index(key_in)][search_ptr*VALUE_WIDTH +: VALUE_WIDTH] <= value_in;
	hash_chain_count[get_hash_index(key_in)] <= hash_chain_count[get_hash_index(key_in)] + 1;
	op_done <= 1;
	op_error <= 0; // No error
	current_state <= OP_DONE;
	end

	DELETE: begin
	// Delete logic here
	// Remove key and value from hash table
	// Shift the rest of the chain
	// use for loop instead
	for (i = 0; i < CHAINING_SIZE - 1; i++) begin
	if (i >= search_ptr) begin
	hash_key_stored[get_hash_index(key_in)][(iKEY_WIDTH) +: KEY_WIDTH] <= hash_key_stored[get_hash_index(key_in)][((i+1)KEY_WIDTH) +: KEY_WIDTH];
	hash_value_stored[get_hash_index(key_in)][(iVALUE_WIDTH) +: VALUE_WIDTH] <= hash_value_stored[get_hash_index(key_in)][((i+1)VALUE_WIDTH) +: VALUE_WIDTH];
	end else begin
	hash_key_stored[get_hash_index(key_in)][(i*KEY_WIDTH) +: KEY_WIDTH] <= {KEY_WIDTH{1'b0}};
	hash_value_stored[get_hash_index(key_in)][(i*VALUE_WIDTH) +: VALUE_WIDTH] <= {VALUE_WIDTH{1'b0}};
	end
	end
	hash_chain_count[get_hash_index(key_in)] <= hash_chain_count[get_hash_index(key_in)] - 1;
	current_state <= OP_DONE;
	op_done <= 1;
	op_error <= 0; // No error
	end

	READ: begin
	// Search logic here
	// Return the value associated with the key
	value_out <= hash_value_stored[get_hash_index(key_in)] >> search_ptr*VALUE_WIDTH;
	collision_count <= hash_chain_count[get_hash_index(key_in)];
	current_state <= OP_DONE;
	op_done <= 1;
	op_error <= 0; // No error
	end

	SEARCH_KEY: begin
	if (hash_chain_count[get_hash_index(key_in)] == 0) begin
	if(op_sel == 2'b00) begin
	current_state <= INSERT;
	end else begin
	collision_count <= 0;
	op_done <= 1;
	op_error <= 1; // KEY_NOT_FOUND error
	current_state <= OP_DONE;
	end
	end else if(key_in == hash_key_stored[get_hash_index(key_in)][search_ptr*KEY_WIDTH +: KEY_WIDTH]) begin
	if(op_sel == 2'b00) begin
	current_state <= INSERT;
	end else if (op_sel == 2'b01) begin
	current_state <= DELETE;
	end else if (op_sel == 2'b10) begin
	current_state <= READ;
	end
	end else if (search_ptr == hash_chain_count[get_hash_index(key_in)]) begin
	if(op_sel == 2'b00 & (hash_chain_count[get_hash_index(key_in)] < CHAINING_SIZE)) begin
	current_state <= INSERT;
	end else begin
	collision_count <= CHAINING_SIZE;
	op_done <= 1;
	op_error <= 1; // KEY_NOT_FOUND error
	current_state <= OP_DONE;
	end
	end else begin
	current_state <= SEARCH_KEY;
	search_ptr <= search_ptr + 1;
	end
	end

	OP_DONE: begin
	current_state <= IDLE;
	op_done <= 0;
	op_error <= 0;
	end

	default: current_state <= IDLE;
	endcase
	end
	end

	endmodule