YuhangQ/atpg-ls
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

同步代码

Browse Source
This commit is contained in:
YuhangQ 2023-05-07 04:48:44 +00:00
parent 78df039924
commit cc370586ae
11 changed files with 406 additions and 749 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
.vscode/settings.json vendored
View File

@ -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"
}
}

BIN
atpg
View File

Binary file not shown.

2
crun
View File

@ -2,7 +2,7 @@
clear
make -j 16
make -j
if [ $? -ne 0 ]; then
echo "compile failed."

251
src/circuit.cpp
View File

@ -5,67 +5,13 @@
#include <unordered_set>
#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<Gate*> q;
std::unordered_map<Gate*, bool> 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<Gate*> q;
std::unordered_map<Gate*, bool> 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<Gate*> q;
std::unordered_map<Gate*, int> 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<Gate*, int> 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;
}

140
src/circuit.h
View File

@ -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<Gate*> fanouts;
std::vector<Gate*> fanins;
int fault_propagate_len[2];
// circuit-ls info
int value_satisfied;
int value_unsatisfied_cost;
std::vector<Gate*> pre_stems;
std::vector<Gate*> suc_stems;
int fault_propagated_len[2];
int fault_propagated_weight[2];
std::vector<Gate*> outputs;
std::vector<Gate*> 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<Gate*> PIs;
std::vector<Gate*> POs;
std::vector<Gate*> gates;
std::vector<Gate*> stems; // PI + stems
std::vector<Gate*> rtopo_gates;
std::unordered_map<std::string, Gate*> name2gate;
std::queue<Gate*> tmp;
std::unordered_map<Gate*, bool> tmp_used;
// std::queue<Gate*> tmp;
// std::unordered_map<Gate*, bool> 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<Fault*> &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<Gate*> 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<Fault*> &faults);
void ls_init_circuit(std::unordered_set<Fault*> &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<Gate*> stem_unsatisfied_set;
};

50
src/gate.cpp
View File

@ -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; i<inputs.size(); i++) {
res &= inputs[i]->value;
res = fanins[0]->value;
for(int i=1; i<fanins.size(); i++) {
res &= fanins[i]->value;
}
break;
case NAND:
res = inputs[0]->value;
for(int i=1; i<inputs.size(); i++) {
res &= inputs[i]->value;
res = fanins[0]->value;
for(int i=1; i<fanins.size(); i++) {
res &= fanins[i]->value;
}
res = !res;
break;
case OR:
res = inputs[0]->value;
for(int i=1; i<inputs.size(); i++) {
res |= inputs[i]->value;
res = fanins[0]->value;
for(int i=1; i<fanins.size(); i++) {
res |= fanins[i]->value;
}
break;
case NOR:
res = inputs[0]->value;
for(int i=1; i<inputs.size(); i++) {
res |= inputs[i]->value;
res = fanins[0]->value;
for(int i=1; i<fanins.size(); i++) {
res |= fanins[i]->value;
}
res = !res;
break;
case XOR:
res = inputs[0]->value;
for(int i=1; i<inputs.size(); i++) {
res ^= inputs[i]->value;
res = fanins[0]->value;
for(int i=1; i<fanins.size(); i++) {
res ^= fanins[i]->value;
}
break;
case XNOR:
res = inputs[0]->value;
for(int i=1; i<inputs.size(); i++) {
res ^= inputs[i]->value;
res = fanins[0]->value;
for(int i=1; i<fanins.size(); i++) {
res ^= fanins[i]->value;
}
res = !res;
break;

547
src/ls.cpp
View File

@ -10,112 +10,18 @@
bool Circuit::local_search(std::unordered_set<Fault*> &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; i<T; i++) {
Gate* t_stem = stems[rand()%stems.size()];
if(!CC[t_stem->id]) 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<double> 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<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;
}
auto end = std::chrono::system_clock::now();
std::chrono::duration<double> 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<Fault*> &faults) {
std::unordered_set<Fault*> 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<Fault*> &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<Fault*> &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<Fault*> &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; 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];
}
}
STEM_INC = 1;
fault_propagate_score = 0;
fault_propagate_tatal_len = 0;
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;
}
for(Gate *g : gates) {
g->fault_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<Gate*> q;
static std::unordered_map<Gate*, int> 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);
}
}
}
}

2
src/main.cpp
View File

@ -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");

7
src/options.h Normal file
View File

@ -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;

9
src/parser.cpp
View File

@ -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);
}
}

129
src/score.cpp Normal file
View File

@ -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;
}