int main(int argc, char* argv[])
{
argc -= handleOpts(argc, argv);
if (argc < 2){
fprintf(stderr, usage, argv[0]);
exit(1);
}
optClientno = atoi(argv[optind+1]);
ConfigParser cp(argv[optind]);
cp.Parse();
bool load_complete = false;
for (auto& section : cp._section_names){
if (section.find("Workload") != std::string::npos){
std::string workload = section;
Config cfg(&cp, workload);
// SYSTEM-SPECIFIC
std::string system_conf = cfg.get<std::string>("yesql", "");
std::string dir = cfg.get<std::string>("logdir", ".");
LOG("Got %s as logdir", dir.c_str());
if (dir.back() != '/')
dir.append("/");
dir.append("client-");
dir.append(std::to_string(optClientno));
dir.append("-");
dir.append(workload);
dir.append(".txt");
LOG("Setting log as %s\n", dir.c_str());
SetLog(dir.c_str());
LOG("About to initialize\n");
if (!load_complete){
sqlite3_initialize();
// FIXME SetDebugLevel(0);
} else {
// FIXME SetDebugLevel(0);
}
int nthreads = cfg.get<int>("threads", 1);
bool do_load = false;
if (!load_complete)
do_load = cfg.get<bool>("load", true);
LOG("About to do a yesql experiment with %d threads\n", nthreads);
do_experiment(nthreads, system_conf.c_str(), &cfg, do_load);
load_complete = true;
}
}
return 0;
}
int main(int argc, char* argv[])
{
argc -= handleOpts(argc, argv);
if (argc < 2){
fprintf(stderr, "Usage: %s [config.ini]\n", argv[0]);
exit(1);
}
optClientno = atoi(argv[optind+1]);
ConfigParser cp(argv[optind]);
cp.Parse();
for (auto& section : cp._sections){
if (section.first.find("Workload") != std::string::npos){
std::string workload = section.first;
Config cfg(&cp, workload);
// SYSTEM-SPECIFIC
std::string system_conf;
if (!optServerPort) system_conf = cfg.get<std::string>("yesql", "");
else system_conf = std::string(optServerPort);
std::string dir = cfg.get<std::string>("logdir", ".");
if (dir.back() != '/')
dir.append("/");
dir.append("client-");
dir.append(std::to_string(optClientno));
dir.append("-");
dir.append(workload);
dir.append(".txt");
SetLog(dir.c_str());
LOG("Starting a YESQL expt.\n");
int nthreads = cfg.get<int>("threads", 1);
do_experiment(nthreads, system_conf.c_str(), &cfg, false);
}
}
return 0;
}
void IntegratorRep::initialize(const State& initState) {
try
{ invalidateIntegratorInternalState();
// Copy the supplied initial state into the integrator.
updAdvancedState() = initState;
// Freeze the number and kinds of state variables.
getSystem().realizeModel(updAdvancedState());
// Freeze problem dimensions; at this point the state represents an
// instance of a physically realizable system.
getSystem().realize(getAdvancedState(), Stage::Instance);
// Some Systems need to get control whenever time is advanced
// successfully (and irreversibly) so that they can do discrete updates.
systemHasTimeAdvancedEvents = getSystem().hasTimeAdvancedEvents();
// Allocate integrator-local data structures now that we know the sizes.
const int ny = getAdvancedState().getNY();
const int nc = getAdvancedState().getNYErr();
const int ne = getAdvancedState().getNEventTriggers();
timeScaleInUse = getSystem().getDefaultTimeScale();
// Set accuracy and consTol to their user-requested values or
// to the appropriate defaults.
setAccuracyAndTolerancesFromUserRequests();
// Now we can ask the System for information about its event triggers.
// (Event trigger info is Instance stage information.) Note that the event
// localization windows here are expressed in terms of the system timescale
// -- be sure to multiply by timescale before using.
getSystem().calcEventTriggerInfo(getAdvancedState(), eventTriggerInfo);
// Realize Time stage, apply prescribed motions, and attempt to project q's
// and u's onto the
// position and velocity constraint manifolds to drive constraint errors
// below accuracy*unitTolerance for each constraint. We'll allow project()
// to throw an exception if it fails since we can't recover from here.
// However, we won't set the LocalOnly option which means project() is
// allowed to thrash around wildly to attempt to find *some* solution.
// Also force repeated updates of iteration matrix to maximize chances of
// finding a solution; we're not in a hurry here.
realizeAndProjectKinematicsWithThrow(updAdvancedState(),
ProjectOptions::ForceProjection, ProjectOptions::ForceFullNewton);
// Inform any state-using System elements (especially Measures) that we
// are starting a simulation and give them a chance to initialize their own
// continuous (z) variables and discrete variables.
// Handler is allowed to throw an exception if it fails since we don't
// have a way to recover.
HandleEventsOptions handleOpts(getConstraintToleranceInUse());
HandleEventsResults results;
getSystem().handleEvents(updAdvancedState(),
Event::Cause::Initialization,
Array_<EventId>(),
handleOpts, results);
SimTK_ERRCHK_ALWAYS(
results.getExitStatus()!=HandleEventsResults::ShouldTerminate,
"Integrator::initialize()",
"An initialization event handler requested termination.");
// Now evaluate the state through the Acceleration stage to calculate
// the initial state derivatives.
realizeStateDerivatives(getAdvancedState());
// Now that we have valid update values for auto-update discrete variables,
// use them to reinitialize the discrete state variables. This one time
// only, the value swapped in from the discrete variable here is not yet
// suitable for use as an update value, during time integration since it
// has never been realized to Instance stage. So we'll force a
// re-evaluation.
updAdvancedState().autoUpdateDiscreteVariables();
getAdvancedState().invalidateAllCacheAtOrAbove(Stage::Instance);
// Re-realize to fill in the swapped-in update values.
realizeStateDerivatives(getAdvancedState());
// Record the continuous parts of this now-realized initial state as the
// previous state as well (previous state is used when we have to back up
// from a failed step attempt).
saveStateAndDerivsAsPrevious(getAdvancedState());
// The initial state is set so it looks like we just *completed* a step to
// get here. That way if the first reportTime is zero, this will get
// reported.
setStepCommunicationStatus(CompletedInternalStepNoEvent);
startOfContinuousInterval = true;
// This will be set to something meaningful when the simulation ends.
terminationReason = Integrator::InvalidTerminationReason;
// Call this virtual method in case the concrete integrator class has
// additional initialization needs. Note that it gets the State as we have
// adjusted it, NOT the one originally passed to initialize().
methodInitialize(getAdvancedState());
} catch (const std::exception& e) {
SimTK_THROW1(Integrator::InitializationFailed, e.what());
} /* catch (...) {
SimTK_THROW1(Integrator::InitializationFailed, "UNKNOWN EXCEPTION");
} */
}
