Gate::Gate(Gate* input1, Operand type, int position)
: i1(input1), t(type), p(position){
if (!is_gate(i1,t)) throw Invalid();
Vector<bool> v1 = input1->getTable();
for(bool e: v1) table.push_back(!e);
}
int dfs_enable_switch(struct dfs_table *table)
{
if (is_gate(table->switch_src_gate))
if (pwrcal_gate_enable(table->switch_src_gate))
return -1;
if (is_mux(table->switch_src_usermux))
if (pwrcal_mux_set_src(table->switch_src_usermux, 1))
return -1;
return 0;
}
void static_features::update_core(expr * e) {
m_num_exprs++;
// even if a benchmark does not contain any theory interpreted function decls, we still have to install
// the theory if the benchmark contains constants or function applications of an interpreted sort.
sort * s = m_manager.get_sort(e);
mark_theory(s->get_family_id());
bool _is_gate = is_gate(e);
bool _is_eq = m_manager.is_eq(e);
if (_is_gate) {
m_cnf = false;
m_num_nested_formulas++;
switch (to_app(e)->get_decl_kind()) {
case OP_ITE:
if (is_bool(e))
m_num_ite_formulas++;
else {
m_num_ite_terms++;
// process then&else nodes
for (unsigned i = 1; i < 3; i++) {
expr * arg = to_app(e)->get_arg(i);
acc_num(arg);
// Must check whether arg is diff logic or not.
// Otherwise, problem can be incorrectly tagged as diff logic.
sort * arg_s = m_manager.get_sort(arg);
family_id fid_arg = arg_s->get_family_id();
if (fid_arg == m_afid) {
m_num_arith_terms++;
rational k;
TRACE("diff_term", tout << "diff_term: " << is_diff_term(arg, k) << "\n" << mk_pp(arg, m_manager) << "\n";);
if (is_diff_term(arg, k)) {
m_num_diff_terms++;
acc_num(k);
}
}
}
}
break;
case OP_AND:
m_num_ands++;
break;
case OP_OR:
m_num_ors++;
break;
case OP_IFF:
m_num_iffs++;
break;
}
int dfs_disable_switch(struct dfs_table *table)
{
if (is_mux(table->switch_src_usermux))
if (pwrcal_mux_set_src(table->switch_src_usermux, 0))
return -1;
if (is_div(table->switch_src_div))
if (pwrcal_div_set_ratio(table->switch_src_div, 1))
return -1;
if (is_gate(table->switch_src_gate))
if (pwrcal_gate_disable(table->switch_src_gate))
return -1;
return 0;
}
int dfs_trans_gate(int lv_from, int lv_to, struct dfs_table *table, int opt)
{
unsigned int from;
unsigned int to;
int trans;
int i;
struct pwrcal_clk *clk;
for (i = 1; i < table->num_of_members; i++) {
clk = table->members[i];
if (is_gate(clk)) {
if (lv_from >= 0)
from = get_value(table, lv_from, i);
else
from = pwrcal_gate_is_enabled(clk);
to = get_value(table, lv_to, i);
trans = 0;
switch (opt) {
case TRANS_HIGH:
if (from < to)
trans = 1;
break;
case TRANS_LOW:
if (from > to)
trans = 1;
break;
case TRANS_DIFF:
if (from != to)
trans = 1;
break;
default:
break;
}
if (trans == 0)
continue;
if (to)
pwrcal_gate_enable(clk);
else
pwrcal_gate_disable(clk);
}
}
return 0;
}
Gate::Gate(Gate* input1, Gate* input2, Operand type, int position):
i1(input1), i2(input2), t(type), p(position)
{
if (!is_gate(i1,i2,t)) throw Invalid();
Vector<bool> v1 = input1->getTable();
Vector<bool> v2 = input2->getTable();
Vector<bool> vFinal;
if(type==Operand::AND){
for(int i=0; i<v1.size(); ++i) vFinal.push_back(v1.at(i)&&v2.at(i));}
else{
for(int i=0; i<v1.size(); ++i) vFinal.push_back(v1.at(i)||v2.at(i));}
table=vFinal;
}
static unsigned int get_rate(struct dfs_table *table)
{
int l, m;
unsigned int cur[128] = {0, };
unsigned long long rate;
struct pwrcal_clk *clk;
for (m = 1; m < table->num_of_members; m++) {
clk = table->members[m];
if (is_pll(clk)) {
rate = pwrcal_pll_get_rate(clk);
do_div(rate, 1000);
cur[m] = (unsigned int)rate;
}
if (is_mux(clk))
cur[m] = pwrcal_mux_get_src(clk);
if (is_div(clk))
cur[m] = pwrcal_div_get_ratio(clk) - 1;
if (is_gate(clk))
cur[m] = pwrcal_gate_is_enabled(clk);
}
for (l = 0; l < table->num_of_lv; l++) {
for (m = 1; m < table->num_of_members; m++)
if (cur[m] != get_value(table, l, m))
break;
if (m == table->num_of_members)
return get_value(table, l, 0);
}
if (is_pll(table->members[1])) {
for (l = 0; l < table->num_of_lv; l++)
if (cur[1] == get_value(table, l, 1))
return get_value(table, l, 0);
}
for (m = 1; m < table->num_of_members; m++) {
clk = table->members[m];
pr_err("dfs_get_rate mid : %s : %d\n", clk->name, cur[m]);
}
return 0;
}
void draw_vertical_dash(void) {
bool gate = 0;
int start = 0;
int dir = 2;
int grid_new[size_of_column+1][size_of_line-1];
int grid_new2[size_of_column+2][size_of_line];
for (int i = 0; i < size_of_column + 1; ++i)
for (int j = 0; j < size_of_line - 1; ++j)
grid_new[i][j] = 0;
for (int i = 0; i < size_of_column - 1; ++i)
for (int j = 0; j < size_of_line - 1; ++j) {
grid_new[i+1][j] = grid_transformed[i][j];
gate = is_gate(i, j, dir);
if (gate && i == 0)
grid_new[i][j] = 2;
if (gate && i == size_of_column - 2)
grid_new[i+2][j] = 2;
}
for (int i = 0; i < size_of_column + 2; ++i)
for (int j = 0; j < size_of_line; ++j)
grid_new2[i][j] = 0;
for (int i = 0; i < size_of_column; ++i)
for (int j = 0; j < size_of_line; ++j)
grid_new2[i+1][j] = grid[i][j];
for (int j = 0; j < size_of_line - 1; ++j)
for (int i = 0; i < size_of_column + 1; ++i) {
if (grid_new[i][j] == 2
&& grid_new[i+1][j] == 2
&& grid_new2[i+1][j] != 1
&& grid_new2[i+1][j] != 3
&& !start) {
printf(" \\draw[dashed, yellow] (%0.1f,%0.1f) -- ", j + 0.5, i - 1 + 0.5);
start = 1;
}
if (grid_new[i][j] == 2
&& (grid_new[i+1][j] != 2
||grid_new2[i+1][j] == 1
|| grid_new2[i+1][j] == 3
|| i == size_of_column)
&& start) {
printf("(%0.1f,%0.1f);\n", j + 0.5, i - 1 + 0.5);
start = 0;
}
}
}
/*When at the gate of path, it ends up sticking out by 0.25cm. I enlarge the grid horizontally by 1 column at each
* side so that I needn't to identify whether it's a gate or not. So is the situation when printing vertical dash.*/
void draw_horizontal_dash(void) {
bool gate = 0; //to identify if it's a gate
int start = 0;
int dir = 1;
int grid_new[size_of_column-1][size_of_line+1];
int grid_new2[size_of_column][size_of_line+2];
for (int i = 0; i < size_of_column - 1; ++i)
for (int j = 0; j < size_of_line + 1; ++j)
grid_new[i][j] = 0;
for (int i = 0; i < size_of_column - 1; ++i)
for (int j = 0; j < size_of_line - 1; ++j) {
grid_new[i][j+1] = grid_transformed[i][j];
gate = is_gate(i, j, dir);
if (gate && j == 0)
grid_new[i][j] = 2;
if (gate && j == size_of_line - 2)
grid_new[i][j+2] = 2;
}
for (int i = 0; i < size_of_column; ++i)
for (int j = 0; j < size_of_line + 2; ++j)
grid_new2[i][j] = 0;
for (int i = 0; i < size_of_column; ++i)
for (int j = 0; j < size_of_line; ++j)
grid_new2[i][j+1] = grid[i][j];
for (int i = 0; i < size_of_column - 1; ++i)
for (int j = 0; j < size_of_line + 1; ++j) {
if (grid_new[i][j] == 2
&& grid_new[i][j+1] == 2
&& grid_new2[i][j+1] < 2
&& !start) {
printf(" \\draw[dashed, yellow] (%0.1f,%0.1f) -- ", j - 1 + 0.5, i + 0.5);
start = 1;
}
if (grid_new[i][j] == 2
&& (grid_new[i][j+1] != 2
|| grid_new2[i][j+1] >= 2
|| j == size_of_line)
&& start) {
printf("(%0.1f,%0.1f);\n", j - 1 + 0.5, i + 0.5);
start = 0;
}
}
}
static int grpgate_disable(struct vclk *vclk)
{
struct pwrcal_vclk_grpgate *grpgate;
struct pwrcal_clk *cur;
struct pwrcal_clk **gates_list;
void *addr;
unsigned int value, dirty;
int i;
grpgate = to_grpgate(vclk);
gates_list = grpgate->gates;
addr = (void *)0xFFFFFFFF;
value = 0;
dirty = 0;
for (i = 0; gates_list[i] != CLK_NONE; i++) {
cur = gates_list[i];
if (!is_gate(cur))
continue;
if (addr != cur->offset) {
if (dirty == 1) {
pwrcal_writel(addr, value);
dirty = 0;
}
addr = cur->offset;
value = pwrcal_readl(addr);
}
if (value & (1 << cur->shift)) {
value &= ~(1 << cur->shift);
dirty = 1;
}
}
if (dirty == 1)
pwrcal_writel(addr, value);
return 0;
}
/*--------------------------------------------------------------
Routine : set_symbols_sens
Purpose : set sensitivity of symbols in the symbols men
---------------------------------------------------------------*/
void
set_symbols_sens(
TREE_PIC_FOREST *tree_pic_forest,
ITEM *item ) /* selected item */
{
if((item != NULL) &&
(item == tree_pic_forest->tree_pic->tree->top_item) &&
((item->child == NULL) || (item->child->type != TRANSOUT)))
{
FTAFrameSetSensitive(TRANSOUT_POS, TRUE );
} else {
FTAFrameSetSensitive(TRANSOUT_POS, FALSE );
}
if ( item != NULL ) {
if ( is_gate( item ) ) {
/* any gate */
FTAFrameSetSensitive(INTERMEDIATE_POS, TRUE );
FTAFrameSetSensitive(BASIC_POS, TRUE );
FTAFrameSetSensitive(UNDEVELOP_POS, TRUE );
FTAFrameSetSensitive(EXTERNAL_POS, TRUE );
FTAFrameSetSensitive(AND_POS, FALSE );
FTAFrameSetSensitive(OR_POS, FALSE );
FTAFrameSetSensitive(PRIORITY_AND_POS, FALSE );
FTAFrameSetSensitive(XOR_POS, FALSE );
FTAFrameSetSensitive(INHIBIT_POS, FALSE );
if ( item->child != NULL &&
( item->child->type == COND_NOT_ANAL ||
item->child->type == COND_ANAL ) )
{
/* already has a condition */
FTAFrameSetSensitive(COND_POS, FALSE );
} else {
FTAFrameSetSensitive(COND_POS, TRUE );
}
FTAFrameSetSensitive(TRANSIN_POS, TRUE );
if ( item->type == INHIBIT )
{
/* Inhibit gate, only one condition, one event */
if ( ( item->num_children >= 2 ) )
{
/* No more symbols allowed */
FTAFrameSetSensitive(INTERMEDIATE_POS, FALSE );
FTAFrameSetSensitive(BASIC_POS, FALSE );
FTAFrameSetSensitive(UNDEVELOP_POS, FALSE );
FTAFrameSetSensitive(EXTERNAL_POS, FALSE );
FTAFrameSetSensitive(TRANSIN_POS, FALSE );
FTAFrameSetSensitive(COND_POS, FALSE );
}
else
{
if ( ( item->num_children == 1 ) )
{
if ( is_condition( item->child ) )
{
FTAFrameSetSensitive(COND_POS, FALSE );
}
else
{
FTAFrameSetSensitive(INTERMEDIATE_POS, FALSE );
FTAFrameSetSensitive(BASIC_POS, FALSE );
FTAFrameSetSensitive(UNDEVELOP_POS, FALSE );
FTAFrameSetSensitive(EXTERNAL_POS, FALSE );
FTAFrameSetSensitive(COND_POS, TRUE );
FTAFrameSetSensitive(TRANSIN_POS, FALSE );
}
}
}
}
return;
}
else if ( item->type == INTERMEDIATE &&
( item->num_children == 0 ||
( item->num_children == 1 &&
item->child->type == TRANSOUT ) ) )
{
/* intermediate event with no child */
FTAFrameSetSensitive(INTERMEDIATE_POS, TRUE );
FTAFrameSetSensitive(BASIC_POS, TRUE );
FTAFrameSetSensitive(UNDEVELOP_POS, TRUE );
FTAFrameSetSensitive(EXTERNAL_POS, TRUE );
FTAFrameSetSensitive(AND_POS, TRUE );
FTAFrameSetSensitive(OR_POS, TRUE );
FTAFrameSetSensitive(PRIORITY_AND_POS, TRUE );
FTAFrameSetSensitive(XOR_POS, TRUE );
FTAFrameSetSensitive(INHIBIT_POS, TRUE );
FTAFrameSetSensitive(COND_POS, FALSE );
FTAFrameSetSensitive(TRANSIN_POS, TRUE );
return;
}
}
/* NULL, primary, condition, transfer-in, intermediate-with-child */
FTAFrameSetSensitive(INTERMEDIATE_POS, FALSE );
FTAFrameSetSensitive(BASIC_POS, FALSE );
FTAFrameSetSensitive(UNDEVELOP_POS, FALSE );
FTAFrameSetSensitive(EXTERNAL_POS, FALSE );
FTAFrameSetSensitive(AND_POS, FALSE );
FTAFrameSetSensitive(OR_POS, FALSE );
FTAFrameSetSensitive(PRIORITY_AND_POS, FALSE );
FTAFrameSetSensitive(XOR_POS, FALSE );
FTAFrameSetSensitive(INHIBIT_POS, FALSE );
FTAFrameSetSensitive(COND_POS, FALSE );
FTAFrameSetSensitive(TRANSIN_POS, FALSE );
}
int set_config(struct pwrcal_clk_set *table, int config)
{
int lidx;
int max;
unsigned long long rate;
int to;
struct pwrcal_clk *cur;
for (lidx = 0; table[lidx].clk != CLK_NONE; lidx++) {
cur = table[lidx].clk;
if (is_gate(cur)) {
to = config ? table[lidx].config1 : table[lidx].config0;
if (to != 1)
continue;
pwrcal_gate_enable(cur);
}
}
for (lidx = 0; table[lidx].clk != CLK_NONE; lidx++) {
cur = table[lidx].clk;
if (is_div(cur)) {
to = config ? table[lidx].config1 : table[lidx].config0;
if (to == -1)
continue;
if (pwrcal_div_get_ratio(cur) < to + 1)
if (pwrcal_div_set_ratio(cur, to + 1))
return -1;
}
}
for (lidx = 0; table[lidx].clk != CLK_NONE; lidx++) {
cur = table[lidx].clk;
if (is_pll(cur)) {
to = config ? table[lidx].config1 : table[lidx].config0;
if (to == -1)
continue;
if (to == 0) {
if (pwrcal_pll_disable(cur) != 0)
return -1;
continue;
}
rate = ((unsigned long long)to) * 1000;
if (pwrcal_pll_get_rate(cur) > rate) {
if (pwrcal_pll_set_rate(cur, rate))
return -1;
if (pwrcal_pll_is_enabled(cur) == 0)
if (pwrcal_pll_enable(cur))
return -1;
}
}
}
for (lidx = 0; table[lidx].clk != CLK_NONE; lidx++) {
cur = table[lidx].clk;
if (is_mux(cur)) {
to = config ? table[lidx].config1 : table[lidx].config0;
if (to == -1)
continue;
if (pwrcal_mux_get_src(cur) != to)
if (pwrcal_mux_set_src(cur, to))
return -1;
}
}
max = lidx;
for (lidx = max - 1; lidx >= 0; lidx--) {
cur = table[lidx].clk;
if (is_pll(cur)) {
to = config ? table[lidx].config1 : table[lidx].config0;
if (to == -1)
continue;
if (to == 0) {
if (pwrcal_pll_disable(cur))
return -1;
continue;
}
rate = ((unsigned long long)to) * 1000;
if (pwrcal_pll_get_rate(cur) < rate) {
if (pwrcal_pll_set_rate(cur, rate))
return -1;
if (pwrcal_pll_is_enabled(cur) == 0)
if (pwrcal_pll_enable(cur))
return -1;
}
}
}
for (lidx = max - 1; lidx >= 0; lidx--) {
cur = table[lidx].clk;
if (is_div(cur)) {
to = config ? table[lidx].config1 : table[lidx].config0;
if (to == -1)
continue;
if (pwrcal_div_get_ratio(cur) > to + 1)
if (pwrcal_div_set_ratio(cur, to + 1))
return -1;
}
}
for (lidx = max - 1; lidx >= 0; lidx--) {
cur = table[lidx].clk;
if (is_gate(cur)) {
to = config ? table[lidx].config1 : table[lidx].config0;
if (to != 0)
continue;
pwrcal_gate_disable(cur);
}
}
return 0;
}
