void mark_lowclusters(Agraph_t * root)
{
Agnode_t *n, *vn;
Agedge_t *orig, *e;
/* first, zap any previous cluster labelings */
for (n = agfstnode(root); n; n = agnxtnode(root, n)) {
ND_clust(n) = NULL;
for (orig = agfstout(root, n); orig; orig = agnxtout(root, orig)) {
if ((e = ED_to_virt(orig))) {
#ifndef WITH_CGRAPH
while (e && (vn = e->head)->u.node_type == VIRTUAL) {
#else /* WITH_CGRAPH */
while (e && (ND_node_type(vn = aghead(e))) == VIRTUAL) {
#endif /* WITH_CGRAPH */
ND_clust(vn) = NULL;
e = ND_out(aghead(e)).list[0];
}
}
}
}
/* do the recursion */
mark_lowcluster_basic(root);
}
static void mark_lowcluster_basic(Agraph_t * g)
{
Agraph_t *clust;
Agnode_t *n, *vn;
Agedge_t *orig, *e;
int c;
for (c = 1; c <= GD_n_cluster(g); c++) {
clust = GD_clust(g)[c];
mark_lowcluster_basic(clust);
}
/* see what belongs to this graph that wasn't already marked */
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
if (ND_clust(n) == NULL)
ND_clust(n) = g;
for (orig = agfstout(g, n); orig; orig = agnxtout(g, orig)) {
if ((e = ED_to_virt(orig))) {
#ifndef WITH_CGRAPH
while (e && (vn = e->head)->u.node_type == VIRTUAL) {
#else /* WITH_CGRAPH */
while (e && (ND_node_type(vn = aghead(e))) == VIRTUAL) {
#endif /* WITH_CGRAPH */
if (ND_clust(vn) == NULL)
ND_clust(vn) = g;
e = ND_out(aghead(e)).list[0];
}
}
}
}
}
static char *NAME(node_t * n)
{
static char buf[20];
if (ND_node_type(n) == NORMAL)
return n->name;
sprintf(buf, "V%x", n);
return buf;
}
static void rebuild_vlists(graph_t * g)
{
int c, i, r, maxi;
node_t *n, *lead;
edge_t *e, *rep;
for (r = GD_minrank(g); r <= GD_maxrank(g); r++)
GD_rankleader(g)[r] = NULL;
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
infuse(g, n);
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
for (rep = e; ED_to_virt(rep); rep = ED_to_virt(rep));
while (ND_rank(rep->head) < ND_rank(e->head)) {
infuse(g, rep->head);
rep = ND_out(rep->head).list[0];
}
}
}
for (r = GD_minrank(g); r <= GD_maxrank(g); r++) {
lead = GD_rankleader(g)[r];
if (ND_rank(g->root)[r].v[ND_order(lead)] != lead)
abort();
GD_rank(g)[r].v =
ND_rank(g->root)[r].v + GD_rankleader(g)[r]->u.order;
maxi = -1;
for (i = 0; i < GD_rank(g)[r].n; i++) {
if ((n = GD_rank(g)[r].v[i]) == NULL)
break;
if (ND_node_type(n) == NORMAL) {
if (agcontains(g, n))
maxi = i;
else
break;
} else {
edge_t *e;
for (e = ND_in(n).list[0]; e && ED_to_orig(e);
e = ED_to_orig(e));
if (e && (agcontains(g, e->tail))
&& agcontains(g, e->head))
maxi = i;
}
}
if (maxi == -1)
agerr(AGWARN, "degenerate concentrated rank %s,%d\n", g->name,
r);
GD_rank(g)[r].n = maxi + 1;
}
for (c = 1; c <= GD_n_cluster(g); c++)
rebuild_vlists(GD_clust(g)[c]);
}
static void
merge_ranks(graph_t * subg)
{
int i, d, r, pos, ipos;
node_t *v;
graph_t *root;
root = agroot(subg);
if (GD_minrank(subg) > 0)
#ifndef WITH_CGRAPH
ND_rank(root)[GD_minrank(subg) - 1].valid = FALSE;
#else /* WITH_CGRAPH */
GD_rank(root)[GD_minrank(subg) - 1].valid = FALSE;
#endif /* WITH_CGRAPH */
for (r = GD_minrank(subg); r <= GD_maxrank(subg); r++) {
d = GD_rank(subg)[r].n;
#ifndef WITH_CGRAPH
ipos = pos = GD_rankleader(subg)[r]->u.order;
#else /* WITH_CGRAPH */
ipos = pos = ND_order(GD_rankleader(subg)[r]);
#endif /* WITH_CGRAPH */
make_slots(root, r, pos, d);
for (i = 0; i < GD_rank(subg)[r].n; i++) {
#ifndef WITH_CGRAPH
v = ND_rank(root)[r].v[pos] = GD_rank(subg)[r].v[i];
#else /* WITH_CGRAPH */
v = GD_rank(root)[r].v[pos] = GD_rank(subg)[r].v[i];
#endif /* WITH_CGRAPH */
ND_order(v) = pos++;
#ifndef WITH_CGRAPH
v->graph = subg->root;
#else /* WITH_CGRAPH */
/* real nodes automatically have v->root = root graph */
if (ND_node_type(v) == VIRTUAL)
v->root = root;
#endif /* WITH_CGRAPH */
delete_fast_node(subg, v);
fast_node(agroot(subg), v);
GD_n_nodes(agroot(subg))++;
}
#ifndef WITH_CGRAPH
GD_rank(subg)[r].v = ND_rank(root)[r].v + ipos;
ND_rank(root)[r].valid = FALSE;
#else /* WITH_CGRAPH */
GD_rank(subg)[r].v = GD_rank(root)[r].v + ipos;
GD_rank(root)[r].valid = FALSE;
#endif /* WITH_CGRAPH */
}
if (r < GD_maxrank(root))
GD_rank(root)[r].valid = FALSE;
GD_expanded(subg) = TRUE;
}
static void free_virtual_node_list(node_t * vn)
{
node_t *next_vn;
while (vn) {
next_vn = ND_next(vn);
free_virtual_edge_list(vn);
if (ND_node_type(vn) == VIRTUAL) {
free_list(ND_out(vn));
free_list(ND_in(vn));
free(vn);
}
vn = next_vn;
}
}
int nonconstraint_edge(edge_t * e)
{
char *constr;
#ifndef WITH_CGRAPH
if (E_constr && (constr = agxget(e, E_constr->index))) {
#else /* WITH_CGRAPH */
if (E_constr && (constr = agxget(e, E_constr))) {
#endif /* WITH_CGRAPH */
if (constr[0] && mapbool(constr) == FALSE)
return TRUE;
}
return FALSE;
}
static void
interclust1(graph_t * g, node_t * t, node_t * h, edge_t * e)
{
node_t *v, *t0, *h0;
int offset, t_len, h_len, t_rank, h_rank;
edge_t *rt, *rh;
if (ND_clust(agtail(e)))
t_rank = ND_rank(agtail(e)) - ND_rank(GD_leader(ND_clust(agtail(e))));
else
t_rank = 0;
if (ND_clust(aghead(e)))
h_rank = ND_rank(aghead(e)) - ND_rank(GD_leader(ND_clust(aghead(e))));
else
h_rank = 0;
offset = ED_minlen(e) + t_rank - h_rank;
if (offset > 0) {
t_len = 0;
h_len = offset;
} else {
t_len = -offset;
h_len = 0;
}
v = virtual_node(g);
ND_node_type(v) = SLACKNODE;
t0 = UF_find(t);
h0 = UF_find(h);
rt = make_aux_edge(v, t0, t_len, CL_BACK * ED_weight(e));
rh = make_aux_edge(v, h0, h_len, ED_weight(e));
ED_to_orig(rt) = ED_to_orig(rh) = e;
}
node_t *virtual_node(graph_t * g)
{
node_t *n;
n = NEW(node_t);
n->name = "virtual";
n->graph = g;
ND_node_type(n) = VIRTUAL;
ND_lw_i(n) = ND_rw_i(n) = 1;
ND_ht_i(n) = 1;
ND_UF_size(n) = 1;
alloc_elist(4, ND_in(n));
alloc_elist(4, ND_out(n));
fast_node(g, n);
GD_n_nodes(g)++;
return n;
}
void unmerge_oneway(edge_t *e)
{
edge_t *rep,*nextrep;
for (rep = ED_to_virt(e); rep; rep = nextrep) {
unrep(rep,e);
nextrep = ED_to_virt(rep);
if (ED_count(rep) == 0) safe_delete_fast_edge(rep); /* free(rep)? */
/* unmerge from a virtual edge chain */
while ((ED_edge_type(rep) == VIRTUAL)
&& (ND_node_type(rep->head) == VIRTUAL)
&& (ND_out(rep->head).size == 1)) {
rep = ND_out(rep->head).list[0];
unrep(rep,e);
}
}
ED_to_virt(e) = NULL;
}
static void
cluster_leader(graph_t * clust)
{
node_t *leader, *n;
int maxrank = 0;
/* find number of ranks and select a leader */
leader = NULL;
for (n = GD_nlist(clust); n; n = ND_next(n)) {
if ((ND_rank(n) == 0) && (ND_node_type(n) == NORMAL))
leader = n;
if (maxrank < ND_rank(n))
maxrank = ND_rank(n);
}
assert(leader != NULL);
GD_leader(clust) = leader;
for (n = agfstnode(clust); n; n = agnxtnode(clust, n)) {
assert((ND_UF_size(n) <= 1) || (n == leader));
UF_union(n, leader);
ND_ranktype(n) = CLUSTER;
}
}
/* this function marks every node in <g> with its top-level cluster under <g> */
void mark_clusters(graph_t * g)
{
int c;
node_t *n, *nn, *vn;
edge_t *orig, *e;
graph_t *clust;
/* remove sub-clusters below this level */
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
if (ND_ranktype(n) == CLUSTER)
UF_singleton(n);
ND_clust(n) = NULL;
}
for (c = 1; c <= GD_n_cluster(g); c++) {
clust = GD_clust(g)[c];
for (n = agfstnode(clust); n; n = nn) {
nn = agnxtnode(clust,n);
if (ND_ranktype(n) != NORMAL) {
agerr(AGWARN,
"%s was already in a rankset, deleted from cluster %s\n",
agnameof(n), agnameof(g));
agdelete(clust,n);
continue;
}
UF_setname(n, GD_leader(clust));
ND_clust(n) = clust;
ND_ranktype(n) = CLUSTER;
/* here we mark the vnodes of edges in the cluster */
for (orig = agfstout(clust, n); orig;
orig = agnxtout(clust, orig)) {
if ((e = ED_to_virt(orig))) {
#ifndef WITH_CGRAPH
while (e && (vn = e->head)->u.node_type == VIRTUAL) {
#else /* WITH_CGRAPH */
while (e && ND_node_type(vn =aghead(e)) == VIRTUAL) {
#endif /* WITH_CGRAPH */
ND_clust(vn) = clust;
e = ND_out(aghead(e)).list[0];
/* trouble if concentrators and clusters are mixed */
}
}
}
}
}
}
void build_skeleton(graph_t * g, graph_t * subg)
{
int r;
node_t *v, *prev, *rl;
edge_t *e;
prev = NULL;
GD_rankleader(subg) = N_NEW(GD_maxrank(subg) + 2, node_t *);
for (r = GD_minrank(subg); r <= GD_maxrank(subg); r++) {
v = GD_rankleader(subg)[r] = virtual_node(g);
ND_rank(v) = r;
ND_ranktype(v) = CLUSTER;
ND_clust(v) = subg;
if (prev) {
e = virtual_edge(prev, v, NULL);
ED_xpenalty(e) *= CL_CROSS;
}
prev = v;
}
/* set the counts on virtual edges of the cluster skeleton */
for (v = agfstnode(subg); v; v = agnxtnode(subg, v)) {
rl = GD_rankleader(subg)[ND_rank(v)];
ND_UF_size(rl)++;
for (e = agfstout(subg, v); e; e = agnxtout(subg, e)) {
for (r = ND_rank(agtail(e)); r < ND_rank(aghead(e)); r++) {
ED_count(ND_out(rl).list[0])++;
}
}
}
for (r = GD_minrank(subg); r <= GD_maxrank(subg); r++) {
rl = GD_rankleader(subg)[r];
if (ND_UF_size(rl) > 1)
ND_UF_size(rl)--;
}
}
static void
map_path(node_t * from, node_t * to, edge_t * orig, edge_t * ve, int type)
{
int r;
node_t *u, *v;
edge_t *e;
assert(ND_rank(from) < ND_rank(to));
if ((agtail(ve) == from) && (aghead(ve) == to))
return;
if (ED_count(ve) > 1) {
ED_to_virt(orig) = NULL;
if (ND_rank(to) - ND_rank(from) == 1) {
if ((e = find_fast_edge(from, to)) && (ports_eq(orig, e))) {
merge_oneway(orig, e);
if ((ND_node_type(from) == NORMAL)
&& (ND_node_type(to) == NORMAL))
other_edge(orig);
return;
}
}
u = from;
for (r = ND_rank(from); r < ND_rank(to); r++) {
if (r < ND_rank(to) - 1)
v = clone_vn(agraphof(from), aghead(ve));
else
v = to;
e = virtual_edge(u, v, orig);
ED_edge_type(e) = type;
u = v;
ED_count(ve)--;
ve = ND_out(aghead(ve)).list[0];
}
} else {
if (ND_rank(to) - ND_rank(from) == 1) {
if ((ve = find_fast_edge(from, to)) && (ports_eq(orig, ve))) {
/*ED_to_orig(ve) = orig; */
ED_to_virt(orig) = ve;
ED_edge_type(ve) = type;
ED_count(ve)++;
if ((ND_node_type(from) == NORMAL)
&& (ND_node_type(to) == NORMAL))
other_edge(orig);
} else {
ED_to_virt(orig) = NULL;
ve = virtual_edge(from, to, orig);
ED_edge_type(ve) = type;
}
}
if (ND_rank(to) - ND_rank(from) > 1) {
e = ve;
if (agtail(ve) != from) {
ED_to_virt(orig) = NULL;
e = ED_to_virt(orig) = virtual_edge(from, aghead(ve), orig);
delete_fast_edge(ve);
} else
e = ve;
while (ND_rank(aghead(e)) != ND_rank(to))
e = ND_out(aghead(e)).list[0];
if (aghead(e) != to) {
ve = e;
e = virtual_edge(agtail(e), to, orig);
ED_edge_type(e) = type;
delete_fast_edge(ve);
}
}
}
}
static bool upcandidate(node_t * v)
{
return ((ND_node_type(v) == VIRTUAL) && (ND_out(v).size == 1)
&& (ND_in(v).size == 1) && (ND_label(v) == NULL));
}
