void submit(SQLQuery *req, const std::string& q)
{
if (qinprog.q.empty())
{
DoQuery(QueueItem(req,q));
}
else
{
// wait your turn.
queue.push_back(QueueItem(req,q));
}
}
unsigned UnwrappedLineFormatter::analyzeSolutionSpace(LineState &InitialState,
bool DryRun) {
std::set<LineState *, CompareLineStatePointers> Seen;
// Increasing count of \c StateNode items we have created. This is used to
// create a deterministic order independent of the container.
unsigned Count = 0;
QueueType Queue;
// Insert start element into queue.
StateNode *Node =
new (Allocator.Allocate()) StateNode(InitialState, false, nullptr);
Queue.push(QueueItem(OrderedPenalty(0, Count), Node));
++Count;
unsigned Penalty = 0;
// While not empty, take first element and follow edges.
while (!Queue.empty()) {
Penalty = Queue.top().first.first;
StateNode *Node = Queue.top().second;
if (!Node->State.NextToken) {
DEBUG(llvm::dbgs() << "\n---\nPenalty for line: " << Penalty << "\n");
break;
}
Queue.pop();
// Cut off the analysis of certain solutions if the analysis gets too
// complex. See description of IgnoreStackForComparison.
if (Count > 10000)
Node->State.IgnoreStackForComparison = true;
if (!Seen.insert(&Node->State).second)
// State already examined with lower penalty.
continue;
FormatDecision LastFormat = Node->State.NextToken->Decision;
if (LastFormat == FD_Unformatted || LastFormat == FD_Continue)
addNextStateToQueue(Penalty, Node, /*NewLine=*/false, &Count, &Queue);
if (LastFormat == FD_Unformatted || LastFormat == FD_Break)
addNextStateToQueue(Penalty, Node, /*NewLine=*/true, &Count, &Queue);
}
if (Queue.empty()) {
// We were unable to find a solution, do nothing.
// FIXME: Add diagnostic?
DEBUG(llvm::dbgs() << "Could not find a solution.\n");
return 0;
}
// Reconstruct the solution.
if (!DryRun)
reconstructPath(InitialState, Queue.top().second);
DEBUG(llvm::dbgs() << "Total number of analyzed states: " << Count << "\n");
DEBUG(llvm::dbgs() << "---\n");
return Penalty;
}
void HbSplashGenerator::regenerate()
{
QString themeName = hbInstance->theme()->name();
qDebug() << PRE << "regenerate() theme:" << themeName;
if (!themeName.isEmpty()) {
try {
emit regenerateStarted();
QTime queuePrepTime;
queuePrepTime.start();
// Delete existing splash screens. This is important because apps
// should never pick up a screen with the previous theme or
// language. If the generation of the new screens (at least the
// empty view) has not finished when a new app is started then it is
// better to show no splash screen at all.
QDir outDir(hbsplash_output_dir());
if (outDir.exists()) {
QStringList names = outDir.entryList(QStringList() << "*", QDir::Files);
foreach(const QString & name, names) {
outDir.remove(name);
}
}
// Clear the queue, generating screens with a non-current theme is
// not possible anyway.
mQueue.clear();
// If this is the first invocation then put some requests for
// screens we won't use. On certain platforms the very first
// rendering (with a newly created mainwindow) may lead to
// mysteriously scaled down output.
if (mFirstRegenerate) {
mFirstRegenerate = false;
mQueue.enqueue(QueueItem(themeName, Qt::Vertical));
mQueue.enqueue(QueueItem(themeName, Qt::Horizontal));
}
// Queue the screenshot request for both orientations.
mQueue.enqueue(QueueItem(themeName, Qt::Vertical));
mQueue.enqueue(QueueItem(themeName, Qt::Horizontal));
queueAppSpecificItems(themeName, Qt::Vertical);
queueAppSpecificItems(themeName, Qt::Horizontal);
qDebug() << PRE << "queue preparation time (ms):" << queuePrepTime.elapsed();
QMetaObject::invokeMethod(this, "processQueue", Qt::QueuedConnection);
} catch (const std::bad_alloc &) {
void Cube::CreateNeighbour(const std::vector<int> &coordinates)
{
// Add the coordinates to the set of visited coordinates if not already
// present.
std::pair<CoordinateSet::iterator, bool> p = m_visited.insert(coordinates);
if (!p.second) {
// We have visited this neighbour before, so there is nothing to do.
return;
}
SHyperedge *hyperedge = CreateHyperedge(coordinates);
const std::vector<int> &storedCoordinates = *p.first;
m_queue.push(QueueItem(hyperedge, &storedCoordinates));
}
Cube::Cube(const SHyperedgeBundle &bundle)
: m_bundle(bundle)
{
// Create the SHyperedge for the 'corner' of the cube.
std::vector<int> coordinates(bundle.beams.size()+1, 0);
SHyperedge *hyperedge = CreateHyperedge(coordinates);
// Add its coordinates to the set of visited coordinates.
std::pair<CoordinateSet::iterator, bool> p = m_visited.insert(coordinates);
const std::vector<int> &storedCoordinates = *p.first;
// Add the SHyperedge to the queue along with its coordinates (which will be
// needed for creating its neighbours).
m_queue.push(QueueItem(hyperedge, &storedCoordinates));
}
void CNoteQueueMidiInputHandler::OnNoteOff(int Note, int Velocity, std::uint32_t TimeStamp)
{
SQueueItem QueueItem(Note, Velocity, TimeStamp);
m_NoteQueue.remove(QueueItem);
if(m_NoteQueue.empty())
{
m_Handler->OnNoteOff(Note, Velocity, TimeStamp);
}
else if(m_NoteQueue.back()!=QueueItem)
{
m_Handler->OnNoteOn(m_NoteQueue.back().s_Note, m_NoteQueue.back().s_Velocity, m_NoteQueue.back().s_TimeStamp);
}
}
///////////////////////////////////////////////////////////////////////////////
/// CConnection::Send
/// @description: Given a message and wether or not it should be sequenced,
/// write that message to the channel.
/// @pre: The CConnection object is initialized.
/// @post: If the window is in not full, the message will have been written to
/// to the channel. Before being sent the message has been signed with the
/// UUID, source hostname and sequence number (if it is being sequenced).
/// If the message is being sequenced and the window is not already full,
/// the timeout timer is cancelled and reset.
/// @param p_mesg: A CMessage to write to the channel.
/// @param sequence: if true, the message will be sequenced and reliably
/// delievered in order. Otherwise it is immediately fired and forgotten.
/// this is mostly meant for use with ACKs. True by default.
///////////////////////////////////////////////////////////////////////////////
void CConnection::Send(CMessage p_mesg, bool sequence)
{
Logger::Debug << __PRETTY_FUNCTION__ << std::endl;
//Make a call to the dispatcher to sign the messages
//With a bunch of shiny stuff.
ptree x = static_cast<ptree>(p_mesg);
unsigned int msgseq;
//m_dispatch.HandleWrite(x);
CMessage outmsg(x);
// Sign the message with the hostname, uuid, and squencenumber
if(sequence == true)
{
if(m_synched == false)
{
m_synched = true;
SendSYN();
}
msgseq = m_outsequenceno;
outmsg.SetSequenceNumber(msgseq);
m_outsequenceno = (m_outsequenceno+1) % GetSequenceModulo();
}
outmsg.SetSourceUUID(GetConnectionManager().GetUUID());
outmsg.SetSourceHostname(GetConnectionManager().GetHostname());
if(sequence == true)
{
// If it isn't squenced then don't put it in the queue.
m_queue.Push( QueueItem(msgseq,outmsg) );
}
// Before, we would put it into a queue to be sent later, now we are going
// to immediately write it to channel.
if(m_queue.size() <= GetWindowSize() || sequence == false)
{
// Only try to write to the socket if the window isn't already full.
// Or it is an unsequenced message
HandleSend(outmsg);
if(sequence == true)
{
m_timeout.cancel();
m_timeout.expires_from_now(boost::posix_time::milliseconds(1000));
m_timeout.async_wait(boost::bind(&CConnection::Resend,this,
boost::asio::placeholders::error));
}
}
}
/// \brief Add the following state to the analysis queue \c Queue.
///
/// Assume the current state is \p PreviousNode and has been reached with a
/// penalty of \p Penalty. Insert a line break if \p NewLine is \c true.
void addNextStateToQueue(unsigned Penalty, StateNode *PreviousNode,
bool NewLine, unsigned *Count, QueueType *Queue) {
if (NewLine && !Indenter->canBreak(PreviousNode->State))
return;
if (!NewLine && Indenter->mustBreak(PreviousNode->State))
return;
StateNode *Node = new (Allocator.Allocate())
StateNode(PreviousNode->State, NewLine, PreviousNode);
if (!formatChildren(Node->State, NewLine, /*DryRun=*/true, Penalty))
return;
Penalty += Indenter->addTokenToState(Node->State, NewLine, true);
Queue->push(QueueItem(OrderedPenalty(Penalty, *Count), Node));
++(*Count);
}
void DoConnectedPoll()
{
restart:
while (qinprog.q.empty() && !queue.empty())
{
/* There's no query currently in progress, and there's queries in the queue. */
DoQuery(queue.front());
queue.pop_front();
}
if (PQconsumeInput(sql))
{
if (PQisBusy(sql))
{
/* Nothing happens here */
}
else if (qinprog.c)
{
/* Fetch the result.. */
PGresult* result = PQgetResult(sql);
/* PgSQL would allow a query string to be sent which has multiple
* queries in it, this isn't portable across database backends and
* we don't want modules doing it. But just in case we make sure we
* drain any results there are and just use the last one.
* If the module devs are behaving there will only be one result.
*/
while (PGresult* temp = PQgetResult(sql))
{
PQclear(result);
result = temp;
}
/* ..and the result */
PgSQLresult reply(result);
switch(PQresultStatus(result))
{
case PGRES_EMPTY_QUERY:
case PGRES_BAD_RESPONSE:
case PGRES_FATAL_ERROR:
{
SQLerror err(SQL_QREPLY_FAIL, PQresultErrorMessage(result));
qinprog.c->OnError(err);
break;
}
default:
/* Other values are not errors */
qinprog.c->OnResult(reply);
}
delete qinprog.c;
qinprog = QueueItem(NULL, "");
goto restart;
}
else
{
qinprog.q.clear();
}
}
else
{
/* I think we'll assume this means the server died...it might not,
* but I think that any error serious enough we actually get here
* deserves to reconnect [/excuse]
* Returning true so the core doesn't try and close the connection.
*/
DelayReconnect();
}
}
/**
* Perform a breadth first construction of all requested derivatives.
*/
void
DerivativeParsedMaterialHelper::assembleDerivatives()
{
// need to check for zero derivatives here, otherwise at least one order is generated
if (_derivative_order < 1) return;
// if we are not on thread 0 we fetch all data from the thread 0 copy that already did all the work
if (_tid > 0)
{
// get the master object from thread 0
const MaterialWarehouse<Material> & material_warehouse = _fe_problem.getMaterialWarehouse();
const ExecuteMooseObjectWarehouse<Material> & warehouse = material_warehouse[_material_data_type];
MooseSharedPointer<DerivativeParsedMaterialHelper> master =
MooseSharedNamespace::dynamic_pointer_cast<DerivativeParsedMaterialHelper>(warehouse.getActiveObject(name()));
// copy parsers and declare properties
for (unsigned int i = 0; i < master->_derivatives.size(); ++i)
{
Derivative newderivative;
newderivative.first = &declarePropertyDerivative<Real>(_F_name, master->_derivatives[i].darg_names);
newderivative.second = ADFunctionPtr(new ADFunction(*master->_derivatives[i].second));
_derivatives.push_back(newderivative);
}
// copy coupled material properties
for (unsigned int i = 0; i < master->_mat_prop_descriptors.size(); ++i)
{
FunctionMaterialPropertyDescriptor newdescriptor(master->_mat_prop_descriptors[i]);
_mat_prop_descriptors.push_back(newdescriptor);
}
// size parameter buffer
_func_params.resize(master->_func_params.size());
}
// set up job queue. We need a deque here to be able to iterate over the currently queued items.
std::deque<QueueItem> queue;
queue.push_back(QueueItem(_func_F));
// generate derivatives until the queue is exhausted
while (!queue.empty())
{
QueueItem current = queue.front();
// all permutations of one set of derivatives are equal, so we make sure to generate only one each
unsigned int first = current._dargs.empty() ? 0 : current._dargs.back();
// add necessary derivative steps
for (unsigned int i = first; i < _nargs; ++i)
{
// go through list of material properties and check if derivatives are needed
unsigned int ndesc = _mat_prop_descriptors.size();
for (unsigned int jj = 0; jj < ndesc; ++jj)
{
FunctionMaterialPropertyDescriptor * j = &_mat_prop_descriptors[jj];
// take a property descriptor and check if it depends on the current derivative variable
if (j->dependsOn(_arg_names[i]))
{
FunctionMaterialPropertyDescriptor matderivative(*j);
matderivative.addDerivative(_arg_names[i]);
// search if this new derivative is not yet in the list of material properties
MatPropDescriptorList::iterator m = findMatPropDerivative(matderivative);
if (m == _mat_prop_descriptors.end())
{
// construct new variable name for the material property derivative as base name + number
std::string newvarname = _dmatvar_base + Moose::stringify(_dmatvar_index++);
matderivative.setSymbolName(newvarname);
// loop over all queue items to register the new dmatvar variable (includes 'current' which is popped below)
for (std::deque<QueueItem>::iterator k = queue.begin(); k != queue.end(); ++k)
{
k->_F->AddVariable(newvarname);
k->_F->RegisterDerivative(j->getSymbolName(), _arg_names[i], newvarname);
}
_mat_prop_descriptors.push_back(matderivative);
}
}
}
// construct new derivative
QueueItem newitem = current;
newitem._dargs.push_back(i);
// build derivative
newitem._F = ADFunctionPtr(new ADFunction(*current._F));
if (newitem._F->AutoDiff(_variable_names[i]) != -1)
mooseError("Failed to take order " << newitem._dargs.size() << " derivative in material " << _name);
// optimize and compile
if (!_disable_fpoptimizer)
newitem._F->Optimize();
if (_enable_jit && !newitem._F->JITCompile())
mooseWarning("Failed to JIT compile expression, falling back to byte code interpretation.");
// generate material property argument vector
std::vector<VariableName> darg_names(0);
for (unsigned int j = 0; j < newitem._dargs.size(); ++j)
darg_names.push_back(_arg_names[newitem._dargs[j]]);
// append to list of derivatives if the derivative is non-vanishing
if (!newitem._F->isZero())
{
Derivative newderivative;
newderivative.first = &declarePropertyDerivative<Real>(_F_name, darg_names);
newderivative.second = newitem._F;
newderivative.darg_names = darg_names;
_derivatives.push_back(newderivative);
}
// push item to queue if further differentiation is required
if (newitem._dargs.size() < _derivative_order)
queue.push_back(newitem);
}
// remove the 'current' element from the queue
queue.pop_front();
}
// increase the parameter buffer to provide storage for the material property derivatives
_func_params.resize(_nargs + _mat_prop_descriptors.size());
}
