Triple egcd( int a, int b ){
if(!b) return Triple(a, 1, 0);
Triple q = egcd(b, a%b);
return Triple(q.d, q.y, q.x-a/b*q.y);
}
/**
* Initialize parallel grid virtual topology as optimal for current number of processes and specified grid sizes
*/
void
ParallelGridCore::initOptimal (grid_coord size1, /**< grid size by first axis */
grid_coord size2, /**< grid size by second axis */
grid_coord size3, /**< grid size by third axis */
int &nodeGridSize1, /**< out: first axis nodes grid size */
int &nodeGridSize2, /**< out: second axis nodes grid size */
int &nodeGridSize3) /**< out: third axis nodes grid size */
{
/*
* Find allowed triples of node grid sizes
*/
std::vector<Triple> allowedTriples;
grid_coord gcd1 = ParallelGridCore::greatestCommonDivider (size1, (grid_coord) totalProcCount);
grid_coord gcd2 = ParallelGridCore::greatestCommonDivider (size2, (grid_coord) totalProcCount);
std::set<grid_coord> allowedM;
for (grid_coord n = 1; n <= gcd1; ++n)
{
if (gcd1 % n != 0)
{
continue;
}
for (grid_coord m = 1; m <= gcd2; ++m)
{
if (gcd2 % m != 0)
{
continue;
}
FPValue k_fp = ((FPValue) totalProcCount) / ((FPValue) n * m);
grid_coord k = (grid_coord) k_fp;
FPValue c1_fp = ((FPValue) size3) / k_fp;
grid_coord c1 = (grid_coord) c1_fp;
if (k == k_fp && c1 == c1_fp)
{
allowedTriples.push_back (Triple (n, m, k));
allowedM.insert (m);
}
}
}
/*
* allowedTriples are sorted in ascending order for n, m, k
*/
ASSERT (allowedTriples.size () > 0);
Triple min = allowedTriples[0];
for (std::set<grid_coord>::iterator it = allowedM.begin ();
it != allowedM.end ();
++it)
{
grid_coord m = *it;
FPValue optimal_n = sqrt (((FPValue) size1 * totalProcCount) / ((FPValue) m * size3));
Triple left = allowedTriples[0];
Triple right = allowedTriples[0];
for (std::vector<Triple>::iterator iter = allowedTriples.begin ();
iter != allowedTriples.end ();
++iter)
{
grid_coord n_iter = iter->n;
grid_coord m_iter = iter->m;
if (m != m_iter)
{
continue;
}
if (n_iter < optimal_n)
{
left = *iter;
}
else
{
right = *iter;
break;
}
}
/*
* This heavily depends on the parallel grid sharing scheme
*/
#define func(triple) \
((size1)*(size2) / (triple.n * triple.m) + \
(size2)*(size3) / (triple.m * triple.k) + \
(size1)*(size3) / (triple.n * triple.k) + \
4*((size1) / triple.n + (size2) / triple.n + (size3) / triple.k))
Triple min_cur;
if (func (left) < func (right))
{
min_cur = left;
}
else
{
min_cur = right;
}
if (func (min_cur) < func (min))
{
min = min_cur;
}
#undef func
}
nodeGridSize1 = min.n;
nodeGridSize2 = min.m;
nodeGridSize3 = min.k;
} /* ParallelGridCore::initOptimal */
void ChatHandler::getPlainText(const std::string& in, std::string &out, std::vector<Triple> &links)
{
if (in.size() == 0)
return;
if (in[0] != '<' || in[in.size() - 1] != '>')
{
// It's a plain text message without HTML
out = in;
return;
}
bool ignore = false;
bool keep_link = false;
std::string last_six_chars;
unsigned int tag_start_index = 0;
Triple current_link;
for(unsigned int i = 0; i < in.size(); ++i)
{
if(keep_link && in[i] == '"')
{
keep_link = false;
current_link.second = out.size();
}
if(last_six_chars == "href=\"")
{
keep_link = true;
current_link.first = out.size();
}
// "rising edge" sets mode to ignore
if(in[i] == '<')
{
tag_start_index = i;
ignore = true;
}
if(!ignore || keep_link)
out += in[i];
// "falling edge" resets mode to keep
if(in[i] == '>') {
// leave ignore mode on, if it's a style tag
if (tag_start_index == 0 || tag_start_index + 6 > i || in.substr(tag_start_index, 6) != "<style")
ignore = false;
}
last_six_chars += in[i];
if(last_six_chars.size() > 6)
last_six_chars = last_six_chars.substr(1);
std::string a = "</a>";
if( current_link.first != -1
&& last_six_chars.size() >= a.size()
&& last_six_chars.substr(last_six_chars.size()-a.size()) == a)
{
// only allow these protocols
// we don't want for example javascript:alert(0)
std::string http = "http://";
std::string https = "https://";
std::string retroshare = "retroshare://";
if( out.substr(current_link.first, http.size()) == http
|| out.substr(current_link.first, https.size()) == https
|| out.substr(current_link.first, retroshare.size()) == retroshare)
{
current_link.third = out.size();
links.push_back(current_link);
}
current_link = Triple();
}
}
}
Triple egcd( ll a, ll b )
{
if( !b ) return Triple( a, ll( 1 ), ll( 0 ) );
Triple q = egcd( b, a % b );
return Triple( q.d, q.y, q.x - a / b * q.y );
}
MCAsmBackend *createHexagonAsmBackend(Target const &T,
MCRegisterInfo const & /*MRI*/,
StringRef TT, StringRef /*CPU*/) {
uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(Triple(TT).getOS());
return new ELFHexagonAsmBackend(T, OSABI);
}
void FeatureGenBackoff::add_template(int a, int b, int c/*=1*/) {
features_.push_back(Triple(a, b, c));
}
