TEST(Flag, MultiThreaded) { Flag f; int count = 0; const int ITERATIONS_COUNT = 100000; auto setter = [&]() { for (int i = 0; i < ITERATIONS_COUNT; ++i) { while (f.IsSet()); f.Set(); } }; auto clearer = [&]() { for (int i = 0; i < ITERATIONS_COUNT; ++i) { while (!f.IsSet()); count++; f.Clear(); } }; std::thread setter_thread(setter); std::thread clearer_thread(clearer); setter_thread.join(); clearer_thread.join(); EXPECT_EQ(ITERATIONS_COUNT, count); }
void CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_double(), "wrong flag type"); trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin); faddr->set_double(value); faddr->set_origin(origin); }
Flag* Flag::fuzzy_match(const char* name, size_t length, bool allow_locked) { float VMOptionsFuzzyMatchSimilarity = 0.7f; Flag* match = NULL; float score; float max_score = -1; for (Flag* current = &flagTable[0]; current->name != NULL; current++) { score = str_similar(current->name, name, length); if (score > max_score) { max_score = score; match = current; } } if (!(match->is_unlocked() || match->is_unlocker())) { if (!allow_locked) { return NULL; } } if (max_score < VMOptionsFuzzyMatchSimilarity) { return NULL; } return match; }
Flag::Error CommandLineFlags::uintxAt(const char* name, size_t len, uintx* value, bool allow_locked, bool return_flag) { Flag* result = Flag::find_flag(name, len, allow_locked, return_flag); if (result == NULL) return Flag::INVALID_FLAG; if (!result->is_uintx()) return Flag::WRONG_FORMAT; *value = result->get_uintx(); return Flag::SUCCESS; }
TEST(Flag, SpinLock) { // Uses a flag to implement basic spinlocking using TestAndSet. Flag f; int count = 0; const int ITERATIONS_COUNT = 5000; const int THREADS_COUNT = 50; auto adder_func = [&]() { for (int i = 0; i < ITERATIONS_COUNT; ++i) { // Acquire the spinlock. while (!f.TestAndSet()); count++; f.Clear(); } }; std::array<std::thread, THREADS_COUNT> threads; for (auto& th : threads) th = std::thread(adder_func); for (auto& th : threads) th.join(); EXPECT_EQ(ITERATIONS_COUNT * THREADS_COUNT, count); }
bool CommandLineFlags::doubleAt(char* name, size_t len, double* value) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return false; if (!result->is_double()) return false; *value = result->get_double(); return true; }
bool CommandLineFlags::ccstrAt(char* name, size_t len, ccstr* value) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return false; if (!result->is_ccstr()) return false; *value = result->get_ccstr(); return true; }
void CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type"); trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin); faddr->set_bool(value); faddr->set_origin(origin); }
bool CommandLineFlags::uint64_tAt(char* name, size_t len, uint64_t* value) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return false; if (!result->is_uint64_t()) return false; *value = result->get_uint64_t(); return true; }
void CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type"); trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin); faddr->set_uint64_t(value); faddr->set_origin(origin); }
void CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type"); trace_flag_changed<EventLongFlagChanged, s8>(faddr->_name, faddr->get_intx(), value, origin); faddr->set_intx(value); faddr->set_origin(origin); }
bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, FlagValueOrigin origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return false; if (!result->is_uint64_t()) return false; uint64_t old_value = result->get_uint64_t(); result->set_uint64_t(*value); *value = old_value; result->origin = origin; return true; }
bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, FlagValueOrigin origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return false; if (!result->is_double()) return false; double old_value = result->get_double(); result->set_double(*value); *value = old_value; result->origin = origin; return true; }
// Contract: Flag will make private copy of the incoming value. // Outgoing value is always malloc-ed, and caller MUST call free. bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, FlagValueOrigin origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return false; if (!result->is_ccstr()) return false; ccstr old_value = result->get_ccstr(); char* new_value = NULL; if (*value != NULL) { new_value = NEW_C_HEAP_ARRAY(char, strlen(*value)+1, mtInternal); strcpy(new_value, *value); }
bool CommandLineFlags::boolAtPut(char* name, size_t len, bool* value, Flag::Flags origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return false; if (!result->is_bool()) return false; bool old_value = result->get_bool(); trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin); result->set_bool(*value); *value = old_value; result->set_origin(origin); return true; }
Flag& Flag::get(const std::string& name, const std::string& type, const std::string& value, const std::string& desc, bool shell_only) { static Flag f; if (name != "") { f.add(name, type, value, desc, shell_only); } return f; }
// Contract: Flag will make private copy of the incoming value. // Outgoing value is always malloc-ed, and caller MUST call free. bool CommandLineFlags::ccstrAtPut(char* name, size_t len, ccstr* value, Flag::Flags origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return false; if (!result->is_ccstr()) return false; ccstr old_value = result->get_ccstr(); trace_flag_changed<EventStringFlagChanged, const char*>(name, old_value, *value, origin); char* new_value = NULL; if (*value != NULL) { new_value = NEW_C_HEAP_ARRAY(char, strlen(*value)+1, mtInternal); strcpy(new_value, *value); }
bool CommandLineFlags::doubleAtPut(char* name, size_t len, double* value, Flag::Flags origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return false; if (!result->is_double()) return false; double old_value = result->get_double(); trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin); result->set_double(*value); *value = old_value; result->set_origin(origin); return true; }
bool CommandLineFlags::uint64_tAtPut(char* name, size_t len, uint64_t* value, Flag::Flags origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return false; if (!result->is_uint64_t()) return false; uint64_t old_value = result->get_uint64_t(); trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); result->set_uint64_t(*value); *value = old_value; result->set_origin(origin); return true; }
bool CommandLineFlags::intxAtPut(char* name, size_t len, intx* value, Flag::Flags origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return false; if (!result->is_intx()) return false; intx old_value = result->get_intx(); trace_flag_changed<EventLongFlagChanged, s8>(name, old_value, *value, origin); result->set_intx(*value); *value = old_value; result->set_origin(origin); return true; }
void QuoteTest::testObservable() { BOOST_MESSAGE("Testing observability of quotes..."); boost::shared_ptr<SimpleQuote> me(new SimpleQuote(0.0)); Flag f; f.registerWith(me); me->setValue(3.14); if (!f.isUp()) BOOST_FAIL("Observer was not notified of quote change"); }
// Implementation of "setflag" command static jint set_flag(AttachOperation* op, outputStream* out) { const char* name = NULL; if ((name = op->arg(0)) == NULL) { out->print_cr("flag name is missing"); return JNI_ERR; } Flag* f = Flag::find_flag((char*)name, strlen(name)); if (f && f->is_external() && f->is_writeable()) { if (f->is_bool()) { return set_bool_flag(name, op, out); } else if (f->is_intx()) { return set_intx_flag(name, op, out); } else if (f->is_uintx()) { return set_uintx_flag(name, op, out); } else if (f->is_uint64_t()) { return set_uint64_t_flag(name, op, out); } else if (f->is_ccstr()) { return set_ccstr_flag(name, op, out); } else { ShouldNotReachHere(); return JNI_ERR; } } else { return AttachListener::pd_set_flag(op, out); } }
/** * Parses a config file with lines of the form * * flag = value * * and sets flags as appropriate. */ Status ParseConfigFile() { Trace(); if (!g_configFile.wasSet()) { Log(LL::Trace) << "No flag config file specified."; return Status::ok(); } const std::string &filename = g_configFile.get(); Log(LL::Trace) << "Begining parse of config file: " << filename; std::ifstream ifile(filename.c_str()); if (!ifile.is_open()) { Log(LL::Trace) << "Config file " << filename << " not found."; return Status(Status::NOT_FOUND); } std::string line; int lineno = 0; while (std::getline(ifile, line)) { if (line.empty()) { lineno++; continue; } std::vector< std::string > argstr = Splitter().on('=').trimWhitespace().split(line, 2); RET_SM( argstr.size() == 2, Status::BAD_INPUT, "Error in config file \"" << filename << "\" " << "on line " << lineno << " is not a valid flag=value pair"); tFlagIter itr = GetGlobalFlags().find(argstr[0]); RET_SM( itr != GetGlobalFlags().end(), Status::BAD_INPUT, "Unknown flag: " << argstr[0] << " @ line " << lineno); iFlagBase *pFlag = itr->second; RET_SM( pFlag->fromString(TrimQuotes(argstr[1])), Status::BAD_INPUT, "Invalid flag value for " << argstr[0] << " at line " << lineno << ". can't parse: " << argstr[1]); lineno++; } return Status::ok(); }
void InstrumentTest::testObservable() { BOOST_TEST_MESSAGE("Testing observability of instruments..."); boost::shared_ptr<SimpleQuote> me1(new SimpleQuote(0.0)); RelinkableHandle<Quote> h(me1); boost::shared_ptr<Instrument> s(new Stock(h)); Flag f; f.registerWith(s); s->NPV(); me1->setValue(3.14); if (!f.isUp()) BOOST_FAIL("Observer was not notified of instrument change"); s->NPV(); f.lower(); boost::shared_ptr<SimpleQuote> me2(new SimpleQuote(0.0)); h.linkTo(me2); if (!f.isUp()) BOOST_FAIL("Observer was not notified of instrument change"); f.lower(); s->freeze(); s->NPV(); me2->setValue(2.71); if (f.isUp()) BOOST_FAIL("Observer was notified of frozen instrument change"); s->NPV(); s->unfreeze(); if (!f.isUp()) BOOST_FAIL("Observer was not notified of instrument change"); }
// Implementation of "printflag" command // See also: PrintVMFlagsDCmd class static jint print_flag(AttachOperation* op, outputStream* out) { const char* name = NULL; if ((name = op->arg(0)) == NULL) { out->print_cr("flag name is missing"); return JNI_ERR; } Flag* f = Flag::find_flag((char*)name, strlen(name)); if (f) { f->print_as_flag(out); out->print_cr(""); } else { out->print_cr("no such flag '%s'", name); } return JNI_OK; }
bool NE_DLL NEDebugManager::Flag::operator==(const Flag& source) const { if(this == &source) return true; if(getFlag() != source.getFlag()) return false; return true; }
int main(int argc, const char *argv[]) { Flag flag; flag.addOption("h", "127.0.0.1", "server address"); flag.addOption("p", "10001", "server port"); flag.addOption("c", "1", "number of client to run"); if (!flag.parse(argc, argv)) { std::cout << flag.help() << std::endl; return -1; } std::string host; int port; int clientNum; flag.getString("h", host); flag.getInt("p", port); flag.getInt("c", clientNum); io_service ios; std::list<boost::shared_ptr<Client> > clients; boost::thread_group threads; // for (int i = 0; i < clientNum; ++i) // { // boost::shared_ptr<Client> c(new Client(ios, host, port)); // clients.push_back(c); // threads.create_thread(boost::bind(&Client::startConnect, c)); // } for (int i = 0; i < clientNum; ++i) { boost::shared_ptr<Client> c(new Client(ios, host, port)); clients.push_back(c); c->startConnect(); } int coreNum = boost::thread::hardware_concurrency(); for (int i = 0; i < coreNum; ++i) { threads.create_thread(boost::bind(&boost::asio::io_service::run, &ios)); } threads.join_all(); return 0; }
// Search the flag table for a named flag Flag* Flag::find_flag(const char* name, size_t length, bool allow_locked) { for (Flag* current = &flagTable[0]; current->name != NULL; current++) { if (str_equal(current->name, name, length)) { // Found a matching entry. Report locked flags only if allowed. if (!(current->is_unlocked() || current->is_unlocker())) { if (!allow_locked) { // disable use of locked flags, e.g. diagnostic, experimental, // commercial... until they are explicitly unlocked return NULL; } } return current; } } // Flag name is not in the flag table return NULL; }
void LazyObjectTest::testDiscardingNotifications() { BOOST_TEST_MESSAGE( "Testing that lazy object discards notifications after the first..."); boost::shared_ptr<SimpleQuote> q(new SimpleQuote(0.0)); boost::shared_ptr<Instrument> s(new Stock(Handle<Quote>(q))); Flag f; f.registerWith(s); s->NPV(); q->setValue(1.0); if (!f.isUp()) BOOST_FAIL("Observer was not notified of change"); f.lower(); q->setValue(2.0); if (f.isUp()) BOOST_FAIL("Observer was notified of second change"); f.lower(); s->NPV(); q->setValue(3.0); if (!f.isUp()) BOOST_FAIL("Observer was not notified of change after recalculation"); }
bool DataStore::doAppendItemsFlag(const PimItem::List &items, const Flag &flag, const QSet<Entity::Id> &existing, const Collection &col_, bool silent) { Collection col = col_; QVariantList flagIds; QVariantList appendIds; PimItem::List appendItems; Q_FOREACH (const PimItem &item, items) { if (existing.contains(item.id())) { continue; } flagIds << flag.id(); appendIds << item.id(); appendItems << item; if (col.id() == -1) { col.setId(item.collectionId()); } else if (col.id() != item.collectionId()) { col.setId(-2); } } if (appendItems.isEmpty()) { return true; // all items have the desired flags already } QueryBuilder qb2(PimItemFlagRelation::tableName(), QueryBuilder::Insert); qb2.setColumnValue(PimItemFlagRelation::leftColumn(), appendIds); qb2.setColumnValue(PimItemFlagRelation::rightColumn(), flagIds); qb2.setIdentificationColumn(QString()); if (!qb2.exec()) { qCDebug(AKONADISERVER_LOG) << "Failed to execute query:" << qb2.query().lastError(); return false; } if (!silent) { mNotificationCollector->itemsFlagsChanged(appendItems, QSet<QByteArray>() << flag.name().toLatin1(), QSet<QByteArray>(), col); } return true; }