void tearDownEagerAsyncFrame(ActRec*& fp, Stack& stack, PC& pc, ObjectData* e) {
auto const func = fp->m_func;
auto const prevFp = fp->arGetSfp();
auto const soff = fp->m_soff;
assert(!fp->resumed());
assert(func->isAsync());
assert(*reinterpret_cast<const Op*>(pc) != OpRetC);
FTRACE(1, "tearDownAsyncFrame: {} ({})\n fp {} prevFp {}\n",
func->fullName()->data(),
func->unit()->filepath()->data(),
implicit_cast<void*>(fp),
implicit_cast<void*>(prevFp));
try {
frame_free_locals_unwind(fp, func->numLocals());
} catch (...) {}
stack.ndiscard(func->numSlotsInFrame());
stack.ret();
assert(stack.topTV() == &fp->m_r);
tvWriteObject(c_StaticExceptionWaitHandle::Create(e), &fp->m_r);
e->decRefCount();
if (UNLIKELY(prevFp == fp)) {
pc = 0;
return;
}
assert(stack.isValidAddress(reinterpret_cast<uintptr_t>(prevFp)) ||
prevFp->resumed());
auto const prevOff = soff + prevFp->m_func->base();
pc = prevFp->m_func->unit()->at(prevOff);
fp = prevFp;
}
// Make all destructors virtual. Just in case.
virtual ~StreamTask()
{
/* send the notification of completion.*/
if ( isAsync()
&& !mProgress.isNull())
mProgress->i_notifyComplete(mRC);
}
std::string func_flag_list(const FuncInfo& finfo) {
auto const func = finfo.func;
std::vector<std::string> flags;
if (func->isGenerator()) flags.push_back("isGenerator");
if (func->isAsync()) flags.push_back("isAsync");
if (func->isClosureBody()) flags.push_back("isClosureBody");
if (func->isPairGenerator()) flags.push_back("isPairGenerator");
std::string strflags = folly::join(" ", flags);
if (!strflags.empty()) return " " + strflags + " ";
return " ";
}
Message *ServerComponent::doCall(Message *msg_in, Message *msg_out, bool sync, int timeout)
{
if (respondTo(msg_in->destination)) {
if (msg_in->answer) {
processAnswer(msg_in);
return NULL;
}
else
{
if(!msg_out) {
msg_out = new Message();
} else {
msg_out->clear();
}
msg_out->uid = msg_in->uid;
msg_out->destination = msg_in->source;
msg_out->source = msg_in->destination;
msg_out->command = msg_in->command;
msg_out->answer = true;
if(isAsync(msg_in))
{
processAsync(msg_in);
return NULL;
}
else
{
Message * answer = process(msg_in, msg_out, true, timeout);
if (answer)
answer->write_header();
return answer;
}
}
} else if (hub) {
if (sync) {
return hub->callSync(msg_in, msg_out, timeout);
} else {
return hub->call(msg_in, msg_out);
}
} else {
throw string("Cannot route message to destination ") + my_itoa(msg_in->destination);
}
};
std::string func_flag_list(const FuncInfo& finfo) {
auto const func = finfo.func;
std::vector<std::string> flags;
if (auto name = func->getGeneratorBodyName()) {
flags.push_back(
folly::format("hasGeneratorBody(\"{}\")", name->toCppString()).str()
);
}
if (func->isGenerator()) flags.push_back("isGenerator");
if (func->isAsync()) flags.push_back("isAsync");
if (func->isGeneratorFromClosure()) flags.push_back("isGeneratorFromClosure");
if (func->isClosureBody()) flags.push_back("isClosureBody");
if (func->isPairGenerator()) flags.push_back("isPairGenerator");
std::string strflags = folly::join(" ", flags);
if (!strflags.empty()) return " " + strflags + " ";
return " ";
}
void VideoCapture::start()
{
emit frameAvailable(frame); //TODO: no copy
if (!frame.isValid() || !frame.constBits(0)) { // if frame is always cloned, then size is at least width*height
qDebug("Captured frame from hardware decoder surface.");
}
CaptureTask *task = new CaptureTask(this);
// copy properties so the task will not be affect even if VideoCapture properties changed
task->save = autoSave();
task->original_fmt = original_fmt;
task->quality = qual;
task->dir = dir;
task->name = name;
task->format = fmt;
task->qfmt = qfmt;
task->frame = frame; //copy here and it's safe in capture thread because start() is called immediatly after setVideoFrame
if (isAsync()) {
videoCaptureThreadPool()->start(task);
} else {
task->run();
delete task;
}
}
NullOutputLayer( std::string name ) :
nnet::NodeLayer( name )
{
nnet::BooleanPtr isAsync( get( "isAsync" ) );
isAsync->set( false );
}
// This is only called from SimpleResponseHandler.deliver() but lives in this
// class because all asyncronous response must have a "response" pointer
// to go through. Only operation classes have a response pointer
void OperationResponseHandler::send(Boolean isComplete)
{
// It is possible to instantiate this class directly (not a derived
// class, which would also inherit from SimpleResponseHandler).
// The caller would do this only if the operation does not have any
// data to be returned.
SimpleResponseHandler* simpleP =
dynamic_cast<SimpleResponseHandler*>(this);
if (simpleP == 0)
{
// if there is no data to be returned, then the message should NEVER be
// incomplete (even on an error)
PEGASUS_ASSERT(isComplete);
return;
}
// some handlers do not send async because their callers cannot handle
// partial responses. If this is the case, stop here.
if (!isAsync())
{
// preserve traditional behavior
if (isComplete)
{
if (_response != 0)
{
_response->operationContext.set(
ContentLanguageListContainer(simpleP->getLanguages()));
}
transfer();
}
return;
}
SimpleResponseHandler& simple = *simpleP;
PEGASUS_ASSERT(_response);
Uint32 objectCount = simple.size();
// have not reached threshold yet
if ((isComplete == false) && (objectCount < _responseObjectThreshold))
{
return;
}
CIMResponseMessage* response = _response;
// for complete responses, just use the one handed down from caller
// otherwise, create our own that the caller never sees but is
// utilized for async responses underneath
if (isComplete == false)
{
_response = _request->buildResponse();
}
_response->setComplete(isComplete);
_responseObjectTotal += objectCount;
// since we are reusing response for every chunk, keep track of original
// count
_response->setIndex(_responseMessageTotal++);
// set the originally allocated response to one more than the current.
// The reason for doing this is proactive in case of an exception. This
// allows the last response to be set as it may not re-enter this code.
if (isComplete == false)
{
response->setIndex(_responseMessageTotal);
}
validate();
if (_response->cimException.getCode() != CIM_ERR_SUCCESS)
{
simple.clear();
}
PEG_TRACE((
TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"%s::transfer",
(const char*) getClass().getCString()));
transfer();
simple.clear();
_response->operationContext.set(
ContentLanguageListContainer(simple.getLanguages()));
// call thru ProviderManager to get externally declared entry point
if (isComplete == false)
{
_responseChunkCallback(_request, _response);
}
// put caller's allocated response back in place. Note that _response
// is INVALID after sending because it has been deleted externally
_response = response;
}
// This is only called from SimpleResponseHandler.deliver() but lives in this
// class because all asyncronous response must have a "response" pointer
// to go through. Only operation classes have a response pointer
void OperationResponseHandler::send(Boolean isComplete)
{
// some handlers do not send async because their callers cannot handle
// partial responses. If this is the case, stop here.
if (isAsync() == false)
{
// preserve tradional behavior
if (isComplete == true)
{
transfer();
}
return;
}
SimpleResponseHandler *simpleP = dynamic_cast<SimpleResponseHandler*>(this);
// It is possible to instantiate this class directly (not derived)
// The caller would do this only if the operation does not have any data to
// be returned
if (! simpleP)
{
// if there is no data to be returned, then the message should NEVER be
// incomplete (even on an error)
if (isComplete == false)
{
PEGASUS_ASSERT(false);
}
return;
}
SimpleResponseHandler &simple = *simpleP;
PEGASUS_ASSERT(_response);
Uint32 objectCount = simple.size();
// have not reached threshold yet
if ((isComplete == false) && (objectCount < _responseObjectThreshold))
{
return;
}
CIMResponseMessage *response = _response;
// for complete responses, just use the one handed down from caller
// otherwise, create our own that the caller never sees but is
// utilized for async responses underneath
if (isComplete == false)
{
_response = _request->buildResponse();
}
_response->setComplete(isComplete);
_responseObjectTotal += objectCount;
// since we are reusing response for every chunk,keep track of original count
_response->setIndex(_responseMessageTotal++);
// set the originally allocated response to one more than the current.
// The reason for doing this is proactive in case of an exception. This
// allows the last response to be set as it may not re-enter this code.
if (isComplete == false)
{
response->setIndex(_responseMessageTotal);
}
validate();
if (_response->cimException.getCode() != CIM_ERR_SUCCESS)
{
simple.clear();
}
String function = getClass() + "::" + "transfer";
Logger::put(
Logger::STANDARD_LOG,
System::CIMSERVER,
Logger::TRACE,
function);
transfer();
simple.clear();
// l10n
_response->operationContext.set(ContentLanguageListContainer(simple.getLanguages()));
// call thru ProviderManager to get externally declared entry point
if (isComplete == false)
{
ProviderManagerService::handleCimResponse(*_request, *_response);
}
// put caller's allocated response back in place. Note that _response
// is INVALID after sending because it has been deleted externally
_response = response;
}
