memories.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	s_memory
struct	s_memory_port_sizes
Typedefs
typedef struct s_memory	t_memory
typedef struct s_memory_port_sizes	t_memory_port_sizes
Functions
void	init_memory_distribution ()
void	report_memory_distribution ()
int	get_memory_port_size (char *name)
void	split_sp_memory_depth (nnode_t *node)
void	split_dp_memory_depth (nnode_t *node)
void	split_sp_memory_width (nnode_t *node)
void	split_dp_memory_width (nnode_t *node)
void	iterate_memories (netlist_t *netlist)
void	clean_memories ()
Variables
struct s_linked_vptr *	sp_memory_list
struct s_linked_vptr *	dp_memory_list
struct s_linked_vptr *	memory_instances
struct s_linked_vptr *	memory_port_size_list
int	split_size

---

Typedef Documentation

typedef struct s_memory t_memory

typedef struct s_memory_port_sizes t_memory_port_sizes

---

Function Documentation

void clean_memories

(

)

Definition at line 999 of file memories.c.

{
        while (sp_memory_list != NULL)
                sp_memory_list = delete_in_vptr_list(sp_memory_list);
        while (dp_memory_list != NULL)
                dp_memory_list = delete_in_vptr_list(dp_memory_list);
        return;
}

Here is the caller graph for this function:

int get_memory_port_size

(

char *

name

)

Definition at line 39 of file memories.c.

{
        struct s_linked_vptr *mpl;

        mpl = memory_port_size_list;
        while (mpl != NULL)
        {
                if (strcmp(((t_memory_port_sizes *)mpl->data_vptr)->name, name) == 0)
                        return ((t_memory_port_sizes *)mpl->data_vptr)->size;
                mpl = mpl->next;
        }
        return -1;
}

void init_memory_distribution

(

)

Definition at line 54 of file memories.c.

{
        return;
}

void iterate_memories

(

netlist_t *

netlist

)

Definition at line 928 of file memories.c.

{
        nnode_t *node;
        struct s_linked_vptr *temp;

        /* Split it up on depth */
        if (configuration.split_memory_depth != 0)
        {
                /* Jason Luu: HACK detected: split_size should NOT come from configuration.split_memory_depth, 
                   it should come from the maximum model size for the port, IMPORTANT TODO!!!! */
                split_size = configuration.split_memory_depth;

                temp = sp_memory_list;
                sp_memory_list = NULL;
                while (temp != NULL)
                {
                        node = (nnode_t *)temp->data_vptr;
                        oassert(node != NULL);
                        oassert(node->type == MEMORY);
                        temp = delete_in_vptr_list(temp);
                        split_sp_memory_depth(node);
                }

                temp = dp_memory_list;
                dp_memory_list = NULL;
                while (temp != NULL)
                {
                        node = (nnode_t *)temp->data_vptr;
                        oassert(node != NULL);
                        oassert(node->type == MEMORY);
                        temp = delete_in_vptr_list(temp);
                        split_dp_memory_depth(node);
                }
        }

        /* Split memory up on width */
        if (configuration.split_memory_width == 1)
        {
                temp = sp_memory_list;
                sp_memory_list = NULL;
                while (temp != NULL)
                {
                        node = (nnode_t *)temp->data_vptr;
                        oassert(node != NULL);
                        oassert(node->type == MEMORY);
                        temp = delete_in_vptr_list(temp);
                        split_sp_memory_width(node);
                }

                temp = dp_memory_list;
                dp_memory_list = NULL;
                while (temp != NULL)
                {
                        node = (nnode_t *)temp->data_vptr;
                        oassert(node != NULL);
                        oassert(node->type == MEMORY);
                        temp = delete_in_vptr_list(temp);
                        split_dp_memory_width(node);
                }
        }

        return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void report_memory_distribution

(

)

Definition at line 60 of file memories.c.

{
        nnode_t *node;
        struct s_linked_vptr *temp;
        int i, idx, width, depth;

        if ((sp_memory_list == NULL) && (dp_memory_list == NULL))
                return;
        printf("\nHard Logical Memory Distribution\n");
        printf("============================\n");

        temp = sp_memory_list;
        while (temp != NULL)
        {
                node = (nnode_t *)temp->data_vptr;
                oassert(node != NULL);
                oassert(node->type == MEMORY);

                /* Need to find the addr and data1 ports */
                idx = 0;
                for (i = 0; i < node->num_input_port_sizes; i++)
                {
                        if (strcmp("addr", node->input_pins[idx]->mapping) == 0)
                        {
                                depth = node->input_port_sizes[i];
                        }
                        else if (strcmp("data", node->input_pins[idx]->mapping) == 0)
                        {
                                width = node->input_port_sizes[i];
                        }
                        idx += node->input_port_sizes[i];
                }

                printf("SPRAM: %d width %d depth\n", width, depth);
                temp = temp->next;
        }

        temp = dp_memory_list;
        while (temp != NULL)
        {
                node = (nnode_t *)temp->data_vptr;
                oassert(node != NULL);
                oassert(node->type == MEMORY);

                /* Need to find the addr and data1 ports */
                idx = 0;
                for (i = 0; i < node->num_input_port_sizes; i++)
                {
                        if (strcmp("addr", node->input_pins[idx]->mapping) == 0)
                        {
                                depth = node->input_port_sizes[i];
                        } else if (strcmp("addr1", node->input_pins[idx]->mapping) == 0)
                        {
                                depth = node->input_port_sizes[i];
                        }
                        else if (strcmp("data1", node->input_pins[idx]->mapping) == 0)
                        {
                                width = node->input_port_sizes[i];
                        }
                        idx += node->input_port_sizes[i];
                }

                printf("DPRAM: %d width %d depth\n", width, depth);
                temp = temp->next;
        }
        
        printf("\n");
        return;
}

Here is the caller graph for this function:

void split_dp_memory_depth

(

nnode_t *

node

)

Definition at line 308 of file memories.c.

{
        int addr1_port = -1;
        int addr2_port = -1;
        int we1_port = -1;
        int we2_port = -1;
        int clk_port = -1;
        int logical_size;
        int i, j, idx, addr1_pin_idx, we1_pin_idx, addr2_pin_idx, we2_pin_idx;
        nnode_t *new_mem_node;
        nnode_t *and1_node, *not1_node, *ff1_node, *mux1_node;
        nnode_t *and2_node, *not2_node, *ff2_node, *mux2_node;
        npin_t *addr1_pin = NULL;
        npin_t *addr2_pin = NULL;
        npin_t *we1_pin = NULL;
        npin_t *we2_pin = NULL;
        npin_t *twe_pin, *taddr_pin, *clk_pin, *tdout_pin;

        oassert(node->type == MEMORY);

        /* Find which ports are the addr1 and addr2 ports */
        idx = 0;
        for (i = 0; i < node->num_input_port_sizes; i++)
        {
                if (strcmp("addr1", node->input_pins[idx]->mapping) == 0)
                {
                        addr1_port = i;
                        addr1_pin_idx = idx;
                        addr1_pin = node->input_pins[idx];
                }
                else if (strcmp("addr2", node->input_pins[idx]->mapping) == 0)
                {
                        addr2_port = i;
                        addr2_pin_idx = idx;
                        addr2_pin = node->input_pins[idx];
                }
                else if (strcmp("we1", node->input_pins[idx]->mapping) == 0)
                {
                        we1_port = i;
                        we1_pin = node->input_pins[idx];
                        we1_pin_idx = idx;
                }
                else if (strcmp("we2", node->input_pins[idx]->mapping) == 0)
                {
                        we2_port = i;
                        we2_pin = node->input_pins[idx];
                        we2_pin_idx = idx;
                }
                else if (strcmp("clk", node->input_pins[idx]->mapping) == 0)
                {
                        clk_port = i;
                        clk_pin = node->input_pins[idx];
                }
                idx += node->input_port_sizes[i];
        }

        if (addr1_port == -1)
        {
                error_message(1, 0, -1, "No \"addr1\" port on dual port RAM");
        }

        
        /* Jason Luu HACK: Logical memory depth determination messed up, forced to use this method */
        for(i = 0; i < node->input_port_sizes[addr1_port]; i++)
        {
                if(strcmp(node->input_pins[addr1_pin_idx + i]->name, "top^ZERO_PAD_ZERO") == 0)
                        break;
        }
        logical_size = i;
        
        /* Check that the memory needs to be split */
        if (logical_size <= split_size) {
                dp_memory_list = insert_in_vptr_list(dp_memory_list, node);
                return;
        } 

        /* Let's remove the address1 line from the memory */
        for (i = addr1_pin_idx; i < node->num_input_pins - 1; i++)
        {
                node->input_pins[i] = node->input_pins[i+1];
                node->input_pins[i]->pin_node_idx--;
        }
        node->input_port_sizes[addr1_port]--;
        node->num_input_pins--;
        if ((we1_port != -1) && (we1_pin_idx >= addr1_pin_idx))
                we1_pin_idx--;
        if ((we2_port != -1) && (we2_pin_idx >= addr1_pin_idx))
                we2_pin_idx--;
        if ((addr2_port != -1) && (addr2_pin_idx >= addr1_pin_idx))
                addr2_pin_idx--;

        /* Let's remove the address2 line from the memory */
        if (addr2_port != -1)
        {
                for (i = addr2_pin_idx; i < node->num_input_pins - 1; i++)
                {
                        node->input_pins[i] = node->input_pins[i+1];
                        node->input_pins[i]->pin_node_idx--;
                }
                node->input_port_sizes[addr2_port]--;
                node->num_input_pins--;
                if ((we1_port != -1) && (we1_pin_idx >= addr2_pin_idx))
                        we1_pin_idx--;
                if ((we2_port != -1) && (we2_pin_idx >= addr2_pin_idx))
                        we2_pin_idx--;
                if (addr1_pin_idx >= addr2_pin_idx)
                        addr1_pin_idx--;
        }

        /* Create the new memory node */
        new_mem_node = allocate_nnode();
        new_mem_node->name = (char *)malloc(strlen(node->name) + 10);
        strcpy(new_mem_node->name, node->name);
        strcat(new_mem_node->name, "__H");
        node->name = (char *)realloc(node->name, strlen(node->name) + 10);
        strcat(node->name,"__S");

        /* Copy properties from the original memory node */
        new_mem_node->type = node->type;
        new_mem_node->related_ast_node = node->related_ast_node;
        new_mem_node->traverse_visited = node->traverse_visited;
        new_mem_node->node_data = NULL;

        new_mem_node->num_output_pins = node->num_output_pins;
        new_mem_node->num_output_port_sizes = node->num_output_port_sizes;
        new_mem_node->output_pins = (struct npin_t_t **)malloc(sizeof(struct npin_t_t **) * new_mem_node->num_output_pins);
        for (i = 0; i < new_mem_node->num_output_pins; i++)
                new_mem_node->output_pins[i] = NULL;
        new_mem_node->output_port_sizes = (int *)malloc(sizeof(int) * new_mem_node->num_output_port_sizes);
        for (i = 0; i < new_mem_node->num_output_port_sizes; i++)
                new_mem_node->output_port_sizes[i] = node->output_port_sizes[i];
        new_mem_node->num_input_port_sizes = node->num_input_port_sizes;
        new_mem_node->input_port_sizes = (int *)malloc(node->num_input_port_sizes * sizeof(int));
        new_mem_node->input_pins = (struct npin_t_t **)malloc(node->num_input_pins * sizeof(struct npin_t_t **));

        /* KEN - IS THIS AN ERROR? */
        new_mem_node->num_input_pins = node->num_input_pins; // jluu yes -1; is an error, removed

        /* Copy over the pin sizes for the new memory */
        for (j = 0; j < new_mem_node->num_input_port_sizes; j++)
        {
                new_mem_node->input_port_sizes[j] = node->input_port_sizes[j];
        }

        /* Copy over the pins for the new memory */
        for (j = 0; j < node->num_input_pins; j++)
        {
                new_mem_node->input_pins[j] = copy_input_npin(node->input_pins[j]);
        }

        if (we1_pin != NULL)
        {
                and1_node = make_2port_gate(LOGICAL_AND, 1, 1, 1, node, node->traverse_visited);
                twe_pin = copy_input_npin(we1_pin);
                add_a_input_pin_to_node_spot_idx(and1_node, twe_pin, 1);
                taddr_pin = copy_input_npin(addr1_pin);
                add_a_input_pin_to_node_spot_idx(and1_node, taddr_pin, 0);
                connect_nodes(and1_node, 0, node, we1_pin_idx);
                node->input_pins[we1_pin_idx]->mapping = we1_pin->mapping;
        }

        if (we2_pin != NULL)
        {
                and2_node = make_2port_gate(LOGICAL_AND, 1, 1, 1, node, node->traverse_visited);
                twe_pin = copy_input_npin(we2_pin);
                add_a_input_pin_to_node_spot_idx(and2_node, twe_pin, 1);
                taddr_pin = copy_input_npin(addr2_pin);
                add_a_input_pin_to_node_spot_idx(and2_node, taddr_pin, 0);
                connect_nodes(and2_node, 0, node, we2_pin_idx);
                node->input_pins[we2_pin_idx]->mapping = we2_pin->mapping;
        }

        if (we1_pin != NULL)
        {
                taddr_pin = copy_input_npin(addr1_pin);
                not1_node = make_not_gate_with_input(taddr_pin, new_mem_node, new_mem_node->traverse_visited);
                and1_node = make_2port_gate(LOGICAL_AND, 1, 1, 1, new_mem_node, new_mem_node->traverse_visited);
                connect_nodes(not1_node, 0, and1_node, 0);
                add_a_input_pin_to_node_spot_idx(and1_node, we1_pin, 1);
                connect_nodes(and1_node, 0, new_mem_node, we1_pin_idx);
                new_mem_node->input_pins[we1_pin_idx]->mapping = we1_pin->mapping;
        }

        if (we2_pin != NULL)
        {
                taddr_pin = copy_input_npin(addr2_pin);
                not2_node = make_not_gate_with_input(taddr_pin, new_mem_node, new_mem_node->traverse_visited);
                and2_node = make_2port_gate(LOGICAL_AND, 1, 1, 1, new_mem_node, new_mem_node->traverse_visited);
                connect_nodes(not2_node, 0, and2_node, 0);
                add_a_input_pin_to_node_spot_idx(and2_node, we2_pin, 1);
                connect_nodes(and2_node, 0, new_mem_node, we2_pin_idx);
                new_mem_node->input_pins[we2_pin_idx]->mapping = we2_pin->mapping;
        }

        if (node->num_output_pins > 0) /* There is an "out1" output */
        {
                ff1_node = make_2port_gate(FF_NODE, 1, 1, 1, node, node->traverse_visited);
                add_a_input_pin_to_node_spot_idx(ff1_node, addr1_pin, 0);
                add_a_input_pin_to_node_spot_idx(ff1_node, copy_input_npin(clk_pin), 1);
        
                /* Copy over the output pins for the new memory */
                for (j = 0; j < node->output_port_sizes[0]; j++)
                {
                        mux1_node = make_2port_gate(MULTI_PORT_MUX, 2, 2, 1, node, node->traverse_visited);
                        connect_nodes(ff1_node, 0, mux1_node, 0);
                        not1_node = make_not_gate(node, node->traverse_visited);
                        connect_nodes(ff1_node, 0, not1_node, 0);
                        connect_nodes(not1_node, 0, mux1_node, 1);
                        tdout_pin = node->output_pins[j];
                        remap_pin_to_new_node(tdout_pin, mux1_node, 0);
                        connect_nodes(node, j, mux1_node, 3);
                        node->output_pins[j]->mapping = tdout_pin->mapping;
                        connect_nodes(new_mem_node, j, mux1_node, 2);
                        new_mem_node->output_pins[j]->mapping = tdout_pin->mapping;
                        tdout_pin->mapping = NULL;
                }
        }

        if (node->num_output_pins > node->output_port_sizes[0]) /* There is an "out2" output */
        {
                ff2_node = make_2port_gate(FF_NODE, 1, 1, 1, node, node->traverse_visited);
                add_a_input_pin_to_node_spot_idx(ff2_node, addr2_pin, 0);
                add_a_input_pin_to_node_spot_idx(ff2_node, copy_input_npin(clk_pin), 1);
        
                /* Copy over the output pins for the new memory */
                for (j = 0; j < node->output_port_sizes[0]; j++)
                {
                        mux2_node = make_2port_gate(MULTI_PORT_MUX, 2, 2, 1, node, node->traverse_visited);
                        connect_nodes(ff2_node, 0, mux2_node, 0);
                        not2_node = make_not_gate(node, node->traverse_visited);
                        connect_nodes(ff2_node, 0, not2_node, 0);
                        connect_nodes(not2_node, 0, mux2_node, 1);
                        tdout_pin = node->output_pins[node->output_port_sizes[0] + j];
                        remap_pin_to_new_node(tdout_pin, mux2_node, 0);
                        connect_nodes(node, node->output_port_sizes[0] + j, mux2_node, 3);
                        node->output_pins[node->output_port_sizes[0] + j]->mapping = tdout_pin->mapping;
                        connect_nodes(new_mem_node, node->output_port_sizes[0] + j, mux2_node, 2);
                        new_mem_node->output_pins[node->output_port_sizes[0] + j]->mapping = tdout_pin->mapping;
                        tdout_pin->mapping = NULL;
                }
        }

        /* must recurse on new memory if it's too small */
        if (logical_size <= split_size) {
                dp_memory_list = insert_in_vptr_list(dp_memory_list, new_mem_node);
                dp_memory_list = insert_in_vptr_list(dp_memory_list, node);
        } else {
                split_dp_memory_depth(node);
                split_dp_memory_depth(new_mem_node);
        }

        return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void split_dp_memory_width

(

nnode_t *

node

)

Definition at line 708 of file memories.c.

{
        int data_port1, data_port2;
        int i, j, k, idx, old_idx, data_diff1, data_diff2;
        nnode_t *new_node;
        char *tmp_name;
        nnet_t *data1_net, *data2_net;

        oassert(node->type == MEMORY);

        /* Find which port is the data port on the input! */
        idx = 0;
        data_port1 = -1;
        data_port2 = -1;
        data_diff1 = 0;
        data_diff2 = 0;
        data1_net = node->output_pins[0]->net;
        if (node->num_output_port_sizes > 1)
                data2_net = node->output_pins[node->output_port_sizes[0]]->net;
        for (i = 0; i < node->num_input_port_sizes; i++)
        {
                if (strcmp("data1", node->input_pins[idx]->mapping) == 0)
                {
                        data_port1 = i;
                        data_diff1 = node->input_port_sizes[data_port1] - 1;
                }
                if (strcmp("data2", node->input_pins[idx]->mapping) == 0)
                {
                        data_port2 = i;
                        data_diff2 = node->input_port_sizes[data_port2] - 1;
                }
                idx += node->input_port_sizes[i];
        }

        if (data_port1 == -1)
        {
                error_message(1, 0, -1, "No \"data1\" port on dual port RAM");
                return;
        }

        /* Need to create a new node for every data bit */
        for (i = 1; i < node->input_port_sizes[data_port1]; i++)
        {
                char BUF[10];
                new_node = allocate_nnode();
                dp_memory_list = insert_in_vptr_list(dp_memory_list, new_node);
                new_node->name = (char *)malloc(strlen(node->name) + 10);
                strcpy(new_node->name, node->name);
                strcat(new_node->name, "-");
                sprintf(BUF, "%d", i);
                strcat(new_node->name, BUF);

                /* Copy properties from the original node */
                new_node->type = node->type;
                new_node->related_ast_node = node->related_ast_node;
                new_node->traverse_visited = node->traverse_visited;
                new_node->node_data = NULL;

                new_node->num_input_port_sizes = node->num_input_port_sizes;
                new_node->input_port_sizes = (int *)malloc(node->num_input_port_sizes * sizeof(int));
                for (j = 0; j < node->num_input_port_sizes; j++)
                        new_node->input_port_sizes[j] = node->input_port_sizes[j];

                new_node->input_port_sizes[data_port1] = 1;
                if (data_port2 != -1)
                        new_node->input_port_sizes[data_port2] = 1;

                if (data_port2 == -1)
                {
                        new_node->num_output_port_sizes = 1;
                        new_node->output_port_sizes = (int *)malloc(sizeof(int));
                }
                else
                {
                        new_node->num_output_port_sizes = 2;
                        new_node->output_port_sizes = (int *)malloc(sizeof(int)*2);
                        new_node->output_port_sizes[1] = 1;
                }
                new_node->output_port_sizes[0] = 1;

                /* Set the number of input pins and pin entires */
                new_node->num_input_pins = node->num_input_pins - data_diff1 - data_diff2;
                new_node->input_pins = (npin_t**)malloc(sizeof(void *) * new_node->num_input_pins);


                idx = 0;
                old_idx = 0;
                for (j = 0; j < new_node->num_input_port_sizes; j++)
                {
                        if (j == data_port1)
                        {
                                new_node->input_pins[idx] = node->input_pins[old_idx + i];
                                node->input_pins[old_idx+i] = NULL;
                                new_node->input_pins[idx]->node = new_node;
                                new_node->input_pins[idx]->pin_node_idx = idx;
                                old_idx = old_idx + node->input_port_sizes[data_port1];
                                idx++;
                        }
                        else if (j == data_port2)
                        {
                                new_node->input_pins[idx] = node->input_pins[old_idx + i];
                                node->input_pins[old_idx+i] = NULL;
                                new_node->input_pins[idx]->node = new_node;
                                new_node->input_pins[idx]->pin_node_idx = idx;
                                old_idx = old_idx + node->input_port_sizes[data_port2];
                                idx++;
                        }
                        else
                        {
                                for (k = 0; k < new_node->input_port_sizes[j]; k++)
                                {
                                        new_node->input_pins[idx] = copy_input_npin(node->input_pins[old_idx]);
                                        new_node->input_pins[idx]->pin_node_idx = idx;
                                        new_node->input_pins[idx]->node = new_node;
                                        idx++;
                                        old_idx++;
                                }
                        }
                }

                /* Set the number of output pins and pin entry */
                if (data_port2 == -1)
                {
                        new_node->num_output_pins = 1;
                        new_node->output_pins = (npin_t **)malloc(sizeof(void*));
//                      new_node->output_pins[0] = copy_output_npin(node->output_pins[i]);
//                      add_a_driver_pin_to_net(data1_net, new_node->output_pins[0]);
//                      free_npin(node->output_pins[i]);
                        new_node->output_pins[0] = node->output_pins[i];
                        node->output_pins[i] = NULL;
                        new_node->output_pins[0]->pin_node_idx = 0;
                        new_node->output_pins[0]->node = new_node;
                }
                else
                {
                        new_node->num_output_pins = 2;
                        new_node->output_pins = (npin_t **)malloc(sizeof(void*)*2);
//                      new_node->output_pins[0] = copy_output_npin(node->output_pins[i]);
//                      new_node->output_pins[1] = copy_output_npin(node->output_pins[i+data_diff1+1]);
//                      add_a_driver_pin_to_net(data1_net, new_node->output_pins[0]);
//                      free_npin(node->output_pins[i]);
                        new_node->output_pins[0] = node->output_pins[i];
                        node->output_pins[i] = NULL;
                        new_node->output_pins[0]->pin_node_idx = 0;
                        new_node->output_pins[0]->node = new_node;

//                      add_a_driver_pin_to_net(data2_net, new_node->output_pins[1]);
//                      free_npin(node->output_pins[i+data_diff1+1]);
                        new_node->output_pins[1] = node->output_pins[i+data_diff1+1];
                        node->output_pins[i+data_diff1+1] = NULL;
                        new_node->output_pins[1]->pin_node_idx = 1;
                        new_node->output_pins[1]->node = new_node;
                }
        }

        /* Now need to clean up the original to do 1 bit output - first bit */
        /* Name the node to show first bit! */
        tmp_name = (char *)malloc(strlen(node->name) + 3);
        strcpy(tmp_name, node->name);
        strcat(tmp_name, "-0");
        free(node->name);
        node->name = tmp_name;

        /* free the additional output pins */
        if (data_port2 == -1)
        {
//              for (i = 1; i < node->num_output_pins; i++)
//                      free_npin(node->output_pins[i]);
                node->num_output_pins = 1;
                node->output_port_sizes[0] = 1;
        }
        else
        {
//              for (i = 1; i < (node->num_output_pins/2); i++)
//                      free_npin(node->output_pins[i]);
                node->output_pins[1] = node->output_pins[data_diff1 + 1];
                node->output_pins[data_diff1 + 1] = NULL;
                node->output_pins[1]->pin_node_idx = 1;
//              for (; i < node->num_output_pins; i++)
//                      free_npin(node->output_pins[i]);
                node->num_output_pins = 2;
                node->output_port_sizes[0] = 1;
                node->output_port_sizes[1] = 1;
        }

        /* Shuffle the input pins on account of removed input pins */
        idx = old_idx = 0;
        node->input_port_sizes[data_port1] = 1;
        if (data_port2 != -1)
                node->input_port_sizes[data_port2] = 1;
        for (i = 0; i < node->num_input_port_sizes; i++)
        {
                for (j = 0; j < node->input_port_sizes[i]; j++)
                {
                        node->input_pins[idx] = node->input_pins[old_idx];
                        node->input_pins[idx]->pin_node_idx = idx;
                        idx++;
                        old_idx++;
                }
                if (i == data_port1)
                        old_idx = old_idx + data_diff1;
                if (i == data_port2)
                        old_idx = old_idx + data_diff2;
        }
        node->num_input_pins = node->num_input_pins - data_diff1;
        if (data_port2 != -1)
                node->num_input_pins = node->num_input_pins - data_diff2;
        dp_memory_list = insert_in_vptr_list(dp_memory_list, node);

        return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void split_sp_memory_depth

(

nnode_t *

node

)

Definition at line 138 of file memories.c.

{
        int addr_port = -1;
        int we_port = -1;
        int clk_port = -1;
        int logical_size;
        int i, j, idx, addr_pin_idx, we_pin_idx;
        nnode_t *new_mem_node;
        nnode_t *and_node, *not_node, *ff_node, *mux_node;
        npin_t *addr_pin = NULL;
        npin_t *we_pin = NULL;
        npin_t *twe_pin, *taddr_pin, *clk_pin, *tdout_pin;

        oassert(node->type == MEMORY);

        /* Find which port is the addr port */
        idx = 0;
        for (i = 0; i < node->num_input_port_sizes; i++)
        {
                if (strcmp("addr", node->input_pins[idx]->mapping) == 0)
                {
                        addr_port = i;
                        addr_pin_idx = idx;
                        addr_pin = node->input_pins[idx];
                }
                else if (strcmp("we", node->input_pins[idx]->mapping) == 0)
                {
                        we_port = i;
                        we_pin = node->input_pins[idx];
                        we_pin_idx = idx;
                }
                else if (strcmp("clk", node->input_pins[idx]->mapping) == 0)
                {
                        clk_port = i;
                        clk_pin = node->input_pins[idx];
                }
                idx += node->input_port_sizes[i];
        }
        if (addr_port == -1)
        {
                error_message(1, 0, -1, "No \"addr\" port on single port RAM");
        }
        if (we_port == -1)
        {
                error_message(1, 0, -1, "No \"we\" port on single port RAM");
        }
        if (clk_port == -1)
        {
                error_message(1, 0, -1, "No \"clk\" port on single port RAM");
        }
        
        /* Check that the memory needs to be split */
        /* Jason Luu HACK: Logical memory depth determination messed up, forced to use this method */
        for(i = 0; i < node->input_port_sizes[addr_port]; i++)
        {
                if(strcmp(node->input_pins[addr_pin_idx + i]->name, "top^ZERO_PAD_ZERO") == 0)
                        break;
        }
        logical_size = i;
        if (logical_size <= split_size) {
                sp_memory_list = insert_in_vptr_list(sp_memory_list, node);
                return;
        }

        /* Let's remove the address line from the memory */
        for (i = addr_pin_idx; i < node->num_input_pins - 1; i++)
        {
                node->input_pins[i] = node->input_pins[i+1];
                node->input_pins[i]->pin_node_idx--;
        }
        node->input_port_sizes[addr_port]--;
        node->num_input_pins--;
        if (we_pin_idx >= addr_pin_idx)
                we_pin_idx--;

        /* Create the new memory node */
        new_mem_node = allocate_nnode();
        new_mem_node->name = (char *)malloc(strlen(node->name) + 10);
        strcpy(new_mem_node->name, node->name);
        strcat(new_mem_node->name, "__H");
        node->name = (char *)realloc(node->name, strlen(node->name) + 10);
        strcat(node->name,"__S");

        /* Copy properties from the original memory node */
        new_mem_node->type = node->type;
        new_mem_node->related_ast_node = node->related_ast_node;
        new_mem_node->traverse_visited = node->traverse_visited;
        new_mem_node->node_data = NULL;
        new_mem_node->num_output_pins = node->num_output_pins;
        new_mem_node->output_pins = (struct npin_t_t **)malloc(node->num_output_pins * sizeof(struct npin_t_t **));
        new_mem_node->output_port_sizes = (int *)malloc(sizeof(int));
        new_mem_node->output_port_sizes[0] = node->output_port_sizes[0];
        for (i = 0; i < new_mem_node->num_output_pins; i++)
                new_mem_node->output_pins[i] = NULL;

        new_mem_node->num_input_port_sizes = node->num_input_port_sizes;
        new_mem_node->input_port_sizes = (int *)malloc(node->num_input_port_sizes * sizeof(int));
        new_mem_node->input_pins = (struct npin_t_t **)malloc(node->num_input_pins * sizeof(struct npin_t_t **));
        new_mem_node->num_input_pins = node->num_input_pins; //- 1;

        /* Copy over the pin sizes for the new memory */
        for (j = 0; j < new_mem_node->num_input_port_sizes; j++)
        {
                new_mem_node->input_port_sizes[j] = node->input_port_sizes[j];
        }

        /* Copy over the pins for the new memory */
        for (j = 0; j < node->num_input_pins; j++)
        {
                new_mem_node->input_pins[j] = copy_input_npin(node->input_pins[j]);
        }

        and_node = make_2port_gate(LOGICAL_AND, 1, 1, 1, node, node->traverse_visited);
        twe_pin = copy_input_npin(we_pin);
        add_a_input_pin_to_node_spot_idx(and_node, twe_pin, 1);
        taddr_pin = copy_input_npin(addr_pin);
        add_a_input_pin_to_node_spot_idx(and_node, taddr_pin, 0);
        connect_nodes(and_node, 0, node, we_pin_idx);
        node->input_pins[we_pin_idx]->mapping = we_pin->mapping;

        taddr_pin = copy_input_npin(addr_pin);
        not_node = make_not_gate_with_input(taddr_pin, new_mem_node, new_mem_node->traverse_visited);
        and_node = make_2port_gate(LOGICAL_AND, 1, 1, 1, new_mem_node, new_mem_node->traverse_visited);
        connect_nodes(not_node, 0, and_node, 0);
        add_a_input_pin_to_node_spot_idx(and_node, we_pin, 1);
        connect_nodes(and_node, 0, new_mem_node, we_pin_idx);
        new_mem_node->input_pins[we_pin_idx]->mapping = we_pin->mapping;

        ff_node = make_2port_gate(FF_NODE, 1, 1, 1, node, node->traverse_visited);
        add_a_input_pin_to_node_spot_idx(ff_node, addr_pin, 0);
        add_a_input_pin_to_node_spot_idx(ff_node, copy_input_npin(clk_pin), 1);

        
        /* Copy over the output pins for the new memory */
        for (j = 0; j < node->num_output_pins; j++)
        {
                mux_node = make_2port_gate(MULTI_PORT_MUX, 2, 2, 1, node, node->traverse_visited);
                connect_nodes(ff_node, 0, mux_node, 0);
                not_node = make_not_gate(node, node->traverse_visited);
                connect_nodes(ff_node, 0, not_node, 0);
                connect_nodes(not_node, 0, mux_node, 1);
                tdout_pin = node->output_pins[j];
                remap_pin_to_new_node(tdout_pin, mux_node, 0);
                connect_nodes(node, j, mux_node, 3);
                node->output_pins[j]->mapping = tdout_pin->mapping;
                connect_nodes(new_mem_node, j, mux_node, 2);
                new_mem_node->output_pins[j]->mapping = tdout_pin->mapping;
                tdout_pin->mapping = NULL;
        }

        /* must recurse on new memory if it's too small */
        if (logical_size <= split_size) {
                sp_memory_list = insert_in_vptr_list(sp_memory_list, new_mem_node);
                sp_memory_list = insert_in_vptr_list(sp_memory_list, node);
        } else {
                split_sp_memory_depth(node);
                split_sp_memory_depth(new_mem_node);
        }

        return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void split_sp_memory_width

(

nnode_t *

node

)

Definition at line 570 of file memories.c.

{
        int data_port;
        int i, j, k, idx, old_idx, diff;
        nnode_t *new_node;
        char *tmp_name;

        oassert(node->type == MEMORY);

        /* Find which port is the data port on the input! */
        idx = 0;
        data_port = -1;
        for (i = 0; i < node->num_input_port_sizes; i++)
        {
                if (strcmp("data", node->input_pins[idx]->mapping) == 0)
                        data_port = i;
                idx += node->input_port_sizes[i];
        }
        if (data_port == -1)
        {
                error_message(1, 0, -1, "No \"data\" port on single port RAM");
        }

        diff = node->input_port_sizes[data_port];

        /* Need to create a new node for every data bit */
        for (i = 1; i < node->input_port_sizes[data_port]; i++)
        {
                char BUF[10];
                new_node = allocate_nnode();
                sp_memory_list = insert_in_vptr_list(sp_memory_list, new_node);
                new_node->name = (char *)malloc(strlen(node->name) + 10);
                strcpy(new_node->name, node->name);
                strcat(new_node->name, "-");
                sprintf(BUF, "%d", i);
                strcat(new_node->name, BUF);

                /* Copy properties from the original node */
                new_node->type = node->type;
                new_node->related_ast_node = node->related_ast_node;
                new_node->traverse_visited = node->traverse_visited;
                new_node->node_data = NULL;

                new_node->num_input_port_sizes = node->num_input_port_sizes;
                new_node->input_port_sizes = (int *)malloc(node->num_input_port_sizes * sizeof(int));
                for (j = 0; j < node->num_input_port_sizes; j++)
                        new_node->input_port_sizes[j] = node->input_port_sizes[j];

                new_node->input_port_sizes[data_port] = 1;
                new_node->num_output_port_sizes = 1;
                new_node->output_port_sizes = (int *)malloc(sizeof(int));
                new_node->output_port_sizes[0] = 1;

                /* Set the number of input pins and pin entires */
                new_node->num_input_pins = node->num_input_pins - diff + 1;
                new_node->input_pins = (npin_t**)malloc(sizeof(void *) * new_node->num_input_pins);

                idx = 0;
                old_idx = 0;
                for (j = 0; j < new_node->num_input_port_sizes; j++)
                {
                        if (j == data_port)
                        {
                                new_node->input_pins[idx] = node->input_pins[idx + i];
                                node->input_pins[idx+i] = NULL;
                                new_node->input_pins[idx]->node = new_node;
                                new_node->input_pins[idx]->pin_node_idx = idx;
                                old_idx = old_idx + node->input_port_sizes[data_port];
                                idx++;
                        }
                        else
                        {
                                for (k = 0; k < new_node->input_port_sizes[j]; k++)
                                {
                                        new_node->input_pins[idx] = copy_input_npin(node->input_pins[old_idx]);
                                        new_node->input_pins[idx]->pin_node_idx = idx;
                                        new_node->input_pins[idx]->node = new_node;
                                        idx++;
                                        old_idx++;
                                }
                        }
                }

                /* Set the number of output pins and pin entry */
                new_node->num_output_pins = 1;
                new_node->output_pins = (npin_t **)malloc(sizeof(void*));
                new_node->output_pins[0] = copy_output_npin(node->output_pins[i]);
                add_a_driver_pin_to_net(node->output_pins[i]->net, new_node->output_pins[0]);
                free_npin(node->output_pins[i]);
                node->output_pins[i] = NULL;
                new_node->output_pins[0]->pin_node_idx = 0;
                new_node->output_pins[0]->node = new_node;
        }

        /* Now need to clean up the original to do 1 bit output - first bit */

        /* Name the node to show first bit! */
        tmp_name = (char *)malloc(strlen(node->name) + 3);
        strcpy(tmp_name, node->name);
        strcat(tmp_name, "-0");
        free(node->name);
        node->name = tmp_name;

        /* free the additional output pins */
        for (i = 1; i < node->num_output_pins; i++)
                free_npin(node->output_pins[i]);
        node->num_output_pins = 1;
        node->output_port_sizes[0] = 1;

        /* Shuffle the input pins on account of removed input pins */
        idx = old_idx = 0;
        node->input_port_sizes[data_port] = 1;
        for (i = 0; i < node->num_input_port_sizes; i++)
        {
                for (j = 0; j < node->input_port_sizes[i]; j++)
                {
                        node->input_pins[idx] = node->input_pins[old_idx];
                        node->input_pins[idx]->pin_node_idx = idx;
                        idx++;
                        old_idx++;
                }
                if (i == data_port)
                        old_idx = old_idx + diff - 1;
        }
        node->num_input_pins = node->num_input_pins - diff + 1;
        sp_memory_list = insert_in_vptr_list(sp_memory_list, node);

        return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

struct s_linked_vptr* dp_memory_list

Definition at line 32 of file memories.c.

struct s_linked_vptr* memory_instances

Definition at line 34 of file memories.c.

struct s_linked_vptr* memory_port_size_list

Definition at line 35 of file memories.c.

struct s_linked_vptr* sp_memory_list

Definition at line 31 of file memories.c.

int split_size

Definition at line 36 of file memories.c.