jcarr
/
coriolis
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'devel' into devel_anabatic 

Catch up the Lemon removal and cdebug correction.
This commit is contained in:
Jean-Paul Chaput 2016-06-11 21:58:25 +02:00
parent c5a9e0b617 f68ac4d0e6
commit 36a982ce47
189 changed files with 2415 additions and 2576 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
bootstrap/refactor.sed Normal file
View File

@ -0,0 +1,3 @@
s|cdebug\.log(\([0-9]*\),\([0-9]*\))|cdebug_log(\1,\2)|
s|cdebug\.log(\([0-9]*\))|cdebug_log(\1,0)|
s|cdebug\.tabw(\([0-9]*\),\(-*[0-9]*\))|cdebug_tabw(\1,\2)|

2
coloquinte/src/CMakeLists.txt
View File

@ -24,7 +24,7 @@ set ( cpps circuit.cxx
orientation.cxx
detailed.cxx
cell_swapping.cxx
MCF_opt.cxx
#MCF_opt.cxx
row_opt.cxx
topologies.cxx
lookup_table.cxx

147
coloquinte/src/MCF_opt.cxx
View File

@ -1,147 +0,0 @@
#include "coloquinte/detailed.hxx"
#include "coloquinte/circuit_helper.hxx"
#include <lemon/smart_graph.h>
#include <lemon/network_simplex.h>
#include <cassert>
namespace coloquinte{
namespace dp{
void optimize_on_topology_HPWL(netlist const & circuit, detailed_placement & pl){
// Solves a minimum cost flow problem to optimize the placement at fixed topology
// Concretely, it means aligning the pins to minimize the wirelength
// It uses the Lemon network simplex solver from the Coin-OR initiative, which should scale well up to hundred of thousands of cells
using namespace lemon;
DIGRAPH_TYPEDEFS(SmartDigraph);
// Create a graph with the cells and bounds of the nets as node
SmartDigraph g;
std::vector<Node> cell_nodes(circuit.cell_cnt());
for(index_t i=0; i<circuit.cell_cnt(); ++i){
if((circuit.get_cell(i).attributes & XMovable) != 0)
cell_nodes[i] = g.addNode();
}
std::vector<Node> Lnet_nodes(circuit.net_cnt()), Unet_nodes(circuit.net_cnt());
for(index_t i=0; i<circuit.net_cnt(); ++i){
if(circuit.get_net(i).pin_cnt > 0){
Lnet_nodes[i] = g.addNode();
Unet_nodes[i] = g.addNode();
}
}
// Two nodes for position constraints
Node fixed = g.addNode();
typedef std::pair<SmartDigraph::Arc, int_t> arc_pair;
typedef std::pair<SmartDigraph::Node, int_t> node_pair;
// The arcs corresponding to constraints of the original problem
std::vector<arc_pair> constraint_arcs;
// Now we add every positional constraint, which becomes an arc in the min-cost flow problem
for(index_t i=0; i<circuit.cell_cnt(); ++i){ // The cells
for(index_t l = pl.neighbours_limits_[i]; l < pl.neighbours_limits_[i+1]; ++l){
index_t oi = pl.neighbours_[l].second;
if(oi == null_ind) continue;
if((circuit.get_cell(i).attributes & XMovable) != 0 and (circuit.get_cell(oi).attributes & XMovable) != 0){
// Two movable cells: OK
auto A = g.addArc(cell_nodes[oi], cell_nodes[i]);
constraint_arcs.push_back(arc_pair(A, -circuit.get_cell(i).size.x_));
}
else if((circuit.get_cell( i).attributes & XMovable) != 0){
// The cell c is movable and constrained on the right
auto A = g.addArc(fixed, cell_nodes[i]);
constraint_arcs.push_back(arc_pair(A, pl.plt_.positions_[oi].x_ - circuit.get_cell(i).size.x_));
}
else if((circuit.get_cell(oi).attributes & XMovable) != 0){
// The cell oc is movable and constrained on the left
auto A = g.addArc(cell_nodes[oi], fixed);
constraint_arcs.push_back(arc_pair(A, -pl.plt_.positions_[i].x_ - circuit.get_cell(i).size.x_));
}
}
}
for(index_t r=0; r<pl.row_cnt(); ++r){ // And the boundaries of each row
index_t lc = pl.row_first_cells_[r];
if(lc != null_ind and (circuit.get_cell(lc).attributes & XMovable) != 0){
auto Al = g.addArc(cell_nodes[lc], fixed);
constraint_arcs.push_back(arc_pair(Al, -pl.min_x_));
}
}
for(index_t r=0; r<pl.row_cnt(); ++r){ // And the boundaries of each row
index_t rc = pl.row_last_cells_[r];
if(rc != null_ind and (circuit.get_cell(rc).attributes & XMovable) != 0){
auto Ar = g.addArc(fixed, cell_nodes[rc]);
constraint_arcs.push_back(arc_pair(Ar, pl.max_x_ - circuit.get_cell(rc).size.x_));
}
}
// And every pin of every net: arcs too
for(index_t n=0; n<circuit.net_cnt(); ++n){
for(auto p : circuit.get_net(n)){
index_t c = p.cell_ind;
int_t pin_offs = (pl.plt_.orientations_[c].x_ ? p.offset.x_ : circuit.get_cell(c).size.x_ - p.offset.x_); // Offset to the beginning of the cell
if((circuit.get_cell(c).attributes & XMovable) != 0){
Arc Al = g.addArc(cell_nodes[c], Lnet_nodes[n]);
constraint_arcs.push_back(arc_pair(Al, pin_offs));
Arc Ar = g.addArc(Unet_nodes[n], cell_nodes[c]);
constraint_arcs.push_back(arc_pair(Ar, -pin_offs));
}
else{ // Fixed offset
auto Al = g.addArc(fixed, Lnet_nodes[n]);
constraint_arcs.push_back(arc_pair(Al, pl.plt_.positions_[c].x_ + pin_offs));
auto Ar = g.addArc(Unet_nodes[n], fixed);
constraint_arcs.push_back(arc_pair(Ar, - pl.plt_.positions_[c].x_ - pin_offs));
}
}
}
// Then the only capacitated arcs: the ones for the nets
std::vector<node_pair> net_supplies;
for(index_t n=0; n<circuit.net_cnt(); ++n){
if(circuit.get_net(n).pin_cnt > 0){
net_supplies.push_back(node_pair(Unet_nodes[n], circuit.get_net(n).weight));
net_supplies.push_back(node_pair(Lnet_nodes[n], -circuit.get_net(n).weight));
}
}
// Create the maps to have cost and capacity for the arcs
IntArcMap cost(g, 0);
IntArcMap capacity(g, circuit.net_cnt());
IntNodeMap supply(g, 0);
for(arc_pair A : constraint_arcs){
cost[A.first] = A.second;
}
for(node_pair N : net_supplies){
supply[N.first] = N.second;
}
// Then we (hope the solver can) solve it
NetworkSimplex<SmartDigraph> ns(g);
ns.supplyMap(supply).costMap(cost);
auto res = ns.run();
if(res != ns.OPTIMAL){
abort();
}
// And we get the new positions as the dual values of the current solution (compared to the fixed pin)
for(index_t c=0; c<circuit.cell_cnt(); ++c){ // The cells
if((circuit.get_cell(c).attributes & XMovable) != 0){
pl.plt_.positions_[c].x_ = ns.potential(cell_nodes[c]) - ns.potential(fixed);
}
}
pl.selfcheck();
}
} // namespace dp
} // namespace coloquinte

30
coloquinte/src/cell_swapping.cxx
View File

@ -22,8 +22,8 @@ std::function<std::int64_t(netlist const &, detailed_placement const &, std::vec
// Get the possible positions for a swap
int_t swp_min_c1 = c2_bnds.first,
swp_min_c2 = c1_bnds.first,
swp_max_c1 = c2_bnds.second - circuit.get_cell(c1).size.x_,
swp_max_c2 = c1_bnds.second - circuit.get_cell(c2).size.x_;
swp_max_c1 = c2_bnds.second - circuit.get_cell(c1).size.x,
swp_max_c2 = c1_bnds.second - circuit.get_cell(c2).size.x;
if(swp_max_c1 >= swp_min_c1 and swp_max_c2 >= swp_min_c2){
// Check both orientations of the cell
@ -49,20 +49,20 @@ std::function<std::int64_t(netlist const &, detailed_placement const &, std::vec
point<bool> o2 = pl.plt_.orientations_[c2];
// Warning: won't work if the two cells don't have the same height
pl.plt_.positions_[c1].x_ = (swp_min_c1 + swp_max_c1) / 2;
pl.plt_.positions_[c2].x_ = (swp_min_c2 + swp_max_c2) / 2;
pl.plt_.positions_[c1].y_ = p2.y_;
pl.plt_.positions_[c2].y_ = p1.y_;
pl.plt_.positions_[c1].x = (swp_min_c1 + swp_max_c1) / 2;
pl.plt_.positions_[c2].x = (swp_min_c2 + swp_max_c2) / 2;
pl.plt_.positions_[c1].y = p2.y;
pl.plt_.positions_[c2].y = p1.y;
// For standard cell placement, we want all the rows to be aligned in the same way
if( (circuit.get_cell(c1).attributes & YFlippable) != 0 and (circuit.get_cell(c2).attributes & YFlippable) != 0)
std::swap(pl.plt_.orientations_[c1].y_, pl.plt_.orientations_[c2].y_);
std::swap(pl.plt_.orientations_[c1].y, pl.plt_.orientations_[c2].y);
if(try_flip and (circuit.get_cell(c1).attributes & XFlippable) != 0 and (circuit.get_cell(c2).attributes & XFlippable) != 0){
index_t bst_ind = 4;
for(index_t i=0; i<4; ++i){
pl.plt_.orientations_[c1].x_ = i % 2;
pl.plt_.orientations_[c2].x_ = i / 2;
pl.plt_.orientations_[c1].x = i % 2;
pl.plt_.orientations_[c2].x = i / 2;
std::int64_t new_cost = get_nets_cost(circuit, pl, involved_nets);
if(new_cost < old_cost){
old_cost = new_cost;
@ -73,8 +73,8 @@ std::function<std::int64_t(netlist const &, detailed_placement const &, std::vec
// One of the orientations with the new positions was better
if(bst_ind < 4){
pl.swap_standard_cell_topologies(c1, c2);
pl.plt_.orientations_[c1].x_ = bst_ind % 2;
pl.plt_.orientations_[c2].x_ = bst_ind / 2;
pl.plt_.orientations_[c1].x = bst_ind % 2;
pl.plt_.orientations_[c2].x = bst_ind / 2;
// We kept the swap
return true;
}
@ -126,15 +126,15 @@ std::function<std::int64_t(netlist const &, detailed_placement const &, std::vec
// Number of cells after/before the end of the cell
index_t nb_after = 0;
index_t nb_before = 0;
int_t pos_low = pl.plt_.positions_[c].x_ - circuit.get_cell(c).size.x_,
pos_hgh = pl.plt_.positions_[c].x_ + 2*circuit.get_cell(c).size.x_;
int_t pos_low = pl.plt_.positions_[c].x - circuit.get_cell(c).size.x,
pos_hgh = pl.plt_.positions_[c].x + 2*circuit.get_cell(c).size.x;
for(index_t oc=first_oc; oc != null_ind and nb_after <= row_extent; oc = pl.get_next_standard_cell_on_row(oc, other_row)){
assert(pl.cell_rows_[oc] == other_row);
if( (circuit.get_cell(oc).attributes & XMovable) == 0) continue; // Don't touche fixed cells
// Count the cells which should trigger stop or shouldn't be used at the next iteration
if(pl.plt_.positions_[oc].x_ >= pos_hgh) ++nb_after;
if(pl.plt_.positions_[oc].x_ + circuit.get_cell(oc).size.x_ <= pos_low) ++ nb_before;
if(pl.plt_.positions_[oc].x >= pos_hgh) ++nb_after;
if(pl.plt_.positions_[oc].x + circuit.get_cell(oc).size.x <= pos_low) ++ nb_before;
if(try_swap(circuit, pl, c, oc, try_flip, get_nets_cost)){
std::swap(c, oc);

10
coloquinte/src/checkers.cxx
View File

@ -22,7 +22,7 @@ void netlist::selfcheck() const{
assert(pin_cnt == net_indexes_.size());
for(auto const p : pin_offsets_){
assert(std::isfinite(p.x_) and std::isfinite(p.y_));
assert(std::isfinite(p.x) and std::isfinite(p.y));
}
}
@ -57,10 +57,10 @@ void verify_placement_legality(netlist const & circuit, placement_t const & pl,
for(index_t i=0; i<circuit.cell_cnt(); ++i){
event b, e;
b.cell = i; e.cell = i;
b.x_min = cells[i].x_min_; e.x_min = cells[i].x_min_;
b.x_max = cells[i].x_max_; e.x_max = cells[i].x_max_;
b.y = cells[i].y_min_; b.removal = false;
e.y = cells[i].y_max_; e.removal = true;
b.x_min = cells[i].x_min; e.x_min = cells[i].x_min;
b.x_max = cells[i].x_max; e.x_max = cells[i].x_max;
b.y = cells[i].y_min; b.removal = false;
e.y = cells[i].y_max; e.removal = true;
if(b.x_max > b.x_min and e.y != b.y){
all_events.push_back(b);
all_events.push_back(e);

94
coloquinte/src/circuit.cxx
View File

@ -8,7 +8,7 @@ std::int64_t get_HPWL_length(netlist const & circuit, placement_t const & pl, in
if(circuit.get_net(net_ind).pin_cnt <= 1) return 0;
auto pins = get_pins_1D(circuit, pl, net_ind);
auto minmaxX = std::minmax_element(pins.x_.begin(), pins.x_.end()), minmaxY = std::minmax_element(pins.y_.begin(), pins.y_.end());
auto minmaxX = std::minmax_element(pins.x.begin(), pins.x.end()), minmaxY = std::minmax_element(pins.y.begin(), pins.y.end());
return ((minmaxX.second->pos - minmaxX.first->pos) + (minmaxY.second->pos - minmaxY.first->pos));
}
@ -67,12 +67,12 @@ point<linear_system> empty_linear_systems(netlist const & circuit, placement_t c
}
if( (XMovable & circuit.get_cell(i).attributes) == 0 or not found_true_net){
ret.x_.add_triplet(i, i, 1.0f);
ret.x_.add_doublet(i, pl.positions_[i].x_);
ret.x.add_triplet(i, i, 1.0f);
ret.x.add_doublet(i, pl.positions_[i].x);
}
if( (YMovable & circuit.get_cell(i).attributes) == 0 or not found_true_net){
ret.y_.add_triplet(i, i, 1.0f);
ret.y_.add_doublet(i, pl.positions_[i].y_);
ret.y.add_triplet(i, i, 1.0f);
ret.y.add_doublet(i, pl.positions_[i].y);
}
}
@ -143,8 +143,8 @@ point<linear_system> get_HPWLF_linear_system (netlist const & circuit, placement
if(pin_cnt < min_s or pin_cnt >= max_s) continue;
auto pins = get_pins_1D(circuit, pl, i);
get_HPWLF(pins.x_, L.x_, tol);
get_HPWLF(pins.y_, L.y_, tol);
get_HPWLF(pins.x, L.x, tol);
get_HPWLF(pins.y, L.y, tol);
}
return L;
}
@ -157,30 +157,30 @@ point<linear_system> get_HPWLR_linear_system (netlist const & circuit, placement
if(pin_cnt < min_s or pin_cnt >= max_s) continue;
auto pins = get_pins_1D(circuit, pl, i);
get_HPWLR(pins.x_, L.x_, tol);
get_HPWLR(pins.y_, L.y_, tol);
get_HPWLR(pins.x, L.x, tol);
get_HPWLR(pins.y, L.y, tol);
}
return L;
}
point<linear_system> get_star_linear_system (netlist const & circuit, placement_t const & pl, float_t tol, index_t min_s, index_t max_s){
point<linear_system> L = empty_linear_systems(circuit, pl);
L.x_.add_variables(circuit.net_cnt());
L.y_.add_variables(circuit.net_cnt());
L.x.add_variables(circuit.net_cnt());
L.y.add_variables(circuit.net_cnt());
for(index_t i=0; i<circuit.net_cnt(); ++i){
// Has the net the right pin count?
index_t pin_cnt = circuit.get_net(i).pin_cnt;
if(pin_cnt < min_s or pin_cnt >= max_s){
// Put a one in the intermediate variable in order to avoid non-invertible matrices
L.x_.add_triplet(i+circuit.cell_cnt(), i+circuit.cell_cnt(), 1.0f);
L.y_.add_triplet(i+circuit.cell_cnt(), i+circuit.cell_cnt(), 1.0f);
L.x.add_triplet(i+circuit.cell_cnt(), i+circuit.cell_cnt(), 1.0f);
L.y.add_triplet(i+circuit.cell_cnt(), i+circuit.cell_cnt(), 1.0f);
continue;
}
auto pins = get_pins_1D(circuit, pl, i);
// Provide the index of the star's central pin in the linear system
get_star(pins.x_, L.x_, tol, i+circuit.cell_cnt());
get_star(pins.y_, L.y_, tol, i+circuit.cell_cnt());
get_star(pins.x, L.x, tol, i+circuit.cell_cnt());
get_star(pins.y, L.y, tol, i+circuit.cell_cnt());
}
return L;
}
@ -193,8 +193,8 @@ point<linear_system> get_clique_linear_system (netlist const & circuit, placemen
if(pin_cnt < min_s or pin_cnt >= max_s) continue;
auto pins = get_pins_1D(circuit, pl, i);
get_clique(pins.x_, L.x_, tol);
get_clique(pins.y_, L.y_, tol);
get_clique(pins.x, L.x, tol);
get_clique(pins.y, L.y, tol);
}
return L;
}
@ -213,8 +213,8 @@ point<linear_system> get_MST_linear_system(netlist const & circuit, placement_t
}
auto const edges = get_MST_topology(points);
for(auto E : edges){
add_force(pins[E.first].x(), pins[E.second].x(), L.x_, tol, 1.0f);
add_force(pins[E.first].y(), pins[E.second].y(), L.y_, tol, 1.0f);
add_force(pins[E.first].x(), pins[E.second].x(), L.x, tol, 1.0f);
add_force(pins[E.first].y(), pins[E.second].y(), L.y, tol, 1.0f);
}
}
return L;
@ -233,11 +233,11 @@ point<linear_system> get_RSMT_linear_system(netlist const & circuit, placement_t
points.push_back(p.pos);
}
auto const edges = get_RSMT_topology(points, 8);
for(auto E : edges.x_){
add_force(pins[E.first].x(), pins[E.second].x(), L.x_, tol, 1.0f);
for(auto E : edges.x){
add_force(pins[E.first].x(), pins[E.second].x(), L.x, tol, 1.0f);
}
for(auto E : edges.y_){
add_force(pins[E.first].y(), pins[E.second].y(), L.y_, tol, 1.0f);
for(auto E : edges.y){
add_force(pins[E.first].y(), pins[E.second].y(), L.y, tol, 1.0f);
}
}
return L;
@ -278,28 +278,28 @@ void solve_linear_system(netlist const & circuit, placement_t & pl, point<linear
std::vector<float_t> x_sol, y_sol;
std::vector<float_t> x_guess(pl.cell_cnt()), y_guess(pl.cell_cnt());
assert(L.x_.internal_size() == x_guess.size());
assert(L.y_.internal_size() == y_guess.size());
assert(L.x.internal_size() == x_guess.size());
assert(L.y.internal_size() == y_guess.size());
for(index_t i=0; i<pl.cell_cnt(); ++i){
x_guess[i] = static_cast<float_t>(pl.positions_[i].x_);
y_guess[i] = static_cast<float_t>(pl.positions_[i].y_);
x_guess[i] = static_cast<float_t>(pl.positions_[i].x);
y_guess[i] = static_cast<float_t>(pl.positions_[i].y);
}
#pragma omp parallel sections num_threads(2)
{
#pragma omp section
x_sol = L.x_.solve_CG(x_guess, nbr_iter);
x_sol = L.x.solve_CG(x_guess, nbr_iter);
#pragma omp section
y_sol = L.y_.solve_CG(y_guess, nbr_iter);
y_sol = L.y.solve_CG(y_guess, nbr_iter);
}
for(index_t i=0; i<pl.cell_cnt(); ++i){
if( (circuit.get_cell(i).attributes & XMovable) != 0){
assert(std::isfinite(x_sol[i]));
pl.positions_[i].x_ = static_cast<int_t>(x_sol[i]);
pl.positions_[i].x = static_cast<int_t>(x_sol[i]);
}
if( (circuit.get_cell(i).attributes & YMovable) != 0){
assert(std::isfinite(y_sol[i]));
pl.positions_[i].y_ = static_cast<int_t>(y_sol[i]);
pl.positions_[i].y = static_cast<int_t>(y_sol[i]);
}
}
}
@ -325,13 +325,13 @@ point<linear_system> get_pulling_forces (netlist const & circuit, placement_t co
float_t typical_force = 1.0f / typical_distance;
std::vector<float_t> scaling = get_area_scales(circuit);
for(index_t i=0; i<pl.cell_cnt(); ++i){
L.x_.add_anchor(
L.x.add_anchor(
typical_force * scaling[i],
i, pl.positions_[i].x_
i, pl.positions_[i].x
);
L.y_.add_anchor(
L.y.add_anchor(
typical_force * scaling[i],
i, pl.positions_[i].y_
i, pl.positions_[i].y
);
}
@ -343,13 +343,13 @@ point<linear_system> get_linear_pulling_forces (netlist const & circuit, placeme
assert(LB_pl.cell_cnt() == UB_pl.cell_cnt());
std::vector<float_t> scaling = get_area_scales(circuit);
for(index_t i=0; i<LB_pl.cell_cnt(); ++i){
L.x_.add_anchor(
force * scaling[i] / (std::max(static_cast<float_t>(std::abs(UB_pl.positions_[i].x_ - LB_pl.positions_[i].x_)), min_distance)),
i, UB_pl.positions_[i].x_
L.x.add_anchor(
force * scaling[i] / (std::max(static_cast<float_t>(std::abs(UB_pl.positions_[i].x - LB_pl.positions_[i].x)), min_distance)),
i, UB_pl.positions_[i].x
);
L.y_.add_anchor(
force * scaling[i] / (std::max(static_cast<float_t>(std::abs(UB_pl.positions_[i].y_ - LB_pl.positions_[i].y_)), min_distance)),
i, UB_pl.positions_[i].y_
L.y.add_anchor(
force * scaling[i] / (std::max(static_cast<float_t>(std::abs(UB_pl.positions_[i].y - LB_pl.positions_[i].y)), min_distance)),
i, UB_pl.positions_[i].y
);
}
@ -375,10 +375,10 @@ float_t get_mean_linear_disruption(netlist const & circuit, placement_t const &
float_t area = static_cast<float_t>(circuit.get_cell(i).area);
point<int_t> diff = LB_pl.positions_[i] - UB_pl.positions_[i];
if( (circuit.get_cell(i).attributes & XMovable) == 0) assert(diff.x_ == 0);
if( (circuit.get_cell(i).attributes & YMovable) == 0) assert(diff.y_ == 0);
if( (circuit.get_cell(i).attributes & XMovable) == 0) assert(diff.x == 0);
if( (circuit.get_cell(i).attributes & YMovable) == 0) assert(diff.y == 0);
tot_cost += area * (std::abs(diff.x_) + std::abs(diff.y_));
tot_cost += area * (std::abs(diff.x) + std::abs(diff.y));
tot_area += area;
}
return tot_cost / tot_area;
@ -391,10 +391,10 @@ float_t get_mean_quadratic_disruption(netlist const & circuit, placement_t const
float_t area = static_cast<float_t>(circuit.get_cell(i).area);
point<int_t> diff = LB_pl.positions_[i] - UB_pl.positions_[i];
if( (circuit.get_cell(i).attributes & XMovable) == 0) assert(diff.x_ == 0);
if( (circuit.get_cell(i).attributes & YMovable) == 0) assert(diff.y_ == 0);
if( (circuit.get_cell(i).attributes & XMovable) == 0) assert(diff.x == 0);
if( (circuit.get_cell(i).attributes & YMovable) == 0) assert(diff.y == 0);
float_t manhattan = (std::abs(diff.x_) + std::abs(diff.y_));
float_t manhattan = (std::abs(diff.x) + std::abs(diff.y));
tot_cost += area * manhattan * manhattan;
tot_area += area;
}

34
coloquinte/src/coloquinte/circuit_helper.hxx
View File

@ -24,28 +24,28 @@ struct pin_2D{
bool movable;
pin_2D(index_t c, point<int_t> p, point<int_t> o, bool m) : cell_ind(c), pos(p), offs(o), movable(m){}
pin_1D x() const{ return pin_1D(cell_ind, pos.x_, offs.x_, movable); }
pin_1D y() const{ return pin_1D(cell_ind, pos.y_, offs.y_, movable); }
pin_1D x() const{ return pin_1D(cell_ind, pos.x, offs.x, movable); }
pin_1D y() const{ return pin_1D(cell_ind, pos.y, offs.y, movable); }
};
inline int_t dist(pin_2D const a, pin_2D const b){
point<int_t> diff = a.pos - b.pos;
return std::abs(diff.x_) + std::abs(diff.y_);
return std::abs(diff.x) + std::abs(diff.y);
}
inline std::vector<pin_2D> get_pins_2D(netlist const & circuit, placement_t const & pl, index_t net_ind){
std::vector<pin_2D> ret;
for(auto p : circuit.get_net(net_ind)){
assert(std::isfinite(pl.positions_[p.cell_ind].x_) and std::isfinite(pl.positions_[p.cell_ind].y_));
assert(std::isfinite(pl.orientations_[p.cell_ind].x_) and std::isfinite(pl.orientations_[p.cell_ind].y_));
assert(std::isfinite(pl.positions_[p.cell_ind].x) and std::isfinite(pl.positions_[p.cell_ind].y));
assert(std::isfinite(pl.orientations_[p.cell_ind].x) and std::isfinite(pl.orientations_[p.cell_ind].y));
point<int_t> offs;
offs.x_ = pl.orientations_[p.cell_ind].x_ ? p.offset.x_ : circuit.get_cell(p.cell_ind).size.x_ - p.offset.x_;
offs.y_ = pl.orientations_[p.cell_ind].y_ ? p.offset.y_ : circuit.get_cell(p.cell_ind).size.y_ - p.offset.y_;
offs.x = pl.orientations_[p.cell_ind].x ? p.offset.x : circuit.get_cell(p.cell_ind).size.x - p.offset.x;
offs.y = pl.orientations_[p.cell_ind].y ? p.offset.y : circuit.get_cell(p.cell_ind).size.y - p.offset.y;
point<int_t> pos = offs + pl.positions_[p.cell_ind];
assert(std::isfinite(offs.x_) and std::isfinite(offs.y_));
assert(std::isfinite(pos.x_) and std::isfinite(pos.y_));
assert(std::isfinite(offs.x) and std::isfinite(offs.y));
assert(std::isfinite(pos.x) and std::isfinite(pos.y));
bool movable = (circuit.get_cell(p.cell_ind).attributes & XMovable) != 0 and (circuit.get_cell(p.cell_ind).attributes & YMovable) != 0;
ret.push_back(pin_2D(p.cell_ind, pos, offs, movable));
@ -56,22 +56,22 @@ inline std::vector<pin_2D> get_pins_2D(netlist const & circuit, placemen
inline point<std::vector<pin_1D> > get_pins_1D(netlist const & circuit, placement_t const & pl, index_t net_ind){
point<std::vector<pin_1D> > ret;
for(auto p : circuit.get_net(net_ind)){
assert(std::isfinite(pl.positions_[p.cell_ind].x_) and std::isfinite(pl.positions_[p.cell_ind].y_));
assert(std::isfinite(pl.orientations_[p.cell_ind].x_) and std::isfinite(pl.orientations_[p.cell_ind].y_));
assert(std::isfinite(pl.positions_[p.cell_ind].x) and std::isfinite(pl.positions_[p.cell_ind].y));
assert(std::isfinite(pl.orientations_[p.cell_ind].x) and std::isfinite(pl.orientations_[p.cell_ind].y));
point<int_t> offs;
offs.x_ = pl.orientations_[p.cell_ind].x_ ? p.offset.x_ : circuit.get_cell(p.cell_ind).size.x_ - p.offset.x_;
offs.y_ = pl.orientations_[p.cell_ind].y_ ? p.offset.y_ : circuit.get_cell(p.cell_ind).size.y_ - p.offset.y_;
offs.x = pl.orientations_[p.cell_ind].x ? p.offset.x : circuit.get_cell(p.cell_ind).size.x - p.offset.x;
offs.y = pl.orientations_[p.cell_ind].y ? p.offset.y : circuit.get_cell(p.cell_ind).size.y - p.offset.y;
point<int_t> pos = offs + pl.positions_[p.cell_ind];
assert(std::isfinite(offs.x_) and std::isfinite(offs.y_));
assert(std::isfinite(pos.x_) and std::isfinite(pos.y_));
assert(std::isfinite(offs.x) and std::isfinite(offs.y));
assert(std::isfinite(pos.x) and std::isfinite(pos.y));
bool x_movable = (circuit.get_cell(p.cell_ind).attributes & XMovable) != 0;
bool y_movable = (circuit.get_cell(p.cell_ind).attributes & YMovable) != 0;
ret.x_.push_back(pin_1D(p.cell_ind, pos.x_, offs.x_, x_movable));
ret.y_.push_back(pin_1D(p.cell_ind, pos.y_, offs.y_, y_movable));
ret.x.push_back(pin_1D(p.cell_ind, pos.x, offs.x, x_movable));
ret.y.push_back(pin_1D(p.cell_ind, pos.y, offs.y, y_movable));
}
return ret;
}

62
coloquinte/src/coloquinte/common.hxx
View File

@ -30,75 +30,83 @@ enum Movability{
template<typename T>
struct point{
T x_, y_;
T x, y;
point(){}
point(T x, T y): x_(x), y_(y){}
point(T x, T y): x(x), y(y){}
template<typename S>
operator point<S>() const{
return point<S>(static_cast<S>(x_), static_cast<S>(y_));
return point<S>(static_cast<S>(x), static_cast<S>(y));
}
void operator+=(point<T> const o){
x_ += o.x_;
y_ += o.y_;
x += o.x;
y += o.y;
}
};
template<typename T>
point<T> operator+(point<T> const a, point<T> const b){
return point<T>(a.x_+b.x_, a.y_+b.y_);
return point<T>(a.x+b.x, a.y+b.y);
}
template<typename T>
point<T> operator-(point<T> const a, point<T> const b){
return point<T>(a.x_-b.x_, a.y_-b.y_);
return point<T>(a.x-b.x, a.y-b.y);
}
template<typename T>
point<T> operator*(T lambda, point<T> const p){
return point<T>(lambda * p.x_, lambda * p.y_);
return point<T>(lambda * p.x, lambda * p.y);
}
template<typename T>
point<T> operator*(point<T> const a, point<T> const b){
return point<T>(a.x_*b.x_, a.y_*b.y_);
return point<T>(a.x*b.x, a.y*b.y);
}
template<typename T>
struct box{
T x_min_, x_max_, y_min_, y_max_;
T x_min, x_max, y_min, y_max;
box(){}
box(T x_mn, T x_mx, T y_mn, T y_mx) : x_min_(x_mn), x_max_(x_mx), y_min_(y_mn), y_max_(y_mx){}
box(point<T> mn, point<T> mx) : x_min_(mn.x_), x_max_(mx.x_), y_min_(mn.y_), y_max_(mx.y_){}
box(T x_mn, T x_mx, T y_mn, T y_mx) : x_min(x_mn), x_max(x_mx), y_min(y_mn), y_max(y_mx){}
box(point<T> mn, point<T> mx) : x_min(mn.x), x_max(mx.x), y_min(mn.y), y_max(mx.y){}
bool in(box<T> const o) const{
return x_max_ <= o.x_max_
&& y_max_ <= o.y_max_
&& x_min_ >= o.x_min_
&& y_min_ >= o.y_min_;
return x_max <= o.x_max
&& y_max <= o.y_max
&& x_min >= o.x_min
&& y_min >= o.y_min;
}
bool intersects(box<T> const o) const{
return x_min_ < o.x_max_
&& y_min_ < o.y_max_
&& o.x_min_ < x_max_
&& o.y_min_ < y_max_;
return x_min < o.x_max
&& y_min < o.y_max
&& o.x_min < x_max
&& o.y_min < y_max;
}
box<T> intersection(box<T> const o) const{
return box<T>(
std::max(x_min_, o.x_min_),
std::min(x_max_, o.x_max_),
std::max(y_min_, o.y_min_),
std::min(y_max_, o.y_max_)
std::max(x_min, o.x_min),
std::min(x_max, o.x_max),
std::max(y_min, o.y_min),
std::min(y_max, o.y_max)
);
}
box<T> bounding_box(box<T> const o) const{
return box<T>(
std::min(x_min, o.x_min),
std::max(x_max, o.x_max),
std::min(y_min, o.y_min),
std::max(y_max, o.y_max)
);
}
point<T> dimensions() const{
return point<T>(x_max_-x_min_, y_max_-y_min_);
return point<T>(x_max-x_min, y_max-y_min);
}
bool empty() const{
return dimensions().x_ <= 0 or dimensions().y_ <= 0;
return dimensions().x <= 0 or dimensions().y <= 0;
}
template<typename S>
operator box<S>() const{
return box<S>(static_cast<S>(x_min_), static_cast<S>(x_max_), static_cast<S>(y_min_), static_cast<S>(y_max_));
return box<S>(static_cast<S>(x_min), static_cast<S>(x_max), static_cast<S>(y_min), static_cast<S>(y_max));
}
};

2
coloquinte/src/coloquinte/detailed.hxx
View File

@ -80,8 +80,6 @@ void OSRP_convex_RSMT(netlist const & circuit, detailed_placement & pl);
void OSRP_noncvx_HPWL(netlist const & circuit, detailed_placement & pl);
void OSRP_noncvx_RSMT(netlist const & circuit, detailed_placement & pl);
void optimize_on_topology_HPWL(netlist const & circuit, detailed_placement & pl);
void row_compatible_orientation(netlist const & circuit, detailed_placement & pl, bool first_row_orient);
} // namespace dp

2
coloquinte/src/coloquinte/netlist.hxx
View File

@ -24,7 +24,7 @@ struct temporary_cell{
index_t list_index;
temporary_cell(){}
temporary_cell(point<int_t> s, mask_t attr, index_t ind) : size(s), attributes(attr), list_index(ind){ area = static_cast<capacity_t>(s.x_) * static_cast<capacity_t>(s.y_);}
temporary_cell(point<int_t> s, mask_t attr, index_t ind) : size(s), attributes(attr), list_index(ind){ area = static_cast<capacity_t>(s.x) * static_cast<capacity_t>(s.y);}
};
struct temporary_net{

8
coloquinte/src/coloquinte/rough_legalizers.hxx
View File

@ -212,7 +212,7 @@ inline region_distribution::movable_cell::movable_cell(capacity_t demand, point<
inline box<int_t> region_distribution::placement_area() const { return placement_area_; }
inline point<float_t> region_distribution::region_dimensions() const {
point<int_t> s = static_cast<point<float_t> >(placement_area().dimensions());
return point<float_t>(s.x_/x_regions_cnt(), s.y_/y_regions_cnt());
return point<float_t>(s.x/x_regions_cnt(), s.y/y_regions_cnt());
}
inline index_t region_distribution::x_regions_cnt() const { return x_regions_cnt_; }
@ -247,10 +247,10 @@ inline capacity_t region_distribution::region::allocated_capacity() const{
inline index_t region_distribution::region::cell_cnt() const{ return cell_references_.size(); }
inline float_t region_distribution::region::distance(region_distribution::cell_ref const & C) const{
return std::abs(pos_.x_ - C.pos_.x_) + std::abs(pos_.y_ - C.pos_.y_);
return std::abs(pos_.x - C.pos_.x) + std::abs(pos_.y - C.pos_.y);
/*
float_t manhattan = std::max(static_cast<float_t>(0.0), std::max(C.pos_.x_ - surface_.x_max_, surface_.x_min_ - C.pos_.x_))
+ std::max(static_cast<float_t>(0.0), std::max(C.pos_.y_ - surface_.y_max_, surface_.y_min_ - C.pos_.y_));
float_t manhattan = std::max(static_cast<float_t>(0.0), std::max(C.pos_.x - surface_.x_max, surface_.x_min - C.pos_.x))
+ std::max(static_cast<float_t>(0.0), std::max(C.pos_.y - surface_.y_max, surface_.y_min - C.pos_.y));
return manhattan * (1.0 + manhattan * 0.0001);
*/
}

11
coloquinte/src/detailed.cxx
View File

@ -20,7 +20,8 @@ detailed_placement::detailed_placement(
plt_(pl),
cell_rows_(placement_rows),
min_x_(min_x), max_x_(max_x),
y_origin_(y_origin)
y_origin_(y_origin),
row_height_(row_height)
{
assert(row_height > 0);
@ -77,7 +78,7 @@ void detailed_placement::selfcheck() const{
for(index_t i=0; i<cell_cnt(); ++i){
for(index_t l=0; l<cell_height(i); ++l){
// not verified now since we don't modify the position for the obstacles
// : assert(c.position.x_ >= min_x_ and c.position.x_ + c.width <= max_x_);
// : assert(c.position.x >= min_x_ and c.position.x + c.width <= max_x_);
index_t n_ind = l + neighbours_limits_[i];
assert(cell_rows_[i] + cell_height(i) <= row_cnt());
@ -142,10 +143,10 @@ std::pair<int_t, int_t> detailed_placement::get_limit_positions(netlist const &
a_i = neighbours_[l].second;
if(b_i != null_ind){
ret.first = std::max(ret.first, plt_.positions_[b_i].x_ + circuit.get_cell(b_i).size.x_);
ret.first = std::max(ret.first, plt_.positions_[b_i].x + circuit.get_cell(b_i).size.x);
}
if(a_i != null_ind){
ret.second = std::min(ret.second, plt_.positions_[a_i].x_);
ret.second = std::min(ret.second, plt_.positions_[a_i].x);
}
}
return ret;
@ -249,7 +250,7 @@ void detailed_placement::reorder_standard_cells(std::vector<index_t> const old_o
void row_compatible_orientation(netlist const & circuit, detailed_placement & pl, bool first_row_orient){
for(index_t c=0; c<circuit.cell_cnt(); ++c){
if( (circuit.get_cell(c).attributes & YFlippable) != 0 and pl.cell_height(c) == 1){
pl.plt_.orientations_[c].y_ = (pl.cell_rows_[c] % 2 != 0) ^ first_row_orient;
pl.plt_.orientations_[c].y = (pl.cell_rows_[c] % 2 != 0) ^ first_row_orient;
}
}
}

46
coloquinte/src/legalizer.cxx
View File

@ -12,14 +12,14 @@ namespace dp{
void get_result(netlist const & circuit, detailed_placement const & dpl, placement_t & gpl){
for(index_t c=0; c<circuit.cell_cnt(); ++c){
if( (circuit.get_cell(c).attributes & XMovable) != 0)
gpl.positions_[c].x_ = dpl.plt_.positions_[c].x_;
gpl.positions_[c].x = dpl.plt_.positions_[c].x;
if( (circuit.get_cell(c).attributes & YMovable) != 0)
gpl.positions_[c].y_ = dpl.plt_.positions_[c].y_;
gpl.positions_[c].y = dpl.plt_.positions_[c].y;
if( (circuit.get_cell(c).attributes & XFlippable) != 0)
gpl.orientations_[c].x_ = dpl.plt_.orientations_[c].x_;
gpl.orientations_[c].x = dpl.plt_.orientations_[c].x;
if( (circuit.get_cell(c).attributes & YFlippable) != 0)
gpl.orientations_[c].y_ = dpl.plt_.orientations_[c].y_;
gpl.orientations_[c].y = dpl.plt_.orientations_[c].y;
}
}
@ -356,8 +356,8 @@ std::vector<cell_leg_properties> good_legalize(
detailed_placement legalize(netlist const & circuit, placement_t const & pl, box<int_t> surface, int_t row_height){
if(row_height <= 0) throw std::runtime_error("The rows' height should be positive\n");
index_t nbr_rows = (surface.y_max_ - surface.y_min_) / row_height;
// The position of the ith row is surface.y_min_ + i * row_height
index_t nbr_rows = (surface.y_max - surface.y_min) / row_height;
// The position of the ith row is surface.y_min + i * row_height
std::vector<std::vector<fixed_cell_interval> > row_occupation(nbr_rows);
std::vector<cell_to_leg> cells;
@ -372,32 +372,32 @@ detailed_placement legalize(netlist const & circuit, placement_t const & pl, box
if( (cur.attributes & XMovable) != 0 && (cur.attributes & YMovable) != 0){
// Just truncate the position we target
point<int_t> target_pos = pl.positions_[i];
index_t cur_cell_rows = (cur.size.y_ + row_height -1) / row_height;
cells.push_back(cell_to_leg(target_pos.x_, target_pos.y_, i, cur.size.x_, cur_cell_rows));
index_t cur_cell_rows = (cur.size.y + row_height -1) / row_height;
cells.push_back(cell_to_leg(target_pos.x, target_pos.y, i, cur.size.x, cur_cell_rows));
cell_heights[i] = cur_cell_rows;
}
else{
// In each row, we put the index of the fixed cell and the range that is already occupied
int_t low_x_pos = pl.positions_[i].x_,
hgh_x_pos = pl.positions_[i].x_ + cur.size.x_,
low_y_pos = pl.positions_[i].y_,
hgh_y_pos = pl.positions_[i].y_ + cur.size.y_;
int_t low_x_pos = pl.positions_[i].x,
hgh_x_pos = pl.positions_[i].x + cur.size.x,
low_y_pos = pl.positions_[i].y,
hgh_y_pos = pl.positions_[i].y + cur.size.y;
new_placement.positions_[i] = point<int_t>(low_x_pos, low_y_pos);
if(hgh_y_pos <= surface.y_min_ or low_y_pos >= surface.y_max_ or hgh_x_pos <= surface.x_min_ or low_x_pos >= surface.x_max_){
if(hgh_y_pos <= surface.y_min or low_y_pos >= surface.y_max or hgh_x_pos <= surface.x_min or low_x_pos >= surface.x_max){
placement_rows[i] = null_ind;
cell_heights[i] = 0;
}
else{
assert(low_x_pos < hgh_x_pos and low_y_pos < hgh_y_pos);
int_t rnd_hgh_x_pos = std::min(surface.x_max_, hgh_x_pos);
int_t rnd_hgh_y_pos = std::min(surface.y_max_, hgh_y_pos);
int_t rnd_low_x_pos = std::max(surface.x_min_, low_x_pos);
int_t rnd_low_y_pos = std::max(surface.y_min_, low_y_pos);
int_t rnd_hgh_x_pos = std::min(surface.x_max, hgh_x_pos);
int_t rnd_hgh_y_pos = std::min(surface.y_max, hgh_y_pos);
int_t rnd_low_x_pos = std::max(surface.x_min, low_x_pos);
int_t rnd_low_y_pos = std::max(surface.y_min, low_y_pos);
index_t first_row = (rnd_low_y_pos - surface.y_min_) / row_height;
index_t last_row = (index_t) (rnd_hgh_y_pos - surface.y_min_ + row_height - 1) / row_height; // Exclusive: if the cell spans the next row, i.e. pos % row_height >= 0, include it too
index_t first_row = (rnd_low_y_pos - surface.y_min) / row_height;
index_t last_row = (index_t) (rnd_hgh_y_pos - surface.y_min + row_height - 1) / row_height; // Exclusive: if the cell spans the next row, i.e. pos % row_height >= 0, include it too
assert(last_row <= nbr_rows);
placement_rows[i] = first_row;
@ -421,12 +421,12 @@ detailed_placement legalize(netlist const & circuit, placement_t const & pl, box
std::vector<std::vector<index_t> > cells_by_rows;
auto final_cells = good_legalize(row_occupation, cells, cells_by_rows,
surface.x_min_, surface.x_max_, surface.y_min_,
surface.x_min, surface.x_max, surface.y_min,
row_height, nbr_rows
);
for(cell_leg_properties C : final_cells){
new_placement.positions_[C.ind] = point<int_t>(C.x_pos, static_cast<int_t>(C.row_pos) * row_height + surface.y_min_);
new_placement.positions_[C.ind] = point<int_t>(C.x_pos, static_cast<int_t>(C.row_pos) * row_height + surface.y_min);
placement_rows[C.ind] = C.row_pos;
}
@ -435,8 +435,8 @@ detailed_placement legalize(netlist const & circuit, placement_t const & pl, box
placement_rows,
cell_heights,
cells_by_rows,
surface.x_min_, surface.x_max_,
surface.y_min_,
surface.x_min, surface.x_max,
surface.y_min,
nbr_rows, row_height
);
}

8
coloquinte/src/orientation.cxx
View File

@ -141,10 +141,10 @@ inline void spread_orient(netlist const & circuit, placement_t & pl, std::functi
} // End anonymous namespace
void optimize_x_orientations(netlist const & circuit, placement_t & pl){
opt_orient(circuit, pl, [](point<int_t> p) -> int_t { return p.x_; }, [](point<bool> & p) -> bool & { return p.x_; }, XFlippable);
opt_orient(circuit, pl, [](point<int_t> p) -> int_t { return p.x; }, [](point<bool> & p) -> bool & { return p.x; }, XFlippable);
}
void optimize_y_orientations(netlist const & circuit, placement_t & pl){
opt_orient(circuit, pl, [](point<int_t> p) -> int_t { return p.y_; }, [](point<bool> & p) -> bool & { return p.y_; }, YFlippable);
opt_orient(circuit, pl, [](point<int_t> p) -> int_t { return p.y; }, [](point<bool> & p) -> bool & { return p.y; }, YFlippable);
}
// Iteratively optimize feasible orientations; performs only one pass
@ -155,8 +155,8 @@ void optimize_exact_orientations(netlist const & circuit, placement_t & pl){
/*
void spread_orientations(netlist const & circuit, placement_t & pl){
spread_orient(circuit, pl, [](point<float_t> & p) -> float_t & { return p.x_; }, XFlippable);
spread_orient(circuit, pl, [](point<float_t> & p) -> float_t & { return p.y_; }, YFlippable);
spread_orient(circuit, pl, [](point<float_t> & p) -> float_t & { return p.x; }, XFlippable);
spread_orient(circuit, pl, [](point<float_t> & p) -> float_t & { return p.y; }, YFlippable);
}
*/

146
coloquinte/src/rough_legalizers.cxx
View File

@ -79,28 +79,28 @@ region_distribution::region::region(capacity_t cap, point<float_t> pos, std::vec
box<int_t> region_distribution::get_box(index_t x, index_t y, index_t x_cnt, index_t y_cnt) const{
auto ret = box<int_t>(
placement_area_.x_min_ + ( ((std::int64_t) (placement_area_.x_max_ - placement_area_.x_min_)) * x ) / x_cnt,
placement_area_.x_min_ + ( ((std::int64_t) (placement_area_.x_max_ - placement_area_.x_min_)) * (x+1) ) / x_cnt,
placement_area_.y_min_ + ( ((std::int64_t) (placement_area_.y_max_ - placement_area_.y_min_)) * y ) / y_cnt,
placement_area_.y_min_ + ( ((std::int64_t) (placement_area_.y_max_ - placement_area_.y_min_)) * (y+1) ) / y_cnt
placement_area_.x_min + ( ((std::int64_t) (placement_area_.x_max - placement_area_.x_min)) * x ) / x_cnt,
placement_area_.x_min + ( ((std::int64_t) (placement_area_.x_max - placement_area_.x_min)) * (x+1) ) / x_cnt,
placement_area_.y_min + ( ((std::int64_t) (placement_area_.y_max - placement_area_.y_min)) * y ) / y_cnt,
placement_area_.y_min + ( ((std::int64_t) (placement_area_.y_max - placement_area_.y_min)) * (y+1) ) / y_cnt
);
assert(not ret.empty());
return ret;
}
std::vector<region_distribution::region> region_distribution::prepare_regions(index_t x_cnt, index_t y_cnt) const{
assert(placement_area_.x_max_ > placement_area_.x_min_);
assert(placement_area_.y_max_ > placement_area_.y_min_);
assert(placement_area_.x_max > placement_area_.x_min);
assert(placement_area_.y_max > placement_area_.y_min);
// Uses a sweepline algorithm to initialize all regions' capacities at a time, taking macros and density maps into account
// The events in the priority queue: basically a density_limit object, but the y_min_ may be different from the original one
// The events in the priority queue: basically a density_limit object, but the y_min may be different from the original one
struct event{
box<int_t> box_;
capacity_t multiplicator_;
bool operator<(event const o) const{
return box_.y_min_ > o.box_.y_min_ // Priority queue = highest first
or (box_.y_min_ == o.box_.y_min_ and multiplicator_ > o.multiplicator_); // Smallest density first, just because
return box_.y_min > o.box_.y_min // Priority queue = highest first
or (box_.y_min == o.box_.y_min and multiplicator_ > o.multiplicator_); // Smallest density first, just because
}
event(box<int_t> surface, capacity_t den) : box_(surface), multiplicator_(den) {}
event(density_limit D, capacity_t density_mul) : box_(D.box_) {
@ -109,9 +109,9 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
};
struct line_y{
int_t y_min_, y_max_;
int_t y_min, y_max;
capacity_t multiplicator_;
line_y(int_t mn, int_t mx, capacity_t cap) : y_min_(mn), y_max_(mx), multiplicator_(cap) {}
line_y(int_t mn, int_t mx, capacity_t cap) : y_min(mn), y_max(mx), multiplicator_(cap) {}
};
// The regions' capacities
@ -120,10 +120,10 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
// Find the limits of the regions
std::vector<int_t> x_reg_lims(x_cnt+1), y_reg_lims(y_cnt+1);
for(index_t i=0; i<=x_cnt; ++i){
x_reg_lims[i] = placement_area_.x_min_ + ( ((std::int64_t) (placement_area_.x_max_ - placement_area_.x_min_)) * i ) / x_cnt;
x_reg_lims[i] = placement_area_.x_min + ( ((std::int64_t) (placement_area_.x_max - placement_area_.x_min)) * i ) / x_cnt;
}
for(index_t i=0; i<=y_cnt; ++i){
y_reg_lims[i] = placement_area_.y_min_ + ( ((std::int64_t) (placement_area_.y_max_ - placement_area_.y_min_)) * i ) / y_cnt;
y_reg_lims[i] = placement_area_.y_min + ( ((std::int64_t) (placement_area_.y_max - placement_area_.y_min)) * i ) / y_cnt;
}
//std::vector<box<int_t> > added;
@ -132,12 +132,12 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
/*
// Failed attempt at calculating the coordinates directly
point<int_t> dims = placement_area_.dimensions();
auto mins = point<int_t>(placement_area_.x_min_, placement_area_.y_min_);
auto mins = point<int_t>(placement_area_.x_min, placement_area_.y_min);
index_t x_mn = (static_cast<std::int64_t>(bx.x_min_ - mins.x_ + 1) * x_cnt) / dims.x_,
x_mx = (static_cast<std::int64_t>(bx.x_max_ - mins.x_ - 1) * x_cnt) / dims.x_ + 1,
y_mn = (static_cast<std::int64_t>(bx.y_min_ - mins.y_ + 1) * y_cnt) / dims.y_,
y_mx = (static_cast<std::int64_t>(bx.y_max_ - mins.y_ - 1) * y_cnt) / dims.y_ + 1;
index_t x_mn = (static_cast<std::int64_t>(bx.x_min - mins.x + 1) * x_cnt) / dims.x,
x_mx = (static_cast<std::int64_t>(bx.x_max - mins.x - 1) * x_cnt) / dims.x + 1,
y_mn = (static_cast<std::int64_t>(bx.y_min - mins.y + 1) * y_cnt) / dims.y,
y_mx = (static_cast<std::int64_t>(bx.y_max - mins.y - 1) * y_cnt) / dims.y + 1;
*/
/*
@ -148,15 +148,15 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
added.push_back(bx);
*/
assert(bx.x_min_ >= placement_area_.x_min_);
assert(bx.y_min_ >= placement_area_.y_min_);
assert(bx.x_max_ <= placement_area_.x_max_);
assert(bx.y_max_ <= placement_area_.y_max_);
assert(bx.x_min >= placement_area_.x_min);
assert(bx.y_min >= placement_area_.y_min);
assert(bx.x_max <= placement_area_.x_max);
assert(bx.y_max <= placement_area_.y_max);
index_t x_mn = std::upper_bound(x_reg_lims.begin(), x_reg_lims.end(), bx.x_min_) - x_reg_lims.begin() -1,
y_mn = std::upper_bound(y_reg_lims.begin(), y_reg_lims.end(), bx.y_min_) - y_reg_lims.begin() -1,
x_mx = std::lower_bound(x_reg_lims.begin(), x_reg_lims.end(), bx.x_max_) - x_reg_lims.begin(),
y_mx = std::lower_bound(y_reg_lims.begin(), y_reg_lims.end(), bx.y_max_) - y_reg_lims.begin();
index_t x_mn = std::upper_bound(x_reg_lims.begin(), x_reg_lims.end(), bx.x_min) - x_reg_lims.begin() -1,
y_mn = std::upper_bound(y_reg_lims.begin(), y_reg_lims.end(), bx.y_min) - y_reg_lims.begin() -1,
x_mx = std::lower_bound(x_reg_lims.begin(), x_reg_lims.end(), bx.x_max) - x_reg_lims.begin(),
y_mx = std::lower_bound(y_reg_lims.begin(), y_reg_lims.end(), bx.y_max) - y_reg_lims.begin();
for(index_t x=x_mn; x<x_mx; ++x){
for(index_t y=y_mn; y<y_mx; ++y){
@ -164,7 +164,7 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
assert(bx.intersects(cur_box));
box<int_t> inter = bx.intersection(cur_box);
point<int_t> dims = inter.dimensions();
region_caps[y*x_cnt + x] += d * static_cast<capacity_t>(dims.x_) * static_cast<capacity_t>(dims.y_);
region_caps[y*x_cnt + x] += d * static_cast<capacity_t>(dims.x) * static_cast<capacity_t>(dims.y);
}
}
};
@ -186,24 +186,24 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
// The initial sweepline, with begin and end of the line
std::map<int_t, line_y> active_obstacles;
line_y placement_begin (placement_area_.y_min_, placement_area_.y_max_, full_density_mul),
placement_end (placement_area_.y_min_, placement_area_.y_max_, 0);
line_y placement_begin (placement_area_.y_min, placement_area_.y_max, full_density_mul),
placement_end (placement_area_.y_min, placement_area_.y_max, 0);
active_obstacles.insert(std::pair<int_t, line_y>(placement_area_.x_min_, placement_begin)); // Full density placement area as initial object
active_obstacles.insert(std::pair<int_t, line_y>(placement_area_.x_max_, placement_end));
active_obstacles.insert(std::pair<int_t, line_y>(placement_area_.x_min, placement_begin)); // Full density placement area as initial object
active_obstacles.insert(std::pair<int_t, line_y>(placement_area_.x_max, placement_end));
// Main loop: sweep the line on y (the line is horizontal, and moves toward bigger y)
while(not events.empty()){
event D = events.top();
int_t x_b=D.box_.x_min_, x_e=D.box_.x_max_;
int_t y_b=D.box_.y_min_, y_e=D.box_.y_max_;
int_t x_b=D.box_.x_min, x_e=D.box_.x_max;
int_t y_b=D.box_.y_min, y_e=D.box_.y_max;
events.pop();
assert(x_b >= placement_area_.x_min_);
assert(y_b >= placement_area_.y_min_);
assert(x_e <= placement_area_.x_max_);
assert(y_e <= placement_area_.y_max_);
assert(x_b >= placement_area_.x_min);
assert(y_b >= placement_area_.y_min);
assert(x_e <= placement_area_.x_max);
assert(y_e <= placement_area_.y_max);
// For each delimitation between the bounds of the new rectangle
// If the new delimitation has higher density or this delimitation ends on y there
@ -215,7 +215,7 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
line_y const new_elt(y_b, y_e, D.multiplicator_);
std::vector<line_y> new_delimitations;
// First element on the line whose x_ is after our x_min (i.e. may have an intersection), and while there is an intersection
// First element on the line whose x is after our x_min (i.e. may have an intersection), and while there is an intersection
auto first_it = active_obstacles.upper_bound(x_b);
assert(first_it != active_obstacles.begin());
assert(std::prev(first_it)->first <= x_b);
@ -224,8 +224,8 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
for(auto it = std::prev(first_it); it != active_obstacles.end() and it->first < x_e;){
auto next_it = std::next(it);
assert(next_it != active_obstacles.end());
assert(it->second.y_min_ <= y_b);
assert(it->second.y_max_ >= y_b);
assert(it->second.y_min <= y_b);
assert(it->second.y_max >= y_b);
assert(it->first < x_e);
assert(next_it->first > x_b);
assert(next_it-> first > it->first);
@ -233,18 +233,18 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
int_t x_c_min = std::max(x_b, it->first),
x_c_max = std::min(x_e, next_it->first);
assert(x_c_min < x_c_max);
// Add the area from it->second.y_min_ to D.box_.y_min_
if(y_b > it->second.y_min_)
add_region(box<int_t>(it->first, next_it->first, it->second.y_min_, y_b), it->second.multiplicator_);
it->second.y_min_ = y_b; // Now the part before has been used
// Add the area from it->second.y_min to D.box_.y_min
if(y_b > it->second.y_min)
add_region(box<int_t>(it->first, next_it->first, it->second.y_min, y_b), it->second.multiplicator_);
it->second.y_min = y_b; // Now the part before has been used
auto part_b = *it, part_e = *next_it;
if(part_b.second.multiplicator_ > D.multiplicator_ or part_b.second.y_max_ == y_b){ // The new event is visible now
if(part_b.second.multiplicator_ > D.multiplicator_ or part_b.second.y_max == y_b){ // The new event is visible now
// In case parts of the line become visible again later
if(part_b.second.y_max_ > y_e){ // Push back a new event to account for the comeback
events.push(event(box<int_t>(x_c_min, x_c_max, y_e, part_b.second.y_max_), part_b.second.multiplicator_));
if(part_b.second.y_max > y_e){ // Push back a new event to account for the comeback
events.push(event(box<int_t>(x_c_min, x_c_max, y_e, part_b.second.y_max), part_b.second.multiplicator_));
}
// Depending whether this part of the line is or is not fully covered
@ -265,8 +265,8 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
}
else{ // The new event is not visible yet
currently_in = false;
if(part_b.second.y_max_ < y_e){ // Push back a new event
events.push(event(box<int_t>(x_c_min, x_c_max, part_b.second.y_max_, y_e), D.multiplicator_));
if(part_b.second.y_max < y_e){ // Push back a new event
events.push(event(box<int_t>(x_c_min, x_c_max, part_b.second.y_max, y_e), D.multiplicator_));
}
}
@ -274,8 +274,8 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
}
}
for(auto it=active_obstacles.begin(); std::next(it) != active_obstacles.end(); ++it){
assert(it->second.y_max_ == placement_area_.y_max_);
add_region(box<int_t>(it->first, std::next(it)->first, it->second.y_min_, it->second.y_max_), it->second.multiplicator_);
assert(it->second.y_max == placement_area_.y_max);
add_region(box<int_t>(it->first, std::next(it)->first, it->second.y_min, it->second.y_max), it->second.multiplicator_);
}
std::vector<region> ret(x_cnt*y_cnt);
@ -284,7 +284,7 @@ std::vector<region_distribution::region> region_distribution::prepare_regions(in
box<int_t> bx = get_box(x, y, x_cnt, y_cnt);
ret[y*x_cnt + x] = region(
region_caps[y*x_cnt + x],
point<float_t>(0.5f * bx.x_min_ + 0.5f * bx.x_max_, 0.5f * bx.y_min_ + 0.5f * bx.y_max_),
point<float_t>(0.5f * bx.x_min + 0.5f * bx.x_max, 0.5f * bx.y_min + 0.5f * bx.y_max),
std::vector<cell_ref>()
);
}
@ -437,7 +437,7 @@ void region_distribution::region::distribute_new_cells(std::vector<std::referenc
}
sort_uniquify(all_cells);
std::sort(all_cells.begin(), all_cells.end(), [](cell_ref const a, cell_ref const b){ return a.allocated_capacity_ > b.allocated_capacity_ or (a.allocated_capacity_ == b.allocated_capacity_ and a.pos_.x_+a.pos_.y_ < b.pos_.x_+b.pos_.y_); });
std::sort(all_cells.begin(), all_cells.end(), [](cell_ref const a, cell_ref const b){ return a.allocated_capacity_ > b.allocated_capacity_ or (a.allocated_capacity_ == b.allocated_capacity_ and a.pos_.x+a.pos_.y < b.pos_.x+b.pos_.y); });
std::vector<std::vector<float_t> > costs(regions.size());
std::vector<capacity_t> demands;
@ -704,7 +704,7 @@ void region_distribution::redo_line_partitions(){
for(index_t x=0; x<x_regions_cnt(); ++x){
regs.push_back(std::reference_wrapper<region>(get_region(x, y)));
}
region::redistribute_cells(regs, [](point<float_t> p){ return p.x_; });
region::redistribute_cells(regs, [](point<float_t> p){ return p.x; });
}
#pragma omp parallel for
for(index_t x=0; x<x_regions_cnt(); ++x){
@ -712,7 +712,7 @@ void region_distribution::redo_line_partitions(){
for(index_t y=0; y<y_regions_cnt(); ++y){
regs.push_back(std::reference_wrapper<region>(get_region(x, y)));
}
region::redistribute_cells(regs, [](point<float_t> p){ return p.y_; });
region::redistribute_cells(regs, [](point<float_t> p){ return p.y; });
}
}
@ -737,7 +737,7 @@ void region_distribution::x_resize(index_t sz){
for(index_t x=0; x<x_regions_cnt(); ++x){
regs.push_back(std::reference_wrapper<region>(get_region(x, y)));
}
region::distribute_new_cells(regs, cells, [](point<float_t> p){ return p.x_; });
region::distribute_new_cells(regs, cells, [](point<float_t> p){ return p.x; });
}
}
@ -762,7 +762,7 @@ void region_distribution::y_resize(index_t sz){
for(index_t y=0; y<y_regions_cnt(); ++y){
regs.push_back(std::reference_wrapper<region>(get_region(x, y)));
}
region::distribute_new_cells(regs, cells, [](point<float_t> p){ return p.y_; });
region::distribute_new_cells(regs, cells, [](point<float_t> p){ return p.y; });
}
}
@ -823,7 +823,7 @@ region_distribution::region_distribution(
auto pos = pl.positions_[i];
auto end = pos + c.size;
density_limit macro;
macro.box_ = box<int_t>(pos.x_, end.x_, pos.y_, end.y_);
macro.box_ = box<int_t>(pos.x, end.x, pos.y, end.y);
macro.density_ = 0.0f;
density_map_.push_back(macro);
}
@ -969,11 +969,11 @@ std::vector<region_distribution::movable_cell> region_distribution::export_sprea
for(index_t i=0; i<n; ++i){
point<float_t> pt = R.cell_references_[i].pos_;
float_t cap = static_cast<float_t>(R.cell_references_[i].allocated_capacity_);
x_cells[i] = OSRP_task(pt.x_, cap/total_capacity * (surface.x_max_ - surface.x_min_), 1.0, i);
y_cells[i] = OSRP_task(pt.y_, cap/total_capacity * (surface.y_max_ - surface.y_min_), 1.0, i);
x_cells[i] = OSRP_task(pt.x, cap/total_capacity * (surface.x_max - surface.x_min), 1.0, i);
y_cells[i] = OSRP_task(pt.y, cap/total_capacity * (surface.y_max - surface.y_min), 1.0, i);
}
std::vector<float_t> x_ret = get_optimal_quadratic_pos(x_cells, surface.x_min_, surface.x_max_);
std::vector<float_t> y_ret = get_optimal_quadratic_pos(y_cells, surface.y_min_, surface.y_max_);
std::vector<float_t> x_ret = get_optimal_quadratic_pos(x_cells, surface.x_min, surface.x_max);
std::vector<float_t> y_ret = get_optimal_quadratic_pos(y_cells, surface.y_min, surface.y_max);
for(index_t i=0; i<n; ++i){
weighted_pos[R.cell_references_[i].index_in_list_] +=
@ -988,7 +988,7 @@ std::vector<region_distribution::movable_cell> region_distribution::export_sprea
movable_cell C = cell_list_[i];
assert(C.demand_ > 0);
C.pos_ = ( static_cast<float_t>(1.0) / static_cast<float_t>(C.demand_) ) * weighted_pos[i];
assert(std::isfinite(C.pos_.x_) and std::isfinite(C.pos_.y_));
assert(std::isfinite(C.pos_.x) and std::isfinite(C.pos_.y));
ret.push_back(C);
}
return ret;
@ -1003,19 +1003,19 @@ std::vector<region_distribution::movable_cell> region_distribution::export_sprea
index_t n = R.cell_references_.size();
float_t total_capacity = static_cast<float_t>(R.capacity());
box<float_t> surface = static_cast<box<float_t> >(get_box(x, y, x_regions_cnt(), y_regions_cnt()));
assert(surface.x_max_ > surface.x_min_ and surface.y_max_ > surface.y_min_);
assert(surface.x_max > surface.x_min and surface.y_max > surface.y_min);
std::vector<legalizable_task<float_t> > x_cells, y_cells;
for(auto const C : R.cell_references_){
float_t cap = static_cast<float_t>(C.allocated_capacity_);
float_t x_cap_prop = cap/total_capacity * (surface.x_max_ - surface.x_min_),
y_cap_prop = cap/total_capacity * (surface.y_max_ - surface.y_min_);
x_cells.push_back(legalizable_task<float_t>(x_cap_prop, C.pos_.x_, C.index_in_list_));
y_cells.push_back(legalizable_task<float_t>(y_cap_prop, C.pos_.y_, C.index_in_list_));
float_t x_cap_prop = cap/total_capacity * (surface.x_max - surface.x_min),
y_cap_prop = cap/total_capacity * (surface.y_max - surface.y_min);
x_cells.push_back(legalizable_task<float_t>(x_cap_prop, C.pos_.x, C.index_in_list_));
y_cells.push_back(legalizable_task<float_t>(y_cap_prop, C.pos_.y, C.index_in_list_));
}
OSRP_leg<float_t> x_leg(surface.x_min_, surface.x_max_), y_leg(surface.y_min_, surface.y_max_);
OSRP_leg<float_t> x_leg(surface.x_min, surface.x_max), y_leg(surface.y_min, surface.y_max);
std::sort(x_cells.begin(), x_cells.end());
for(legalizable_task<float_t> & C : x_cells)
@ -1025,7 +1025,7 @@ std::vector<region_distribution::movable_cell> region_distribution::export_sprea
auto x_pl = x_leg.get_placement();
for(index_t i=0; i<n; ++i){
assert(std::isfinite(x_pl[i].second));
weighted_pos[x_pl[i].first].x_ += (x_pl[i].second + 0.5f * x_cells[i].width) * static_cast<float_t>(x_cells[i].width * total_capacity / (surface.x_max_ - surface.x_min_));
weighted_pos[x_pl[i].first].x += (x_pl[i].second + 0.5f * x_cells[i].width) * static_cast<float_t>(x_cells[i].width * total_capacity / (surface.x_max - surface.x_min));
}
std::sort(y_cells.begin(), y_cells.end());
@ -1036,7 +1036,7 @@ std::vector<region_distribution::movable_cell> region_distribution::export_sprea
auto y_pl = y_leg.get_placement();
for(index_t i=0; i<n; ++i){
assert(std::isfinite(y_pl[i].second));
weighted_pos[y_pl[i].first].y_ += (y_pl[i].second + 0.5f * y_cells[i].width) * static_cast<float_t>(y_cells[i].width * total_capacity / (surface.y_max_ - surface.y_min_));
weighted_pos[y_pl[i].first].y += (y_pl[i].second + 0.5f * y_cells[i].width) * static_cast<float_t>(y_cells[i].width * total_capacity / (surface.y_max - surface.y_min));
}
}
}
@ -1046,7 +1046,7 @@ std::vector<region_distribution::movable_cell> region_distribution::export_sprea
movable_cell C = cell_list_[i];
assert(C.demand_ > 0);
C.pos_ = ( 1.0f / static_cast<float_t>(C.demand_ * cell_density_mul) ) * weighted_pos[i];
assert(std::isfinite(C.pos_.x_) and std::isfinite(C.pos_.y_));
assert(std::isfinite(C.pos_.x) and std::isfinite(C.pos_.y));
ret.push_back(C);
}
return ret;
@ -1055,7 +1055,7 @@ std::vector<region_distribution::movable_cell> region_distribution::export_sprea
float_t region_distribution::region::cost() const{
float_t res = 0.0;
for(cell_ref const C : cell_references_){
res += (std::abs(C.pos_.x_-pos_.x_) + std::abs(C.pos_.y_-pos_.y_)) * static_cast<float_t>(C.allocated_capacity_);
res += (std::abs(C.pos_.x-pos_.x) + std::abs(C.pos_.y-pos_.y)) * static_cast<float_t>(C.allocated_capacity_);
}
return res;
}

28
coloquinte/src/row_opt.cxx
View File

@ -180,10 +180,10 @@ Hnet_group get_B2B_netgroup(netlist const & circuit, detailed_placement const &
Hnet_group ret;
for(index_t c : cells)
ret.cell_widths.push_back(circuit.get_cell(c).size.x_);
ret.cell_widths.push_back(circuit.get_cell(c).size.x);
for(index_t n : involved_nets){
std::vector<pin_1D> cur_pins = get_pins_1D(circuit, pl.plt_, n).x_;
std::vector<pin_1D> cur_pins = get_pins_1D(circuit, pl.plt_, n).x;
for(pin_1D & p : cur_pins){
auto it = std::lower_bound(cells_in_row.begin(), cells_in_row.end(), p.cell_ind);
if(it != cells_in_row.end() and it->cell_ind == p.cell_ind){
@ -206,7 +206,7 @@ Hnet_group get_RSMT_netgroup(netlist const & circuit, detailed_placement const &
Hnet_group ret;
for(index_t c : cells)
ret.cell_widths.push_back(circuit.get_cell(c).size.x_);
ret.cell_widths.push_back(circuit.get_cell(c).size.x);
for(index_t n : involved_nets){
auto vpins = get_pins_2D(circuit, pl.plt_, n);
@ -223,7 +223,7 @@ Hnet_group get_RSMT_netgroup(netlist const & circuit, detailed_placement const &
std::vector<point<int_t> > pin_locations;
for(auto p : vpins)
pin_locations.push_back(p.pos);
auto const Htopo = get_RSMT_topology(pin_locations, 8).x_;
auto const Htopo = get_RSMT_topology(pin_locations, 8).x;
// In the horizontal topology, we transform the parts of the tree that are on the row into HPWL subnets
// Two pins sharing an edge are in the same subnet if one of them is on the row: use union-find
@ -432,7 +432,7 @@ std::vector<std::pair<int_t, int_t> > get_cell_ranges(netlist const & circuit, d
std::vector<std::pair<int_t, int_t> > lims;
for(index_t i=0; i+1<cells.size(); ++i){
assert(pl.plt_.positions_[cells[i]].x_ + circuit.get_cell(cells[i]).size.x_ <= pl.plt_.positions_[cells[i+1]].x_);
assert(pl.plt_.positions_[cells[i]].x + circuit.get_cell(cells[i]).size.x <= pl.plt_.positions_[cells[i+1]].x);
}
// Extreme limits, except macros are allowed to be beyond the limit of the placement area
@ -442,13 +442,13 @@ std::vector<std::pair<int_t, int_t> > get_cell_ranges(netlist const & circuit, d
for(index_t OSRP_cell : cells){
auto attr = circuit.get_cell(OSRP_cell).attributes;
auto cur_lim = std::pair<int_t, int_t>(lower_lim, upper_lim);
int_t pos = pl.plt_.positions_[OSRP_cell].x_;
int_t pos = pl.plt_.positions_[OSRP_cell].x;
if( (attr & XMovable) == 0 or pl.cell_height(OSRP_cell) != 1){
cur_lim = std::pair<int_t, int_t>(pos, pos + circuit.get_cell(OSRP_cell).size.x_);
cur_lim = std::pair<int_t, int_t>(pos, pos + circuit.get_cell(OSRP_cell).size.x);
}
else{
assert(pos >= lower_lim);
assert(pos + circuit.get_cell(OSRP_cell).size.x_ <= upper_lim);
assert(pos + circuit.get_cell(OSRP_cell).size.x <= upper_lim);
}
lims.push_back(cur_lim);
}
@ -486,8 +486,8 @@ void OSRP_generic(netlist const & circuit, detailed_placement & pl){
std::vector<int> flipped;
optimize_noncvx_sequence(nets, no_permutation, final_positions, flipped, flippability, lims);
for(index_t i=0; i<cells.size(); ++i){
bool old_orient = pl.plt_.orientations_[cells[i]].x_;
pl.plt_.orientations_[cells[i]].x_ = flipped[i] ? not old_orient : old_orient;
bool old_orient = pl.plt_.orientations_[cells[i]].x;
pl.plt_.orientations_[cells[i]].x = flipped[i] ? not old_orient : old_orient;
}
}
else{
@ -496,7 +496,7 @@ void OSRP_generic(netlist const & circuit, detailed_placement & pl){
// Update the positions and orientations
for(index_t i=0; i<cells.size(); ++i){
pl.plt_.positions_[cells[i]].x_ = final_positions[i];
pl.plt_.positions_[cells[i]].x = final_positions[i];
}
}
} // Iteration on the rows
@ -560,10 +560,10 @@ void swaps_row_generic(netlist const & circuit, detailed_placement & pl, index_t
for(index_t i=0; i<cells.size(); ++i){
index_t r_ind = best_permutation[i]; // In the row from in the Hnet_group
new_cell_order[r_ind] = cells[i];
pl.plt_.positions_[cells[i]].x_ = best_positions[r_ind];
pl.plt_.positions_[cells[i]].x = best_positions[r_ind];
if(NON_CONVEX){
bool old_orient = pl.plt_.orientations_[cells[i]].x_;
pl.plt_.orientations_[cells[i]].x_ = best_flippings[r_ind] ? not old_orient : old_orient;
bool old_orient = pl.plt_.orientations_[cells[i]].x;
pl.plt_.orientations_[cells[i]].x = best_flippings[r_ind] ? not old_orient : old_orient;
}
}

56
coloquinte/src/topologies.cxx
View File

@ -34,17 +34,17 @@ template<int pin_cnt>
int_t Hconnectivity<pin_cnt>::get_wirelength(std::array<point<int_t>, pin_cnt> const sorted_points) const{
std::array<minmax_t, pin_cnt-2> minmaxs;
for(index_t i=0; i<pin_cnt-2; ++i){
minmaxs[i] = minmax_t(sorted_points[i+1].y_, sorted_points[i+1].y_);
minmaxs[i] = minmax_t(sorted_points[i+1].y, sorted_points[i+1].y);
}
std::uint8_t b_con = extremes & 15u, e_con = extremes >> 4;
minmaxs[b_con].merge(sorted_points.front() .y_);
minmaxs[e_con].merge(sorted_points.back() .y_);
minmaxs[b_con].merge(sorted_points.front() .y);
minmaxs[e_con].merge(sorted_points.back() .y);
for(std::uint8_t const E : connexions){
minmaxs[(E >> 4)].merge(minmaxs[(E & 15u)]);
}
int_t cost = sorted_points.back().x_ - sorted_points.front().x_ + sorted_points[b_con+1].x_ - sorted_points[e_con+1].x_;
int_t cost = sorted_points.back().x - sorted_points.front().x + sorted_points[b_con+1].x - sorted_points[e_con+1].x;
for(std::uint8_t const E : connexions){
cost += std::abs(sorted_points[(E >> 4) +1].x_ - sorted_points[(E & 15u) +1].x_);
cost += std::abs(sorted_points[(E >> 4) +1].x - sorted_points[(E & 15u) +1].x);
}
for(index_t i=0; i<pin_cnt-2; ++i){
cost += (minmaxs[i].max - minmaxs[i].min);
@ -84,14 +84,14 @@ int_t get_wirelength_from_sorted(std::vector<point<int_t> > const & pins, std::a
std::int64_t get_wirelength_from_topo(std::vector<point<int_t> > const & points, std::vector<std::pair<index_t, index_t> > Htopo){
std::vector<minmax_t> minmaxs(points.size());
for(index_t i=0; i<points.size(); ++i){
minmaxs[i] = minmax_t(points[i].y_, points[i].y_);
minmaxs[i] = minmax_t(points[i].y, points[i].y);
}
for(auto const E : Htopo){
minmaxs[E.second].merge(minmaxs[E.first]);
}
std::int64_t cost = 0;
for(edge_t const E : Htopo){
cost += std::abs(points[E.first].x_ - points[E.second].x_);
cost += std::abs(points[E.first].x - points[E.second].x);
}
for(index_t i=0; i<points.size(); ++i){
cost += (minmaxs[i].max - minmaxs[i].min);
@ -133,7 +133,7 @@ std::vector<edge_t> get_vertical_topology(std::vector<point<int_t> > pins, std::
ipoints[i] = indexed_pt(pins[i], i);
}
std::sort(ipoints.begin(), ipoints.end(), [](indexed_pt a , indexed_pt b){return a.y_ < b.y_; });
std::sort(ipoints.begin(), ipoints.end(), [](indexed_pt a , indexed_pt b){return a.y < b.y; });
// First pin with y ordering
std::vector<index_t> min_y_pin(pins.size());
@ -222,19 +222,19 @@ inline void northeast_octant_neighbours(std::vector<point<int_t> > pins, std::ve
}
std::sort(point_list.begin(), point_list.end(),
[](indexed_pt const a, indexed_pt const b){ return a.x_ + a.y_ < b.x_ + b.y_; }
[](indexed_pt const a, indexed_pt const b){ return a.x + a.y < b.x + b.y; }
);
// Decreasing order of x and y; multiset not necessary because no two elements have same coordinate
std::set<indexed_pt, std::function<bool (indexed_pt const, indexed_pt const)> >
active_upper_octant([](indexed_pt const a, indexed_pt const b)->bool{return a.x_ > b.x_;}),
active_lower_octant([](indexed_pt const a, indexed_pt const b)->bool{return a.y_ > b.y_;});
active_upper_octant([](indexed_pt const a, indexed_pt const b)->bool{return a.x > b.x;}),
active_lower_octant([](indexed_pt const a, indexed_pt const b)->bool{return a.y > b.y;});
for(indexed_pt const current : point_list){
{ // North to north-east region
auto first_it = active_upper_octant.lower_bound(current); // Largest x with x <= current.x
auto it = first_it;
for(; it != active_upper_octant.end() && it->x_ - it->y_ >= current.x_ - current.y_; ++it){
for(; it != active_upper_octant.end() && it->x - it->y >= current.x - current.y; ++it){
edges.push_back(std::pair<index_t, index_t>(current.index, it->index));
}
if(first_it != active_upper_octant.end()){ active_upper_octant.erase(first_it, it); }
@ -243,7 +243,7 @@ inline void northeast_octant_neighbours(std::vector<point<int_t> > pins, std::ve
{ // North-east to east region
auto first_it = active_lower_octant.lower_bound(current); // Largest y with y <= current.y
auto it = first_it;
for(; it != active_lower_octant.end() && it->y_ - it->x_ >= current.y_ - current.x_; ++it){
for(; it != active_lower_octant.end() && it->y - it->x >= current.y - current.x; ++it){
edges.push_back(std::pair<index_t, index_t>(current.index, it->index));
}
if(first_it != active_lower_octant.end()){ active_lower_octant.erase(first_it, it); }
@ -255,7 +255,7 @@ inline void northeast_octant_neighbours(std::vector<point<int_t> > pins, std::ve
// Gets the nearest octant neighbour for each point in the south-east quadrant
inline void southeast_octant_neighbours(std::vector<point<int_t> > pins, std::vector<std::pair<index_t, index_t> > & edges){
for(auto & pin : pins){
pin.y_ = - pin.y_;
pin.y = - pin.y;
}
northeast_octant_neighbours(pins, edges);
}
@ -336,7 +336,7 @@ std::vector<edge_t> get_big_horizontal_topology_from_sorted(std::vector<point<in
std::vector<point<int_t> > inverted_coords = pins;
for(point<int_t> & pt : inverted_coords){
std::swap(pt.x_, pt.y_);
std::swap(pt.x, pt.y);
}
auto Htopo = get_vertical_topology(inverted_coords, Vtopo);
@ -356,7 +356,7 @@ std::vector<edge_t> get_RSMT_horizontal_topology(std::vector<point<int_t> > cons
ipoints[i] = indexed_pt(pins[i], i);
}
auto xpoints=ipoints;
std::sort(xpoints.begin(), xpoints.end(), [](indexed_pt a , indexed_pt b){return a.x_ < b.x_; });
std::sort(xpoints.begin(), xpoints.end(), [](indexed_pt a , indexed_pt b){return a.x < b.x; });
return std::vector<edge_t>{{xpoints[0].index, xpoints[1].index}, {xpoints[1].index, xpoints[2].index}};
}
@ -368,7 +368,7 @@ std::vector<edge_t> get_RSMT_horizontal_topology(std::vector<point<int_t> > cons
for(index_t i=0; i<pins.size(); ++i){
ipoints[i] = indexed_pt(pins[i], i);
}
std::sort(ipoints.begin(), ipoints.end(), [](indexed_pt a , indexed_pt b){return a.x_ < b.x_; });
std::sort(ipoints.begin(), ipoints.end(), [](indexed_pt a , indexed_pt b){return a.x < b.x; });
std::vector<point<int_t> > sorted_pins(pins.size());
for(index_t i=0; i<pins.size(); ++i){
sorted_pins[i] = ipoints[i];
@ -401,7 +401,7 @@ std::vector<std::pair<index_t, index_t> > get_MST_topology(std::vector<point<int
edges.push_back(edge_t(0, 1));
}
if(pins.size() == 3){
auto D = [](point<int_t> a, point<int_t> b){ return std::abs(a.x_ - b.x_) + std::abs(a.y_ - b.y_); };
auto D = [](point<int_t> a, point<int_t> b){ return std::abs(a.x - b.x) + std::abs(a.y - b.y); };
auto dists = std::array<int_t, 3>({D(pins[1], pins[2]), D(pins[1], pins[2]), D(pins[0], pins[1])});
index_t mx = std::max_element(dists.begin(), dists.end()) - dists.begin();
for(index_t i=0; i<3; ++i){
@ -420,7 +420,7 @@ std::vector<std::pair<index_t, index_t> > get_MST_topology(std::vector<point<int
auto edge_length = [&](edge_t E){
point<int_t> p1 = pins[E.first],
p2 = pins[E.second];
return std::abs(p1.x_ - p2.x_) + std::abs(p1.y_ - p2.y_);
return std::abs(p1.x - p2.x) + std::abs(p1.y - p2.y);
};
// Perform Kruskal to get the tree
std::sort(edges.begin(), edges.end(), [&](edge_t a, edge_t b){ return edge_length(a) < edge_length(b); });
@ -444,8 +444,8 @@ std::int64_t MST_length(std::vector<point<int_t> > const & pins){
auto edges = get_MST_topology(pins);
std::int64_t sum = 0;
for(auto E : edges){
sum += std::abs(pins[E.first].x_ - pins[E.second].x_);
sum += std::abs(pins[E.first].y_ - pins[E.second].y_);
sum += std::abs(pins[E.first].x - pins[E.second].x);
sum += std::abs(pins[E.first].y - pins[E.second].y);
}
return sum;
}
@ -454,12 +454,12 @@ std::int64_t RSMT_length(std::vector<point<int_t> > const & pins, index_t exacti
assert(exactitude_limit <= 10 and exactitude_limit >= 3);
if(pins.size() <= 3){
if(pins.size() == 2){
return std::abs(pins[0].x_ - pins[1].x_) + std::abs(pins[0].y_ - pins[1].y_);
return std::abs(pins[0].x - pins[1].x) + std::abs(pins[0].y - pins[1].y);
}
else if(pins.size() == 3){
auto minmaxX = std::minmax_element(pins.begin(), pins.end(), [](point<int_t> a, point<int_t> b){ return a.x_ < b.x_; }),
minmaxY = std::minmax_element(pins.begin(), pins.end(), [](point<int_t> a, point<int_t> b){ return a.y_ < b.y_; });
return (minmaxX.second->x_ - minmaxX.first->x_) + (minmaxY.second->y_ - minmaxY.first->y_);
auto minmaxX = std::minmax_element(pins.begin(), pins.end(), [](point<int_t> a, point<int_t> b){ return a.x < b.x; }),
minmaxY = std::minmax_element(pins.begin(), pins.end(), [](point<int_t> a, point<int_t> b){ return a.y < b.y; });
return (minmaxX.second->x - minmaxX.first->x) + (minmaxY.second->y - minmaxY.first->y);
}
else{
return 0;
@ -467,7 +467,7 @@ std::int64_t RSMT_length(std::vector<point<int_t> > const & pins, index_t exacti
}
else{
std::vector<point<int_t> > points = pins;
std::sort(points.begin(), points.end(), [](point<int_t> a , point<int_t> b){return a.x_ < b.x_; });
std::sort(points.begin(), points.end(), [](point<int_t> a , point<int_t> b){return a.x < b.x; });
if(points.size() <= exactitude_limit){
switch(points.size()){
@ -517,9 +517,9 @@ point<std::vector<std::pair<index_t, index_t> > > get_RSMT_topology(std::vector<
ipoints[i] = indexed_pt(pins[i], i);
}
auto xpoints=ipoints;
std::sort(xpoints.begin(), xpoints.end(), [](indexed_pt a , indexed_pt b){return a.x_ < b.x_; });
std::sort(xpoints.begin(), xpoints.end(), [](indexed_pt a , indexed_pt b){return a.x < b.x; });
auto ypoints=ipoints;
std::sort(ypoints.begin(), ypoints.end(), [](indexed_pt a , indexed_pt b){return a.y_ < b.y_; });
std::sort(ypoints.begin(), ypoints.end(), [](indexed_pt a , indexed_pt b){return a.y < b.y; });
return point<std::vector<edge_t> >{{{xpoints[0].index, xpoints[1].index}, {xpoints[1].index, xpoints[2].index}}, {{ypoints[0].index, ypoints[1].index}, {ypoints[1].index, ypoints[2].index}}};
}

4
crlcore/src/ccore/AllianceLibrary.cpp
View File

@ -132,7 +132,7 @@ namespace CRL {
, DataBase::CreateLib|DataBase::WarnCreateLib );
AllianceLibrary* aLibrary = NULL;
cdebug.log(19) << "| " << libDbPath << " : " << library << endl;
cdebug_log(19,0) << "| " << libDbPath << " : " << library << endl;
if (library) {
aLibrary = af->getAllianceLibrary( library );
@ -151,7 +151,7 @@ namespace CRL {
if (not library) library = aLibrary->getLibrary();
}
cdebug.log(19) << "| Associates to: " << aLibrary << endl;
cdebug_log(19,0) << "| Associates to: " << aLibrary << endl;
if (aLibrary->getLibrary() != library) {
cerr << Warning( "JsonAllianceLibrary::toData(): Underlying Hurricane Library discrepency for \"%s\".\n"

2
crlcore/src/ccore/Catalog.cpp
View File

@ -436,7 +436,7 @@ namespace CRL {
Catalog::State* state = get<Catalog::State*>( stack, "_state" );
CatalogProperty* property = NULL;
cdebug.log(19) << "topDBo:" << dbo << endl;
cdebug_log(19,0) << "topDBo:" << dbo << endl;
Cell* cell = dynamic_cast<Cell*>( dbo );
if (cell) {

10
crlcore/src/ccore/RoutingLayerGauge.cpp
View File

@ -207,17 +207,17 @@ namespace CRL {
unsigned RoutingLayerGauge::getTrackIndex ( DbU::Unit start, DbU::Unit stop, DbU::Unit position, unsigned mode ) const
{
cdebug.log(100,1) << "RoutingLayerGauge::getTrackIndex ( " << position << " )" << endl;
cdebug_log(100,1) << "RoutingLayerGauge::getTrackIndex ( " << position << " )" << endl;
long modulo;
long depth;
divide ( position-start, depth, modulo );
cdebug.log(100) << "depth := " << depth << endl;
cdebug_log(100,0) << "depth := " << depth << endl;
if ( depth < 0 ) {
cdebug.tabw(100,-1);
cdebug_tabw(100,-1);
return 0;
// throw Error ( negativeIndex
@ -239,7 +239,7 @@ namespace CRL {
unsigned int tracksNumber = getTrackNumber(start,stop);
if ( (unsigned)depth >= tracksNumber ) {
cdebug.tabw(100,-1);
cdebug_tabw(100,-1);
return (tracksNumber > 0) ? tracksNumber-1 : 0;
// throw Error ( overflowIndex
// , getString(this).c_str()
@ -249,7 +249,7 @@ namespace CRL {
// );
}
cdebug.tabw(100,-1);
cdebug_tabw(100,-1);
return depth;
}

24
crlcore/src/ccore/bookshelf/BookshelfParser.cpp
View File

@ -318,7 +318,7 @@ Name BKParser::getNewNetName()
bool BKParser::isNumber ( char* token ) {
cdebug.log(100) << "isNumber = " << token;
cdebug_log(100,0) << "isNumber = " << token;
unsigned i = 0;
char tok;
@ -330,7 +330,7 @@ bool BKParser::isNumber ( char* token ) {
}
bool BKParser::isFloat ( char* token ) {
cdebug.log(100) << "isFloat = " << token;
cdebug_log(100,0) << "isFloat = " << token;
unsigned i = 0;
char tok;
@ -343,7 +343,7 @@ bool BKParser::isFloat ( char* token ) {
}
bool BKParser::isName ( char* token ) {
cdebug.log(100) << "isName = " << token;
cdebug_log(100,0) << "isName = " << token;
unsigned i = 0;
char tok;
@ -358,7 +358,7 @@ bool BKParser::isName ( char* token ) {
}
bool BKParser::isSymetry ( char* token ) {
cdebug.log(100) << "isSymetry = " << token;
cdebug_log(100,0) << "isSymetry = " << token;
if ( ( ( token[0] == 'X' ) && ( token[1] == char(0) ) )
|| ( ( token[0] == 'Y' ) && ( token[1] == char(0) ) )
|| ( ( token[0] == 'R' ) && ( token[1] == '9' ) && ( token[2] == '0' ) && ( token[3] == char(0) ) ) )
@ -366,7 +366,7 @@ bool BKParser::isSymetry ( char* token ) {
return false;
}
bool BKParser::isDirection ( char* token ) {
cdebug.log(100) << "isDirection = " << token;
cdebug_log(100,0) << "isDirection = " << token;
if ( ( ( token[0] == 'I' ) || ( token[0] == 'O' ) || ( token[0] == 'B' ) ) && ( token[1] == char(0) ) )
return true;
@ -381,7 +381,7 @@ bool BKParser::ScanAux ()
// The Aux record looks like :
// RowBasedPlacement : <cell_name>.nodes <cell_name>.nets <cell_name>.wts <cell_name>.pl <cell_name>.scl
// **********************************************************************************************************
cdebug.log(100) << "ScanAux = " << _buffer;
cdebug_log(100,0) << "ScanAux = " << _buffer;
// ***********************
// Patterns initialization
@ -441,7 +441,7 @@ bool BKParser::ScanNum ( unsigned& num )
// The NodeNum record looks like :
// NumNodes : <num>
// *******************************
cdebug.log(100) << "ScanNum = " << _buffer;
cdebug_log(100,0) << "ScanNum = " << _buffer;
char *p_type, *p_num;
if ( ( ( p_type = strtok ( _buffer, "\t \n:" ) ) != NULL ) &&
@ -460,7 +460,7 @@ bool BKParser::ScanDegree ( unsigned& degree, Name& netName )
// The NetDregree record looks like :
// NetDegree : <degree> [netName]
// **********************************
cdebug.log(100) << "ScanDegree = " << _buffer;
cdebug_log(100,0) << "ScanDegree = " << _buffer;
bool mDegree = false;
bool mName = false;
@ -502,7 +502,7 @@ bool BKParser::ScanNodes ( Name& name, DbU::Unit& width, DbU::Unit& height, bool
// The Node record looks like :
// <ins_name> <width> <height> [terminal]
// **************************************
cdebug.log(100) << "ScanNodes = " << _buffer;
cdebug_log(100,0) << "ScanNodes = " << _buffer;
char *p_name, *p_width, *p_height, *p_term;
if ( ( ( p_name = strtok ( _buffer, "\t \n" ) ) != NULL ) &&
@ -528,7 +528,7 @@ bool BKParser::ScanNets ( Name& insName, Net::Direction& dir, DbU::Unit& dx, DbU
// The Net record looks like :
// NetDegree : <degree> <net_name>
// *********************************
cdebug.log(100) << "ScanNets = " << _buffer;
cdebug_log(100,0) << "ScanNets = " << _buffer;
bool mName = false;
bool mDirection = false;
@ -580,7 +580,7 @@ bool BKParser::ScanWts ( Name& name, unsigned& weight )
// The Weight record looks like :
// <ins_name> <weight>
// ******************************
cdebug.log(100) << "ScanWts = " << _buffer;
cdebug_log(100,0) << "ScanWts = " << _buffer;
//char *p_x, *p_y, *p_model, *p_name, *p_transf;
@ -622,7 +622,7 @@ bool BKParser::ScanPl ( Name& name, DbU::Unit& x, DbU::Unit& y, Transformation::
// The Placement record looks like :
// <ins_name> <x> <y> : <orient> [FIXED]
// *************************************
cdebug.log(100) << "ScanPl = " << _buffer;
cdebug_log(100,0) << "ScanPl = " << _buffer;
char *p_name, *p_x, *p_y, *p_orient, *p_fixed;
if ( ( ( p_name = strtok ( _buffer, "\t \n" ) ) != NULL ) &&

2
crlcore/src/ccore/toolbox/RoutingPads.cpp
View File

@ -208,7 +208,7 @@ void createPlacedRoutingPadsAndPinsRing ( Cell* top_cell )
netOccurrence = Occurrence(net);
for_each_occurrence ( plugOccurrence, HyperNet(netOccurrence).getLeafPlugOccurrences() )
{
cdebug.log(109,1) << "Creating Routing Pad " << plugOccurrence << endl;
cdebug_log(109,1) << "Creating Routing Pad " << plugOccurrence << endl;
cerr << RoutingPad::create ( net, plugOccurrence, RoutingPad::BiggestArea ) << endl;
//ltraceout(58);
end_for;

2
crlcore/src/pyCRL/PyAcmSigda.cpp
View File

@ -55,7 +55,7 @@ extern "C" {
static PyObject* PyAcmSigda_load ( PyObject*, PyObject* args )
{
cdebug.log(30) << "PyAcmSigda_load()" << endl;
cdebug_log(30,0) << "PyAcmSigda_load()" << endl;
Cell* cell = NULL;

30
crlcore/src/pyCRL/PyAllianceFramework.cpp
View File

@ -70,7 +70,7 @@ extern "C" {
static PyObject* PyAllianceFramework_create ( PyObject*, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_create()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_create()" << endl;
AllianceFramework* af = NULL;
PyAllianceFramework* pyAf = NULL;
@ -96,7 +96,7 @@ extern "C" {
static PyObject* PyAllianceFramework_get ( PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_get()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_get()" << endl;
AllianceFramework* af = NULL;
PyAllianceFramework* pyAf = NULL;
@ -116,7 +116,7 @@ extern "C" {
static PyObject* PyAllianceFramework_getEnvironment ( PyAllianceFramework* self )
{
cdebug.log(30) << "PyAllianceFramework_getEnvironment ()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_getEnvironment ()" << endl;
Environment* env = NULL;
@ -134,7 +134,7 @@ extern "C" {
static PyObject* PyAllianceFramework_getLibrary ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_getLibrary()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_getLibrary()" << endl;
Library* lib = NULL;
@ -164,7 +164,7 @@ extern "C" {
static PyObject* PyAllianceFramework_getAllianceLibrary ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_getAllianceLibrary()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_getAllianceLibrary()" << endl;
AllianceLibrary* alib = NULL;
@ -199,7 +199,7 @@ extern "C" {
static PyObject* PyAllianceFramework_getCell ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_getCell ()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_getCell ()" << endl;
char* name = NULL;
Cell* cell = NULL;
@ -222,7 +222,7 @@ extern "C" {
static PyObject* PyAllianceFramework_saveCell ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_saveCell ()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_saveCell ()" << endl;
HTRY
@ -243,7 +243,7 @@ extern "C" {
static PyObject* PyAllianceFramework_createCell ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_createCell ()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_createCell ()" << endl;
char* name = NULL;
Cell* cell = NULL;
@ -265,7 +265,7 @@ extern "C" {
static PyObject* PyAllianceFramework_createLibrary ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_createLibrary()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_createLibrary()" << endl;
AllianceLibrary* alib = NULL;
string libName = "";
@ -304,7 +304,7 @@ extern "C" {
static PyObject* PyAllianceFramework_isPad ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_isPad ()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_isPad ()" << endl;
char* name = NULL;
@ -325,7 +325,7 @@ extern "C" {
static PyObject* PyAllianceFramework_addRoutingGauge ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_addRoutingGauge ()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_addRoutingGauge ()" << endl;
HTRY
METHOD_HEAD("AllianceFramework.addRoutingGauge()")
@ -341,7 +341,7 @@ extern "C" {
static PyObject* PyAllianceFramework_getRoutingGauge ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_getRoutingGauge ()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_getRoutingGauge ()" << endl;
RoutingGauge* rg = NULL;
@ -365,7 +365,7 @@ extern "C" {
static PyObject* PyAllianceFramework_addCellGauge ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_addCellGauge ()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_addCellGauge ()" << endl;
HTRY
METHOD_HEAD("AllianceFramework.addCellGauge()")
@ -381,7 +381,7 @@ extern "C" {
static PyObject* PyAllianceFramework_getCellGauge ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_getCellGauge ()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_getCellGauge ()" << endl;
CellGauge* rg = NULL;
@ -405,7 +405,7 @@ extern "C" {
static PyObject* PyAllianceFramework_loadLibraryCells ( PyAllianceFramework* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceFramework_loadLibraryCells()" << endl;
cdebug_log(30,0) << "PyAllianceFramework_loadLibraryCells()" << endl;
unsigned int count = 0;

6
crlcore/src/pyCRL/PyAllianceLibrary.cpp
View File

@ -59,7 +59,7 @@ extern "C" {
static PyObject* PyAllianceLibrary_getLibrary ( PyAllianceLibrary* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceLibrary_getLibrary()" << endl;
cdebug_log(30,0) << "PyAllianceLibrary_getLibrary()" << endl;
Library* lib = NULL;
@ -74,7 +74,7 @@ extern "C" {
static PyObject* PyAllianceLibrary_getPath ( PyAllianceLibrary* self, PyObject* args )
{
cdebug.log(30) << "PyAllianceLibrary_getPath()" << endl;
cdebug_log(30,0) << "PyAllianceLibrary_getPath()" << endl;
HTRY
METHOD_HEAD("AllianceLibrary.getPath()")
@ -114,7 +114,7 @@ extern "C" {
DirectHashMethod(PyAllianceLibrary_Hash, PyAllianceLibrary)
extern void PyAllianceLibrary_LinkPyType() {
cdebug.log(30) << "PyAllianceLibrary_LinkType()" << endl;
cdebug_log(30,0) << "PyAllianceLibrary_LinkType()" << endl;
PyTypeAllianceLibrary.tp_dealloc = (destructor) PyAllianceLibrary_DeAlloc;
PyTypeAllianceLibrary.tp_repr = (reprfunc) PyAllianceLibrary_Repr;

4
crlcore/src/pyCRL/PyBanner.cpp
View File

@ -57,7 +57,7 @@ extern "C" {
static PyObject* PyBanner_new ( PyTypeObject* type, PyObject* args, PyObject* kwArgs )
{
cdebug.log(30) << "PyBanner_new()" << endl;
cdebug_log(30,0) << "PyBanner_new()" << endl;
Banner* banner = NULL;
PyBanner* pyBanner = (PyBanner*)type->tp_alloc(type,0);
@ -180,7 +180,7 @@ extern "C" {
DirectHashMethod(PyBanner_Hash, PyBanner)
extern void PyBanner_LinkPyType() {
cdebug.log(30) << "PyBanner_LinkType()" << endl;
cdebug_log(30,0) << "PyBanner_LinkType()" << endl;
PyTypeBanner.tp_new = PyBanner_new;
PyTypeBanner.tp_dealloc = (destructor)PyBanner_DeAlloc;

2
crlcore/src/pyCRL/PyBlif.cpp
View File

@ -55,7 +55,7 @@ extern "C" {
static PyObject* PyBlif_load ( PyObject*, PyObject* args )
{
cdebug.log(30) << "PyBlif_load()" << endl;
cdebug_log(30,0) << "PyBlif_load()" << endl;
Cell* cell = NULL;

6
crlcore/src/pyCRL/PyCRL.cpp
View File

@ -73,7 +73,7 @@ extern "C" {
static PyObject* PyVhdl_destroyAllVHDL ( PyObject* module )
{
cdebug.log(30) << "PyVhdl_destroyAllVHDL()" << endl;
cdebug_log(30,0) << "PyVhdl_destroyAllVHDL()" << endl;
HTRY
EntityExtension::destroyAll();
@ -103,7 +103,7 @@ extern "C" {
// Module Initialization : "initCRL ()"
DL_EXPORT(void) initCRL () {
cdebug.log(30) << "initCRL()" << endl;
cdebug_log(30,0) << "initCRL()" << endl;
PyBanner_LinkPyType ();
PyCatalogState_LinkPyType ();
@ -197,7 +197,7 @@ extern "C" {
//PyObject* dictionnary = PyModule_GetDict ( module );
//DbULoadConstants ( dictionnary );
cdebug.log(30) << "CRL.so loaded " << (void*)&typeid(string) << endl;
cdebug_log(30,0) << "CRL.so loaded " << (void*)&typeid(string) << endl;
}

2
crlcore/src/pyCRL/PyCatalogState.cpp
View File

@ -114,7 +114,7 @@ extern "C" {
DirectHashMethod(PyCatalogState_Hash, PyCatalogState)
extern void PyCatalogState_LinkPyType() {
cdebug.log(30) << "PyCatalogState_LinkType()" << endl;
cdebug_log(30,0) << "PyCatalogState_LinkType()" << endl;
PyTypeCatalogState.tp_dealloc = (destructor) PyCatalogState_DeAlloc;
PyTypeCatalogState.tp_compare = (cmpfunc) PyCatalogState_Cmp;
PyTypeCatalogState.tp_repr = (reprfunc) PyCatalogState_Repr;

2
crlcore/src/pyCRL/PyCellGauge.cpp
View File

@ -61,7 +61,7 @@ extern "C" {
static PyObject* PyCellGauge_create ( PyObject*, PyObject* args )
{
cdebug.log(30) << "PyCellGauge_create()" << endl;
cdebug_log(30,0) << "PyCellGauge_create()" << endl;
CellGauge* cg = NULL;
PyCellGauge* pyCg = NULL;

6
crlcore/src/pyCRL/PyEnvironment.cpp
View File

@ -67,7 +67,7 @@ extern "C" {
PyObject* PyEnvironment_addSYSTEM_LIBRARY ( PyEnvironment* self, PyObject* args, PyObject* kwArgs )
{
cdebug.log(30) << "PyEnvironment_addSYSTEM_LIBRARY()" << endl;
cdebug_log(30,0) << "PyEnvironment_addSYSTEM_LIBRARY()" << endl;
HTRY
METHOD_HEAD("Environment.addSYSTEM_LIBRARY()")
@ -113,7 +113,7 @@ extern "C" {
PyObject* PyEnvironment_getLIBRARYPath ( PyEnvironment* self, PyObject* args )
{
cdebug.log(30) << "PyEnvironment_getLIBRARYPath()" << endl;
cdebug_log(30,0) << "PyEnvironment_getLIBRARYPath()" << endl;
HTRY
METHOD_HEAD("Environment.getLIBRARYPath()")
@ -265,7 +265,7 @@ extern "C" {
DirectHashMethod(PyEnvironment_Hash, PyEnvironment)
extern void PyEnvironment_LinkPyType() {
cdebug.log(30) << "PyEnvironment_LinkType()" << endl;
cdebug_log(30,0) << "PyEnvironment_LinkType()" << endl;
PyTypeEnvironment.tp_dealloc = (destructor) PyEnvironment_DeAlloc;
PyTypeEnvironment.tp_repr = (reprfunc) PyEnvironment_Repr;

2
crlcore/src/pyCRL/PyIspd05.cpp
View File

@ -56,7 +56,7 @@ extern "C" {
static PyObject* PyIspd05_load ( PyObject*, PyObject* args )
{
cdebug.log(30) << "PyIspd05_load()" << endl;
cdebug_log(30,0) << "PyIspd05_load()" << endl;
Cell* cell = NULL;

20
crlcore/src/pyCRL/PyRoutingGauge.cpp
View File

@ -67,7 +67,7 @@ extern "C" {
static PyObject* PyRoutingGauge_create ( PyObject*, PyObject* args )
{
cdebug.log(30) << "PyRoutingGauge_create()" << endl;
cdebug_log(30,0) << "PyRoutingGauge_create()" << endl;
RoutingGauge* rg = NULL;
PyRoutingGauge* pyRg = NULL;
@ -96,7 +96,7 @@ extern "C" {
static PyObject* PyRoutingGauge_getTechnology ( PyRoutingGauge* self )
{
cdebug.log(30) << "PyRoutingGauge_getTechnology()" << endl;
cdebug_log(30,0) << "PyRoutingGauge_getTechnology()" << endl;
Technology* technology = NULL;
@ -111,7 +111,7 @@ extern "C" {
static PyObject* PyRoutingGauge_getDepth ( PyRoutingGauge* self )
{
cdebug.log(30) << "PyRoutingGauge_getDepth()" << endl;
cdebug_log(30,0) << "PyRoutingGauge_getDepth()" << endl;
size_t depth = 0;
@ -126,7 +126,7 @@ extern "C" {
static PyObject* PyRoutingGauge_getLayerDepth ( PyRoutingGauge* self, PyObject* args )
{
cdebug.log(30) << "PyRoutingGauge_getLayerDepth()" << endl;
cdebug_log(30,0) << "PyRoutingGauge_getLayerDepth()" << endl;
size_t depth = 0;
@ -153,7 +153,7 @@ extern "C" {
static PyObject* PyRoutingGauge_getLayerGauge ( PyRoutingGauge* self, PyObject* args )
{
cdebug.log(30) << "PyRoutingGauge_getLayerGauge()" << endl;
cdebug_log(30,0) << "PyRoutingGauge_getLayerGauge()" << endl;
RoutingLayerGauge* rlg = NULL;
@ -188,7 +188,7 @@ extern "C" {
static PyObject* PyRoutingGauge_getLayerDirection ( PyRoutingGauge* self, PyObject* args )
{
cdebug.log(30) << "PyRoutingGauge_getLayerDirection()" << endl;
cdebug_log(30,0) << "PyRoutingGauge_getLayerDirection()" << endl;
unsigned int direction = 0;
@ -219,7 +219,7 @@ extern "C" {
static PyObject* PyRoutingGauge_getLayerPitch ( PyRoutingGauge* self, PyObject* args )
{
cdebug.log(30) << "PyRoutingGauge_getLayerPitch()" << endl;
cdebug_log(30,0) << "PyRoutingGauge_getLayerPitch()" << endl;
DbU::Unit pitch = 0;
@ -250,7 +250,7 @@ extern "C" {
static PyObject* PyRoutingGauge_getRoutingLayer ( PyRoutingGauge* self, PyObject* args )
{
cdebug.log(30) << "PyRoutingGauge_getRoutingLayer()" << endl;
cdebug_log(30,0) << "PyRoutingGauge_getRoutingLayer()" << endl;
Layer* layer = NULL;
@ -277,7 +277,7 @@ extern "C" {
static PyObject* PyRoutingGauge_getContactLayer ( PyRoutingGauge* self, PyObject* args )
{
cdebug.log(30) << "PyRoutingGauge_getContactLayer()" << endl;
cdebug_log(30,0) << "PyRoutingGauge_getContactLayer()" << endl;
Layer* layer = NULL;
@ -304,7 +304,7 @@ extern "C" {
PyObject* PyRoutingGauge_addLayerGauge ( PyRoutingGauge* self, PyObject* args )
{
cdebug.log(30) << "PyRoutingGauge_addLayerGauge()" << endl;
cdebug_log(30,0) << "PyRoutingGauge_addLayerGauge()" << endl;
HTRY
METHOD_HEAD("RoutingGauge.addLayerGauge()")

12
crlcore/src/pyCRL/PyRoutingLayerGauge.cpp
View File

@ -60,7 +60,7 @@ extern "C" {
static PyObject* PyRoutingLayerGauge_create ( PyObject*, PyObject* args )
{
cdebug.log(30) << "PyRoutingLayerGauge_create()" << endl;
cdebug_log(30,0) << "PyRoutingLayerGauge_create()" << endl;
RoutingLayerGauge* rlg = NULL;
PyRoutingLayerGauge* pyRlg = NULL;
@ -140,7 +140,7 @@ extern "C" {
static PyObject* PyRoutingLayerGauge_getLayer ( PyRoutingLayerGauge* self )
{
cdebug.log(30) << "PyRoutingLayerGauge_getLayer()" << endl;
cdebug_log(30,0) << "PyRoutingLayerGauge_getLayer()" << endl;
Layer* layer = NULL;
@ -155,7 +155,7 @@ extern "C" {
static PyObject* PyRoutingLayerGauge_getBlockageLayer ( PyRoutingLayerGauge* self )
{
cdebug.log(30) << "PyRoutingLayerGauge_getBlockageLayer()" << endl;
cdebug_log(30,0) << "PyRoutingLayerGauge_getBlockageLayer()" << endl;
Layer* layer = NULL;
@ -170,7 +170,7 @@ extern "C" {
static PyObject* PyRoutingLayerGauge_getTrackNumber ( PyRoutingLayerGauge* self, PyObject* args )
{
cdebug.log(30) << "PyRoutingLayerGauge_getTrackNumber()" << endl;
cdebug_log(30,0) << "PyRoutingLayerGauge_getTrackNumber()" << endl;
unsigned int trackNumber = 0;
@ -194,7 +194,7 @@ extern "C" {
static PyObject* PyRoutingLayerGauge_getTrackIndex ( PyRoutingLayerGauge* self, PyObject* args )
{
cdebug.log(30) << "PyRoutingLayerGauge_getTrackIndex()" << endl;
cdebug_log(30,0) << "PyRoutingLayerGauge_getTrackIndex()" << endl;
unsigned int trackIndex = 0;
@ -232,7 +232,7 @@ extern "C" {
static PyObject* PyRoutingLayerGauge_getTrackPosition ( PyRoutingLayerGauge* self, PyObject* args )
{
cdebug.log(30) << "PyRoutingLayerGauge_getTrackPosition()" << endl;
cdebug_log(30,0) << "PyRoutingLayerGauge_getTrackPosition()" << endl;
DbU::Unit trackPosition = 0;

2
crlcore/src/pyCRL/PyToolBox.cpp
View File

@ -70,7 +70,7 @@ extern "C" {
extern PyObject* PyToolBox_createPartRing ( PyObject* module, PyObject* args )
{
cdebug.log(30) << "PyToolBox_createPartRing ()" << endl;
cdebug_log(30,0) << "PyToolBox_createPartRing ()" << endl;
HTRY
PyObject* arg0;

6
crlcore/src/pyCRL/PyToolEngine.cpp
View File

@ -46,7 +46,7 @@ extern "C" {
static PyObject* PyToolEngine_get ( PyObject*, PyObject* args, PyObject* kwArgs )
{
cdebug.log(30) << "PyToolEngine_get()" << endl;
cdebug_log(30,0) << "PyToolEngine_get()" << endl;
HTRY
PyObject* pyCell = NULL;
@ -98,7 +98,7 @@ extern "C" {
static PyObject* PyToolEngine_destroyAll ( PyObject* )
{
cdebug.log(30) << "PyToolEngine_destroyAll()" << endl;
cdebug_log(30,0) << "PyToolEngine_destroyAll()" << endl;
HTRY
ToolEngine::destroyAll();
@ -110,7 +110,7 @@ extern "C" {
static PyObject* PyToolEngine_getCell ( PyToolEngine* self )
{
cdebug.log(30) << "PyToolEngine_getCell ()" << endl;
cdebug_log(30,0) << "PyToolEngine_getCell ()" << endl;
Cell* cell = NULL;

20
documentation/UsersGuide/UsersGuide.html
View File

@ -271,15 +271,8 @@ running the <span class="cb">ccb</span> installer.</p>
</ul>
<p>Optional libraries:</p>
<ul class="simple">
<li><a class="reference external" href="https://www.si2.org/">Lemon</a> (used by the detailed placer)</li>
<li>LEF/DEF (from <a class="reference external" href="https://www.si2.org/">SI2</a>)</li>
</ul>
<p>The <span class="sc">Coloquinte</span> component requires the <span class="sc">lemon</span> component from <span class="sc">coin-or</span> (<a class="reference external" href="http://www.coin-or.org/index.html">Coin Or Home</a>).
A repository of <span class="sc">coin-or</span> packages backported from <span class="sc">Fedora</span> 21 is available here:</p>
<ul class="simple">
<li><span class="sc">Scientific Linux 6</span>: <a class="reference external" href="http://ftp.lip6.fr/pub/linux/distributions/slsoc/slsoc/soc/addons/i386/repoview">ftp://pub/linux/distributions/slsoc/slsoc/soc/addons/i386/RPMS</a></li>
<li><span class="sc">Scientific Linux 7</span>: <a class="reference external" href="http://ftp.lip6.fr/pub/linux/distributions/slsoc/soc/7/addons/x86_64/repoview">ftp://pub/linux/distributions/slsoc/soc/7/addons/x86_64/RPMS</a></li>
</ul>
<p>For other distributions, refer to their own packaging system.</p>
<p><span class="raw-html"><hr></span></p>
<div class="section" id="fixed-directory-tree">
@ -824,7 +817,8 @@ parametersTable = \
, ('misc.logMode' , TypeBool , True )
, ('misc.verboseLevel1' , TypeBool , False )
, ('misc.verboseLevel2' , TypeBool , True )
, ('misc.traceLevel' , TypeInt , 1000 )
, ('misc.minTraceLevel' , TypeInt , 0 )
, ('misc.maxTraceLevel' , TypeInt , 0 )
)
# Some ordinary Python script...
@ -1568,12 +1562,16 @@ sequences</td>
</tr>
<tr><td colspan="3"><strong>Development/Debug Parameters</strong></td>
</tr>
<tr><td rowspan="2"><tt class="docutils literal">misc.traceLevel</tt></td>
<tr><td><tt class="docutils literal">misc.minTraceLevel</tt></td>
<td>TypeInt</td>
<td><span class="cb">0</span></td>
</tr>
<tr><td colspan="2">Display trace information <em>below</em> that level
(<span class="cb">ltrace</span> stream)</td>
<tr><td rowspan="2"><tt class="docutils literal">misc.maxTraceLevel</tt></td>
<td>TypeInt</td>
<td><span class="cb">0</span></td>
</tr>
<tr><td colspan="2">Display trace information <em>between</em> those two
levels (<span class="cb">cdebug</span> stream)</td>
</tr>
<tr><td rowspan="2"><tt class="docutils literal">misc.catchCore</tt></td>
<td>TypeBool</td>

668
documentation/UsersGuide/UsersGuide.pdf
View File

File diff suppressed because it is too large Load Diff

10
documentation/UsersGuide/UsersGuide.rst
View File

@ -27,8 +27,6 @@
.. |FC13| replace:: :sc:`fc13`
.. |Debian| replace:: :sc:`Debian`
.. |Ubuntu| replace:: :sc:`Ubuntu`
.. |LEMON| replace:: :sc:`lemon`
.. |Coin-Or| replace:: :sc:`coin-or`
.. |Alexandre| replace:: :sc:`Alexandre`
.. |Belloeil| replace:: :sc:`Belloeil`
@ -128,7 +126,6 @@
.. _Box Router: http://www.cerc.utexas.edu/~thyeros/boxrouter/boxrouter.htm
.. _hMETIS: http://glaros.dtc.umn.edu/gkhome/views/metis
.. _Knik Thesis: http://www-soc.lip6.fr/en/users/damiendupuis/PhD/
.. _Coin Or Home: http://www.coin-or.org/index.html
.. _RapidJSON: http://miloyip.github.io/rapidjson/
.. _coriolis2-1.0.2049-1.slsoc6.i686.rpm: http://asim.lip6.fr/pub/coriolis/2.0/coriolis2-1.0.2049-1.slsoc6.i686.rpm
@ -377,15 +374,8 @@ Building documentation prerequisites:
Optional libraries:
* `Lemon <https://www.si2.org/>`_ (used by the detailed placer)
* LEF/DEF (from `SI2 <https://www.si2.org/>`_)
The |Coloquinte| component requires the |LEMON| component from |Coin-Or| (`Coin Or Home`_).
A repository of |Coin-Or| packages backported from |Fedora| 21 is available here:
* |SL6|: `ftp://pub/linux/distributions/slsoc/slsoc/soc/addons/i386/RPMS <http://ftp.lip6.fr/pub/linux/distributions/slsoc/slsoc/soc/addons/i386/repoview>`_
* |SL7|: `ftp://pub/linux/distributions/slsoc/soc/7/addons/x86_64/RPMS <http://ftp.lip6.fr/pub/linux/distributions/slsoc/soc/7/addons/x86_64/repoview>`_
For other distributions, refer to their own packaging system.
|newpage|

14
etesian/src/AddFeeds.cpp
View File

@ -115,8 +115,8 @@ namespace {
void Slice::merge ( DbU::Unit source, DbU::Unit target )
{
Interval chunkToMerge = _xspan.getIntersection( Interval(source,target) );
cdebug.log(129) << " Slice::merge() " << " " << chunkToMerge << endl;
cdebug.log(129) << " | " << _getString() << endl;
cdebug_log(129,0) << " Slice::merge() " << " " << chunkToMerge << endl;
cdebug_log(129,0) << " | " << _getString() << endl;
if (chunkToMerge.isEmpty()) return;
@ -126,20 +126,20 @@ namespace {
while ( ichunk != _chunks.end() ) {
if (imerge == _chunks.end()) {
if (chunkToMerge.getVMax() < (*ichunk).getVMin()) {
cdebug.log(129) << " | Insert before " << *ichunk << endl;
cdebug_log(129,0) << " | Insert before " << *ichunk << endl;
imerge = _chunks.insert( ichunk, chunkToMerge );
break;
}
if (chunkToMerge.intersect(*ichunk)) {
cdebug.log(129) << " | Merge with " << *ichunk << endl;
cdebug_log(129,0) << " | Merge with " << *ichunk << endl;
imerge = ichunk;
(*imerge).merge( chunkToMerge );
}
} else {
if (chunkToMerge.getVMax() >= (*ichunk).getVMin()) {
(*imerge).merge( *ichunk );
cdebug.log(129) << " | Absorb (erase) " << *ichunk << endl;
cdebug_log(129,0) << " | Absorb (erase) " << *ichunk << endl;
ichunk = _chunks.erase( ichunk );
continue;
} else
@ -151,8 +151,8 @@ namespace {
if (imerge == _chunks.end()) {
_chunks.insert( ichunk, chunkToMerge );
cdebug.log(129) << " | Insert at end " << DbU::getValueString(_ybottom) << " " << chunkToMerge << endl;
cdebug.log(129) << " | " << _getString() << endl;
cdebug_log(129,0) << " | Insert at end " << DbU::getValueString(_ybottom) << " " << chunkToMerge << endl;
cdebug_log(129,0) << " | " << _getString() << endl;
}
}

2
etesian/src/Configuration.cpp
View File

@ -80,7 +80,7 @@ namespace Etesian {
Configuration::~Configuration ()
{
cdebug.log(129) << "About to delete attribute _cg (CellGauge)." << endl;
cdebug_log(129,0) << "About to delete attribute _cg (CellGauge)." << endl;
_cg->destroy ();
}

20
etesian/src/EtesianEngine.cpp
View File

@ -148,19 +148,19 @@ namespace {
, DbU::Unit pitch
)
{
DbU::Unit tx = position.x_ * pitch;
DbU::Unit ty = position.y_ * pitch;
DbU::Unit tx = position.x * pitch;
DbU::Unit ty = position.y * pitch;
Box cellBox = model->getAbutmentBox();
Transformation::Orientation orient = Transformation::Orientation::ID;
if ( not orientation.x_ and orientation.y_) {
if ( not orientation.x and orientation.y) {
tx += cellBox.getWidth();
orient = Transformation::Orientation::MX;
} else if ( orientation.x_ and not orientation.y_) {
} else if ( orientation.x and not orientation.y) {
ty += cellBox.getHeight();
orient = Transformation::Orientation::MY;
} else if ( not orientation.x_ and not orientation.y_) {
} else if ( not orientation.x and not orientation.y) {
tx += cellBox.getWidth();
ty += cellBox.getHeight();
orient = Transformation::Orientation::R2;
@ -287,7 +287,7 @@ namespace Etesian {
void EtesianEngine::_preDestroy ()
{
cdebug.log(129,1) << "EtesianEngine::_preDestroy()" << endl;
cdebug_log(129,1) << "EtesianEngine::_preDestroy()" << endl;
cmess1 << " o Deleting ToolEngine<" << getName() << "> from Cell <"
<< getCell()->getName() << ">" << endl;
@ -586,7 +586,7 @@ namespace Etesian {
_placementLB.positions_ = positions;
_placementLB.orientations_ = orientations;
_placementUB = _placementLB;
//cerr << "Coloquinte cell height: " << _circuit.get_cell(0).size.y_ << endl;
//cerr << "Coloquinte cell height: " << _circuit.get_cell(0).size.y << endl;
}
@ -616,11 +616,11 @@ namespace Etesian {
auto legalizer = (options & ForceUniformDensity) != 0 ?
region_distribution::uniform_density_distribution (_surface, _circuit, _placementLB, _densityLimits)
: region_distribution::full_density_distribution (_surface, _circuit, _placementLB, _densityLimits);
while(legalizer.region_dimensions().x_ > 2*legalizer.region_dimensions().y_)
while(legalizer.region_dimensions().x > 2*legalizer.region_dimensions().y)
legalizer.x_bipartition();
while(2*legalizer.region_dimensions().x_ < legalizer.region_dimensions().y_)
while(2*legalizer.region_dimensions().x < legalizer.region_dimensions().y)
legalizer.y_bipartition();
while( std::max(legalizer.region_dimensions().x_, legalizer.region_dimensions().y_)*4 > minDisruption ) {
while( std::max(legalizer.region_dimensions().x, legalizer.region_dimensions().y)*4 > minDisruption ) {
legalizer.x_bipartition();
legalizer.y_bipartition();
legalizer.redo_line_partitions();

2
etesian/src/PyEtesian.cpp
View File

@ -65,7 +65,7 @@ extern "C" {
// Module Initialization : "initEtesian ()"
DL_EXPORT(void) initEtesian () {
cdebug.log(34) << "initEtesian()" << endl;
cdebug_log(34,0) << "initEtesian()" << endl;
PyEtesianEngine_LinkPyType();
PyGraphicEtesianEngine_LinkPyType();

8
etesian/src/PyEtesianEngine.cpp
View File

@ -65,7 +65,7 @@ extern "C" {
static PyObject* PyEtesianEngine_get ( PyObject*, PyObject* args )
{
cdebug.log(34) << "PyEtesianEngine_get()" << endl;
cdebug_log(34,0) << "PyEtesianEngine_get()" << endl;
EtesianEngine* etesian = NULL;
@ -82,7 +82,7 @@ extern "C" {
static PyObject* PyEtesianEngine_create ( PyObject*, PyObject* args )
{
cdebug.log(34) << "PyEtesianEngine_create()" << endl;
cdebug_log(34,0) << "PyEtesianEngine_create()" << endl;
EtesianEngine* etesian = NULL;
@ -108,7 +108,7 @@ extern "C" {
static PyObject* PyEtesianEngine_setViewer ( PyEtesianEngine* self, PyObject* args )
{
cdebug.log(34) << "PyEtesianEngine_setViewer ()" << endl;
cdebug_log(34,0) << "PyEtesianEngine_setViewer ()" << endl;
HTRY
METHOD_HEAD( "EtesianEngine.setViewer()" )
@ -129,7 +129,7 @@ extern "C" {
static PyObject* PyEtesianEngine_place ( PyEtesianEngine* self )
{
cdebug.log(34) << "PyEtesianEngine_place()" << endl;
cdebug_log(34,0) << "PyEtesianEngine_place()" << endl;
HTRY
METHOD_HEAD("EtesianEngine.place()")
if (etesian->getViewer()) {

4
etesian/src/PyGraphicEtesianEngine.cpp
View File

@ -49,7 +49,7 @@ extern "C" {
static PyObject* PyGraphicEtesianEngine_grab ( PyObject* )
{
cdebug.log(34) << "PyGraphicEtesianEngine_grab()" << endl;
cdebug_log(34,0) << "PyGraphicEtesianEngine_grab()" << endl;
PyGraphicEtesianEngine* pyGraphicEtesianEngine = NULL;
HTRY
@ -65,7 +65,7 @@ extern "C" {
static PyObject* PyGraphicEtesianEngine_getCell ( PyGraphicEtesianEngine* self )
{
cdebug.log(34) << "PyGraphicEtesianEngine_getCell ()" << endl;
cdebug_log(34,0) << "PyGraphicEtesianEngine_getCell ()" << endl;
Cell* cell = NULL;

6
hurricane/src/hurricane/BasicLayer.cpp
View File

@ -352,7 +352,7 @@ namespace Hurricane {
{
if (flags & JsonWriter::RegisterMode) return;
cdebug.log(19) << "JsonBasicLayer::JsonBasicLayer()" << endl;
cdebug_log(19,0) << "JsonBasicLayer::JsonBasicLayer()" << endl;
add( "_material" , typeid(string) );
add( "_extractNumber", typeid(string) );
@ -375,7 +375,7 @@ namespace Hurricane {
void JsonBasicLayer::toData(JsonStack& stack)
{
cdebug.tabw(19,1);
cdebug_tabw(19,1);
check( stack, "JsonBasicLayer::toData" );
@ -449,7 +449,7 @@ namespace Hurricane {
update( stack, basicLayer );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}

2
hurricane/src/hurricane/Box.cpp
View File

@ -405,7 +405,7 @@ void JsonBox::toData(JsonStack& stack)
if ( (xMin <= xMax) and (yMin <= yMax) )
box.merge( xMin, yMin, xMax, yMax );
cdebug.log(19) << "Box(" << xMin << ", "
cdebug_log(19,0) << "Box(" << xMin << ", "
<< yMin << ", "
<< xMax << ", "
<< yMax << ")" << endl;

32
hurricane/src/hurricane/Cell.cpp
View File

@ -194,7 +194,7 @@ namespace Hurricane {
UniquifyRelation* relation = NULL;
Cell* cell = dynamic_cast<Cell*>( dbo );
cdebug.log(19) << "topDBo:" << dbo << endl;
cdebug_log(19,0) << "topDBo:" << dbo << endl;
if (cell) {
relation = UniquifyRelation::get( cell );
@ -394,7 +394,7 @@ namespace Hurricane {
SlavedsRelation* relation = NULL;
Cell* cell = dynamic_cast<Cell*>( dbo );
cdebug.log(19) << "topDBo:" << dbo << endl;
cdebug_log(19,0) << "topDBo:" << dbo << endl;
if (cell) {
relation = SlavedsRelation::get( cell );
@ -667,12 +667,12 @@ Entity* Cell::getEntity(const Signature& signature) const
return NULL;
}
cdebug.log(18) << "Cell::getEntity(): <" << getName() << ">, Net:<" << net->getName() << ">" << endl;
cdebug_log(18,0) << "Cell::getEntity(): <" << getName() << ">, Net:<" << net->getName() << ">" << endl;
if (signature.getType() == Signature::TypeContact) {
cdebug.log(18) << "Looking in Contacts..." << endl;
cdebug_log(18,0) << "Looking in Contacts..." << endl;
for ( Contact* component : getComponents().getSubSet<Contact*>() ) {
cdebug.log(18) << "| " << component << endl;
cdebug_log(18,0) << "| " << component << endl;
if ( (component->getLayer () == signature.getLayer())
and (component->getDx () == signature.getDim(Signature::ContactDx))
and (component->getDy () == signature.getDim(Signature::ContactDy))
@ -683,9 +683,9 @@ Entity* Cell::getEntity(const Signature& signature) const
}
if (signature.getType() == Signature::TypeVertical) {
cdebug.log(18) << "Looking in Verticals..." << endl;
cdebug_log(18,0) << "Looking in Verticals..." << endl;
for ( Vertical* component : getComponents().getSubSet<Vertical*>() ) {
cdebug.log(18) << "| " << component << endl;
cdebug_log(18,0) << "| " << component << endl;
if ( (component->getLayer () == signature.getLayer())
and (component->getWidth () == signature.getDim(Signature::VerticalWidth))
and (component->getX () == signature.getDim(Signature::VerticalX))
@ -696,9 +696,9 @@ Entity* Cell::getEntity(const Signature& signature) const
}
if (signature.getType() == Signature::TypeHorizontal) {
cdebug.log(18) << "Looking in Horizontals..." << endl;
cdebug_log(18,0) << "Looking in Horizontals..." << endl;
for ( Horizontal* component : getComponents().getSubSet<Horizontal*>() ) {
cdebug.log(18) << "| " << component << endl;
cdebug_log(18,0) << "| " << component << endl;
if ( (component->getLayer () == signature.getLayer())
and (component->getWidth () == signature.getDim(Signature::HorizontalWidth))
and (component->getY () == signature.getDim(Signature::HorizontalY))
@ -709,9 +709,9 @@ Entity* Cell::getEntity(const Signature& signature) const
}
if (signature.getType() == Signature::TypePad) {
cdebug.log(18) << "Looking in Pads..." << endl;
cdebug_log(18,0) << "Looking in Pads..." << endl;
for ( Pad* component : getComponents().getSubSet<Pad*>() ) {
cdebug.log(18) << "| " << component << endl;
cdebug_log(18,0) << "| " << component << endl;
if ( (component->getLayer() == signature.getLayer())
and (component->getBoundingBox().getXMin() == signature.getDim(Signature::PadXMin))
and (component->getBoundingBox().getYMin() == signature.getDim(Signature::PadYMin))
@ -817,7 +817,7 @@ DeepNet* Cell::getDeepNet ( Path path, const Net* leafNet ) const
void Cell::flattenNets(unsigned int flags)
// ***************************************
{
cdebug.log(18) << "Cell::flattenNets() flags:0x" << hex << flags << endl;
cdebug_log(18,0) << "Cell::flattenNets() flags:0x" << hex << flags << endl;
UpdateSession::open();
@ -1003,7 +1003,7 @@ Cell* Cell::getClone()
void Cell::uniquify(unsigned int depth)
// ************************************
{
cdebug.log(18,1) << "Cell::uniquify() " << this << endl;
cdebug_log(18,1) << "Cell::uniquify() " << this << endl;
vector<DeepNet*> deepNets;
for ( DeepNet* deepNet : getNets().getSubSet<DeepNet*>() ) {
@ -1019,7 +1019,7 @@ void Cell::uniquify(unsigned int depth)
for ( Instance* instance : getInstances() ) {
Cell* masterCell = instance->getMasterCell();
cdebug.log(18) << "| " << instance << endl;
cdebug_log(18,0) << "| " << instance << endl;
if (masterCell->isTerminal()) continue;
if (masterCells.find(masterCell) == masterCells.end()) {
@ -1042,8 +1042,8 @@ void Cell::uniquify(unsigned int depth)
cell->uniquify( depth-1 );
}
cdebug.tabw(18,-1);
cdebug.log(18) << "Cell::uniquify() END " << this << endl;
cdebug_tabw(18,-1);
cdebug_log(18,0) << "Cell::uniquify() END " << this << endl;
}
void Cell::materialize()

10
hurricane/src/hurricane/Component.cpp
View File

@ -330,7 +330,7 @@ ComponentFilter Component::getIsUnderFilter(const Box& area)
void Component::materialize()
// **************************
{
cdebug.log(18) << "Component::materialize() - " << this << endl;
cdebug_log(18,0) << "Component::materialize() - " << this << endl;
if (!isMaterialized()) {
Cell* cell = getCell();
@ -350,7 +350,7 @@ void Component::materialize()
void Component::unmaterialize()
// ****************************
{
cdebug.log(18) << "Component::unmaterialize() " << this << endl;
cdebug_log(18,0) << "Component::unmaterialize() " << this << endl;
if (isMaterialized()) {
Cell* cell = getCell();
@ -408,7 +408,7 @@ void Component::_postCreate()
void Component::_preDestroy()
// *************************
{
cdebug.log(18,1) << "entering Component::_Predestroy: " << this << endl;
cdebug_log(18,1) << "entering Component::_Predestroy: " << this << endl;
clearProperties();
@ -468,8 +468,8 @@ void Component::_preDestroy()
if (_net) _net->_getComponentSet()._remove(this);
cdebug.log(18) << "exiting Component::_Predestroy:" << endl;
cdebug.tabw(18,-1);
cdebug_log(18,0) << "exiting Component::_Predestroy:" << endl;
cdebug_tabw(18,-1);
}
void Component::_toJson( JsonWriter* writer ) const

6
hurricane/src/hurricane/Contact.cpp
View File

@ -325,14 +325,14 @@ void Contact::setOffset(const DbU::Unit& dx, const DbU::Unit& dy)
void Contact::_preDestroy()
// ***********************
{
cdebug.log(18,1) << "entering Contact::PreDestroy " << this << endl;
cdebug_log(18,1) << "entering Contact::PreDestroy " << this << endl;
Inherit::_preDestroy();
_anchorHook.detach();
cdebug.log(19) << "exiting Contact::PreDestroy" << endl;
cdebug.tabw(18,-1);
cdebug_log(19,0) << "exiting Contact::PreDestroy" << endl;
cdebug_tabw(18,-1);
}
void Contact::_toJson(JsonWriter* writer) const

6
hurricane/src/hurricane/ContactLayer.cpp
View File

@ -225,7 +225,7 @@ namespace Hurricane {
{
if (flags & JsonWriter::RegisterMode) return;
cdebug.log(19) << "JsonContactLayer::JsonContactLayer()" << endl;
cdebug_log(19,0) << "JsonContactLayer::JsonContactLayer()" << endl;
add( "_metal" , typeid(string) );
add( "_cut" , typeid(string) );
@ -254,7 +254,7 @@ namespace Hurricane {
void JsonContactLayer::toData(JsonStack& stack)
{
cdebug.tabw(19,1);
cdebug_tabw(19,1);
check( stack, "JsonContactLayer::toData" );
@ -333,7 +333,7 @@ namespace Hurricane {
update( stack, layer );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}

8
hurricane/src/hurricane/DeepNet.cpp
View File

@ -56,7 +56,7 @@ namespace Hurricane {
)
, _netOccurrence(netOccurrence)
{
cdebug.log(18) << "DeepNet::DeepNet() " << getCell() << " " << this << endl;
cdebug_log(18,0) << "DeepNet::DeepNet() " << getCell() << " " << this << endl;
}
@ -154,7 +154,7 @@ namespace Hurricane {
JsonDeepNet::JsonDeepNet ( unsigned long flags )
: JsonNet(flags)
{
cdebug.log(19) << "JsonDeepNet::JsonDeepNet()" << endl;
cdebug_log(19,0) << "JsonDeepNet::JsonDeepNet()" << endl;
add( "_netOccurrence", typeid(Occurrence) );
}
@ -174,7 +174,7 @@ namespace Hurricane {
void JsonDeepNet::toData(JsonStack& stack)
{
cdebug.tabw(19,1);
cdebug_tabw(19,1);
check( stack, "JsonDeepNet::toData" );
presetId( stack );
@ -191,7 +191,7 @@ namespace Hurricane {
setName( ".Net" );
update( stack, _net );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}

6
hurricane/src/hurricane/DiffusionLayer.cpp
View File

@ -253,7 +253,7 @@ namespace Hurricane {
{
if (flags & JsonWriter::RegisterMode) return;
cdebug.log(19) << "JsonDiffusionLayer::JsonDiffusionLayer()" << endl;
cdebug_log(19,0) << "JsonDiffusionLayer::JsonDiffusionLayer()" << endl;
add( "_active" , typeid(string) );
add( "_diffusion" , typeid(string) );
@ -281,7 +281,7 @@ namespace Hurricane {
void JsonDiffusionLayer::toData(JsonStack& stack)
{
cdebug.tabw(19,1);
cdebug_tabw(19,1);
check( stack, "JsonDiffusionLayer::toData" );
@ -360,7 +360,7 @@ namespace Hurricane {
update( stack, layer );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}

8
hurricane/src/hurricane/Entity.cpp
View File

@ -80,7 +80,7 @@ namespace Hurricane {
if (_flags & ForcedIdMode) {
if (_flags & NextIdSet) {
_flags &= ~NextIdSet;
cdebug.log(18) << demangle(typeid(*this).name())
cdebug_log(18,0) << demangle(typeid(*this).name())
<< "::getNextId(): Consuming the preset id:" << _nextId << endl;
return _nextId;
} else {
@ -223,14 +223,14 @@ namespace Hurricane {
void JsonEntityRef::toData ( JsonStack& stack )
{
cdebug.tabw(19,1);
cdebug_tabw(19,1);
check( stack, "JsonEntityRef::toData" );
unsigned int jsonId = get<int64_t>( stack, "_id" );
Entity* entity = stack.getEntity<Entity*>( jsonId );
cdebug.log(19) << "jsonId:" << jsonId << " entity:" << entity << endl;
cdebug_log(19,0) << "jsonId:" << jsonId << " entity:" << entity << endl;
if (entity) {
JsonBaseArray<Entity*>* array = jget< JsonBaseArray<Entity*> >( stack );
@ -243,7 +243,7 @@ namespace Hurricane {
update( stack, NULL );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}
} // End of Hurricane namespace.

8
hurricane/src/hurricane/ExtensionGo.cpp
View File

@ -50,7 +50,7 @@ namespace Hurricane {
void ExtensionGo::_preDestroy ()
{
cdebug.log(18) << "ExtensionGo::_preDestroy() - " << (void*)this << endl;
cdebug_log(18,0) << "ExtensionGo::_preDestroy() - " << (void*)this << endl;
Go::_preDestroy ();
}
@ -73,7 +73,7 @@ namespace Hurricane {
void ExtensionGo::unmaterialize ()
{
cdebug.log(18,1) << "ExtensionGo::unmaterialize() - start" << (void*)this << endl;
cdebug_log(18,1) << "ExtensionGo::unmaterialize() - start" << (void*)this << endl;
if ( isMaterialized() ) {
ExtensionSlice* slice = _cell->getExtensionSlice( getName() );
@ -84,8 +84,8 @@ namespace Hurricane {
}
}
cdebug.tabw(18,-1);
cdebug.log(18) << "ExtensionGo::unmaterialize() - completed" << endl;
cdebug_tabw(18,-1);
cdebug_log(18,0) << "ExtensionGo::unmaterialize() - completed" << endl;
}

2
hurricane/src/hurricane/ExtensionSlice.cpp
View File

@ -66,7 +66,7 @@ namespace Hurricane {
ExtensionSlice::~ExtensionSlice ()
{
cdebug.log(18) << "ExtensionSlice::~ExtensionSlice() - " << (void*)this << endl;
cdebug_log(18,0) << "ExtensionSlice::~ExtensionSlice() - " << (void*)this << endl;
_cell->_removeSlice ( this );
}

12
hurricane/src/hurricane/Instance.cpp
View File

@ -428,8 +428,8 @@ void Instance::setPlacementStatus(const PlacementStatus& placementStatus)
void Instance::setMasterCell(Cell* masterCell, bool secureFlag)
// ************************************************************
{
cdebug.log(18,1) << "Instance::setMasterCell() on " << this << endl;
cdebug.log(18) << "NEW masterCell:" << masterCell << endl;
cdebug_log(18,1) << "Instance::setMasterCell() on " << this << endl;
cdebug_log(18,0) << "NEW masterCell:" << masterCell << endl;
if (masterCell != _masterCell) {
UpdateSession::open();
@ -475,14 +475,14 @@ void Instance::setMasterCell(Cell* masterCell, bool secureFlag)
masterNetList.pop_front();
}
cdebug.log(18) << "Remove " << this << " from " << _masterCell << endl;
cdebug_log(18,0) << "Remove " << this << " from " << _masterCell << endl;
_masterCell->_getSlaveInstanceSet()._remove(this);
_masterCell = masterCell;
cdebug.log(18) << "Add (before) " << this << " to " << _masterCell << endl;
cdebug_log(18,0) << "Add (before) " << this << " to " << _masterCell << endl;
_masterCell->isUnique();
_masterCell->_getSlaveInstanceSet()._insert(this);
cdebug.log(18) << "Add (after) " << this << " to " << _masterCell << endl;
cdebug_log(18,0) << "Add (after) " << this << " to " << _masterCell << endl;
_masterCell->isUnique();
for_each_net(externalNet, _masterCell->getExternalNets()) {
@ -493,7 +493,7 @@ void Instance::setMasterCell(Cell* masterCell, bool secureFlag)
UpdateSession::close();
}
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}
void Instance::uniquify()

32
hurricane/src/hurricane/JsonReader.cpp
View File

@ -212,7 +212,7 @@ namespace Hurricane {
}
}
cdebug.log(19) << "HurricaneHandler::String() [key/typename] \"" << value << "\"." << endl;
cdebug_log(19,0) << "HurricaneHandler::String() [key/typename] \"" << value << "\"." << endl;
_key.clear();
return true;
}
@ -230,13 +230,13 @@ namespace Hurricane {
_key = key;
if (_state & TypenameKey) return true;
//cdebug.log(19) << "HurricaneHandler::Key() key:" << _key << " objects().size():" << objects().size() << endl;
//cdebug_log(19,0) << "HurricaneHandler::Key() key:" << _key << " objects().size():" << objects().size() << endl;
if (objects().back()) {
if ( doCallToData() and not _key.empty() and (_key[0] != '_') ) {
// The key is no longer a simple attribute of the object.
// Triggers it's creation in the Json stack.
cdebug.log(19) << "HurricaneHandler::key() Calling "
cdebug_log(19,0) << "HurricaneHandler::key() Calling "
<< objects().back()->getTypeName() << "::toData(JsonStack&)." << endl;
objects().back()->toData( stack() );
}
@ -248,28 +248,28 @@ namespace Hurricane {
bool HurricaneHandler::StartObject ()
{
cdebug.log(19,1) << "Hurricane::StartObject()" << endl;
cdebug_log(19,1) << "Hurricane::StartObject()" << endl;
_state |= TypenameKey;
_objectName = _key;
objects().push_back( new JsonDummy() );
_key.clear();
cdebug.log(19) << "objects().push_back(NULL), size():" << objects().size() << "." << endl;
cdebug.tabw(19,1);
cdebug_log(19,0) << "objects().push_back(NULL), size():" << objects().size() << "." << endl;
cdebug_tabw(19,1);
return true;
}
bool HurricaneHandler::EndObject ( SizeType )
{
cdebug.tabw(19,-2);
cdebug.log(19) << "HurricaneHandler::EndObject()" << endl;
cdebug.tabw(19,1);
cdebug_tabw(19,-2);
cdebug_log(19,0) << "HurricaneHandler::EndObject()" << endl;
cdebug_tabw(19,1);
_objectName.clear();
if (not isDummy()) {
if (doCallToData()) {
cdebug.log(19) << "Calling " << objects().back()->getTypeName() << "::toData(JsonStack&)." << endl;
cdebug_log(19,0) << "Calling " << objects().back()->getTypeName() << "::toData(JsonStack&)." << endl;
objects().back()->toData( stack() );
}
if (stack().size() > 1) {
@ -277,21 +277,21 @@ namespace Hurricane {
}
}
cdebug.log(19) << "objects().pop_back(), size():" << objects().size() << "." << endl;
cdebug_log(19,0) << "objects().pop_back(), size():" << objects().size() << "." << endl;
if (objects().back()->issetFlags(JsonWriter::DBoObject))
stack().pop_back_dbo();
delete objects().back();
objects().pop_back();
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
return true;
}
bool HurricaneHandler::StartArray()
{
cdebug.log(19,1) << "HurricaneHandler::StartArray() key:\"" << _key << "\"." << endl;
cdebug_log(19,1) << "HurricaneHandler::StartArray() key:\"" << _key << "\"." << endl;
_objectName.clear();
if (_key[0] != '+') {
@ -306,8 +306,8 @@ namespace Hurricane {
bool HurricaneHandler::EndArray ( SizeType )
{
cdebug.tabw(19,-1);
cdebug.log(19) << "HurricaneHandler::EndArray()" << endl;
cdebug_tabw(19,-1);
cdebug_log(19,0) << "HurricaneHandler::EndArray()" << endl;
return true;
}
@ -351,7 +351,7 @@ namespace Hurricane {
fileName += ".json.bz2";
_file = fopen( fileName.c_str(), "r" );
cdebug.log(19) << "_file:" << _file << ", _buffer:" << (void*)_buffer << endl;
cdebug_log(19,0) << "_file:" << _file << ", _buffer:" << (void*)_buffer << endl;
if (not _file) {
throw Error( "JsonReader::parse(): Cannot open file \"%s\"."

10
hurricane/src/hurricane/Net.cpp
View File

@ -1113,7 +1113,7 @@ string Net_SlavePlugs::Locator::_getString() const
{
if (flags & JsonWriter::RegisterMode) return;
cdebug.log(19) << "JsonNet::JsonNet()" << endl;
cdebug_log(19,0) << "JsonNet::JsonNet()" << endl;
add( "_name" , typeid(string) );
add( "_isGlobal" , typeid(bool) );
@ -1125,7 +1125,7 @@ string Net_SlavePlugs::Locator::_getString() const
add( "+componentSet" , typeid(JsonArray) );
add( "+externalComponents", typeid(JsonArray) );
cdebug.log(19) << "Disabling auto-materialization (" << _autoMaterialize << ")." << endl;
cdebug_log(19,0) << "Disabling auto-materialization (" << _autoMaterialize << ")." << endl;
Go::disableAutoMaterialization();
}
@ -1140,7 +1140,7 @@ string Net_SlavePlugs::Locator::_getString() const
if (_autoMaterialize) {
Go::enableAutoMaterialization();
cdebug.log(18) << "Enabling auto-materialization." << endl;
cdebug_log(18,0) << "Enabling auto-materialization." << endl;
}
}
@ -1155,7 +1155,7 @@ string Net_SlavePlugs::Locator::_getString() const
void JsonNet::toData ( JsonStack& stack )
{
cdebug.tabw(19,1);
cdebug_tabw(19,1);
check( stack, "JsonNet::toData" );
presetId( stack );
@ -1169,7 +1169,7 @@ string Net_SlavePlugs::Locator::_getString() const
update( stack, _net );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}

4
hurricane/src/hurricane/NetExternalComponents.cpp
View File

@ -149,12 +149,12 @@ namespace Hurricane {
void JsonNetExternalComponents::toData ( JsonStack& stack )
{
cdebug.tabw(19,1);
cdebug_tabw(19,1);
check ( stack, "JsonNetExternalComponents::toData" );
update( stack, NULL );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}

8
hurricane/src/hurricane/Plug.cpp
View File

@ -180,14 +180,14 @@ void Plug::_destroy()
void Plug::_preDestroy()
// ********************
{
cdebug.log(18,1) << "entering Plug::_preDestroy: " << this << endl;
cdebug_log(18,1) << "entering Plug::_preDestroy: " << this << endl;
Inherit::_preDestroy();
_instance->_getPlugMap()._remove(this);
cdebug.log(18) << "exiting Plug::_preDestroy:" << endl;
cdebug.tabw(18,-1);
cdebug_log(18,0) << "exiting Plug::_preDestroy:" << endl;
cdebug_tabw(18,-1);
}
void Plug::_toJson(JsonWriter* writer) const
@ -289,7 +289,7 @@ void JsonPlug::toData(JsonStack& stack)
} else {
cerr << Error( "JsonPlug::toData(): Cannot find \".Instance\" in stack, skipping." ) << endl;
}
cdebug.log(19) << "Instance Plug contents ignored for now." << endl;
cdebug_log(19,0) << "Instance Plug contents ignored for now." << endl;
update( stack, plug );
}

6
hurricane/src/hurricane/Quark.cpp
View File

@ -81,7 +81,7 @@ void Quark::_postCreate()
void Quark::_preDestroy()
// *********************
{
cdebug.log(18,1) << "entering Quark::_preDestroy: " << this << endl;
cdebug_log(18,1) << "entering Quark::_preDestroy: " << this << endl;
Inherit::_preDestroy();
@ -92,8 +92,8 @@ void Quark::_preDestroy()
else
if (NULL_SHARED_PATH_QUARK_MAP) NULL_SHARED_PATH_QUARK_MAP->_remove(this);
cdebug.log(18) << "exiting Quark::_preDestroy:" << endl;
cdebug.tabw(18,-1);
cdebug_log(18,0) << "exiting Quark::_preDestroy:" << endl;
cdebug_tabw(18,-1);
}
string Quark::_getString() const

6
hurricane/src/hurricane/RegularLayer.cpp
View File

@ -350,7 +350,7 @@ namespace Hurricane {
{
if (flags & JsonWriter::RegisterMode) return;
cdebug.log(19) << "JsonRegularLayer::JsonRegularLayer()" << endl;
cdebug_log(19,0) << "JsonRegularLayer::JsonRegularLayer()" << endl;
add( "_basicLayer" , typeid(string) );
add( "_enclosure" , typeid(int64_t) );
@ -373,7 +373,7 @@ namespace Hurricane {
void JsonRegularLayer::toData( JsonStack& stack )
{
cdebug.tabw(19,1);
cdebug_tabw(19,1);
check( stack, "JsonRegularLayer::toData" );
@ -440,7 +440,7 @@ namespace Hurricane {
update( stack, layer );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}
} // Hurricane namespace.

6
hurricane/src/hurricane/RoutingPad.cpp
View File

@ -236,14 +236,14 @@ namespace Hurricane {
void RoutingPad::_preDestroy ()
{
cdebug.log(18,1) << "entering RoutingPad::preDestroy: " << this << endl;
cdebug_log(18,1) << "entering RoutingPad::preDestroy: " << this << endl;
if ( not _occurrence.getPath().isEmpty() )
_occurrence.getMasterCell()->_removeSlaveEntity(_occurrence.getEntity(),this);
Inherit::_preDestroy();
cdebug.log(18) << "exiting RoutingPad::preDestroy:" << endl;
cdebug.tabw(18,-1);
cdebug_log(18,0) << "exiting RoutingPad::preDestroy:" << endl;
cdebug_tabw(18,-1);
}

6
hurricane/src/hurricane/Rubber.cpp
View File

@ -179,7 +179,7 @@ void Rubber::_destroy()
void Rubber::_preDestroy()
// **********************
{
cdebug.log(18,1) << "entering Rubber::_preDestroy: " << this << endl;
cdebug_log(18,1) << "entering Rubber::_preDestroy: " << this << endl;
Inherit::_preDestroy();
@ -192,8 +192,8 @@ void Rubber::_preDestroy()
_net->_getRubberSet()._remove(this);
cdebug.log(18) << "exiting Rubber::_preDestroy:" << endl;
cdebug.tabw(18,-1);
cdebug_log(18,0) << "exiting Rubber::_preDestroy:" << endl;
cdebug_tabw(18,-1);
}
string Rubber::_getString() const

6
hurricane/src/hurricane/Segment.cpp
View File

@ -294,15 +294,15 @@ void Segment::invert()
void Segment::_preDestroy()
// ***********************
{
cdebug.log(18,1) << "entering Segment::_preDestroy: " << this << endl;
cdebug_log(18,1) << "entering Segment::_preDestroy: " << this << endl;
Inherit::_preDestroy();
_sourceHook.detach();
_targetHook.detach();
cdebug.log(18) << "exiting Segment::_preDestroy:" << endl;
cdebug.tabw(18,-1);
cdebug_log(18,0) << "exiting Segment::_preDestroy:" << endl;
cdebug_tabw(18,-1);
}
void Segment::_toJson(JsonWriter* writer) const

2
hurricane/src/hurricane/Signature.cpp
View File

@ -107,7 +107,7 @@ namespace Hurricane {
void JsonSignature::toData ( JsonStack& stack )
{
cdebug.log(19) << (void*)this << " _subTypeName:" << _subTypeName << endl;
cdebug_log(19,0) << (void*)this << " _subTypeName:" << _subTypeName << endl;
check( stack, "JsonSignature::toData" );

6
hurricane/src/hurricane/Technology.cpp
View File

@ -640,7 +640,7 @@ JsonTechnology::JsonTechnology(unsigned long flags)
{
if (flags & JsonWriter::RegisterMode) return;
cdebug.log(19) << "JsonTechnology::JsonTechnology()" << endl;
cdebug_log(19,0) << "JsonTechnology::JsonTechnology()" << endl;
add( "_name" , typeid(string) );
add( "+layers", typeid(JsonArray) );
@ -683,7 +683,7 @@ void JsonTechnology::addBlockageRef(const string& blockageLayer, BasicLayer* lay
void JsonTechnology::toData(JsonStack& stack)
// ******************************************
{
cdebug.tabw(19,1);
cdebug_tabw(19,1);
check( stack, "JsonTechnology::toData" );
@ -708,7 +708,7 @@ void JsonTechnology::toData(JsonStack& stack)
update( stack, techno );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}
} // End of Hurricane namespace.

6
hurricane/src/hurricane/TransistorLayer.cpp
View File

@ -258,7 +258,7 @@ namespace Hurricane {
{
if (flags & JsonWriter::RegisterMode) return;
cdebug.log(19) << "JsonTransistorLayer::JsonTransistorLayer()" << endl;
cdebug_log(19,0) << "JsonTransistorLayer::JsonTransistorLayer()" << endl;
add( "_gate" , typeid(string) );
add( "_active" , typeid(string) );
@ -289,7 +289,7 @@ namespace Hurricane {
void JsonTransistorLayer::toData ( JsonStack& stack )
{
cdebug.tabw(19,1);
cdebug_tabw(19,1);
check( stack, "JsonTransistorLayer::toData" );
@ -374,7 +374,7 @@ namespace Hurricane {
update( stack, layer );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}

16
hurricane/src/hurricane/UpdateSession.cpp
View File

@ -147,7 +147,7 @@ void UpdateSession::onNotOwned()
void Go::invalidate(bool propagateFlag)
// ************************************
{
cdebug.log(18,1) << "Go::invalidate(" << this << ")" << endl;
cdebug_log(18,1) << "Go::invalidate(" << this << ")" << endl;
if (not UPDATOR_STACK or UPDATOR_STACK->empty())
throw Error( "Can't invalidate go: empty update session stack" );
@ -184,30 +184,30 @@ void Go::invalidate(bool propagateFlag)
}
}
cdebug.log(18) << "Go::invalidate(" << this << ") - Completed." << endl;
cdebug.tabw(18,-1);
cdebug_log(18,0) << "Go::invalidate(" << this << ") - Completed." << endl;
cdebug_tabw(18,-1);
}
void UpdateSession::open()
// ***********************
{
cdebug.log(18,1) << "UpdateSession::open()" << endl;
cdebug_log(18,1) << "UpdateSession::open()" << endl;
UpdateSession::_create();
}
void UpdateSession::close()
// ************************
{
cdebug.tabw(18,-1);
cdebug.log(18,1) << "UpdateSession::close() - Start materialization." << endl;
cdebug_tabw(18,-1);
cdebug_log(18,1) << "UpdateSession::close() - Start materialization." << endl;
if (!UPDATOR_STACK || UPDATOR_STACK->empty())
throw Error("Can't end update : empty update session stack");
UPDATOR_STACK->top()->_destroy();
cdebug.tabw(18,-1);
cdebug.log(18) << "UpdateSession::close() - Materialization completed." << endl;
cdebug_tabw(18,-1);
cdebug_log(18,0) << "UpdateSession::close() - Materialization completed." << endl;
}

6
hurricane/src/hurricane/ViaLayer.cpp
View File

@ -230,7 +230,7 @@ namespace Hurricane {
{
if (flags & JsonWriter::RegisterMode) return;
cdebug.log(19) << "JsonViaLayer::JsonViaLayer()" << endl;
cdebug_log(19,0) << "JsonViaLayer::JsonViaLayer()" << endl;
add( "_bottom" , typeid(string) );
add( "_cut" , typeid(string) );
@ -255,7 +255,7 @@ namespace Hurricane {
void JsonViaLayer::toData(JsonStack& stack)
{
cdebug.tabw(19,1);
cdebug_tabw(19,1);
check( stack, "JsonViaLayer::toData" );
@ -326,7 +326,7 @@ namespace Hurricane {
update( stack, layer );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}

28
hurricane/src/hurricane/grenier/json/JsonReader.cpp
View File

@ -176,7 +176,7 @@ namespace {
_objects[_objects.size()-1]->setName( _objectName );
}
cdebug.log(19) << "HurricaneHandler::String() [key/typename] " << value << endl;
cdebug_log(19,0) << "HurricaneHandler::String() [key/typename] " << value << endl;
return true;
}
@ -201,13 +201,13 @@ namespace {
return true;
}
//cdebug.log(19) << "HurricaneHandler::Key() key:" << _key << " _objects.size():" << _objects.size() << endl;
//cdebug_log(19,0) << "HurricaneHandler::Key() key:" << _key << " _objects.size():" << _objects.size() << endl;
if (_objects.back()) {
if ( doCallToData() and not _key.empty() and (_key[0] != '_') ) {
// The key is no longer a simple attribute of the object.
// Triggers it's creation in the Json stack.
cdebug.log(19) << "HurricaneHandler::key() Calling "
cdebug_log(19,0) << "HurricaneHandler::key() Calling "
<< _objects.back()->getTypeName() << "::toData(JsonStack&)." << endl;
_objects.back()->toData( _stack );
}
@ -219,17 +219,17 @@ namespace {
bool HurricaneHandler::StartObject ()
{
cdebug.log(19) << "Hurricane::StartObject()" << endl;
cdebug_log(19,0) << "Hurricane::StartObject()" << endl;
ltracein(50);
_state |= TypenameKey;
// if (doCallToData()) {
// cdebug.log(19) << "Calling " << _objects.back()->getTypeName() << "::toData(JsonStack&)." << endl;
// cdebug_log(19,0) << "Calling " << _objects.back()->getTypeName() << "::toData(JsonStack&)." << endl;
// _objects.back()->toData( _stack );
// }
_objectName = (_key == ".Array") ? "" : _key;
_objects.push_back( NULL );
cdebug.log(19) << "_objects.push_back(NULL), size():" << _objects.size() << "." << endl;
cdebug_log(19,0) << "_objects.push_back(NULL), size():" << _objects.size() << "." << endl;
ltracein(50);
return true;
@ -239,7 +239,7 @@ namespace {
bool HurricaneHandler::EndObject ( SizeType )
{
ltraceout(50,2);
cdebug.log(19) << "HurricaneHandler::EndObject()" << endl;
cdebug_log(19,0) << "HurricaneHandler::EndObject()" << endl;
ltracein(50);
_objectName.clear();
@ -247,11 +247,11 @@ namespace {
_state &= ~SkipObject;
} else {
if (doCallToData()) {
cdebug.log(19) << "Calling " << _objects.back()->getTypeName() << "::toData(JsonStack&)." << endl;
cdebug_log(19,0) << "Calling " << _objects.back()->getTypeName() << "::toData(JsonStack&)." << endl;
_objects.back()->toData( _stack );
}
if (_objects.size() > 1) {
cdebug.log(19) << "_objects.pop_back(), size():" << _objects.size() << "." << endl;
cdebug_log(19,0) << "_objects.pop_back(), size():" << _objects.size() << "." << endl;
delete _objects.back();
_objects.pop_back();
}
@ -259,14 +259,14 @@ namespace {
if (_stack[-1].first[0] != '_') _stack.pop_back();
}
}
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
return true;
}
bool HurricaneHandler::StartArray()
{
cdebug.log(19) << "HurricaneHandler::StartArray() key:\"" << _key << "\"." << endl;
cdebug_log(19,0) << "HurricaneHandler::StartArray() key:\"" << _key << "\"." << endl;
ltracein(50);
_objectName.clear();
@ -285,14 +285,14 @@ namespace {
bool HurricaneHandler::EndArray ( SizeType )
{
cdebug.tabw(19,-1);
cdebug.log(19) << "HurricaneHandler::EndArray()" << endl;
cdebug_tabw(19,-1);
cdebug_log(19,0) << "HurricaneHandler::EndArray()" << endl;
ltracein(50);
_state &= ~(ArrayMode | SkipArray);
_key.clear();
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
return true;
}

10
hurricane/src/hurricane/grenier/json/JsonReader.h
View File

@ -655,7 +655,7 @@ namespace Hurricane {
{ }
template<typename T> inline void JsonStack::push_back ( const std::string& key, T t ) {
cdebug.log(19) << "JsonStack::push_back() key:" << key << " t:" << t
cdebug_log(19,0) << "JsonStack::push_back() key:" << key << " t:" << t
<< " (" << demangle(typeid(T)) << ")." << endl;
_stack.push_back(std::make_pair(key,boost::any(t)));
}
@ -667,7 +667,7 @@ namespace Hurricane {
<< (count+1) << " elements remains to pop." << std::endl;
break;
}
cdebug.log(19) << "| _stack.pop_back() " << _stack.back().first << endl;
cdebug_log(19,0) << "| _stack.pop_back() " << _stack.back().first << endl;
_stack.pop_back();
}
}
@ -685,7 +685,7 @@ namespace Hurricane {
int i = _stack.size()-1;
do {
if (_stack[i].first == key) {
cdebug.log(19) << "JsonStack::rhas(): key \"" << key << "\" found at index:"
cdebug_log(19,0) << "JsonStack::rhas(): key \"" << key << "\" found at index:"
<< (i-(int)_stack.size()) << " (i:" << i << ")." << endl;
return i-(int)_stack.size();
}
@ -693,7 +693,7 @@ namespace Hurricane {
--i;
} while ( true );
cdebug.log(19) << "JsonStack::rhas(): key \"" << key << "\" not found (returning index: 0)." << endl;
cdebug_log(19,0) << "JsonStack::rhas(): key \"" << key << "\" not found (returning index: 0)." << endl;
return 0;
}
@ -703,7 +703,7 @@ namespace Hurricane {
int i = _stack.size()-1;
do {
if (_stack[i].first == key) {
cdebug.log(19) << "JsonStack::as<T>() k:" << key
cdebug_log(19,0) << "JsonStack::as<T>() k:" << key
<< " t:" << _stack[i].second.type().name() << std::endl;
return boost::any_cast<T>( _stack[i].second );
}

2
hurricane/src/hurricane/grenier/json/Net.cpp
View File

@ -1095,7 +1095,7 @@ void JsonNet::toData(JsonStack& stack)
update( stack, net );
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}
} // End of Hurricane namespace.

6
hurricane/src/hurricane/hurricane/Collection.h
View File

@ -1107,16 +1107,16 @@ template<typename Type>
inline void jsonWrite ( JsonWriter* w, const std::string& key, Hurricane::GenericCollection<Type> collection )
{
if (cdebug.enabled(19))
cdebug.log(19) << "jsonWrite< GenericCollection<" << Hurricane::demangle(typeid(Type).name())
cdebug_log(19,0) << "jsonWrite< GenericCollection<" << Hurricane::demangle(typeid(Type).name())
<< "> >(w,key,coll)" << " key:\"" << key << "\"" << std::endl;
cdebug.tabw(19,1);
cdebug_tabw(19,1);
w->key( key );
w->startArray();
for ( Type element : collection ) jsonWrite( w, element );
w->endArray();
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}

4
hurricane/src/hurricane/hurricane/Commons.h
View File

@ -815,6 +815,10 @@ inline tstream& operator<< ( tstream& o, const std::string& s )
extern tstream cdebug;
#define cdebug_log(level,indent) if (cdebug.enabled(level)) cdebug.log(level,indent)
#define cdebug_tabw(level,indent) cdebug.tabw(level,indent)
// x-----------------------------------------------------------------x
// | Classes Neededs in All Hurricane Modules |
// x-----------------------------------------------------------------x

12
hurricane/src/hurricane/hurricane/JsonObject.h
View File

@ -284,7 +284,7 @@ namespace Hurricane {
template<typename T> inline void JsonStack::push_back ( const std::string& key, T t )
{
cdebug.log(19) << "JsonStack::push_back(T) key:" << key << " value:" << t
cdebug_log(19,0) << "JsonStack::push_back(T) key:" << key << " value:" << t
<< " (" << demangle(typeid(T)) << ")." << endl;
_stack.push_back(std::make_pair(key,boost::any(t)));
}
@ -297,7 +297,7 @@ namespace Hurricane {
<< (count+1) << " elements remains to pop." << std::endl;
break;
}
cdebug.log(19) << "| _stack.pop_back() \"" << _stack.back().first
cdebug_log(19,0) << "| _stack.pop_back() \"" << _stack.back().first
<< "\", size:" << _stack.size() << ", dbos:" << _dbos.size() << endl;
_stack.pop_back();
}
@ -316,7 +316,7 @@ namespace Hurricane {
int i = _stack.size()-1;
do {
if (_stack[i].first == key) {
cdebug.log(19) << "JsonStack::rhas(): key \"" << key << "\" found at index:"
cdebug_log(19,0) << "JsonStack::rhas(): key \"" << key << "\" found at index:"
<< (i-(int)_stack.size()) << " (i:" << i << ") "
<< "(" << demangle(_stack[i].second.type().name()) << ")."
<< endl;
@ -326,7 +326,7 @@ namespace Hurricane {
--i;
} while ( true );
cdebug.log(19) << "JsonStack::rhas(): key \"" << key << "\" not found (returning index: 0)." << endl;
cdebug_log(19,0) << "JsonStack::rhas(): key \"" << key << "\" not found (returning index: 0)." << endl;
return 0;
}
@ -336,7 +336,7 @@ namespace Hurricane {
int i = _stack.size()-1;
do {
if (_stack[i].first == key) {
cdebug.log(19) << "JsonStack::as<T>() k:" << key
cdebug_log(19,0) << "JsonStack::as<T>() k:" << key
<< " value:" << demangle(_stack[i].second.type().name()) << std::endl;
return boost::any_cast<T>( _stack[i].second );
}
@ -405,7 +405,7 @@ namespace Hurricane {
template<typename T>
inline void JsonObject::update ( JsonStack& stack, T hobject )
{
cdebug.log(19) << "JsonObject::update<T>()" << endl;
cdebug_log(19,0) << "JsonObject::update<T>()" << endl;
stack.pop_back( _attributes.size() );
stack.push_back<T>( getStackName(), hobject );
setObject<T>( hobject );

16
hurricane/src/hurricane/hurricane/JsonWriter.h
View File

@ -221,12 +221,12 @@ inline void jsonWrite ( JsonWriter* w, const std::string& key, const C& )
template<typename C>
inline void jsonWrite ( JsonWriter* w, const C* object )
{
cdebug.log(19,1) << "jsonWrite<" << Hurricane::demangle(typeid(C).name()) << "*>(w,object)" << std::endl;
cdebug_log(19,1) << "jsonWrite<" << Hurricane::demangle(typeid(C).name()) << "*>(w,object)" << std::endl;
if (object) object->toJson( w );
else jsonWrite(w);
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}
@ -240,21 +240,21 @@ inline void jsonWrite ( JsonWriter* w, const std::string& key, C* object )
template<typename C>
inline void jsonWrite ( JsonWriter* w, const std::string& key, const C* object )
{
cdebug.log(19,1) << "jsonWrite<" << Hurricane::demangle(typeid(C).name()) << "*>(w,key,object)"
cdebug_log(19,1) << "jsonWrite<" << Hurricane::demangle(typeid(C).name()) << "*>(w,key,object)"
<< " key:\"" << key << "\"" << std::endl;
w->key( key );
if (object) jsonWrite( w, object );
else jsonWrite(w);
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}
template<typename Element>
inline void jsonWrite ( JsonWriter* w, const std::string& key, const std::vector<Element>& v )
{
cdebug.log(19,1) << "jsonWrite< vector<" << Hurricane::demangle(typeid(Element).name())
cdebug_log(19,1) << "jsonWrite< vector<" << Hurricane::demangle(typeid(Element).name())
<< "> >(w,key,v)" << " key:\"" << key << "\"" << std::endl;
w->key( key );
@ -262,7 +262,7 @@ inline void jsonWrite ( JsonWriter* w, const std::string& key, const std::vecto
for ( Element element : v ) jsonWrite( w, element );
w->endArray();
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}
@ -271,7 +271,7 @@ inline void jsonWrite ( JsonWriter* w
, const std::string& key
, const std::map<Key,Element,Compare,Allocator>& m )
{
cdebug.log(19,1) << "jsonWrite< map<"
cdebug_log(19,1) << "jsonWrite< map<"
<< Hurricane::demangle(typeid(Key ).name()) << ","
<< Hurricane::demangle(typeid(Element).name()) << ","
<< Hurricane::demangle(typeid(Compare).name())
@ -282,7 +282,7 @@ inline void jsonWrite ( JsonWriter* w
for ( auto mapElement : m ) jsonWrite( w, mapElement.second );
w->endArray();
cdebug.tabw(19,-1);
cdebug_tabw(19,-1);
}

4
hurricane/src/isobar/ProxyProperty.cpp
View File

@ -80,12 +80,12 @@ ProxyProperty* ProxyProperty::create ( void* shadow ) {
void ProxyProperty::_preDestroy () {
if ( _owner ) _owner->_onDestroyed ( this );
cdebug.log(20) << "ProxyProperty::_owner := " << hex << (void*)_owner << endl;
cdebug_log(20,0) << "ProxyProperty::_owner := " << hex << (void*)_owner << endl;
if ( _offset > 0 ) {
void** shadowMember = ( (void**)( (unsigned long)_shadow + _offset ) );
cdebug.log(20) << "ProxyProperty::_shadowMember := " << hex << *shadowMember << endl;
cdebug_log(20,0) << "ProxyProperty::_shadowMember := " << hex << *shadowMember << endl;
*shadowMember = NULL;
}

4
hurricane/src/isobar/PyBasicLayer.cpp
View File

@ -47,7 +47,7 @@ extern "C" {
static PyObject* PyBasicLayer_create ( PyObject*, PyObject* args )
{
cdebug.log(20) << "PyBasicLayer_create()" << endl;
cdebug_log(20,0) << "PyBasicLayer_create()" << endl;
BasicLayer* basicLayer = NULL;
@ -96,7 +96,7 @@ extern "C" {
static PyObject* PyBasicLayer_getMaterial ( PyBasicLayer *self )
{
cdebug.log(20) << "PyBasicLayer_getMaterial ()" << endl;
cdebug_log(20,0) << "PyBasicLayer_getMaterial ()" << endl;
METHOD_HEAD ( "BasicLayer.getMaterial()" )
BasicLayer::Material* material = NULL;

24
hurricane/src/isobar/PyBox.cpp
View File

@ -62,7 +62,7 @@ extern "C" {
// Class Method : "PyBox_NEW ()"
static PyObject* PyBox_NEW (PyObject *module, PyObject *args) {
cdebug.log(20) << "PyBox_NEW()" << endl;
cdebug_log(20,0) << "PyBox_NEW()" << endl;
Box* box = NULL;
PyBox* pyBox = NULL;
@ -106,13 +106,13 @@ extern "C" {
static int PyBox_Init ( PyBox* self, PyObject* args, PyObject* kwargs )
{
cdebug.log(20) << "PyBox_Init(): " << (void*)self << endl;
cdebug_log(20,0) << "PyBox_Init(): " << (void*)self << endl;
return 0;
}
static PyObject* PyBox_getCenter ( PyBox *self ) {
cdebug.log(20) << "PyBox_getCenter()" << endl;
cdebug_log(20,0) << "PyBox_getCenter()" << endl;
METHOD_HEAD ( "Box.Center()" )
@ -128,7 +128,7 @@ extern "C" {
static PyObject* PyBox_getUnion ( PyBox *self, PyObject* args ) {
cdebug.log(20) << "PyBox_getUnion()" << endl;
cdebug_log(20,0) << "PyBox_getUnion()" << endl;
METHOD_HEAD ( "Box.getUnion()" )
@ -154,7 +154,7 @@ extern "C" {
// Attribute Method : "PyBox_getIntersection ()"
static PyObject* PyBox_getIntersection ( PyBox *self, PyObject* args ) {
cdebug.log(20) << "PyBox_getIntersection()" << endl;
cdebug_log(20,0) << "PyBox_getIntersection()" << endl;
METHOD_HEAD ( "Box.getIntersection()" )
@ -179,7 +179,7 @@ extern "C" {
// Attribute Method : "PyBox_contains ()"
static PyObject* PyBox_contains ( PyBox *self, PyObject* args ) {
cdebug.log(20) << "PyBox_contains ()" << endl;
cdebug_log(20,0) << "PyBox_contains ()" << endl;
METHOD_HEAD ( "Box.contains()" )
@ -214,7 +214,7 @@ extern "C" {
// Attribute Method : "PyBox_intersect ()"
static PyObject* PyBox_intersect ( PyBox *self, PyObject* args ) {
cdebug.log(20) << "PyBox_intersect ()" << endl;
cdebug_log(20,0) << "PyBox_intersect ()" << endl;
bool result = false;
HTRY
@ -244,7 +244,7 @@ extern "C" {
// Attribute Method : "PyBox_isConstrainedBy ()"
static PyObject* PyBox_isConstrainedBy ( PyBox *self, PyObject* args ) {
cdebug.log(20) << "PyBox_isConstrainedBy ()" << endl;
cdebug_log(20,0) << "PyBox_isConstrainedBy ()" << endl;
bool result = false;
HTRY
@ -273,7 +273,7 @@ extern "C" {
// Attribute Method : "PyBox_makeEmpty ()"
static PyObject* PyBox_makeEmpty ( PyBox *self, PyObject* args ) {
cdebug.log(20) << "PyBox_makeEmpty ()" << endl;
cdebug_log(20,0) << "PyBox_makeEmpty ()" << endl;
HTRY
METHOD_HEAD ( "Box.makeEmpty()" )
@ -289,7 +289,7 @@ extern "C" {
// Attribute Method : "PyBox_inflate ()"
static PyObject* PyBox_inflate ( PyBox *self, PyObject* args ) {
cdebug.log(20) << "PyBox_inflate ()" << endl;
cdebug_log(20,0) << "PyBox_inflate ()" << endl;
METHOD_HEAD ( "Box.inflate()" )
@ -326,7 +326,7 @@ extern "C" {
// Attribute Method : "PyBox_merge ()"
static PyObject* PyBox_merge ( PyBox *self, PyObject* args ) {
cdebug.log(20) << "Box_merge()" << endl;
cdebug_log(20,0) << "Box_merge()" << endl;
METHOD_HEAD ( "Box.merge()" )
@ -364,7 +364,7 @@ extern "C" {
// Attribute Method : "PyBox_translate ()"
static PyObject* PyBox_translate ( PyBox *self, PyObject* args ) {
cdebug.log(20) << "PyBox_translate ()" << endl;
cdebug_log(20,0) << "PyBox_translate ()" << endl;
HTRY
METHOD_HEAD ( "Box.translate()" )

10
hurricane/src/isobar/PyBreakpoint.cpp
View File

@ -44,13 +44,13 @@ extern "C" {
static void PyBreakpoint_DeAlloc ( PyBreakpoint* self )
{
cdebug.log(20) << "PySingletonObject_DeAlloc(" << hex << self << ")" << endl;
cdebug_log(20,0) << "PySingletonObject_DeAlloc(" << hex << self << ")" << endl;
}
static PyObject* PyBreakpoint_stop ( PyObject*, PyObject *args )
{
cdebug.log(20) << "PyBreakpoint_stop()" << endl;
cdebug_log(20,0) << "PyBreakpoint_stop()" << endl;
bool result = false;
@ -71,7 +71,7 @@ extern "C" {
static PyObject* PyBreakpoint_setStopLevel ( PyObject*, PyObject* args )
{
cdebug.log(20) << "PyBreakpoint_setStopLevel()" << endl;
cdebug_log(20,0) << "PyBreakpoint_setStopLevel()" << endl;
HTRY
@ -89,7 +89,7 @@ extern "C" {
static PyObject* PyBreakpoint_getStopLevel ( PyObject* )
{
cdebug.log(20) << "PyBreakpoint_getStopLevel()" << endl;
cdebug_log(20,0) << "PyBreakpoint_getStopLevel()" << endl;
return Py_BuildValue ( "i", Breakpoint::getStopLevel() );
@ -112,7 +112,7 @@ extern "C" {
// extern void PyBreakpoint_LinkPyType()
// {
// cdebug.log(20) << "PyBreakpoint_LinkType()" << endl;
// cdebug_log(20,0) << "PyBreakpoint_LinkType()" << endl;
// PyTypeBreakpoint.tp_new = (newfunc) PyType_GenericNew;
// PyTypeBreakpoint.tp_dealloc = (destructor)PyBreakpoint_DeAlloc;

52
hurricane/src/isobar/PyCell.cpp
View File

@ -65,7 +65,7 @@ extern "C" {
// Attribute Method : "PyCell_create ()"
PyObject* PyCell_create ( PyObject*, PyObject *args ) {
cdebug.log(20) << "PyCell_create()" << endl;
cdebug_log(20,0) << "PyCell_create()" << endl;
char* name = NULL;
PyLibrary* pyLibrary = NULL;
@ -88,7 +88,7 @@ extern "C" {
// Attribute Method : "PyCell_getLibrary ()"
static PyObject* PyCell_getLibrary ( PyCell *self ) {
cdebug.log(20) << "PyCell_getLibrary ()" << endl;
cdebug_log(20,0) << "PyCell_getLibrary ()" << endl;
Library* library = NULL;
@ -110,7 +110,7 @@ extern "C" {
// Attribute Method : "PyCell_getInstance ()"
static PyObject* PyCell_getInstance ( PyCell *self, PyObject* args ) {
cdebug.log(20) << "PyCell_getInstance ()" << endl;
cdebug_log(20,0) << "PyCell_getInstance ()" << endl;
METHOD_HEAD("Cell.getInstance()")
Instance* instance = NULL;
@ -133,7 +133,7 @@ extern "C" {
// Attribute Method : "PyCell_getInstances()"
static PyObject* PyCell_getInstances( PyCell *self ) {
cdebug.log(20) << "PyCell_getInstances()" << endl;
cdebug_log(20,0) << "PyCell_getInstances()" << endl;
METHOD_HEAD ( "Cell.getInstances()" )
@ -158,7 +158,7 @@ extern "C" {
// Attribute Method : "PyCell_getInstancesUnder()"
static PyObject* PyCell_getInstancesUnder(PyCell *self, PyObject* args) {
cdebug.log(20) << "PyCell_getInstancesUnder()" << endl;
cdebug_log(20,0) << "PyCell_getInstancesUnder()" << endl;
METHOD_HEAD("Cell.getInstancesUnder()")
@ -188,7 +188,7 @@ extern "C" {
// Attribute Method : "PyCell_getSlaveInstances()"
static PyObject* PyCell_getSlaveInstances(PyCell *self) {
cdebug.log(20) << "PyCell_getSlaveInstances()" << endl;
cdebug_log(20,0) << "PyCell_getSlaveInstances()" << endl;
METHOD_HEAD("Cell.getSlaveInstances()")
@ -213,7 +213,7 @@ extern "C" {
// Attribute Method : "PyCell_getComponents()"
static PyObject* PyCell_getComponents(PyCell *self) {
cdebug.log(20) << "PyCell_getComponents()" << endl;
cdebug_log(20,0) << "PyCell_getComponents()" << endl;
METHOD_HEAD("Cell.getComponents()")
@ -239,7 +239,7 @@ extern "C" {
// Attribute Method : "PyCell_getComponentsUnder()"
static PyObject* PyCell_getComponentsUnder(PyCell *self, PyObject* args) {
cdebug.log(20) << "PyCell_getComponentsUnder()" << endl;
cdebug_log(20,0) << "PyCell_getComponentsUnder()" << endl;
METHOD_HEAD("Cell.getComponentsUnder()")
@ -268,7 +268,7 @@ extern "C" {
// Attribute Method : "PyCell_getOccurrences()"
static PyObject* PyCell_getOccurrences(PyCell *self) {
cdebug.log(20) << "PyCell_getOccurrences()" << endl;
cdebug_log(20,0) << "PyCell_getOccurrences()" << endl;
METHOD_HEAD("Cell.getOccurrences()")
@ -294,7 +294,7 @@ extern "C" {
// Attribute Method : "PyCell_getOccurrencesUnder()"
static PyObject* PyCell_getOccurrencesUnder(PyCell *self, PyObject* args) {
cdebug.log(20) << "PyCell_getOccurrencesUnder()" << endl;
cdebug_log(20,0) << "PyCell_getOccurrencesUnder()" << endl;
METHOD_HEAD("Cell.getOccurrencesUnder()")
@ -323,7 +323,7 @@ extern "C" {
// Attribute Method : "PyCell_getLeafInstanceOccurrences()"
static PyObject* PyCell_getLeafInstanceOccurrences(PyCell *self) {
cdebug.log(20) << "PyCell_getLeafInstanceOccurrences()" << endl;
cdebug_log(20,0) << "PyCell_getLeafInstanceOccurrences()" << endl;
METHOD_HEAD ( "Cell.getLeafInstanceOccurrences()" )
@ -348,7 +348,7 @@ extern "C" {
// Attribute Method : "PyCell_getLeafInstanceOccurrencesUnder()"
static PyObject* PyCell_getLeafInstanceOccurrencesUnder(PyCell *self, PyObject* args) {
cdebug.log(20) << "PyCell_getLeafInstanceOccurrencesUnder()" << endl;
cdebug_log(20,0) << "PyCell_getLeafInstanceOccurrencesUnder()" << endl;
METHOD_HEAD ( "Cell.getLeafInstanceOccurrencesUnder()" )
@ -378,7 +378,7 @@ extern "C" {
// Attribute Method : "PyCell_getReferences()"
static PyObject* PyCell_getReferences(PyCell *self) {
cdebug.log(20) << "PyCell_getReferences()" << endl;
cdebug_log(20,0) << "PyCell_getReferences()" << endl;
METHOD_HEAD("Cell.getReferences()")
@ -403,7 +403,7 @@ extern "C" {
// Attribute Method : "PyCell_getHyperNets()"
static PyObject* PyCell_getHyperNets(PyCell *self) {
cdebug.log(20) << "PyCell_getHyperNets()" << endl;
cdebug_log(20,0) << "PyCell_getHyperNets()" << endl;
METHOD_HEAD ( "Cell.getHyperNets()" )
@ -428,7 +428,7 @@ extern "C" {
// Attribute Method : "PyCell_getNet ()"
static PyObject* PyCell_getNet(PyCell *self, PyObject* args) {
cdebug.log(20) << "PyCell_getNet ()" << endl;
cdebug_log(20,0) << "PyCell_getNet ()" << endl;
METHOD_HEAD ( "Cell.getNet()" )
Net* net = NULL;
@ -449,7 +449,7 @@ extern "C" {
// Attribute Method : "PyCell_getNets ()"
static PyObject* PyCell_getNets ( PyCell *self ) {
cdebug.log(20) << "PyCell_getNets()" << endl;
cdebug_log(20,0) << "PyCell_getNets()" << endl;
METHOD_HEAD("Cell.getNets()")
@ -474,7 +474,7 @@ extern "C" {
// Attribute Method : "PyCell_getExternalNets()"
static PyObject* PyCell_getExternalNets(PyCell *self) {
cdebug.log(20) << "PyCell_getExternalNets()" << endl;
cdebug_log(20,0) << "PyCell_getExternalNets()" << endl;
METHOD_HEAD("Cell.getExternalNets()")
@ -498,7 +498,7 @@ extern "C" {
// Attribute Method : "PyCell_getClockNets()"
static PyObject* PyCell_getClockNets(PyCell *self) {
cdebug.log(20) << "PyCell_getClockNets()" << endl;
cdebug_log(20,0) << "PyCell_getClockNets()" << endl;
METHOD_HEAD("Cell.getClockNets")
@ -522,7 +522,7 @@ extern "C" {
// Attribute Method : "PyCell_getSupplyNets()"
static PyObject* PyCell_getSupplyNets(PyCell *self) {
cdebug.log(20) << "PyCell_getSupplyNets()" << endl;
cdebug_log(20,0) << "PyCell_getSupplyNets()" << endl;
METHOD_HEAD ( "Cell.getSupplyNets()" )
@ -547,7 +547,7 @@ extern "C" {
// Attribute Method : "PyCell_getPowerNets()"
static PyObject* PyCell_getPowerNets(PyCell *self) {
cdebug.log(20) << "PyCell_getPowerNets()" << endl;
cdebug_log(20,0) << "PyCell_getPowerNets()" << endl;
METHOD_HEAD ( "Cell.getPowerNets()" )
@ -572,7 +572,7 @@ extern "C" {
// Attribute Method : "PyCell_getGroundNets()"
static PyObject* PyCell_getGroundNets(PyCell *self) {
cdebug.log(20) << "PyCell_getGroundNets()" << endl;
cdebug_log(20,0) << "PyCell_getGroundNets()" << endl;
METHOD_HEAD ( "Cell.getGroundNets()" )
@ -596,7 +596,7 @@ extern "C" {
// Attribute Method : "PyCell_getAbutmentBox ()"
static PyObject* PyCell_getAbutmentBox ( PyCell *self ) {
cdebug.log(20) << "PyCell_getAbutmentBox()" << endl;
cdebug_log(20,0) << "PyCell_getAbutmentBox()" << endl;
METHOD_HEAD ( "Cell.getAbutmentBox()" )
@ -620,7 +620,7 @@ extern "C" {
// Attribute Method : "PyCell_setAbutmentBox ()"
static PyObject* PyCell_setAbutmentBox ( PyCell *self, PyObject* args ) {
cdebug.log(20) << "Cell.setAbutmentBox()" << endl;
cdebug_log(20,0) << "Cell.setAbutmentBox()" << endl;
HTRY
METHOD_HEAD ( "Cell.setAbutmentBox()" )
@ -640,7 +640,7 @@ extern "C" {
// Attribute Method : "PyCell_setTerminal ()"
static PyObject* PyCell_setTerminal ( PyCell *self, PyObject* args ) {
cdebug.log(20) << "PyCell_setTerminal ()" << endl;
cdebug_log(20,0) << "PyCell_setTerminal ()" << endl;
HTRY
METHOD_HEAD ( "Cell.setTerminal()" )
@ -658,7 +658,7 @@ extern "C" {
// Attribute Method : "PyCell_uniquify ()"
static PyObject* PyCell_uniquify ( PyCell *self, PyObject* args ) {
cdebug.log(20) << "PyCell_uniquify ()" << endl;
cdebug_log(20,0) << "PyCell_uniquify ()" << endl;
HTRY
METHOD_HEAD ( "Cell.uniquify()" )
@ -677,7 +677,7 @@ extern "C" {
// Attribute Method : "PyCell_getClone ()"
static PyObject* PyCell_getClone ( PyCell *self ) {
cdebug.log(20) << "PyCell_getClone ()" << endl;
cdebug_log(20,0) << "PyCell_getClone ()" << endl;
Cell* cloneCell = NULL;
HTRY

14
hurricane/src/isobar/PyComponent.cpp
View File

@ -61,7 +61,7 @@ extern "C" {
static PyObject* PyComponent_getPosition ( PyComponent *self )
{
cdebug.log(20) << "PyComponent_getPosition ()" << endl;
cdebug_log(20,0) << "PyComponent_getPosition ()" << endl;
METHOD_HEAD ( "Component.getPosition()" )
PyPoint* pyPoint = PyObject_NEW ( PyPoint, &PyTypePoint );
@ -77,7 +77,7 @@ extern "C" {
static PyObject* PyComponent_getNet ( PyComponent *self )
{
cdebug.log(20) << "PyComponent_getNet ()" << endl;
cdebug_log(20,0) << "PyComponent_getNet ()" << endl;
Net* net = NULL;
@ -93,7 +93,7 @@ extern "C" {
static PyObject* PyComponent_getLayer ( PyComponent *self )
{
cdebug.log(20) << "PyComponent_getLayer ()" << endl;
cdebug_log(20,0) << "PyComponent_getLayer ()" << endl;
METHOD_HEAD ( "Component.getLayer()" )
Layer* layer = NULL;
@ -108,7 +108,7 @@ extern "C" {
static PyObject* PyComponent_getCenter ( PyComponent *self )
{
cdebug.log(20) << "PyComponent_getCenter ()" << endl;
cdebug_log(20,0) << "PyComponent_getCenter ()" << endl;
METHOD_HEAD( "Component.getCenter()" )
PyPoint* pyPoint = PyObject_NEW( PyPoint, &PyTypePoint );
@ -124,7 +124,7 @@ extern "C" {
static PyObject* PyComponent_getBoundingBox ( PyComponent *self, PyObject* args )
{
cdebug.log(20) << "PyComponent_getBoundingBox ()" << endl;
cdebug_log(20,0) << "PyComponent_getBoundingBox ()" << endl;
METHOD_HEAD ( "Component.getBoundingBox()" )
PyBox* pyBox = PyObject_NEW ( PyBox, &PyTypeBox );
@ -154,7 +154,7 @@ extern "C" {
static PyObject* PyComponent_getConnexComponents ( PyComponent *self )
{
cdebug.log(20) << "PyComponent_getConnexComponents()" << endl;
cdebug_log(20,0) << "PyComponent_getConnexComponents()" << endl;
METHOD_HEAD( "PyComponent.getConnexComponents()" )
PyComponentCollection* pyComponentCollection = NULL;
@ -176,7 +176,7 @@ extern "C" {
static PyObject* PyComponent_getSlaveComponents ( PyComponent *self )
{
cdebug.log(20) << "PyComponent_getSlaveComponents()" << endl;
cdebug_log(20,0) << "PyComponent_getSlaveComponents()" << endl;
METHOD_HEAD( "PyComponent.getSlaveComponents()" )
PyComponentCollection* pyComponentCollection = NULL;

4
hurricane/src/isobar/PyContact.cpp
View File

@ -66,7 +66,7 @@ extern "C" {
static PyObject* PyContact_create ( PyObject*, PyObject *args ) {
cdebug.log(20) << "PyContact_create()" << endl;
cdebug_log(20,0) << "PyContact_create()" << endl;
Contact* contact = NULL;
@ -99,7 +99,7 @@ extern "C" {
static PyObject* PyContact_translate ( PyContact *self, PyObject* args ) {
cdebug.log(20) << "PyContact_translate ()" << endl;
cdebug_log(20,0) << "PyContact_translate ()" << endl;
HTRY
METHOD_HEAD ( "Contact.translate()" )

2
hurricane/src/isobar/PyContactLayer.cpp
View File

@ -76,7 +76,7 @@ extern "C" {
static PyObject* PyContactLayer_create ( PyObject*, PyObject* args )
{
cdebug.log(20) << "PyContactLayer_create()" << endl;
cdebug_log(20,0) << "PyContactLayer_create()" << endl;
ContactLayer* contactLayer = NULL;

8
hurricane/src/isobar/PyDataBase.cpp
View File

@ -38,7 +38,7 @@ extern "C" {
static PyObject* PyDataBase_create ( PyObject* ) {
cdebug.log(20) << "PyDataBase_create()" << endl;
cdebug_log(20,0) << "PyDataBase_create()" << endl;
DataBase* db = NULL;
@ -51,7 +51,7 @@ extern "C" {
static PyObject* PyDataBase_getDB ( PyObject* ) {
cdebug.log(20) << "PyDataBase_getDB()" << endl;
cdebug_log(20,0) << "PyDataBase_getDB()" << endl;
DataBase* db = NULL;
@ -66,7 +66,7 @@ extern "C" {
PyObject* PyDataBase_getTechnology ( PyDataBase* self ) {
cdebug.log(20) << "PyDataBase_getTechnology()" << endl;
cdebug_log(20,0) << "PyDataBase_getTechnology()" << endl;
Technology* techno = NULL;
@ -84,7 +84,7 @@ extern "C" {
static PyObject* PyDataBase_getRootLibrary ( PyDataBase *self ) {
cdebug.log(20) << "PyDataBase_getRootLibrary ()" << endl;
cdebug_log(20,0) << "PyDataBase_getRootLibrary ()" << endl;
Library* library = NULL;

2
hurricane/src/isobar/PyDbU.cpp
View File

@ -531,7 +531,7 @@ extern "C" {
extern void PyDbU_LinkPyType()
{
cdebug.log(20) << "PyDbU_LinkType()" << endl;
cdebug_log(20,0) << "PyDbU_LinkType()" << endl;
PyTypeDbU.tp_methods = PyDbU_Methods;
}

8
hurricane/src/isobar/PyDebugSession.cpp
View File

@ -44,13 +44,13 @@ extern "C" {
static void PyDebugSession_DeAlloc ( PyDebugSession* self )
{
cdebug.log(20) << "PyDebugSession_DeAlloc(" << hex << self << ")" << endl;
cdebug_log(20,0) << "PyDebugSession_DeAlloc(" << hex << self << ")" << endl;
}
static PyObject* PyDebugSession_open ( PyObject*, PyObject* args )
{
cdebug.log(20) << "PyDebugSession_open()" << endl;
cdebug_log(20,0) << "PyDebugSession_open()" << endl;
HTRY
PyObject* arg0;
@ -85,7 +85,7 @@ extern "C" {
static PyObject* PyDebugSession_close ( PyObject* )
{
cdebug.log(20) << "PyDebugSession_close()" << endl;
cdebug_log(20,0) << "PyDebugSession_close()" << endl;
HTRY
DebugSession::close ();
@ -97,7 +97,7 @@ extern "C" {
static PyObject* PyDebugSession_addToTrace ( PyObject*, PyObject* args )
{
cdebug.log(20) << "PyDebugSession_addToTrace()" << endl;
cdebug_log(20,0) << "PyDebugSession_addToTrace()" << endl;
HTRY
PyObject* pySymbol = NULL;

2
hurricane/src/isobar/PyDiffusionLayer.cpp
View File

@ -76,7 +76,7 @@ extern "C" {
static PyObject* PyDiffusionLayer_create ( PyObject*, PyObject* args )
{
cdebug.log(20) << "PyDiffusionLayer_create()" << endl;
cdebug_log(20,0) << "PyDiffusionLayer_create()" << endl;
DiffusionLayer* diffusionLayer = NULL;

2
hurricane/src/isobar/PyEntity.cpp
View File

@ -59,7 +59,7 @@ extern "C" {
// Attribute Method : "PyEntity_getCell ()"
static PyObject* PyEntity_getCell ( PyEntity *self ) {
cdebug.log(20) << "PyEntity_getCell ()" << endl;
cdebug_log(20,0) << "PyEntity_getCell ()" << endl;
Cell* cell = NULL;

12
hurricane/src/isobar/PyHook.cpp
View File

@ -48,7 +48,7 @@ extern "C" {
static PyObject* PyHook_getComponent ( PyHook *self )
{
cdebug.log(20) << "PyHook_getComponent()" << endl;
cdebug_log(20,0) << "PyHook_getComponent()" << endl;
METHOD_HEAD ( "Hook.getComponent()" )
Component* component = NULL;
@ -62,7 +62,7 @@ extern "C" {
static PyObject* PyHook_getHooks ( PyHook *self )
{
cdebug.log(20) << "PyHook_getHooks()" << endl;
cdebug_log(20,0) << "PyHook_getHooks()" << endl;
METHOD_HEAD( "Hook.getHooks()" )
@ -83,7 +83,7 @@ extern "C" {
static PyObject* PyHook_getSlaveHooks ( PyHook *self )
{
cdebug.log(20) << "PyHook_getSlaveHooks()" << endl;
cdebug_log(20,0) << "PyHook_getSlaveHooks()" << endl;
METHOD_HEAD( "Hook.getSlaveHooks()" )
@ -104,7 +104,7 @@ extern "C" {
static PyObject* PyHook_detach ( PyHook *self )
{
cdebug.log(20) << "PyHook_detach()" << endl;
cdebug_log(20,0) << "PyHook_detach()" << endl;
METHOD_HEAD ( "Hook.detach()" )
PyHook* pyReturnHook = PyObject_NEW ( PyHook, &PyTypeHook );
@ -120,7 +120,7 @@ extern "C" {
static PyObject* PyHook_attach ( PyHook *self, PyObject* args )
{
cdebug.log(20) << "PyHook_attach()" << endl;
cdebug_log(20,0) << "PyHook_attach()" << endl;
METHOD_HEAD ( "Hook.attach()" )
PyHook* pyReturnHook = PyObject_NEW ( PyHook, &PyTypeHook );
@ -147,7 +147,7 @@ extern "C" {
static PyObject* PyHook_merge ( PyHook *self, PyObject* args )
{
cdebug.log(20) << "PyHook_merge()" << endl;
cdebug_log(20,0) << "PyHook_merge()" << endl;
METHOD_HEAD ( "Hook.merge()" )
PyHook* pyReturnHook = PyObject_NEW ( PyHook, &PyTypeHook );

4
hurricane/src/isobar/PyHorizontal.cpp
View File

@ -61,7 +61,7 @@ extern "C" {
// Attribute Method : "PyHorizontal_create ()"
static PyObject* PyHorizontal_create ( PyObject*, PyObject *args ) {
cdebug.log(20) << "PyHorizontal_create()" << endl;
cdebug_log(20,0) << "PyHorizontal_create()" << endl;
PyObject* arg0;
PyObject* arg1;
@ -152,7 +152,7 @@ extern "C" {
// Attribute Method : "PyHorizontal_translate ()"
static PyObject* PyHorizontal_translate ( PyHorizontal *self, PyObject* args ) {
cdebug.log(20) << "PyHorizontal_translate ()" << endl;
cdebug_log(20,0) << "PyHorizontal_translate ()" << endl;
HTRY
METHOD_HEAD ( "Horizontal.translate()" )

6
hurricane/src/isobar/PyHurricane.cpp
View File

@ -209,7 +209,7 @@ using namespace Hurricane;
for ( unsigned i=0 ; i < _types.size() ; i++ ) {
if ( ! strcmp ( _types[i]->_id, id ) ) {
//throw Error ( objectTypeRedefinition ); // 04.09.2009 d2 modification so Pharos can run several scripts during one execution
cdebug.log(20) << objectTypeRedefinition << endl;
cdebug_log(20,0) << objectTypeRedefinition << endl;
return;
}
}
@ -526,7 +526,7 @@ extern "C" {
DL_EXPORT(void) initHurricane () {
//trace_on();
cdebug.log(20) << "initHurricane()" << endl;
cdebug_log(20,0) << "initHurricane()" << endl;
PyDebugSession_LinkPyType ();
PyUpdateSession_LinkPyType ();
@ -836,7 +836,7 @@ extern "C" {
PyInstance_postModuleInit();
PyQuery_postModuleInit();
cdebug.log(20) << "Hurricane.so loaded " << (void*)&typeid(string) << endl;
cdebug_log(20,0) << "Hurricane.so loaded " << (void*)&typeid(string) << endl;
}

8
hurricane/src/isobar/PyHyperNet.cpp
View File

@ -43,7 +43,7 @@ extern "C" {
static PyObject* PyHyperNet_create ( PyObject*, PyObject *args ) {
cdebug.log(20) << "PyHyperNet_create()" << endl;
cdebug_log(20,0) << "PyHyperNet_create()" << endl;
HyperNet* hyperNet = NULL;
PyObject* arg0;
@ -69,7 +69,7 @@ extern "C" {
static PyObject* PyHyperNet_getNetOccurrences(PyHyperNet *self)
{
cdebug.log(20) << "PyHyperNet_getNetOccurrences()" << endl;
cdebug_log(20,0) << "PyHyperNet_getNetOccurrences()" << endl;
METHOD_HEAD ( "HyperNet.getNetOccurrences()" )
@ -92,7 +92,7 @@ extern "C" {
static PyObject* PyHyperNet_getLeafPlugOccurrences(PyHyperNet *self)
{
cdebug.log(20) << "PyHyperNet_getLeafPlugOccurrences()" << endl;
cdebug_log(20,0) << "PyHyperNet_getLeafPlugOccurrences()" << endl;
METHOD_HEAD ( "HyperNet.getLeafPlugOccurrences()" )
@ -115,7 +115,7 @@ extern "C" {
static PyObject* PyHyperNet_getCell ( PyHyperNet *self )
{
cdebug.log(20) << "PyHyperNet_getCell ()" << endl;
cdebug_log(20,0) << "PyHyperNet_getCell ()" << endl;
Cell* cell = NULL;

30
hurricane/src/isobar/PyInstance.cpp
View File

@ -73,7 +73,7 @@ extern "C" {
static PyObject* PyInstance_create ( PyObject*, PyObject *args )
{
cdebug.log(20) << "PyInstance_create()" << endl;
cdebug_log(20,0) << "PyInstance_create()" << endl;
Instance* instance = NULL;
PyObject* arg0 = NULL;
@ -117,7 +117,7 @@ extern "C" {
static PyObject* PyInstance_getMasterCell ( PyInstance *self )
{
cdebug.log(20) << "PyInstance_getMasterCell ()" << endl;
cdebug_log(20,0) << "PyInstance_getMasterCell ()" << endl;
Cell* cell = NULL;
@ -132,7 +132,7 @@ extern "C" {
static PyObject* PyInstance_getPlacementStatus ( PyInstance *self )
{
cdebug.log(20) << "PyInstance_getPlacementStatus ()" << endl;
cdebug_log(20,0) << "PyInstance_getPlacementStatus ()" << endl;
METHOD_HEAD ( "Instance.getPlacementStatus()" );
@ -147,7 +147,7 @@ extern "C" {
static PyObject* PyInstance_setPlacementStatus ( PyInstance *self, PyObject* args )
{
cdebug.log(20) << "PyInstance_setPlacementStatus()" << endl;
cdebug_log(20,0) << "PyInstance_setPlacementStatus()" << endl;
METHOD_HEAD ( "Instance.setPlacementStatus()" )
HTRY
@ -163,7 +163,7 @@ extern "C" {
static PyObject* PyInstance_getTransformation ( PyInstance *self )
{
cdebug.log(20) << "PyInstance_getTransformation ()" << endl;
cdebug_log(20,0) << "PyInstance_getTransformation ()" << endl;
METHOD_HEAD ( "Instance.getTransformation()" );
PyTransformation* resultPyTransf = PyObject_NEW ( PyTransformation, &PyTypeTransformation );
@ -179,7 +179,7 @@ extern "C" {
static PyObject* PyInstance_getPlug ( PyInstance *self, PyObject* args )
{
cdebug.log(20) << "PyInstance_getPlug ()" << endl;
cdebug_log(20,0) << "PyInstance_getPlug ()" << endl;
Plug* plug = NULL;
@ -198,7 +198,7 @@ extern "C" {
static PyObject* PyInstance_getPlugs(PyInstance *self )
{
cdebug.log(20) << "PyInstance_getPlugs()" << endl;
cdebug_log(20,0) << "PyInstance_getPlugs()" << endl;
METHOD_HEAD ( "Instance.getPlugs()" )
@ -221,7 +221,7 @@ extern "C" {
static PyObject* PyInstance_getConnectedPlugs(PyInstance *self)
{
cdebug.log(20) << "PyInstance_getConnectedPlugs ()" << endl;
cdebug_log(20,0) << "PyInstance_getConnectedPlugs ()" << endl;
METHOD_HEAD ( "Instance.getConnectedPlugs()")
@ -244,7 +244,7 @@ extern "C" {
static PyObject* PyInstance_getUnconnectedPlugs(PyInstance *self)
{
cdebug.log(20) << "PyInstance_getUnconnectedPlugs ()" << endl;
cdebug_log(20,0) << "PyInstance_getUnconnectedPlugs ()" << endl;
METHOD_HEAD ( "Instance.getUnconnectedPlugs()")
@ -267,7 +267,7 @@ extern "C" {
static PyObject* PyInstance_getAbutmentBox ( PyInstance *self )
{
cdebug.log(20) << "PyInstance_getAbutmentBox ()" << endl;
cdebug_log(20,0) << "PyInstance_getAbutmentBox ()" << endl;
METHOD_HEAD ( "Instance.getAbutmentBox()" )
PyBox* pyBox = PyObject_NEW ( PyBox, &PyTypeBox );
@ -283,7 +283,7 @@ extern "C" {
static PyObject* PyInstance_uniquify ( PyInstance *self )
{
cdebug.log(20) << "PyInstance_uniquify ()" << endl;
cdebug_log(20,0) << "PyInstance_uniquify ()" << endl;
HTRY
METHOD_HEAD ( "Instance.uniquify()" )
@ -295,7 +295,7 @@ extern "C" {
static PyObject* PyInstance_slaveAbutmentBox ( PyInstance *self )
{
cdebug.log(20) << "PyInstance_slaveAbutmentBox ()" << endl;
cdebug_log(20,0) << "PyInstance_slaveAbutmentBox ()" << endl;
METHOD_HEAD ( "Instance.slaveAbutmentBox()" )
HTRY
@ -309,7 +309,7 @@ extern "C" {
static PyObject* PyInstance_getClone ( PyInstance *self, PyObject* args )
{
cdebug.log(20) << "PyInstance_getClone ()" << endl;
cdebug_log(20,0) << "PyInstance_getClone ()" << endl;
Instance* cloneInstance = NULL;
HTRY
@ -332,7 +332,7 @@ extern "C" {
static PyObject* PyInstance_setTransformation ( PyInstance *self, PyObject* args )
{
cdebug.log(20) << "PyInstance_setTransformation()" << endl;
cdebug_log(20,0) << "PyInstance_setTransformation()" << endl;
METHOD_HEAD ( "Instance.setTransformation()" )
HTRY
@ -348,7 +348,7 @@ extern "C" {
static PyObject* PyInstance_setMasterCell ( PyInstance *self, PyObject* args )
{
cdebug.log(20) << "Instance.setMasterCell()" << endl;
cdebug_log(20,0) << "Instance.setMasterCell()" << endl;
METHOD_HEAD ( "Instance.setMasterCell()" )
HTRY

22
hurricane/src/isobar/PyInterval.cpp
View File

@ -54,7 +54,7 @@ extern "C" {
// Class Method : "PyInterval_NEW ()"
static PyObject* PyInterval_NEW (PyObject *module, PyObject *args) {
cdebug.log(20) << "PyInterval_NEW()" << endl;
cdebug_log(20,0) << "PyInterval_NEW()" << endl;
Interval* interval = NULL;
@ -85,13 +85,13 @@ extern "C" {
static int PyInterval_Init ( PyInterval* self, PyObject* args, PyObject* kwargs )
{
cdebug.log(20) << "PyInterval_Init(): " << (void*)self << endl;
cdebug_log(20,0) << "PyInterval_Init(): " << (void*)self << endl;
return 0;
}
static PyObject* PyInterval_getUnion ( PyInterval *self, PyObject* args ) {
cdebug.log(20) << "PyInterval_getUnion()" << endl;
cdebug_log(20,0) << "PyInterval_getUnion()" << endl;
METHOD_HEAD ( "Interval.getUnion()" )
@ -110,7 +110,7 @@ extern "C" {
static PyObject* PyInterval_getIntersection ( PyInterval *self, PyObject* args ) {
cdebug.log(20) << "PyInterval_getIntersection()" << endl;
cdebug_log(20,0) << "PyInterval_getIntersection()" << endl;
METHOD_HEAD ( "Interval.getIntersection()" )
@ -129,7 +129,7 @@ extern "C" {
static PyObject* PyInterval_contains ( PyInterval *self, PyObject* args ) {
cdebug.log(20) << "PyInterval_contains ()" << endl;
cdebug_log(20,0) << "PyInterval_contains ()" << endl;
METHOD_HEAD( "Interval.contains()" )
@ -155,7 +155,7 @@ extern "C" {
static PyObject* PyInterval_intersect ( PyInterval *self, PyObject* args ) {
cdebug.log(20) << "PyInterval_intersect ()" << endl;
cdebug_log(20,0) << "PyInterval_intersect ()" << endl;
bool result = false;
HTRY
@ -176,7 +176,7 @@ extern "C" {
static PyObject* PyInterval_makeEmpty ( PyInterval *self, PyObject* args ) {
cdebug.log(20) << "PyInterval_makeEmpty ()" << endl;
cdebug_log(20,0) << "PyInterval_makeEmpty ()" << endl;
METHOD_HEAD( "Interval.makeEmpty()" )
interval->makeEmpty();
@ -187,7 +187,7 @@ extern "C" {
static PyObject* PyInterval_inflate ( PyInterval *self, PyObject* args ) {
cdebug.log(20) << "PyInterval_inflate ()" << endl;
cdebug_log(20,0) << "PyInterval_inflate ()" << endl;
METHOD_HEAD( "Interval.inflate()" )
@ -213,7 +213,7 @@ extern "C" {
static PyObject* PyInterval_merge ( PyInterval *self, PyObject* args ) {
cdebug.log(20) << "PyInterval_merge ()" << endl;
cdebug_log(20,0) << "PyInterval_merge ()" << endl;
METHOD_HEAD( "Interval.merge()" )
@ -239,7 +239,7 @@ extern "C" {
static PyObject* PyInterval_intersection ( PyInterval *self, PyObject* args ) {
cdebug.log(20) << "PyInterval_intersection ()" << endl;
cdebug_log(20,0) << "PyInterval_intersection ()" << endl;
METHOD_HEAD( "Interval.intersection()" )
@ -265,7 +265,7 @@ extern "C" {
static PyObject* PyInterval_translate ( PyInterval *self, PyObject* args ) {
cdebug.log(20) << "PyInterval_translate ()" << endl;
cdebug_log(20,0) << "PyInterval_translate ()" << endl;
HTRY
METHOD_HEAD( "Interval.translate()" )

16
hurricane/src/isobar/PyLayer.cpp
View File

@ -51,7 +51,7 @@ extern "C" {
# define accessorDbuFromOptBasicLayer(FUNC_NAME,PY_SELF_TYPE,SELF_TYPE) \
static PyObject* PY_SELF_TYPE##_##FUNC_NAME ( PY_SELF_TYPE* self, PyObject* args ) \
{ \
cdebug.log(20) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
cdebug_log(20,0) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
\
DbU::Unit rvalue = 0; \
\
@ -85,7 +85,7 @@ extern "C" {
# define accessorLayerFromLayer(FUNC_NAME,PY_SELF_TYPE,SELF_TYPE) \
static PyObject* PY_SELF_TYPE##_##FUNC_NAME ( PY_SELF_TYPE* self, PyObject* args ) \
{ \
cdebug.log(20) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
cdebug_log(20,0) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
\
Layer* rlayer = 0; \
\
@ -116,7 +116,7 @@ extern "C" {
# define accessorMaskFromVoid(FUNC_NAME,PY_SELF_TYPE,SELF_TYPE) \
static PyObject* PY_SELF_TYPE##_##FUNC_NAME ( PY_SELF_TYPE* self ) \
{ \
cdebug.log(20) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
cdebug_log(20,0) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
\
Layer::Mask mask = 0; \
\
@ -132,7 +132,7 @@ extern "C" {
# define accessorLayerFromOptBool(FUNC_NAME,PY_SELF_TYPE,SELF_TYPE) \
static PyObject* PY_SELF_TYPE##_##FUNC_NAME ( PY_SELF_TYPE* self, PyObject* args ) \
{ \
cdebug.log(20) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
cdebug_log(20,0) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
\
Layer* rlayer = NULL; \
\
@ -162,7 +162,7 @@ extern "C" {
# define predicateFromVoid(FUNC_NAME,PY_SELF_TYPE,SELF_TYPE) \
static PyObject* PY_SELF_TYPE##_##FUNC_NAME ( PY_SELF_TYPE* self ) \
{ \
cdebug.log(20) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
cdebug_log(20,0) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
\
HTRY \
GENERIC_METHOD_HEAD(SELF_TYPE,cobject,#SELF_TYPE"."#FUNC_NAME"()") \
@ -176,7 +176,7 @@ extern "C" {
# define updatorFromDbu(FUNC_NAME,PY_SELF_TYPE,SELF_TYPE) \
static PyObject* PY_SELF_TYPE##_##FUNC_NAME ( PY_SELF_TYPE* self, PyObject* args ) \
{ \
cdebug.log(20) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
cdebug_log(20,0) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
\
HTRY \
GENERIC_METHOD_HEAD(SELF_TYPE,cobject,#SELF_TYPE"."#FUNC_NAME"()") \
@ -199,7 +199,7 @@ extern "C" {
# define updatorFromBasicLayerDbu(FUNC_NAME,PY_SELF_TYPE,SELF_TYPE) \
static PyObject* PY_SELF_TYPE##_##FUNC_NAME ( PY_SELF_TYPE* self, PyObject* args ) \
{ \
cdebug.log(20) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
cdebug_log(20,0) << #PY_SELF_TYPE "_" #FUNC_NAME "()" << endl; \
\
HTRY \
GENERIC_METHOD_HEAD(SELF_TYPE,cobject,#SELF_TYPE"."#FUNC_NAME"()") \
@ -227,7 +227,7 @@ extern "C" {
static PyObject* PyLayer_getTechnology ( PyLayer *self ) {
cdebug.log(20) << "PyLayer_getTechnology ()" << endl;
cdebug_log(20,0) << "PyLayer_getTechnology ()" << endl;
Technology* techno = NULL;

6
hurricane/src/isobar/PyLayerMask.cpp
View File

@ -106,7 +106,7 @@ extern "C" {
static PyObject* PyLayerMask_new ( PyTypeObject* type, PyObject* args, PyObject* kwds )
{
cdebug.log(20) << "PyLayerMask_new()" << endl;
cdebug_log(20,0) << "PyLayerMask_new()" << endl;
PyLayerMask* pyMask = (PyLayerMask*)type->tp_alloc(type,0);
@ -287,7 +287,7 @@ extern "C" {
static void PyLayerMask_DeAlloc ( PyLayerMask *self )
{
cdebug.log(20) << "PyLayerMask_DeAlloc(" << hex << self << ") " << self->_object << endl;
cdebug_log(20,0) << "PyLayerMask_DeAlloc(" << hex << self << ") " << self->_object << endl;
PyObject_DEL ( self );
}
@ -312,7 +312,7 @@ extern "C" {
extern void PyLayerMask_LinkPyType()
{
cdebug.log(20) << "PyLayerMask_LinkType()" << endl;
cdebug_log(20,0) << "PyLayerMask_LinkType()" << endl;
PyTypeLayerMask.tp_new = PyLayerMask_new;
PyTypeLayerMask.tp_dealloc = (destructor) PyLayerMask_DeAlloc;

8
hurricane/src/isobar/PyLibrary.cpp
View File

@ -40,7 +40,7 @@ extern "C" {
static PyObject* PyLibrary_create ( PyObject *, PyObject *args ) {
cdebug.log(20) << "PyLibrary_create()" << endl;
cdebug_log(20,0) << "PyLibrary_create()" << endl;
PyObject* arg0;
PyObject* arg1;
@ -69,7 +69,7 @@ extern "C" {
static PyObject* PyLibrary_getSubLibrary ( PyLibrary *self, PyObject* args ) {
cdebug.log(20) << "PyLibrary_getLibrary ()" << endl;
cdebug_log(20,0) << "PyLibrary_getLibrary ()" << endl;
Library* subLibrary = NULL;
@ -89,7 +89,7 @@ extern "C" {
static PyObject* PyLibrary_getCell ( PyLibrary* self, PyObject* args ) {
cdebug.log(20) << "PyLibrary_getCell ()" << endl;
cdebug_log(20,0) << "PyLibrary_getCell ()" << endl;
Cell* cell = NULL;
@ -109,7 +109,7 @@ extern "C" {
static PyObject* PyLibrary_getCells(PyLibrary *self) {
cdebug.log(20) << "PyLibrary_getCells()" << endl;
cdebug_log(20,0) << "PyLibrary_getCells()" << endl;
METHOD_HEAD ( "Library.getCells()" )

Some files were not shown because too many files have changed in this diff Show More