PB_DS_CLASS_T_DEC inline void PB_DS_CLASS_C_DEC:: rotate_right(node_pointer p_x) { node_pointer p_y = p_x->m_p_left; p_x->m_p_left = p_y->m_p_right; if (p_y->m_p_right != 0) p_y->m_p_right->m_p_parent = p_x; p_y->m_p_parent = p_x->m_p_parent; if (p_x == m_p_head->m_p_parent) m_p_head->m_p_parent = p_y; else if (p_x == p_x->m_p_parent->m_p_right) p_x->m_p_parent->m_p_right = p_y; else p_x->m_p_parent->m_p_left = p_y; p_y->m_p_right = p_x; p_x->m_p_parent = p_y; PB_DS_ASSERT_NODE_CONSISTENT(p_x) PB_DS_ASSERT_NODE_CONSISTENT(p_y) apply_update(p_x, (node_update* )this); apply_update(p_x->m_p_parent, (node_update* )this); }
void PreUpdater::receive(Message *update) { try { apply_update(update); } catch (const DataError& err) { BOOST_LOG_TRIVIAL(error) << "Invalid update received; " << err.what(); } }
void LinearLayer::update(double learning_rate) { MatrixAdd apply_update(-1*learning_rate); apply_update.execute(m_weights, m_weights_update); apply_update.execute(m_bias, m_bias_update); std::cout << "Sum of weight updates linear layer" << DataAbsSum().execute(m_weights_update) << std::endl; }
inline void PB_DS_CLASS_C_DEC:: update_to_top(node_pointer p_nd, Node_Update_* p_update) { while (p_nd != m_p_head) { apply_update(p_nd, p_update); p_nd = p_nd->m_p_parent; } }
PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::entry_pointer PB_DS_CLASS_C_DEC:: find_imp(const_key_reference r_key) const { if (m_p_l == NULL) return NULL; if (s_eq_fn(r_key, PB_DS_V2F(m_p_l->m_value))) { apply_update(m_p_l, s_metadata_type_indicator); _GLIBCXX_DEBUG_ONLY(map_debug_base::check_key_exists(r_key);) return m_p_l;
PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::entry_pointer PB_DS_CLASS_C_DEC:: find_imp(key_const_reference r_key) const { if (m_p_l == 0) return 0; if (s_eq_fn(r_key, PB_DS_V2F(m_p_l->m_value))) { apply_update(m_p_l, s_metadata_type_indicator); PB_DS_CHECK_KEY_EXISTS(r_key) return m_p_l; }
static int sj_init() { struct v7 *v7 = s_v7; LOG(LL_INFO, ("Mongoose IoT Firmware %s", build_id)); LOG(LL_INFO, ("RAM: %d total, %d free", sj_get_heap_size(), sj_get_free_heap_size())); int r = start_nwp(); if (r < 0) { LOG(LL_ERROR, ("Failed to start NWP: %d", r)); return 0; } int boot_cfg_idx = get_active_boot_cfg_idx(); if (boot_cfg_idx < 0) return 0; struct boot_cfg boot_cfg; if (read_boot_cfg(boot_cfg_idx, &boot_cfg) < 0) return 0; LOG(LL_INFO, ("Boot cfg %d: 0x%llx, 0x%u, %s @ 0x%08x, %s", boot_cfg_idx, boot_cfg.seq, boot_cfg.flags, boot_cfg.app_image_file, boot_cfg.app_load_addr, boot_cfg.fs_container_prefix)); uint64_t saved_seq = 0; if (boot_cfg.flags & BOOT_F_FIRST_BOOT) { /* Tombstone the current config. If anything goes wrong between now and * commit, next boot will use the old one. */ saved_seq = boot_cfg.seq; boot_cfg.seq = BOOT_CFG_TOMBSTONE_SEQ; write_boot_cfg(&boot_cfg, boot_cfg_idx); } r = init_fs(boot_cfg.fs_container_prefix); if (r < 0) { LOG(LL_ERROR, ("FS init error: %d", r)); if (boot_cfg.flags & BOOT_F_FIRST_BOOT) { revert_update(boot_cfg_idx, &boot_cfg); } return 0; } if (boot_cfg.flags & BOOT_F_FIRST_BOOT) { LOG(LL_INFO, ("Applying update")); if (apply_update(boot_cfg_idx, &boot_cfg) < 0) { revert_update(boot_cfg_idx, &boot_cfg); } } mongoose_init(); #ifndef CS_DISABLE_JS v7 = s_v7 = init_v7(&v7); /* Disable GC during JS API initialization. */ v7_set_gc_enabled(v7, 0); sj_gpio_api_setup(v7); sj_i2c_api_setup(v7); sj_wifi_api_setup(v7); sj_timers_api_setup(v7); #endif sj_v7_ext_api_setup(v7); sj_init_sys(v7); sj_wifi_init(v7); #ifndef DISABLE_C_CLUBBY sj_clubby_init(); #endif sj_http_api_setup(v7); #if !defined(DISABLE_C_CLUBBY) && !defined(CS_DISABLE_JS) sj_clubby_api_setup(v7); #endif /* Common config infrastructure. Mongoose & v7 must be initialized. */ init_device(v7); sj_updater_post_init(v7); #ifndef DISABLE_C_CLUBBY init_updater_clubby(v7); #endif #ifndef CS_DISABLE_JS /* SJS initialized, enable GC back, and trigger it */ v7_set_gc_enabled(v7, 1); v7_gc(v7, 1); v7_val_t res; if (v7_exec_file(v7, "sys_init.js", &res) != V7_OK) { fprintf(stderr, "Error: "); v7_fprint(stderr, v7, res); } #endif LOG(LL_INFO, ("%s init done, RAM: %d free", "Sys", sj_get_free_heap_size())); if (!sj_app_init(v7)) { LOG(LL_ERROR, ("App init failed")); abort(); } LOG(LL_INFO, ("%s init done, RAM: %d free", "App", sj_get_free_heap_size())); if (boot_cfg.flags & BOOT_F_FIRST_BOOT) { boot_cfg.seq = saved_seq; commit_update(boot_cfg_idx, &boot_cfg); clubby_updater_finish(0); } else { /* * If there is no update reply state, this will just be ignored. * But if there is, then update was rolled back and reply will be sent. */ clubby_updater_finish(-1); } #ifndef CS_DISABLE_JS sj_prompt_init(v7); #endif return 1; }
bool operator()(ProblemDescriptionT & problem_description, PDESystemT const & pde_system, LinearSolverT& linear_solver, std::size_t break_pde = 0) { #ifdef VIENNAFVM_VERBOSE std::streamsize cout_precision = std::cout.precision(); #endif bool is_linear = pde_system.is_linear(); //TODO: Replace with an automatic detection if (is_linear) { for (std::size_t pde_index = 0; pde_index < pde_system.size(); ++pde_index) { #ifdef VIENNAFVM_VERBOSE viennafvm::Timer timer; timer.start(); std::cout << " * Quantity " << pde_index << " : " << std::endl; std::cout << " ------------------------------------------" << std::endl; #endif MatrixType system_matrix; VectorType load_vector; #ifdef VIENNAFVM_VERBOSE viennafvm::Timer subtimer; subtimer.start(); #endif viennafvm::linear_assembler fvm_assembler; fvm_assembler(pde_system, pde_index, problem_description.mesh(), problem_description.quantities(), system_matrix, load_vector); #ifdef VIENNAFVM_VERBOSE std::cout.precision(3); subtimer.get(); std::cout << " Assembly time : " << std::fixed << subtimer.get() << " s" << std::endl; #endif VectorType update; linear_solver(system_matrix, load_vector, update); #ifdef VIENNAFVM_VERBOSE std::cout << " Solver time : " << std::fixed << linear_solver.last_solver_time() << " s" << std::endl; #endif #ifdef VIENNAFVM_VERBOSE subtimer.start(); numeric_type update_norm = apply_update(pde_system, pde_index, problem_description.mesh(), problem_description.quantities(), update, 1.0); #else apply_update(pde_system, pde_index, problem_description.mesh(), problem_description.quantities(), update, 1.0); //this is linear, so there's no need for any damping #endif #ifdef VIENNAFVM_VERBOSE subtimer.get(); std::cout << " Update time : " << std::fixed << subtimer.get() << " s" << std::endl; #endif #ifdef VIENNAFVM_VERBOSE timer.get(); std::cout << " Total time : " << std::fixed << timer.get() << " s" << std::endl; std::cout.precision(cout_precision); std::cout.unsetf(std::ios_base::floatfield); std::cout << " Solver iters : " << linear_solver.last_iterations(); if(linear_solver.last_iterations() == linear_solver.max_iterations()) std::cout << " ( not converged ) " << std::endl; else std::cout << std::endl; std::cout << " Solver error : " << linear_solver.last_error() << std::endl; std::cout << " Update norm : " << update_norm << std::endl; std::cout << std::endl; #endif if(linear_solver.last_iterations() == linear_solver.max_iterations()) { #ifdef VIENNAFVM_VERBOSE std::cout << " Linear Solver for pde: " << pde_index << "failed to converge" << std::endl; #endif return false; // TODO: should we stop solving here? } } } else // nonlinear { picard_iteration_ = true; #ifdef VIENNAFVM_VERBOSE std::vector<double> previous_update_norms(pde_system.size()); #endif bool converged = false; std::size_t required_nonlinear_iterations = 0; for (std::size_t iter=0; iter < nonlinear_iterations; ++iter) { required_nonlinear_iterations++; #ifdef VIENNAFVM_VERBOSE std::cout << " --- Nonlinear iteration " << iter << " --- " << std::endl; #endif if (picard_iteration_) { for (std::size_t pde_index = 0; pde_index < pde_system.size(); ++pde_index) { #ifdef VIENNAFVM_VERBOSE viennafvm::Timer timer; timer.start(); std::cout << " * Quantity " << pde_index << " : " << std::endl; std::cout << " ------------------------------------" << std::endl; #endif MatrixType system_matrix; VectorType load_vector; #ifdef VIENNAFVM_VERBOSE viennafvm::Timer subtimer; subtimer.start(); #endif // assemble linearized systems viennafvm::linear_assembler fvm_assembler; fvm_assembler(pde_system, pde_index, problem_description.mesh(), problem_description.quantities(), system_matrix, load_vector); #ifdef VIENNAFVM_VERBOSE std::cout.precision(3); subtimer.get(); std::cout << " Assembly time : " << std::fixed << subtimer.get() << " s" << std::endl; #endif VectorType update; linear_solver(system_matrix, load_vector, update); #ifdef VIENNAFVM_VERBOSE std::cout << " Solver time : " << std::fixed << linear_solver.last_solver_time() << " s" << std::endl; #endif #ifdef VIENNAFVM_VERBOSE subtimer.start(); #endif numeric_type update_norm = apply_update(pde_system, pde_index, problem_description.mesh(), problem_description.quantities(), update, damping); #ifdef VIENNAFVM_VERBOSE subtimer.get(); std::cout << " Update time : " << std::fixed << subtimer.get() << " s" << std::endl; #endif #ifdef VIENNAFVM_VERBOSE timer.get(); std::cout << " Total time : " << std::fixed << timer.get() << " s" << std::endl; std::cout.precision(cout_precision); std::cout.unsetf(std::ios_base::floatfield); std::cout << " Solver iters : " << linear_solver.last_iterations(); if(linear_solver.last_iterations() == linear_solver.max_iterations()) std::cout << " ( not converged ) " << std::endl; else std::cout << std::endl; std::cout << " Solver error : " << linear_solver.last_error() << std::endl; std::string norm_tendency_indicator; if(iter == 0) { previous_update_norms[pde_index] = update_norm; norm_tendency_indicator = ""; } else { if(update_norm > previous_update_norms[pde_index]) norm_tendency_indicator = "<up>"; else if(update_norm < previous_update_norms[pde_index]) norm_tendency_indicator = "<down>"; else norm_tendency_indicator = "<=>"; previous_update_norms[pde_index] = update_norm; } std::cout << " Update norm : " << update_norm << " " << norm_tendency_indicator; if(pde_index == break_pde) std::cout << " ( **** )" << std::endl; else std::cout << std::endl; std::cout << std::endl; #endif if(pde_index == break_pde) // check if the potential update has converged .. { if(update_norm <= nonlinear_breaktol) converged = true; } } } else { throw "not implemented!"; } #ifdef VIENNAFVM_VERBOSE std::cout << std::endl; #endif if(converged) break; // .. the nonlinear for-loop } // nonlinear for-loop if(!converged) { #ifdef VIENNAFVM_VERBOSE std::cout << std::endl; std::cout << "--------" << std::endl; std::cout << "Warning: Simulation did not converge!" << std::endl; std::cout << " Update norm of observed variable did not reach the break-tolerance of " << nonlinear_breaktol << " in " << nonlinear_iterations << " iterations" << std::endl; std::cout << "--------" << std::endl; #endif return false; } #ifdef VIENNAFVM_VERBOSE std::cout << std::endl; std::cout << "--------" << std::endl; std::cout << "Success: Simulation converged successfully!" << std::endl; std::cout << " Update norm of observed variable reached the break-tolerance of " << nonlinear_breaktol << " in " << required_nonlinear_iterations << " iterations" << std::endl; std::cout << "--------" << std::endl; #endif } return true; }
bool do_update() { compute_update(); return apply_update(); }