From 87016b9bd60a03eaaf1bd7f0816e27dbe96ef6ed Mon Sep 17 00:00:00 2001 From: fahim Date: Thu, 5 Feb 2015 17:23:51 +0530 Subject: Subject: Adding all the source code of nghdl Description: Adding all the source code of nghdl --- src/ghdlserver/Utility_Package.vhdl | 204 ++++++++ src/ghdlserver/Vhpi_Package.vhdl | 77 +++ src/ghdlserver/compile.sh | 6 + src/ghdlserver/ghdlserver.c | 666 +++++++++++++++++++++++++ src/ghdlserver/ghdlserver.h | 58 +++ src/ghdlserver/start_server.sh | 10 + src/ghdlserver/uthash.h | 948 ++++++++++++++++++++++++++++++++++++ src/model_generation.py | 750 ++++++++++++++++++++++++++++ src/ngspice_ghdl.py | 208 ++++++++ 9 files changed, 2927 insertions(+) create mode 100755 src/ghdlserver/Utility_Package.vhdl create mode 100755 src/ghdlserver/Vhpi_Package.vhdl create mode 100755 src/ghdlserver/compile.sh create mode 100644 src/ghdlserver/ghdlserver.c create mode 100644 src/ghdlserver/ghdlserver.h create mode 100755 src/ghdlserver/start_server.sh create mode 100644 src/ghdlserver/uthash.h create mode 100755 src/model_generation.py create mode 100755 src/ngspice_ghdl.py (limited to 'src') diff --git a/src/ghdlserver/Utility_Package.vhdl b/src/ghdlserver/Utility_Package.vhdl new file mode 100755 index 0000000..887a5a4 --- /dev/null +++ b/src/ghdlserver/Utility_Package.vhdl @@ -0,0 +1,204 @@ +-- author: Madhav P. Desai +library ieee; +use ieee.std_logic_1164.all; + +package Utility_Package is + + ----------------------------------------------------------------------------- + -- constants + ----------------------------------------------------------------------------- + constant c_word_length : integer := 32; + constant c_vhpi_max_string_length : integer := 1024; + + ----------------------------------------------------------------------------- + -- types + ----------------------------------------------------------------------------- + subtype VhpiString is string(1 to c_vhpi_max_string_length); + + ----------------------------------------------------------------------------- + -- utility functions + ----------------------------------------------------------------------------- + function Minimum(x,y: integer) return integer; -- returns minimum + function Pack_String_To_Vhpi_String(x: string) return VhpiString; -- converts x to null terminated string + function Pack_SLV_To_Vhpi_String(x: std_logic_vector) return VhpiString; -- converts slv x to null terminated string + function Unpack_String(x: VhpiString; lgth: integer) return std_logic_vector; -- convert null term string to slv + function To_Std_Logic(x: VhpiString) return std_logic; -- string to sl + function To_String(x: std_logic) return VhpiString; -- string to sl + function Convert_To_String(val : natural) return STRING; -- convert val to string. + function Convert_SLV_To_String(val : std_logic_vector) return STRING; -- convert val to string. + function To_Hex_Char (constant val: std_logic_vector) return character; + function Convert_SLV_To_Hex_String(val : std_logic_vector) return STRING; -- convert val to string. + +end package Utility_Package; + +package body Utility_Package is + + ----------------------------------------------------------------------------- + -- utility functions + ----------------------------------------------------------------------------- + function Minimum(x,y: integer) return integer is + begin + if( x < y) then return x; else return y; end if; + end Minimum; + + function Ceiling(x,y: integer) return integer is + variable ret_var : integer; + begin + assert x /= 0 report "divide by zero in ceiling function" severity failure; + ret_var := x/y; + if(ret_var*y < x) then ret_var := ret_var + 1; end if; + return(ret_var); + end Ceiling; + + function Pack_String_To_Vhpi_String(x: string) return VhpiString is + alias lx: string(1 to x'length) is x; + variable strlen: integer; + variable ret_var : VhpiString; + begin + strlen := Minimum(c_vhpi_max_string_length-1,x'length); + for I in 1 to strlen loop + ret_var(I) := lx(I); + end loop; + ret_var(strlen+1) := nul; + return(ret_var); + end Pack_String_To_Vhpi_String; + + function Pack_SLV_To_Vhpi_String(x: std_logic_vector) return VhpiString is + alias lx : std_logic_vector(1 to x'length) is x; + variable strlen: integer; + variable ret_var : VhpiString; + begin + strlen := Minimum(c_vhpi_max_string_length-1,x'length); + for I in 1 to strlen loop + if(lx(I) = '1') then + ret_var(I) := '1'; + else + ret_var(I) := '0'; + end if; + end loop; + ret_var(strlen+1) := nul; + return(ret_var); + end Pack_SLV_To_Vhpi_String; + + function Unpack_String(x: VhpiString; lgth: integer) return std_logic_vector is + variable ret_var : std_logic_vector(1 to lgth); + variable strlen: integer; + begin + strlen := Minimum(c_vhpi_max_string_length-1,lgth); + for I in 1 to strlen loop + if(x(I) = '1') then + ret_var(I) := '1'; + else + ret_var(I) := '0'; + end if; + end loop; + return(ret_var); + end Unpack_String; + + function To_Std_Logic(x: VhpiString) return std_logic is + variable s: std_logic_vector(0 downto 0); + begin + s := Unpack_String(x,1); + return(s(0)); + end To_Std_Logic; + + function To_String(x: std_logic) return VhpiString is + variable s: std_logic_vector(0 downto 0); + begin + s(0) := x; + return(Pack_SLV_To_Vhpi_String(s)); + end To_String; + + -- Thanks to: D. Calvet calvet@hep.saclay.cea.fr + function Convert_To_String(val : NATURAL) return STRING is + variable result : STRING(10 downto 1) := (others => '0'); -- smallest natural, longest string + variable pos : NATURAL := 1; + variable tmp, digit : NATURAL; + begin + tmp := val; + loop + digit := abs(tmp MOD 10); + tmp := tmp / 10; + result(pos) := character'val(character'pos('0') + digit); + pos := pos + 1; + exit when tmp = 0; + end loop; + return result((pos-1) downto 1); + end Convert_To_String; + + function Convert_SLV_To_String(val : std_logic_vector) return STRING is + alias lval: std_logic_vector(1 to val'length) is val; + variable ret_var: string( 1 to lval'length); + begin + for I in lval'range loop + if(lval(I) = '1') then + ret_var(I) := '1'; + elsif (lval(I) = '0') then + ret_var(I) := '0'; + else + ret_var(I) := 'X'; + end if; + end loop; + return(ret_var); + end Convert_SLV_To_String; + + function To_Hex_Char (constant val: std_logic_vector) return character is + alias lval: std_logic_vector(1 to val'length) is val; + variable tvar : std_logic_vector(1 to 4); + variable ret_val : character; + begin + if(lval'length >= 4) then + tvar := lval(1 to 4); + else + tvar := (others => '0'); + tvar(1 to lval'length) := lval; + end if; + + case tvar is + when "0000" => ret_val := '0'; + when "0001" => ret_val := '1'; + when "0010" => ret_val := '2'; + when "0011" => ret_val := '3'; + when "0100" => ret_val := '4'; + when "0101" => ret_val := '5'; + when "0110" => ret_val := '6'; + when "0111" => ret_val := '7'; + when "1000" => ret_val := '8'; + when "1001" => ret_val := '9'; + when "1010" => ret_val := 'a'; + when "1011" => ret_val := 'b'; + when "1100" => ret_val := 'c'; + when "1101" => ret_val := 'd'; + when "1110" => ret_val := 'e'; + when "1111" => ret_val := 'f'; + when others => ret_val := 'f'; + end case; + + return(ret_val); + end To_Hex_Char; + + function Convert_SLV_To_Hex_String(val : std_logic_vector) return STRING is + alias lval: std_logic_vector(val'length downto 1) is val; + variable ret_var: string( 1 to Ceiling(lval'length,4)); + variable hstr : std_logic_vector(4 downto 1); + variable I : integer; + begin + + I := 0; + + while I < (lval'length/4) loop + hstr := lval(4*(I+1) downto (4*I)+1); + ret_var(ret_var'length - I) := To_Hex_Char(hstr); + I := (I + 1); + end loop; -- I + + hstr := (others => '0'); + if(ret_var'length > (lval'length/4)) then + hstr((lval'length-((lval'length/4)*4)) downto 1) := lval(lval'length downto (4*(lval'length/4))+1); + ret_var(1) := To_Hex_Char(hstr); + end if; + + return(ret_var); + end Convert_SLV_To_Hex_String; +end Utility_Package; + diff --git a/src/ghdlserver/Vhpi_Package.vhdl b/src/ghdlserver/Vhpi_Package.vhdl new file mode 100755 index 0000000..febc00b --- /dev/null +++ b/src/ghdlserver/Vhpi_Package.vhdl @@ -0,0 +1,77 @@ +-- author: Madhav P. Desai +library ieee; +use ieee.std_logic_1164.all; +library work; +use work.Utility_Package.all; +package Vhpi_Foreign is + + ----------------------------------------------------------------------------- + -- foreign Vhpi function + ----------------------------------------------------------------------------- + procedure Vhpi_Initialize; + attribute foreign of Vhpi_Initialize : procedure is "VHPIDIRECT Vhpi_Initialize"; + + procedure Vhpi_Close; -- close . + attribute foreign of Vhpi_Close : procedure is "VHPIDIRECT Vhpi_Close"; + + procedure Vhpi_Listen; + attribute foreign of Vhpi_Listen : procedure is "VHPIDIRECT Vhpi_Listen"; + + procedure Vhpi_Send; + attribute foreign of Vhpi_Send : procedure is "VHPIDIRECT Vhpi_Send"; + + procedure Vhpi_Set_Port_Value(port_name: in VhpiString; port_value: in VhpiString; port_width: in integer); + attribute foreign of Vhpi_Set_Port_Value: procedure is "VHPIDIRECT Vhpi_Set_Port_Value"; + + procedure Vhpi_Get_Port_Value(port_name: in VhpiString; port_value : out VhpiString; port_width: in integer); + attribute foreign of Vhpi_Get_Port_Value : procedure is "VHPIDIRECT Vhpi_Get_Port_Value"; + + procedure Vhpi_Log(message_string: in VhpiString); + attribute foreign of Vhpi_Log : procedure is "VHPIDIRECT Vhpi_Log"; + +end Vhpi_Foreign; + +package body Vhpi_Foreign is + + ----------------------------------------------------------------------------- + -- subprogram bodies for foreign vhpi routines. will never be called + ----------------------------------------------------------------------------- + procedure Vhpi_Initialize is + begin + assert false report "fatal: this should never be called" severity failure; + end Vhpi_Initialize; + + procedure Vhpi_Close is + begin + assert false report "fatal: this should never be called" severity failure; + end Vhpi_Close; + + procedure Vhpi_Listen is + begin + assert false report "fatal: this should never be called" severity failure; + end Vhpi_Listen; + + procedure Vhpi_Send is + begin + assert false report "fatal: this should never be called" severity failure; + end Vhpi_Send; + + procedure Vhpi_Set_Port_Value(port_name: in VhpiString; port_value: in VhpiString; port_width: in integer) is + begin + assert false report "fatal: this should never be called" severity failure; + end Vhpi_Set_Port_Value; + + procedure Vhpi_Get_Port_Value(port_name : in VhpiString; port_value: out VhpiString; port_width: in integer)is + begin + assert false report "fatal: this should never be called" severity failure; + end Vhpi_Get_Port_Value; + + procedure Vhpi_Log(message_string: in VhpiString) is + begin + assert false report "fatal: this should never be called" severity failure; + end Vhpi_Log; + +end Vhpi_Foreign; + + + diff --git a/src/ghdlserver/compile.sh b/src/ghdlserver/compile.sh new file mode 100755 index 0000000..bfe413e --- /dev/null +++ b/src/ghdlserver/compile.sh @@ -0,0 +1,6 @@ +#!/bin/sh +gcc -c ghdlserver.c +ghdl -a Utility_Package.vhdl && +ghdl -a Vhpi_Package.vhdl + + diff --git a/src/ghdlserver/ghdlserver.c b/src/ghdlserver/ghdlserver.c new file mode 100644 index 0000000..0e5c887 --- /dev/null +++ b/src/ghdlserver/ghdlserver.c @@ -0,0 +1,666 @@ +#include +#include "ghdlserver.h" +#include "uthash.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define _XOPEN_SOURCE 500 +#define MAX_NUMBER_PORT 100 +//#define LOG_FILE "vhpi.log" +//FILE *log_file = NULL; +//FILE *log_sock_id = NULL; +FILE *log_server = NULL; +#define z32__ "00000000000000000000000000000000" + +char* Out_Port_Array[MAX_NUMBER_PORT]; +int out_port_num=0; + +int vhpi_cycle_count =0; +//server socket +int server_socket_id=-1; +struct my_struct { + char val[1024]; + char key[1024]; //Key + UT_hash_handle hh; /* makes this structure hashable */ +}; + + +struct my_struct *s, *users ,*tmp = NULL; + +void parse_buffer(int sock_id,char* receive_buffer) +{ + /*Taking time information for log*/ + + //time_t systime; + //systime = time(NULL); + log_server=fopen("server.log","a"); + //fprintf(log_server,"Buffer came at %s \n",ctime(&systime)); + + fprintf(log_server,"Server-The recieved buffer is : %s \n",receive_buffer); + fprintf(log_server,"Server-The socket id is : %d \n",sock_id); + + /*Parsing buffer to store in hash table */ + char *rest; + char *token; + char *ptr1=receive_buffer; + + char *var; + char *value; + + + fprintf(stderr,"Server-The recieved buffer is : %s \n",receive_buffer); + fprintf(stderr,"Server-The socket id is : %d \n",sock_id); + while(token = strtok_r(ptr1,",",&rest)) + { + ptr1 = rest; // rest contains the left over part..assign it to ptr...and start tokenizing again. + + //Processing token again; + + while(var=strtok_r(token,":",&value)) + { + + s = (struct my_struct*)malloc(sizeof(struct my_struct)); + printf("Server-Variable is %s \n",var); + printf("Server-Value is %s \n",value); + + strncpy(s->key, var,10); + strncpy(s->val,value,10); + HASH_ADD_STR( users, key, s ); + break; + } + } + + s = (struct my_struct*)malloc(sizeof(struct my_struct)); + strncpy(s->key,"sock_id",10); + snprintf(s->val,10,"%d",sock_id); + HASH_ADD_STR(users,key,s); + fflush(log_server); + fclose(log_server); +} + + +void Vhpi_Set_Port_Value(char *port_name,char *port_value,int port_width) +{ + //char *lb; // you need to know maximum size of lb. + //int I; + //snprintf(lb,sizeof(char),"%s", port_value); + + printf("Server-Vhpi_Set_Port_value \n"); + printf("Server-The port name is %s \n",port_name); + + + //printf("Port valu is %s",port_value); + + s = (struct my_struct*)malloc(sizeof(struct my_struct)); + strncpy(s->key, port_name,10); + strncpy(s->val,port_value,10); + HASH_ADD_STR( users, key, s ); + + + printf("Server-The out port value is %s \n ",port_value); + + log_server=fopen("server.log","a"); + fprintf(log_server,"Set Port Details \n"); + fprintf(log_server,"Port Name - %s And Port Value - %s \n",port_name,port_value); + fflush(log_server); + fclose(log_server); + + +} + +void Vhpi_Get_Port_Value(char* port_name,char* port_value,int port_width) + +{ + + printf("Server-Vhpi_Get_Port_Value \n"); + //int I; + //snprintf(port_value,1024,"1"); + + log_server=fopen("server.log","a"); + fprintf(log_server,"Get Port Details \n"); + + HASH_FIND_STR(users,port_name,s); + if(s) + { + printf("Server-The key is %s and value is %s \n",s->key,s->val); + + snprintf(port_value,sizeof(port_value),"%s",s->val); + fprintf(log_server,"Port Name - %s And Port Value - %s \n",port_name,port_value); + HASH_DEL(users, s); + free(s); + } + else + { + printf("Server-Port %s Not found \n",port_name); + fprintf(log_server,"Port : %s not found \n",port_name); + } + + fflush(log_server); + fclose(log_server); +} +/* +int Copy_Value(char* dest, char* src, int width) +{ + int ret_val = 0; + char src_buf[4096]; + int src_width = 0; + + // skip spaces + while(*src == ' ') + src++; + while(1) + { + if(src[src_width] == '1' || src[src_width] == '0') + { + src_buf[src_width] = src[src_width]; + src_width++; + } + else + break; + } + src_buf[src_width] = 0; // null-terminate + ret_val = src_width - width; + dest[width] = 0; + int i; + for(i = 1; i <= width; i++) + { + if(i <= src_width) + dest[width-i] = src[src_width-i]; + else + dest[width-i] = '0'; // pad with 0. + } + + return(ret_val); +} + +*/ +/* +int extract_payload(char* receive_buffer,char* payload, int max_n) +{ + int hash_pos = 0; + int ret_val = 0; + while(receive_buffer[hash_pos] != '#') + { + printf("Buffer is %c \n",receive_buffer[hash_pos]); + if(receive_buffer[hash_pos] == 0) // end of string + { + hash_pos = -1; + break; + } + hash_pos++; + } + + if(hash_pos >= 0) + { + receive_buffer[hash_pos] = 0; + ret_val = max_n - (hash_pos+1); + bcopy(receive_buffer+(hash_pos+1),payload,ret_val); + } + + return(ret_val); +} +*/ + + +// +//Create Server to listen for message +// + +int create_server(int port_number,int max_connections) +{ + + + int sockfd; + struct sockaddr_in serv_addr; + sockfd = socket(AF_INET, SOCK_STREAM, 0); + fprintf(stderr, "Server- Info: opening socket for server on port %d with socket id %d \n",port_number,sockfd); + if (sockfd < 0) + fprintf(stderr, "Server- Error: in opening socket on port %d\n", port_number); + + bzero((char *) &serv_addr, sizeof(serv_addr)); + serv_addr.sin_family = AF_INET; + serv_addr.sin_addr.s_addr = INADDR_ANY; + serv_addr.sin_port = htons(port_number); + + if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) + { + fprintf(stderr,"Server- Error: could not bind socket to port %d\n",port_number); + close(sockfd); + sockfd= -1; + } + else + fprintf(stderr,"Server- Info: finished binding socket to port %d\n",port_number); + // start listening on the server. + listen(sockfd,max_connections); + return sockfd; + +} + + +// +// ask the server to wait for a client connection +// and accept one connection if possible +// +// uses select to make this non-blocking. +// +// + +int connect_to_client(int server_fd) +{ + int ret_val = 1; + int newsockfd = -1; + socklen_t clilen; + struct sockaddr_in cli_addr; + fd_set c_set; + struct timeval time_limit; + time_limit.tv_sec = 0; + time_limit.tv_usec = 1000; + + clilen = sizeof(cli_addr); + FD_ZERO(&c_set); + FD_SET(server_fd,&c_set); + select(server_fd+1, &c_set,NULL,NULL,&time_limit); + if(FD_ISSET(server_fd,&c_set)) + { + newsockfd = accept(server_fd,(struct sockaddr *) &cli_addr,&clilen); + if (newsockfd >= 0) + { + fprintf(stderr,"Server- Info: new client connection %d \n",newsockfd); + } + else + { + fprintf(stderr,"Server- Info: failed in accept()\n"); + } + } + //else + //{ + // fprintf(stderr,"Server- failed to connect to client \n"); + //} + + return(newsockfd); +} + + +// +//use select to check if we can write to +// the socket.. +// + +int can_read_from_socket(int socket_id) +{ + struct timeval time_limit; + time_limit.tv_sec = 0; + time_limit.tv_usec = 1000; + + fd_set c_set; + FD_ZERO(&c_set); + FD_SET(socket_id,&c_set); + + int npending = select(socket_id + 1, &c_set, NULL,NULL,&time_limit); + + return(FD_ISSET(socket_id,&c_set)); +} + + +// +// use select to check if we can write to +// the socket.. +// + +int can_write_to_socket(int socket_id) +{ + struct timeval time_limit; + time_limit.tv_sec = 0; + time_limit.tv_usec = 1000; + + fd_set c_set; + FD_ZERO(&c_set); + FD_SET(socket_id,&c_set); + int npending = select(socket_id + 1, NULL, &c_set,NULL,&time_limit); + + return(FD_ISSET(socket_id,&c_set)); +} + + +//receive string from socket and put it inside buffer. + +int receive_string(int sock_id, char* buffer) +{ + int nbytes = 0; + + while(1) + { + if(can_read_from_socket(sock_id)) + break; + else + usleep(1000); + } + + nbytes = recv(sock_id,buffer,MAX_BUF_SIZE,0); + return(nbytes); +} + +// +// will establish a connection, send the +// packet and block till a response is obtained. +// socket will be closed after the response +// is obtained.. +// the buffer is used for the sent as well +// as the received data. +// + + +void set_non_blocking(int sock_id) +{ + int x; + x=fcntl(sock_id,F_GETFL,0); + fcntl(sock_id,F_SETFL,x | O_NONBLOCK); + fprintf(stderr,"Server- Setting server to non blocking state"); +} + + +void Vhpi_Initialize() +{ + + /*Taking time info for log*/ + time_t systime; + systime = time(NULL); + + log_server=fopen("server.log","a"); + //log_file=fopen("vhpi.log","a"); + + signal(SIGINT,Vhpi_Close); + signal(SIGTERM,Vhpi_Close); + + int try_limit = 100; + + while(try_limit > 0) + { + server_socket_id = create_server(DEFAULT_SERVER_PORT,DEFAULT_MAX_CONNECTIONS); + + if(server_socket_id > 0) + { + fprintf(stderr,"Server- Info:Success: Started the server on port %d\n",DEFAULT_SERVER_PORT); + fprintf(log_server,"Server -Started the server at port %d \n",DEFAULT_SERVER_PORT); + set_non_blocking(server_socket_id); + break; + + } + else + fprintf(stderr,"Server- Info:Could not start server on port %d,will try again\n",DEFAULT_SERVER_PORT); + + usleep(1000); + try_limit--; + + if(try_limit==0) + { + fprintf(stderr,"Server- Error:Tried to start server on port %d, failed..giving up \n",DEFAULT_SERVER_PORT); + exit(1); + } + + } + + //fprintf(log_server,"Setup completed on server side at %s ",ctime(&systime)); + fflush(log_server); + fclose(log_server); + + // + //Reading Output Port name and storing in Out_Port_Array; + // + char *line = NULL; + size_t len = 0; + ssize_t read; + char *token; + FILE *fp; + fp=fopen("connection_info.txt","r"); + + while ((read = getline(&line, &len, fp)) != -1) + { + if (strstr(line,"OUT") != NULL || strstr(line,"out") != NULL ) + { + strtok_r(line, " ",&token); + Out_Port_Array[out_port_num] = line; + out_port_num++; + } + line = (char *)malloc(sizeof(char)); + } + + + fprintf(stderr,"\n Server- Vhpi_Initialize finished \n"); + sleep(2); + fclose(fp); +} + +void Vhpi_Listen() +{ + char payload[4096]; + int payload_length; + vhpi_cycle_count++; + //#ifdef DEBUG + //fprintf(log_file,"Server- Info: listening in cycle %d\n", vhpi_cycle_count); + //fflush(log_file); + //#endif + int new_sock; + while(1) + { + if((new_sock = connect_to_client(server_socket_id)) > 0) + { + char receive_buffer[MAX_BUF_SIZE]; + fprintf(stderr,"Server- Info : waiting for client message \n"); + + //if the client has connected "just now" + // it must send something! + //#ifdef DEBUG + //fprintf(log_file,"Server- Info: waiting for message from client %d\n", new_sock); + //fflush(log_file); + //#endif + int n = receive_string(new_sock,receive_buffer); + + + if(n > 0) + { + + //payload_length = extract_payload(receive_buffer,payload,n); + //#ifdef DEBUG + //fprintf(log_file,"Info: received message from client %d: %s (payload-length=%d)\n",new_sock, receive_buffer,payload_length); + //fprintf(log_file,"Server- Info: received message from client %d : %s \n",new_sock,receive_buffer); + //fflush(log_file); + //#endif + + + if(strcmp(receive_buffer,"END")==0) + { + + log_server=fopen("server.log","a"); + fprintf(log_server,"Accept Server closing request \n"); + printf("Accept server closing request \n"); + fflush(log_server); + fclose(log_server); + Vhpi_Close(); + exit(0); + sleep(1); + //close(server_socket_id); + } + + else + { + parse_buffer(new_sock,receive_buffer); + + } + + //parse_buffer(new_sock,receive_buffer); + break; + } + + } + else + { + break; + } + } + //#ifdef DEBUG + //fprintf(log_file,"Server- Info: finished listening in cycle %d\n", vhpi_cycle_count); + //fflush(log_file); + //#endif +} + +// go down the list of finished jobs and send +// out the resulting port values.. +void Vhpi_Send() +{ + int sockid; + char* out; + //#ifdef DEBUG + //fprintf(log_file,"Server- Info: sending in cycle %d\n", vhpi_cycle_count); + //fflush(log_file); + //#endif + + log_server=fopen("server.log","a"); + + fprintf(stderr,"Server- Sending data to client \n"); + fprintf(log_server,"Sending data from server to client \n"); + HASH_FIND_STR(users,"sock_id",s); + if(s) + { + printf("Server- The key is %s and value is %s \n",s->key,s->val); + sockid=atoi(s->val); + //strncpy(sockid,10,atoi(s->val)); + //HASH_DEL(users, s); + //free(s); + } + else + { + printf("Server- The socket id not found in table \n"); + fprintf(log_server,"The socket id is not present in table \n"); + } + + //snprintf(sockid,sizeof(sockid),"%d",s->val); + + int i=0; + for (i=0;ikey,s->val); + printf("Server- s-val %s \n",s->val); + + //Count Digits in number + while(cpy>0) + { + rem[count_digits]=cpy%10; + count_digits++; + cpy=cpy/10; + } + + int c=0; + + //adds the difference of length as 0's + for(i=0;i<2-count_digits;i++) + new_str[c++]='0'; + + //appends rest of the string + for(i=count_digits-1;i>=0;i--) + new_str[c++]=rem[i]+48; + new_str[c++]='\0'; + + out=(char *)malloc(sizeof(char)); + snprintf(out,sizeof(out),"%s",s->val); + //HASH_DEL(users, s); + //free(s); + + while(1) + { + if(can_write_to_socket(sockid)) + break; + usleep(1000); + + } + + if ((send(sockid,out,sizeof(out),0))== -1) + { + perror("Server- Failure Sending Message\n"); + //exit(1); + } + + } + else + { + printf("Server- The key %s Not found \n",s->key); + } + + */ + + + //#ifdef DEBUG + //fprintf(log_file,"Server- Info: trying to send message %s in %d\n", send_buffer, vhpi_cycle_count); + //fflush(log_file); + //#endif + + fflush(log_server); + fclose(log_server); + +} + +void Data_Send(int sockid,char* out_port) +{ + char* out; + HASH_FIND_STR(users,out_port,s); + if(s) + { + printf("Server-Sending data has key:%s and value:%s \n",s->key,s->val); + fprintf(log_server,"Sending data has key:%s and value:%s \n",s->key,s->val); + out=(char *)malloc(sizeof(char)); + snprintf(out,sizeof(out),"%s",s->val); + //HASH_DEL(users, s); + //free(s); + while(1) + { + if(can_write_to_socket(sockid)) + break; + usleep(1000); + } + + if ((send(sockid,out,sizeof(out),0))== -1) + { + perror("Server- Failure Sending Message\n"); + exit(1); + } + } + else + { + printf("Server- The output port's %s value Not found \n",out_port); + fprintf(log_server,"The %s's value not found in the table \n",out_port); + } +} + +void Vhpi_Close() +{ + fprintf(stderr,"Server- Info: closing VHPI link\n"); + //fclose(log_file); + close(server_socket_id); + +} + +static void Vhpi_Exit(int sig) +{ + fprintf(stderr, "Server- *** Break! ***\n"); + fprintf(stderr,"Server- Info: Stopping the simulation \n"); + Vhpi_Close(); + exit(0); +} diff --git a/src/ghdlserver/ghdlserver.h b/src/ghdlserver/ghdlserver.h new file mode 100644 index 0000000..d8bc017 --- /dev/null +++ b/src/ghdlserver/ghdlserver.h @@ -0,0 +1,58 @@ + +#include +#include +#include +#include +#include +#include +#include +#include + + +// Should be enough.. +#define MAX_BUF_SIZE 4096 + +//Defualt port number +#define DEFAULT_SERVER_PORT 5000 + +//unlikely to have more than 16 active +//threads talking to the TB? +#define DEFAULT_MAX_CONNECTIONS 65535 + + + + +//Payload Handling +int extract_payload(char* receive_buffer,char* payload, int max_n); +//void print_payload(FILE* log_file,char* send_buffer, int wlength, int nwords); +//void pack_value(char* payload,int wlength,int offset, char* port_value); +//void unpack_value(char* payload,int wlength,int offset, char* port_value); + + +//Create Server to listen for message +int create_server(int port_number, int max_connections); + + +int connect_to_client(int server_fd); + +int can_read_from_socket(int socket_id); + +int can_write_to_socket(int socket_id); + +int receive_string(int n, char* buffer); + +void send_packet_and_wait_for_response(char* buffer, int send_length, char* server_host_name, int server_port_number); + +void set_non_blocking(int sock_id); +void Data_Send(int sockid,char* out_port); + +//Vhpi Function +void Vhpi_Initialize(); +void Vhpi_Close(); +void Vhpi_Listen(); +void Vhpi_Send(); +void Vhpi_Set_Port_Value(char* reg_name, char* reg_value, int port_width); +void Vhpi_Get_Port_Value(char* reg_name, char* reg_value, int port_width); +void Vhpi_Log(char* message_string); + + diff --git a/src/ghdlserver/start_server.sh b/src/ghdlserver/start_server.sh new file mode 100755 index 0000000..548d7d7 --- /dev/null +++ b/src/ghdlserver/start_server.sh @@ -0,0 +1,10 @@ +#!/bin/sh +gcc -c ghdlserver.c +ghdl -a Utility_Package.vhdl && +ghdl -a Vhpi_Package.vhdl && +ghdl -a inverter.vhdl && +ghdl -a inverter_tb.vhdl && + +ghdl -e -Wl,ghdlserver.o inverter_tb && +./inverter_tb + diff --git a/src/ghdlserver/uthash.h b/src/ghdlserver/uthash.h new file mode 100644 index 0000000..ae09d9e --- /dev/null +++ b/src/ghdlserver/uthash.h @@ -0,0 +1,948 @@ +/* +Copyright (c) 2003-2014, Troy D. Hanson http://troydhanson.github.com/uthash/ +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef UTHASH_H +#define UTHASH_H + +#include /* memcmp,strlen */ +#include /* ptrdiff_t */ +#include /* exit() */ + +/* These macros use decltype or the earlier __typeof GNU extension. + As decltype is only available in newer compilers (VS2010 or gcc 4.3+ + when compiling c++ source) this code uses whatever method is needed + or, for VS2008 where neither is available, uses casting workarounds. */ +#ifdef _MSC_VER /* MS compiler */ +#if _MSC_VER >= 1600 && defined(__cplusplus) /* VS2010 or newer in C++ mode */ +#define DECLTYPE(x) (decltype(x)) +#else /* VS2008 or older (or VS2010 in C mode) */ +#define NO_DECLTYPE +#define DECLTYPE(x) +#endif +#else /* GNU, Sun and other compilers */ +#define DECLTYPE(x) (__typeof(x)) +#endif + +#ifdef NO_DECLTYPE +#define DECLTYPE_ASSIGN(dst,src) \ +do { \ + char **_da_dst = (char**)(&(dst)); \ + *_da_dst = (char*)(src); \ +} while(0) +#else +#define DECLTYPE_ASSIGN(dst,src) \ +do { \ + (dst) = DECLTYPE(dst)(src); \ +} while(0) +#endif + +/* a number of the hash function use uint32_t which isn't defined on win32 */ +#ifdef _MSC_VER +typedef unsigned int uint32_t; +typedef unsigned char uint8_t; +#else +#include /* uint32_t */ +#endif + +#define UTHASH_VERSION 1.9.9 + +#ifndef uthash_fatal +#define uthash_fatal(msg) exit(-1) /* fatal error (out of memory,etc) */ +#endif +#ifndef uthash_malloc +#define uthash_malloc(sz) malloc(sz) /* malloc fcn */ +#endif +#ifndef uthash_free +#define uthash_free(ptr,sz) free(ptr) /* free fcn */ +#endif + +#ifndef uthash_noexpand_fyi +#define uthash_noexpand_fyi(tbl) /* can be defined to log noexpand */ +#endif +#ifndef uthash_expand_fyi +#define uthash_expand_fyi(tbl) /* can be defined to log expands */ +#endif + +/* initial number of buckets */ +#define HASH_INITIAL_NUM_BUCKETS 32 /* initial number of buckets */ +#define HASH_INITIAL_NUM_BUCKETS_LOG2 5 /* lg2 of initial number of buckets */ +#define HASH_BKT_CAPACITY_THRESH 10 /* expand when bucket count reaches */ + +/* calculate the element whose hash handle address is hhe */ +#define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho))) + +#define HASH_FIND(hh,head,keyptr,keylen,out) \ +do { \ + unsigned _hf_bkt,_hf_hashv; \ + out=NULL; \ + if (head) { \ + HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt); \ + if (HASH_BLOOM_TEST((head)->hh.tbl, _hf_hashv)) { \ + HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ], \ + keyptr,keylen,out); \ + } \ + } \ +} while (0) + +#ifdef HASH_BLOOM +#define HASH_BLOOM_BITLEN (1ULL << HASH_BLOOM) +#define HASH_BLOOM_BYTELEN (HASH_BLOOM_BITLEN/8) + ((HASH_BLOOM_BITLEN%8) ? 1:0) +#define HASH_BLOOM_MAKE(tbl) \ +do { \ + (tbl)->bloom_nbits = HASH_BLOOM; \ + (tbl)->bloom_bv = (uint8_t*)uthash_malloc(HASH_BLOOM_BYTELEN); \ + if (!((tbl)->bloom_bv)) { uthash_fatal( "out of memory"); } \ + memset((tbl)->bloom_bv, 0, HASH_BLOOM_BYTELEN); \ + (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE; \ +} while (0) + +#define HASH_BLOOM_FREE(tbl) \ +do { \ + uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN); \ +} while (0) + +#define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8] |= (1U << ((idx)%8))) +#define HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8] & (1U << ((idx)%8))) + +#define HASH_BLOOM_ADD(tbl,hashv) \ + HASH_BLOOM_BITSET((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1))) + +#define HASH_BLOOM_TEST(tbl,hashv) \ + HASH_BLOOM_BITTEST((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1))) + +#else +#define HASH_BLOOM_MAKE(tbl) +#define HASH_BLOOM_FREE(tbl) +#define HASH_BLOOM_ADD(tbl,hashv) +#define HASH_BLOOM_TEST(tbl,hashv) (1) +#define HASH_BLOOM_BYTELEN 0 +#endif + +#define HASH_MAKE_TABLE(hh,head) \ +do { \ + (head)->hh.tbl = (UT_hash_table*)uthash_malloc( \ + sizeof(UT_hash_table)); \ + if (!((head)->hh.tbl)) { uthash_fatal( "out of memory"); } \ + memset((head)->hh.tbl, 0, sizeof(UT_hash_table)); \ + (head)->hh.tbl->tail = &((head)->hh); \ + (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS; \ + (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2; \ + (head)->hh.tbl->hho = (char*)(&(head)->hh) - (char*)(head); \ + (head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_malloc( \ + HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket)); \ + if (! (head)->hh.tbl->buckets) { uthash_fatal( "out of memory"); } \ + memset((head)->hh.tbl->buckets, 0, \ + HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket)); \ + HASH_BLOOM_MAKE((head)->hh.tbl); \ + (head)->hh.tbl->signature = HASH_SIGNATURE; \ +} while(0) + +#define HASH_ADD(hh,head,fieldname,keylen_in,add) \ + HASH_ADD_KEYPTR(hh,head,&((add)->fieldname),keylen_in,add) + +#define HASH_REPLACE(hh,head,fieldname,keylen_in,add,replaced) \ +do { \ + replaced=NULL; \ + HASH_FIND(hh,head,&((add)->fieldname),keylen_in,replaced); \ + if (replaced!=NULL) { \ + HASH_DELETE(hh,head,replaced); \ + }; \ + HASH_ADD(hh,head,fieldname,keylen_in,add); \ +} while(0) + +#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add) \ +do { \ + unsigned _ha_bkt; \ + (add)->hh.next = NULL; \ + (add)->hh.key = (char*)(keyptr); \ + (add)->hh.keylen = (unsigned)(keylen_in); \ + if (!(head)) { \ + head = (add); \ + (head)->hh.prev = NULL; \ + HASH_MAKE_TABLE(hh,head); \ + } else { \ + (head)->hh.tbl->tail->next = (add); \ + (add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail); \ + (head)->hh.tbl->tail = &((add)->hh); \ + } \ + (head)->hh.tbl->num_items++; \ + (add)->hh.tbl = (head)->hh.tbl; \ + HASH_FCN(keyptr,keylen_in, (head)->hh.tbl->num_buckets, \ + (add)->hh.hashv, _ha_bkt); \ + HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt],&(add)->hh); \ + HASH_BLOOM_ADD((head)->hh.tbl,(add)->hh.hashv); \ + HASH_EMIT_KEY(hh,head,keyptr,keylen_in); \ + HASH_FSCK(hh,head); \ +} while(0) + +#define HASH_TO_BKT( hashv, num_bkts, bkt ) \ +do { \ + bkt = ((hashv) & ((num_bkts) - 1)); \ +} while(0) + +/* delete "delptr" from the hash table. + * "the usual" patch-up process for the app-order doubly-linked-list. + * The use of _hd_hh_del below deserves special explanation. + * These used to be expressed using (delptr) but that led to a bug + * if someone used the same symbol for the head and deletee, like + * HASH_DELETE(hh,users,users); + * We want that to work, but by changing the head (users) below + * we were forfeiting our ability to further refer to the deletee (users) + * in the patch-up process. Solution: use scratch space to + * copy the deletee pointer, then the latter references are via that + * scratch pointer rather than through the repointed (users) symbol. + */ +#define HASH_DELETE(hh,head,delptr) \ +do { \ + unsigned _hd_bkt; \ + struct UT_hash_handle *_hd_hh_del; \ + if ( ((delptr)->hh.prev == NULL) && ((delptr)->hh.next == NULL) ) { \ + uthash_free((head)->hh.tbl->buckets, \ + (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \ + HASH_BLOOM_FREE((head)->hh.tbl); \ + uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \ + head = NULL; \ + } else { \ + _hd_hh_del = &((delptr)->hh); \ + if ((delptr) == ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) { \ + (head)->hh.tbl->tail = \ + (UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + \ + (head)->hh.tbl->hho); \ + } \ + if ((delptr)->hh.prev) { \ + ((UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + \ + (head)->hh.tbl->hho))->next = (delptr)->hh.next; \ + } else { \ + DECLTYPE_ASSIGN(head,(delptr)->hh.next); \ + } \ + if (_hd_hh_del->next) { \ + ((UT_hash_handle*)((ptrdiff_t)_hd_hh_del->next + \ + (head)->hh.tbl->hho))->prev = \ + _hd_hh_del->prev; \ + } \ + HASH_TO_BKT( _hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt); \ + HASH_DEL_IN_BKT(hh,(head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del); \ + (head)->hh.tbl->num_items--; \ + } \ + HASH_FSCK(hh,head); \ +} while (0) + + +/* convenience forms of HASH_FIND/HASH_ADD/HASH_DEL */ +#define HASH_FIND_STR(head,findstr,out) \ + HASH_FIND(hh,head,findstr,strlen(findstr),out) +#define HASH_ADD_STR(head,strfield,add) \ + HASH_ADD(hh,head,strfield[0],strlen(add->strfield),add) +#define HASH_REPLACE_STR(head,strfield,add,replaced) \ + HASH_REPLACE(hh,head,strfield,strlen(add->strfield),add,replaced) +#define HASH_FIND_INT(head,findint,out) \ + HASH_FIND(hh,head,findint,sizeof(int),out) +#define HASH_ADD_INT(head,intfield,add) \ + HASH_ADD(hh,head,intfield,sizeof(int),add) +#define HASH_REPLACE_INT(head,intfield,add,replaced) \ + HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced) +#define HASH_FIND_PTR(head,findptr,out) \ + HASH_FIND(hh,head,findptr,sizeof(void *),out) +#define HASH_ADD_PTR(head,ptrfield,add) \ + HASH_ADD(hh,head,ptrfield,sizeof(void *),add) +#define HASH_REPLACE_PTR(head,ptrfield,add,replaced) \ + HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced) +#define HASH_DEL(head,delptr) \ + HASH_DELETE(hh,head,delptr) + +/* HASH_FSCK checks hash integrity on every add/delete when HASH_DEBUG is defined. + * This is for uthash developer only; it compiles away if HASH_DEBUG isn't defined. + */ +#ifdef HASH_DEBUG +#define HASH_OOPS(...) do { fprintf(stderr,__VA_ARGS__); exit(-1); } while (0) +#define HASH_FSCK(hh,head) \ +do { \ + unsigned _bkt_i; \ + unsigned _count, _bkt_count; \ + char *_prev; \ + struct UT_hash_handle *_thh; \ + if (head) { \ + _count = 0; \ + for( _bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; _bkt_i++) { \ + _bkt_count = 0; \ + _thh = (head)->hh.tbl->buckets[_bkt_i].hh_head; \ + _prev = NULL; \ + while (_thh) { \ + if (_prev != (char*)(_thh->hh_prev)) { \ + HASH_OOPS("invalid hh_prev %p, actual %p\n", \ + _thh->hh_prev, _prev ); \ + } \ + _bkt_count++; \ + _prev = (char*)(_thh); \ + _thh = _thh->hh_next; \ + } \ + _count += _bkt_count; \ + if ((head)->hh.tbl->buckets[_bkt_i].count != _bkt_count) { \ + HASH_OOPS("invalid bucket count %d, actual %d\n", \ + (head)->hh.tbl->buckets[_bkt_i].count, _bkt_count); \ + } \ + } \ + if (_count != (head)->hh.tbl->num_items) { \ + HASH_OOPS("invalid hh item count %d, actual %d\n", \ + (head)->hh.tbl->num_items, _count ); \ + } \ + /* traverse hh in app order; check next/prev integrity, count */ \ + _count = 0; \ + _prev = NULL; \ + _thh = &(head)->hh; \ + while (_thh) { \ + _count++; \ + if (_prev !=(char*)(_thh->prev)) { \ + HASH_OOPS("invalid prev %p, actual %p\n", \ + _thh->prev, _prev ); \ + } \ + _prev = (char*)ELMT_FROM_HH((head)->hh.tbl, _thh); \ + _thh = ( _thh->next ? (UT_hash_handle*)((char*)(_thh->next) + \ + (head)->hh.tbl->hho) : NULL ); \ + } \ + if (_count != (head)->hh.tbl->num_items) { \ + HASH_OOPS("invalid app item count %d, actual %d\n", \ + (head)->hh.tbl->num_items, _count ); \ + } \ + } \ +} while (0) +#else +#define HASH_FSCK(hh,head) +#endif + +/* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to + * the descriptor to which this macro is defined for tuning the hash function. + * The app can #include to get the prototype for write(2). */ +#ifdef HASH_EMIT_KEYS +#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen) \ +do { \ + unsigned _klen = fieldlen; \ + write(HASH_EMIT_KEYS, &_klen, sizeof(_klen)); \ + write(HASH_EMIT_KEYS, keyptr, fieldlen); \ +} while (0) +#else +#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen) +#endif + +/* default to Jenkin's hash unless overridden e.g. DHASH_FUNCTION=HASH_SAX */ +#ifdef HASH_FUNCTION +#define HASH_FCN HASH_FUNCTION +#else +#define HASH_FCN HASH_JEN +#endif + +/* The Bernstein hash function, used in Perl prior to v5.6 */ +#define HASH_BER(key,keylen,num_bkts,hashv,bkt) \ +do { \ + unsigned _hb_keylen=keylen; \ + char *_hb_key=(char*)(key); \ + (hashv) = 0; \ + while (_hb_keylen--) { (hashv) = ((hashv) * 33) + *_hb_key++; } \ + bkt = (hashv) & (num_bkts-1); \ +} while (0) + + +/* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at + * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx */ +#define HASH_SAX(key,keylen,num_bkts,hashv,bkt) \ +do { \ + unsigned _sx_i; \ + char *_hs_key=(char*)(key); \ + hashv = 0; \ + for(_sx_i=0; _sx_i < keylen; _sx_i++) \ + hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i]; \ + bkt = hashv & (num_bkts-1); \ +} while (0) + +#define HASH_FNV(key,keylen,num_bkts,hashv,bkt) \ +do { \ + unsigned _fn_i; \ + char *_hf_key=(char*)(key); \ + hashv = 2166136261UL; \ + for(_fn_i=0; _fn_i < keylen; _fn_i++) \ + hashv = (hashv * 16777619) ^ _hf_key[_fn_i]; \ + bkt = hashv & (num_bkts-1); \ +} while(0) + +#define HASH_OAT(key,keylen,num_bkts,hashv,bkt) \ +do { \ + unsigned _ho_i; \ + char *_ho_key=(char*)(key); \ + hashv = 0; \ + for(_ho_i=0; _ho_i < keylen; _ho_i++) { \ + hashv += _ho_key[_ho_i]; \ + hashv += (hashv << 10); \ + hashv ^= (hashv >> 6); \ + } \ + hashv += (hashv << 3); \ + hashv ^= (hashv >> 11); \ + hashv += (hashv << 15); \ + bkt = hashv & (num_bkts-1); \ +} while(0) + +#define HASH_JEN_MIX(a,b,c) \ +do { \ + a -= b; a -= c; a ^= ( c >> 13 ); \ + b -= c; b -= a; b ^= ( a << 8 ); \ + c -= a; c -= b; c ^= ( b >> 13 ); \ + a -= b; a -= c; a ^= ( c >> 12 ); \ + b -= c; b -= a; b ^= ( a << 16 ); \ + c -= a; c -= b; c ^= ( b >> 5 ); \ + a -= b; a -= c; a ^= ( c >> 3 ); \ + b -= c; b -= a; b ^= ( a << 10 ); \ + c -= a; c -= b; c ^= ( b >> 15 ); \ +} while (0) + +#define HASH_JEN(key,keylen,num_bkts,hashv,bkt) \ +do { \ + unsigned _hj_i,_hj_j,_hj_k; \ + unsigned char *_hj_key=(unsigned char*)(key); \ + hashv = 0xfeedbeef; \ + _hj_i = _hj_j = 0x9e3779b9; \ + _hj_k = (unsigned)(keylen); \ + while (_hj_k >= 12) { \ + _hj_i += (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 ) \ + + ( (unsigned)_hj_key[2] << 16 ) \ + + ( (unsigned)_hj_key[3] << 24 ) ); \ + _hj_j += (_hj_key[4] + ( (unsigned)_hj_key[5] << 8 ) \ + + ( (unsigned)_hj_key[6] << 16 ) \ + + ( (unsigned)_hj_key[7] << 24 ) ); \ + hashv += (_hj_key[8] + ( (unsigned)_hj_key[9] << 8 ) \ + + ( (unsigned)_hj_key[10] << 16 ) \ + + ( (unsigned)_hj_key[11] << 24 ) ); \ + \ + HASH_JEN_MIX(_hj_i, _hj_j, hashv); \ + \ + _hj_key += 12; \ + _hj_k -= 12; \ + } \ + hashv += keylen; \ + switch ( _hj_k ) { \ + case 11: hashv += ( (unsigned)_hj_key[10] << 24 ); \ + case 10: hashv += ( (unsigned)_hj_key[9] << 16 ); \ + case 9: hashv += ( (unsigned)_hj_key[8] << 8 ); \ + case 8: _hj_j += ( (unsigned)_hj_key[7] << 24 ); \ + case 7: _hj_j += ( (unsigned)_hj_key[6] << 16 ); \ + case 6: _hj_j += ( (unsigned)_hj_key[5] << 8 ); \ + case 5: _hj_j += _hj_key[4]; \ + case 4: _hj_i += ( (unsigned)_hj_key[3] << 24 ); \ + case 3: _hj_i += ( (unsigned)_hj_key[2] << 16 ); \ + case 2: _hj_i += ( (unsigned)_hj_key[1] << 8 ); \ + case 1: _hj_i += _hj_key[0]; \ + } \ + HASH_JEN_MIX(_hj_i, _hj_j, hashv); \ + bkt = hashv & (num_bkts-1); \ +} while(0) + +/* The Paul Hsieh hash function */ +#undef get16bits +#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \ + || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__) +#define get16bits(d) (*((const uint16_t *) (d))) +#endif + +#if !defined (get16bits) +#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8) \ + +(uint32_t)(((const uint8_t *)(d))[0]) ) +#endif +#define HASH_SFH(key,keylen,num_bkts,hashv,bkt) \ +do { \ + unsigned char *_sfh_key=(unsigned char*)(key); \ + uint32_t _sfh_tmp, _sfh_len = keylen; \ + \ + int _sfh_rem = _sfh_len & 3; \ + _sfh_len >>= 2; \ + hashv = 0xcafebabe; \ + \ + /* Main loop */ \ + for (;_sfh_len > 0; _sfh_len--) { \ + hashv += get16bits (_sfh_key); \ + _sfh_tmp = (uint32_t)(get16bits (_sfh_key+2)) << 11 ^ hashv; \ + hashv = (hashv << 16) ^ _sfh_tmp; \ + _sfh_key += 2*sizeof (uint16_t); \ + hashv += hashv >> 11; \ + } \ + \ + /* Handle end cases */ \ + switch (_sfh_rem) { \ + case 3: hashv += get16bits (_sfh_key); \ + hashv ^= hashv << 16; \ + hashv ^= (uint32_t)(_sfh_key[sizeof (uint16_t)] << 18); \ + hashv += hashv >> 11; \ + break; \ + case 2: hashv += get16bits (_sfh_key); \ + hashv ^= hashv << 11; \ + hashv += hashv >> 17; \ + break; \ + case 1: hashv += *_sfh_key; \ + hashv ^= hashv << 10; \ + hashv += hashv >> 1; \ + } \ + \ + /* Force "avalanching" of final 127 bits */ \ + hashv ^= hashv << 3; \ + hashv += hashv >> 5; \ + hashv ^= hashv << 4; \ + hashv += hashv >> 17; \ + hashv ^= hashv << 25; \ + hashv += hashv >> 6; \ + bkt = hashv & (num_bkts-1); \ +} while(0) + +#ifdef HASH_USING_NO_STRICT_ALIASING +/* The MurmurHash exploits some CPU's (x86,x86_64) tolerance for unaligned reads. + * For other types of CPU's (e.g. Sparc) an unaligned read causes a bus error. + * MurmurHash uses the faster approach only on CPU's where we know it's safe. + * + * Note the preprocessor built-in defines can be emitted using: + * + * gcc -m64 -dM -E - < /dev/null (on gcc) + * cc -## a.c (where a.c is a simple test file) (Sun Studio) + */ +#if (defined(__i386__) || defined(__x86_64__) || defined(_M_IX86)) +#define MUR_GETBLOCK(p,i) p[i] +#else /* non intel */ +#define MUR_PLUS0_ALIGNED(p) (((unsigned long)p & 0x3) == 0) +#define MUR_PLUS1_ALIGNED(p) (((unsigned long)p & 0x3) == 1) +#define MUR_PLUS2_ALIGNED(p) (((unsigned long)p & 0x3) == 2) +#define MUR_PLUS3_ALIGNED(p) (((unsigned long)p & 0x3) == 3) +#define WP(p) ((uint32_t*)((unsigned long)(p) & ~3UL)) +#if (defined(__BIG_ENDIAN__) || defined(SPARC) || defined(__ppc__) || defined(__ppc64__)) +#define MUR_THREE_ONE(p) ((((*WP(p))&0x00ffffff) << 8) | (((*(WP(p)+1))&0xff000000) >> 24)) +#define MUR_TWO_TWO(p) ((((*WP(p))&0x0000ffff) <<16) | (((*(WP(p)+1))&0xffff0000) >> 16)) +#define MUR_ONE_THREE(p) ((((*WP(p))&0x000000ff) <<24) | (((*(WP(p)+1))&0xffffff00) >> 8)) +#else /* assume little endian non-intel */ +#define MUR_THREE_ONE(p) ((((*WP(p))&0xffffff00) >> 8) | (((*(WP(p)+1))&0x000000ff) << 24)) +#define MUR_TWO_TWO(p) ((((*WP(p))&0xffff0000) >>16) | (((*(WP(p)+1))&0x0000ffff) << 16)) +#define MUR_ONE_THREE(p) ((((*WP(p))&0xff000000) >>24) | (((*(WP(p)+1))&0x00ffffff) << 8)) +#endif +#define MUR_GETBLOCK(p,i) (MUR_PLUS0_ALIGNED(p) ? ((p)[i]) : \ + (MUR_PLUS1_ALIGNED(p) ? MUR_THREE_ONE(p) : \ + (MUR_PLUS2_ALIGNED(p) ? MUR_TWO_TWO(p) : \ + MUR_ONE_THREE(p)))) +#endif +#define MUR_ROTL32(x,r) (((x) << (r)) | ((x) >> (32 - (r)))) +#define MUR_FMIX(_h) \ +do { \ + _h ^= _h >> 16; \ + _h *= 0x85ebca6b; \ + _h ^= _h >> 13; \ + _h *= 0xc2b2ae35l; \ + _h ^= _h >> 16; \ +} while(0) + +#define HASH_MUR(key,keylen,num_bkts,hashv,bkt) \ +do { \ + const uint8_t *_mur_data = (const uint8_t*)(key); \ + const int _mur_nblocks = (keylen) / 4; \ + uint32_t _mur_h1 = 0xf88D5353; \ + uint32_t _mur_c1 = 0xcc9e2d51; \ + uint32_t _mur_c2 = 0x1b873593; \ + uint32_t _mur_k1 = 0; \ + const uint8_t *_mur_tail; \ + const uint32_t *_mur_blocks = (const uint32_t*)(_mur_data+_mur_nblocks*4); \ + int _mur_i; \ + for(_mur_i = -_mur_nblocks; _mur_i; _mur_i++) { \ + _mur_k1 = MUR_GETBLOCK(_mur_blocks,_mur_i); \ + _mur_k1 *= _mur_c1; \ + _mur_k1 = MUR_ROTL32(_mur_k1,15); \ + _mur_k1 *= _mur_c2; \ + \ + _mur_h1 ^= _mur_k1; \ + _mur_h1 = MUR_ROTL32(_mur_h1,13); \ + _mur_h1 = _mur_h1*5+0xe6546b64; \ + } \ + _mur_tail = (const uint8_t*)(_mur_data + _mur_nblocks*4); \ + _mur_k1=0; \ + switch((keylen) & 3) { \ + case 3: _mur_k1 ^= _mur_tail[2] << 16; \ + case 2: _mur_k1 ^= _mur_tail[1] << 8; \ + case 1: _mur_k1 ^= _mur_tail[0]; \ + _mur_k1 *= _mur_c1; \ + _mur_k1 = MUR_ROTL32(_mur_k1,15); \ + _mur_k1 *= _mur_c2; \ + _mur_h1 ^= _mur_k1; \ + } \ + _mur_h1 ^= (keylen); \ + MUR_FMIX(_mur_h1); \ + hashv = _mur_h1; \ + bkt = hashv & (num_bkts-1); \ +} while(0) +#endif /* HASH_USING_NO_STRICT_ALIASING */ + +/* key comparison function; return 0 if keys equal */ +#define HASH_KEYCMP(a,b,len) memcmp(a,b,len) + +/* iterate over items in a known bucket to find desired item */ +#define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,out) \ +do { \ + if (head.hh_head) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,head.hh_head)); \ + else out=NULL; \ + while (out) { \ + if ((out)->hh.keylen == keylen_in) { \ + if ((HASH_KEYCMP((out)->hh.key,keyptr,keylen_in)) == 0) break; \ + } \ + if ((out)->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,(out)->hh.hh_next)); \ + else out = NULL; \ + } \ +} while(0) + +/* add an item to a bucket */ +#define HASH_ADD_TO_BKT(head,addhh) \ +do { \ + head.count++; \ + (addhh)->hh_next = head.hh_head; \ + (addhh)->hh_prev = NULL; \ + if (head.hh_head) { (head).hh_head->hh_prev = (addhh); } \ + (head).hh_head=addhh; \ + if (head.count >= ((head.expand_mult+1) * HASH_BKT_CAPACITY_THRESH) \ + && (addhh)->tbl->noexpand != 1) { \ + HASH_EXPAND_BUCKETS((addhh)->tbl); \ + } \ +} while(0) + +/* remove an item from a given bucket */ +#define HASH_DEL_IN_BKT(hh,head,hh_del) \ + (head).count--; \ + if ((head).hh_head == hh_del) { \ + (head).hh_head = hh_del->hh_next; \ + } \ + if (hh_del->hh_prev) { \ + hh_del->hh_prev->hh_next = hh_del->hh_next; \ + } \ + if (hh_del->hh_next) { \ + hh_del->hh_next->hh_prev = hh_del->hh_prev; \ + } + +/* Bucket expansion has the effect of doubling the number of buckets + * and redistributing the items into the new buckets. Ideally the + * items will distribute more or less evenly into the new buckets + * (the extent to which this is true is a measure of the quality of + * the hash function as it applies to the key domain). + * + * With the items distributed into more buckets, the chain length + * (item count) in each bucket is reduced. Thus by expanding buckets + * the hash keeps a bound on the chain length. This bounded chain + * length is the essence of how a hash provides constant time lookup. + * + * The calculation of tbl->ideal_chain_maxlen below deserves some + * explanation. First, keep in mind that we're calculating the ideal + * maximum chain length based on the *new* (doubled) bucket count. + * In fractions this is just n/b (n=number of items,b=new num buckets). + * Since the ideal chain length is an integer, we want to calculate + * ceil(n/b). We don't depend on floating point arithmetic in this + * hash, so to calculate ceil(n/b) with integers we could write + * + * ceil(n/b) = (n/b) + ((n%b)?1:0) + * + * and in fact a previous version of this hash did just that. + * But now we have improved things a bit by recognizing that b is + * always a power of two. We keep its base 2 log handy (call it lb), + * so now we can write this with a bit shift and logical AND: + * + * ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0) + * + */ +#define HASH_EXPAND_BUCKETS(tbl) \ +do { \ + unsigned _he_bkt; \ + unsigned _he_bkt_i; \ + struct UT_hash_handle *_he_thh, *_he_hh_nxt; \ + UT_hash_bucket *_he_new_buckets, *_he_newbkt; \ + _he_new_buckets = (UT_hash_bucket*)uthash_malloc( \ + 2 * tbl->num_buckets * sizeof(struct UT_hash_bucket)); \ + if (!_he_new_buckets) { uthash_fatal( "out of memory"); } \ + memset(_he_new_buckets, 0, \ + 2 * tbl->num_buckets * sizeof(struct UT_hash_bucket)); \ + tbl->ideal_chain_maxlen = \ + (tbl->num_items >> (tbl->log2_num_buckets+1)) + \ + ((tbl->num_items & ((tbl->num_buckets*2)-1)) ? 1 : 0); \ + tbl->nonideal_items = 0; \ + for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++) \ + { \ + _he_thh = tbl->buckets[ _he_bkt_i ].hh_head; \ + while (_he_thh) { \ + _he_hh_nxt = _he_thh->hh_next; \ + HASH_TO_BKT( _he_thh->hashv, tbl->num_buckets*2, _he_bkt); \ + _he_newbkt = &(_he_new_buckets[ _he_bkt ]); \ + if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) { \ + tbl->nonideal_items++; \ + _he_newbkt->expand_mult = _he_newbkt->count / \ + tbl->ideal_chain_maxlen; \ + } \ + _he_thh->hh_prev = NULL; \ + _he_thh->hh_next = _he_newbkt->hh_head; \ + if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev = \ + _he_thh; \ + _he_newbkt->hh_head = _he_thh; \ + _he_thh = _he_hh_nxt; \ + } \ + } \ + uthash_free( tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \ + tbl->num_buckets *= 2; \ + tbl->log2_num_buckets++; \ + tbl->buckets = _he_new_buckets; \ + tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ? \ + (tbl->ineff_expands+1) : 0; \ + if (tbl->ineff_expands > 1) { \ + tbl->noexpand=1; \ + uthash_noexpand_fyi(tbl); \ + } \ + uthash_expand_fyi(tbl); \ +} while(0) + + +/* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */ +/* Note that HASH_SORT assumes the hash handle name to be hh. + * HASH_SRT was added to allow the hash handle name to be passed in. */ +#define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn) +#define HASH_SRT(hh,head,cmpfcn) \ +do { \ + unsigned _hs_i; \ + unsigned _hs_looping,_hs_nmerges,_hs_insize,_hs_psize,_hs_qsize; \ + struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail; \ + if (head) { \ + _hs_insize = 1; \ + _hs_looping = 1; \ + _hs_list = &((head)->hh); \ + while (_hs_looping) { \ + _hs_p = _hs_list; \ + _hs_list = NULL; \ + _hs_tail = NULL; \ + _hs_nmerges = 0; \ + while (_hs_p) { \ + _hs_nmerges++; \ + _hs_q = _hs_p; \ + _hs_psize = 0; \ + for ( _hs_i = 0; _hs_i < _hs_insize; _hs_i++ ) { \ + _hs_psize++; \ + _hs_q = (UT_hash_handle*)((_hs_q->next) ? \ + ((void*)((char*)(_hs_q->next) + \ + (head)->hh.tbl->hho)) : NULL); \ + if (! (_hs_q) ) break; \ + } \ + _hs_qsize = _hs_insize; \ + while ((_hs_psize > 0) || ((_hs_qsize > 0) && _hs_q )) { \ + if (_hs_psize == 0) { \ + _hs_e = _hs_q; \ + _hs_q = (UT_hash_handle*)((_hs_q->next) ? \ + ((void*)((char*)(_hs_q->next) + \ + (head)->hh.tbl->hho)) : NULL); \ + _hs_qsize--; \ + } else if ( (_hs_qsize == 0) || !(_hs_q) ) { \ + _hs_e = _hs_p; \ + if (_hs_p){ \ + _hs_p = (UT_hash_handle*)((_hs_p->next) ? \ + ((void*)((char*)(_hs_p->next) + \ + (head)->hh.tbl->hho)) : NULL); \ + } \ + _hs_psize--; \ + } else if (( \ + cmpfcn(DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_p)), \ + DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_q))) \ + ) <= 0) { \ + _hs_e = _hs_p; \ + if (_hs_p){ \ + _hs_p = (UT_hash_handle*)((_hs_p->next) ? \ + ((void*)((char*)(_hs_p->next) + \ + (head)->hh.tbl->hho)) : NULL); \ + } \ + _hs_psize--; \ + } else { \ + _hs_e = _hs_q; \ + _hs_q = (UT_hash_handle*)((_hs_q->next) ? \ + ((void*)((char*)(_hs_q->next) + \ + (head)->hh.tbl->hho)) : NULL); \ + _hs_qsize--; \ + } \ + if ( _hs_tail ) { \ + _hs_tail->next = ((_hs_e) ? \ + ELMT_FROM_HH((head)->hh.tbl,_hs_e) : NULL); \ + } else { \ + _hs_list = _hs_e; \ + } \ + if (_hs_e) { \ + _hs_e->prev = ((_hs_tail) ? \ + ELMT_FROM_HH((head)->hh.tbl,_hs_tail) : NULL); \ + } \ + _hs_tail = _hs_e; \ + } \ + _hs_p = _hs_q; \ + } \ + if (_hs_tail){ \ + _hs_tail->next = NULL; \ + } \ + if ( _hs_nmerges <= 1 ) { \ + _hs_looping=0; \ + (head)->hh.tbl->tail = _hs_tail; \ + DECLTYPE_ASSIGN(head,ELMT_FROM_HH((head)->hh.tbl, _hs_list)); \ + } \ + _hs_insize *= 2; \ + } \ + HASH_FSCK(hh,head); \ + } \ +} while (0) + +/* This function selects items from one hash into another hash. + * The end result is that the selected items have dual presence + * in both hashes. There is no copy of the items made; rather + * they are added into the new hash through a secondary hash + * hash handle that must be present in the structure. */ +#define HASH_SELECT(hh_dst, dst, hh_src, src, cond) \ +do { \ + unsigned _src_bkt, _dst_bkt; \ + void *_last_elt=NULL, *_elt; \ + UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh=NULL; \ + ptrdiff_t _dst_hho = ((char*)(&(dst)->hh_dst) - (char*)(dst)); \ + if (src) { \ + for(_src_bkt=0; _src_bkt < (src)->hh_src.tbl->num_buckets; _src_bkt++) { \ + for(_src_hh = (src)->hh_src.tbl->buckets[_src_bkt].hh_head; \ + _src_hh; \ + _src_hh = _src_hh->hh_next) { \ + _elt = ELMT_FROM_HH((src)->hh_src.tbl, _src_hh); \ + if (cond(_elt)) { \ + _dst_hh = (UT_hash_handle*)(((char*)_elt) + _dst_hho); \ + _dst_hh->key = _src_hh->key; \ + _dst_hh->keylen = _src_hh->keylen; \ + _dst_hh->hashv = _src_hh->hashv; \ + _dst_hh->prev = _last_elt; \ + _dst_hh->next = NULL; \ + if (_last_elt_hh) { _last_elt_hh->next = _elt; } \ + if (!dst) { \ + DECLTYPE_ASSIGN(dst,_elt); \ + HASH_MAKE_TABLE(hh_dst,dst); \ + } else { \ + _dst_hh->tbl = (dst)->hh_dst.tbl; \ + } \ + HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, _dst_bkt); \ + HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt],_dst_hh); \ + (dst)->hh_dst.tbl->num_items++; \ + _last_elt = _elt; \ + _last_elt_hh = _dst_hh; \ + } \ + } \ + } \ + } \ + HASH_FSCK(hh_dst,dst); \ +} while (0) + +#define HASH_CLEAR(hh,head) \ +do { \ + if (head) { \ + uthash_free((head)->hh.tbl->buckets, \ + (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket)); \ + HASH_BLOOM_FREE((head)->hh.tbl); \ + uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \ + (head)=NULL; \ + } \ +} while(0) + +#define HASH_OVERHEAD(hh,head) \ + (size_t)((((head)->hh.tbl->num_items * sizeof(UT_hash_handle)) + \ + ((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket)) + \ + (sizeof(UT_hash_table)) + \ + (HASH_BLOOM_BYTELEN))) + +#ifdef NO_DECLTYPE +#define HASH_ITER(hh,head,el,tmp) \ +for((el)=(head), (*(char**)(&(tmp)))=(char*)((head)?(head)->hh.next:NULL); \ + el; (el)=(tmp),(*(char**)(&(tmp)))=(char*)((tmp)?(tmp)->hh.next:NULL)) +#else +#define HASH_ITER(hh,head,el,tmp) \ +for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL); \ + el; (el)=(tmp),(tmp)=DECLTYPE(el)((tmp)?(tmp)->hh.next:NULL)) +#endif + +/* obtain a count of items in the hash */ +#define HASH_COUNT(head) HASH_CNT(hh,head) +#define HASH_CNT(hh,head) ((head)?((head)->hh.tbl->num_items):0) + +typedef struct UT_hash_bucket { + struct UT_hash_handle *hh_head; + unsigned count; + + /* expand_mult is normally set to 0. In this situation, the max chain length + * threshold is enforced at its default value, HASH_BKT_CAPACITY_THRESH. (If + * the bucket's chain exceeds this length, bucket expansion is triggered). + * However, setting expand_mult to a non-zero value delays bucket expansion + * (that would be triggered by additions to this particular bucket) + * until its chain length reaches a *multiple* of HASH_BKT_CAPACITY_THRESH. + * (The multiplier is simply expand_mult+1). The whole idea of this + * multiplier is to reduce bucket expansions, since they are expensive, in + * situations where we know that a particular bucket tends to be overused. + * It is better to let its chain length grow to a longer yet-still-bounded + * value, than to do an O(n) bucket expansion too often. + */ + unsigned expand_mult; + +} UT_hash_bucket; + +/* random signature used only to find hash tables in external analysis */ +#define HASH_SIGNATURE 0xa0111fe1 +#define HASH_BLOOM_SIGNATURE 0xb12220f2 + +typedef struct UT_hash_table { + UT_hash_bucket *buckets; + unsigned num_buckets, log2_num_buckets; + unsigned num_items; + struct UT_hash_handle *tail; /* tail hh in app order, for fast append */ + ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */ + + /* in an ideal situation (all buckets used equally), no bucket would have + * more than ceil(#items/#buckets) items. that's the ideal chain length. */ + unsigned ideal_chain_maxlen; + + /* nonideal_items is the number of items in the hash whose chain position + * exceeds the ideal chain maxlen. these items pay the penalty for an uneven + * hash distribution; reaching them in a chain traversal takes >ideal steps */ + unsigned nonideal_items; + + /* ineffective expands occur when a bucket doubling was performed, but + * afterward, more than half the items in the hash had nonideal chain + * positions. If this happens on two consecutive expansions we inhibit any + * further expansion, as it's not helping; this happens when the hash + * function isn't a good fit for the key domain. When expansion is inhibited + * the hash will still work, albeit no longer in constant time. */ + unsigned ineff_expands, noexpand; + + uint32_t signature; /* used only to find hash tables in external analysis */ +#ifdef HASH_BLOOM + uint32_t bloom_sig; /* used only to test bloom exists in external analysis */ + uint8_t *bloom_bv; + char bloom_nbits; +#endif + +} UT_hash_table; + +typedef struct UT_hash_handle { + struct UT_hash_table *tbl; + void *prev; /* prev element in app order */ + void *next; /* next element in app order */ + struct UT_hash_handle *hh_prev; /* previous hh in bucket order */ + struct UT_hash_handle *hh_next; /* next hh in bucket order */ + void *key; /* ptr to enclosing struct's key */ + unsigned keylen; /* enclosing struct's key len */ + unsigned hashv; /* result of hash-fcn(key) */ +} UT_hash_handle; + +#endif /* UTHASH_H */ diff --git a/src/model_generation.py b/src/model_generation.py new file mode 100755 index 0000000..d21de69 --- /dev/null +++ b/src/model_generation.py @@ -0,0 +1,750 @@ +#!/usr/bin/env python + +"""#!/usr/bin/python """ +import re +import sys +import os + +#######Script start from here +print "Arguement is :", sys.argv[1] +fname = os.path.basename(sys.argv[1]) +print "VHDL filename is :",fname +home = os.path.expanduser("~") +###########Creating connection_info.txt file from vhdl file##################### +read_vhdl = open(sys.argv[1],'r') +vhdl_data = read_vhdl.readlines() +read_vhdl.close() + +start_flag = -1 #Used for scaning part of data +scan_data=[] +#p=re.search('port(.*?)end',read_vhdl,re.M|re.I|re.DOTALL).group() + +for item in vhdl_data: + if re.search('port',item,re.I): + start_flag = 1 + + elif re.search("end",item,re.I): + start_flag = 0 + else: + pass + + if start_flag == 1: + item=re.sub("port", " ", item, flags=re.I) + item=re.sub("\(", " ", item, flags=re.I) + item=re.sub("\)", " ", item, flags=re.I) + item=re.sub(";"," ",item,flags=re.I) + + scan_data.append(item.rstrip()) + scan_data=filter(None, scan_data) + elif start_flag == 0: + break + +#print "Scan Data",scan_data +port_info=[] + +for item in scan_data: + print "Scan Data :",item + if re.search("in",item,flags=re.I): + if re.search("std_logic_vector",item,flags=re.I): + temp=re.compile(r"\s*std_logic_vector\s*",flags=re.I) + elif re.search("std_logic",item,flags=re.I): + temp=re.compile(r"\s*std_logic\s*",flags=re.I) + else: + print "Please check your vhdl code for datatype of input port" + sys.exit() + elif re.search("out",item,flags=re.I): + if re.search("std_logic_vector",item,flags=re.I): + temp=re.compile(r"\s*std_logic_vector\s*",flags=re.I) + elif re.search("std_logic",item,flags=re.I): + temp=re.compile(r"\s*std_logic\s*",flags=re.I) + else: + print "Please check your vhdl code for datatype of output port" + sys.exit() + else: + print "Please check the in/out direction of your port" + sys.exit() + + lhs=temp.split(item)[0] + rhs=temp.split(item)[1] + bit_info=re.compile(r"\s*downto\s*",flags=re.I).split(rhs)[0] + port_info.append(lhs+":"+str(int(bit_info)+int(1))) + +print "Port Info :",port_info + +#Open connection_info.txt file + +con_ifo=open('connection_info.txt','w') + +for item in port_info: + word=item.split(':') + con_ifo.write(word[0].strip()+' '+word[1].strip()+' '+word[2].strip()) + con_ifo.write("\n") +con_ifo.close() +############### Reading connection/port information############################# + +#Declaring input and output list +input_list=[] +output_list=[] + +#Reading connection_info.txt file for port infomation +read_file=open('connection_info.txt','r') +data=read_file.readlines() +read_file.close() + +#Extracting input and output port list from data +for line in data: + if re.match(r'^\s*$', line): + pass + #print "Blank Line" + else: + in_items=re.findall("IN",line,re.MULTILINE|re.IGNORECASE) + out_items=re.findall("OUT",line,re.MULTILINE|re.IGNORECASE) + #print "Line",line + if in_items: + input_list.append(line.split()) + #print "Found IN" + else: + pass + #print "Not Found" + + if out_items: + output_list.append(line.split()) + #print "Found Out" + else: + pass + +print "Inout List :",input_list +print "Output list",output_list +input_port=[] +output_port=[] +#creating list of input and output port with its weight +for input in input_list: + input_port.append(input[0]+":"+input[2]) + #print "Input List: ",input +for output in output_list: + output_port.append(output[0]+":"+output[2]) + #print "Output List: ",output + +print "Output Port List : ",output_port +print "Input Port List : ",input_port + +######################Creating content for cfunc.mod file####################### +print "Starting With cfunc.mod file" +cfunc=open('cfunc.mod','w') + +print "Building content for cfunc.mod file" + +comment='''/* This is cfunc.mod file auto generated by gen_con_info.py +Developed by Fahim at IIT Bombay */ \n + ''' + +header=''' +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +''' + +function_open='''void cm_'''+fname.split('.')[0]+'''(ARGS) \n{''' + +digital_state_output=[] +for item in output_port: + digital_state_output.append("Digital_State_t *_op_"+item.split(':')[0]+", *_op_"+item.split(':')[0]+"_old;") + + +var_section=''' + // Declaring components of Client + static int flag=0; + FILE *log_client = NULL; + log_client=fopen("client.log","a"); + int socket_fd, bytes_recieved; + char send_data[1024]; + char recv_data[1024]; + struct hostent *host; + struct sockaddr_in server_addr; + double time_limit = PARAM(stop_time); +''' +temp_input_var=[] +for item in input_port: + temp_input_var.append("char temp_"+item.split(':')[0]+"[1024];") + +#Start of INIT function +init_start_function=''' + if(INIT) + { + /* Allocate storage for output ports.And set the load for input ports */ +''' + +cm_event_alloc=[] +cm_count_output=0 +for item in output_port: + cm_event_alloc.append("cm_event_alloc("+str(cm_count_output)+","+item.split(':')[1]+"*sizeof(Digital_State_t));") + cm_count_output=cm_count_output+1 + +load_in_port=[] +for item in input_port: + load_in_port.append("for(Ii=0;Iih_addr); + bzero(&(server_addr.sin_zero),8); + +''' + +connect_server=''' + printf("Client-Connecting to server \\n"); + fprintf(log_client,"Client-Connecting to server \\n"); + //Conneting to server + + int try_limit=10; + while(try_limit>0) + { + if (connect(socket_fd, (struct sockaddr*)&server_addr,sizeof(struct sockaddr)) == -1) + { + sleep(1); + try_limit--; + if(try_limit==0) + { + fprintf(stderr,"Connect- Error:Tried to connect server on port , failed..giving up \\n"); + fprintf(log_client,"Connect- Error:Tried to connect server on port , failed..giving up \\n"); + exit(1); + } + } + else + { + printf("Client-Connected to server \\n"); + fprintf(log_client,"Client-Connected to server \\n"); + break; + } + } + +''' + +time_limit =''' + if(TIME < time_limit) + { + //Formating data for sending it to client + int Ii; + +''' +#Assign bit value to every input +assign_data_to_input=[] +for item in input_port: + assign_data_to_input.append("\t\t\tfor(Ii=0;Ii "+item.split(':')[0]+",\n") + +for item in output_port: + if output_port.index(item) == len(output_port) - 1: + map.append("\t\t\t\t"+item.split(':')[0]+" => "+item.split(':')[0]+"\n") + else: + map.append("\t\t\t\t"+item.split(':')[0]+" => "+item.split(':')[0]+",\n") +map.append("\t\t\t);") + + +#testbench Clock +tb_clk= "clk_s <= not clk_s after 5 us;\n\n" + +#Adding process block +process=[] +process.append("\tprocess\n\n") + +for item in input_port: + process.append("\t\tvariable "+item.split(':')[0]+"_v : VhpiString;\n") + +for item in output_port: + process.append("\t\tvariable "+item.split(':')[0]+"_v : VhpiString;\n") + +process.append("\t\tvariable obj_ref : VhpiString;\n") +process.append("\tbegin\n\n\t\tVhpi_Initialize;\n\t\twait until clk_s = '1';\n\n") +process.append("\t\twhile true loop\n") +process.append("\t\t\twait until clk_s = '0';\n\t\t\twait for 5 ns;\n\t\t\tVhpi_Listen;\n\n") + +for item in input_port: + process.append('\t\t\tobj_ref := Pack_String_To_Vhpi_String("'+item.split(':')[0]+'");\n') + process.append('\t\t\tVhpi_Get_Port_Value(obj_ref,'+item.split(':')[0]+'_v,'+item.split(':')[1]+');\n') + process.append('\t\t\tassert false report "Get port value '+item.split(':')[0]+' returns " &'+item.split(':')[0]+'_v severity note;\n') + process.append('\t\t\t'+item.split(':')[0]+' <= Unpack_String('+item.split(':')[0]+'_v,'+item.split(':')[1]+');\n') + process.append('\t\t\twait for 1 ns;\n') + process.append("\n") + +for item in output_port: + process.append('\t\t\t'+item.split(':')[0]+'_v := Pack_String_To_Vhpi_String(Convert_SLV_To_String('+item.split(':')[0]+'));\n') + process.append('\t\t\tobj_ref := Pack_String_To_Vhpi_String("'+item.split(':')[0]+'");\n') + process.append('\t\t\tVhpi_Set_Port_Value(obj_ref,'+item.split(':')[0]+'_v,'+item.split(':')[1]+');\n') + process.append('\t\t\tassert false report "Set port value '+item.split(':')[0]+' returns " &'+item.split(':')[0]+'_v severity note;\n') + process.append('\t\t\twait for 1 ns;\n') + process.append("\n") + + +process.append("\t\t\tVhpi_Send;\n\n") +process.append("\t\tend loop;\n") +process.append("\tend process;\n\n") +process.append("end architecture;") + + +#Writing all the components to testbench file + +testbench.write(tb_header) +testbench.write(tb_entity) +testbench.write(arch) + +for item in components: + testbench.write(item) + +for item in signals: + testbench.write(item) + +testbench.write("\n\n") + +testbench.write("begin\n\n") + +for item in map: + testbench.write(item) + +testbench.write("\n\t"+tb_clk) + +for item in process: + testbench.write(item) + +testbench.close() + +#####################################Creating and writing components in start_server.sh ################################ + +start_server = open('start_server.sh','w') + +start_server.write("#!/bin/bash\n\n") +start_server.write("###This server run ghdl testebench for infinite time till ngspice send END signal to stop it\n\n") +start_server.write("#gcc -c ghdlserver.c\n") +start_server.write("#ghdl -a Utility_Package.vhdl &&\n") +start_server.write("#ghdl -a Vhpi_Package.vhdl &&\n") +start_server.write("cd "+home+"/ngspice-26/src/xspice/icm/ghdl/"+fname.split('.')[0]+"/DUTghdl/\n") +start_server.write("ghdl -a "+fname+" &&\n") +start_server.write("ghdl -a "+fname.split('.')[0]+"_tb.vhdl &&\n") +start_server.write("ghdl -e -Wl,ghdlserver.o "+fname.split('.')[0]+"_tb &&\n") +start_server.write("./"+fname.split('.')[0]+"_tb") + +start_server.close() diff --git a/src/ngspice_ghdl.py b/src/ngspice_ghdl.py new file mode 100755 index 0000000..9f88ce2 --- /dev/null +++ b/src/ngspice_ghdl.py @@ -0,0 +1,208 @@ +#!/usr/bin/env python + + +"""#!/usr/bin/python""" + +#This file create the gui to install code model in the ngspice. + +import os +import sys +import shutil +import subprocess +from PyQt4 import QtGui +from PyQt4 import QtCore +from ConfigParser import SafeConfigParser + + +class Mainwindow(QtGui.QWidget): + def __init__(self): + super(Mainwindow, self).__init__() + print "Initializing.........." + self.home = os.path.expanduser("~") + self.parser = SafeConfigParser() + self.parser.read(self.home+'/.FreeEDA/config.ini') + self.initUI() + + def initUI(self): + self.uploadbtn = QtGui.QPushButton('Upload') + self.uploadbtn.clicked.connect(self.uploadModle) + self.exitbtn = QtGui.QPushButton('Exit') + self.exitbtn.clicked.connect(self.closeWindow) + self.browsebtn = QtGui.QPushButton('Browse') + self.browsebtn.clicked.connect(self.browseFile) + self.ledit = QtGui.QLineEdit(self) + self.tedit = QtGui.QTextEdit(self) + + + + #Creating gridlayout + grid = QtGui.QGridLayout() + grid.setSpacing(5) + grid.addWidget(self.ledit, 1, 0) + grid.addWidget(self.browsebtn, 1, 1) + grid.addWidget(self.uploadbtn,2,0) + grid.addWidget(self.exitbtn,2,1) + grid.addWidget(self.tedit,3,0) + + self.setLayout(grid) + self.setGeometry(300, 300, 600,600) + self.setWindowTitle("Ngspice Digital Model Creator") + #self.setWindowIcon(QtGui.QIcon('logo.png')) + self.tedit.setReadOnly(True) + self.show() + + + + def closeWindow(self): + print "Close button clicked" + quit() + + def browseFile(self): + print "Browse button clicked" + self.filename = QtGui.QFileDialog.getOpenFileName(self, 'Open File', '.') + print "Path file :", self.filename + self.ledit.setText(self.filename) + + def createModelDirectory(self): + print "Create Model Directory Called" + self.digital_home=self.parser.get('NGSPICE','DIGITAL_MODEL') + print "Digital Home",self.digital_home + os.chdir(self.digital_home) + print "Current Working Directory Changed to",os.getcwd() + self.modelname = os.path.basename(str(self.filename)).split('.')[0] + print "Model name is :",self.modelname + # Looking if model directory is present or not + if os.path.isdir(self.modelname): + print "Model Already present" + ret = QtGui.QMessageBox.critical(self, "Critical",'''The Model already exist.Do you want to overwrite it?
+ If yes press ok else cancel it and change the name of you vhdl file''', QtGui.QMessageBox.Ok, QtGui.QMessageBox.Cancel) + if ret == QtGui.QMessageBox.Ok: + print "Overwriting existing model" + cmd="rm -rf "+self.modelname + #process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) + subprocess.call(cmd, shell=True) + os.mkdir(self.modelname) + else: + print "Exiting application" + quit() + + + + else: + print "Creating new model directory" + os.mkdir(self.modelname) + + def addingModelInModpath(self): + print "Adding Model in Modpath file",self.modelname,self.digital_home + #Adding name of model in the modpath file + #Check if the string is already in the file + with open(self.digital_home+"/modpath.lst",'a+') as f: + flag = 0 + for line in f: + if line.strip() == self.modelname: + print "Found model" + flag = 1 + break + else: + pass + + if flag == 0: + print "Adding model name into modpath.lst" + f.write(self.modelname+"\n") + else: + print "Model name is already into modpath.lst" + + + def createModelFiles(self): + print "Create Model Files Called" + os.chdir(self.cur_dir) + print "Current Working directory changed to ",self.cur_dir + cmd = "python ~/.FreeEDA/model_generation.py "+str(self.ledit.text()) + stdouterr = os.popen4(cmd)[1].read() + self.tedit.append(stdouterr) + #Moving file to model directory + path=self.digital_home+"/"+self.modelname + shutil.move("cfunc.mod",path) + shutil.move("ifspec.ifs",path) + + #Creating directory inside model directoy + os.mkdir(path+"/DUTghdl/") + shutil.move("connection_info.txt",path+"/DUTghdl/") + shutil.move("start_server.sh",path+"/DUTghdl/") + shutil.move(self.modelname+"_tb.vhdl",path+"/DUTghdl/") + + shutil.copy(str(self.filename),path+"/DUTghdl/") + shutil.copy(self.home+"/.FreeEDA/ghdlserver/compile.sh",path+"/DUTghdl/") + shutil.copy(self.home+"/.FreeEDA/ghdlserver/uthash.h",path+"/DUTghdl/") + shutil.copy(self.home+"/.FreeEDA/ghdlserver/ghdlserver.c",path+"/DUTghdl/") + shutil.copy(self.home+"/.FreeEDA/ghdlserver/ghdlserver.h",path+"/DUTghdl/") + shutil.copy(self.home+"/.FreeEDA/ghdlserver/Utility_Package.vhdl",path+"/DUTghdl/") + shutil.copy(self.home+"/.FreeEDA/ghdlserver/Vhpi_Package.vhdl",path+"/DUTghdl/") + + os.chdir(path+"/DUTghdl") + subprocess.call("bash "+path+"/DUTghdl/compile.sh", shell=True) + subprocess.call("chmod a+x start_server.sh",shell=True) + os.remove("compile.sh") + os.remove("ghdlserver.c") + #os.remove("ghdlserver.h") + #os.remove("Utility_Package.vhdl") + #os.remove("Vhpi_Package.vhdl") + + + + + + + + def runMake(self): + print "run Make Called" + self.release_home=self.parser.get('NGSPICE','RELEASE') + os.chdir(self.release_home) + try: + cmd = "make" + self.tedit.append("Running Make") + subprocess.call(cmd,shell=True) + #stdouterr = os.popen4(cmd)[1].read() + #self.tedit.append(stdouterr) + except: + print "There is error in 'make' " + quit() + + def runMakeInstall(self): + print "run Make Install Called" + try: + cmd = "make install" + self.tedit.append("Running Make Install") + subprocess.call(cmd,shell=True) + #stdouterr = os.popen4(cmd)[1].read() + #self.tedit.append(stdouterr) + except: + print "There is error during in 'make install' " + quit() + + def uploadModle(self): + print "Upload button clicked" + self.file_extension = os.path.splitext(str(self.filename))[1] + print "File extension",self.file_extension + print "Parser Content:",self.parser.get('NGSPICE', 'NGSPICE_HOME') + self.cur_dir = os.getcwd() + print "My Current Working Directory",self.cur_dir + if self.file_extension == ".vhdl": + self.createModelDirectory() + self.addingModelInModpath() + self.createModelFiles() + self.runMake() + self.runMakeInstall() + else: + QtGui.QMessageBox.about(self,'Message','''Important Message.

This accepts only .vhdl file ''') + + + + +def main(): + app = QtGui.QApplication(sys.argv) + w = Mainwindow() + sys.exit(app.exec_()) + +if __name__=='__main__': + main() -- cgit