void ClintStmtOccurrence::resetOccurrence(osl_statement_p stmt, const std::vector<int> &betaVector) {
bool differentBeta = (m_betaVector == betaVector);
bool differentPoints = false;
m_betaVector = betaVector;
m_oslStatement = stmt;
if (stmt == nullptr) {
if (m_oslScattering != nullptr)
emit pointsChanged();
if (differentBeta)
emit betaChanged();
return;
}
osl_relation_p oslScattering = nullptr;
oslListForeach(stmt->scattering, [&oslScattering,&betaVector](osl_relation_p scattering) {
if (betaExtract(scattering) == betaVector) {
CLINT_ASSERT(oslScattering == nullptr,
"Duplicate beta-vector found");
oslScattering = scattering;
}
});
CLINT_ASSERT(oslScattering != nullptr,
"Trying to create an occurrence for the inexistent beta-vector");
differentPoints = !osl_relation_equal(oslScattering, m_oslScattering);
m_oslScattering = oslScattering;
if (differentPoints) {
emit pointsChanged();
}
if (differentBeta) {
emit betaChanged();
}
}
/**
* osl_scop_equal function:
* this function returns true if the two scops are the same, false
* otherwise (the usr field is not tested).
* \param s1 The first scop.
* \param s2 The second scop.
* \return 1 if s1 and s2 are the same (content-wise), 0 otherwise.
*/
int osl_scop_equal(osl_scop_p s1, osl_scop_p s2) {
while ((s1 != NULL) && (s2 != NULL)) {
if (s1 == s2)
return 1;
if (s1->version != s2->version) {
OSL_info("versions are not the same");
return 0;
}
if (strcmp(s1->language, s2->language) != 0) {
OSL_info("languages are not the same");
return 0;
}
if (!osl_relation_equal(s1->context, s2->context)) {
OSL_info("contexts are not the same");
return 0;
}
if (!osl_generic_equal(s1->parameters, s2->parameters)) {
OSL_info("parameters are not the same");
return 0;
}
if (!osl_statement_equal(s1->statement, s2->statement)) {
OSL_info("statements are not the same");
return 0;
}
if (!osl_interface_equal(s1->registry, s2->registry)) {
OSL_info("registries are not the same");
return 0;
}
if (!osl_generic_equal(s1->extension, s2->extension)) {
OSL_info("extensions are not the same");
return 0;
}
s1 = s1->next;
s2 = s2->next;
}
if (((s1 == NULL) && (s2 != NULL)) || ((s1 != NULL) && (s2 == NULL)))
return 0;
return 1;
}
/**
* osl_dependence_equal function:
* this function returns true if the two dependences provided as parameters
* are the same, false otherwise (the usr field is not tested).
* NOTE: the different pointer to statements or relations are nto compared
* \param[in] d1 The first dependence.
* \param[in] d2 The second dependence.
* \return 1 if d1 and d2 are the same (content-wise), 0 otherwise.
*/
int osl_dependence_equal(osl_dependence_p d1, osl_dependence_p d2) {
if (d1 == d2)
return 1;
if ((d1->next != NULL && d2->next == NULL) ||
(d1->next == NULL && d2->next != NULL))
return 0;
if (d1->next != NULL && d2->next != NULL)
if (!osl_dependence_equal(d1->next, d2->next))
return 0;
if (!osl_relation_equal(d1->domain, d2->domain))
return 0;
if (d1->label_source != d2->label_source ||
d1->label_target != d2->label_target ||
d1->ref_source != d2->ref_source ||
d1->ref_target != d2->ref_target ||
d1->depth != d2->depth ||
d1->type != d2->type ||
d1->source_nb_output_dims_domain !=
d2->source_nb_output_dims_domain ||
d1->source_nb_output_dims_access !=
d2->source_nb_output_dims_access ||
d1->target_nb_output_dims_domain !=
d2->target_nb_output_dims_domain ||
d1->target_nb_output_dims_access !=
d2->target_nb_output_dims_access ||
d1->source_nb_local_dims_domain !=
d2->source_nb_local_dims_domain ||
d1->source_nb_local_dims_access !=
d2->source_nb_local_dims_access ||
d1->target_nb_local_dims_domain !=
d2->target_nb_local_dims_domain ||
d1->target_nb_local_dims_access !=
d2->target_nb_local_dims_access)
return 0;
return 1;
}
/* Check if two scop can be compared (same number of statements and
* same access array/domain in the same order)
*
* \param[in] s1 first scop to compare
* \param[in] s2 second scop to compare
* \return 1 if two scops equal, 0 otherwise
*/
int candl_util_check_scop(osl_scop_p s1, osl_scop_p s2) {
osl_statement_p it1 = s1->statement, it2 = s2->statement;
for (; it1 != NULL && it2 != NULL ; it1 = it1->next, it2 = it2->next) {
if (!osl_relation_list_equal(it1->access, it2->access))
return 0;
if (!osl_relation_equal(it1->domain, it2->domain))
return 0;
}
/* Different number of statements */
if ((it1 == NULL || it2 == NULL) && it1 != it2)
return 0;
return 1;
}
/**
* @brief Fusion 2 osl_relation_list : if some osl_relation of the list
* are found in rl2 and rl1, only one is added to the result list.
*
* @param[in] rl1 The first osl_relation_list.
* @param[in] rl2 The second osl_relation_list.
*
* @return An osl_relation_list, fusion of rl1 and rl2, without any
* osl_relation duplicate.
*/
struct osl_relation_list * substrate_osl_relation_list_fusion(
struct osl_relation_list * rl1,
struct osl_relation_list * rl2)
{
struct osl_relation_list *res = NULL, *cursor = NULL, *last_rel = NULL;
if(rl1 == NULL)
{
res = osl_relation_list_clone(rl2);
}
else
{
res = osl_relation_list_clone(rl1);
//find the last elt of the list
last_rel=res;
while(last_rel->next != NULL) last_rel = last_rel->next;
while(rl2 != NULL)
{
cursor=res;
while( (cursor != NULL) && !osl_relation_equal(rl2->elt, cursor->elt) )
{
cursor = cursor->next;
}
//If cursor is NULL, no relation in "res" was found equal, so we add it
//to the end of "res".
if(cursor == NULL)
{
last_rel->next=osl_relation_list_node(rl2->elt);
last_rel = last_rel->next;
}
rl2=rl2->next;
}
}
return res;
}
