diff --git a/.vscode/settings.json b/.vscode/settings.json index 2fd5bc6..60c8f0e 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -37,6 +37,22 @@ "type_traits": "cpp", "tuple": "cpp", "typeinfo": "cpp", - "utility": "cpp" + "utility": "cpp", + "cstdarg": "cpp", + "cstddef": "cpp", + "atomic": "cpp", + "bit": "cpp", + "bitset": "cpp", + "set": "cpp", + "algorithm": "cpp", + "iterator": "cpp", + "memory": "cpp", + "memory_resource": "cpp", + "numeric": "cpp", + "random": "cpp", + "regex": "cpp", + "fstream": "cpp", + "iostream": "cpp", + "cinttypes": "cpp" } } \ No newline at end of file diff --git a/atpg b/atpg index bb8fbac..66d1f2a 100755 Binary files a/atpg and b/atpg differ diff --git a/crun b/crun index 12b724c..7adf915 100755 --- a/crun +++ b/crun @@ -2,7 +2,7 @@ clear -make -j 16 +make -j if [ $? -ne 0 ]; then echo "compile failed." diff --git a/src/circuit.cpp b/src/circuit.cpp index 5156cb3..f67abe8 100644 --- a/src/circuit.cpp +++ b/src/circuit.cpp @@ -5,67 +5,13 @@ #include #include "assert.h" -void Circuit::init_stems() { - for(auto& gate: gates) { - if(gate->outputs.size() >= 2) { - gate->stem = true; - } - if(gate->stem) { - stems.push_back(gate); - } - } - - for(Gate *g : gates) { - if(g->isPI) continue; - std::queue q; - std::unordered_map used; - q.push(g); - - while(!q.empty()) { - Gate* now = q.front(); - q.pop(); - for(Gate* in : now->inputs) { - if(in->stem) { - g->pre_stems.push_back(in); - } else if(!used[in]) { - used[in] = true; - q.push(in); - } - } - } - printf("pre: %s %d\n", g->name.c_str(), g->pre_stems.size()); - } - - for(Gate *g : gates) { - if(g->isPO) continue; - std::queue q; - std::unordered_map used; - q.push(g); - - while(!q.empty()) { - Gate* now = q.front(); - q.pop(); - for(Gate* out : now->outputs) { - if(out->stem) { - g->suc_stems.push_back(out); - } else if(!used[out]) { - used[out] = true; - q.push(out); - } - } - } - //printf("pre: %s %d\n", g->name.c_str(), g->pre_stems.size()); - } -} - - void Circuit::init_topo_index() { int topo = 1; std::queue q; std::unordered_map ins; for(Gate* gate : gates) { - ins[gate] = gate->inputs.size(); + ins[gate] = gate->fanins.size(); } for(auto in : PIs) { @@ -75,7 +21,7 @@ void Circuit::init_topo_index() { while(!q.empty()) { Gate* g = q.front(); q.pop(); - for(Gate* out : g->outputs) { + for(Gate* out : g->fanouts) { ins[out]--; if(ins[out] == 0) { out->id = topo++; @@ -83,6 +29,27 @@ void Circuit::init_topo_index() { } } } + + // 计算反向拓扑序 + topo = 1; + std::unordered_map outs; + + for(auto out : POs) { + out->rtopo = topo++; + q.push(out); + } + + while(!q.empty()) { + Gate* g = q.front(); q.pop(); + rtopo_gates.push_back(g); + for(Gate* in : g->fanins) { + outs[in]++; + if(outs[in] == in->fanouts.size()) { + in->rtopo = topo++; + q.push(in); + } + } + } } void Circuit::init_gate_level() { @@ -103,7 +70,7 @@ void Circuit::init_gate_level() { MAX_GATE_LEVEL = std::max(MAX_GATE_LEVEL, g->level); - for(Gate* out : g->outputs) { + for(Gate* out : g->fanouts) { if(out->level == -1) { out->level = g->level + 1; q.push(out); @@ -119,8 +86,8 @@ void Circuit::init_gate_level() { void Circuit::print_gates() { static const char* type2name[9] = {"AND", "NAND", "OR", "NOR", "XOR", "XNOR", "NOT", "BUF", "IN"}; for(Gate* gate : gates) { - printf("Gate: %3s (t:%4s v:%d pi:%d po:%d s:%d p:%d s0:%d s1:%d fpl0:%d fpl1:%d) Inputs:", gate->name.c_str(), type2name[gate->type], gate->value, gate->isPI, gate->isPO, gate->stem, gate->is_propagated(), gate->sa[0], gate->sa[1], gate->fault_propagate_len[0], gate->fault_propagate_len[1]); - for(Gate* in : gate->inputs) { + printf("Gate: %3s (t:%4s v:%d pi:%d po:%d s0:%d s1:%d fpl0:%d fpl1:%d) Inputs:", gate->name.c_str(), type2name[gate->type], gate->value, gate->isPI, gate->isPO, gate->fault_detected[0], gate->fault_detected[1], gate->fault_propagated_len[0], gate->fault_propagated_len[1]); + for(Gate* in : gate->fanins) { printf(" %s(%d)", in->name.c_str(), gate->is_detected(in)); } printf("\n"); @@ -129,113 +96,113 @@ void Circuit::print_gates() { bool Circuit::is_valid_circuit() { - ll flip_total_weight = 0; - ll stem_total_weight = 0; - ll fault_total_weight = 0; + // ll flip_total_weight = 0; + // ll stem_total_weight = 0; + // ll fault_total_weight = 0; - int flip_total_cnt = 0; - int stem_total_cnt = 0; - int fault_total_cnt = 0; + // int flip_total_cnt = 0; + // int stem_total_cnt = 0; + // int fault_total_cnt = 0; - ll fault_propagate_score = 0; + // ll fault_propagate_score = 0; - //printf("flip: %d, stem: %d, fault:%d\n", flip_total_weight, stem_total_weight, fault_total_weight); + // //printf("flip: %d, stem: %d, fault:%d\n", flip_total_weight, stem_total_weight, fault_total_weight); - for(Gate* g : gates) { + // for(Gate* g : gates) { - fault_propagate_score += g->fault_propagate_len[0] * fault_weight[g->id][0]; - fault_propagate_score += g->fault_propagate_len[1] * fault_weight[g->id][1]; + // fault_propagate_score += g->fault_propagate_len[0] * fault_weight[g->id][0]; + // fault_propagate_score += g->fault_propagate_len[1] * fault_weight[g->id][1]; - if(flip_need_update[g->id]) { - flip_total_weight += flip_weight[g->id]; - flip_total_cnt++; - } + // if(flip_need_update[g->id]) { + // flip_total_weight += flip_weight[g->id]; + // flip_total_cnt++; + // } - if(g->stem && g->cal_value() != g->value) { - stem_total_weight += stem_weight[g->id]; - } + // if(g->stem && g->cal_value() != g->value) { + // stem_total_weight += stem_weight[g->id]; + // } - if(g->stem && g->cal_value() == g->value) { - stem_total_cnt++; - } + // if(g->stem && g->cal_value() == g->value) { + // stem_total_cnt++; + // } - if(g->cal_propagate_len(0) != g->fault_propagate_len[0] || g->cal_propagate_len(1) != g->fault_propagate_len[1]) { - printf("WRONG-PRO-LEN: %s \n", g->name.c_str()); - print_gates(); - return false; - } + // if(g->cal_propagate_len(0) != g->fault_propagate_len[0] || g->cal_propagate_len(1) != g->fault_propagate_len[1]) { + // printf("WRONG-PRO-LEN: %s \n", g->name.c_str()); + // print_gates(); + // return false; + // } - if(g->sa[0]) { - fault_total_weight += fault_weight[g->id][0]; - fault_total_cnt += 1; - } + // if(g->sa[0]) { + // fault_total_weight += fault_weight[g->id][0]; + // fault_total_cnt += 1; + // } - if(g->sa[1]) { - fault_total_weight += fault_weight[g->id][1]; - fault_total_cnt += 1; - } + // if(g->sa[1]) { + // fault_total_weight += fault_weight[g->id][1]; + // fault_total_cnt += 1; + // } - if(g->stem) { - assert(stem_satisfied[g->id] == (g->cal_value() == g->value)); - } + // if(g->stem) { + // assert(stem_satisfied[g->id] == (g->cal_value() == g->value)); + // } - // 检查门的赋值情况 - if(g->cal_value() != g->value) { - printf("WRONG-ASSGIN: %s \n", g->name.c_str()); - return false; - } + // // 检查门的赋值情况 + // if(g->cal_value() != g->value) { + // printf("WRONG-ASSGIN: %s \n", g->name.c_str()); + // return false; + // } - // 检查 PO 的传播设定是否正确 - if(g->isPO) { - if(g->sa[g->value] != 0 || g->sa[!g->value] == 0 ) { - printf("WRONG-PO: %s \n", g->name.c_str()); - } - continue; - } + // // 检查 PO 的传播设定是否正确 + // if(g->isPO) { + // if(g->sa[g->value] != 0 || g->sa[!g->value] == 0 ) { + // printf("WRONG-PO: %s \n", g->name.c_str()); + // } + // continue; + // } - // 非 PO 情况下检查故障传播是否正确 + // // 非 PO 情况下检查故障传播是否正确 - bool sa0 = false; - bool sa1 = false; + // bool sa0 = false; + // bool sa1 = false; - for(Gate* out : g->outputs) { - if(out->cal_value() != out->value) { - assert(out->stem); - continue; - } + // for(Gate* out : g->fan_outs) { + // if(out->cal_value() != out->value) { + // assert(out->stem); + // continue; + // } - g->value = !g->value; + // g->value = !g->value; - if(out->cal_value() != out->value) { - sa0 |= out->is_propagated() && !g->value; - sa1 |= out->is_propagated() && g->value; - } + // if(out->cal_value() != out->value) { + // sa0 |= out->is_propagated() && !g->value; + // sa1 |= out->is_propagated() && g->value; + // } - g->value = !g->value; - } + // g->value = !g->value; + // } - if(sa0 != g->sa[0] || sa1 != g->sa[1]) { - printf("WRONG-SA: %s \n", g->name.c_str()); - return false; - } - } + // if(sa0 != g->sa[0] || sa1 != g->sa[1]) { + // printf("WRONG-SA: %s \n", g->name.c_str()); + // return false; + // } + // } - if(this->flip_total_weight != flip_total_weight || this->stem_total_weight != stem_total_weight || this->fault_total_weight != fault_total_weight) { - printf("CIRCUIT CHECK FAILED!\n"); - printf("[wrong] flip: %d, stem: %d, fault:%d\n", this->flip_total_weight, this->stem_total_weight, this->fault_total_weight); - printf("[right] flip: %d, stem: %d, fault:%d\n", flip_total_weight, stem_total_weight, fault_total_weight); - return false; - } + // if(this->flip_total_weight != flip_total_weight || this->stem_total_weight != stem_total_weight || this->fault_total_weight != fault_total_weight) { + // printf("CIRCUIT CHECK FAILED!\n"); + // printf("[wrong] flip: %d, stem: %d, fault:%d\n", this->flip_total_weight, this->stem_total_weight, this->fault_total_weight); + // printf("[right] flip: %d, stem: %d, fault:%d\n", flip_total_weight, stem_total_weight, fault_total_weight); + // return false; + // } - if(this->flip_total_cnt != flip_total_cnt || this->stem_total_cnt != stem_total_cnt || this->fault_total_cnt != fault_total_cnt) { - printf("CIRCUIT CHECK FAILED!\n"); - printf("[wrong] flip_cnt: %d, stem_cnt: %d, fault_cnt:%d\n", this->flip_total_cnt, this->stem_total_cnt, this->fault_total_cnt); - printf("[right] flip_cnt: %d, stem_cnt: %d, fault_cnt:%d\n", flip_total_cnt, stem_total_cnt, fault_total_weight); - return false; - } + // if(this->flip_total_cnt != flip_total_cnt || this->stem_total_cnt != stem_total_cnt || this->fault_total_cnt != fault_total_cnt) { + // printf("CIRCUIT CHECK FAILED!\n"); + // printf("[wrong] flip_cnt: %d, stem_cnt: %d, fault_cnt:%d\n", this->flip_total_cnt, this->stem_total_cnt, this->fault_total_cnt); + // printf("[right] flip_cnt: %d, stem_cnt: %d, fault_cnt:%d\n", flip_total_cnt, stem_total_cnt, fault_total_weight); + // return false; + // } - printf("%lld %lld\n", fault_propagate_score , this->fault_propagate_score); - assert(fault_propagate_score == this->fault_propagate_score); + // printf("%lld %lld\n", fault_propagate_score , this->fault_propagate_score); + // assert(fault_propagate_score == this->fault_propagate_score); return true; } diff --git a/src/circuit.h b/src/circuit.h index bef48b5..682fa32 100644 --- a/src/circuit.h +++ b/src/circuit.h @@ -10,29 +10,80 @@ using ll = long long; class Gate { public: + + // gate basic info + int id; int level; + int rtopo; std::string name; enum Type { AND, NAND, OR, NOR, XOR, XNOR, NOT, BUF, INPUT } type; int value; - bool sa[2]; - bool stem; bool isPI; bool isPO; + std::vector fanouts; + std::vector fanins; - int fault_propagate_len[2]; + // circuit-ls info + int value_satisfied; + int value_unsatisfied_cost; - std::vector pre_stems; - std::vector suc_stems; + int fault_propagated_len[2]; + int fault_propagated_weight[2]; - std::vector outputs; - std::vector inputs; + int fault_propagated_satisfied[2]; + int fault_propagated_unsatisfied_cost[2]; + + int fault_detected[2]; + int fault_detected_weight[2]; + + int fault_detected_satisfied[2]; + int fault_detected_unsatisfied_cost[2]; + + int CC; bool is_propagated(); + int cal_value(); - bool cal_sa(bool x); + + bool cal_fault_detected(bool x); + bool is_detected(Gate* one_of_input); + int cal_propagate_len(bool x); + + // ( partical ) score + + // score(x) = for y in neibor(x) { ~V_x,V_y make - ~V_x,V_y break } + // [ cal_FPL(~Vx, fanouts) - cal_FPL(Vx, fanouts) ] * FLP_WEIGHT(x) + // [ cal_FD(~Vx, fanouts) - cal_FD(Vx, fanouts) ] * FD_WEIGHT(x) + + // [ cal_FPLS(~Vx, fanouts) - cal_FPLS(Vx, fanouts) ] * - FPLS_COST(x) + // [ cal_FDS(~Vx, fanouts) - cal_FDS(Vx, fanouts) ] * - FDS_COST(x) + + int score; + + int score_value_unsatisfied_cost; + + int score_fault_propagated_weight[2]; + int score_fault_propagated_unsatisfied_cost[2]; + + int score_fault_detected_weight[2]; + int score_fault_detected_unsatisfied_cost[2]; + + // score calculation function + + int cal_score(); + + int cal_value_unsatisfied_cost(); + + int cal_score_fault_propagated_weight(int sa); + + int cal_score_fault_propagated_unsatisfied_cost(int sa); + + int cal_score_fault_detected_weight(int sa); + + int cal_score_fault_detected_unsatisfied_cost(int sa); }; class Fault { @@ -47,84 +98,31 @@ public: std::vector PIs; std::vector POs; std::vector gates; -std::vector stems; // PI + stems +std::vector rtopo_gates; + std::unordered_map name2gate; -std::queue tmp; -std::unordered_map tmp_used; +// std::queue tmp; +// std::unordered_map tmp_used; + +void init_topo_index(); +int MAX_GATE_LEVEL; +void init_gate_level(); void parse_from_file(const char *filename); void print_gates(); bool is_valid_circuit(); -void init_topo_index(); - -int MAX_GATE_LEVEL; -void init_gate_level(); -void init_stems(); - // local search - bool local_search(std::unordered_set &faults); -// incremental flip struct - -const double SP = 0.01; - -const int FLIP_INC = 1; -const int FLIP_WEIGHT_MAX = 1e9; - -int* CC; - -ll flip_total_weight; -int flip_total_cnt; -int* flip_weight; -int* flip_need_update; -std::vector flip_update_queue; - -// incremental stem struct -int STEM_INC = 0; -const int STEM_WEIGHT_MAX = 1e9; -ll stem_total_weight; -int stem_total_cnt; -int* stem_weight; -int* stem_satisfied; - -int fault_propagate_tatal_len; -ll fault_propagate_score; - -const int FAULT_INC = 1; -const int FAULT_WEIGHT_MAX = 20; -ll fault_total_weight; -int fault_total_cnt; -int** fault_weight; -int** fault_detected; - -void ls_init_circuit(); -void ls_init_weight(const std::unordered_set &faults); +void ls_init_circuit(std::unordered_set &faults); void ls_update_weight(); -void ls_init_data_structs(); - -void ls_block_recal(Gate* stem); +Gate* ls_pick(); void ls_flip(Gate* stem); void ls_update(Gate* stem); -ll ls_pick_score(Gate* stem); - -ll ls_score(); - -int** simulate(); - -// time status - -int flip_cnt = 0; -double flip_time = 0; - -int update_cnt = 0; -double update_time = 0; - -std::unordered_set stem_unsatisfied_set; }; \ No newline at end of file diff --git a/src/gate.cpp b/src/gate.cpp index c2e1b23..269ae3a 100644 --- a/src/gate.cpp +++ b/src/gate.cpp @@ -7,9 +7,9 @@ int Gate::cal_propagate_len(bool x) { int fpl[2]; fpl[0] = fpl[1] = 0; - for(Gate* out : outputs) { + for(Gate* out : fanouts) { if(!out->is_detected(this)) continue; - fpl[!value] = std::max(fpl[!value], out->fault_propagate_len[!out->value] + 1); + fpl[!value] = std::max(fpl[!value], out->fault_propagated_len[!out->value] + 1); } return fpl[x]; } @@ -22,10 +22,10 @@ bool Gate::is_detected(Gate* one_of_input) { } bool Gate::is_propagated() { - return sa[0] || sa[1]; + return fault_detected[0] || fault_detected[1]; } -bool Gate::cal_sa(bool x) { +bool Gate::cal_fault_detected(bool x) { if(isPO) { if(x == 0) return value; else return !value; @@ -34,7 +34,7 @@ bool Gate::cal_sa(bool x) { bool sa0 = 0; bool sa1 = 0; - for(Gate* out : outputs) { + for(Gate* out : fanouts) { if(!out->is_propagated()) continue; if(out->cal_value() != out->value) continue; @@ -56,47 +56,47 @@ int Gate::cal_value() { switch(type) { case NOT: - res = !inputs[0]->value; + res = !fanins[0]->value; break; case BUF: - res = inputs[0]->value; + res = fanins[0]->value; break; case AND: - res = inputs[0]->value; - for(int i=1; ivalue; + res = fanins[0]->value; + for(int i=1; ivalue; } break; case NAND: - res = inputs[0]->value; - for(int i=1; ivalue; + res = fanins[0]->value; + for(int i=1; ivalue; } res = !res; break; case OR: - res = inputs[0]->value; - for(int i=1; ivalue; + res = fanins[0]->value; + for(int i=1; ivalue; } break; case NOR: - res = inputs[0]->value; - for(int i=1; ivalue; + res = fanins[0]->value; + for(int i=1; ivalue; } res = !res; break; case XOR: - res = inputs[0]->value; - for(int i=1; ivalue; + res = fanins[0]->value; + for(int i=1; ivalue; } break; case XNOR: - res = inputs[0]->value; - for(int i=1; ivalue; + res = fanins[0]->value; + for(int i=1; ivalue; } res = !res; break; diff --git a/src/ls.cpp b/src/ls.cpp index 328e35f..52530d9 100644 --- a/src/ls.cpp +++ b/src/ls.cpp @@ -10,112 +10,18 @@ bool Circuit::local_search(std::unordered_set &faults) { - // 初始化并重置所有 ls 数据结构 - ls_init_data_structs(); - - // 赋值初始权重 - ls_init_weight(faults); - // 随机生成初始电路 - ls_init_circuit(); + ls_init_circuit(faults); + + printf("generate random circuit done!\n"); + exit(0); //printf("local search!\n"); while(true) { - - // int ustem = 0; - // for(Gate* stem : stems) { - // ustem += !stem_satisfied[stem->id]; - // } - // printf("ustem: %d %d\n", ustem, stem_unsatisfied_set.size()); - // assert(ustem == stem_unsatisfied_set.size()); - - auto start = std::chrono::system_clock::now(); - - Gate* stem = nullptr; - ll max_score = 0; - - const int T = 20; - - for(int i=0; iid]) continue; - - ll t_score = ls_pick_score(t_stem); - if(t_score > max_score) { - max_score = t_score; - stem = t_stem; - } - } - - 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; - } - - auto end = std::chrono::system_clock::now(); - std::chrono::duration elapsed_seconds = end - start; - flip_cnt++; - flip_time += elapsed_seconds.count(); - - } else { - ls_update_weight(); - - if(stem_total_cnt == stems.size()) { - 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); - } - //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 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; - } - - auto end = std::chrono::system_clock::now(); - std::chrono::duration elapsed_seconds = end - start; - update_cnt++; - update_time += elapsed_seconds.count(); - //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); + Gate* gate = ls_pick(); + if(gate == nullptr) { + break; } } @@ -128,7 +34,7 @@ bool Circuit::local_search(std::unordered_set &faults) { std::unordered_set tmp = faults; for(Fault* f : tmp) { - if(f->gate->sa[f->type]) { + if(f->gate->fault_detected[f->type]) { faults.erase(f); } } @@ -137,425 +43,66 @@ bool Circuit::local_search(std::unordered_set &faults) { printf("coverage: %.3f%%\tpattern: %d\tbefore: %d\tnow: %d\n", (double)(original_faults - faults.size()) / (original_faults) * 100, ++pattern, tmp.size(), faults.size()); - printf("flip-cnt: %d flip-time: %.3fs update-cnt: %d update-time: %.3fs\n", flip_cnt, flip_time, update_cnt, update_time); - printf("time-per-flip: %.2fms time-per-update: %.2fms\n", flip_time / flip_cnt * 1000, update_time / update_cnt * 1000); - - //if(tmp.size() == faults.size()) return false; + if(tmp.size() == faults.size()) return false; return true; } +Gate* Circuit::ls_pick() { + return nullptr; +} + +void Circuit::ls_flip(Gate* gate) { + + gate->value ^= 1; + + for(Gate* g : gate->fanouts) { + g->value_satisfied = ( g->cal_value() == g->value ); + } + + + +} + void Circuit::ls_update_weight() { - STEM_INC += 1; - 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; - } - } - } - } - - 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; - fault_propagate_score += FAULT_INC * (g->fault_propagate_len[0]); - } - - 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; - fault_propagate_score += FAULT_INC * (g->fault_propagate_len[1]); - } - } - } -} - - -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) { +void Circuit::ls_init_circuit(std::unordered_set &faults) { - 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 + fault_propagate_tatal_len; - ll score = - flip_total_weight - stem_total_weight + fault_propagate_score + fault_total_weight; - return score; -} - -void Circuit::ls_init_weight(const std::unordered_set &faults) { - for(Gate* s : stems) { - stem_weight[s->id] = 1; - stem_total_weight += stem_weight[s->id]; + // init value, weight and cost + for(Gate* g : gates) { + g->value = rand() % 2; + g->value_unsatisfied_cost = 1; + g->fault_propagated_weight[0] = g->fault_propagated_weight[1] = 0; + g->fault_propagated_unsatisfied_cost[0] = g->fault_propagated_unsatisfied_cost[1] = 1; + g->fault_detected_weight[0] = g->fault_detected_weight[1] = 0; + g->fault_detected_unsatisfied_cost[0] = g->fault_detected_unsatisfied_cost[1] = 1; } for(Fault* f : faults) { - fault_weight[f->gate->id][f->type] = 1; + f->gate->fault_propagated_weight[f->type] = 1; + f->gate->fault_detected_weight[f->type] = 1; } - // int r = rand() % faults.size(); - // auto it = faults.begin(); - // std::advance(it, r); - - // fault_weight[(*it)->gate->id][(*it)->type] = 1000000; - - for(Gate* s: stems) { - flip_weight[s->id] = 1; + for(Gate* g : rtopo_gates) { + g->value_satisfied = ( g->cal_value() == g->value ); + g->fault_propagated_len[0] = g->cal_propagate_len(0); + g->fault_propagated_len[1] = g->cal_propagate_len(1); + g->fault_propagated_satisfied[0] = g->fault_propagated_satisfied[1] = 0; + g->fault_detected_satisfied[0] = g->fault_detected_satisfied[1] = 0; } -} - -void Circuit::ls_init_circuit() { + // cal score for(Gate* g : gates) { - g->sa[0] = 0; - g->sa[1] = 0; + g->score = g->cal_score(); + printf("%d ", g->score); } - for(Gate* s : stems) { - s->value = rand() % 2; - } - - for(int i=stems.size()-1; i>=0; i--) { - ls_update(stems[i]); - } - - 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; ifault_propagate_len[0] = 0; - g->fault_propagate_len[1] = 0; - } -} - - -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_unsatisfied_set.erase(stem); - - stem_satisfied[stem->id] = true; - stem_total_weight -= stem_weight[stem->id]; - stem_total_cnt += 1; - for(Gate* pre : stem->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(stem->cal_value() != stem->value && stem_satisfied[stem->id]) { - stem_unsatisfied_set.insert(stem); - - stem_satisfied[stem->id] = false; - stem_total_weight += stem_weight[stem->id]; - stem_total_cnt -= 1; - for(Gate* pre : stem->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(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; - - for(Gate* pre : stem->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(stem->sa[stem->value] == true) { - fault_total_weight -= fault_weight[stem->id][stem->value]; - fault_total_cnt -= 1; - stem->sa[stem->value] = false; - - for(Gate* pre : stem->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; - } - } - } - - static std::queue q; - static std::unordered_map used; - assert(q.empty()); - used.clear(); - - q.push(stem); - - while(!q.empty()) { - Gate* g = q.front(); - q.pop(); - used[g] = false; - for(Gate* out : g->outputs) { - if(out->stem) { - continue; - } - out->value = out->cal_value(); - if(!used[out]) { - used[out] = true; - q.push(out); - } - } - } - - assert(q.empty()); - used.clear(); - - for(Gate* stem : stem->suc_stems) { - q.push(stem); - - int fpl0 = stem->cal_propagate_len(0); - int fpl1 = stem->cal_propagate_len(1); - - if(fault_weight[stem->id][0]) { - fault_propagate_tatal_len += (fpl0 - stem->fault_propagate_len[0]); - } - - if(fault_weight[stem->id][1]) { - fault_propagate_tatal_len += (fpl1 - stem->fault_propagate_len[1]); - } - - fault_propagate_score += (fault_weight[stem->id][0] * (fpl0 - stem->fault_propagate_len[0])); - fault_propagate_score += (fault_weight[stem->id][1] * (fpl1 - stem->fault_propagate_len[1])); - - stem->fault_propagate_len[0] = fpl0; - stem->fault_propagate_len[1] = fpl1; - - if(stem->cal_value() == stem->value && !stem_satisfied[stem->id]){ - stem_unsatisfied_set.erase(stem); - 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_unsatisfied_set.insert(stem); - 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; - - for(Gate* in : g->inputs) { - - bool old_sa[2]; - old_sa[0] = in->sa[0]; - old_sa[1] = in->sa[1]; - - in->sa[0] = in->cal_sa(0); - in->sa[1] = in->cal_sa(1); - - 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; - } - } - - int fpl0 = in->cal_propagate_len(0); - int fpl1 = in->cal_propagate_len(1); - - // if(in->name == "422") { - // printf("%s changed: %d fpl0: %d fpl1: %d \n", in->name.c_str(), (in->fault_propagate_len[0] != fpl0 || in->fault_propagate_len[1] != fpl1), fpl0, fpl1); - // } - - if(in->stem && !in->isPI && (in->fault_propagate_len[0] != fpl0 || in->fault_propagate_len[1] != fpl1)) { - - 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(fault_weight[in->id][0]) { - fault_propagate_tatal_len += fpl0 - in->fault_propagate_len[0]; - } - - if(fault_weight[in->id][1]) { - fault_propagate_tatal_len += fpl1 - in->fault_propagate_len[1]; - } - - fault_propagate_score += fault_weight[in->id][0] * (fpl0 - in->fault_propagate_len[0]); - fault_propagate_score += fault_weight[in->id][1] * (fpl1 - in->fault_propagate_len[1]); - - in->fault_propagate_len[0] = fpl0; - in->fault_propagate_len[1] = fpl1; - - 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; - } - } - - if(!in->stem && !used[in]) { - used[in] = true; - q.push(in); - } - } - } } \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index e842258..314c401 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -17,7 +17,6 @@ int main(int args, char* argv[]) { printf("parsing file %s ...", argv[1]); circuit->parse_from_file(argv[1]); - circuit->init_stems(); circuit->init_topo_index(); circuit->init_gate_level(); printf(" Done.\n"); @@ -26,7 +25,6 @@ int main(int args, char* argv[]) { printf("PI:\t%ld\n", circuit->PIs.size()); printf("PO:\t%ld\n", circuit->POs.size()); printf("Gate:\t%ld\n", circuit->name2gate.size()); - printf("Stem:\t%ld\n", circuit->stems.size()); printf("Level:\t%d\n", circuit->MAX_GATE_LEVEL); printf("================================ \n"); diff --git a/src/options.h b/src/options.h new file mode 100644 index 0000000..1996ed8 --- /dev/null +++ b/src/options.h @@ -0,0 +1,7 @@ +const double SP = 0.01; + +const int STEM_INC = 0; +const int STEM_WEIGHT_MAX = 1e9; + +const int FAULT_INC = 1; +const int FAULT_WEIGHT_MAX = 20; diff --git a/src/parser.cpp b/src/parser.cpp index 438d432..6de1483 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -73,8 +73,6 @@ void Circuit::parse_from_file(const char *filename) { Gate* gate = new Gate(); gate->name = tokens[0]; - gate->sa[0] = gate->sa[1] = false; - gate->stem = false; gate->isPI = false; gate->isPO = false; @@ -87,8 +85,8 @@ void Circuit::parse_from_file(const char *filename) { auto in_gate = name2gate[in]; - gate->inputs.push_back(in_gate); - in_gate->outputs.push_back(gate); + gate->fanins.push_back(in_gate); + in_gate->fanouts.push_back(gate); } if(tokens[2] == "AND") { gate->type = Gate::AND; } @@ -113,8 +111,6 @@ void Circuit::parse_from_file(const char *filename) { Gate* gate = new Gate(); gate->name = tokens[2]; gate->type = Gate::INPUT; - gate->sa[0] = gate->sa[1] = false; - gate->stem = true; gate->isPI = true; gate->isPO = false; @@ -142,7 +138,6 @@ void Circuit::parse_from_file(const char *filename) { Gate* po = name2gate[po_name]; po->isPO = true; - po->stem = true; POs.push_back(po); } } \ No newline at end of file diff --git a/src/score.cpp b/src/score.cpp new file mode 100644 index 0000000..09046e8 --- /dev/null +++ b/src/score.cpp @@ -0,0 +1,129 @@ +#include "circuit.h" + + +int Gate::cal_score() { + score_value_unsatisfied_cost = cal_value_unsatisfied_cost(); + score_fault_propagated_weight[0] = cal_score_fault_propagated_weight(0); + score_fault_propagated_weight[1] = cal_score_fault_propagated_weight(1); + + score_fault_propagated_unsatisfied_cost[0] = cal_score_fault_propagated_unsatisfied_cost(0); + score_fault_propagated_unsatisfied_cost[1] = cal_score_fault_propagated_unsatisfied_cost(1); + + score_fault_detected_weight[0] = cal_score_fault_detected_weight(0); + score_fault_detected_weight[1] = cal_score_fault_detected_weight(1); + + score_fault_detected_unsatisfied_cost[0] = cal_score_fault_detected_unsatisfied_cost(0); + score_fault_detected_unsatisfied_cost[1] = cal_score_fault_detected_unsatisfied_cost(1); + + return - score_value_unsatisfied_cost + + score_fault_propagated_weight[0] + score_fault_propagated_weight[1] + - score_fault_propagated_unsatisfied_cost[0] - score_fault_propagated_unsatisfied_cost[1] + + score_fault_detected_weight[0] + score_fault_detected_weight[1] + - score_fault_detected_unsatisfied_cost[0] - score_fault_detected_unsatisfied_cost[1]; +} + +int Gate::cal_value_unsatisfied_cost() { + int res = 0; + value ^= 1; + for(Gate* g : fanouts) { + if(g->value_satisfied && g->cal_value() != g->value) { + res += g->value_unsatisfied_cost; + } + if(!g->value_satisfied && g->cal_value() == g->value) { + res -= g->value_unsatisfied_cost; + } + } + if(this->value_satisfied) { + res += this->value_unsatisfied_cost; + } else { + res -= this->value_unsatisfied_cost; + } + value ^= 1; + return res; +} + +int Gate::cal_score_fault_propagated_weight(int sa) { + int res = 0; + value ^= 1; + + int origin_fault_propagated_len = this->fault_propagated_len[sa]; + this->fault_propagated_len[sa] = this->cal_propagate_len(sa); + + res += (this->fault_propagated_len[sa] - origin_fault_propagated_len ) * this->fault_propagated_weight[sa]; + for(Gate* g : fanins) { + res += ( g->cal_propagate_len(sa) - g->fault_propagated_len[sa] ) * g->fault_propagated_weight[sa]; + } + + this->fault_propagated_len[sa] = origin_fault_propagated_len; + + value ^= 1; + return res; +} + +int Gate::cal_score_fault_propagated_unsatisfied_cost(int sa) { + int res = 0; + value ^= 1; + int origin_fault_propagated_len = this->fault_propagated_len[sa]; + this->fault_propagated_len[sa] = this->cal_propagate_len(sa); + + if(!this->fault_propagated_satisfied[sa]) { + res -= this->fault_propagated_unsatisfied_cost[res]; + } + + for(Gate* g : fanins) { + if(g->fault_propagated_satisfied[sa] && g->cal_propagate_len(sa) != g->fault_propagated_len[sa]) { + res += g->fault_propagated_unsatisfied_cost[sa]; + } + if(!g->fault_propagated_satisfied[sa] && g->cal_propagate_len(sa) == g->fault_propagated_len[sa]) { + res -= g->fault_propagated_unsatisfied_cost[sa]; + } + } + + this->fault_propagated_len[sa] = origin_fault_propagated_len; + value ^= 1; + return res; +} + +int Gate::cal_score_fault_detected_weight(int sa) { + int res = 0; + value ^= 1; + + int origin_fault_detected = this->fault_detected[sa]; + this->fault_detected[sa] = this->cal_fault_detected(sa); + res += ( this->fault_detected[sa] - origin_fault_detected ) * this->fault_detected_weight[sa]; + + for(Gate* g : fanins) { + res += ( g->cal_fault_detected(sa) - g->fault_detected[sa] ) * this->fault_detected_weight[sa]; + } + + this->fault_detected[sa] = origin_fault_detected; + + value ^= 1; + return res; +} + +int Gate::cal_score_fault_detected_unsatisfied_cost(int sa) { + int res = 0; + value ^= 1; + + int origin_fault_detected = this->fault_detected[sa]; + this->fault_detected[sa] = this->cal_fault_detected(sa); + + if(!this->fault_detected_satisfied[sa]) { + res -= this->fault_detected_unsatisfied_cost[sa]; + } + + for(Gate* g : fanins) { + if(g->fault_detected_satisfied[sa] && g->cal_fault_detected(sa) != g->fault_detected[sa]) { + res += g->fault_detected_unsatisfied_cost[sa]; + } + if(!g->fault_detected_satisfied[sa] && g->cal_fault_detected(sa) == g->fault_detected[sa]) { + res -= g->fault_detected_unsatisfied_cost[sa]; + } + } + + this->fault_detected[sa] = origin_fault_detected; + + value ^= 1; + return res; +} \ No newline at end of file