int main(int argc, char** argv) { using namespace Sirikata; InitOptions(); Network::IOService* ios = new Network::IOService("Nameserver"); Network::IOStrand* mainStrand = ios->createStrand("CDN Nameserver Main"); delete mainStrand; delete ios; return 0; }
void setUp() { if (!_initialized) { _initialized = 1; _pmgr.load(_plugin); } // Storage is tied to the main event loop, which requires quite a bit of setup ObjectHostID oh_id(1); _trace = new Trace::Trace("dummy.trace"); _ios = new Network::IOService("StorageTest"); _mainStrand = _ios->createStrand("StorageTest"); _work = new Network::IOWork(*_ios, "StorageTest"); Time start_time = Timer::now(); // Just for stats in ObjectHostContext. Duration duration = Duration::zero(); // Indicates to run forever. _sstConnMgr = new ODPSST::ConnectionManager(); _ohSSTConnMgr = new OHDPSST::ConnectionManager(); _ctx = new ObjectHostContext("test", oh_id, _sstConnMgr, _ohSSTConnMgr, _ios, _mainStrand, _trace, start_time, duration); _storage = OH::StorageFactory::getSingleton().getConstructor(_type)(_ctx, _args); for(int i = 0; i < 2; i++) _storage->leaseBucket(_buckets[i]); _ctx->add(_ctx); _ctx->add(_storage); // Run the context, but we need to make sure it only lives in other // threads, otherwise we'd block up this one. We include 4 threads to // exercise support for multiple threads. _ctx->run(4, Context::AllNew); }
int main(int argc, char** argv) { using namespace Sirikata; InitOptions(); Trace::Trace::InitOptions(); OHTrace::InitOptions(); InitSimOHOptions(); ParseOptions(argc, argv); PluginManager plugins; plugins.loadList( GetOptionValue<String>(OPT_PLUGINS) ); plugins.loadList( GetOptionValue<String>(OPT_OH_PLUGINS) ); String trace_file = GetPerServerFile(STATS_OH_TRACE_FILE, 1); Trace::Trace* gTrace = new Trace::Trace(trace_file); BoundingBox3f region = GetOptionValue<BoundingBox3f>("region"); Duration duration = GetOptionValue<Duration>("duration"); // Get the starting time Time start_time = Timer::now(); srand( GetOptionValue<uint32>("rand-seed") ); Network::IOService* ios = Network::IOServiceFactory::makeIOService(); Network::IOStrand* mainStrand = ios->createStrand(); ObjectHostContext* ctx = new ObjectHostContext(ObjectHostID(1), ios, mainStrand, gTrace, start_time, duration); ObjectFactory* obj_factory = new ObjectFactory(ctx, region, duration); // Nothing actually runs here -- we only cared about getting the // object factory setup so it could dump the object pack data. gTrace->prepareShutdown(); delete obj_factory; delete ctx; gTrace->shutdown(); delete gTrace; gTrace = NULL; delete mainStrand; Network::IOServiceFactory::destroyIOService(ios); return 0; }
int main(int argc, char** argv) { using namespace Sirikata; DynamicLibrary::Initialize(); InitOptions(); Trace::Trace::InitOptions(); SpaceTrace::InitOptions(); InitSpaceOptions(); ParseOptions(argc, argv, OPT_CONFIG_FILE, AllowUnregisteredOptions); PluginManager plugins; plugins.loadList( GetOptionValue<String>(OPT_PLUGINS) ); plugins.loadList( GetOptionValue<String>(OPT_EXTRA_PLUGINS) ); plugins.loadList( GetOptionValue<String>(OPT_SPACE_PLUGINS) ); plugins.loadList( GetOptionValue<String>(OPT_SPACE_EXTRA_PLUGINS) ); // Fill defaults after plugin loading to ensure plugin-added // options get their defaults. FillMissingOptionDefaults(); // Rerun original parse to make sure any newly added options are // properly parsed. ParseOptions(argc, argv, OPT_CONFIG_FILE); DaemonizeAndSetOutputs(); ReportVersion(); // After options so log goes to the right place std::string time_server=GetOptionValue<String>("time-server"); NTPTimeSync sync; if (time_server.size() > 0) sync.start(time_server); ServerID server_id = GetOptionValue<ServerID>("id"); String trace_file = GetPerServerFile(STATS_TRACE_FILE, server_id); Sirikata::Trace::Trace* gTrace = new Trace::Trace(trace_file); // Compute the starting date/time String start_time_str = GetOptionValue<String>("wait-until"); Time start_time = start_time_str.empty() ? Timer::now() : Timer::getSpecifiedDate( start_time_str ); start_time += GetOptionValue<Duration>("wait-additional"); Duration duration = GetOptionValue<Duration>("duration"); Network::IOService* ios = new Network::IOService("Space"); Network::IOStrand* mainStrand = ios->createStrand("Space Main"); ODPSST::ConnectionManager* sstConnMgr = new ODPSST::ConnectionManager(); OHDPSST::ConnectionManager* ohSstConnMgr = new OHDPSST::ConnectionManager(); SpaceContext* space_context = new SpaceContext("space", server_id, sstConnMgr, ohSstConnMgr, ios, mainStrand, start_time, gTrace, duration); String servermap_type = GetOptionValue<String>("servermap"); String servermap_options = GetOptionValue<String>("servermap-options"); ServerIDMap * server_id_map = ServerIDMapFactory::getSingleton().getConstructor(servermap_type)(space_context, servermap_options); space_context->add(space_context); String timeseries_type = GetOptionValue<String>(OPT_TRACE_TIMESERIES); String timeseries_options = GetOptionValue<String>(OPT_TRACE_TIMESERIES_OPTIONS); Trace::TimeSeries* time_series = Trace::TimeSeriesFactory::getSingleton().getConstructor(timeseries_type)(space_context, timeseries_options); String commander_type = GetOptionValue<String>(OPT_COMMAND_COMMANDER); String commander_options = GetOptionValue<String>(OPT_COMMAND_COMMANDER_OPTIONS); Command::Commander* commander = NULL; if (!commander_type.empty()) commander = Command::CommanderFactory::getSingleton().getConstructor(commander_type)(space_context, commander_options); Transfer::TransferMediator::getSingleton().registerContext(space_context); Sirikata::SpaceNetwork* gNetwork = NULL; String network_type = GetOptionValue<String>(NETWORK_TYPE); if (network_type == "tcp") gNetwork = new TCPSpaceNetwork(space_context); BoundingBox3f region = GetOptionValue<BoundingBox3f>("region"); Vector3ui32 layout = GetOptionValue<Vector3ui32>("layout"); srand( GetOptionValue<uint32>("rand-seed") ); ObjectHostSessionManager* oh_sess_mgr = new ObjectHostSessionManager(space_context); ObjectSessionManager* obj_sess_mgr = new ObjectSessionManager(space_context); String auth_type = GetOptionValue<String>(SPACE_OPT_AUTH); String auth_opts = GetOptionValue<String>(SPACE_OPT_AUTH_OPTIONS); Authenticator* auth = AuthenticatorFactory::getSingleton().getConstructor(auth_type)(space_context, auth_opts); gNetwork->setServerIDMap(server_id_map); Forwarder* forwarder = new Forwarder(space_context); String cseg_type = GetOptionValue<String>(CSEG); CoordinateSegmentation* cseg = NULL; if (cseg_type == "uniform") cseg = new UniformCoordinateSegmentation(space_context, region, layout); else if (cseg_type == "client") { cseg = new CoordinateSegmentationClient(space_context, region, layout, server_id_map); } else { assert(false); exit(-1); } String loc_update_type = GetOptionValue<String>(LOC_UPDATE); String loc_update_opts = GetOptionValue<String>(LOC_UPDATE_OPTIONS); LocationUpdatePolicy* loc_update_policy = LocationUpdatePolicyFactory::getSingleton().getConstructor(loc_update_type)(space_context, loc_update_opts); String loc_service_type = GetOptionValue<String>(LOC); String loc_service_opts = GetOptionValue<String>(LOC_OPTIONS); LocationService* loc_service = LocationServiceFactory::getSingleton().getConstructor(loc_service_type)(space_context, loc_update_policy, loc_service_opts); ServerMessageQueue* sq = NULL; String server_queue_type = GetOptionValue<String>(SERVER_QUEUE); if (server_queue_type == "fair") { sq = new FairServerMessageQueue( space_context, gNetwork, (ServerMessageQueue::Sender*)forwarder); } else { assert(false); exit(-1); } ServerMessageReceiver* server_message_receiver = NULL; String server_receiver_type = GetOptionValue<String>(SERVER_RECEIVER); if (server_queue_type == "fair") server_message_receiver = new FairServerMessageReceiver(space_context, gNetwork, (ServerMessageReceiver::Listener*)forwarder); else { assert(false); exit(-1); } LoadMonitor* loadMonitor = new LoadMonitor(space_context, cseg); // OSeg Cache OSegCache* oseg_cache = NULL; std::string cacheSelector = GetOptionValue<String>(CACHE_SELECTOR); uint32 cacheSize = GetOptionValue<uint32>(OSEG_CACHE_SIZE); if (cacheSelector == CACHE_TYPE_COMMUNICATION) { double cacheCommScaling = GetOptionValue<double>(CACHE_COMM_SCALING); oseg_cache = new CommunicationCache(space_context, cacheCommScaling, cseg, cacheSize); } else if (cacheSelector == CACHE_TYPE_ORIGINAL_LRU) { uint32 cacheCleanGroupSize = GetOptionValue<uint32>(OSEG_CACHE_CLEAN_GROUP_SIZE); Duration entryLifetime = GetOptionValue<Duration>(OSEG_CACHE_ENTRY_LIFETIME); oseg_cache = new CacheLRUOriginal(space_context, cacheSize, cacheCleanGroupSize, entryLifetime); } else { std::cout<<"\n\nUNKNOWN CACHE TYPE SELECTED. Please re-try.\n\n"; std::cout.flush(); assert(false); } //Create OSeg std::string oseg_type = GetOptionValue<String>(OSEG); std::string oseg_options = GetOptionValue<String>(OSEG_OPTIONS); Network::IOStrand* osegStrand = space_context->ioService->createStrand("OSeg"); ObjectSegmentation* oseg = OSegFactory::getSingleton().getConstructor(oseg_type)(space_context, osegStrand, cseg, oseg_cache, oseg_options); //end create oseg // We have all the info to initialize the forwarder now forwarder->initialize(oseg, sq, server_message_receiver, loc_service); String aggmgr_hostname = GetOptionValue<String>(OPT_AGGMGR_HOSTNAME); String aggmgr_service = GetOptionValue<String>(OPT_AGGMGR_SERVICE); String aggmgr_consumer_key = GetOptionValue<String>(OPT_AGGMGR_CONSUMER_KEY); String aggmgr_consumer_secret = GetOptionValue<String>(OPT_AGGMGR_CONSUMER_SECRET); String aggmgr_access_key = GetOptionValue<String>(OPT_AGGMGR_ACCESS_KEY); String aggmgr_access_secret = GetOptionValue<String>(OPT_AGGMGR_ACCESS_SECRET); String aggmgr_username = GetOptionValue<String>(OPT_AGGMGR_USERNAME); Transfer::OAuthParamsPtr aggmgr_oauth; // Currently you need to explicitly override hostname to enable upload if (!aggmgr_hostname.empty()&& !aggmgr_consumer_key.empty() && !aggmgr_consumer_secret.empty() && !aggmgr_access_key.empty() && !aggmgr_access_secret.empty()) { aggmgr_oauth = Transfer::OAuthParamsPtr( new Transfer::OAuthParams( aggmgr_hostname, aggmgr_service, aggmgr_consumer_key, aggmgr_consumer_secret, aggmgr_access_key, aggmgr_access_secret ) ); } std::string aggmgr_type = GetOptionValue<String>(OPT_AGGMGR); AggregateManager* aggmgr = AggregateManagerFactory::getSingleton().getConstructor(aggmgr_type)(loc_service, aggmgr_oauth, aggmgr_username); std::string prox_type = GetOptionValue<String>(OPT_PROX); std::string prox_options = GetOptionValue<String>(OPT_PROX_OPTIONS); Proximity* prox = ProximityFactory::getSingleton().getConstructor(prox_type)(space_context, loc_service, cseg, gNetwork, aggmgr, prox_options); // We need to do an async lookup, and to finish it the server needs to be // running. But we can't create the server until we have the address from // this lookup. We isolate as little as possible into this callback -- // creating the server, finishing prox initialization, and getting them both // registered. We pass storage for the Server to the callback so we can // handle cleaning it up ourselves. using std::tr1::placeholders::_1; using std::tr1::placeholders::_2; Server* server = NULL; ModuleList modules; ServerData sd; sd.space_context = space_context; sd.auth = auth; sd.forwarder = forwarder; sd.loc_service = loc_service; sd.cseg = cseg; sd.prox = prox; sd.oseg = oseg; sd.oh_sess_mgr = oh_sess_mgr; sd.obj_sess_mgr = obj_sess_mgr; server_id_map->lookupExternal( space_context->id(), space_context->mainStrand->wrap( std::tr1::bind( &createServer, &server, &modules, sd, _1, _2) ) ); // If we're one of the initial nodes, we'll have to wait until we hit the start time { Time now_time = Timer::now(); if (start_time > now_time) { Duration sleep_time = start_time - now_time; printf("Waiting %f seconds\n", sleep_time.toSeconds() ); fflush(stdout); Timer::sleep(sleep_time); } } ///////////Go go go!! start of simulation///////////////////// space_context->add(auth); space_context->add(gNetwork); space_context->add(cseg); space_context->add(loc_service); space_context->add(oseg); space_context->add(loadMonitor); space_context->add(sstConnMgr); space_context->add(ohSstConnMgr); space_context->add(prox); space_context->run(3); space_context->cleanup(); if (GetOptionValue<bool>(PROFILE)) { space_context->profiler->report(); } gTrace->prepareShutdown(); Mesh::FilterFactory::destroy(); ModelsSystemFactory::destroy(); LocationServiceFactory::destroy(); LocationUpdatePolicyFactory::destroy(); for(ModuleList::iterator it = modules.begin(); it != modules.end(); it++) delete *it; modules.clear(); delete server; delete sq; delete server_message_receiver; delete prox; delete aggmgr; delete server_id_map; delete loadMonitor; delete cseg; delete oseg; delete oseg_cache; delete loc_service; delete forwarder; delete obj_sess_mgr; delete oh_sess_mgr; delete gNetwork; gNetwork=NULL; gTrace->shutdown(); delete gTrace; gTrace = NULL; delete commander; delete space_context; space_context = NULL; delete time_series; delete mainStrand; delete osegStrand; delete ios; delete sstConnMgr; delete ohSstConnMgr; Transfer::TransferMediator::destroy(); sync.stop(); plugins.gc(); Sirikata::Logging::finishLog(); DaemonCleanup(); return 0; }
int main(int argc, char** argv) { using namespace Sirikata; DynamicLibrary::Initialize(); InitOptions(); Trace::Trace::InitOptions(); OHTrace::InitOptions(); InitSimOHOptions(); ParseOptions(argc, argv); PluginManager plugins; plugins.loadList( GetOptionValue<String>(OPT_PLUGINS) ); plugins.loadList( GetOptionValue<String>(OPT_OH_PLUGINS) ); // Fill defaults after plugin loading to ensure plugin-added // options get their defaults. FillMissingOptionDefaults(); // Rerun original parse to make sure any newly added options are // properly parsed. ParseOptions(argc, argv); ReportVersion(); // After options so log goes to the right place std::string time_server=GetOptionValue<String>("time-server"); NTPTimeSync sync; if (time_server.size() > 0) sync.start(time_server); ObjectHostID oh_id = GetOptionValue<ObjectHostID>("ohid"); String trace_file = GetPerServerFile(STATS_OH_TRACE_FILE, oh_id); Trace::Trace* gTrace = new Trace::Trace(trace_file); MaxDistUpdatePredicate::maxDist = GetOptionValue<float64>(MAX_EXTRAPOLATOR_DIST); BoundingBox3f region = GetOptionValue<BoundingBox3f>("region"); Vector3ui32 layout = GetOptionValue<Vector3ui32>("layout"); Duration duration = GetOptionValue<Duration>("duration"); // Get the starting time String start_time_str = GetOptionValue<String>("wait-until"); Time start_time = start_time_str.empty() ? Timer::now() : Timer::getSpecifiedDate( start_time_str ); start_time += GetOptionValue<Duration>("wait-additional"); srand( GetOptionValue<uint32>("rand-seed") ); Network::IOService* ios = Network::IOServiceFactory::makeIOService(); Network::IOStrand* mainStrand = ios->createStrand(); ODPSST::ConnectionManager* sstConnMgr = new ODPSST::ConnectionManager(); OHDPSST::ConnectionManager* ohSSTConnMgr = new OHDPSST::ConnectionManager(); ObjectHostContext* ctx = new ObjectHostContext("simoh", oh_id, sstConnMgr, ohSSTConnMgr, ios, mainStrand, gTrace, start_time, duration); String servermap_type = GetOptionValue<String>("servermap"); String servermap_options = GetOptionValue<String>("servermap-options"); ServerIDMap * server_id_map = ServerIDMapFactory::getSingleton().getConstructor(servermap_type)(ctx, servermap_options); String timeseries_type = GetOptionValue<String>(OPT_TRACE_TIMESERIES); String timeseries_options = GetOptionValue<String>(OPT_TRACE_TIMESERIES_OPTIONS); Trace::TimeSeries* time_series = Trace::TimeSeriesFactory::getSingleton().getConstructor(timeseries_type)(ctx, timeseries_options); ObjectFactory* obj_factory = new ObjectFactory(ctx, region, duration); ObjectHost* obj_host = new ObjectHost(ctx, gTrace, server_id_map); Scenario* scenario = ScenarioFactory::getSingleton().getConstructor(GetOptionValue<String>("scenario"))(GetOptionValue<String>("scenario-options")); // If we're one of the initial nodes, we'll have to wait until we hit the start time { Time now_time = Timer::now(); if (start_time > now_time) { Duration sleep_time = start_time - now_time; printf("Waiting %f seconds\n", sleep_time.toSeconds() ); fflush(stdout); #if SIRIKATA_PLATFORM == SIRIKATA_WINDOWS Sleep( sleep_time.toMilliseconds() ); #else usleep( sleep_time.toMicroseconds() ); #endif } } ///////////Go go go!! start of simulation///////////////////// ctx->add(ctx); ctx->add(obj_factory); scenario->initialize(ctx); ctx->add(scenario); ctx->add(sstConnMgr); ctx->add(ohSSTConnMgr); ctx->run(2); ctx->cleanup(); if (GetOptionValue<bool>(PROFILE)) { ctx->profiler->report(); } gTrace->prepareShutdown(); delete server_id_map; delete obj_factory; delete scenario; delete obj_host; delete ctx; delete sstConnMgr; delete ohSSTConnMgr; delete time_series; gTrace->shutdown(); delete gTrace; gTrace = NULL; delete mainStrand; Network::IOServiceFactory::destroyIOService(ios); sync.stop(); Sirikata::Logging::finishLog(); return 0; }
int main (int argc, char** argv) { using namespace Sirikata; DynamicLibrary::Initialize(); InitOptions(); Trace::Trace::InitOptions(); OHTrace::InitOptions(); InitCPPOHOptions(); ParseOptions(argc, argv, OPT_CONFIG_FILE, AllowUnregisteredOptions); PluginManager plugins; String search_path=GetOptionValue<String>(OPT_OH_PLUGIN_SEARCH_PATHS); if (search_path.length()) { while (true) { String::size_type where=search_path.find(":"); if (where==String::npos) { DynamicLibrary::AddLoadPath(search_path); break; }else { DynamicLibrary::AddLoadPath(search_path.substr(0,where)); search_path=search_path.substr(where+1); } } } plugins.loadList( GetOptionValue<String>(OPT_PLUGINS) ); plugins.loadList( GetOptionValue<String>(OPT_EXTRA_PLUGINS) ); plugins.loadList( GetOptionValue<String>(OPT_OH_PLUGINS) ); plugins.loadList( GetOptionValue<String>(OPT_OH_EXTRA_PLUGINS) ); // Fill defaults after plugin loading to ensure plugin-added // options get their defaults. FillMissingOptionDefaults(); // Rerun original parse to make sure any newly added options are // properly parsed. ParseOptions(argc, argv, OPT_CONFIG_FILE); DaemonizeAndSetOutputs(); ReportVersion(); // After options so log goes to the right place String time_server = GetOptionValue<String>("time-server"); NTPTimeSync sync; if (time_server.size() > 0) sync.start(time_server); #ifdef __GNUC__ #ifndef __APPLE__ if (GetOptionValue<bool>(OPT_SIGFPE)) { feenableexcept(FE_DIVBYZERO|FE_INVALID|FE_OVERFLOW|FE_UNDERFLOW); } #endif #endif ObjectHostID oh_id = GetOptionValue<ObjectHostID>("ohid"); String trace_file = GetPerServerFile(STATS_OH_TRACE_FILE, oh_id); Trace::Trace* trace = new Trace::Trace(trace_file); srand( GetOptionValue<uint32>("rand-seed") ); Network::IOService* ios = new Network::IOService("Object Host"); Network::IOStrand* mainStrand = ios->createStrand("Object Host Main"); ODPSST::ConnectionManager* sstConnMgr = new ODPSST::ConnectionManager(); OHDPSST::ConnectionManager* ohSstConnMgr = new OHDPSST::ConnectionManager(); Time start_time = Timer::now(); // Just for stats in ObjectHostContext. Duration duration = Duration::zero(); // Indicates to run forever. ObjectHostContext* ctx = new ObjectHostContext("cppoh", oh_id, sstConnMgr, ohSstConnMgr, ios, mainStrand, trace, start_time, duration); String servermap_type = GetOptionValue<String>("servermap"); String servermap_options = GetOptionValue<String>("servermap-options"); ServerIDMap * server_id_map = ServerIDMapFactory::getSingleton().getConstructor(servermap_type)(ctx, servermap_options); String timeseries_type = GetOptionValue<String>(OPT_TRACE_TIMESERIES); String timeseries_options = GetOptionValue<String>(OPT_TRACE_TIMESERIES_OPTIONS); Trace::TimeSeries* time_series = Trace::TimeSeriesFactory::getSingleton().getConstructor(timeseries_type)(ctx, timeseries_options); String commander_type = GetOptionValue<String>(OPT_COMMAND_COMMANDER); String commander_options = GetOptionValue<String>(OPT_COMMAND_COMMANDER_OPTIONS); Command::Commander* commander = NULL; if (!commander_type.empty()) commander = Command::CommanderFactory::getSingleton().getConstructor(commander_type)(ctx, commander_options); Transfer::TransferMediator::getSingleton().registerContext(ctx); SpaceID mainSpace(GetOptionValue<UUID>(OPT_MAIN_SPACE)); String oh_options = GetOptionValue<String>(OPT_OH_OPTIONS); ObjectHost *oh = new CppohObjectHost(ctx, ios, oh_options); // Add all the spaces to the ObjectHost. We used to have SpaceIDMap and // fill in the same ServerIDMap for all these. Now we just add the // ServerIDMap for the main space. We need a better way of handling multiple // spaces. oh->addServerIDMap(mainSpace, server_id_map); String objstorage_type = GetOptionValue<String>(OPT_OBJECT_STORAGE); String objstorage_options = GetOptionValue<String>(OPT_OBJECT_STORAGE_OPTS); OH::Storage* obj_storage = OH::StorageFactory::getSingleton().getConstructor(objstorage_type)(ctx, objstorage_options); oh->setStorage(obj_storage); String objpersistentset_type = GetOptionValue<String>(OPT_OH_PERSISTENT_SET); String objpersistentset_options = GetOptionValue<String>(OPT_OH_PERSISTENT_SET_OPTS); OH::PersistedObjectSet* obj_persistent_set = OH::PersistedObjectSetFactory::getSingleton().getConstructor(objpersistentset_type)(ctx, objpersistentset_options); oh->setPersistentSet(obj_persistent_set); String objfactory_type = GetOptionValue<String>(OPT_OBJECT_FACTORY); String objfactory_options = GetOptionValue<String>(OPT_OBJECT_FACTORY_OPTS); ObjectFactory* obj_factory = NULL; String obj_query_type = GetOptionValue<String>(OPT_OBJECT_QUERY_PROCESSOR); String obj_query_options = GetOptionValue<String>(OPT_OBJECT_QUERY_PROCESSOR_OPTS); OH::ObjectQueryProcessor* obj_query_processor = OH::ObjectQueryProcessorFactory::getSingleton().getConstructor(obj_query_type)(ctx, obj_query_options); oh->setQueryProcessor(obj_query_processor); String query_data_type = GetOptionValue<String>(OPT_OBJECT_QUERY_DATA); String query_data_type_opts = GetOptionValue<String>(OPT_OBJECT_QUERY_DATA_OPTS); if (query_data_type != "") { assert(QueryDataLookupFactory::getSingleton().hasConstructor(query_data_type)); oh->setQueryDataLookupConstructor(QueryDataLookupFactory::getSingleton().getConstructor(query_data_type), query_data_type_opts); } ///////////Go go go!! start of simulation///////////////////// ctx->add(ctx); ctx->add(obj_storage); ctx->add(obj_persistent_set); ctx->add(obj_query_processor); ctx->add(oh); ctx->add(sstConnMgr); ctx->add(ohSstConnMgr); if (!objfactory_type.empty()) { obj_factory = ObjectFactoryFactory::getSingleton().getConstructor(objfactory_type)(ctx, oh, mainSpace, objfactory_options); obj_factory->generate(); } ctx->run(1); ctx->cleanup(); if (GetOptionValue<bool>(PROFILE)) { ctx->profiler->report(); } trace->prepareShutdown(); Mesh::FilterFactory::destroy(); ModelsSystemFactory::destroy(); ObjectScriptManagerFactory::destroy(); delete oh; delete obj_storage; delete obj_persistent_set; SimulationFactory::destroy(); delete commander; delete ctx; delete time_series; trace->shutdown(); delete trace; trace = NULL; delete mainStrand; delete ios; delete sstConnMgr; delete ohSstConnMgr; Transfer::TransferMediator::destroy(); plugins.gc(); sync.stop(); Sirikata::Logging::finishLog(); DaemonCleanup(); return 0; }
int main(int argc, char** argv) { using namespace Sirikata; DynamicLibrary::Initialize(); InitOptions(); Trace::Trace::InitOptions(); InitCSegOptions(); ParseOptions(argc, argv); PluginManager plugins; plugins.loadList( GetOptionValue<String>(OPT_PLUGINS)); plugins.loadList( GetOptionValue<String>(OPT_EXTRA_PLUGINS) ); plugins.loadList( GetOptionValue<String>(OPT_CSEG_PLUGINS)); // Fill defaults after plugin loading to ensure plugin-added // options get their defaults. FillMissingOptionDefaults(); // Rerun original parse to make sure any newly added options are // properly parsed. ParseOptions(argc, argv); ReportVersion(); // After options so log goes to the right place ServerID server_id = GetOptionValue<ServerID>("cseg-id"); String trace_file = GetPerServerFile(STATS_TRACE_FILE, server_id); Trace::Trace* trace = new Trace::Trace(trace_file); // Compute the starting date/time String start_time_str = GetOptionValue<String>("wait-until"); Time start_time = start_time_str.empty() ? Timer::now() : Timer::getSpecifiedDate( start_time_str ); Duration duration = GetOptionValue<Duration>("duration") + GetOptionValue<Duration>("additional-cseg-duration") + GetOptionValue<Duration>("wait-additional"); Network::IOService* ios = new Network::IOService("CSeg"); Network::IOStrand* mainStrand = ios->createStrand("CSeg Main"); CSegContext* cseg_context = new CSegContext(server_id, ios, mainStrand, trace, start_time, duration); String timeseries_type = GetOptionValue<String>(OPT_TRACE_TIMESERIES); String timeseries_options = GetOptionValue<String>(OPT_TRACE_TIMESERIES_OPTIONS); Trace::TimeSeries* time_series = Trace::TimeSeriesFactory::getSingleton().getConstructor(timeseries_type)(cseg_context, timeseries_options); BoundingBox3f region = GetOptionValue<BoundingBox3f>("region"); Vector3ui32 layout = GetOptionValue<Vector3ui32>("layout"); uint32 max_space_servers = GetOptionValue<uint32>("max-servers"); if (max_space_servers == 0) max_space_servers = layout.x * layout.y * layout.z; srand( GetOptionValue<uint32>("rand-seed") ); String servermap_type = GetOptionValue<String>("servermap"); String servermap_options = GetOptionValue<String>("cseg-servermap-options"); ServerIDMap * server_id_map = ServerIDMapFactory::getSingleton().getConstructor(servermap_type)(cseg_context, servermap_options); DistributedCoordinateSegmentation* cseg = new DistributedCoordinateSegmentation(cseg_context, region, layout, max_space_servers, server_id_map); ///////////Go go go!! start of simulation///////////////////// srand(time(NULL)); cseg_context->add(cseg_context); cseg_context->add(cseg); cseg_context->run(2); std::cout << "CSEG cleaning up\n"; fflush(stdout); cseg_context->cleanup(); if (GetOptionValue<bool>(PROFILE)) { cseg_context->profiler->report(); } trace->prepareShutdown(); delete cseg; trace->shutdown(); delete trace; trace = NULL; delete cseg_context; cseg_context = NULL; delete time_series; delete mainStrand; delete ios; plugins.gc(); Sirikata::Logging::finishLog(); return 0; }
int main (int argc, char** argv) { using namespace Sirikata; DynamicLibrary::Initialize(); InitOptions(); Trace::Trace::InitOptions(); OHTrace::InitOptions(); InitCPPOHOptions(); ParseOptions(argc, argv, OPT_CONFIG_FILE); PluginManager plugins; String search_path=GetOptionValue<String>(OPT_OH_PLUGIN_SEARCH_PATHS); if (search_path.length()) { while (true) { String::size_type where=search_path.find(":"); if (where==String::npos) { DynamicLibrary::AddLoadPath(search_path); break; }else { DynamicLibrary::AddLoadPath(search_path.substr(0,where)); search_path=search_path.substr(where+1); } } } plugins.loadList( GetOptionValue<String>(OPT_PLUGINS) ); plugins.loadList( GetOptionValue<String>(OPT_OH_PLUGINS) ); String time_server = GetOptionValue<String>("time-server"); NTPTimeSync sync; if (time_server.size() > 0) sync.start(time_server); #ifdef __GNUC__ #ifndef __APPLE__ if (GetOptionValue<bool>(OPT_SIGFPE)) { feenableexcept(FE_DIVBYZERO|FE_INVALID|FE_OVERFLOW|FE_UNDERFLOW); } #endif #endif ObjectHostID oh_id = GetOptionValue<ObjectHostID>("ohid"); String trace_file = GetPerServerFile(STATS_OH_TRACE_FILE, oh_id); Trace::Trace* trace = new Trace::Trace(trace_file); String servermap_type = GetOptionValue<String>("servermap"); String servermap_options = GetOptionValue<String>("servermap-options"); ServerIDMap * server_id_map = ServerIDMapFactory::getSingleton().getConstructor(servermap_type)(servermap_options); srand( GetOptionValue<uint32>("rand-seed") ); Network::IOService* ios = Network::IOServiceFactory::makeIOService(); Network::IOStrand* mainStrand = ios->createStrand(); Time start_time = Timer::now(); // Just for stats in ObjectHostContext. Duration duration = Duration::zero(); // Indicates to run forever. ObjectHostContext* ctx = new ObjectHostContext(oh_id, ios, mainStrand, trace, start_time, duration); Context::mainContextPtr = ctx; String timeseries_type = GetOptionValue<String>(OPT_TRACE_TIMESERIES); String timeseries_options = GetOptionValue<String>(OPT_TRACE_TIMESERIES_OPTIONS); Trace::TimeSeries* time_series = Trace::TimeSeriesFactory::getSingleton().getConstructor(timeseries_type)(ctx, timeseries_options); SSTConnectionManager* sstConnMgr = new SSTConnectionManager(); SpaceID mainSpace(GetOptionValue<UUID>(OPT_MAIN_SPACE)); String oh_options = GetOptionValue<String>(OPT_OH_OPTIONS); ObjectHost *oh = new CppohObjectHost(ctx, ios, oh_options); // Add all the spaces to the ObjectHost. We used to have SpaceIDMap and // fill in the same ServerIDMap for all these. Now we just add the // ServerIDMap for the main space. We need a better way of handling multiple // spaces. oh->addServerIDMap(mainSpace, server_id_map); String objstorage_type = GetOptionValue<String>(OPT_OBJECT_STORAGE); String objstorage_options = GetOptionValue<String>(OPT_OBJECT_STORAGE_OPTS); OH::Storage* obj_storage = OH::StorageFactory::getSingleton().getConstructor(objstorage_type)(ctx, objstorage_options); oh->setStorage(obj_storage); String objpersistentset_type = GetOptionValue<String>(OPT_OH_PERSISTENT_SET); String objpersistentset_options = GetOptionValue<String>(OPT_OH_PERSISTENT_SET_OPTS); OH::PersistedObjectSet* obj_persistent_set = OH::PersistedObjectSetFactory::getSingleton().getConstructor(objpersistentset_type)(ctx, objpersistentset_options); oh->setPersistentSet(obj_persistent_set); String objfactory_type = GetOptionValue<String>(OPT_OBJECT_FACTORY); String objfactory_options = GetOptionValue<String>(OPT_OBJECT_FACTORY_OPTS); ObjectFactory* obj_factory = NULL; ///////////Go go go!! start of simulation///////////////////// ctx->add(ctx); ctx->add(obj_storage); ctx->add(obj_persistent_set); ctx->add(oh); ctx->add(sstConnMgr); if (!objfactory_type.empty()) { obj_factory = ObjectFactoryFactory::getSingleton().getConstructor(objfactory_type)(ctx, oh, mainSpace, objfactory_options); obj_factory->generate(); } ctx->run(1); ctx->cleanup(); trace->prepareShutdown(); delete oh; //delete pd; delete obj_storage; delete obj_persistent_set; SimulationFactory::destroy(); delete sstConnMgr; delete ctx; delete time_series; trace->shutdown(); delete trace; trace = NULL; delete mainStrand; Network::IOServiceFactory::destroyIOService(ios); plugins.gc(); sync.stop(); return 0; }
int main(int argc, char** argv) { InitOptions(); InitializeClassOptions::module(SIRIKATA_OPTIONS_MODULE) .addOption(new OptionValue("mesh","",Sirikata::OptionValueType<String>(),"Mesh to load and display.")) .addOption(new OptionValue("screenshot","",Sirikata::OptionValueType<String>(),"If non-empty, trigger a screenshot to the given filename and exit.")) ; ParseOptions(argc, argv, AllowUnregisteredOptions); PluginManager plugins; plugins.loadList( GetOptionValue<String>(OPT_PLUGINS) ); plugins.loadList( GetOptionValue<String>(OPT_EXTRA_PLUGINS) ); // FIXME this should be an option plugins.loadList( "colladamodels,mesh-billboard,mesh-ply,common-filters,nvtt" ); // Fill defaults after plugin loading to ensure plugin-added // options get their defaults. FillMissingOptionDefaults(); // Rerun original parse to make sure any newly added options are // properly parsed. ParseOptions(argc, argv); DaemonizeAndSetOutputs(); ReportVersion(); // After options so log goes to the right place Network::IOService* ios = new Network::IOService("MeshView"); Network::IOStrand* iostrand = ios->createStrand("MeshView Main"); Trace::Trace* trace = new Trace::Trace("meshview.log"); Time epoch = Timer::now(); Context* ctx = new Context("MeshView", ios, iostrand, trace, epoch); OgreRenderer* renderer = new OgreRenderer(ctx,Network::IOStrandPtr(ios->createStrand("OgreRenderer"))); renderer->initialize("", false); MeshViewCamera* cam = new MeshViewCamera(renderer); cam->attach("", 0, 0, Vector4f(.7,.7,.7,1), 0); cam->setPosition(Vector3d(0, 0, 2)); MeshViewEntity* ent = new MeshViewEntity(renderer, GetOptionValue<String>("screenshot")); ent->setOgrePosition(Vector3d(0, 0, 0)); ent->setOgreOrientation(Quaternion::identity()); renderer->addObject(ent, Transfer::URI(GetOptionValue<String>("mesh"))); ctx->add(ctx); ctx->add(renderer); ctx->run(1); delete ent; delete cam; delete renderer; ctx->cleanup(); trace->prepareShutdown(); delete ctx; trace->shutdown(); delete trace; delete iostrand; delete ios; Transfer::TransferMediator::destroy(); plugins.gc(); Sirikata::Logging::finishLog(); DaemonCleanup(); return 0; }
int main(int argc, char** argv) { using namespace Sirikata; DynamicLibrary::Initialize(); InitOptions(); Trace::Trace::InitOptions(); InitPintoOptions(); ParseOptions(argc, argv); PluginManager plugins; plugins.loadList( GetOptionValue<String>(OPT_PLUGINS)); plugins.loadList( GetOptionValue<String>(OPT_PINTO_PLUGINS)); // Currently not distributed, so we just use any ID String trace_file = GetPerServerFile(STATS_TRACE_FILE, (ServerID)0); Trace::Trace* trace = new Trace::Trace(trace_file); // Compute the starting date/time String start_time_str = GetOptionValue<String>("wait-until"); Time start_time = start_time_str.empty() ? Timer::now() : Timer::getSpecifiedDate( start_time_str ); Duration duration = GetOptionValue<Duration>("duration") + GetOptionValue<Duration>("wait-additional"); Network::IOService* ios = Network::IOServiceFactory::makeIOService(); Network::IOStrand* mainStrand = ios->createStrand(); PintoContext* pinto_context = new PintoContext(ios, mainStrand, trace, start_time, duration); PintoManager* pinto = new PintoManager(pinto_context); srand( GetOptionValue<uint32>("rand-seed") ); ///////////Go go go!! start of simulation///////////////////// srand(time(NULL)); pinto_context->add(pinto_context); pinto_context->add(pinto); pinto_context->run(1); pinto_context->cleanup(); if (GetOptionValue<bool>(PROFILE)) { pinto_context->profiler->report(); } trace->prepareShutdown(); delete pinto; trace->shutdown(); delete trace; trace = NULL; delete pinto_context; pinto_context = NULL; delete mainStrand; Network::IOServiceFactory::destroyIOService(ios); plugins.gc(); return 0; }