Maybe implemented BF solver (don't tested yet).

[libfirm] / heuristical.c

diff --git a/heuristical.c b/heuristical.c
index 48c7dc9..23d0488 100644 (file)
--- a/heuristical.c
+++ b/heuristical.c
@@ -855,17 +855,11 @@ static void apply_brute_force_reductions(pbqp *pbqp)
 
 static unsigned get_minimal_alternative(pbqp *pbqp, pbqp_node *node)
 {
-       pbqp_edge   *edge;
        vector      *node_vec;
-       vector      *vec;
-       pbqp_matrix *mat;
-       unsigned     edge_index;
-       unsigned     max_degree   = 0;
        unsigned     node_index;
        unsigned     node_len;
        unsigned     min_index    = 0;
        num          min          = INF_COSTS;
-       int          is_src;
 
        assert(pbqp);
        assert(node);
@@ -873,7 +867,7 @@ static unsigned get_minimal_alternative(pbqp *pbqp, pbqp_node *node)
        node_len = node_vec->len;
 
        for (node_index = 0; node_index < node_len; ++node_index) {
-               num value = node_vec->entries[node_index].data;
+               num value;
 
                /* Some node buckets and the edge bucket should be empty. */
                assert(node_bucket_get_length(node_buckets[1]) == 0);
@@ -885,15 +879,39 @@ static unsigned get_minimal_alternative(pbqp *pbqp, pbqp_node *node)
                pbqp_node_bucket *bucket_deg3 = node_bucket_deep_copy(node_buckets[3]);
                pbqp_node_bucket *bucket_red  = node_bucket_deep_copy(reduced_bucket);
 
-               /* TODO */
+               /* Select alternative and solve PBQP recursively. */
+               select_alternative(node, node_index);
                apply_brute_force_reductions(pbqp);
 
+               value = determine_solution(pbqp->dump_file);
+
                if (value < min) {
                        min = value;
                        min_index = node_index;
                }
+
+               /* Some node buckets and the edge bucket should still be empty. */
+               assert(node_bucket_get_length(node_buckets[1]) == 0);
+               assert(node_bucket_get_length(node_buckets[2]) == 0);
+               assert(edge_bucket_get_length(edge_bucket)     == 0);
+
+               /* Clear modified buckets... */
+               node_bucket_clear(&node_buckets[0]);
+               node_bucket_clear(&node_buckets[3]);
+               node_bucket_clear(&reduced_bucket);
+
+               /* ... and restore old PBQP state. */
+               node_bucket_copy(&node_buckets[0], bucket_deg0);
+               node_bucket_copy(&node_buckets[3], bucket_deg3);
+               node_bucket_copy(&reduced_bucket, bucket_red);
+
+               /* Free copies. */
+               node_bucket_free(bucket_deg0);
+               node_bucket_free(bucket_deg3);
+               node_bucket_free(bucket_red);
        }
-       return 0;
+
+       return min_index;
 }
 
 void apply_Brute_Force(pbqp *pbqp)