bool Journal::PlayNext()
{
if (_State == PlayState) {
_start();
Id id;
mFile->read(&id);
Functor* jrn = _create(id);
AssertFatal(jrn,"Journal: Undefined function found in journal");
jrn->read(mFile);
_finish();
_Dispatching = true;
jrn->dispatch();
_Dispatching = false;
delete jrn;
if (_Count)
return true;
Stop();
//debugBreak();
}
return false;
}
int main()
{
int N;
cin >> N;
Functor *f = new FunctorShow;
Functor *fc = new FunctorCreate;
mfunc["showall"] = f;
mfunc["create"] = fc;
string command;
vector<string> strvec;
for (int i = 0; i < N; i++) {
cin >> command;
Functor *fctr = mfunc[command];
if (fctr) {
int argnum = fctr->getArgNum();
if (argnum == 2)
for (int j = 0; j < argnum; j++) {
string str;
cin >> str;
strvec.push_back(str);
}
(*fctr)(strvec);
}
}
return 0;
}
void ThreadQueue::dispatchResponseCalls()
{
lock();
for(S32 i = 0; i < mResponseCalls.size(); i++)
{
Functor *c = mResponseCalls[i];
c->dispatch(this);
delete c;
}
mResponseCalls.clear();
unlock();
}
int main()
{
Functor t;
std::cout << t() << std::endl;
t.set_configuration("two");
std::cout << t() << std::endl;
for (int i=0 ; i < 1e9; ++i)
(void) t();
return 0;
}
void ThreadQueue::dispatchNextCall()
{
mSemaphore.wait();
lock();
if(mThreadCalls.size() == 0)
{
unlock();
return;
}
Functor *c = mThreadCalls.first();
mThreadCalls.pop_front();
unlock();
c->dispatch(this);
delete c;
}
unsigned int __stdcall TaskSchedulerImpl::WorkerProc(void* userdata)
{
unsigned int workerID = *static_cast<unsigned int*>(userdata);
SetEvent(s_doneEvents[workerID]);
Worker& worker = s_workers[workerID];
WaitForSingleObject(worker.wakeEvent, INFINITE);
while (worker.running)
{
Functor* task = nullptr;
if (worker.workCount > 0) // Permet d'éviter d'entrer inutilement dans une section critique
{
EnterCriticalSection(&worker.queueMutex);
if (!worker.queue.empty()) // Nécessaire car le workCount peut être tombé à zéro juste avant l'entrée dans la section critique
{
task = worker.queue.front();
worker.queue.pop();
worker.workCount = worker.queue.size();
}
LeaveCriticalSection(&worker.queueMutex);
}
// Que faire quand vous n'avez plus de travail ?
if (!task)
task = StealTask(workerID); // Voler le travail des autres !
if (task)
{
// On exécute la tâche avant de la supprimer
task->Run();
delete task;
}
else
{
SetEvent(s_doneEvents[workerID]);
WaitForSingleObject(worker.wakeEvent, INFINITE);
}
}
// Au cas où un thread attendrait sur WaitForTasks() pendant qu'un autre appellerait Uninitialize()
// Ça ne devrait pas arriver, mais comme ça ne coûte pas grand chose..
SetEvent(s_doneEvents[workerID]);
return 0;
}
static Vector AttituteDynamics(const ssfTime &_time, const Vector& _integratingState, Orbit *_Orbit, Attitude *_Attitude, const Matrix &_parameters, const Functor &_forceFunctorPtr)
{
static Vector stateDot(7);
static Matrix bMOI(3,3);
static Matrix qtemp(4,3);
static Vector Tmoment(3);
static Vector qIn(4);
static Vector wIn(3);
qIn = _integratingState(_(VectorIndexBase,VectorIndexBase + 3));
wIn = _integratingState(_(VectorIndexBase + 4,VectorIndexBase + 6));
qIn /= norm2(qIn);
qtemp(_(VectorIndexBase+0,VectorIndexBase+2),_) = skew(qIn(_(VectorIndexBase+0,VectorIndexBase+2))) + qIn(VectorIndexBase+3) * eye(3);
qtemp(VectorIndexBase+3, _) = -(~qIn(_(VectorIndexBase+0,VectorIndexBase+2)));
bMOI = _parameters(_(MatrixIndexBase+0,MatrixIndexBase+2),_(MatrixIndexBase+0,MatrixIndexBase+2));
Tmoment = _forceFunctorPtr.Call(_time, _Orbit->GetStateObject(), _Attitude->GetStateObject());
stateDot(_(VectorIndexBase,VectorIndexBase + 3)) = 0.5 * qtemp * wIn;
stateDot(_(VectorIndexBase + 4,VectorIndexBase + 6)) = (bMOI.inverse() * (Tmoment - skew(wIn) * (bMOI * wIn)));
return stateDot;
}
void ITimerManager::waitTo(const mtime& time, Functor<Class,RetType>& func) const {
wait(time);
func.call();
}
void ITimerManager::waitTo(const mtime& time, Functor<Class,RetType,Param1>& func, Param1& arg1) const {
wait(time);
func.call(arg1);
}
FloatInputStream::FloatInputStream(const Functor& connectToGetterFunctor)
: InputStream()
, connectedFunctor(connectToGetterFunctor.clone())
//, unreadStack()
{
}
void FloatInputStream::connectToFunctor(const Functor& newFunctor)
{
if (connectedStream != NULL) disconnectFromStream();
connectedFunctor = newFunctor.clone();
}
BOOST_AUTO_TEST_CASE_TEMPLATE(works, BasisFunctionType, basis_function_types)
{
typedef BasisFunctionType BFT;
typedef typename Fiber::ScalarTraits<BFT>::ComplexType RT;
typedef typename Fiber::ScalarTraits<BFT>::RealType CT;
GridParameters params;
params.topology = GridParameters::TRIANGULAR;
shared_ptr<Grid> grid = GridFactory::importGmshGrid(
params, "meshes/two_disjoint_triangles.msh",
false /* verbose */);
PiecewiseLinearContinuousScalarSpace<BFT> pwiseLinears(grid);
PiecewiseConstantScalarSpace<BFT> pwiseConstants(grid);
AssemblyOptions assemblyOptions;
assemblyOptions.setVerbosityLevel(VerbosityLevel::LOW);
AccuracyOptions accuracyOptions;
accuracyOptions.doubleRegular.setAbsoluteQuadratureOrder(5);
accuracyOptions.doubleSingular.setAbsoluteQuadratureOrder(5);
NumericalQuadratureStrategy<BFT, RT> quadStrategy(accuracyOptions);
Context<BFT, RT> context(make_shared_from_ref(quadStrategy), assemblyOptions);
const RT waveNumber(1.23, 0.31);
BoundaryOperator<BFT, RT> slpOpConstants = Bempp::helmholtz3dSingleLayerBoundaryOperator<BFT>(
make_shared_from_ref(context),
make_shared_from_ref(pwiseConstants),
make_shared_from_ref(pwiseConstants),
make_shared_from_ref(pwiseConstants),
waveNumber);
BoundaryOperator<BFT, RT> slpOpLinears = helmholtz3dSingleLayerBoundaryOperator<BFT>(
make_shared_from_ref(context),
make_shared_from_ref(pwiseLinears),
make_shared_from_ref(pwiseLinears),
make_shared_from_ref(pwiseLinears),
waveNumber);
BoundaryOperator<BFT, RT> hypOp = helmholtz3dHypersingularBoundaryOperator<BFT>(
make_shared_from_ref(context),
make_shared_from_ref(pwiseLinears),
make_shared_from_ref(pwiseLinears),
make_shared_from_ref(pwiseLinears),
waveNumber);
// Get the matrix repr. of the hypersingular operator
arma::Mat<RT> hypMat = hypOp.weakForm()->asMatrix();
// Construct the expected hypersingular operator matrix. For this, we need:
// * the surface curls of all basis functions (which are constant)
typedef Fiber::SurfaceCurl3dElementaryFunctor<CT> ElementaryFunctor;
typedef Fiber::ElementaryBasisTransformationFunctorWrapper<ElementaryFunctor> Functor;
Functor functor;
size_t basisDeps = 0, geomDeps = 0;
functor.addDependencies(basisDeps, geomDeps);
arma::Mat<CT> points(2, 1);
points.fill(0.);
typedef Fiber::PiecewiseLinearContinuousScalarBasis<3, BFT> Basis;
Basis basis;
Fiber::BasisData<BFT> basisData;
basis.evaluate(basisDeps, points, Fiber::ALL_DOFS, basisData);
Fiber::GeometricalData<CT> geomData[2];
std::unique_ptr<GridView> view = grid->leafView();
std::unique_ptr<EntityIterator<0> > it = view->entityIterator<0>();
it->entity().geometry().getData(geomDeps, points, geomData[0]);
it->next();
it->entity().geometry().getData(geomDeps, points, geomData[1]);
Fiber::DefaultCollectionOfBasisTransformations<Functor> transformations(functor);
Fiber::CollectionOf3dArrays<BFT> surfaceCurl[2];
transformations.evaluate(basisData, geomData[0], surfaceCurl[0]);
transformations.evaluate(basisData, geomData[1], surfaceCurl[1]);
// * the single-layer potential matrix for constant basis functions
arma::Mat<RT> slpMatConstants = slpOpConstants.weakForm()->asMatrix();
// * the single-layer potential matrix for linear basis functions
arma::Mat<RT> slpMatLinears = slpOpLinears.weakForm()->asMatrix();
arma::Mat<RT> expectedHypMat(6, 6);
for (size_t testElement = 0; testElement < 2; ++testElement)
for (size_t trialElement = 0; trialElement < 2; ++trialElement)
for (size_t r = 0; r < 3; ++r)
for (size_t c = 0; c < 3; ++c) {
RT curlMultiplier = 0.;
for (size_t dim = 0; dim < 3; ++dim)
curlMultiplier += surfaceCurl[testElement][0](dim, r, 0) *
surfaceCurl[trialElement][0](dim, c, 0);
RT valueMultiplier = 0.;
for (size_t dim = 0; dim < 3; ++dim)
valueMultiplier += geomData[testElement].normals(dim, 0) *
geomData[trialElement].normals(dim, 0);
expectedHypMat(3 * testElement + r, 3 * trialElement + c) =
curlMultiplier * slpMatConstants(testElement, trialElement) -
waveNumber * waveNumber * valueMultiplier *
slpMatLinears(3 * testElement + r, 3 * trialElement + c);
}
BOOST_CHECK(check_arrays_are_close<RT>(expectedHypMat, hypMat, 1e-6));
}
void BoolOutputStream::connectToFunctor(const Functor& newFunctor)
{
connectedFunctors += newFunctor.clone();
}