Example #1
0
void UnitsClassWidget::linkToDatastoreItem(const std::list<openfluid::fluidx::DatastoreItemDescriptor*>& DSList)
{
  mp_LayerSource = nullptr;

  // disconnect signal to avoid multiple refresh of map,
  // due to changeVisible slot
  disconnect(ui->VisibleCheckBox,SIGNAL(toggled(bool)),this,SLOT(changeVisible()));

  if (!DSList.empty())
  {
    mp_LayerSource = DSList.front();
    ui->LayerSourceLabel->setText(QDir::toNativeSeparators(QString::fromStdString(mp_LayerSource->getRelativePath())));
    ui->StyleParamsWidget->setEnabled(true);
  }
  else
  {
    ui->LayerSourceLabel->setText(tr("(no layer to display)"));
    ui->StyleParamsWidget->setEnabled(false);
    ui->VisibleCheckBox->setChecked(false);
  }

  connect(ui->VisibleCheckBox,SIGNAL(toggled(bool)),this,SLOT(changeVisible()));
}
Example #2
0
		void hpc_logger::write_buffer_list(std::list<buffer_info>& llist)
		{
			while (!llist.empty())
			{
				buffer_info new_buffer_info = llist.front();
                llist.pop_front();

				if (_current_log_file_bytes + new_buffer_info.buffer_size >= MAX_FILE_SIZE)
				{
					_current_log->close();
					delete _current_log;
                    _current_log = nullptr;

                    create_log_file();
				}

				_current_log->write(new_buffer_info.buffer, new_buffer_info.buffer_size);

				_current_log_file_bytes += new_buffer_info.buffer_size;

				free(new_buffer_info.buffer);
			}
		}
// Returns true if anything was executed.
bool __RunOnePendingInterrupt()
{
	if (inInterrupt || !interruptsEnabled)
	{
		// Already in an interrupt! We'll keep going when it's done.
		return false;
	}
	// Can easily prioritize between different kinds of interrupts if necessary.
retry:
	if (pendingInterrupts.size())
	{
		// If we came from CoreTiming::Advance(), we might've come from a waiting thread's callback.
		// To avoid "injecting" return values into our saved state, we context switch here.
		__KernelSwitchOffThread("interrupt");

		PendingInterrupt pend = pendingInterrupts.front();
		SubIntrHandler *handler = intrHandlers[pend.intr].get(pend.subintr);
		if (handler == NULL)
		{
			WARN_LOG(HLE, "Ignoring interrupt, already been released.");
			pendingInterrupts.pop_front();
			goto retry;
		}

		intState.save();
		handler->copyArgsToCPU(pend);

		currentMIPS->r[MIPS_REG_RA] = __KernelInterruptReturnAddress();
		inInterrupt = true;
		return true;
	}
	else
	{
		// DEBUG_LOG(HLE, "No more interrupts!");
		return false;
	}
}
Example #4
0
void* GetConnect()
{
	void* con;  
	EnterCriticalSection(&secLock); 
	if(connLists.size()>0)//连接池容器中还有连接  
	{  
		con=connLists.front();//得到第一个连接  
		connLists.pop_front();//移除第一个连接  
		if(YTConn_GetStatus(con) < 0)//如果连接已经被关闭,删除后重新建立一个  
		{  
			YTConn_Close(con);
			YTConn_Connect(con);
		}  
		
		LeaveCriticalSection(&secLock);  
		return con;  
	}  
	else
	{
		if(iCurConnects< imaxConnects)
		{//还可以创建新的连接  
			con= YTConn_NewConn(ptrConfig);
			if (YTConn_Connect(con) < 0)
			{
				YTConn_DelConn(con);
				con = NULL;
			}
			LeaveCriticalSection(&secLock);
			return con;
		}  
		else
		{//建立的连接数已经达到maxSize  
			LeaveCriticalSection(&secLock);
			return NULL; 
		}  
	}  
}
Example #5
0
/**
 * @brief Move half the population from the first Cell to the last Cell of cellPath
 * @details It should be noted that movePopulation() check wether it's legal to do that move before
 * 
 * @param cellPath a list of pointer to Hexacell, all HexaCell should be adjacent
 * @param playerID the Id of the player trying to do that move
 */
void MainWindow::movePopulation(std::list<HexaCell*> cellPath, int playerID )
{
    HexaCell* startCell = cellPath.front();
    HexaCell* endCell = cellPath.back();
    int popToMove = (startCell)->getPopulation() / 2;
    if (playerID != startCell->getPlayerID()){
        return;
    }
    if (endCell->getPlayerID() == playerID)
    {
        startCell->decPopulation(popToMove);
        endCell->incPopulation(popToMove);
    }
    else{
        if (endCell->getPopulation() > popToMove){
            startCell->decPopulation(popToMove);
            endCell->decPopulation(popToMove);
        }
        else{
            startCell->decPopulation(popToMove);
            endCell->setPopulation(popToMove - endCell->getPopulation());
            if (endCell->getPlayerID() == 1)
                hexaCellBoard->removePlayerCell(endCell);
            else if (endCell->getPlayerID() == 2)
                hexaCellBoard->removeBotCell(endCell);

            if (playerID == 1)
                hexaCellBoard->addPlayerCell(endCell);
            if (playerID == 2)
                hexaCellBoard->addBotCell(endCell);

            endCell->setPlayerID(playerID);
        }
    }
    startCell->update();
    endCell->update();
}
Example #6
0
 virtual void AddNodeStmt(Node* n, const AstNodePtr& s) 
   {
     PtrAnal::StmtRef s_stmts = m.translate_stmt(s);
     if (s_stmts.size() == 0) {
        if (fa.IsStatement(s))
           return;
        PtrAnal::Stmt s_exp = m.translate_exp(s).stmt;
        assert(s_exp != 0);
        s_stmts.push_back(s_exp); 
     }
     if (n->size()) {
        m.contrl_flow(n->back(), s_stmts.front(), CFGConfig::ALWAYS);
     }
     else if (n == &nodes.front())
        m.contrl_flow(defn, s_stmts.front(), CFGConfig::ALWAYS);
     PtrAnal::StmtRef::const_iterator p = s_stmts.begin();
     n->push_back(*p);
     for (++p;  p != s_stmts.end(); ++p) {
        PtrAnal::Stmt cur = *p;
        m.contrl_flow(n->back(), cur, CFGConfig::ALWAYS);
        n->push_back(cur);
     }
     std::map<Node*, EdgeInfo>::iterator p_pending = pending_in.find(n);
     if (p_pending != pending_in.end()) {
        EdgeInfo& cur = (*p_pending).second;
        for (std::list<std::pair<Node*,EdgeType> >::const_iterator 
              p_edge=cur.begin(); p_edge != cur.end(); ++p_edge) {
           Node* n1 = (*p_edge).first; 
           if (n1->size())
               m.contrl_flow( n1->back(), n->front(), (*p_edge).second);       
           else
              pending_out[n1].push_back(std::pair<Node*,EdgeType>(n, (*p_edge).second));
        }
        pending_in.erase(p_pending);
     }
   }
Example #7
0
void CLogRequest::MassQueue(std::list<std::string>& queue )
{
	while (!queue.empty())
	{
		std::string event = queue.front();
		queue.pop_front();
		if(mData.size() == 0)
		{
			mData = event;
		}
		else
		{
			mData += "~" + event;
			if ( mData.length() > 300)
			{
				Send();
				CLogRequest newRequest(mTrackUrl);
				newRequest.MassQueue(queue);
				return;
			}
		}
	}
	Send();
}
Example #8
0
void test_with_empty_headers()
{
    multipartparser parser;

#define BOUNDARY "boundary"
#define BODY                                                    \
    "--" BOUNDARY "\r\n"                                        \
    "\r\n"                                                      \
    "This is implicitly typed plain ASCII text.\r\n"            \
    "It does NOT end with a linebreak."                         \
    "\r\n--" BOUNDARY "--\r\n"

    init_globals();
    multipartparser_init(&parser, BOUNDARY);

    assert(multipartparser_execute(&parser, &g_callbacks, BODY, strlen(BODY)) == strlen(BODY));
    assert(g_body_begin_called);
    assert(g_parts.size() == 1);
    assert(g_parts.front().headers.empty());
    assert(g_body_end_called);

#undef BOUNDARY
#undef BODY
}
Example #9
0
// SIGINT alarm handler:  alarm set by entity handler.  Does
// slow response when fired
void AlarmHandler(int sig)
{
    if (sig == SIGALRM)
    {
        OC_LOG (INFO, TAG, "Server starting slow response");
        if (gRequestList.empty())
        {
            OC_LOG (INFO, TAG, "No requests to service");
            return;
        }

        // Get the request from the list
        OCEntityHandlerRequest *entityHandlerRequest = gRequestList.front();
        gRequestList.pop_front();
        if (entityHandlerRequest->method == OC_REST_GET)
        {
            OC_LOG (INFO, TAG, "Received OC_REST_GET from client");
            ProcessGetRequest (entityHandlerRequest);
        }
        else
        {
            OC_LOG_V (INFO, TAG, "Received unsupported method %d from client",
                    entityHandlerRequest->method);
        }
        // Free the request
        OCFree(entityHandlerRequest->query);
        OCFree(entityHandlerRequest->reqJSONPayload);
        OCFree(entityHandlerRequest);

        // If there are more requests in list, re-arm the alarm signal
        if (gRequestList.empty())
        {
            alarm(SLOW_RESPONSE_DELAY_SEC);
        }
    }
}
Example #10
0
void _MaxSizeLogAppender::roll()
{
  std::stringstream newPath_stream;
  newPath_stream << context.path << "." << getCurrDateTime();

  std::stringstream postfix_stream;
  postfix_stream << "(" << currBackupCount++ << ")";

  std::string newPath = rename(newPath_stream.str().c_str(),
      postfix_stream.str().c_str());
  backupList.push_back(newPath);

  if (backupList.size() > (size_t) maxBackupCount)
    {
      std::string remove_path = backupList.front();
      backupList.pop_front();

      int e = remove(remove_path.c_str());
      if (e != 0)
        {
          perror("remove");
        }
    }
}
Example #11
0
char *send_command(zmq::socket_t &sock, std::list<Value> &params) {
	if (params.size() == 0) return 0;
	Value cmd_val = params.front();
	params.pop_front();
	std::string cmd = cmd_val.asString();
	char *msg = MessageEncoding::encodeCommand(cmd, &params);
	{FileLogger fl(program_name); fl.f() << "sending: " << msg << "\n"; }
	if (options.verbose) std::cout << " sending: " << msg << "\n";
	sendMessage(sock, msg);
	size_t size = strlen(msg);
	free(msg);
	{FileLogger fl(program_name); fl.f() << "getting reply:\n"; }
	zmq::message_t reply;
	if (sock.recv(&reply)) {
		{FileLogger fl(program_name); fl.f() << "got reply:\n"; }
		size = reply.size();
		char *data = (char *)malloc(size+1);
		memcpy(data, reply.data(), size);
		data[size] = 0;

		return data;
	}
	return 0;
}
Example #12
0
    /* Socket dapat ditulis */
    void write_cb(ev::io &watcher) {
        if (write_queue.empty()) {
            io.set(ev::READ);
            return;
        }
 
        Buffer* buffer = write_queue.front();
 
        ssize_t written = write(watcher.fd, buffer->dpos(), buffer->nbytes());
        if (written < 0) {
            perror("read error");
            return;
        }
 
        buffer->pos += written;
        if (buffer->nbytes() == 0) {
            write_queue.pop_front();
            delete buffer;
        }

        /* Tutup dan bebaskan watcher saat selesai mengirim response (stateless) */
        io.stop();
        close(sfd);
    }
Example #13
0
	void performFilling() {
		Range *range = generateRangeAndReplaceColor(start_point.y, start_point.x, UP);
		ranges.push_back(range);
		ranges.push_back(new Range(range->line, range->start, range->end, DOWN));

		int row;
		while (!ranges.empty()) {
			range = ranges.front();

			if (range->direction == UP) {
				row = range->line - 1;
				if (row >= 0) {
					checkRangeAndGenerateNewRanges(range, row, UP);
				}
			} else {
				row = range->line + 1;
				if (row < y_size) {
					checkRangeAndGenerateNewRanges(range, row, DOWN);
				}
			}
			ranges.pop_front();
			delete(range);
		}
	}
void matchRecord::getWrstBattPship(std::list<playerInnsRecord> &b1,
                                   std::list<playerInnsRecord> &b2 ) const
{
   for (int i = 0; i < nPlayersPerTeam ; i += 2)
   {
      // test whether this batting pship is worse than the worst seen so far
      if (  battingRec[i].runsScored + battingRec[i + 1].runsScored
          < b1.front().runsScored    + b2.front().runsScored       )
      {
         // remove all but one record from both lists
         while (b1.size() > 1) b1.pop_back();
         while (b2.size() > 1) b2.pop_back();

         // update remaining records
         b1.front() = playerInnsRecord(battingRec[i].runsScored,
                                       battingRec[i].batsmansName,
                                       teamName, date             );
         b2.front() = playerInnsRecord(battingRec[i + 1].runsScored,
                                       battingRec[i + 1].batsmansName,
                                       teamName, date                 );
      }
      else
        // test whether this batting pship is equal to the worst seen so far
        if (   battingRec[i].runsScored + battingRec[i + 1].runsScored
            == b1.front().runsScored    + b2.front().runsScored       )
        {
           // add record to list
           b1.push_back(playerInnsRecord(battingRec[i].runsScored,
                                         battingRec[i].batsmansName,
                                         teamName, date             ));
           b2.push_back(playerInnsRecord(battingRec[i + 1].runsScored,
                                         battingRec[i + 1].batsmansName,
                                         teamName, date                 ));
        }
   }
}
Example #15
0
 /** \copydoc Option::proceed */
 void proceed (const std::list<std::string>& args, IProperties& props)
 {
     props.add (0, getName(), args.front());
 }
Example #16
0
  CHECK_TEST_CONDITION(r);
  CHECK_EQ(2, c.get_alternative_blocks_count());

  // Some blocks that were in main chain are in alt chain now
  BOOST_FOREACH(block b, alt_blocks)
  {
    CHECK_TEST_CONDITION(m_chain_1.end() != std::find(m_chain_1.begin(), m_chain_1.end(), b));
  }

  std::vector<cryptonote::block> chain;
  map_hash2tx_t mtx;
  r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back()));
  CHECK_TEST_CONDITION(r);
  CHECK_EQ(MK_COINS(8),  get_balance(m_recipient_account_1, chain, mtx));
  CHECK_EQ(MK_COINS(3),  get_balance(m_recipient_account_2, chain, mtx));
  CHECK_EQ(MK_COINS(14), get_balance(m_recipient_account_3, chain, mtx));
  CHECK_EQ(MK_COINS(16), get_balance(m_recipient_account_4, chain, mtx));

  std::list<transaction> tx_pool;
  c.get_pool_transactions(tx_pool);
  CHECK_EQ(1, tx_pool.size());
  CHECK_TEST_CONDITION(!(tx_pool.front() == m_tx_pool.front()));

  std::vector<size_t> tx_outs;
  uint64_t transfered;
  lookup_acc_outs(m_recipient_account_2.get_keys(), tx_pool.front(), tx_outs, transfered);
  CHECK_EQ(MK_COINS(7), transfered);

  return true;
}
bool listPointsEqual(std::list<Point2f> l1, std::list<Point2f> l2) {
    return l1.front() == l2.front();
}
Example #18
0
void Vimpc::Run(std::string hostname, uint16_t port)
{
   int input = ERR;

   // Keyboard input event handler
   Vimpc::EventHandler(Event::Input, [&input] (EventData const & Data)
   {
      input = Data.input;
   });

   // Refresh the mode after a status update
   Vimpc::EventHandler(Event::StatusUpdate, [this] (EventData const & Data)
   {
      if (screen_.PagerIsVisible() == false)
      {
         Ui::Mode & mode = assert_reference(modeTable_[currentMode_]);
         mode.Refresh();
      }
   });

   // Set up the display
   {
      Ui::Mode & mode = assert_reference(modeTable_[currentMode_]);
      mode.Initialise(0);
   }

   SetSkipConfigConnects((hostname != "") || (port != 0));

   // Parse the config file
   commandMode_.SetQueueCommands(true);
   bool const configExecutionResult = Config::ExecuteConfigCommands(commandMode_);

   SetSkipConfigConnects(false);

   screen_.Start();

   if (configExecutionResult == true)
   {
      // If we didn't connect to a host from the config file, just connect to the default
      if (commandMode_.ConnectionAttempt() == false)
      {
         client_.Connect(hostname, port);
      }

      screen_.Update();
      commandMode_.SetQueueCommands(false);

      // The main loop
      while (Running == true)
      {
         screen_.UpdateErrorDisplay();

         {
            UniqueLock<Mutex> Lock(QueueMutex);

            if ((Queue.empty() == false) ||
               (ConditionWait(Condition, Lock, 100) != false))
            {
               if (Queue.empty() == false)
               {
                  EventPair const Event = Queue.front();
                  Queue.pop_front();
                  Lock.unlock();

                  if ((userEvents_ == false) &&
                     (Event.second.user == true))
                  {
                     Debug("Discarding user event");
                     continue;
                  }

                  for (auto func : Handler[Event.first])
                  {
                     func(Event.second);
                  }

                  EventMutex.lock();

                  for (auto cond : WaitConditions[Event.first])
                  {
                     cond->notify_all();
                  }

                  EventMutex.unlock();

                  Debug("Event triggered: " + EventStrings::Default[Event.first]);
               }
            }
         }

         if (input != ERR)
         {
            screen_.ClearErrorDisplay();

            if ((screen_.PagerIsVisible() == true)
#ifdef HAVE_MOUSE_SUPPORT
               && (input != KEY_MOUSE)
#endif
            )
            {
               if (screen_.PagerIsFinished() == true)
               {
                  screen_.HidePagerWindow();
               }
               else
               {
                  screen_.PagerWindowNext();
               }
            }
            else
            {
               Handle(input);
            }
         }

         bool const Resize = screen_.Resize();

         QueueMutex.lock();

         if (((input != ERR) || (Resize == true)) || (requireRepaint_ == true))
         {
            QueueMutex.unlock();
            Repaint();
         }
         else
         {
            QueueMutex.unlock();
         }

         input = ERR;
      }
   }
}
Example #19
0
 const char *PeekNext() const {
     return IsEmpty() ? NULL : args.front();
 }
		Cord getFront(void){
			return cords.front();
		}
Example #21
0
bool stack_compare(const std::list<item> &lhs, const std::list<item> &rhs)
{
    return lhs.front() < rhs.front();
}
Example #22
0
void ExecutionPath::checkScope(const Token *tok, std::list<ExecutionPath *> &checks)
{
    if (!tok || tok->str() == "}" || checks.empty())
        return;

    const std::auto_ptr<ExecutionPath> check(checks.front()->copy());

    for (; tok; tok = tok->next()) {
        // might be a noreturn function..
        if (Token::simpleMatch(tok->tokAt(-2), ") ; }") &&
            Token::Match(tok->linkAt(-2)->tokAt(-2), "[;{}] %var% (") &&
            tok->linkAt(-2)->previous()->varId() == 0) {
            ExecutionPath::bailOut(checks);
            return;
        }

        if (Token::simpleMatch(tok, "union {")) {
            tok = tok->next()->link();
            continue;
        }

        if (tok->str() == "}")
            return;

        if (tok->str() == "break") {
            ExecutionPath::bailOut(checks);
            return;
        }

        if (Token::simpleMatch(tok, "while (")) {
            // parse condition
            if (checks.size() > 10 || check->parseCondition(*tok->tokAt(2), checks)) {
                ExecutionPath::bailOut(checks);
                return;
            }

            // skip "while (fgets()!=NULL)"
            if (Token::simpleMatch(tok, "while ( fgets (")) {
                const Token *tok2 = tok->linkAt(3);
                if (Token::simpleMatch(tok2, ") ) {")) {
                    tok = tok2->linkAt(2);
                    if (!tok)
                        break;
                    continue;
                }
            }
        }

        // goto/setjmp/longjmp => bailout
        else if (Token::Match(tok, "goto|setjmp|longjmp")) {
            ExecutionPath::bailOut(checks);
            return;
        }

        // ?: => bailout
        if (tok->str() == "?") {
            for (const Token *tok2 = tok; tok2 && tok2->str() != ";"; tok2 = tok2->next()) {
                if (tok2->varId() > 0)
                    ExecutionPath::bailOutVar(checks, tok2->varId());
            }
        }

        // for/while/switch/do .. bail out
        else if (Token::Match(tok, "for|while|switch|do")) {
            // goto {
            const Token *tok2 = tok->next();
            if (tok2 && tok2->str() == "(")
                tok2 = tok2->link();
            if (tok2 && tok2->str() == ")")
                tok2 = tok2->next();
            if (!tok2 || tok2->str() != "{") {
                ExecutionPath::bailOut(checks);
                return;
            }

            if (tok->str() == "switch") {
                // parse condition
                if (checks.size() > 10 || check->parseCondition(*tok->next(), checks)) {
                    ExecutionPath::bailOut(checks);
                    return;
                }

                // what variable ids should the if be counted for?
                std::set<unsigned int> countif;

                std::list<ExecutionPath *> newchecks;

                for (const Token* tok3 = tok2->next(); tok3; tok3 = tok3->next()) {
                    if (tok3->str() == "{")
                        tok3 = tok3->link();
                    else if (tok3->str() == "}")
                        break;
                    else if (tok3->str() == "case" &&
                             !Token::Match(tok3, "case %num% : ; case")) {
                        parseIfSwitchBody(tok3, checks, newchecks, countif);
                    }
                }

                // Add newchecks to checks..
                std::copy(newchecks.begin(), newchecks.end(), std::back_inserter(checks));

                // Increase numberOfIf
                std::list<ExecutionPath *>::iterator it;
                for (it = checks.begin(); it != checks.end(); ++it) {
                    if (countif.find((*it)->varId) != countif.end())
                        (*it)->numberOfIf++;
                }
            }
            // no switch
            else {
                for (const Token *tok3 = tok; tok3 && tok3 != tok2; tok3 = tok3->next()) {
                    if (tok3->varId())
                        ExecutionPath::bailOutVar(checks, tok3->varId());
                }

                // it is not certain that a for/while will be executed:
                for (std::list<ExecutionPath *>::iterator it = checks.begin(); it != checks.end();) {
                    if ((*it)->numberOfIf > 0) {
                        delete *it;
                        checks.erase(it++);
                    } else
                        ++it;
                }

                // #2231 - loop body only contains a conditional initialization..
                if (Token::simpleMatch(tok2->next(), "if (")) {
                    // Start { for the if block
                    const Token *tok3 = tok2->linkAt(2);
                    if (Token::simpleMatch(tok3,") {")) {
                        tok3 = tok3->next();

                        // End } for the if block
                        const Token *tok4 = tok3->link();
                        if (Token::Match(tok3, "{ %var% =") &&
                            Token::simpleMatch(tok4, "} }") &&
                            Token::simpleMatch(tok4->tokAt(-2), "break ;")) {
                            // Is there a assignment and then a break?
                            const Token *t = Token::findsimplematch(tok3, ";");
                            if (t && t->tokAt(3) == tok4) {
                                for (std::list<ExecutionPath *>::iterator it = checks.begin(); it != checks.end(); ++it) {
                                    if ((*it)->varId == tok3->next()->varId()) {
                                        (*it)->numberOfIf++;
                                        break;
                                    }
                                }
                                tok = tok2->link();
                                continue;
                            }
                        }
                    }
                }

                // parse loop bodies
                check->parseLoopBody(tok2->next(), checks);
            }

            // skip { .. }
            tok2 = tok2->link();

            // if "do { .. } while ( .." , goto end of while..
            if (Token::simpleMatch(tok, "do {") && Token::simpleMatch(tok2, "} while ("))
                tok2 = tok2->linkAt(2);

            // bail out all variables if the scope contains a "return"
            // bail out all variables used in this for/while/switch/do
            for (; tok && tok != tok2; tok = tok->next()) {
                if (tok->str() == "return")
                    ExecutionPath::bailOut(checks);
                if (tok->varId())
                    ExecutionPath::bailOutVar(checks, tok->varId());
            }

            continue;
        }

        // bailout used variables in '; FOREACH ( .. ) { .. }'
        else if (tok->str() != "if" && Token::Match(tok->previous(), "[;{}] %var% (")) {
            // goto {
            const Token *tok2 = tok->next()->link()->next();
            if (tok2 && tok2->str() == "{") {
                // goto "}"
                tok2 = tok2->link();

                // bail out all variables used in "{ .. }"
                for (; tok && tok != tok2; tok = tok->next()) {
                    if (tok->varId())
                        ExecutionPath::bailOutVar(checks, tok->varId());
                }
                if (!tok)
                    break;
            }
        }

        // .. ) { ... }  => bail out
        if (tok->str() == ")" && tok->next() && tok->next()->str() == "{") {
            ExecutionPath::bailOut(checks);
            return;
        }

        if ((tok->str() == "abort" || tok->str() == "exit") &&
            tok->next() && tok->next()->str() == "(") {
            ExecutionPath::bailOut(checks);
            return;
        }

        // don't parse into "struct type { .."
        if (Token::Match(tok, "struct|union|class %type% {|:")) {
            while (tok && tok->str() != "{" && tok->str() != ";")
                tok = tok->next();
            tok = tok ? tok->link() : 0;
            if (!tok) {
                ExecutionPath::bailOut(checks);
                return;
            }
        }

        if (Token::simpleMatch(tok, "= {")) {
            // GCC struct initialization.. bail out
            if (Token::Match(tok->tokAt(2), ". %var% =")) {
                ExecutionPath::bailOut(checks);
                return;
            }

            const Token * const end = tok->next()->link();
            while (tok && tok != end) {
                if (Token::Match(tok, "[{,] & %var% [,}]"))
                    ExecutionPath::bailOutVar(checks, tok->tokAt(2)->varId());
                tok = tok->next();
            }
            if (!tok) {
                ExecutionPath::bailOut(checks);
                return;
            }
            continue;
        }

        // ; { ... }
        if (Token::Match(tok->previous(), "[;{}:] {")) {
            ExecutionPath::checkScope(tok->next(), checks);
            tok = tok->link();
            continue;
        }

        if (tok->str() == "if" && tok->next() && tok->next()->str() == "(") {
            // what variable ids should the numberOfIf be counted for?
            std::set<unsigned int> countif;

            std::list<ExecutionPath *> newchecks;
            while (tok->str() == "if" && tok->next() && tok->next()->str() == "(") {
                // goto "("
                tok = tok->next();

                // parse condition
                if (checks.size() > 10 || check->parseCondition(*tok->next(), checks)) {
                    ExecutionPath::bailOut(checks);
                    ExecutionPath::bailOut(newchecks);
                    return;
                }

                // goto ")"
                tok = tok->link();

                // goto "{"
                tok = tok->next();

                if (!tok || tok->str() != "{") {
                    ExecutionPath::bailOut(checks);
                    ExecutionPath::bailOut(newchecks);
                    return;
                }

                // Recursively check into the if ..
                parseIfSwitchBody(tok->next(), checks, newchecks, countif);

                // goto "}"
                tok = tok->link();

                // there is no else => break out
                if (!tok->next() || tok->next()->str() != "else")
                    break;

                // parse next "if"..
                tok = tok->tokAt(2);
                if (!tok) {
                    ExecutionPath::bailOut(newchecks);
                    return;
                }
                if (tok->str() == "if")
                    continue;

                // there is no "if"..
                ExecutionPath::checkScope(tok->next(), checks);
                tok = tok->link();
                if (!tok) {
                    ExecutionPath::bailOut(newchecks);
                    return;
                }
            }

            // Add newchecks to checks..
            std::copy(newchecks.begin(), newchecks.end(), std::back_inserter(checks));

            // Increase numberOfIf
            std::list<ExecutionPath *>::iterator it;
            for (it = checks.begin(); it != checks.end(); ++it) {
                if (countif.find((*it)->varId) != countif.end())
                    (*it)->numberOfIf++;
            }

            // Delete checks that have numberOfIf >= 2
            for (it = checks.begin(); it != checks.end();) {
                if ((*it)->varId > 0 && (*it)->numberOfIf >= 2) {
                    delete *it;
                    checks.erase(it++);
                } else {
                    ++it;
                }
            }
        }

        tok = check->parse(*tok, checks);
        if (!tok || checks.empty())
            return;

        // return/throw ends all execution paths
        if (tok->str() == "return" ||
            tok->str() == "throw" ||
            tok->str() == "continue" ||
            tok->str() == "break") {
            ExecutionPath::bailOut(checks);
        }
    }
}
// shunting yard algorithm
double evaluate(std::list<std::string> &tokens) {
  std::stack<double> operands;
  std::stack<std::string> operators;
  while (!tokens.empty()) {
    if (!isANumber(tokens.front())) {
      // token is an operator
      std::string poppedOperator = tokens.front();
      tokens.pop_front();
      if (operators.empty()) {
        // empty operator stack, just push it on
        operators.push(poppedOperator);
      } else if (poppedOperator == "(") {
        // left paren, just push it on
        operators.push(poppedOperator);
      } else if (poppedOperator == ")") {
        // right paren, pop off and apply all operators until we find the left paren
        while (operators.top() != "(") {
          double operandTwo = operands.top();
          operands.pop();
          double operandOne = operands.top();
          operands.pop();
          std::string operatorToApply = operators.top();
          operators.pop();
          double newOperand = applyOperatorToOperands(operandOne, operandTwo, operatorToApply);
          operands.push(newOperand);
        }
        // found the left paren, pop it off
        if (!operators.empty()) {
          operators.pop();
        }
        // check for unary operator -
        if (!operators.empty()) {
          if (operators.top() == "-" && operands.size() == 1) {
            // apply unary operator -
            double operand = operands.top();
            operands.pop();
            operators.pop();
            operands.push(operand * -1);
          }
        }
      } else if (tokens.front() == "(") {
        // corner case, singly parened number
        operators.push(poppedOperator);
      } else {
        // check for operator precedence
        while (topOfStackHasHigherOrEqualPrecedenceThanOperator(poppedOperator, operators)) {
          double operandTwo = operands.top();
          operands.pop();
          double operandOne = operands.top();
          operands.pop();
          std::string operatorToApply = operators.top();
          operators.pop();
          double newOperand = applyOperatorToOperands(operandOne, operandTwo, operatorToApply);
          operands.push(newOperand);
        }
        // precedence cleared, push operator
        operators.push(poppedOperator);
      }
    } else {
      // token is a number, push to operand stack
      operands.push(toDouble(tokens.front()));
      tokens.pop_front();
    }
  }
// end of token list, apply all remaining operators
  while (!operators.empty()) {
    double operandTwo = operands.top();
    operands.pop();
    double operandOne = operands.top();
    operands.pop();
    std::cout << operandOne << " " << operandTwo << " " << operators.top() << std::endl;
    std::string operatorToApply = operators.top();
    operators.pop();
    double newOperand = applyOperatorToOperands(operandOne, operandTwo, operatorToApply);
    operands.push(newOperand);
  }
  return operands.top();
}
Example #24
0
Tree::Expr
ConsDefWS::group(const std::list<EquationDefinition>& defs)
{
  if (defs.size() != 1)
  {
    throw "too many definitions";
  }

  auto& cons = get<Parser::ConstructorDecl>(*defs.front().parsed());

  Tree::TupleExpr::TuplePairs pairs
  {
    {Tree::DimensionExpr{DIM_TYPE}, cons.type},
    {Tree::DimensionExpr{DIM_CONS}, cons.name}
  };

  std::map<u32string, dimension_index> rewrites;
  std::vector<dimension_index> dims;

  for (size_t i = 0; i != cons.args.size(); ++i)
  {
    std::ostringstream argos;
    argos << "arg" << i;
    pairs.push_back(std::make_pair(
      Tree::DimensionExpr(utf8_to_utf32(argos.str())),
      Tree::IdentExpr(cons.args[i])
    ));

    auto dim = m_system.nextHiddenDim();

    dims.push_back(dim);

    rewrites.insert({cons.args[i], dim});
  }

  Tree::Expr guard = fixupGuardArgs(cons.guard, rewrites);

  Tree::ConditionalBestfitExpr cond;
  cond.declarations.push_back(std::make_tuple
  (
    defs.front().start(),
    guard,
    Tree::Expr(),
    Tree::TupleExpr{pairs}
  ));

  Tree::Expr abstractions = cond;

  auto dimIter = dims.rbegin();
  for (auto argsIter = cons.args.rbegin();
       argsIter != cons.args.rend();
       ++argsIter, ++dimIter)
  {
    auto base = Tree::BaseAbstractionExpr(*argsIter, abstractions);
    base.dims.push_back(*dimIter);

    abstractions = std::move(base);
  }

  return abstractions;
}
Example #25
0
    void syncFixUp(OperationContext* txn,
                   FixUpInfo& fixUpInfo,
                   OplogReader* oplogreader,
                   ReplicationCoordinator* replCoord) {
        DBClientConnection* them = oplogreader->conn();

        // fetch all first so we needn't handle interruption in a fancy way

        unsigned long long totalSize = 0;

        list< pair<DocID, BSONObj> > goodVersions;

        BSONObj newMinValid;

        // fetch all the goodVersions of each document from current primary
        DocID doc;
        unsigned long long numFetched = 0;
        try {
            for (set<DocID>::iterator it = fixUpInfo.toRefetch.begin();
                    it != fixUpInfo.toRefetch.end();
                    it++) {
                doc = *it;

                verify(!doc._id.eoo());

                {
                    // TODO : slow.  lots of round trips.
                    numFetched++;
                    BSONObj good = them->findOne(doc.ns, doc._id.wrap(),
                                                     NULL, QueryOption_SlaveOk).getOwned();
                    totalSize += good.objsize();
                    uassert(13410, "replSet too much data to roll back",
                            totalSize < 300 * 1024 * 1024);

                    // note good might be eoo, indicating we should delete it
                    goodVersions.push_back(pair<DocID, BSONObj>(doc,good));
                }
            }
            newMinValid = oplogreader->getLastOp(rsOplogName);
            if (newMinValid.isEmpty()) {
                error() << "rollback error newMinValid empty?";
                return;
            }
        }
        catch (DBException& e) {
            LOG(1) << "rollback re-get objects: " << e.toString();
            error() << "rollback couldn't re-get ns:" << doc.ns << " _id:" << doc._id << ' '
                    << numFetched << '/' << fixUpInfo.toRefetch.size();
            throw e;
        }

        log() << "rollback 3.5";
        if (fixUpInfo.rbid != getRBID(oplogreader->conn())) {
            // our source rolled back itself.  so the data we received isn't necessarily consistent.
            warning() << "rollback rbid on source changed during rollback, cancelling this attempt";
            return;
        }

        // update them
        log() << "rollback 4 n:" << goodVersions.size();

        bool warn = false;

        invariant(!fixUpInfo.commonPointOurDiskloc.isNull());
        invariant(txn->lockState()->isW());

        // we have items we are writing that aren't from a point-in-time.  thus best not to come
        // online until we get to that point in freshness.
        Timestamp minValid = newMinValid["ts"].timestamp();
        log() << "minvalid=" << minValid.toStringLong();
        setMinValid(txn, minValid);

        // any full collection resyncs required?
        if (!fixUpInfo.collectionsToResyncData.empty()
                || !fixUpInfo.collectionsToResyncMetadata.empty()) {

            for (const string& ns : fixUpInfo.collectionsToResyncData) {
                log() << "rollback 4.1.1 coll resync " << ns;

                fixUpInfo.collectionsToResyncMetadata.erase(ns);

                const NamespaceString nss(ns);

                Database* db = dbHolder().openDb(txn, nss.db().toString());
                invariant(db);

                {
                    WriteUnitOfWork wunit(txn);
                    db->dropCollection(txn, ns);
                    wunit.commit();
                }

                {
                    string errmsg;

                    // This comes as a GlobalWrite lock, so there is no DB to be acquired after
                    // resume, so we can skip the DB stability checks. Also 
                    // copyCollectionFromRemote will acquire its own database pointer, under the
                    // appropriate locks, so just releasing and acquiring the lock is safe.
                    invariant(txn->lockState()->isW());
                    Lock::TempRelease release(txn->lockState());

                    bool ok = copyCollectionFromRemote(txn, them->getServerAddress(), ns, errmsg);
                    uassert(15909, str::stream() << "replSet rollback error resyncing collection "
                                                 << ns << ' ' << errmsg, ok);
                }
            }

            for (const string& ns : fixUpInfo.collectionsToResyncMetadata) {
                log() << "rollback 4.1.2 coll metadata resync " << ns;

                const NamespaceString nss(ns);
                auto db = dbHolder().openDb(txn, nss.db().toString());
                invariant(db);
                auto collection = db->getCollection(ns);
                invariant(collection);
                auto cce = collection->getCatalogEntry();

                const std::list<BSONObj> info =
                    them->getCollectionInfos(nss.db().toString(), BSON("name" << nss.coll()));

                if (info.empty()) {
                    // Collection dropped by "them" so we should drop it too.
                    log() << ns << " not found on remote host, dropping";
                    fixUpInfo.toDrop.insert(ns);
                    continue;
                }

                invariant(info.size() == 1);

                CollectionOptions options;
                auto status = options.parse(info.front());
                if (!status.isOK()) {
                    throw RSFatalException(str::stream() << "Failed to parse options "
                                                         << info.front() << ": "
                                                         << status.toString());
                }

                WriteUnitOfWork wuow(txn);
                if (options.flagsSet || cce->getCollectionOptions(txn).flagsSet) {
                    cce->updateFlags(txn, options.flags);
                }

                status = collection->setValidator(txn, options.validator);
                if (!status.isOK()) {
                    throw RSFatalException(str::stream() << "Failed to set validator: "
                                                         << status.toString());
                }
                wuow.commit();
            }

            // we did more reading from primary, so check it again for a rollback (which would mess
            // us up), and make minValid newer.
            log() << "rollback 4.2";

            string err;
            try {
                newMinValid = oplogreader->getLastOp(rsOplogName);
                if (newMinValid.isEmpty()) {
                    err = "can't get minvalid from sync source";
                }
                else {
                    Timestamp minValid = newMinValid["ts"].timestamp();
                    log() << "minvalid=" << minValid.toStringLong();
                    setMinValid(txn, minValid);
                }
            }
            catch (DBException& e) {
                err = "can't get/set minvalid: ";
                err += e.what();
            }
            if (fixUpInfo.rbid != getRBID(oplogreader->conn())) {
                // our source rolled back itself.  so the data we received isn't necessarily
                // consistent. however, we've now done writes.  thus we have a problem.
                err += "rbid at primary changed during resync/rollback";
            }
            if (!err.empty()) {
                severe() << "rolling back : " << err
                        << ". A full resync will be necessary.";
                // TODO: reset minvalid so that we are permanently in fatal state
                // TODO: don't be fatal, but rather, get all the data first.
                throw RSFatalException();
            }
            log() << "rollback 4.3";
        }

        map<string,shared_ptr<Helpers::RemoveSaver> > removeSavers;

        log() << "rollback 4.6";
        // drop collections to drop before doing individual fixups - that might make things faster
        // below actually if there were subsequent inserts to rollback
        for (set<string>::iterator it = fixUpInfo.toDrop.begin();
                it != fixUpInfo.toDrop.end();
                it++) {
            log() << "rollback drop: " << *it;

            Database* db = dbHolder().get(txn, nsToDatabaseSubstring(*it));
            if (db) {
                WriteUnitOfWork wunit(txn);

                shared_ptr<Helpers::RemoveSaver>& removeSaver = removeSavers[*it];
                if (!removeSaver)
                    removeSaver.reset(new Helpers::RemoveSaver("rollback", "", *it));

                // perform a collection scan and write all documents in the collection to disk
                boost::scoped_ptr<PlanExecutor> exec(
                        InternalPlanner::collectionScan(txn,
                                                        *it,
                                                        db->getCollection(*it)));
                BSONObj curObj;
                PlanExecutor::ExecState execState;
                while (PlanExecutor::ADVANCED == (execState = exec->getNext(&curObj, NULL))) {
                    removeSaver->goingToDelete(curObj);
                }
                if (execState != PlanExecutor::IS_EOF) {
                    if (execState == PlanExecutor::FAILURE &&
                            WorkingSetCommon::isValidStatusMemberObject(curObj)) {
                        Status errorStatus = WorkingSetCommon::getMemberObjectStatus(curObj);
                        severe() << "rolling back createCollection on " << *it
                                 << " failed with " << errorStatus
                                 << ". A full resync is necessary.";
                    }
                    else {
                        severe() << "rolling back createCollection on " << *it
                                 << " failed. A full resync is necessary.";
                    }
                            
                    throw RSFatalException();
                }

                db->dropCollection(txn, *it);
                wunit.commit();
            }
        }

        log() << "rollback 4.7";
        OldClientContext ctx(txn, rsOplogName);
        Collection* oplogCollection = ctx.db()->getCollection(rsOplogName);
        uassert(13423,
                str::stream() << "replSet error in rollback can't find " << rsOplogName,
                oplogCollection);

        unsigned deletes = 0, updates = 0;
        time_t lastProgressUpdate = time(0);
        time_t progressUpdateGap = 10;
        for (list<pair<DocID, BSONObj> >::iterator it = goodVersions.begin();
                it != goodVersions.end();
                it++) {
            time_t now = time(0);
            if (now - lastProgressUpdate > progressUpdateGap) {
                log() << deletes << " delete and "
                      << updates << " update operations processed out of "
                      << goodVersions.size() << " total operations";
                lastProgressUpdate = now;
            }
            const DocID& doc = it->first;
            BSONObj pattern = doc._id.wrap(); // { _id : ... }
            try {
                verify(doc.ns && *doc.ns);
                if (fixUpInfo.collectionsToResyncData.count(doc.ns)) {
                    // we just synced this entire collection
                    continue;
                }

                // keep an archive of items rolled back
                shared_ptr<Helpers::RemoveSaver>& removeSaver = removeSavers[doc.ns];
                if (!removeSaver)
                    removeSaver.reset(new Helpers::RemoveSaver("rollback", "", doc.ns));

                // todo: lots of overhead in context, this can be faster
                OldClientContext ctx(txn, doc.ns);

                // Add the doc to our rollback file
                BSONObj obj;
                Collection* collection = ctx.db()->getCollection(doc.ns);

                // Do not log an error when undoing an insert on a no longer existent collection.
                // It is likely that the collection was dropped as part of rolling back a
                // createCollection command and regardless, the document no longer exists.
                if (collection) {
                    bool found = Helpers::findOne(txn, collection, pattern, obj, false);
                    if (found) {
                        removeSaver->goingToDelete(obj);
                    }
                    else {
                        error() << "rollback cannot find object: " << pattern
                                << " in namespace " << doc.ns;
                    }
                }

                if (it->second.isEmpty()) {
                    // wasn't on the primary; delete.
                    // TODO 1.6 : can't delete from a capped collection.  need to handle that here.
                    deletes++;

                    if (collection) {
                        if (collection->isCapped()) {
                            // can't delete from a capped collection - so we truncate instead. if
                            // this item must go, so must all successors!!!
                            try {
                                // TODO: IIRC cappedTruncateAfter does not handle completely empty.
                                // this will crazy slow if no _id index.
                                long long start = Listener::getElapsedTimeMillis();
                                RecordId loc = Helpers::findOne(txn, collection, pattern, false);
                                if (Listener::getElapsedTimeMillis() - start > 200)
                                    warning() << "roll back slow no _id index for "
                                          << doc.ns << " perhaps?";
                                // would be faster but requires index:
                                // RecordId loc = Helpers::findById(nsd, pattern);
                                if (!loc.isNull()) {
                                    try {
                                        collection->temp_cappedTruncateAfter(txn, loc, true);
                                    }
                                    catch (DBException& e) {
                                        if (e.getCode() == 13415) {
                                            // hack: need to just make cappedTruncate do this...
                                            MONGO_WRITE_CONFLICT_RETRY_LOOP_BEGIN {
                                                WriteUnitOfWork wunit(txn);
                                                uassertStatusOK(collection->truncate(txn));
                                                wunit.commit();
                                            } MONGO_WRITE_CONFLICT_RETRY_LOOP_END(
                                                                            txn,
                                                                            "truncate",
                                                                            collection->ns().ns());
                                        }
                                        else {
                                            throw e;
                                        }
                                    }
                                }
                            }
                            catch (DBException& e) {
                                error() << "rolling back capped collection rec "
                                      << doc.ns << ' ' << e.toString();
                            }
                        }
                        else {
Example #26
0
//============================================================================
void plNetLinkingMgr::ExecNextOp () {
    plNetLinkingMgr * lm = plNetLinkingMgr::GetInstance();

    if (!s_opqueue.size())
        return;

    NlmOp* op = s_opqueue.front();

    switch (op->opcode) {
        case kNlmOpNoOp:
            break;

        case kNlmOpWaitOp:
            return; // don't allow wait op to be unlinked/deleted from list

        case kNlmOpJoinAgeOp: {
            ASSERT(!s_ageJoiner);
            ASSERT(!s_ageLeaver);

            // Insert a wait operation into the exec queue
            NlmOpWaitOp * waitOp = new NlmOpWaitOp;
            QueueOp(waitOp, true);

            NlmJoinAgeOp * joinAgeOp = (NlmJoinAgeOp *)op;
            NCAgeJoinerCreate(
                &s_ageJoiner,
                joinAgeOp->age,
                joinAgeOp->muteSfx,
                NCAgeJoinerCallback,
                waitOp
            );
        }
        break;

        case kNlmOpLeaveAgeOp: {
            ASSERT(!s_ageJoiner);
            ASSERT(!s_ageLeaver);

            // Insert a wait operation into the exec queue
            NlmOpWaitOp * waitOp = new NlmOpWaitOp;
            QueueOp(waitOp, true);

            lm->SetEnabled(false);
            lm->fLinkedIn = false;

            NlmLeaveAgeOp * leaveAgeOp = (NlmLeaveAgeOp *)op;
            NCAgeLeaverCreate(
                &s_ageLeaver,
                leaveAgeOp->quitting,
                leaveAgeOp->muteSfx,
                NCAgeLeaverCallback,
                waitOp
            );
        }
        break;

        default:
            break;
    }

    s_opqueue.remove(op);
    delete op;
}
Example #27
0
int main(int argc, char *argv[])
{
	if (argc < 4) {
		return 1;
	}

	long processNum = atoi(argv[4]);
	long threadNum = atoi(argv[3]);
	long dtime = atol(argv[2]) * 1000;
	char* testName = argv[1];
	long cycles = 0;
	Task task = get_test(testName, doneTask);
	int pipefd[2];

	// open pipe
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

	for (long i = 0; i < processNum; ++i) {
		if (fork() != 0) {
			continue;
		}

		// close unused read end
		close(pipefd[0]);

		pthread_mutexattr_t test4_mutexattr;
		pthread_mutex_init(&test4_mutex, &test4_mutexattr);

		pthread_attr_t attr;
		pthread_attr_init(&attr);
		pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN * 8);

		pthread_mutexattr_t mutexattr;
		pthread_mutex_init(&mutex, &mutexattr);

		pthread_condattr_t condattr;
		pthread_cond_init(&cond, &condattr);

		int rc = 0;
		pthread_t pid;

		if ((rc = pthread_mutex_lock(&mutex)) != 0) {
			std::cout << "pthread_mutex_lock " << rc << " " << strerror(rc) << std::endl;
			return 3;
		}

		time_start();
		bool working = true;
		while ((working = (time_stop() < dtime)) || workingNum) {
			for (long i = workingNum; i < threadNum; ++i) {
				if ((rc = pthread_create(&pid, &attr, task, NULL)) != 0) {
					std::cout << "pthread_create " << rc << " " << strerror(rc) << std::endl;
					return 2;
				}
				++workingNum;
			}

			if (workingNum == threadNum) {
				if ((rc = pthread_cond_wait(&cond, &mutex)) != 0) {
					std::cout << "pthread_cond_wait " << rc << " " << strerror(rc) << std::endl;
					return 3;
				}
			}
			//pthread_join(pids.front(), NULL);
			//pids.pop_front();
			cycles += threadNum - workingNum;
			if (!working) {
				threadNum = workingNum;
			}

			while (!terminated_pids.empty()) {
				pthread_detach(terminated_pids.front());
				terminated_pids.pop_front();
			}
		}
		//cycles += workingNum;

		if ((rc = pthread_mutex_unlock(&mutex)) != 0) {
			std::cout << "pthread_mutex_unlock " << rc << " " << strerror(rc) << std::endl;
			return 3;
		}

		write(pipefd[1], &cycles, sizeof(cycles));
		close(pipefd[1]);

		return 0;
	}

	// close unused write end
	close(pipefd[1]);

	long double result = 0;
	while (read(pipefd[0], &cycles, sizeof(cycles)) > 0) {
		result += cycles;
	}
	close(pipefd[0]);

	std::cout << ((long double) result * 1000) / dtime << std::endl;

	return 0;
}
Example #28
0
    virtual void perform() {
      for(;;) { // forever

        BackgroundCompileRequest* req = 0;

        // Lock, wait, get a request, unlock
        {
          thread::Mutex::LockGuard guard(mutex_);

          if(pause_) {
            state = cPaused;

            paused_ = true;
            pause_condition_.signal();

            while(pause_) {
              condition_.wait(mutex_);
            }

            state = cUnknown;
            paused_ = false;
          }

          // If we've been asked to stop, do so now.
          if(stop_) return;

          while(pending_requests_.size() == 0) {
            state = cIdle;

            // unlock and wait...
            condition_.wait(mutex_);

            if(stop_) return;
          }

          // now locked again, shift a request
          req = pending_requests_.front();
          pending_requests_.pop_front();

          state = cRunning;
        }

        // mutex now unlock, allowing others to push more requests
        //


        LLVMCompiler* jit = new LLVMCompiler();

        {
          timer::Running timer(ls_->time_spent);
          jit->compile(ls_, req->vmmethod(), req->is_block());
          jit->generate_function(ls_);
        }

        if(show_machine_code_) {
          jit->show_machine_code();
        }

        // Ok, compiled, generated machine code, now update MachineMethod

        // Ok, now we are manipulating managed memory, so make
        // sure the GC doesn't run.
        ls_->shared().gc_dependent();

        req->vmmethod()->set_jitted(jit->llvm_function(),
                                    jit->code_bytes(),
                                    jit->function_pointer());

        if(req->is_block()) {
          BlockEnvironment* be = req->block_env();
          if(!be) {
            llvm::outs() << "Fatal error in JIT. Expected a BlockEnvironment.\n";
          } else {
            be->set_native_function(jit->function_pointer());
          }
        } else {
          MachineMethod* mm = req->machine_method();
          if(!mm) {
            llvm::outs() << "Fatal error in JIT. Expected a MachineMethod.\n";
          } else {
            mm->update(req->vmmethod(), jit);
            mm->activate();
          }
        }

        int which = ls_->add_jitted_method();
        if(ls_->config().jit_show_compiling) {
          llvm::outs() << "[[[ JIT finished background compiling "
                    << which
                    << (req->is_block() ? " (block)" : " (method)")
                    << " ]]]\n";
        }

        delete req;

        // We don't depend on the GC here, so let it run independent
        // of us.
        ls_->shared().gc_independent();
      }
    }
Example #29
0
	//From still, decide what the next mode should be
	int decideNextMode() {

        out_twist.linear.x = 0.0;
        out_twist.angular.z = 0.0;
		
		if (followsPath) {
            ROS_INFO("following path");
			
			//Check if we have arrived
			if (fabs(curPosOri.linear.x - targetPos.x) <= NODE_DIST_LIMIT && 
			fabs(curPosOri.linear.y - targetPos.y) <= NODE_DIST_LIMIT) {
				//Close enough
                ROS_INFO("reached node (%f, %f)", targetPos.x, targetPos.y);

                if(path.empty()){
                    ROS_INFO("reached end of path - go to STRAIGHT_FORWARD");
                    mode = STRAIGHT_FORWARD;
                    prevmode = STILL;
                    followsPath = false;
                    return mode;
                }

				//Compute direction to next node
				geometry_msgs::Point next = path.front();
				ROS_INFO("target position: (%f, %f)", next.x, next.y);
				ROS_INFO("current position: (%f, %f)", curPosOri.linear.x, curPosOri.linear.y);

                while(fabs(curPosOri.linear.x - next.x) <= NODE_DIST_LIMIT &&
                      fabs(curPosOri.linear.y - next.y) <= NODE_DIST_LIMIT){
                    //possible dirty bugfix, check if next node is already reached
                    if(path.empty()){
                        ROS_INFO("reached end of path - go to STRAIGHT_FORWARD");
                        mode = STRAIGHT_FORWARD;
                        prevmode = STILL;
                        followsPath = false;
                        return mode;
                    }
                    ROS_INFO("removing close points from path");
                    path.pop_front();
                    next = path.front();

                    ROS_INFO("target position: (%f, %f)", next.x, next.y);
                    ROS_INFO("current position: (%f, %f)", curPosOri.linear.x, curPosOri.linear.y);
                }

				int dir;
                ROS_INFO("x diff: %f", fabs(curPosOri.linear.x - next.x));
                ROS_INFO("y diff: %f", fabs(curPosOri.linear.y - next.y));
				if (fabs(curPosOri.linear.x - next.x) > fabs(curPosOri.linear.y - next.y)) {
					if (curPosOri.linear.x > next.x) {
						dir = 0;	//west
					} else {
						dir = 2;	//east
					}
				} else {
					if (curPosOri.linear.y > next.y) {
						dir = 1;	//south
					} else {
						dir = 3;	//north
					}
				}
				int curDir = (int)(floor(angle/(PI/2.0)+0.5));	//Find the closest NSWE orientation
				if (curDir >= 0) {
					curDir = curDir % 4;
				} else {
					curDir = (curDir + 400000000) % 4;
				}

				ROS_INFO("current direction: %d, target direction: %d", curDir, dir);
				
				if (dir == curDir) {	//No turn required
					targetPos = path.front();
					path.pop_front();
                    mode = STRAIGHT_FORWARD;
//					if (path.empty()) {
//						//We are facing the final node, which should hold the object.
//						//We shouldn't go there - just observe from where we are standing.
//						//TODO Decide what to do next. I don't know if we will be given a new object
//						//to find the path to, or if something else should be done.
						
//						mode = STRAIGHT_FORWARD;
						
//					} else {
//						mode = STRAIGHT_FORWARD;
//					}
				} else if (dir == (curDir+1)%4) {	//Rotate left
					mode = LEFT_ROTATE;
					prevmode = STILL;
                    targetAngle = floor((angle/(PI/2.0))+0.5) * PI/2.0 + PI/2.0;
				} else if ((dir+1)%4 == curDir) {	//Rotate right
					mode = RIGHT_ROTATE;
					prevmode = STILL;
                    targetAngle = floor((angle/(PI/2.0))+0.5) * PI/2.0 - PI/2.0;
				} else {	//Rotate left, continuing 180 degrees.
					mode = LEFT_ROTATE;
					prevmode = STILL;
                    targetAngle = floor((angle/(PI/2.0))+0.5) * PI/2.0 + PI/2.0;
				}
                return mode;
			}			
		}
		
		out_twist.linear.x = 0.0;
		out_twist.angular.z = 0.0;			
		if (delta_enc[0] != 0 || delta_enc[1] != 0) {
			//Do nothing
			ROS_INFO("still in still");
			return STILL;
		}
		
		//Rohit: check the previous mode and accordingly decide the next mode	 
		if (prevmode==RIGHT_WALL_ALIGN){ 	
			prevmode=mode;
			rightBool1 = true;
			leftBool1 = true; 
			mode = RIGHT_WALL_FOLLOW;
				
		}
		
		else if (prevmode==LEFT_WALL_ALIGN){	
			prevmode=mode;
			leftBool1 = true;
			rightBool1 = true;
			mode = LEFT_WALL_FOLLOW;
									
		}

		else if(prevmode==LEFT_ROTATE){
			prevmode=mode;
			mode = RIGHT_WALL_ALIGN;
		}

		else if(prevmode==RIGHT_ROTATE){
			prevmode=mode;
			mode = LEFT_WALL_ALIGN;
		}
		
		else if (in_ir.front_left > IR_SHORT_LIMIT || in_ir.back_left > IR_SHORT_LIMIT) {
			prevmode=mode;
			mode = LEFT_ROTATE;
			targetAngle = floor((angle/(PI/2.0))+0.5) * PI/2.0 + PI/2.0;
			//ROS_INFO("target Angle = %lf", (targetAngle*360)/TWOPI);
			//ROS_INFO("Left rotate:First if");
		} else if (in_ir.front_right > IR_SHORT_LIMIT || in_ir.back_right > IR_SHORT_LIMIT) {
			prevmode=mode;
			mode = RIGHT_ROTATE;
			targetAngle = floor((angle/(PI/2.0))+0.5) * PI/2.0 - PI/2.0;
			//ROS_INFO("target Angle = %lf", (targetAngle*360)/TWOPI);
		} else {
			//TODO go back
			prevmode=mode;
			mode = LEFT_ROTATE;
			targetAngle = floor((angle/(PI/2.0))+0.5) * PI/2.0 + PI/2.0;
			//ROS_INFO("target Angle = %lf", (targetAngle*360)/TWOPI);
			//ROS_INFO("Left rotate:Second if");
		}

		return mode;
	}
Example #30
0
void GLRenderer::doBucketing(std::list<GLRenderListItem*> &ltb) {
	
	GLRenderListBucketItem *bucket;
	GLRenderListItem *cur;
	
	if(ltb.empty())
		return;
	
	cur = ltb.front();
	
	Console_DPrintf("bucketing list of %d elements\n", ltb.size());
	
	while(typeid(*cur) == typeid(GLRenderListMeshItem)) {
		ltb.pop_front();
		bucket = addListItemToBucket(cur, ltb);
		
		for(std::list<GLRenderListItem*>::iterator itr = ltb.begin(); itr != ltb.end(); itr++) {
			if(typeid(GLRenderListMeshItem) == typeid(**itr) && bucket->equals(*itr)) {
				bucket->add(*itr);
				itr = ltb.erase(itr);
			}
		}
		
		cur = ltb.front();
		Console_DPrintf("bucketing...\n");
	}
	
	Console_DPrintf("bucketed list of %d elements\n", ltb.size());
	
	/*int bucketSize=0;
	std::list<GLRenderListItem*>::iterator itr = ltb.begin();
	std::list<GLRenderListItem*>::iterator start = itr;
	
	for(itr++; itr != ltb.end(); itr++) {
		if(typeid(GLRenderListMeshItem) == typeid(**start) && typeid(**start) == typeid(**itr)) {
			GLRenderListMeshItem *s = dynamic_cast<GLRenderListMeshItem*>(*start);
			GLRenderListMeshItem *e = dynamic_cast<GLRenderListMeshItem*>(*itr);
			
			if(s->getMesh() != e->getMesh()) {
				if(bucketSize>1) {
					std::list<GLRenderListItem*> l;
					
					l.splice(l.begin(), ltb, start, itr);
					
					//Console_DPrintf("Created bucket[%d] of size %d\n", bucketCount, bucketSize);
					
					//bucket it!
					buckets[bucketCount].setMaterial(s->getMaterial());
					buckets[bucketCount].add(l);
					
					if(s->getSceneObject()->model>0)
						buckets[bucketCount].setModel(s->getSceneObject()->model);
					
					ltb.insert(itr, &buckets[bucketCount]);
					
					bucketCount++;
				}
				bucketSize=0;
				start = itr;
			} else {
				bucketSize++;
			}
		} else {
			bucketSize=0;
			start = itr;
		}
	}*/
}