void doWalkFunction(Function* func) {
Flat::verifyFlatness(func);
// Build the data-flow IR.
graph.build(func, getModule());
nodeUsers.build(graph);
// Propagate optimizations through the graph.
std::unordered_set<DataFlow::Node*> optimized; // which nodes we optimized
for (auto& node : graph.nodes) {
workLeft.insert(node.get()); // we should try to optimize each node
}
while (!workLeft.empty()) {
//std::cout << "\n\ndump before work iter\n";
//dump(graph, std::cout);
auto iter = workLeft.begin();
auto* node = *iter;
workLeft.erase(iter);
workOn(node);
}
// After updating the DataFlow IR, we can update the sets in
// the wasm.
// TODO: we also need phis, as a phi can flow directly into say
// a return or a call parameter.
for (auto* set : graph.sets) {
auto* node = graph.setNodeMap[set];
auto iter = optimized.find(node);
if (iter != optimized.end()) {
assert(node->isExpr()); // this is a set, where the node is defined
set->value = node->expr;
}
}
}
EvaluateResult evaluate(struct w_query_ctx* ctx, FileResult* file) override {
if (!set.empty()) {
bool matched;
w_string str;
if (wholename) {
str = w_query_ctx_get_wholename(ctx);
if (caseSensitive == CaseSensitivity::CaseInSensitive) {
str = str.piece().asLowerCase();
}
} else {
str = caseSensitive == CaseSensitivity::CaseInSensitive
? file->baseName().asLowerCase()
: file->baseName().asWString();
}
matched = set.find(str) != set.end();
return matched;
}
w_string_piece str;
if (wholename) {
str = w_query_ctx_get_wholename(ctx);
} else {
str = file->baseName();
}
if (caseSensitive == CaseSensitivity::CaseInSensitive) {
return w_string_equal_caseless(str, name);
}
return str == name;
}
std::shared_ptr<Settings> Settings::create(
std::shared_ptr<SettingsStorageInterface> settingsStorage,
std::unordered_set<std::shared_ptr<GlobalSettingsObserverInterface>> globalSettingsObserver,
std::shared_ptr<registrationManager::CustomerDataManager> dataManager) {
if (!settingsStorage) {
ACSDK_ERROR(LX("createFailed").d("reason", "settingsStorageNullReference").d("return", "nullptr"));
return nullptr;
}
if (globalSettingsObserver.empty()) {
ACSDK_ERROR(LX("createFailed").d("reason", "emptysettingsGlobalObserver").d("return", "nullptr"));
return nullptr;
}
for (auto observer : globalSettingsObserver) {
if (!observer) {
ACSDK_ERROR(LX("createFailed").d("reason", "settingsGlobalObserverNullReference").d("return", "nullptr"));
return nullptr;
}
}
auto settingsObject = std::shared_ptr<Settings>(new Settings(settingsStorage, globalSettingsObserver, dataManager));
if (!settingsObject->initialize()) {
ACSDK_ERROR(LX("createFailed").d("reason", "Initialization error."));
return nullptr;
}
return settingsObject;
}
void pal::setup_api_sets(const std::unordered_set<pal::string_t>& api_sets)
{
if (api_sets.empty())
{
return;
}
pal::string_t path;
(void) getenv(_X("PATH"), &path);
// We need this ugly hack, as the PInvoked DLL's static dependencies can come from
// some other NATIVE_DLL_SEARCH_DIRECTORIES and not necessarily side by side. However,
// CoreCLR.dll loads PInvoke DLLs with LOAD_WITH_ALTERED_SEARCH_PATH. Note that this
// option cannot be combined with LOAD_LIBRARY_SEARCH_USER_DIRS, so the AddDllDirectory
// doesn't help much in telling CoreCLR where to load the PInvoke DLLs from.
// So we resort to modifying the PATH variable on our own hoping Windows loader will do the right thing.
for (const auto& as : api_sets)
{
// AddDllDirectory is still needed for Standalone App's CoreCLR load.
::AddDllDirectory(as.c_str());
// Path patch is needed for static dependencies of a PInvoked DLL load out of the nuget cache.
path.push_back(PATH_SEPARATOR);
path.append(as);
}
trace::verbose(_X("Setting PATH=%s"), path.c_str());
::SetEnvironmentVariableW(_X("PATH"), path.c_str());
}
mod_manager::mod_manager()
{
// Insure obsolete_mod_list is initialized.
if( obsolete_mod_list.empty() && file_exist(FILENAMES["obsolete-mods"]) ) {
load_obsolete_mods(FILENAMES["obsolete-mods"]);
}
}
bool find_symbols(expression const e, std::function<bool(symbol)> const selector,
std::unordered_set<symbol,symbol::hash>& output)
{
if (selector(get_symbol(e)))
output.insert(get_symbol(e));
for (uint64_t i = 0ULL; i < num_parameters(e); ++i)
find_symbols(argument(e,i),selector,output);
return !output.empty();
}
void editor_coordinates_gui::perform(
editor_setup& setup,
const vec2i screen_size,
const vec2i mouse_pos,
const std::unordered_set<entity_id>& all_selected
) {
using namespace augs::imgui;
auto coordinates = make_scoped_window(ImGuiWindowFlags_AlwaysAutoResize);
if (!coordinates) {
return;
}
const auto settings = setup.settings;
auto& v = setup.view();
if (const auto current_eye = setup.find_current_camera_eye()) {
const auto cone = camera_cone(*current_eye, screen_size);
const auto world_cursor_pos = cone.to_world_space(mouse_pos);
text("Grid size: %x/%x", v.grid.unit_pixels, settings.grid.render.get_maximum_unit());
text("Cursor: %x", world_cursor_pos);
text("View center: %x", vec2(current_eye->transform.pos).discard_fract());
text("Camera AABB: %x", cone.get_visible_world_rect_aabb());
{
auto zoom = current_eye->zoom * 100.f;
if (slider("Zoom: ", zoom, 1.f, 1000.f, "%.3f%%")) {
if (!v.panned_camera.has_value()) {
v.panned_camera = current_eye;
}
zoom = std::clamp(zoom, 1.f, 1000.f);
v.panned_camera->zoom = zoom / 100.f;
}
}
}
text("Rect select mode: %x", format_enum(v.rect_select_mode));
if (!all_selected.empty()) {
text("Selected %x entities", all_selected.size());
if (const auto aabb = setup.find_selection_aabb()) {
const auto size = aabb->get_size();
text("AABB: %x x %x pixels\ncenter: %x\nlt: %x\nrb: %x", size.x, size.y, aabb->get_center(), aabb->left_top(), aabb->right_bottom());
}
}
else {
text("No entity selected");
}
}
GMsg VectorBuffer::EraseFeatureFromInteraction(
const feature_ptr &src, const string &proj,
const std::unordered_set<long> &targets,
const std::unordered_set<long> &immunes)
{
GRect ext = MapnikUtils::Box2d2GRect(src->envelope());
unordered_map<long, feature_ptr> fs = GetFeaturesInRect(
proj, ext, _config_app().VIEW_VECTORBUFFER_SELECTION_MAX);
unordered_map<long, feature_ptr> edited_in_clipping;
unordered_set<long> removed_in_clipping;
for (unordered_map<long, feature_ptr>::const_iterator it = fs.begin();
it != fs.end(); it++)
{
feature_ptr f = it->second;
if (immunes.find(f->id()) != immunes.end()) continue;
if (!targets.empty() && targets.find(f->id()) == targets.end()) continue;
if (MapnikUtils::contains(
src, f, wkbPolygon, _book->GetGeomType(), proj, _layer->proj()))
{
removed_in_clipping.insert(it->first);
}
else if (MapnikUtils::intersects(
src, f, wkbPolygon, _book->GetGeomType(), proj, _layer->proj()))
{
feature_ptr clipped = MapnikUtils::difference(
f, src, _book->GetGeomType(), wkbPolygon, _layer->proj(), proj);
if (clipped != nullptr) {
edited_in_clipping.insert(pair<long, feature_ptr>(it->first, clipped));
}
}
}
unsigned int num = removed_in_clipping.size() + edited_in_clipping.size();
if (num == 0) return G_NOERR;
_undoStack->beginMacro(num == 1 ? "Erase feature" : "Erase features");
for (unordered_set<long>::const_iterator it = removed_in_clipping.begin();
it != removed_in_clipping.end(); it++)
{
_undoStack->push(new VBCommandDeleteFeature(this, *it));
}
for (unordered_map<long, feature_ptr>::const_iterator it = edited_in_clipping.begin();
it != edited_in_clipping.end(); it++)
{
long fid = it->first;
feature_ptr f = it->second;
Q_ASSERT(_deletedFeatures.find(fid) == _deletedFeatures.end());
f->put<value_unicode_string>(
_config_app().VIEW_VECTORBUFFER_FIELD_EDITED,
transcoder("utf-8").transcode("edited"));
_undoStack->push(new VBCommandEditFeature(this, fid, f));
}
_undoStack->endMacro();
return G_NOERR;
}
//------------------------------------------------------------------------------
Entity * Scene::getTaggedEntity(const std::string & tag)
{
u32 tagIndex = m_tagManager.getTagIndex(tag);
if (tagIndex == TagManager::INVALID_INDEX)
return nullptr;
const std::unordered_set<Entity*> taggedEntities = m_tagManager.getObjectsByTag(tagIndex);
if (taggedEntities.empty())
return nullptr;
return *taggedEntities.begin();
}
static bool codetester_module_cleanup(KviModule *)
{
while(!g_pCodeTesterWindowList.empty())
{
auto w = g_pCodeTesterWindowList.begin();
if (w == g_pCodeTesterWindowList.end())
break;
(*w)->close(); // deleted path!
}
return true;
}
virtual void global_initialize(m3bp::Task &task) override {
EXPECT_FALSE(m_global_initialized);
EXPECT_TRUE(m_thread_local_initialized.empty());
const auto num_iports = input_ports().size();
for(m3bp::identifier_type i = 0; i < num_iports; ++i){
const auto &iport = input_ports()[i];
if(iport.movement() == m3bp::Movement::BROADCAST){
m_broadcasted[i] = read_input(task.input(i));
}
}
m_global_initialized = true;
}
//------------------------------------------------------------------------------
std::vector<Entity*> Scene::getTaggedEntities(const std::string & tag)
{
std::vector<Entity*> entities;
u32 tagIndex = m_tagManager.getTagIndex(tag);
if (tagIndex == TagManager::INVALID_INDEX)
return entities;
const std::unordered_set<Entity*> taggedEntities = m_tagManager.getObjectsByTag(tagIndex);
if (taggedEntities.empty())
return entities;
entities.reserve(taggedEntities.size());
for (auto it = taggedEntities.begin(); it != taggedEntities.end(); ++it)
entities.push_back(*it);
return entities;
}
void operator()(msgpack::object::with_zone& o, const std::unordered_set<T>& v) const {
o.type = msgpack::type::ARRAY;
if(v.empty()) {
o.via.array.ptr = nullptr;
o.via.array.size = 0;
} else {
uint32_t size = checked_get_container_size(v.size());
msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
msgpack::object* const pend = p + size;
o.via.array.ptr = p;
o.via.array.size = size;
typename std::unordered_set<T>::const_iterator it(v.begin());
do {
*p = msgpack::object(*it, o.zone);
++p;
++it;
} while(p < pend);
}
}
bool wordBreak(std::string s, std::unordered_set<std::string> &dict) {
if (dict.empty())
return false;
int len = s.size(), max_len = dict.begin()->size(), min_len = max_len;
for (auto it = dict.begin(); it != dict.end(); ++it)
if (it->size() > max_len)
max_len = it->size();
else if (it->size() < min_len)
min_len = it->size();
std::vector<int> flag(len + 1);
flag[len] = 1;
for (int i = len - 1; i >= 0; --i)
for (int j = min_len; j <= std::min(max_len, len - i); ++j)
if (flag[i + j] && dict.find(s.substr(i, j)) != dict.end()) {
flag[i] = 1;
break;
}
return flag[0] == 1;
}
virtual ~TestProcessorBase(){
EXPECT_FALSE(m_global_initialized);
EXPECT_TRUE(m_thread_local_initialized.empty());
}
static bool links_module_can_unload(KviModule *)
{
return (g_pLinksWindowList.empty());
}
static bool codetester_module_can_unload(KviModule *)
{
return g_pCodeTesterWindowList.empty();
}
int compute_evc_bound_using_sukp(Dataset &dataset,
const std::unordered_set<const std::set<int>*> &collection, const
stats_config &stats_conf, std::pair<int,int> &result) {
std::ifstream dataset_s(dataset.get_path());
if(! dataset_s.good()) {
std::cerr << "ERROR: cannot open dataset file" << std::endl;
dataset_s.close();
std::exit(EXIT_FAILURE);
}
if (collection.empty()) {
result.first = 0;
result.second = 0;
return 1;
}
// The following is called U in the pseudocode
std::unordered_set<int> items;
int collection_size = 0;
for (const std::set<int> *itemset : collection) {
items.insert(itemset->begin(), itemset->end());
++collection_size;
}
// The following is called L in the pseudocode
std::map<int, int, bool (*)(int,int)> intersection_sizes_counts(reverse_int_comp);
// The following is called D_C in the pseudocode
std::set<std::set<int> > intersections;
std::string line;
int size = 0;
while (std::getline(dataset_s, line)) {
++size;
const std::set<int> tau = string2itemset(line);
std::vector<int> intersection_v(tau.size());
std::vector<int>::iterator it;
it = std::set_intersection(
tau.begin(), tau.end(), items.begin(), items.end(),
intersection_v.begin());
if (it != intersection_v.begin() && it - intersection_v.begin() != items.size()) {
std::set<int> intersection(intersection_v.begin(), it);
std::pair<std::set<std::set<int> >::iterator, bool> insertion_pair = intersections.insert(intersection);
if (insertion_pair.second) { // intersection was not already in intersections
std::map<int, int, bool (*)(int,int)>::iterator intersection_it = intersection_sizes_counts.find(intersection.size());
if (intersection_it == intersection_sizes_counts.end()) { // we've never seen an intersection of this size
int prev_value = 0; // We add an element with key equal to the intersection size, and value equal to the value of the element with key immediately larger thn this one, or 0 if there is no such element.
if (! intersection_sizes_counts.empty()) {
auto longer_intersection_it = intersection_sizes_counts.lower_bound(intersection.size());
if (longer_intersection_it != intersection_sizes_counts.begin()) {
--longer_intersection_it;
prev_value = longer_intersection_it->second;
}
}
intersection_it = (intersection_sizes_counts.emplace(intersection.size(), prev_value)).first;
}
// Exploit the sorted nature (in decreasing order) of the map
for (; intersection_it != intersection_sizes_counts.end(); ++intersection_it) {
intersection_sizes_counts[intersection_it->first] += 1;
}
}
}
}
dataset_s.close();
dataset.set_size(size); // Set size in the database object
// We do not need a counter 'i' like in the pseudocode, we can use an
// iterator that exploits the sorted nature of the map
std::map<int, int, bool (*)(int,int)>::iterator it = intersection_sizes_counts.begin();
IloEnv env;
IloModel model(env);
if (get_CPLEX_model(model, env, items, collection, it->first, stats_conf.use_antichain) == -1) {
std::cerr << "ERROR: something went wrong while building the CPLEX model" << std::endl;
env.end();
std::exit(EXIT_FAILURE);
}
IloCplex cplex(model);
// Set parameters, like max runtime and tolerance gaps
set_CPLEX_params(cplex);
// Redirect output to null stream
cplex.setOut(env.getNullStream());
// Iterate over the possible lengths
while (true) {
// The following is q in the pseudocode
double profit = get_SUKP_profit(cplex);
if (profit == -1.0) {
std::cerr << "ERROR: something went wrong while solving the SUKP" << std::endl;
env.end();
std::exit(EXIT_FAILURE);
}
// This is b in the pseudocode
int bound = ((int) floor(log2(profit))) + 1;
if (bound <= it->second) {
result.first = bound;
result.second = -1;
env.end();
return 1;
} else {
++it;
if (it != intersection_sizes_counts.end()) {
if (it->first == 1) {
result.first = 1;
result.second = -1;
env.end();
return 1;
}
set_capacity(model, it->first);
} else {
env.end();
break;
}
}
}
--it;
// XXX TODO The following needs to be checked a bit: it may not be the best.
result.first = (int) floor(fmin(it->second, log2(collection_size)));
result.second = -1;
env.end();
return 1;
}
virtual void global_finalize(m3bp::Task &task) override {
EXPECT_TRUE(m_global_initialized);
EXPECT_TRUE(m_thread_local_initialized.empty());
m_global_initialized = false;
if(!task.is_cancelled()){ validate_broadcast_inputs(task); }
}
~DefaultFileSystem()
{
DF3D_ASSERT(m_sources.empty());
}
Stats::Stats(
Dataset &dataset,
const std::unordered_set<const std::set<int> *> &collection, const stats_config &stats_conf, Itemset *root) {
std::ifstream dataset_s(dataset.get_path());
if (stats_conf.cnt_method == COUNT_SUKP) {
std::pair<int, int> result;
compute_evc_bound_using_sukp(dataset, collection, stats_conf, result);
evc_bound = result.first;
max_supp = result.second;
return;
}
if(! dataset_s.good()) {
std::cerr << "ERROR: cannot open dataset file" << std::endl;
dataset_s.close();
std::exit(EXIT_FAILURE);
}
if (collection.empty()) {
evc_bound = 0;
max_supp = 0;
return;
}
// The following is called U in the pseudocode
std::set<int> items;
for (const std::set<int> *itemset : collection) {
items.insert(itemset->begin(), itemset->end());
}
// The following is called T in the pseudocode. The name is a little
// confusing, because the keys are not really the sizes of the
// intersections, but rather are the values
// \lfloor\log_2 \ell_\tau\rfloor + 1,
// where \ell_tau is the number of itemsets in C that appear in \tau.
std::map<int, std::forward_list<const std::set<int> *>, bool (*)(int,int)>
intersections_by_size(reverse_int_comp);
// The following is called L in the pseudocode
std::set<std::set<int>> intersections;
std::string line;
int size = 0;
// This is the first loop in the pseudocode, to populate T and L
while (std::getline(dataset_s, line)) {
++size;
const std::set<int> tau = string2itemset(line);
std::vector<int> intersection_v(tau.size());
std::vector<int>::iterator it;
it = std::set_intersection(
tau.begin(), tau.end(), items.begin(), items.end(),
intersection_v.begin());
if (it != intersection_v.begin() && it - intersection_v.begin() != items.size()) {
std::set<int> intersection(intersection_v.begin(), it);
std::pair<std::set<std::set<int> >::iterator, bool> insertion_pair = intersections.insert(intersection);
if (insertion_pair.second) { // intersection was not already in intersections
int itemsets_in_tau_log = intersection.size();
if (stats_conf.cnt_method == COUNT_EXACT) {
int itemsets_in_tau = 0;
if (stats_conf.use_antichain) {
itemsets_in_tau = get_largest_antichain_size(intersection, collection, root);
} else {
itemsets_in_tau = find_itemsets_in_transaction(intersection, collection, root);
}
itemsets_in_tau_log = ((int) floor(log2(itemsets_in_tau))) + 1;
}
if (intersections_by_size.find(itemsets_in_tau_log) == intersections_by_size.end()) {
std::forward_list<const std::set<int> *> v(1, &(*insertion_pair.first));
intersections_by_size[itemsets_in_tau_log] = v;
} else {
intersections_by_size[itemsets_in_tau_log].push_front(&(*insertion_pair.first));
}
}
}
}
dataset_s.close();
dataset.set_size(size); // Set size in the database object
//itemsets_supps.clear(); XXX I never know if this is a good idea
evc_bound = compute_evc_bound(intersections_by_size, stats_conf);
max_supp = -1;
}
static bool links_module_cleanup(KviModule *)
{
while (!g_pLinksWindowList.empty())
(*g_pLinksWindowList.begin())->die();
return true;
}