Subversion Repositories Vertical

 * $Id: partition.c,v 1.1.1.1 2003/11/04 23:34:57 mjames Exp $

 * $Id: partition.c,v 1.1.1.1 2003/11/04 23:34:57 mjames Exp $  

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 * Added in reference to expression.h, but no changes made

 * Added in reference to expression.h, but no changes made

 *

 *

 * Added generics exported upwards

 * Added generics exported upwards

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 * Checkin before datatype printing

 * Checkin before datatype printing

 *

 *

 *

 *

#include "partition.h"

#include <stdio.h>

#include "acf_yacc.h"

#include "vertcl_main.h" 

#include "routing.h"

#include "partition.h"

#include "sorting.h"

#include "cmdlog.h"

#include "vertcl_main.h"

#include "acf_yacc.h"

void clear_partition_nets (void)

void clear_partition_nets(void)

{

  {

        net_t *net = named_list; /* only interested in nets carrying a signal */

  net_t * net = named_list; /* only interested in nets carrying a signal */

        while (net)

  while(net){

                net->leaves_partition = 0; /* not leaving partition */

    net->leaves_partition = 0; /* not leaving partition */

                net->inside_partition = 0; /* not used inside partition */

    net->inside_partition = 0; /* not used inside partition */

                if (!net->type_defined && net->vhdltype)

    if(!net->type_defined && net->vhdltype) {

                        if (net->vhdltype->basetype)

      if(net->vhdltype->basetype) {

                                /* ought to free it */

        /* ought to free it */  

                                free (net->vhdltype->basetype);

        free(net->vhdltype->basetype);      

                                net->vhdltype->basetype = NULL;

        net->vhdltype->basetype = NULL;

                        }

        }

                        if (net->vhdltype->expr)

      if(net->vhdltype->expr) {

                                net->vhdltype = NULL;

        net->vhdltype = NULL;

                                free_expression (net->vhdltype->expr);

        free_expression(net->vhdltype->expr);

}

void name_routed_nets (void)

void name_routed_nets(void)

{

  {

        net_t *link;

  net_t * link;

        net_t *net = routed_list; /* check each net in turn */

  net_t * net = routed_list; /* check each net in turn */

                                  /* this code is here : shoould it be ? */

/* this code is here : shoould it be ? */

        while (net)

  while(net) {

                noderef_t *noderefs = net->nodes;

    noderef_t *  noderefs = net->nodes;

                link = net->next;

    link = net->next;

                if (IS_ROUTABLE (noderefs->net->how_routed))

    if(IS_ROUTABLE(noderefs->net->how_routed)) {

                        if (ISNULLSTR (net->name))

      if (ISNULLSTR(net->name))

                                net->name = net->identifier;

        net->name = net->identifier;

                        while (noderefs)

      while(noderefs){

                                /*      noderefs->node->in_use = 1; */

/*      noderefs->node->in_use = 1; */

                                noderefs->node->name = net->name;

        noderefs->node->name = net->name;

                                noderefs = noderefs->next;

        noderefs = noderefs->next;

                        }

        }

                        combine_routed_and_unrouted (net, net);

          combine_routed_and_unrouted (net, net);

                        transfer_net_to_named (&routed_list, net);

          transfer_net_to_named (&routed_list, net);

                }

      }

                net = link;

    net = link;

        }

    }      

                return /*TCL_ERROR*/;

    return /*TCL_ERROR*/;

        }

    }

        else

  else

        {

    {

                Log (LOG_GENERAL, "-- Using '%s' as match pattern\n", expr);

    Log(LOG_GENERAL,"-- Using '%s' as match pattern\n",expr);

        }

        }

int add_all_to_partition (void)

int add_all_to_partition(void)

        return set_clear_partition (".*", 1);

  return set_clear_partition(".*",1);

void list_partition (FILE *f)

void list_partition(FILE * f)

        socket_t *skt = socket_head;

  socket_t * skt = socket_head;

        fprintf (f, "Partition includes the following blocks:\n");

  fprintf(f,"Partition includes the following blocks:\n");

        while (skt)

  while(skt){

                if (skt->selected) /* selected */

    if(skt->selected) /* selected */

                        fprintf (f, "  '%s'\n", skt->name);

      fprintf(f,"  '%s'\n",skt->name);

                skt = skt->next;

    skt = skt->next;

        }

  }

        fprintf (f, "-- End list -- \n");

  fprintf(f,"-- End list -- \n");

       to 'selected' sockets and there is an output or buffer pin inside the          then the

       to 'selected' sockets and there is an output or buffer pin inside the          then the net is inside the partition.

   net is inside the partition. if the net is all inputs the the net has to leave the partition

           if the net is all inputs the the net has to leave the

   as an input.

           partition as an input.

void perform_partition (void)

void perform_partition(void)

        net_t *net = named_list; /* check each net in turn */

  net_t * net = named_list; /* check each net in turn */

        int ports = 0;

  int ports = 0;

        int port_wires = 0;

  int port_wires = 0;

        int signals = 0;

  int signals = 0;

        int signal_wires = 0;

  int signal_wires = 0;

        while (net)

  while(net) {

                noderef_t *noderefs = net->nodes;

    noderef_t *  noderefs = net->nodes;

                char used_outside = 0; /* set if the net goes outside */

    char      used_outside = 0; /* set if the net goes outside */

                char used_inside = 0;  /* set if the net used inside */

    char      used_inside = 0;  /* set if the net used inside */

                char inputs_on_net = 0;

    char      inputs_on_net = 0;

                char outputs_on_net = 0;

    char      outputs_on_net = 0;

                char buffers_on_net = 0; /* another pin type that we must handle */

    char      buffers_on_net = 0; /* another pin type that we must handle */

                char bidirs_on_net = 0;

    char      bidirs_on_net = 0;

                char default_drive = 0; /* Was this net defined with a default value ? */

    char      default_drive = 0; /* Was this net defined with a default value ? */

                int width = 0; /* how many wires in the bundle */

    int width = 0;              /* how many wires in the bundle */

                int high = 0;

    int high  = 0;

                int low = 1000;

    int low   = 1000;

                expression_t *exp, *variable_seen, *high_ref, *low_ref, *high_exp, *low_exp,

    expression_t * exp,* variable_seen,

                    *highest_exp, *lowest_exp;

            *high_ref, * low_ref,  * high_exp, *low_exp, * highest_exp, * lowest_exp ;

                highest_exp = NULL;

    highest_exp = NULL;

                lowest_exp = NULL;

    lowest_exp  = NULL;

                high_ref = NULL; /* reference to expression containing highest expr */

    high_ref = NULL; /* reference to expression containing highest expr */

                low_ref = NULL;

    low_ref  = NULL;

                variable_seen = NULL;

    variable_seen = NULL;

                net->ext_dir = NONE; /* not yet known */

    net->ext_dir = NONE; /* not yet known */

                /* set flag if the net was defined as "signal x : type := value;" */

    /* set flag if the net was defined as "signal x : type := value;" */

                    net->type_defined && net->vhdltype && net->vhdltype->default_expr;

    default_drive = net->type_defined && net->vhdltype && net->vhdltype->default_expr;

                /* predefined net type definition, can already know upper ansd lower bounds */

    /* predefined net type definition, can already know upper ansd lower bounds */

                printf ("net %s \n", net->identifier);

    printf("net %s \n",net->identifier);

                while (noderefs)

    while(noderefs){

                        if (n->in_use)

      node_t * n = noderefs->node;

                        {

      if(n->in_use) {

                                int h, l;

        int h,l;

                                vhdl_t *vhdl;

        vhdl_t * vhdl;

                                vhdl = noderefs->vhdltype;

        vhdl = noderefs->vhdltype;

                                if (vhdl && vhdl->expr)

        if(vhdl && vhdl->expr)

                                        exp = vhdl->expr;

          exp = vhdl->expr;

                                else

        else

                                        exp = NULL;

          exp = NULL;

                                {

        if(exp) {

                                        printf ("expression vhdl%p expr%p", vhdl, exp);

          printf("expression vhdl%p expr%p",vhdl,exp);

                                        print_range_expression (stdout, exp, 0);

          print_range_expression(stdout,exp,0);

                                        printf ("\n");

          printf("\n");

                                }

          }

#endif

#endif   

                                /* if we have a variable defining width,

        /* if we have a variable defining width,

                                   remember what the top level variable is called,

           remember what the top level variable is called,

                                   then keep expanding it until we get an expression

           then keep expanding it until we get an expression

                                   rather than a variable */

           rather than a variable */

                                if (exp && exp->opcode == EXP_VARIABLE)

        if(exp && exp->opcode == EXP_VARIABLE) {

                                {

           variable_seen = exp;

                                        while (exp->opcode == EXP_VARIABLE)

           while(exp->opcode == EXP_VARIABLE)

                                                exp = exp->left.g->expr;

             exp = exp->left.g->expr;

                                }

           }

                                if (exp)

        if(exp) {

                                {

          if (exp->opcode == TO) {

                                                high_exp = exp->right.e;

            high_exp = exp->right.e;

                                                low_exp = exp->left.e;

            low_exp  = exp->left.e;

                                        }

            }

                                        else if (exp->opcode == DOWNTO)

          else if (exp->opcode == DOWNTO) {

                                                high_exp = exp->left.e;

            high_exp = exp->left.e;

                                                low_exp = exp->right.e;

            low_exp  = exp->right.e;

                                        }

            }

                                        else

          else

                                                    exp; /* not a range, just a single value */

            high_exp = low_exp = exp; /* not a range, just a single value */

                                        l = eval_expression (low_exp, NULL);

          l = eval_expression(low_exp, NULL);  

                                        h = eval_expression (high_exp, NULL);

          h = eval_expression(high_exp, NULL);

                                        /* sort out the highest and lowest bound of any logic

        /* sort out the highest and lowest bound of any logic vector pins

                                           single bits so calculation applies here) */

             on the net (high and low are zero for single bits so calculation

                                        if (h > high)

             applies here) */

                                        {

        if (h > high) {

                                                highest_exp = high_exp;

          highest_exp = high_exp;

                                                high_ref = exp;

          high_ref    = exp;

                                                high = h;

          high = h;

                                        }

          }

                                        {

        if (l  < low){

                                                lowest_exp = low_exp;

          lowest_exp = low_exp;

                                                low_ref = exp;

          low_ref    = exp;

                                        }

          low  = l;

                                }

           }

                                else

         }  

                                {

        else {

                                        high = 0;

          high=0;

                                        low = 0;

          low=0;

                                };

          };

                                /* discover it is routed outside - it links to an unselected

        /* discover it is routed outside - it links to an unselected socket */

                                /* but if it only links to unselected sockets,

        /* but if it only links to unselected sockets,

                                   used_inside wont be set as well */

           used_inside wont be set as well */

                                if (!n->socket->selected)

        if(!n->socket->selected)

                                        used_outside = 1;

          used_outside = 1;

                                else

        else{

                                {

          used_inside = 1;

                                        if (noderefs->pindir == INPUT)

          if (noderefs->pindir == INPUT)

                                                inputs_on_net = 1;

            inputs_on_net = 1;

                                        if (noderefs->pindir == OUTPUT)

          if (noderefs->pindir == OUTPUT)

                                                outputs_on_net = 1;

            outputs_on_net = 1;

                                        if (noderefs->pindir == BIDIR)

          if (noderefs->pindir == BIDIR)

                                                bidirs_on_net = 1;

            bidirs_on_net = 1;

                                        if (noderefs->pindir == BUFFER)

          if (noderefs->pindir == BUFFER)

                                                buffers_on_net = 1;

            buffers_on_net = 1;

                                        /* I was  using the ordinal value of the pindir_t type

          /* I was  using the ordinal value of the pindir_t type

                                      if  (noderefs->pindir >= net->ext_dir ) ||  */

        if  (noderefs->pindir >= net->ext_dir ) ||  */

                                        /* now June 1999 takes on the type of the first node ,

           /* now June 1999 takes on the type of the first node ,

                                          or if one of the nodes has a bus connection use that

             or if one of the nodes has a bus connection use that : still a

                                          declared so it has a type defined then keep that as

             guess. Alternatively if the net was declared so it has a

                                          it is more correct...  */

             type defined then keep that as it is more correct...  */

                                            (!net->vhdltype || !net->vhdltype->basetype ||

        if(!net->type_defined && ( !net->vhdltype || !net->vhdltype->basetype ||

                                             (!net->vhdltype->is_vector && vhdl->is_vector)))

              (!net->vhdltype->is_vector && vhdl->is_vector))) {

                                                 * signal attribute*/

            /* copy over base VHDL type and vector/single signal attribute*/

                                                net->vhdltype = copy_vhdl (vhdl, NULL);

            net->vhdltype = copy_vhdl(vhdl,NULL);          

                                        }

                                }

            }

                        }

        }      

                        noderefs = noderefs->next;

    noderefs = noderefs->next;

                }

    }    

                if (net->type_defined && net->vhdltype)

    if(net->type_defined && net->vhdltype ) {

                        exp = net->vhdltype->expr;

      exp = net->vhdltype->expr;

                        if (exp && exp->opcode == EXP_VARIABLE)

      if(exp && exp->opcode == EXP_VARIABLE)

                                exp = exp->left.g->expr;

         exp = exp->left.g->expr;

                        {

      if(exp) {

                                if (exp->opcode == TO)

        if (exp->opcode == TO) {

                                        highest_exp = exp->right.e;

          highest_exp = exp->right.e;

                                        lowest_exp = exp->left.e;

          lowest_exp  = exp->left.e;

                                }

          }

                                else if (exp->opcode == DOWNTO)

        else if (exp->opcode == DOWNTO) {

                                        highest_exp = exp->left.e;

          highest_exp = exp->left.e;

                                        lowest_exp = exp->right.e;

          lowest_exp  = exp->right.e;

                                }

          }

                                else

        else

                                        highest_exp = lowest_exp = exp->left.e;

          highest_exp = lowest_exp = exp->left.e;

                                low = eval_expression (lowest_exp, NULL);

        low = eval_expression(lowest_exp,NULL);  

                                high = eval_expression (highest_exp, NULL);

        high = eval_expression(highest_exp,NULL);

                        }

        }

                }

      }

                if (!net->type_defined && net->vhdltype && net->vhdltype->is_vector)

    if ( !net->type_defined && net->vhdltype && net->vhdltype->is_vector) {

                        if (variable_seen)

      if(variable_seen)

                                net->vhdltype->expr = variable_seen;

        net->vhdltype->expr  = variable_seen;

                        else if (highest_exp && lowest_exp)

      else if(highest_exp && lowest_exp) {

                                if (high_ref && (high_ref == low_ref))

         if (high_ref && (high_ref == low_ref))

                                        net->vhdltype->expr = high_ref;

           net->vhdltype->expr = high_ref;

                                else

         else

                                            DOWNTO, highest_exp, lowest_exp);

           net->vhdltype->expr = compile_expression(DOWNTO,highest_exp,lowest_exp);

                        }

         }

                        else

      else

                                net->vhdltype->expr = compile_constant (0);

         net->vhdltype->expr = compile_constant(0);

                }

      }

                /* pin will appear on port list if : */

    /* pin will appear on port list if : */

                /* routed inside & outside */

                            /* routed inside & outside */

                    (used_inside && used_outside) ||

    net->leaves_partition = (used_inside && used_outside) ||

                    /* inputs but not any sort of outputs, or default drive (a kind of output)

                            /* inputs but not any sort of outputs, or default drive (a kind of output) */

                    (inputs_on_net && !(default_drive || outputs_on_net || buffers_on_net)) ||

                            (inputs_on_net && !( default_drive || outputs_on_net || buffers_on_net)) ||

                    /* any sort of outputs but not inputs */

                            /* any sort of outputs but not inputs */

                    ((outputs_on_net || buffers_on_net) && !inputs_on_net) ||

                            ((outputs_on_net || buffers_on_net) && !inputs_on_net) ||

                    /* any bidirectional pins */

                            /* any bidirectional pins */

                    bidirs_on_net ||

                            bidirs_on_net ||

                    /* net is forced as a port */

                            /* net is forced as a port */

                    net->force_port;

                            net->force_port;

                net->needs_buff_sig = inputs_on_net && (outputs_on_net || buffers_on_net) &&

                            (outputs_on_net || buffers_on_net) &&

                                      net->leaves_partition;

                            net->leaves_partition;                          

                /* sort out the pin directions */

    /* sort out the pin directions */

                /* any bidirectional pins */

    /* any bidirectional pins */

                if (bidirs_on_net)

    if(bidirs_on_net)

                        net->ext_dir = BIDIR;

      net->ext_dir  = BIDIR;

                /* inputs but not any sort of outputs */

    /* inputs but not any sort of outputs */  

                else if (inputs_on_net && !(outputs_on_net || buffers_on_net))

    else if(inputs_on_net && !(outputs_on_net || buffers_on_net))

                        net->ext_dir = INPUT;

      net->ext_dir  = INPUT;

                /* any sort of outputs but not inputs */

    /* any sort of outputs but not inputs */

                else if (outputs_on_net || buffers_on_net)

    else if (outputs_on_net || buffers_on_net)

                        net->ext_dir = OUTPUT;

      net->ext_dir  = OUTPUT;

                else

    else

                        net->ext_dir = NONE;

      net->ext_dir  = NONE;

                /* net will appear in local signal definition if : */

    /* net will appear in local signal definition if : */

                /* it is used inside  */

                            /* it is used inside  */

                /* and either only inside or it is a BUFFER

                            /* and either only inside or it is a BUFFER

                   port in which

                               port in which

                   case a temporary signal is provided by

                               case a temporary signal is provided by

                   printout.c */

                               printout.c */

                net->inside_partition =

                               (!net->leaves_partition) ||

                    used_inside && ((!net->leaves_partition) || (net->needs_buff_sig));

                               (net->needs_buff_sig));

                width = high - low + 1;

                if (level & 1)

    width = high-low+1;

                {

    if(level & 1)

                        printf (

      {                              

                            "Partition : Net %-20s Inside %d Outside %d Crossing Dir %d width "

      printf("Partition : Net %-20s Inside %d Outside %d Crossing Dir %d width %d %c%c%c%c%c\n",

                            net->leaves_partition,

            net->name,net->inside_partition,net->leaves_partition,

                            width,

            net->ext_dir,width,

                            outputs_on_net ? 'O' : 'o',

            outputs_on_net?'O':'o',

                            inputs_on_net ? 'I' : 'i',

            inputs_on_net ?'I':'i',

                            bidirs_on_net ? 'B' : 'b',

            bidirs_on_net ?'B':'b',

                            buffers_on_net ? 'U' : 'u',

            buffers_on_net?'U':'u',

                            default_drive ? 'D' : 'd');

            default_drive ?'D':'d');

                }

      }

                /* compute the bus width unless it is already defined  */

    /* compute the bus width unless it is already defined  */

                if (net->leaves_partition)

    if(net->leaves_partition) {

                        port_wires += width;

      port_wires+= width;    

                        ports++;

      ports++;

                };

      };

                if (net->inside_partition)

    if(net->inside_partition) {

                        signal_wires += width;

      signal_wires+= width;

                        signals++;

      signals++;

                };

      };

                net = net->next;

    net = net->next;

        }

  }

            "-- %5d Nets    (%5d wires) leaving partition\n"

  Log(LOG_GENERAL,"-- %5d Nets    (%5d wires) leaving partition\n"

            "-- %5d Signals (%5d wires) inside partition\n",

                  "-- %5d Signals (%5d wires) inside partition\n",

            signal_wires);

                  ports,port_wires,signals,signal_wires);

void delete_port (char *template)

void delete_port(char * template)

        int rc;

  int rc;

        net_t *net = named_list;

  net_t * net = named_list;

        int found = 0;

  int found = 0;

        int net_count = 0;

  int net_count = 0;

        /* compile regular expression */

  /* compile regular expression */

        vert_regex_t *preg;

  vert_regex_t  * preg;