1 /* be_spill_loc (ation) -> BY Sven Polk*/
12 #include "irgraph_t.h"
13 #include "irprintf_t.h"
23 #include "besched_t.h"
25 #include "bechordal_t.h"
33 #include "irprintf_t.h"
39 #include "iredges_t.h"
50 #include "iredges_t.h"
56 #include "firm/bearch_firm.h"
57 #include "ia32/bearch_ia32.h"
58 #include "arm/bearch_arm.h"
59 #include "ppc32/bearch_ppc32.h"
60 #include "mips/bearch_mips.h"
67 #include "besched_t.h"
68 #include "belistsched.h"
71 #include "bespillbelady.h"
73 #include "beraextern.h"
74 #include "bechordal_t.h"
76 #include "beifg_impl.h"
77 #include "becopyopt.h"
78 #include "becopystat.h"
79 #include "bessadestr.h"
92 #include "irphase_t.h"
96 //#include "bespillloc_t.h"
97 #include "bespillloc.h"
99 #define LPP_SERVER "i44pc52"
100 #define LPP_SOLVER "cplex"
102 // "cat /proc/cpuinfo" cache size : 512 KB => wahrscheinlich L2
103 // arranged into 32-byte cache lines
107 #define LINESIZE_BYTES (32)
112 #define L1SIZE_BYTES (L1SIZE * 1024)
113 #define L2SIZE_BYTES (L2SIZE * 1024)
115 #define L1LINECOUNT (L1SIZE_BYTES / LINESIZE_BYTES)
116 #define L2LINECOUNT (L2SIZE_BYTES / LINESIZE_BYTES)
118 #define ASSOCIATIVE (1)
119 #define BLOCKFACTOR (2)
120 #define CONTEMP_RANGE (10)
125 typedef struct _spilloc_env_t {
130 const arch_env_t *arch;
153 pset *chilimbi_Cli_ents;
161 typedef struct _cacheline {
170 typedef struct _vertex {
175 pset *neighbors; /* The neighboring entities */
176 int ela; /* entity layout affinity */
178 int is_coal; /* singled/doubled position */
183 typedef struct _edge {
193 typedef struct _Node { /*Prototype Row of Graph-Matrix*/
195 pset *edges; /*The outgoin' edges of vtx*/
209 typedef struct _ent_position {
224 typedef struct _Coalesce {
235 static void _ents(entity*, void*);
236 static void _ent_nodes(ir_node*, void*);
238 static void create_Vertex(void*);
239 static void create_Edge(entity*, entity*, void*);
241 int values_contemp(ir_node*, ir_node*);
242 int count_Edge_Affinity(pset*, pset*);
244 static void Cli_ents(int, int, int, void*);
245 static cacheline *create_Cli_ent(struct obstack*);
247 int wt(entity*, entity*);
248 int get_edge_affinity(entity*, entity*, void*);
249 int compute_Entity_Cache_Affinity(entity*, pset*, void*);
251 void ir_printf_ent_nodes(void*);
252 void ir_printf_ent_nodes_aff(void*) ;
254 int Entity_values_interfere(entity*, entity*, void*);
255 int Ents_Coalesce (entity*, entity*, void*);
256 void Check_Coalesce(void*);
258 int delta_configuration_locality(entity*, cacheline*, void*);
260 int check_offset(void*);
261 int is_filled(pset*, pset*);
263 entity *min_configuration_locality(cacheline*, void*);
264 entity *max_configuration_locality(cacheline*, void*);
265 void bbcache_REORDER (void*);
267 int is_pasteable(entity*, pset*);
268 entity *MAX_affinity_ents(pset*, pset*, void*);
269 int bbcache_CHILIMBI (void*);
275 static void _ents(entity *_entity, void *env) {
276 /* GET all ents from stack-frame of the current irg*/
278 spilloc_env_t *spi = env;
279 entity *ent = obstack_alloc(&spi->ob, sizeof(*ent));
282 pset_insert_ptr(spi->ents, ent);
286 static void _ent_nodes(ir_node *irn, void *env) {
287 /* GET ir_node(s) for each found entity */
289 spilloc_env_t *spi = env;
290 entity *ir_ent, *ent;
294 ir_ent = arch_get_frame_entity(spi->arch, irn);
297 foreach_pset(spi->ents, ent)
301 if(!pmap_find(spi->ent_nodes, ent)) {
302 nodes = pset_new_ptr_default();
303 pmap_insert(spi->ent_nodes, ent, nodes);
306 nodes = pmap_get(spi->ent_nodes, ent);
307 node = obstack_alloc(&spi->ob, sizeof(*node));
310 pset_insert_ptr(nodes, node); /* entity and their ir_node(set)*/
312 pset_insert_ptr(spi->nodes, node); /* 'only' all ir_node(s)*/
320 static void create_Vertex(void *env) {
322 spilloc_env_t *spi = env;
327 foreach_pset(spi->ents, ent)
331 node = obstack_alloc(&spi->ob, sizeof(*node));
332 node->vtx = obstack_alloc(&spi->ob, sizeof(*(node->vtx)));
333 node->edges = pset_new_ptr_default();
336 node->vtx->ent = ent;
337 node->vtx->offset_bits = 0;
338 node->vtx->offset_bytes = 0;
340 node->vtx->neighbors = pset_new_ptr_default();
342 node->vtx->Cli->end = 0;
343 node->vtx->Cli->start = 0;
344 node->vtx->Cli->nr = 0;
345 node->vtx->Cli->ents = pset_new_ptr_default();
350 pmap_insert(spi->afgraph, ent, node);
351 pset_insert_ptr(spi->afgraph_vs, node);
355 int values_contemp(ir_node *a, ir_node *b) {
357 /* check, if 2 nodes lying within range */
363 int range = CONTEMP_RANGE;
365 // backward (until block-border)
366 for(i = 0; i < range; i++) {
367 if(sched_has_prev(irn)) {
368 prev = sched_prev(irn);
369 if(prev == b) return -1;
374 // forward (until block-border)
375 for(i = 0, irn = a; i < range; i++) {
376 if(sched_has_next(irn)) {
378 next = sched_next(irn);
379 if(next == b) return 1;
386 int count_Edge_Affinity(pset *a, pset *b) {
388 /* count entity *a and entity *b */
390 ir_node *a_node, *cpy;
391 pset *copy = pset_new_ptr(pset_count(b));
394 foreach_pset(b, cpy) {pset_insert_ptr(copy, cpy);}
395 foreach_pset(a, a_node) {
396 foreach_pset(copy, cpy) {
397 if (values_contemp(a_node, cpy) != 0)
406 static void create_Edge(entity *a, entity *b, void *env) {
408 /* create a node in afgraph */
410 spilloc_env_t *spi = env;
412 pset *nodes_a,*nodes_b;
417 nodes_a = ((pset *)pmap_get(spi->ent_nodes, a));
418 nodes_b = ((pset *)pmap_get(spi->ent_nodes, b));
420 if(nodes_a && nodes_b)aff = count_Edge_Affinity(nodes_a, nodes_b);
425 edg = obstack_alloc(&spi->ob, sizeof(*edg));
429 node = (Node *)pmap_get(spi->afgraph, a);
430 edg->vtx_src = node->vtx;
432 node = (Node *)pmap_get(spi->afgraph, b);
433 edg->vtx_tgt = node->vtx;
437 node = pmap_get(spi->afgraph, a);
438 pset_insert_ptr(node->edges, b);
439 node = pmap_get(spi->afgraph, b);
440 pset_insert_ptr(node->edges, a);
441 pset_insert_ptr(spi->afgraph_es, edg);
445 static void Cli_ents(int start, int end, int nr, void *env) {
447 spilloc_env_t *spi = env;
448 pset *surrounder = pset_new_ptr_default();
453 foreach_pset(spi->ents, ent)
455 if((start < get_entity_offset_bytes(ent)) && (get_entity_offset_bytes(ent) < end)) {
456 pset_insert_ptr(surrounder, ent);
460 cli = obstack_alloc(&spi->ob, sizeof(*cli));
465 cli->ents = pset_new_ptr_default();
467 foreach_pset(surrounder, ent) {pset_insert_ptr(cli->ents,ent);}
468 pmap_insert(spi->Cli_ents, (void *)nr, cli);
469 del_pset(surrounder);
472 static cacheline *create_Cli_ent(struct obstack *ob) {
476 cli = obstack_alloc(ob, sizeof(*cli));
481 cli->ents = pset_new_ptr_default();
491 int wt(entity *ent1, entity *ent2) {
492 /*Relative Distance of 2 Ents == from start to start*/
494 int o1, o2, cache_blk_size, dist, wt;
496 o1 = get_entity_offset_bytes(ent1);
497 o2 = get_entity_offset_bytes(ent2);
503 if (o1 > o2) dist = (o1 - o2);
505 cache_blk_size = LINESIZE_BYTES;
506 wt = ((cache_blk_size - dist) / cache_blk_size);
507 if(wt != 0) return wt;
513 int get_edge_affinity(entity *a, entity *b, pmap *graph) {
518 if((pmap_find(graph,a))) {
519 node = pmap_get(graph, a);
520 foreach_pset(node->edges, edg) {
521 if(edg->src == a && edg->tgt == b) {
529 int compute_Entity_Cache_Affinity(entity *ent, pset *surrs, void *env) {
531 spilloc_env_t *spi = env;
536 if(pset_count(surrs) != 0) {
537 foreach_pset(surrs, sur)
539 aff = get_edge_affinity(ent, sur, spi->afgraph);
540 ela += (wt(ent, sur) * aff);
547 void ir_printf_ent_nodes(void *env) {
549 spilloc_env_t *spi = env;
556 // printf("%c", get_irg_dump_name(spi->irg));
558 nodes = pset_new_ptr_default();
559 foreach_pset(spi->ents, ent) {
560 printf("\n <%d>",ent->nr);
561 nodes = pmap_get(spi->ent_nodes, ent);
562 if(nodes) {foreach_pset(nodes, node) {printf(" %d, ", node->node_nr);}}
567 void ir_printf_ent_nodes_aff(void *env) {
569 spilloc_env_t *spi = env;
577 nodes = pset_new_ptr_default();
578 foreach_pset(spi->afgraph_es, edg) {
579 printf("\n <%d-%d> :",edg->src->nr, edg->tgt->nr);
580 printf(" %d \n", edg->aff);
584 void ir_printf_chilimbi_cachelines(spilloc_env_t env) {
586 spilloc_env_t spi = env;
592 foreach_pset(spi.chilimbi_Cli_ents, cline) {
594 foreach_pset(cline->ents, ent)
596 printf("%d,", ent->nr);
614 int Entity_values_interfere(entity *ent_A, entity *ent_B, void *env) {
616 spilloc_env_t *spi = env;
618 ir_node *node_A, *node_B;
619 pset *nodes_A = pmap_get(spi->ent_nodes, ent_A);
620 pset *nodes_B = pmap_get(spi->ent_nodes, ent_B);
622 foreach_pset(nodes_A, node_A) {
623 foreach_pset(nodes_B, node_B) {
624 if(values_interfere(node_A, node_B)) {
632 int Ents_Coalesce (entity *a, entity *b, void *env) {
634 spilloc_env_t *spi = env;
638 /* check (ent,ent)-interfere */
640 if(Entity_values_interfere(a,b,&spi) == 1) {
642 aNode = pmap_get(spi->afgraph, a);
643 bNode = pmap_get(spi->afgraph, b);
645 if(pset_find_ptr(aNode->edges,b) && pset_find_ptr(bNode->edges,a))
648 // find THE EDGE(a,b) - if exists
650 pmap_foreach(spi->afgraph_es, edg) {
651 if((edg->src == a || edg->tgt == b) || (edg->src == b || edg->tgt == a)) pmap_break(spi->afgraph_es);
653 // (a,b) are coalescable
655 if ((edg != NULL) && (edg->aff > 0))
661 // (a,b) not coalescable
668 void Check_Coalesce(void *env) {
670 /* return a subset of (ptr_set) = all potential coalescing pairs */
672 spilloc_env_t *spi = env;
673 pset *these = pset_new_ptr_default();
674 pset *those = pset_new_ptr_default();
676 entity *cpy, *ea, *eb;
679 foreach_pset(spi->ents, cpy) {
680 pset_insert_ptr(these, cpy);
681 pset_insert_ptr(those, cpy);
684 foreach_pset(these, ea) { /* (ena,enb) */
685 foreach_pset(those, eb) {
687 if(Ents_Coalesce(ea, eb, &spi) == 1)
692 /* alloc and set new information*/
693 coal = obstack_alloc(&spi->ob, sizeof(*coal));
698 pset_insert_ptr(spi->coals, coal);
710 ir_node *find_phi_ent() {
714 ir_node *looptroop() {
726 int delta_configuration_locality(entity *ent, cacheline *cli_env, void *env) {
728 spilloc_env_t *spi = env;
732 cli->ents = pset_new_ptr_default();
734 // teste ent in allen cachelines ...
735 pmap_foreach(spi->Cli_ents, cli) {
737 /* ausser der gegebenen cacheline(ent)*/
739 node = pmap_get(spi->afgraph, ent);
740 //node->vtx->ela = compute_Entity_Cache_Affinity(ent,rel,&spi);
741 node->vtx->ela = compute_Entity_Cache_Affinity(ent,(cli->ents),&spi);
750 int is_pasteable(entity *ent, pset *co) {
752 /* RETURNs 1, IF ent could be moved to CACHELine co
757 int step,curr_pos,curr_end, etc_pos, etc_end;
760 ir_type *stype = get_entity_type(ent);
762 align = get_type_alignment_bytes(stype);
763 size = get_type_size_bytes(stype);
765 // check all possible alignment-constrainted positions
766 for(step=0; (step*align) >= LINESIZE_BYTES; step++) {
767 curr_pos = (step*align);
768 curr_end = curr_pos + size;
770 // collision with prev and/or next neighbor
771 foreach_pset(co, etc) {
772 etc_pos = get_entity_offset_bytes(get_entity_type(etc));
773 etc_end = (get_entity_offset_bytes(get_entity_type(etc)) + get_type_size_bytes(get_entity_type(etc)));
775 if((etc_end < curr_pos) || (curr_end < etc_pos)) { /* (etc,ent) is OK */ }
776 else if((etc_pos < curr_pos) && (curr_pos < etc_end) && (etc_end < curr_end)) {return 0;}
777 else if((curr_pos < etc_pos) && (etc_end < curr_end)) {return 0;}
778 else if((etc_pos < curr_pos) && (curr_end < etc_end)) {return 0;}
779 else if((curr_pos < etc_pos) && (etc_pos < curr_end) && (etc_end > curr_end)) {return 0;}
782 // overlapping to next LINE
783 if(get_entity_offset_bytes(ent)+get_type_size_bytes(ent) > LINESIZE_BYTES) {return 0;}
797 entity *min_configuration_locality(cacheline *cli_env, void *env) {
799 spilloc_env_t *spi = env;
801 cacheline *cli = cli_env;
806 if(cli->ents == NULL) return NULL;
808 foreach_pset(cli->ents, ent) {
809 node = pmap_get(spi->afgraph, ent);
810 if(node->vtx->ela < min) {min = (float)node->vtx->ela; ret = node->vtx->ent;}
816 void bbcache_REORDER (void *env) {
818 spilloc_env_t *spi = env;
819 int curr_ela, line_nr;
823 pset *ws = pset_new_ptr_default();
825 cacheline *cli, *mv2cli;
827 do{ /* first, find 'some' (= 1 ?) bad for each CACHELINE */
828 pmap_foreach(spi->Cli_ents, cli) {
830 /* ents(cacheline) holen - jeweils kleinste insert(ws) und remove(cacheline(i) = cli(i)) */
832 if(min_configuration_locality(&cli, &spi) != NULL) {
834 ent = min_configuration_locality(&cli, &spi);
835 pset_insert_ptr(ws, ent); // insert(ws,ent)
836 //pset_remove_ptr(Cli_ents,ent); // cacheline_remove(i,ent)
843 /* second, PASTE them AGAIN hopefully elsewhere*/
844 copy=pset_new_ptr(pset_count(ws));
845 foreach_pset(ws, ent) {pset_insert_ptr(copy,ent);}
847 foreach_pset(copy,cpy){
849 node = pmap_get(spi->afgraph,cpy);
850 curr_ela = node->vtx->ela;
854 pmap_foreach(spi->Cli_ents, cli) { /* for each CACHELINE */
855 if(delta_configuration_locality(cpy, &cli, &spi) > curr_ela){ // condition 1
856 if((is_pasteable(cpy,&cli) != 0)) { // condition 2
865 if((mv2cli != NULL) && (line_nr > 0)) {
867 cli = pmap_get(spi->Cli_ents, line_nr);
868 pset_insert_ptr(cli->ents,cpy);
869 pset_remove_ptr(ws,cpy);
876 } while(pset_count(ws) > 0);
879 entity *MAX_affinity_ents(pset *ws, pset *layout_set, spilloc_env_t *env) {
881 //spilloc_env_t *spi = env;
882 //pset *layout = pset_new_ptr_default();
887 //foreach_pset() {layout}
889 foreach_pset(ws, ent) {
891 y = compute_Entity_Cache_Affinity(ent, layout_set, env);
903 entity *max_configuration_locality(cacheline *cli_env, void *env) {
905 spilloc_env_t *spi = env;
906 cacheline *cli = cli_env;
913 if(cli->ents == NULL) return NULL;
915 foreach_pset(cli->ents, ent) {
916 node = pmap_get(spi->afgraph, ent);
917 if(node->vtx->ela < min) {min = (float)node->vtx->ela; ret = node->vtx->ent;}
923 int check_offset(void *env) {
925 spilloc_env_t *spi = env;
930 cli_ent_set = pset_new_ptr_default();
931 if(is_pasteable(ent, cli_ent_set)) return ;
936 int is_filled(pset *cli, pset *ws) {
941 foreach_pset(ws, ent) {
942 if (is_pasteable(ent, cli)) re = 0;
948 int bbcache_CHILIMBI (void *env) {
950 spilloc_env_t *spi = env;
955 edge *edg, *max_edge;
956 entity *max, *last_max;
958 int o,p,q, x,y,z, i,j,k;
962 /* get workset: ws == (spi->ents) */
963 o = pset_count(spi->ents);
964 ws = pset_new_ptr(o);
965 foreach_pset(spi->ents,ent) {pset_insert_ptr(ws,ent);}
970 cline = create_Cli_ent(&spi->ob);
979 (1) start BY: adding the pair of ents
981 the maxinmum affinity edge
985 /* MAX affinity-edge */
986 foreach_pset(spi->afgraph_es, edg)
989 if((edg->aff > p) && (pset_find_ptr(ws, edg->src)) && (pset_find_ptr(ws, edg->tgt)))
996 o = pset_count(spi->afgraph_es);
997 if(o == 0) return -1;
999 if(is_pasteable(max_edge->src, cline->ents)) {
1000 pset_insert_ptr(cline->ents, max_edge->src);
1001 pset_remove_ptr(ws, max_edge->src);
1004 if(is_pasteable(max_edge->tgt, cline->ents)) {
1005 pset_insert_ptr(cline->ents, max_edge->tgt);
1006 pset_remove_ptr(ws, max_edge->tgt);
1010 /* (2) A single entity
1011 is appended to the existing layout,
1013 that increases configuration locality
1014 by the largest amount
1017 if(o == 0) return -2;
1019 o = pset_count(cline->ents);
1021 max = MAX_affinity_ents(ws, (cline->ents), spi);
1024 if((o != 0) && (max != NULL) ) { // && (max->value != NULL)
1030 // paste to layout set
1031 if(is_pasteable(max, cline->ents)) {
1032 pset_insert_ptr(cline->ents, max);
1033 pset_remove_ptr(ws, max);
1037 // get the best-fit'in entity
1038 o = pset_count(cline->ents);
1040 if(o != 0 && p != 0)
1041 max = MAX_affinity_ents(ws, (cline->ents), spi);
1043 } while( ((max != last_max) || (last_max != NULL) || (max == NULL)) && (p != 0));
1047 /* insert one "filled" cacheline */
1048 pset_insert_ptr(spi->chilimbi_Cli_ents, cline);
1050 } while(ws != NULL && pset_count(ws) > 0);
1056 void frame_information (spilloc_env_t spi) {
1061 frame = get_irg_frame_type(spi.irg);
1062 frame_align = get_type_alignment_bytes(frame);
1066 void be_spill_loc(const be_chordal_env_t *chordal_env) {
1071 int max_off, i, start, end;
1076 obstack_init(&spi.ob);
1078 spi.irg = chordal_env->irg;
1079 spi.arch = chordal_env->birg->main_env->arch_env;
1081 spi.ents = pset_new_ptr_default();
1082 spi.nodes = pset_new_ptr_default();
1083 spi.ent_nodes = pmap_create();
1092 spi.afgraph = pmap_create();
1093 spi.afgraph_es = pset_new_ptr_default();
1094 spi.afgraph_vs = pset_new_ptr_default();
1096 spi.Cli_ents = pmap_create();
1097 spi.position = pmap_create();
1098 spi.coals = pset_new_ptr_default();
1100 spi.chilimbi_Cli_ents = pset_new_ptr_default();
1105 walk_types_entities(get_irg_frame_type(chordal_env->irg), _ents, &spi);
1106 if(spi.ent_cnt != pset_count(spi.ents))
1107 spi.ent_cnt = pset_count(spi.ents);
1112 irg_walk_blkwise_graph(chordal_env->irg, NULL, _ent_nodes, &spi);
1113 if(spi.node_cnt != pset_count(spi.nodes))
1114 spi.ent_cnt = pset_count(spi.ents);
1118 create_Vertex(&spi);
1122 /* (ent,ent) -> edge */
1123 copy = pset_new_ptr(spi.ent_cnt);
1124 foreach_pset(spi.ents, ent) {pset_insert_ptr(copy,ent);}
1125 foreach_pset(copy, cpy) {
1126 foreach_pset(spi.ents, ent) {
1128 create_Edge(ent,cpy,&spi);
1135 /* ======================================================================================================*/
1136 /* ======================================================================================================*/
1137 /* ======================================================================================================*/
1138 /* ======================================================================================================*/
1140 /* use the dumb offset */
1142 /* ======================================================================================================*/
1143 /* ======================================================================================================*/
1144 /* ======================================================================================================*/
1145 /* ======================================================================================================*/
1148 /* {ent} -> max_off */
1150 foreach_pset(spi.ents, ent) {
1151 if(get_entity_offset_bytes(ent) > max_off) {max_off = get_entity_offset_bytes(ent);}
1156 /* max_off -> max_cli */
1158 while((i * LINESIZE_BYTES) < max_off){
1166 /* {ent} -> {({ent},int), ({ent},int), ({ent},int),...,({ent},int)} */
1167 for(i = 0; i < spi.cli_cnt; i++) {
1168 start = (i * LINESIZE_BYTES);
1169 end = start + LINESIZE_BYTES;
1170 Cli_ents(start, end, (i + 1), &spi);
1175 /* (ent,{ent}) -> int */
1177 for(i = 1; i <= spi.cli_cnt; i++) {
1181 cline = pmap_get(spi.Cli_ents, i);
1184 foreach_pset(spi.ents, ent) {
1185 node = pmap_get(spi.afgraph, ent);
1186 //node->vtx->ela = compute_Entity_Cache_Affinity(ent,rel,&spi);
1187 node->vtx->ela = compute_Entity_Cache_Affinity(ent,(cline->ents),&spi);
1192 /* ======================================================================================================*/
1195 /* {ent} -> {ent_position} (INIT) */
1197 foreach_pset(spi.ents, ent) {
1201 epos = obstack_alloc(&spi.ob, sizeof(*epos));
1207 pmap_insert(spi.position,ent,epos);
1210 /* {ent_position->offset} -> {ent_position} (SET) */
1212 foreach_pset(spi.ents, ent) {
1213 pos = pmap_get(spi.position, ent);
1214 pos->offset = get_entity_offset_bytes(pos->ent);
1221 /* ======================================================================================================*/
1222 /* ======================================================================================================*/
1223 /* ======================================================================================================*/
1224 /* ======================================================================================================*/
1226 /* use the initial offset */
1228 /* ======================================================================================================*/
1229 /* ======================================================================================================*/
1230 /* ======================================================================================================*/
1231 /* ======================================================================================================*/
1242 ir_printf_ent_nodes(&spi); // <ent->nr>: ir_node->node_nr, ir_node->node_nr ....
1243 ir_printf_ent_nodes_aff(&spi); // <ent->nr,ent->nr>: affinity
1246 // CHILIMBI => BBCache - algorithm
1248 bbcache_CHILIMBI(&spi);
1253 ir_printf_chilimbi_cachelines(spi);
1256 // HIGH affinity && NO values_interfere
1258 //Check_Coalesce(&spi);
1271 del_pset(spi.nodes);
1272 pmap_destroy(spi.ent_nodes);
1274 pmap_destroy(spi.afgraph);
1275 del_pset(spi.afgraph_es);
1276 del_pset(spi.afgraph_vs);
1278 pmap_destroy(spi.Cli_ents);
1279 pmap_destroy(spi.position);
1281 del_pset(spi.coals);
1283 del_pset(spi.chilimbi_Cli_ents);
1285 obstack_free(&spi.ob, NULL);