BookshelfDataBase.h

Go to the documentation of this file.

 
#ifndef BOOKSHELFPARSER_DATABASE_H
#define BOOKSHELFPARSER_DATABASE_H
 
#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cassert>
#include <limits>

namespace BookshelfParser {

using std::cout;
using std::endl;
using std::cerr;
using std::string; 
using std::vector;
using std::pair;
using std::make_pair;
using std::ostream;
typedef int int32_t;
typedef unsigned int uint32_t;
typedef long int64_t;

class IntegerArray : public vector<int>
{
    public: 
        typedef vector<int> base_type;
        using base_type::size_type;
        using base_type::value_type;
        using base_type::allocator_type;

        IntegerArray(const allocator_type& alloc = allocator_type())
            : base_type(alloc) {}

        IntegerArray(size_type n, const value_type& val, const allocator_type& alloc = allocator_type())
            : base_type(n, val, alloc) {}
};

class StringArray : public vector<string>
{
    public: 
        typedef vector<string> base_type;
        using base_type::size_type;
        using base_type::value_type;
        using base_type::allocator_type;

        StringArray(const allocator_type& alloc = allocator_type())
            : base_type(alloc) {}

        StringArray(size_type n, const value_type& val, const allocator_type& alloc = allocator_type())
            : base_type(n, val, alloc) {}
};

struct Item 
{
    virtual void print(ostream&) const {};
    friend ostream& operator<<(ostream& ss, Item const& rhs)
    {
        rhs.print(ss);
        return ss;
    }
};

struct Row : public Item
{
    int32_t origin[2]; 
    string orient; 
    int32_t height; 
    int32_t site_num; 
    int32_t site_width; 
    int32_t site_spacing; 
    int32_t site_orient; 
    string site_orient_str; 
    int32_t site_symmetry; 
    string site_symmetry_str; 
    Row()
    {
        reset();
    }

    void reset()
    {
        orient = "";
        origin[0] = origin[1]  = -1;
        height = 0;
        site_num = 0;
        site_width = site_spacing = site_orient = site_symmetry = 0;
        site_orient_str = "";
        site_symmetry_str = "";
    }

    virtual void print(ostream& ss) const
    {
        ss << "//////// Row ////////" << endl
            << "origin = " << origin[0] << " " << origin[1] << endl 
            << "orient = " << orient << endl 
            << "site width = " << site_width << endl 
            << "site_spacing = " << site_spacing << endl 
            << "site_orient = " << site_orient << endl 
            << "site_orient_str = " << site_orient_str << endl
            << "site_symmetry = " << site_symmetry << endl
            << "site_symmetry_str = " << site_symmetry_str << endl;
    }
};

struct NetPin : public Item 
{
    string node_name; 
    string pin_name; 
    char direct; 
    double offset[2]; 
    double size[2]; 

    NetPin()
    {
        node_name = "";
        pin_name = ""; 
        direct = '\0';
        offset[0] = 0; 
        offset[1] = 0; 
        size[0] = 0;
        size[1] = 0;
    }

    NetPin(string& nn, char d, double x, double y, double w, double h, string& pn)
    {
        node_name.swap(nn);
        direct = d;
        offset[0] = x;
        offset[1] = y;
        size[0] = w;
        size[1] = h;
        pin_name.swap(pn);
    }

    NetPin(string& nn, char d, double x, double y, double w, double h)
    {
        node_name.swap(nn);
        direct = d;
        offset[0] = x;
        offset[1] = y;
        size[0] = w;
        size[1] = h;
        pin_name.clear();
    }

    void reset()
    {
        node_name = "";
        pin_name = "";
        direct = 'I';
        offset[0] = offset[1] = 0;
        size[0] = size[1] = 0;
    }
};

struct Net : public Item
{
    string net_name; 
    vector<NetPin> vNetPin; 
    void reset()
    {
        net_name = "";
        vNetPin.clear();
    }

    virtual void print(ostream& ss) const
    {
        ss << "//////// Net ////////" << endl
            << "net_name = " << net_name << endl; 
        for (uint32_t i = 0; i < vNetPin.size(); ++i)
            ss << "(" << vNetPin[i].node_name << ", " << vNetPin[i].pin_name << ") " 
                << vNetPin[i].direct << " @(" << vNetPin[i].offset[0] << ", " << vNetPin[i].offset[1] << ")";
        ss << endl;
    }
};

struct ShapeBox : public Item 
{
    string name; 
    double origin[2]; 
    double size[2]; 

    ShapeBox(string& n, double x, double y, double w, double h)
    {
        name.swap(n); 
        origin[0] = x; 
        origin[1] = y; 
        size[0] = w; 
        size[1] = h; 
    }

    void reset()
    {
        name = "";
        origin[0] = origin[1] = 0;
        size[0] = size[1] = 0;
    }
};

struct NodeShape : public Item 
{
    string node_name; 
    vector<ShapeBox> vShapeBox; 

    void reset()
    {
        node_name = "";
        vShapeBox.clear();
    }

    virtual void print(ostream& ss) const
    {
        ss << "//////// NodeShape ////////" << endl
            << "node_name = " << node_name << endl; 
        for (uint32_t i = 0; i < vShapeBox.size(); ++i)
            ss << vShapeBox[i].name 
                << " @(" << vShapeBox[i].origin[0] << ", " << vShapeBox[i].origin[1] << ") "
                << " w/h (" << vShapeBox[i].size[0] << ", " << vShapeBox[i].size[1] << ")" 
                << endl;
        ss << endl;
    }
};

struct IOPinLayer : public Item 
{
    string pin_name; 
    int layer; 

    IOPinLayer(string& name, int l)
    {
        pin_name.swap(name); 
        layer = l; 
    }

    void reset()
    {
        pin_name = "";
        layer = std::numeric_limits<int>::max();
    }
};

struct BlockageLayer : public Item 
{
    string node_name; 
    vector<int> vLayer; 

    void reset()
    {
        node_name = "";
        vLayer.clear();
    }
};

struct RouteInfo : public Item 
{
    int numGrids[2]; 
    int numLayers; 
    vector<int> vVerticalCapacity; 
    vector<int> vHorizontalCapacity; 
    vector<int> vMinWireWidth; 
    vector<int> vMinWireSpacing; 
    vector<int> vViaSpacing; 
    double gridOrigin[2]; 
    double tileSize[2]; 
    int blockagePorosity; 

    void reset()
    {
        numGrids[0] = numGrids[1] = 0; 
        numLayers = 0; 
        vVerticalCapacity.clear(); 
        vHorizontalCapacity.clear(); 
        vMinWireWidth.clear(); 
        vMinWireSpacing.clear(); 
        vViaSpacing.clear(); 
        gridOrigin[0] = gridOrigin[1] = 0; 
        tileSize[0] = tileSize[1] = 0; 
        blockagePorosity = 0; 
    }

    virtual void print(ostream& ss) const
    {
        ss << "//////// RouteInfo ////////" << endl;
        ss << "grids = " << numGrids[0] << ", " << numGrids[1] << endl; 
        ss << "numLayers = " << numLayers << endl; 
        ss << "vVerticalCapacity = ";
        for (unsigned int i = 0; i < vVerticalCapacity.size(); ++i)
            ss << vVerticalCapacity[i] << " ";
        ss << endl; 
        ss << "vHorizontalCapacity = ";
        for (unsigned int i = 0; i < vHorizontalCapacity.size(); ++i)
            ss << vHorizontalCapacity[i] << " ";
        ss << endl; 
        ss << "vMinWireWidth = ";
        for (unsigned int i = 0; i < vMinWireWidth.size(); ++i)
            ss << vMinWireWidth[i] << " ";
        ss << endl; 
        ss << "vMinWireSpacing = ";
        for (unsigned int i = 0; i < vMinWireSpacing.size(); ++i)
            ss << vMinWireSpacing[i] << " ";
        ss << endl; 
        ss << "vViaSpacing = ";
        for (unsigned int i = 0; i < vViaSpacing.size(); ++i)
            ss << vViaSpacing[i] << " ";
        ss << endl; 
        ss << "gridOrigin = " << gridOrigin[0] << ", " << gridOrigin[1] << endl; 
        ss << "tileSize = " << tileSize[0] << ", " << tileSize[1] << endl; 
        ss << "blockagePorosity = " << blockagePorosity << endl; 
    }
};
 
// forward declaration
class BookshelfDataBase
{
    public:
        virtual void resize_bookshelf_node_terminals(int, int) = 0;
        virtual void resize_bookshelf_net(int) = 0;
        virtual void resize_bookshelf_pin(int) = 0;
        virtual void resize_bookshelf_row(int) = 0;
        virtual void resize_bookshelf_shapes(int);
        virtual void resize_bookshelf_niterminal_layers(int);
        virtual void resize_bookshelf_blockage_layers(int);
        virtual void add_bookshelf_terminal(string&, int, int) = 0;
        virtual void add_bookshelf_terminal_NI(string&, int, int);
        virtual void add_bookshelf_node(string&, int, int, bool) = 0;
        virtual void add_bookshelf_net(Net const&) = 0;
        virtual void add_bookshelf_row(Row const&) = 0;
        virtual void set_bookshelf_node_position(string const&, double, double, string const&, string const&, bool) = 0;
        virtual void set_bookshelf_net_weight(string const& name, double w);
        virtual void set_bookshelf_shape(NodeShape const&); 
        virtual void set_bookshelf_route_info(RouteInfo const&);
        virtual void add_bookshelf_niterminal_layer(string const&, string const&);
        virtual void add_bookshelf_blockage_layers(string const&, vector<string> const&);
        virtual void set_bookshelf_design(string&) = 0;
        virtual void bookshelf_end() = 0;
    private:
        void bookshelf_user_cbk_reminder(const char* str) const;
};
 
} // namespace BookshelfParser
 
#endif