1 /* be_spill_loc (ation) -> BY Sven Polk*/
10 #include "irprintf_t.h"
20 #include "besched_t.h"
22 #include "bechordal_t.h"
30 #include "irprintf_t.h"
36 #include "iredges_t.h"
47 #include "iredges_t.h"
53 #include "firm/bearch_firm.h"
54 #include "ia32/bearch_ia32.h"
55 #include "arm/bearch_arm.h"
56 #include "ppc32/bearch_ppc32.h"
57 #include "mips/bearch_mips.h"
64 #include "besched_t.h"
65 #include "belistsched.h"
68 #include "bespillbelady.h"
70 #include "beraextern.h"
71 #include "bechordal_t.h"
73 #include "beifg_impl.h"
74 #include "becopyopt.h"
75 #include "becopystat.h"
76 #include "bessadestr.h"
89 #include "irphase_t.h"
93 //#include "bespillloc_t.h"
94 #include "bespillloc.h"
96 #define LPP_SERVER "i44pc52"
97 #define LPP_SOLVER "cplex"
99 // "cat /proc/cpuinfo" cache size : 512 KB => wahrscheinlich L2
100 // arranged into 32-byte cache lines
104 #define LINESIZE_BYTES (32)
109 #define L1SIZE_BYTES (L1SIZE * 1024)
110 #define L2SIZE_BYTES (L2SIZE * 1024)
112 #define L1LINECOUNT (L1SIZE_BYTES / LINESIZE_BYTES)
113 #define L2LINECOUNT (L2SIZE_BYTES / LINESIZE_BYTES)
115 #define ASSOCIATIVE (1)
116 #define BLOCKFACTOR (2)
117 #define CONTEMP_RANGE (10)
122 typedef struct _spilloc_env_t {
127 const arch_env_t *arch;
150 pset *chilimbi_Cli_ents;
158 typedef struct _cacheline {
167 typedef struct _vertex {
172 pset *neighbors; /* The neighboring entities */
173 int ela; /* entity layout affinity */
175 int is_coal; /* singled/doubled position */
180 typedef struct _edge {
190 typedef struct _Node { /*Prototype Row of Graph-Matrix*/
192 pset *edges; /*The outgoin' edges of vtx*/
206 typedef struct _ent_position {
221 typedef struct _Coalesce {
232 static void _ents(entity*, void*);
233 static void _ent_nodes(ir_node*, void*);
235 static void create_Vertex(void*);
236 static void create_Edge(entity*, entity*, void*);
238 int values_contemp(ir_node*, ir_node*);
239 int count_Edge_Affinity(pset*, pset*);
241 static void Cli_ents(int, int, int, void*);
242 static cacheline *create_Cli_ent(struct obstack*);
244 int wt(entity*, entity*);
245 int get_edge_affinity(entity*, entity*, void*);
246 int compute_Entity_Cache_Affinity(entity*, pset*, void*);
248 void ir_printf_ent_nodes(void*);
249 void ir_printf_ent_nodes_aff(void*) ;
251 int Entity_values_interfere(entity*, entity*, void*);
252 int Ents_Coalesce (entity*, entity*, void*);
253 void Check_Coalesce(void*);
255 int delta_configuration_locality(entity*, cacheline*, void*);
257 int check_offset(void*);
258 int is_filled(pset*, pset*);
260 entity *min_configuration_locality(cacheline*, void*);
261 entity *max_configuration_locality(cacheline*, void*);
262 void bbcache_REORDER (void*);
264 int is_pasteable(entity*, pset*);
265 entity *MAX_affinity_ents(pset*, pset*, void*);
266 int bbcache_CHILIMBI (void*);
272 static void _ents(entity *_entity, void *env) {
273 /* GET all ents from stack-frame of the current irg*/
275 spilloc_env_t *spi = env;
276 entity *ent = obstack_alloc(&spi->ob, sizeof(*ent));
279 pset_insert_ptr(spi->ents, ent);
283 static void _ent_nodes(ir_node *irn, void *env) {
284 /* GET ir_node(s) for each found entity */
286 spilloc_env_t *spi = env;
287 entity *ir_ent, *ent;
291 ir_ent = arch_get_frame_entity(spi->arch, irn);
294 foreach_pset(spi->ents, ent)
298 if(!pmap_find(spi->ent_nodes, ent)) {
299 nodes = pset_new_ptr_default();
300 pmap_insert(spi->ent_nodes, ent, nodes);
303 nodes = pmap_get(spi->ent_nodes, ent);
304 node = obstack_alloc(&spi->ob, sizeof(*node));
307 pset_insert_ptr(nodes, node); /* entity and their ir_node(set)*/
309 pset_insert_ptr(spi->nodes, node); /* 'only' all ir_node(s)*/
317 static void create_Vertex(void *env) {
319 spilloc_env_t *spi = env;
324 foreach_pset(spi->ents, ent)
328 node = obstack_alloc(&spi->ob, sizeof(*node));
329 node->vtx = obstack_alloc(&spi->ob, sizeof(*(node->vtx)));
330 node->edges = pset_new_ptr_default();
333 node->vtx->ent = ent;
334 node->vtx->offset_bits = 0;
335 node->vtx->offset_bytes = 0;
337 node->vtx->neighbors = pset_new_ptr_default();
339 node->vtx->Cli->end = 0;
340 node->vtx->Cli->start = 0;
341 node->vtx->Cli->nr = 0;
342 node->vtx->Cli->ents = pset_new_ptr_default();
347 pmap_insert(spi->afgraph, ent, node);
348 pset_insert_ptr(spi->afgraph_vs, node);
352 int values_contemp(ir_node *a, ir_node *b) {
354 /* check, if 2 nodes lying within range */
360 int range = CONTEMP_RANGE;
362 // backward (until block-border)
363 for(i = 0; i < range; i++) {
364 if(sched_has_prev(irn)) {
365 prev = sched_prev(irn);
366 if(prev == b) return -1;
371 // forward (until block-border)
372 for(i = 0, irn = a; i < range; i++) {
373 if(sched_has_next(irn)) {
375 next = sched_next(irn);
376 if(next == b) return 1;
383 int count_Edge_Affinity(pset *a, pset *b) {
385 /* count entity *a and entity *b */
387 ir_node *a_node, *cpy;
388 pset *copy = pset_new_ptr(pset_count(b));
391 foreach_pset(b, cpy) {pset_insert_ptr(copy, cpy);}
392 foreach_pset(a, a_node) {
393 foreach_pset(copy, cpy) {
394 if (values_contemp(a_node, cpy) != 0)
403 static void create_Edge(entity *a, entity *b, void *env) {
405 /* create a node in afgraph */
407 spilloc_env_t *spi = env;
409 pset *nodes_a,*nodes_b;
414 nodes_a = ((pset *)pmap_get(spi->ent_nodes, a));
415 nodes_b = ((pset *)pmap_get(spi->ent_nodes, b));
417 if(nodes_a && nodes_b)aff = count_Edge_Affinity(nodes_a, nodes_b);
422 edg = obstack_alloc(&spi->ob, sizeof(*edg));
426 node = (Node *)pmap_get(spi->afgraph, a);
427 edg->vtx_src = node->vtx;
429 node = (Node *)pmap_get(spi->afgraph, b);
430 edg->vtx_tgt = node->vtx;
434 node = pmap_get(spi->afgraph, a);
435 pset_insert_ptr(node->edges, b);
436 node = pmap_get(spi->afgraph, b);
437 pset_insert_ptr(node->edges, a);
438 pset_insert_ptr(spi->afgraph_es, edg);
442 static void Cli_ents(int start, int end, int nr, void *env) {
444 spilloc_env_t *spi = env;
445 pset *surrounder = pset_new_ptr_default();
450 foreach_pset(spi->ents, ent)
452 if((start < get_entity_offset_bytes(ent)) && (get_entity_offset_bytes(ent) < end)) {
453 pset_insert_ptr(surrounder, ent);
457 cli = obstack_alloc(&spi->ob, sizeof(*cli));
462 cli->ents = pset_new_ptr_default();
464 foreach_pset(surrounder, ent) {pset_insert_ptr(cli->ents,ent);}
465 pmap_insert(spi->Cli_ents, (void *)nr, cli);
466 del_pset(surrounder);
469 static cacheline *create_Cli_ent(struct obstack *ob) {
473 cli = obstack_alloc(ob, sizeof(*cli));
478 cli->ents = pset_new_ptr_default();
488 int wt(entity *ent1, entity *ent2) {
489 /*Relative Distance of 2 Ents == from start to start*/
491 int o1, o2, cache_blk_size, dist, wt;
493 o1 = get_entity_offset_bytes(ent1);
494 o2 = get_entity_offset_bytes(ent2);
500 if (o1 > o2) dist = (o1 - o2);
502 cache_blk_size = LINESIZE_BYTES;
503 wt = ((cache_blk_size - dist) / cache_blk_size);
504 if(wt != 0) return wt;
510 int get_edge_affinity(entity *a, entity *b, pmap *graph) {
515 if((pmap_find(graph,a))) {
516 node = pmap_get(graph, a);
517 foreach_pset(node->edges, edg) {
518 if(edg->src == a && edg->tgt == b) {
526 int compute_Entity_Cache_Affinity(entity *ent, pset *surrs, void *env) {
528 spilloc_env_t *spi = env;
533 if(pset_count(surrs) != 0) {
534 foreach_pset(surrs, sur)
536 aff = get_edge_affinity(ent, sur, spi->afgraph);
537 ela += (wt(ent, sur) * aff);
544 void ir_printf_ent_nodes(void *env) {
546 spilloc_env_t *spi = env;
553 // printf("%c", get_irg_dump_name(spi->irg));
555 nodes = pset_new_ptr_default();
556 foreach_pset(spi->ents, ent) {
557 printf("\n <%d>",ent->nr);
558 nodes = pmap_get(spi->ent_nodes, ent);
559 if(nodes) {foreach_pset(nodes, node) {printf(" %d, ", node->node_nr);}}
564 void ir_printf_ent_nodes_aff(void *env) {
566 spilloc_env_t *spi = env;
574 nodes = pset_new_ptr_default();
575 foreach_pset(spi->afgraph_es, edg) {
576 printf("\n <%d-%d> :",edg->src->nr, edg->tgt->nr);
577 printf(" %d \n", edg->aff);
581 void ir_printf_chilimbi_cachelines(spilloc_env_t env) {
583 spilloc_env_t spi = env;
589 foreach_pset(spi.chilimbi_Cli_ents, cline) {
591 foreach_pset(cline->ents, ent)
593 printf("%d,", ent->nr);
611 int Entity_values_interfere(entity *ent_A, entity *ent_B, void *env) {
613 spilloc_env_t *spi = env;
615 ir_node *node_A, *node_B;
616 pset *nodes_A = pmap_get(spi->ent_nodes, ent_A);
617 pset *nodes_B = pmap_get(spi->ent_nodes, ent_B);
619 foreach_pset(nodes_A, node_A) {
620 foreach_pset(nodes_B, node_B) {
621 if(values_interfere(node_A, node_B)) {
629 int Ents_Coalesce (entity *a, entity *b, void *env) {
631 spilloc_env_t *spi = env;
635 /* check (ent,ent)-interfere */
637 if(Entity_values_interfere(a,b,&spi) == 1) {
639 aNode = pmap_get(spi->afgraph, a);
640 bNode = pmap_get(spi->afgraph, b);
642 if(pset_find_ptr(aNode->edges,b) && pset_find_ptr(bNode->edges,a))
645 // find THE EDGE(a,b) - if exists
647 pmap_foreach(spi->afgraph_es, edg) {
648 if((edg->src == a || edg->tgt == b) || (edg->src == b || edg->tgt == a)) pmap_break(spi->afgraph_es);
650 // (a,b) are coalescable
652 if ((edg != NULL) && (edg->aff > 0))
658 // (a,b) not coalescable
665 void Check_Coalesce(void *env) {
667 /* return a subset of (ptr_set) = all potential coalescing pairs */
669 spilloc_env_t *spi = env;
670 pset *these = pset_new_ptr_default();
671 pset *those = pset_new_ptr_default();
673 entity *cpy, *ea, *eb;
676 foreach_pset(spi->ents, cpy) {
677 pset_insert_ptr(these, cpy);
678 pset_insert_ptr(those, cpy);
681 foreach_pset(these, ea) { /* (ena,enb) */
682 foreach_pset(those, eb) {
684 if(Ents_Coalesce(ea, eb, &spi) == 1)
689 /* alloc and set new information*/
690 coal = obstack_alloc(&spi->ob, sizeof(*coal));
695 pset_insert_ptr(spi->coals, coal);
707 ir_node *find_phi_ent() {
711 ir_node *looptroop() {
723 int delta_configuration_locality(entity *ent, cacheline *cli_env, void *env) {
725 spilloc_env_t *spi = env;
729 cli->ents = pset_new_ptr_default();
731 // teste ent in allen cachelines ...
732 pmap_foreach(spi->Cli_ents, cli) {
734 /* ausser der gegebenen cacheline(ent)*/
736 node = pmap_get(spi->afgraph, ent);
737 //node->vtx->ela = compute_Entity_Cache_Affinity(ent,rel,&spi);
738 node->vtx->ela = compute_Entity_Cache_Affinity(ent,(cli->ents),&spi);
747 int is_pasteable(entity *ent, pset *co) {
749 /* RETURNs 1, IF ent could be moved to CACHELine co
754 int step,curr_pos,curr_end, etc_pos, etc_end;
757 ir_type *stype = get_entity_type(ent);
759 align = get_type_alignment_bytes(stype);
760 size = get_type_size_bytes(stype);
762 // check all possible alignment-constrainted positions
763 for(step=0; (step*align) >= LINESIZE_BYTES; step++) {
764 curr_pos = (step*align);
765 curr_end = curr_pos + size;
767 // collision with prev and/or next neighbor
768 foreach_pset(co, etc) {
769 etc_pos = get_entity_offset_bytes(get_entity_type(etc));
770 etc_end = (get_entity_offset_bytes(get_entity_type(etc)) + get_type_size_bytes(get_entity_type(etc)));
772 if((etc_end < curr_pos) || (curr_end < etc_pos)) { /* (etc,ent) is OK */ }
773 else if((etc_pos < curr_pos) && (curr_pos < etc_end) && (etc_end < curr_end)) {return 0;}
774 else if((curr_pos < etc_pos) && (etc_end < curr_end)) {return 0;}
775 else if((etc_pos < curr_pos) && (curr_end < etc_end)) {return 0;}
776 else if((curr_pos < etc_pos) && (etc_pos < curr_end) && (etc_end > curr_end)) {return 0;}
779 // overlapping to next LINE
780 if(get_entity_offset_bytes(ent)+get_type_size_bytes(ent) > LINESIZE_BYTES) {return 0;}
794 entity *min_configuration_locality(cacheline *cli_env, void *env) {
796 spilloc_env_t *spi = env;
798 cacheline *cli = cli_env;
803 if(cli->ents == NULL) return NULL;
805 foreach_pset(cli->ents, ent) {
806 node = pmap_get(spi->afgraph, ent);
807 if(node->vtx->ela < min) {min = (float)node->vtx->ela; ret = node->vtx->ent;}
813 void bbcache_REORDER (void *env) {
815 spilloc_env_t *spi = env;
816 int curr_ela, line_nr;
820 pset *ws = pset_new_ptr_default();
822 cacheline *cli, *mv2cli;
824 do{ /* first, find 'some' (= 1 ?) bad for each CACHELINE */
825 pmap_foreach(spi->Cli_ents, cli) {
827 /* ents(cacheline) holen - jeweils kleinste insert(ws) und remove(cacheline(i) = cli(i)) */
829 if(min_configuration_locality(&cli, &spi) != NULL) {
831 ent = min_configuration_locality(&cli, &spi);
832 pset_insert_ptr(ws, ent); // insert(ws,ent)
833 //pset_remove_ptr(Cli_ents,ent); // cacheline_remove(i,ent)
840 /* second, PASTE them AGAIN hopefully elsewhere*/
841 copy=pset_new_ptr(pset_count(ws));
842 foreach_pset(ws, ent) {pset_insert_ptr(copy,ent);}
844 foreach_pset(copy,cpy){
846 node = pmap_get(spi->afgraph,cpy);
847 curr_ela = node->vtx->ela;
851 pmap_foreach(spi->Cli_ents, cli) { /* for each CACHELINE */
852 if(delta_configuration_locality(cpy, &cli, &spi) > curr_ela){ // condition 1
853 if((is_pasteable(cpy,&cli) != 0)) { // condition 2
862 if((mv2cli != NULL) && (line_nr > 0)) {
864 cli = pmap_get(spi->Cli_ents, line_nr);
865 pset_insert_ptr(cli->ents,cpy);
866 pset_remove_ptr(ws,cpy);
873 } while(pset_count(ws) > 0);
876 entity *MAX_affinity_ents(pset *ws, pset *layout_set, spilloc_env_t *env) {
878 //spilloc_env_t *spi = env;
879 //pset *layout = pset_new_ptr_default();
884 //foreach_pset() {layout}
886 foreach_pset(ws, ent) {
888 y = compute_Entity_Cache_Affinity(ent, layout_set, env);
900 entity *max_configuration_locality(cacheline *cli_env, void *env) {
902 spilloc_env_t *spi = env;
903 cacheline *cli = cli_env;
910 if(cli->ents == NULL) return NULL;
912 foreach_pset(cli->ents, ent) {
913 node = pmap_get(spi->afgraph, ent);
914 if(node->vtx->ela < min) {min = (float)node->vtx->ela; ret = node->vtx->ent;}
920 int check_offset(void *env) {
922 spilloc_env_t *spi = env;
927 cli_ent_set = pset_new_ptr_default();
928 if(is_pasteable(ent, cli_ent_set)) return ;
933 int is_filled(pset *cli, pset *ws) {
938 foreach_pset(ws, ent) {
939 if (is_pasteable(ent, cli)) re = 0;
945 int bbcache_CHILIMBI (void *env) {
947 spilloc_env_t *spi = env;
952 edge *edg, *max_edge;
953 entity *max, *last_max;
955 int o,p,q, x,y,z, i,j,k;
959 /* get workset: ws == (spi->ents) */
960 o = pset_count(spi->ents);
961 ws = pset_new_ptr(o);
962 foreach_pset(spi->ents,ent) {pset_insert_ptr(ws,ent);}
967 cline = create_Cli_ent(&spi->ob);
976 (1) start BY: adding the pair of ents
978 the maxinmum affinity edge
982 /* MAX affinity-edge */
983 foreach_pset(spi->afgraph_es, edg)
986 if((edg->aff > p) && (pset_find_ptr(ws, edg->src)) && (pset_find_ptr(ws, edg->tgt)))
993 o = pset_count(spi->afgraph_es);
994 if(o == 0) return -1;
996 if(is_pasteable(max_edge->src, cline->ents)) {
997 pset_insert_ptr(cline->ents, max_edge->src);
998 pset_remove_ptr(ws, max_edge->src);
1001 if(is_pasteable(max_edge->tgt, cline->ents)) {
1002 pset_insert_ptr(cline->ents, max_edge->tgt);
1003 pset_remove_ptr(ws, max_edge->tgt);
1007 /* (2) A single entity
1008 is appended to the existing layout,
1010 that increases configuration locality
1011 by the largest amount
1014 if(o == 0) return -2;
1016 o = pset_count(cline->ents);
1018 max = MAX_affinity_ents(ws, (cline->ents), spi);
1021 if((o != 0) && (max != NULL) ) { // && (max->value != NULL)
1027 // paste to layout set
1028 if(is_pasteable(max, cline->ents)) {
1029 pset_insert_ptr(cline->ents, max);
1030 pset_remove_ptr(ws, max);
1034 // get the best-fit'in entity
1035 o = pset_count(cline->ents);
1037 if(o != 0 && p != 0)
1038 max = MAX_affinity_ents(ws, (cline->ents), spi);
1040 } while( ((max != last_max) || (last_max != NULL) || (max == NULL)) && (p != 0));
1044 /* insert one "filled" cacheline */
1045 pset_insert_ptr(spi->chilimbi_Cli_ents, cline);
1047 } while(ws != NULL && pset_count(ws) > 0);
1053 void frame_information (spilloc_env_t spi) {
1058 frame = get_irg_frame_type(spi.irg);
1059 frame_align = get_type_alignment_bytes(frame);
1063 void be_spill_loc(const be_chordal_env_t *chordal_env) {
1068 int max_off, i, start, end;
1073 obstack_init(&spi.ob);
1075 spi.irg = chordal_env->irg;
1076 spi.arch = chordal_env->birg->main_env->arch_env;
1078 spi.ents = pset_new_ptr_default();
1079 spi.nodes = pset_new_ptr_default();
1080 spi.ent_nodes = pmap_create();
1089 spi.afgraph = pmap_create();
1090 spi.afgraph_es = pset_new_ptr_default();
1091 spi.afgraph_vs = pset_new_ptr_default();
1093 spi.Cli_ents = pmap_create();
1094 spi.position = pmap_create();
1095 spi.coals = pset_new_ptr_default();
1097 spi.chilimbi_Cli_ents = pset_new_ptr_default();
1102 walk_types_entities(get_irg_frame_type(chordal_env->irg), _ents, &spi);
1103 if(spi.ent_cnt != pset_count(spi.ents))
1104 spi.ent_cnt = pset_count(spi.ents);
1109 irg_walk_blkwise_graph(chordal_env->irg, NULL, _ent_nodes, &spi);
1110 if(spi.node_cnt != pset_count(spi.nodes))
1111 spi.ent_cnt = pset_count(spi.ents);
1115 create_Vertex(&spi);
1119 /* (ent,ent) -> edge */
1120 copy = pset_new_ptr(spi.ent_cnt);
1121 foreach_pset(spi.ents, ent) {pset_insert_ptr(copy,ent);}
1122 foreach_pset(copy, cpy) {
1123 foreach_pset(spi.ents, ent) {
1125 create_Edge(ent,cpy,&spi);
1132 /* ======================================================================================================*/
1133 /* ======================================================================================================*/
1134 /* ======================================================================================================*/
1135 /* ======================================================================================================*/
1137 /* use the dumb offset */
1139 /* ======================================================================================================*/
1140 /* ======================================================================================================*/
1141 /* ======================================================================================================*/
1142 /* ======================================================================================================*/
1145 /* {ent} -> max_off */
1147 foreach_pset(spi.ents, ent) {
1148 if(get_entity_offset_bytes(ent) > max_off) {max_off = get_entity_offset_bytes(ent);}
1153 /* max_off -> max_cli */
1155 while((i * LINESIZE_BYTES) < max_off){
1163 /* {ent} -> {({ent},int), ({ent},int), ({ent},int),...,({ent},int)} */
1164 for(i = 0; i < spi.cli_cnt; i++) {
1165 start = (i * LINESIZE_BYTES);
1166 end = start + LINESIZE_BYTES;
1167 Cli_ents(start, end, (i + 1), &spi);
1172 /* (ent,{ent}) -> int */
1174 for(i = 1; i <= spi.cli_cnt; i++) {
1178 cline = pmap_get(spi.Cli_ents, i);
1181 foreach_pset(spi.ents, ent) {
1182 node = pmap_get(spi.afgraph, ent);
1183 //node->vtx->ela = compute_Entity_Cache_Affinity(ent,rel,&spi);
1184 node->vtx->ela = compute_Entity_Cache_Affinity(ent,(cline->ents),&spi);
1189 /* ======================================================================================================*/
1192 /* {ent} -> {ent_position} (INIT) */
1194 foreach_pset(spi.ents, ent) {
1198 epos = obstack_alloc(&spi.ob, sizeof(*epos));
1204 pmap_insert(spi.position,ent,epos);
1207 /* {ent_position->offset} -> {ent_position} (SET) */
1209 foreach_pset(spi.ents, ent) {
1210 pos = pmap_get(spi.position, ent);
1211 pos->offset = get_entity_offset_bytes(pos->ent);
1218 /* ======================================================================================================*/
1219 /* ======================================================================================================*/
1220 /* ======================================================================================================*/
1221 /* ======================================================================================================*/
1223 /* use the initial offset */
1225 /* ======================================================================================================*/
1226 /* ======================================================================================================*/
1227 /* ======================================================================================================*/
1228 /* ======================================================================================================*/
1239 ir_printf_ent_nodes(&spi); // <ent->nr>: ir_node->node_nr, ir_node->node_nr ....
1240 ir_printf_ent_nodes_aff(&spi); // <ent->nr,ent->nr>: affinity
1243 // CHILIMBI => BBCache - algorithm
1245 bbcache_CHILIMBI(&spi);
1250 ir_printf_chilimbi_cachelines(spi);
1253 // HIGH affinity && NO values_interfere
1255 //Check_Coalesce(&spi);
1268 del_pset(spi.nodes);
1269 pmap_destroy(spi.ent_nodes);
1271 pmap_destroy(spi.afgraph);
1272 del_pset(spi.afgraph_es);
1273 del_pset(spi.afgraph_vs);
1275 pmap_destroy(spi.Cli_ents);
1276 pmap_destroy(spi.position);
1278 del_pset(spi.coals);
1280 del_pset(spi.chilimbi_Cli_ents);
1282 obstack_free(&spi.ob, NULL);