atpg-ls/ls.cpp

#include "circuit.h"

#include <queue>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include "assert.h"

bool Circuit::local_search(std::unordered_set<Fault*> &faults) {

    STEM_INC = 0;

    // 初始化并重置所有 ls 数据结构
    ls_init_data_structs();

    // 赋值初始权重
    ls_init_weight(faults);

    // 随机生成初始电路
    ls_init_circuit();
    
    printf("local search!\n");

    while(true) {

        Gate* stem = nullptr;
        ll max_score = 0;
        
        std::vector<Gate*> stems_random;
        std::vector<Gate*> candidates;

        for(int i=0; i<stems.size(); i++) {
            if(CC[stems[i]->id]) {
                stems_random.push_back(stems[i]);
            }
        }
        for(int i=0; i<stems_random.size(); i++) {
            std::swap(stems_random[i], stems_random[rand()%stems_random.size()]);
        }

        const int T = 50;
        int t = 0;

        for(int i=0; i<stems_random.size(); i++) {
            Gate* t_stem = stems_random[i];
            ll t_score = ls_pick_score(t_stem);
            if(t_score > max_score) {
                max_score = t_score;
                stem = t_stem;
            }
            if(t_score > 0) t++;
            if(t >= T) break;
        }

        if(max_score > 0) {
            // printf("FLIP: %s (+%lld)\n", stem->name.c_str(), max_score);
            // printf("[LS] flip: %lld, stem: %lld, fault:%lld. flip_cnt: %d, stem_cnt: %d, fault_cnt:%d\n", flip_total_weight, stem_total_weight, fault_total_weight, flip_total_cnt, stem_total_cnt, fault_total_cnt);
            ls_flip(stem);

            CC[stem->id] = 0;

            for(Gate* pre : stem->pre_stems) {
                CC[pre->id] = 1;
            }

            for(Gate* suc : stem->suc_stems) {
                CC[suc->id] = 1;
            }

        } else {
            ls_update_weight();

            while(!flip_update_queue.empty()) {
                Gate* g = flip_update_queue.back();
                flip_update_queue.pop_back();
                if(!flip_need_update[g->id]) continue;
                flip_need_update[g->id] = false;
                flip_total_weight -= flip_weight[g->id];
                flip_total_cnt -= 1;
                ls_update(g);
            }

            if(stem_total_cnt == stems.size() && flip_total_cnt == 0) {
                printf("FIND SOLUTION!\n");
                printf("[SOL] flip: %lld, stem: %lld, fault:%lld. flip_cnt: %d, stem_cnt: %d, fault_cnt:%d\n", flip_total_weight, stem_total_weight, fault_total_weight, flip_total_cnt, stem_total_cnt, fault_total_cnt);
                break;
            }

            std::vector<Gate*> candidates;
            for(Gate *g : stems) {
                if(g->isPO) continue;
                if(stem_satisfied[g->id]) continue;
                candidates.push_back(g);
            }

            if(candidates.size() == 0) {
                candidates.push_back(stems[rand()%stems.size()]);
            }

            Gate* pick = candidates[rand()%candidates.size()];

            ls_flip(pick);

            CC[pick->id] = 0;

            for(Gate* pre : pick->pre_stems) {
                CC[pre->id] = 1;
            }

            for(Gate* suc : pick->suc_stems) {
                CC[suc->id] = 1;
            }

            printf("[UP] flip: %lld, stem: %lld, fault:%lld. flip_cnt: %lld, stem_cnt: %lld, fault_cnt:%lld\n", flip_total_weight, stem_total_weight, fault_total_weight, flip_total_cnt, stem_total_cnt, fault_total_cnt);
        }
    }

    while(!flip_update_queue.empty()) {
        Gate* g = flip_update_queue.back();
        flip_update_queue.pop_back();
        if(!flip_need_update[g->id]) continue;
        flip_need_update[g->id] = false;
        flip_total_weight -= flip_weight[g->id];
        flip_total_cnt -= 1;
        ls_update(g);
    }

    static int original_faults = -1;
    if(original_faults == - 1) {
        original_faults = faults.size();
    }
    static int pattern = 0;

    std::unordered_set<Fault*> tmp = faults;

    for(Fault* f : tmp) {
        if(f->gate->sa[f->type]) {
            faults.erase(f);
        }
    }

    if(tmp.size() == faults.size()) pattern--;

    printf("coverage: %.4f\tpattern: %d\tbefore: %d\tnow: %d\n", (double)(original_faults - faults.size()) / (original_faults), ++pattern, tmp.size(), faults.size());

    //if(tmp.size() == faults.size()) return false;

    return true;
}

void Circuit::ls_update_weight() {

    STEM_INC++;

    if(rand() % 10000 <= SP * 10000) {
        for(Gate* g : gates) {
            if(g->stem && stem_satisfied[g->id] && (stem_weight[g->id] - STEM_INC >= 1)) {
                stem_weight[g->id] -= STEM_INC;
                for(Gate* suc : g->suc_stems) {
                    if(stem_weight[suc->id] + STEM_INC <= STEM_WEIGHT_MAX) {
                        stem_weight[suc->id] += STEM_INC;
                        if(!stem_satisfied[suc->id]) {
                            stem_total_weight += STEM_INC;
                        }
                    }
                }
            }
        }
    } else {
        for(Gate* g : gates) {
            if(flip_need_update[g->id] && (flip_weight[g->id] + FLIP_INC < FLIP_WEIGHT_MAX)) {
                flip_weight[g->id] += FLIP_INC;
                flip_total_weight += FLIP_INC;
            }

            if(g->stem && !stem_satisfied[g->id] && (stem_weight[g->id] + STEM_INC < STEM_WEIGHT_MAX)) {
                stem_weight[g->id] += STEM_INC;
                stem_total_weight += STEM_INC;

                for(Gate* suc : g->suc_stems) {
                    if(stem_weight[suc->id] - STEM_INC > 1) {
                        stem_weight[suc->id] -= STEM_INC;
                        if(!stem_satisfied[suc->id]) {
                            stem_total_weight -= STEM_INC;
                        }
                    }
                }
            }

            // for(int i=0; i<=1; i++) {
            //     if(!fault_weight[g->id][i]) continue;
            //     for(Gate* suc : g->suc_stems) {
            //         int inc = 0.2 * fault_weight[g->id][i];

            //         inc = std::max(inc, 1);

            //         if(fault_weight[suc->id][0] + inc <= FAULT_WEIGHT_MAX) {
            //             fault_weight[suc->id][0] += inc;
            //             if(suc->sa[0]) fault_total_weight += inc;
            //         }

            //         if(fault_weight[suc->id][1] + inc <= FAULT_WEIGHT_MAX) {
            //             fault_weight[suc->id][1] += inc;
            //             if(suc->sa[1]) fault_total_weight += inc;
            //         }

            //     }
            // }

            if(!g->sa[0] && fault_weight[g->id][0] > 0 && (fault_weight[g->id][0] + FAULT_INC < FAULT_WEIGHT_MAX)) {
                fault_weight[g->id][0] += FAULT_INC;
            }

            if(!g->sa[1] && fault_weight[g->id][1] > 0 && (fault_weight[g->id][1] + FAULT_INC < FAULT_WEIGHT_MAX)) {
                fault_weight[g->id][1] += FAULT_INC;
            }
        }
    }
}


bool cmp(Gate* a, Gate *b) {
    return a->id > b->id;
}

void Circuit::ls_flip(Gate* stem) {
    stem->value = !stem->value;
    ls_block_recal(stem);
}
void Circuit::ls_update(Gate* stem) {
    ls_block_recal(stem);
}
ll Circuit::ls_pick_score(Gate* stem) {

    ll old_score = ls_score();

    ls_flip(stem);

    ll new_score = ls_score();

    ls_flip(stem);

    old_score = std::max(old_score, ls_score());

    return new_score - old_score;
}

ll Circuit::ls_score() {
    //ll score =  -flip_total_weight -stem_total_weight + fault_total_weight;
    ll score =  -flip_total_weight -stem_total_weight + fault_total_weight;
    return score;
}

void Circuit::ls_block_recal(Gate* stem) {

    if(flip_need_update[stem->id]) {
        flip_need_update[stem->id] = false;
        flip_total_weight -= flip_weight[stem->id];
        flip_total_cnt -= 1;
    }

    if(stem->cal_value() == stem->value && !stem_satisfied[stem->id]){
        stem_satisfied[stem->id] = true;
        stem_total_weight -= stem_weight[stem->id];
        stem_total_cnt += 1;
    }
    
    if(stem->cal_value() != stem->value && stem_satisfied[stem->id]) {
        stem_satisfied[stem->id] = false;
        stem_total_weight += stem_weight[stem->id];
        stem_total_cnt -= 1;
    }

    //printf("flip: %s\n", stem->name.c_str());

    //stem->value = !stem->value;

    if(stem->isPO) {

        if(stem->sa[!stem->value] == false) {
            fault_total_weight += fault_weight[stem->id][!stem->value];
            fault_total_cnt += 1;
            stem->sa[!stem->value] = true;
        }

        if(stem->sa[stem->value] == true) {
            fault_total_weight -= fault_weight[stem->id][stem->value];
            fault_total_cnt -= 1;
            stem->sa[stem->value] = false;
        }
    }

    std::queue<Gate*> q;
    std::unordered_map<Gate*, int> used;
    std::vector<Gate*> suc_stems;

    //printf("suc: %d %d\n", suc_stems.size(), stem->suc_stems.size());

    q.push(stem);
    
    while(!q.empty()) {
        Gate* g = q.front();
        q.pop();
        used[g] = false;
        for(Gate* out : g->outputs) {
            if(out->stem) {
                suc_stems.push_back(out);
                continue;
            }
            out->value = out->cal_value();
            if(!used[out]) {
                used[out] = true;
                q.push(out);
            }
        }
    }

    // sort(suc_stems.begin(), suc_stems.end(), cmp);
    // sort(stem->suc_stems.begin(), stem->suc_stems.end(), cmp);
    // assert(suc_stems == stem->suc_stems);

    assert(q.empty());
    used.clear();

    for(Gate* stem : suc_stems) {
        q.push(stem);

        if(stem->cal_value() == stem->value && !stem_satisfied[stem->id]){
            stem_satisfied[stem->id] = true;
            stem_total_weight -= stem_weight[stem->id];
            stem_total_cnt += 1;
        }
    
        if(stem->cal_value() != stem->value && stem_satisfied[stem->id]) {
            stem_satisfied[stem->id] = false;
            stem_total_weight += stem_weight[stem->id];
            stem_total_cnt -= 1;
        }
    }

    while(!q.empty()) {
        Gate *g = q.front();
        q.pop();

        used[g] = false;

        bool right_value = (g->cal_value() == g->value);
        for(Gate* in : g->inputs) {
            in->value = !in->value;
            bool input_detected = (g->cal_value() != g->value);
            in->value = !in->value;
                
            bool sa0 = right_value && input_detected && g->sa[!g->value] && in->value;
            bool sa1 = right_value && input_detected && g->sa[!g->value] && !in->value;

            //printf("gate: %s -> %s rv: %d id: %d p:%d sa0: %d sa1: %d\n", in->name.c_str(), g->name.c_str(), right_value, input_detected, g->is_propagated(), sa0, sa1);

            in->sa_by_out[g] = std::make_pair(sa0, sa1);

            bool old_sa[2];
            old_sa[0] = in->sa[0];
            old_sa[1] = in->sa[1];

            in->sa[0] = in->sa[1] = 0;
            for(Gate* out : in->outputs) {
                auto &p = in->sa_by_out[out];
                //printf("%d %d\n", p.first, p.second);
                in->sa[0] |= p.first;
                in->sa[1] |= p.second;
            }

            if(in->stem && !in->isPI && (in->sa[0] != old_sa[0] || in->sa[1] != old_sa[1])) {

                for(Gate* pre : in->pre_stems) {
                    if(flip_need_update[pre->id]) continue;

                    flip_need_update[pre->id] = true;
                    flip_update_queue.push_back(pre);

                    flip_total_weight += flip_weight[pre->id];
                    flip_total_cnt += 1;
                }
            }

            if(old_sa[0] != in->sa[0]) {
                if(in->sa[0]) {
                    fault_total_weight += fault_weight[in->id][0];
                    fault_total_cnt += 1;
                } else {
                    fault_total_weight -= fault_weight[in->id][0];
                    fault_total_cnt -= 1;
                }
            }

            if(old_sa[1] != in->sa[1]) {
                if(in->sa[1]) {
                    fault_total_weight += fault_weight[in->id][1];
                    fault_total_cnt += 1;
                } else {
                    fault_total_weight -= fault_weight[in->id][1];
                    fault_total_cnt -= 1;
                }
            }

            //printf("gate: %s -> %s rv: %d id: %d p:%d sa0: %d sa1: %d\n", in->name.c_str(), g->name.c_str(), right_value, input_detected, g->is_propagated(), in->sa[0], in->sa[1]);
                
            if(!in->stem && !used[in]) {
                used[in] = true;
                q.push(in);
            }
        }
    }
}

void Circuit::ls_init_weight(const std::unordered_set<Fault*> &faults) {
    for(Gate* s : stems) {
        stem_weight[s->id] = 1;
        stem_total_weight += stem_weight[s->id];
    }
    for(Fault* f : faults) {
        fault_weight[f->gate->id][f->type] = 1;
    }
    for(Gate* s: stems) {
        flip_weight[s->id] = 1;
    }
}

void Circuit::ls_init_circuit() {
    // for(auto pi : PIs) {
    //     pi->value = rand() % 2;
    // }

    for(Gate* g : gates) {
        g->sa[0] = 0;
        g->sa[1] = 0;
    }

    for(Gate* s : stems) {
        s->value = rand() % 2;
    }

    for(int i=stems.size()-1; i>=0; i--) {
        ls_update(stems[i]);
    }

    //printf("flip: %lld, stem: %lld, fault:%lld\n", flip_total_weight, stem_total_weight, fault_total_weight);

    while(!flip_update_queue.empty()) {
        Gate* g = flip_update_queue.back();
        flip_update_queue.pop_back();
        if(!flip_need_update[g->id]) continue;
        flip_need_update[g->id] = false;
        flip_total_weight -= flip_weight[g->id];
        flip_total_cnt -= 1;
        ls_update(g);
    }
}

void Circuit::ls_init_data_structs() {
    const int MAX_LEN = gates.size() + 1;

    if(flip_weight == nullptr) {
        CC = new int[MAX_LEN];


        flip_weight = new int[MAX_LEN];
        flip_need_update = new int[MAX_LEN];

        stem_weight = new int[MAX_LEN];
        stem_satisfied = new int[MAX_LEN];

        fault_weight = new int*[MAX_LEN];
        for(int i=0; i<MAX_LEN; i++) {
            fault_weight[i] = new int[2];
        }
        fault_detected = new int*[MAX_LEN];
        for(int i=0; i<MAX_LEN; i++) {
            fault_detected[i] = new int[2];
        }

    }

    flip_total_weight = 0;
    flip_total_cnt = 0;

    stem_total_weight = 0;
    stem_total_cnt = 0;

    fault_total_weight = 0;
    fault_total_cnt = 0;

    for(int i=0; i<MAX_LEN; i++) {
        CC[i] = 1;
        flip_weight[i] = 0;
        flip_need_update[i] = 0;
        stem_weight[i] = 0;
        stem_satisfied[i] = 0;
        fault_weight[i][0] = 0;
        fault_weight[i][1] = 0;
        fault_detected[i][0] = 0;
        fault_detected[i][1] = 0;
    }
}