void test2()
{
sc_uint passed = 0;
sc_uint idx = 0;
sc_uint32 packed;
sc_uint32 test_count = 10000000;
sc_addr addr, addr2;
printf("Test sc-addr packing\n");
passed = 0;
timer = g_timer_new();
g_timer_reset(timer);
g_timer_start(timer);
for (idx = 0; idx < test_count; idx++)
{
// make random addr
addr.seg = g_random_int() % SC_ADDR_SEG_MAX;
addr.offset = g_random_int() % SC_ADDR_OFFSET_MAX;
// pack
packed = SC_ADDR_LOCAL_TO_INT(addr);
// unpack
addr2.seg = SC_ADDR_LOCAL_SEG_FROM_INT(packed);
addr2.offset = SC_ADDR_LOCAL_OFFSET_FROM_INT(packed);
if (SC_ADDR_IS_NOT_EQUAL(addr, addr2))
{
printf("Error!\n");
printf("Source seg=%d, offset=%d\n", addr.seg, addr.offset);
printf("Packed=%d\n", packed);
printf("Unpacked seg=%d, offset=%d", addr2.seg, addr2.offset);
}else
passed++;
}
g_timer_stop(timer);
printf("Passed %d of %d tests\n", passed, idx);
printf("Pack/Unpack operations per second: %f", test_count / g_timer_elapsed(timer, 0));
g_timer_destroy(timer);
}
sc_bool system_sys_search_recurse(sc_memory_context *context, sc_addr sc_pattern, sc_type_hash *pattern, sc_addr curr_const_element, sc_addr curr_pattern_element, sc_type_result *inp_result, sc_type_result_vector *out_common_result, int level)
{
sc_addr addr1, addr2, temp, temp1;
int out_arc_count = 0;
sc_type_result_vector common_result;
sc_type_result_vector del_result;
sc_type_result inp_result_copy = *inp_result;
common_result.push_back(inp_result);
//Pattern arcs list
sc_addr_vector pattern_arc_set;
sc_iterator3 *it_pattern_arc = sc_iterator3_f_a_a_new(context, curr_pattern_element, 0, 0);
if (it_pattern_arc == null_ptr) {return SC_FALSE;}
while (SC_TRUE == sc_iterator3_next(it_pattern_arc))
{
addr2 = sc_iterator3_value(it_pattern_arc, 1);
if (pattern->find(SC_ADDR_LOCAL_TO_INT(addr2)) != pattern->end())
{
out_arc_count++;
pattern_arc_set.push_back(addr2);
}
}
sc_iterator3_free(it_pattern_arc);
it_pattern_arc = sc_iterator3_a_a_f_new(context, 0, 0, curr_pattern_element);
if (it_pattern_arc == null_ptr) {return SC_FALSE;}
while (SC_TRUE == sc_iterator3_next(it_pattern_arc))
{
addr1 = sc_iterator3_value(it_pattern_arc, 0);
if (SC_ADDR_IS_EQUAL(addr1, sc_pattern)) continue;
addr2 = sc_iterator3_value(it_pattern_arc, 1);
if (pattern->find(SC_ADDR_LOCAL_TO_INT(addr2)) != pattern->end())
{
pattern_arc_set.push_back(addr2);
}
}
sc_iterator3_free(it_pattern_arc);
sc_addr pattern_arc;
sc_addr const_arc;
sc_addr next_pattern_element;
sc_addr next_const_element;
sc_addr next_pattern_element_begin, next_pattern_element_end;
sc_addr next_const_element_begin, next_const_element_end;
sc_bool out_arc_flag = SC_TRUE;
sc_type_result_vector new_common_result;
sc_type_result_vector next_common_result;
sc_type_result_vector next_common_result_arc;
sc_type_result_vector next_common_result_begin;
sc_type_result_vector next_common_result_end;
sc_type_result_vector next_common_result_element;
sc_bool next_pattern_element_is_node = SC_FALSE;
sc_type next_pattern_element_type;
sc_type next_pattern_element_begin_type;
sc_type next_pattern_element_end_type;
sc_bool pattern_arc_is_const_or_has_value = SC_FALSE;
sc_bool pattern_is_const_or_has_value = SC_FALSE;
sc_bool pattern_begin_is_const_or_has_value = SC_FALSE;
sc_bool pattern_end_is_const_or_has_value = SC_FALSE;
//Pattern arcs loop
for (sc_uint i = 0; i < pattern_arc_set.size(); i++)
{
pattern_arc = pattern_arc_set[i];
out_arc_flag = SC_TRUE;
//!check pattern_arc type
sc_type pattern_arc_type;
if (sc_memory_get_element_type(context, pattern_arc, &pattern_arc_type) != SC_RESULT_OK)
continue;
if ((sc_type_const & pattern_arc_type) == sc_type_const)
continue;
pattern_arc_is_const_or_has_value = SC_FALSE;
pattern_is_const_or_has_value = SC_FALSE;
if (out_arc_count > 0)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(context, pattern_arc, &next_pattern_element))
continue;
out_arc_count--;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, pattern_arc, &next_pattern_element))
continue;
out_arc_flag = SC_FALSE;
}
if (sc_memory_get_element_type(context, next_pattern_element, &next_pattern_element_type) != SC_RESULT_OK) {continue;}
if ((sc_type_node & next_pattern_element_type) == sc_type_node)
{
next_pattern_element_is_node = SC_TRUE;
}
else
{
next_pattern_element_is_node = SC_FALSE;
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, next_pattern_element, &next_pattern_element_begin)) {continue;}
if (SC_RESULT_OK != sc_memory_get_arc_end(context, next_pattern_element, &next_pattern_element_end)) {continue;}
}
if (pattern->find(SC_ADDR_LOCAL_TO_INT(next_pattern_element)) == pattern->end())
{
continue;
}
if (next_pattern_element_is_node == SC_FALSE)
{
if (pattern->find(SC_ADDR_LOCAL_TO_INT(next_pattern_element_begin)) == pattern->end())
{
continue;
}
if (pattern->find(SC_ADDR_LOCAL_TO_INT(next_pattern_element_end)) == pattern->end())
{
continue;
}
}
sc_type_result::iterator arc_it = inp_result_copy.find(pattern_arc);
if (arc_it != inp_result_copy.end())
{
const_arc = (*arc_it).second;
pattern_arc_is_const_or_has_value = SC_TRUE;
if (out_arc_flag == SC_TRUE)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(context, const_arc, &next_const_element))
continue;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, const_arc, &next_const_element))
continue;
}
}
//!check next_pattern_element type
if ((sc_type_const & next_pattern_element_type) == sc_type_const)
{
if (pattern_arc_is_const_or_has_value == SC_TRUE)
{
if (!SC_ADDR_IS_EQUAL(next_const_element, next_pattern_element))
{
continue;
}
}
else
{
next_const_element = next_pattern_element;
}
pattern_is_const_or_has_value = SC_TRUE;
}
else
{
sc_type_result::iterator it = inp_result_copy.find(next_pattern_element);
if (it != inp_result_copy.end())
{
if (pattern_arc_is_const_or_has_value == SC_TRUE)
{
if (!SC_ADDR_IS_EQUAL(next_const_element, (*it).second))
{
continue;
}
}
else
{
next_const_element = (*it).second;
}
pattern_is_const_or_has_value = SC_TRUE;
}
}
if (next_pattern_element_is_node == SC_FALSE)
{
pattern_begin_is_const_or_has_value = SC_FALSE;
pattern_end_is_const_or_has_value = SC_FALSE;
if (sc_memory_get_element_type(context, next_pattern_element_begin, &next_pattern_element_begin_type) != SC_RESULT_OK) {continue;}
if (sc_memory_get_element_type(context, next_pattern_element_end, &next_pattern_element_end_type) != SC_RESULT_OK) {continue;}
if (SC_TRUE == pattern_arc_is_const_or_has_value || SC_TRUE == pattern_is_const_or_has_value)
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, next_const_element, &next_const_element_begin)) {continue;}
if (SC_RESULT_OK != sc_memory_get_arc_end(context, next_const_element, &next_const_element_end)) {continue;}
}
//!check next_pattern_element_begin type
if ((sc_type_const & next_pattern_element_begin_type) == sc_type_const)
{
if (SC_TRUE == pattern_arc_is_const_or_has_value || SC_TRUE == pattern_is_const_or_has_value)
{
if (!SC_ADDR_IS_EQUAL(next_const_element_begin, next_pattern_element_begin))
{
continue;
}
}
else
{
next_const_element_begin = next_pattern_element_begin;
}
pattern_begin_is_const_or_has_value = SC_TRUE;
}
else
{
sc_type_result::iterator it = inp_result_copy.find(next_pattern_element_begin);
if (it != inp_result_copy.end())
{
if (SC_TRUE == pattern_arc_is_const_or_has_value || SC_TRUE == pattern_is_const_or_has_value)
{
if (!SC_ADDR_IS_EQUAL(next_const_element_begin, (*it).second))
{
continue;
}
}
else
{
next_const_element_begin = (*it).second;
}
pattern_begin_is_const_or_has_value = SC_TRUE;
}
}
//!check next_pattern_element_end type
if ((sc_type_const & next_pattern_element_end_type) == sc_type_const)
{
if (SC_TRUE == pattern_arc_is_const_or_has_value || SC_TRUE == pattern_is_const_or_has_value)
{
if (!SC_ADDR_IS_EQUAL(next_const_element_end, next_pattern_element_end))
{
continue;
}
}
else
{
next_const_element_end = next_pattern_element_end;
}
pattern_end_is_const_or_has_value = SC_TRUE;
}
else
{
sc_type_result::iterator it = inp_result_copy.find(next_pattern_element_end);
if (it != inp_result_copy.end())
{
if (SC_TRUE == pattern_arc_is_const_or_has_value || SC_TRUE == pattern_is_const_or_has_value)
{
if (!SC_ADDR_IS_EQUAL(next_const_element_end, (*it).second))
{
continue;
}
}
else
{
next_const_element_end = (*it).second;
}
pattern_end_is_const_or_has_value = SC_TRUE;
}
}
}
//!const arc loop
sc_addr_vector const_arc_set;
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
sc_iterator3 *it_const_arc;
sc_type const_arc_type = ((~sc_type_var & pattern_arc_type) | sc_type_const);
if (out_arc_flag == SC_TRUE)
{
if (pattern_is_const_or_has_value == SC_TRUE)
{
it_const_arc = sc_iterator3_f_a_f_new(context, curr_const_element, const_arc_type, next_const_element);
}
else
{
sc_type next_const_element_type = ((~sc_type_var & next_pattern_element_type) | sc_type_const);
if ((sc_type_node & next_pattern_element_type) == sc_type_node)
{
next_const_element_type = next_const_element_type & sc_type_link;
}
it_const_arc = sc_iterator3_f_a_a_new(context, curr_const_element, const_arc_type, next_const_element_type);
}
}
else
{
if (pattern_is_const_or_has_value == SC_TRUE)
{
it_const_arc = sc_iterator3_f_a_f_new(context, next_const_element, const_arc_type, curr_const_element);
}
else
{
sc_type next_const_element_type = ((~sc_type_var & next_pattern_element_type) | sc_type_const);
if ((sc_type_node & next_pattern_element_type) == sc_type_node)
{
next_const_element_type = next_const_element_type & sc_type_link;
}
it_const_arc = sc_iterator3_a_a_f_new(context, next_const_element_type, const_arc_type, curr_const_element);
}
}
while (SC_TRUE == sc_iterator3_next(it_const_arc))
{
if (out_arc_flag == SC_FALSE)
{
addr1 = sc_iterator3_value(it_const_arc, 0);
if (SC_ADDR_IS_EQUAL(addr1, sc_pattern))
continue;
}
addr2 = sc_iterator3_value(it_const_arc, 1);
const_arc_set.push_back(addr2);
}
sc_iterator3_free(it_const_arc);
}
else
{
const_arc_set.push_back(const_arc);
}
for (sc_uint j = 0; j < const_arc_set.size(); j++)
{
const_arc = const_arc_set[j];
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
if (out_arc_flag == SC_TRUE)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(context, const_arc, &next_const_element))
continue;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, const_arc, &next_const_element))
continue;
}
}
//!TODO Optimize
if (SC_FALSE == next_pattern_element_is_node)
{
sc_addr next_const_element_begin1, next_const_element_end1;
if (SC_RESULT_OK != sc_memory_get_arc_begin(context, next_const_element, &next_const_element_begin1)) {continue;}
if (SC_RESULT_OK != sc_memory_get_arc_end(context, next_const_element, &next_const_element_end1)) {continue;}
if (SC_TRUE == pattern_begin_is_const_or_has_value && SC_ADDR_IS_NOT_EQUAL(next_const_element_begin, next_const_element_begin1))
{
continue;
}
if (SC_TRUE == pattern_end_is_const_or_has_value && SC_ADDR_IS_NOT_EQUAL(next_const_element_end, next_const_element_end1))
{
continue;
}
next_const_element_begin = next_const_element_begin1;
next_const_element_end = next_const_element_end1;
}
//!Results loop
for (sc_uint k = 0; k < common_result.size(); k++)
{
sc_type_result *result = common_result[k];
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
if (SC_TRUE == find_result_pair_for_const(result, const_arc, &temp))
continue;
if (SC_FALSE == pattern_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element))
{
continue;
}
if (SC_FALSE == next_pattern_element_is_node)
{
if (SC_FALSE == pattern_begin_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element_begin, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element_begin))
{
continue;
}
if (SC_FALSE == pattern_end_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element_end, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element_end))
{
continue;
}
}
if (SC_TRUE == find_result_pair_for_var(result, pattern_arc, &temp))
{
//!Gen new result
if (SC_FALSE == check_coherence(context, next_pattern_element, sc_pattern, pattern_arc, !out_arc_flag, result, &inp_result_copy))
{
continue;
}
sc_type_result *new_result = new sc_type_result();
(*new_result) = (*result);
new_common_result.push_back(new_result);
result = new_result;
result->erase(pattern_arc);
if (pattern_is_const_or_has_value == SC_FALSE)
{
result->erase(next_pattern_element);
}
if (SC_FALSE == next_pattern_element_is_node)
{
if (pattern_begin_is_const_or_has_value == SC_FALSE)
{
result->erase(next_pattern_element_begin);
}
if (pattern_end_is_const_or_has_value == SC_FALSE)
{
result->erase(next_pattern_element_end);
}
}
}
else
{
//! TODO Add flags to not add already existing elements
if (SC_FALSE == pattern_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element))
{
continue;
}
if (SC_FALSE == next_pattern_element_is_node)
{
if (SC_FALSE == pattern_begin_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element_begin, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element_begin))
{
continue;
}
if (SC_FALSE == pattern_end_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element_end, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element_end))
{
continue;
}
}
}
//!Genering pair for 2nd element
result->insert(sc_addr_pair(pattern_arc, const_arc));
//!Genering pair for 3rd element
if (pattern_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element, next_const_element));
}
//! Generating pair for next pattern element begin and end
if (SC_FALSE == next_pattern_element_is_node)
{
if (pattern_begin_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element_begin, next_const_element_begin));
}
if (pattern_end_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element_end, next_const_element_end));
}
}
}
else
{
if (SC_TRUE == find_result_pair_for_const(result, const_arc, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, pattern_arc))
{
continue;
}
if (SC_TRUE == find_result_pair_for_var(result, pattern_arc, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, const_arc))
{
continue;
}
if (SC_FALSE == pattern_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element))
{
continue;
}
if (SC_FALSE == next_pattern_element_is_node)
{
if (SC_FALSE == pattern_begin_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element_begin, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element_begin))
{
continue;
}
if (SC_FALSE == pattern_end_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element_end, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element_end))
{
continue;
}
}
if (SC_FALSE == pattern_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element))
{
continue;
}
if (SC_FALSE == next_pattern_element_is_node)
{
if (SC_FALSE == pattern_begin_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element_begin, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element_begin))
{
continue;
}
if (SC_FALSE == pattern_end_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_var(result, next_pattern_element_end, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_const_element_end))
{
continue;
}
}
//!Genering pair for 3rd element
if (pattern_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element, next_const_element));
}
//! Generating pair for next pattern element begin and end
if (SC_FALSE == next_pattern_element_is_node)
{
if (pattern_begin_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element_begin, next_const_element_begin));
}
if (pattern_end_is_const_or_has_value == SC_FALSE)
{
result->insert(sc_addr_pair(next_pattern_element_end, next_const_element_end));
}
}
}
sc_type_result *arc_result = new sc_type_result();
(*arc_result) = (*result);
del_result.push_back(result);
pattern->erase(SC_ADDR_LOCAL_TO_INT(pattern_arc));
pattern->erase(SC_ADDR_LOCAL_TO_INT(next_pattern_element));
if (next_pattern_element_is_node == SC_FALSE)
{
pattern->erase(SC_ADDR_LOCAL_TO_INT(next_pattern_element_begin));
pattern->erase(SC_ADDR_LOCAL_TO_INT(next_pattern_element_end));
}
system_sys_search_recurse(context, sc_pattern, pattern, const_arc, pattern_arc,
arc_result, &next_common_result_arc, level + 1);
for (sc_uint kk = 0; kk < next_common_result_arc.size(); kk++)
{
sc_type_result *element_result = next_common_result_arc[kk];
system_sys_search_recurse(context, sc_pattern, pattern, next_const_element, next_pattern_element,
element_result, &next_common_result_element, level + 1);
if (SC_FALSE == next_pattern_element_is_node)
{
//! Recurse for begin element
for (sc_uint kk_begin = 0; kk_begin < next_common_result_element.size(); kk_begin++)
{
sc_type_result *begin_result = next_common_result_element[kk_begin];
system_sys_search_recurse(context, sc_pattern, pattern, next_const_element_begin, next_pattern_element_begin,
begin_result, &next_common_result_begin, level + 1);
//! Recurse for end element
for (sc_uint kk_end = 0; kk_end < next_common_result_begin.size(); kk_end++)
{
sc_type_result *end_result = next_common_result_begin[kk_end];
system_sys_search_recurse(context, sc_pattern, pattern, next_const_element_end, next_pattern_element_end,
end_result, &next_common_result_end, level + 1);
next_common_result.insert(next_common_result.end(),
next_common_result_end.begin(), next_common_result_end.end());
next_common_result_end.clear();
}
next_common_result_begin.clear();
}
next_common_result_element.clear();
}
else
{
next_common_result.insert(next_common_result.end(),
next_common_result_element.begin(), next_common_result_element.end());
next_common_result_element.clear();
}
}
pattern->insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(pattern_arc), pattern_arc));
pattern->insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(next_pattern_element), next_pattern_element));
if (next_pattern_element_is_node == SC_FALSE)
{
pattern->insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(next_pattern_element_begin), next_pattern_element_begin));
pattern->insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(next_pattern_element_end), next_pattern_element_end));
}
out_common_result->insert(out_common_result->end(), next_common_result.begin(), next_common_result.end());
new_common_result.insert(new_common_result.end(), next_common_result.begin(), next_common_result.end());
next_common_result.clear();
next_common_result_arc.clear();
}
}//const loop
common_result.insert(common_result.begin(), new_common_result.begin(), new_common_result.end());
new_common_result.clear();
remove_all_elements(&del_result, &common_result);
remove_all_elements(&del_result, out_common_result);
free_result_vector(&del_result);
}//pattern loop
out_common_result->insert(out_common_result->end(), common_result.begin(), common_result.end());
common_result.clear();
cantorize_result_vector(out_common_result);
return SC_TRUE;
}
sc_bool system_sys_search_recurse(sc_addr sc_pattern, sc_type_hash pattern, sc_addr curr_const_element, sc_addr curr_pattern_element, sc_type_result *inp_result, sc_type_result_vector *out_common_result, int element_number)
{
sc_type input_element_type;
if (sc_memory_get_element_type(curr_pattern_element, &input_element_type) != SC_RESULT_OK) {return SC_FALSE;}
if (element_number == 2 && (sc_type_node & input_element_type) != sc_type_node)
{
//!Input element is arc
sc_addr const_element, pattern_element, temp, end_pattern_element, end_const_element;
sc_type pattern_element_type, end_pattern_element_type;
sc_memory_get_arc_begin(curr_const_element, &const_element);
sc_memory_get_arc_begin(curr_pattern_element, &pattern_element);
sc_memory_get_arc_end(curr_const_element, &end_const_element);
sc_memory_get_arc_end(curr_pattern_element, &end_pattern_element);
if (sc_memory_get_element_type(pattern_element, &pattern_element_type) != SC_RESULT_OK) {return SC_TRUE;}
if ((sc_type_const & pattern_element_type) == sc_type_const)
{
if (SC_ADDR_IS_NOT_EQUAL(const_element, pattern_element))
{
inp_result->erase(curr_pattern_element);
return SC_TRUE;
}
}
else if (SC_TRUE == find_result_pair_for_var(inp_result, pattern_element, &temp))
{
if (SC_ADDR_IS_NOT_EQUAL(const_element, temp))
{
inp_result->erase(curr_pattern_element);
return SC_TRUE;
}
}
if (sc_memory_get_element_type(end_pattern_element, &end_pattern_element_type) != SC_RESULT_OK) {return SC_TRUE;}
if ((sc_type_const & end_pattern_element_type) == sc_type_const)
{
if (SC_ADDR_IS_NOT_EQUAL(end_const_element, end_pattern_element))
{
inp_result->erase(curr_pattern_element);
return SC_TRUE;
}
}
else if (SC_TRUE == find_result_pair_for_var(inp_result, end_pattern_element, &temp))
{
if (SC_ADDR_IS_NOT_EQUAL(end_const_element, temp))
{
inp_result->erase(curr_pattern_element);
return SC_TRUE;
}
}
if (SC_ADDR_IS_NOT_EQUAL(const_element, pattern_element))
{
inp_result->insert(sc_addr_pair(pattern_element, const_element));
}
pattern.insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(curr_pattern_element), curr_pattern_element));
system_sys_search_recurse(sc_pattern, pattern, const_element, pattern_element, inp_result, out_common_result, 2);
return SC_TRUE;
}
sc_addr addr1, addr2, temp, temp1;
int out_arc_count = 0;
sc_type_result_vector common_result;
sc_type_result_vector del_result;
sc_type_result inp_result_copy = *inp_result;
common_result.push_back(inp_result);
//Pattern arcs list
sc_addr_vector pattern_arc_set;
sc_iterator3 *it_pattern_arc = sc_iterator3_f_a_a_new(curr_pattern_element, 0, 0);
if (it_pattern_arc == nullptr) {return SC_FALSE;}
while (SC_TRUE == sc_iterator3_next(it_pattern_arc))
{
addr2 = sc_iterator3_value(it_pattern_arc, 1);
if (pattern.find(SC_ADDR_LOCAL_TO_INT(addr2)) != pattern.end())
{
out_arc_count++;
pattern_arc_set.push_back(addr2);
}
}
sc_iterator3_free(it_pattern_arc);
it_pattern_arc = sc_iterator3_a_a_f_new(0, 0, curr_pattern_element);
if (it_pattern_arc == nullptr) {return SC_FALSE;}
while (SC_TRUE == sc_iterator3_next(it_pattern_arc))
{
addr1 = sc_iterator3_value(it_pattern_arc, 0);
if (SC_ADDR_IS_EQUAL(addr1, sc_pattern)) continue;
addr2 = sc_iterator3_value(it_pattern_arc, 1);
if (pattern.find(SC_ADDR_LOCAL_TO_INT(addr2)) != pattern.end())
{
pattern_arc_set.push_back(addr2);
}
}
sc_iterator3_free(it_pattern_arc);
sc_addr pattern_arc;
sc_addr const_arc;
sc_addr next_pattern_element;
sc_addr next_const_element;
sc_bool out_arc_flag = SC_TRUE;
sc_type_result_vector new_common_result;
sc_type_result_vector next_common_result;
sc_type_result_vector next_common_result_arc;
sc_type_result_vector next_common_result1;
sc_bool pattern_arc_is_const_or_has_value = SC_FALSE;
sc_bool pattern_is_const_or_has_value = SC_FALSE;
//Pattern arcs loop
for (sc_uint i = 0; i < pattern_arc_set.size(); i++)
{
pattern_arc = pattern_arc_set[i];
out_arc_flag = SC_TRUE;
//!check pattern_arc type
sc_type pattern_arc_type;
if (sc_memory_get_element_type(pattern_arc, &pattern_arc_type) != SC_RESULT_OK)
continue;
if ((sc_type_const & pattern_arc_type) == sc_type_const)
continue;
pattern_arc_is_const_or_has_value = SC_FALSE;
pattern_is_const_or_has_value = SC_FALSE;
if (out_arc_count > 0)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(pattern_arc, &next_pattern_element))
continue;
out_arc_count--;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(pattern_arc, &next_pattern_element))
continue;
out_arc_flag = SC_FALSE;
}
if (pattern.find(SC_ADDR_LOCAL_TO_INT(next_pattern_element)) == pattern.end())
{
continue;
}
sc_type_result::iterator arc_it = inp_result_copy.find(pattern_arc);
if (arc_it != inp_result_copy.end())
{
const_arc = (*arc_it).second;
pattern_arc_is_const_or_has_value = SC_TRUE;
if (out_arc_flag == SC_TRUE)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(const_arc, &next_const_element))
continue;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(const_arc, &next_const_element))
continue;
}
}
//!check next_pattern_element type
sc_type next_pattern_element_type;
if (sc_memory_get_element_type(next_pattern_element, &next_pattern_element_type) != SC_RESULT_OK) {continue;}
if ((sc_type_const & next_pattern_element_type) == sc_type_const)
{
if (pattern_arc_is_const_or_has_value == SC_TRUE)
{
if (!SC_ADDR_IS_EQUAL(next_const_element, next_pattern_element))
{
continue;
}
}
else
{
next_const_element = next_pattern_element;
}
pattern_is_const_or_has_value = SC_TRUE;
}
else
{
sc_type_result::iterator it = inp_result_copy.find(next_pattern_element);
if (it != inp_result_copy.end())
{
if (pattern_arc_is_const_or_has_value == SC_TRUE)
{
if (!SC_ADDR_IS_EQUAL(next_const_element, (*it).second))
{
continue;
}
}
else
{
next_const_element = (*it).second;
}
pattern_is_const_or_has_value = SC_TRUE;
}
}
pattern.erase(SC_ADDR_LOCAL_TO_INT(next_pattern_element));
//!const arc loop
sc_addr_vector const_arc_set;
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
sc_iterator3 *it_const_arc;
sc_type const_arc_type = ((~sc_type_var & pattern_arc_type) | sc_type_const);
if (out_arc_flag == SC_TRUE)
{
if (pattern_is_const_or_has_value == SC_TRUE)
{
it_const_arc = sc_iterator3_f_a_f_new(curr_const_element, const_arc_type, next_const_element);
}
else
{
sc_type next_const_element_type = ((~sc_type_var & next_pattern_element_type) | sc_type_const);
it_const_arc = sc_iterator3_f_a_a_new(curr_const_element, const_arc_type, next_const_element_type);
}
}
else
{
if (pattern_is_const_or_has_value == SC_TRUE)
{
it_const_arc = sc_iterator3_f_a_f_new(next_const_element, const_arc_type, curr_const_element);
}
else
{
sc_type next_const_element_type = ((~sc_type_var & next_pattern_element_type) | sc_type_const);
it_const_arc = sc_iterator3_a_a_f_new(next_const_element_type, const_arc_type, curr_const_element);
}
}
while (SC_TRUE == sc_iterator3_next(it_const_arc))
{
if (out_arc_flag == SC_FALSE)
{
addr1 = sc_iterator3_value(it_const_arc, 0);
if (SC_ADDR_IS_EQUAL(addr1, sc_pattern))
continue;
}
addr2 = sc_iterator3_value(it_const_arc, 1);
const_arc_set.push_back(addr2);
}
sc_iterator3_free(it_const_arc);
}
else
{
const_arc_set.push_back(const_arc);
}
//printf("ELEMENT %u|%u CONST ARCS COUNT:%d\n", curr_const_element.seg, curr_const_element.offset, const_arc_set.size());
for (sc_uint j = 0; j < const_arc_set.size(); j++)
{
const_arc = const_arc_set[j];
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
if (out_arc_flag == SC_TRUE)
{
if (SC_RESULT_OK != sc_memory_get_arc_end(const_arc, &next_const_element))
continue;
}
else
{
if (SC_RESULT_OK != sc_memory_get_arc_begin(const_arc, &next_const_element))
continue;
}
}
if (pattern_is_const_or_has_value == SC_FALSE && pattern.find(SC_ADDR_LOCAL_TO_INT(next_const_element)) != pattern.end())
{
continue;
}
//!Results loop
for (sc_uint k = 0; k < common_result.size(); k++)
{
sc_type_result *result = common_result[k];
sc_bool gen_arc = SC_FALSE;
if (pattern_arc_is_const_or_has_value == SC_FALSE)
{
if (SC_TRUE == find_result_pair_for_const(result, const_arc, &temp))
continue;
if (SC_TRUE == find_result_pair_for_var(result, pattern_arc, &temp))
{
//!Gen new result
if (SC_FALSE == pattern_is_const_or_has_value
&& SC_TRUE == find_result_pair_for_const(result, next_const_element, &temp1)
&& SC_ADDR_IS_NOT_EQUAL(temp1, next_pattern_element))
{
continue;
}
sc_type_result *new_result = new sc_type_result();
//class_count++;
(*new_result) = (*result);
new_common_result.push_back(new_result);
result = new_result;
result->erase(pattern_arc);
if (pattern_is_const_or_has_value == SC_FALSE)
{
result->erase(next_pattern_element);
}
}
gen_arc = SC_TRUE;
}
//!Genering pair for 3rd element
if (pattern_is_const_or_has_value == SC_FALSE
&& SC_FALSE == find_result_pair_for_var(result, next_pattern_element, &temp))
{
//!Genering pair for 2nd element
if (gen_arc == SC_TRUE)
{
result->insert(sc_addr_pair(pattern_arc, const_arc));
pattern.erase(SC_ADDR_LOCAL_TO_INT(pattern_arc));
}
result->insert(sc_addr_pair(next_pattern_element, next_const_element));
pattern.erase(SC_ADDR_LOCAL_TO_INT(next_pattern_element));
}
else
{
//!Genering pair for 2nd element
if (gen_arc == SC_TRUE)
{
result->insert(sc_addr_pair(pattern_arc, const_arc));
pattern.erase(SC_ADDR_LOCAL_TO_INT(pattern_arc));
}
}
sc_type_result *recurse_result = new sc_type_result();
(*recurse_result) = (*result);
del_result.push_back(result);
system_sys_search_recurse(sc_pattern, pattern, const_arc, pattern_arc,
recurse_result, &next_common_result_arc, 1);
for (sc_uint kk = 0; kk < next_common_result_arc.size(); kk++)
{
sc_type_result *element_result = next_common_result_arc[kk];
system_sys_search_recurse(sc_pattern, pattern, next_const_element, next_pattern_element,
element_result, &next_common_result1, 2);
if (!next_common_result1.empty())
{
next_common_result.insert(next_common_result.end(),
next_common_result1.begin(), next_common_result1.end());
next_common_result1.clear();
}
else
{
next_common_result.push_back(element_result);
}
}
pattern.insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(pattern_arc), pattern_arc));
pattern.insert(sc_hash_pair(SC_ADDR_LOCAL_TO_INT(next_pattern_element), next_pattern_element));
out_common_result->insert(out_common_result->end(), next_common_result.begin(), next_common_result.end());
new_common_result.insert(new_common_result.end(), next_common_result.begin(), next_common_result.end());
cantorize_result_vector(&new_common_result);
next_common_result.clear();
next_common_result_arc.clear();
}
}//const loop
common_result.insert(common_result.begin(), new_common_result.begin(), new_common_result.end());
new_common_result.clear();
remove_all_elements(&del_result, &common_result);
remove_all_elements(&del_result, out_common_result);
free_result_vector(&del_result);
}//pattern loop
out_common_result->insert(out_common_result->end(), common_result.begin(), common_result.end());
common_result.clear();
cantorize_result_vector(out_common_result);
return SC_TRUE;
}
bool ScAddr::operator != (ScAddr const & other) const
{
return SC_ADDR_IS_NOT_EQUAL(m_realAddr, other.m_realAddr);
}
sc_uint32 sc_segment_free_garbage(sc_segment *seg, sc_uint32 oldest_time_stamp)
{
sc_uint32 free_count = 0;
sc_uint32 idx = 0;
//sc_uint32 newest_time_stamp = sc_storage_get_time_stamp();
#if USE_TWO_ORIENTED_ARC_LIST
sc_element *el = 0, *el2 = 0, *el_arc = 0, *next_el_arc = 0, *prev_el_arc = 0;
sc_addr prev_arc, next_arc;
sc_addr self_addr;
#else
sc_element *el = 0, *el2 = 0, *el_arc = 0, *prev_el_arc = 0;
sc_addr prev_arc, current_arc;
sc_addr self_addr;
#endif
#if USE_SEGMENT_EMPTY_SLOT_BUFFER
seg->empty_slot_buff_head = 0;
#endif
self_addr.seg = seg->num;
for (idx = 0; idx < SEGMENT_SIZE; ++idx)
{
el = &(seg->elements[idx]);
self_addr.offset = idx;
// skip element that wasn't deleted
if (el->delete_time_stamp <= oldest_time_stamp && el->delete_time_stamp != 0)
{
// delete arcs from output and intpu lists
// @todo two oriented lists support
if (el->type & sc_type_arc_mask)
{
#if USE_TWO_ORIENTED_ARC_LIST
prev_arc = el->arc.prev_out_arc;
next_arc = el->arc.next_out_arc;
if (SC_ADDR_IS_NOT_EMPTY(prev_arc))
{
prev_el_arc = sc_storage_get_element(prev_arc, SC_TRUE);
prev_el_arc->arc.next_out_arc = next_arc;
}
if (SC_ADDR_IS_NOT_EMPTY(next_arc))
{
next_el_arc = sc_storage_get_element(next_arc, SC_TRUE);
next_el_arc->arc.prev_out_arc = prev_arc;
}
#else
SC_ADDR_MAKE_EMPTY(prev_arc);
// output list
el2 = sc_storage_get_element(el->arc.begin, SC_TRUE);
current_arc = el2->first_out_arc;
while (SC_ADDR_IS_NOT_EMPTY(current_arc) && SC_ADDR_IS_NOT_EQUAL(self_addr, current_arc))
{
prev_arc = current_arc;
prev_el_arc = el_arc;
el_arc = sc_storage_get_element(current_arc, SC_TRUE);
current_arc = el->arc.next_out_arc;
}
if (SC_ADDR_IS_NOT_EMPTY(prev_arc) && SC_ADDR_IS_NOT_EMPTY(current_arc))
prev_el_arc->arc.next_out_arc = el_arc->arc.next_out_arc;
prev_el_arc = 0;
el_arc = 0;
SC_ADDR_MAKE_EMPTY(prev_arc);
// input list
el2 = sc_storage_get_element(el->arc.end, SC_TRUE);
current_arc = el2->first_in_arc;
while (SC_ADDR_IS_NOT_EMPTY(current_arc) && SC_ADDR_IS_NOT_EQUAL(self_addr, current_arc))
{
prev_arc = current_arc;
prev_el_arc = el_arc;
el_arc = sc_storage_get_element(current_arc, SC_TRUE);
current_arc = el->arc.next_in_arc;
}
if (SC_ADDR_IS_NOT_EMPTY(prev_arc) && SC_ADDR_IS_NOT_EMPTY(current_arc))
prev_el_arc->arc.next_in_arc = el_arc->arc.next_in_arc;
#endif
}
el->type = 0;
free_count ++;
}
// collect empty cells
if (el->type == 0 && !(idx == 0 && seg->num == 0))
{
#if USE_SEGMENT_EMPTY_SLOT_BUFFER
if (seg->empty_slot_buff_head < SEGMENT_EMPTY_BUFFER_SIZE)
seg->empty_slot_buff[seg->empty_slot_buff_head++] = idx;
#else
seg->empty_slot = idx;
#endif
}
}
return free_count;
}
