Ejemplo n.º 1
0
void cache_control::drain()
{
	while (true)
	{
		std::shared_ptr<file_ma> target;

		while (true)
		{
			lock_guard<std::mutex> _lock(task_lock);

			if (terminal)
				return;

			if (priority_queue.empty())
			{
				if (total_cache_size < max_cache_size)
					start_drain.wait(task_lock);
				else
				{
					auto res = std::max_element(cache_set.begin(), cache_set.end(), [](const std::shared_ptr<file_ma> &a, const std::shared_ptr<file_ma> &b) {
						return a->getcachesize() < b->getcachesize();
					});
					if (res != cache_set.end())
					{
						target = *res;
						break;
					}
				}
			}
			else
			{
				auto x = priority_queue.begin();
				target = std::move(*x);
				priority_queue.erase(x);
				break;
			}
		}

		assert(target);

		_DEBUG_OUT("task[%p] start drain,%u had cached\n", target->parent->get_guid(), total_cache_size.load());
		target->do_write_back();
		_DEBUG_OUT("%u left\n", total_cache_size.load());
	}
}
Ejemplo n.º 2
0
  qi::Future<void> RemoteObject::metaDisconnect(SignalLink linkId)
  {
    unsigned int event = linkId >> 32;
    //disconnect locally
    qi::Future<void> fut = DynamicObject::metaDisconnect(linkId);
    if (fut.hasError())
    {
      std::stringstream ss;
      ss << "Disconnection failure for " << linkId << ", error:" << fut.error();
      qiLogWarning() << ss.str();
      return qi::makeFutureError<void>(ss.str());
    }

    boost::recursive_mutex::scoped_lock _lock(_localToRemoteSignalLinkMutex);
    LocalToRemoteSignalLinkMap::iterator it;
    it = _localToRemoteSignalLink.find(event);
    if (it == _localToRemoteSignalLink.end()) {
      qiLogWarning() << "Cant find " << event << " in the localtoremote signal map";
      return fut;
    }
    qi::SignalLink toDisco = qi::SignalBase::invalidSignalLink;
    {
      RemoteSignalLinks &rsl = it->second;
      std::vector<SignalLink>::iterator vslit;
      vslit = std::find(rsl.localSignalLink.begin(), rsl.localSignalLink.end(), linkId);

      if (vslit != rsl.localSignalLink.end()) {
        rsl.localSignalLink.erase(vslit);
      } else {
        qiLogWarning() << "Cant find " << linkId << " in the remote signal vector (event:" << event << ")";
      }

      //only drop the remote connection when no more local connection are registered
      if (rsl.localSignalLink.size() == 0) {
        toDisco = rsl.remoteSignalLink;
        _localToRemoteSignalLink.erase(it);
      }
    }
    if (toDisco != qi::SignalBase::invalidSignalLink) {
      TransportSocketPtr sock = _socket;
      if (sock && sock->isConnected())
        return _self.async<void>("unregisterEvent", _service, event, toDisco);
    }
    return fut;
  }
Ejemplo n.º 3
0
//++ ------------------------------------------------------------------------------------
// Details: Wait for thread to stop.
// Type:    Method.
// Args:    None.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMIUtilThread::Join()
{
    if (m_pThread != nullptr)
    {
        // Wait for this thread to die
        m_pThread->join();

        // Scope the thread lock while we modify the pointer
        {
            CMIUtilThreadLock _lock(m_mutex);
            delete m_pThread;
            m_pThread = nullptr;
        }
    }

    return MIstatus::success;
}
Ejemplo n.º 4
0
MBOOL
IPostProcPipeBridge::
init()
{
    MBOOL   ret = MTRUE;
    Mutex::Autolock _lock(mLock);

    if  ( 0 != mu4InitRefCount )
    {
        mu4InitRefCount++;
    }
    else if ( (ret = getImp()->init()) )
    {
        mu4InitRefCount = 1;
    }
    PIPE_DBG("- mu4InitRefCount(%d), ret(%d)", mu4InitRefCount, ret);
    return  ret;
}
Ejemplo n.º 5
0
MBOOL
IPostProcPipeBridge::
uninit()
{
    MBOOL   ret = MTRUE;
    Mutex::Autolock _lock(mLock);

    if  ( 0 < mu4InitRefCount )
    {
        mu4InitRefCount--;
        if  ( 0 == mu4InitRefCount )
        {
            ret = getImp()->uninit();
        }
    }
    PIPE_DBG("- mu4InitRefCount(%d), ret(%d)", mu4InitRefCount, ret);
    return  ret;
}
Ejemplo n.º 6
0
uint32_t
ParamsManager::
getZoomRatio() const
{
    RWLock::AutoRLock _lock(mRWLock);
    ssize_t index = mParameters.getInt(CameraParameters::KEY_ZOOM);

    if  (index < 0)
    {
        index = 0;
    }
    else if(index >= (ssize_t)mvZoomRatios.size())
    {
        index = mvZoomRatios.size() - 1;
    }

    return  mvZoomRatios[index];
}
Ejemplo n.º 7
0
int CThreadPool::getInstanceCurrentThreadIsAssociatedWith()
{
	if (_allThreadData.size()==0)
		return(-1);
	_lock(16);
	VTHREAD_ID_TYPE threadID=VThread::getCurrentThreadId();
	int retVal=-1;
	for (int i=0;i<int(_allThreadData.size());i++)
	{
		if (VThread::areThreadIDsSame(_allThreadData[i]->threadID,threadID))
		{
			retVal=_allThreadData[i]->threadInstanceIndex;
			break;
		}
	}
	_unlock(16);
	return(retVal);
}
Ejemplo n.º 8
0
/**
 * @param workspaceToCheck :: A workspace to check.
 * @param level :: The current nesting level. Intended for internal use only by
 * WorkspaceGroup.
 * @return :: True if the worspace is found in any of the nested groups in this
 * group.
 */
bool WorkspaceGroup::isInGroup(const Workspace &workspaceToCheck,
                               size_t level) const {
  // Check for a cycle.
  if (level > MAXIMUM_DEPTH) {
    throw std::runtime_error("WorkspaceGroup nesting level is too deep.");
  }
  std::lock_guard<std::recursive_mutex> _lock(m_mutex);
  for (const auto &workspace : m_workspaces) {
    if (workspace.get() == &workspaceToCheck)
      return true;
    WorkspaceGroup *group = dynamic_cast<WorkspaceGroup *>(workspace.get());
    if (group) {
      if (group->isInGroup(workspaceToCheck, level + 1))
        return true;
    }
  }
  return false;
}
Ejemplo n.º 9
0
Status LinuxThread::Terminate() {
	CHECK_ERROR(m_threadId);

    _lock(m_terminateMutex);
    if(m_bTerminate){
        _unlock(m_terminateMutex);
        return ER;
    }
    m_bTerminate = true;
    _unlock(m_terminateMutex);

    if(!IsRunning())
    	_assume();

    Status retval;
    int ret = pthread_join(*m_threadId,(void**)&retval);
    return (ret == 0 && val == OK) ? OK : ER;
}
Ejemplo n.º 10
0
MBOOL
ICamIOPipeBridge::
init()
{
    MBOOL   ret = MTRUE;
    Mutex::Autolock _lock(mLock);

    if  ( 0 != mu4InitRefCount )
    {
        mu4InitRefCount++;
    }
    else if ( (ret = getImp()->init()) )
    {
        mu4InitRefCount = 1;
    }
    MY_LOGD("- mu4InitRefCount(%d), ret(%d)", mu4InitRefCount, ret);
    return  ret;
}
Ejemplo n.º 11
0
MBOOL
ICamIOPipeBridge::
uninit()
{
    MBOOL   ret = MTRUE;
    Mutex::Autolock _lock(mLock);

    if  ( 0 < mu4InitRefCount )
    {
        mu4InitRefCount--;
        if  ( 0 == mu4InitRefCount )
        {
            ret = getImp()->uninit();
        }
    }
    MY_LOGD("- mu4InitRefCount(%d), ret(%d)", mu4InitRefCount, ret);
    return  ret;
}
Ejemplo n.º 12
0
   // PD_TRACE_DECLARE_FUNCTION ( SDB_COORDSN_DISCONN, "CoordSession::disConnect" )
   INT32 CoordSession::disConnect( const MsgRouteID &routeID )
   {
      INT32 rc = SDB_OK;
      PD_TRACE_ENTRY ( SDB_COORDSN_DISCONN );
      BOOLEAN hasSession = FALSE;
      {
         ossScopedLock _lock( &_mutex ) ;
         COORD_SUBSESSION_MAP::iterator it;
         it = _subSessionMap.find( routeID.value );
         if ( it != _subSessionMap.end() )
         {
            hasSession = TRUE;
            it->second.isConnected = FALSE;
         }
      }

      if ( hasSession )
      {
         MsgOpReply *pMsg = (MsgOpReply *)SDB_OSS_MALLOC( sizeof(MsgOpReply) );
         if ( NULL != pMsg )
         {
            pMsg->header.messageLength = sizeof(MsgOpReply);
            pMsg->header.opCode = MSG_COOR_REMOTE_DISC;
            pMsg->header.routeID = routeID;
            pMsg->header.requestID = pmdGetKRCB()->getCoordCB(
               )->getRouteAgent()->reqIDNew();
            pMsg->flags = SDB_COORD_REMOTE_DISC;
            pMsg->numReturned = 0;
            pMsg->contextID = -1 ;
            pMsg->startFrom = 0 ;
            _pEduCB->postEvent ( pmdEDUEvent( PMD_EDU_EVENT_MSG,
                                              PMD_EDU_MEM_ALLOC,
                                              pMsg ) ) ;
         }
         else
         {
            rc = SDB_OOM;
            PD_LOG( PDERROR, "malloc failed(size=%d)", sizeof(MsgHeader) );
         }
      }

      PD_TRACE_EXITRC ( SDB_COORDSN_DISCONN, rc );
      return rc;
   }
Ejemplo n.º 13
0
uint32_t
ParamsManager::
getMultFrameBlending() const
{
    RWLock::AutoRLock _lock(mRWLock);
    char const* pMfb = mParameters.get(MtkCameraParameters::KEY_MFB_MODE);
    char const*const pScene = mParameters.get(CameraParameters::KEY_SCENE_MODE);

    bool mNightMode = false;    
    uint32_t mfbMode = 0;

    if(!pMfb)
    {
        MY_LOGD("No KEY_MFB_MODE");
        return 0;
    }

    if  ( pScene && (0 == ::strcmp(pScene, CameraParameters::SCENE_MODE_NIGHT)) )
    {
        MY_LOGD(" MFB enable for NightMode");
        mNightMode = true;
    }

    // default MFB off, leave for CCT MFLL
    if  (0 == ::strcmp(pMfb, MtkCameraParameters::KEY_MFB_MODE_MFLL) )
    {
        MY_LOGD(" MFB enable for CCT");
        mfbMode = 1;
    }
    
    if  (0 == ::strcmp(pMfb, MtkCameraParameters::KEY_MFB_MODE_AIS) )
    {
        MY_LOGD(" MFB enable for AIS");
        mfbMode = 2;
    } 
    
    if  ((0 == ::strcmp(pMfb, MtkCameraParameters::OFF))&&
            true == mNightMode)
    {
        mfbMode = 1; 
    }
    
    return mfbMode;
}
Ejemplo n.º 14
0
status_t LivePhotoSource::read(MediaBuffer **buffer, const ReadOptions *options) {
	ALOGD("+");

    *buffer = NULL;
	if(options != NULL) {
		ALOGE("Failed: LivePhotoSource dose not support read options");
		return ERROR_UNSUPPORTED;
	}
	
	{
		Mutex::Autolock _lock(mLock);

		if( (mSourceStarted && !mLivePhotoStarted) || (mSourceStarted && mLivePhotoStarted && (mMediaBufferPool.empty() && mCodecConfigBuffer==NULL))) {
	        status_t status = mFrameAvailableCond.wait(mLock);
	        if  ( NO_ERROR != status ) {
	            ALOGE("wait status(%d) err", status);
				return UNKNOWN_ERROR;
	        }
		}

		if(mLivePhotoStarted && (mMediaBufferPool.empty() && mCodecConfigBuffer==NULL))
			mLivePhotoStarted = false;

		if( !mSourceStarted && !mLivePhotoStarted ) {
			mWriterReadEndCond.signal();
			ALOGD("- Live photo stoped, return ERROR_END_OF_STREAM");
			return ERROR_END_OF_STREAM;
		}
			
		if( mCodecConfigBuffer != NULL)	{
			ALOGD("codec config buffer");
			*buffer = mCodecConfigBuffer;
			mCodecConfigBuffer = NULL;
		}
		else if(!(mMediaBufferPool.empty())) {
			List<MediaBuffer *>::iterator it = mMediaBufferPool.begin();
			*buffer = (*it);
			mMediaBufferPool.erase(it);
		}
		
		ALOGD("-");
		return OK;
	}
}
Ejemplo n.º 15
0
static void
_namenode_decref(struct hdfs_namenode *n)
{
	bool lastref = false;
	int rc;

	_lock(&n->nn_lock);
	ASSERT(n->nn_refs >= 1);
	n->nn_refs--;
	if (n->nn_refs == 0)
		lastref = true;
	_unlock(&n->nn_lock);

	if (lastref) {
		hdfs_namenode_destroy_cb dcb = NULL;

		ASSERT(n->nn_dead);
		if (n->nn_recver_started) {
			rc = write(n->nn_recv_sigpipe[1], "a", 1);
			ASSERT(rc == 1);

			rc = pthread_join(n->nn_recv_thr, NULL);
			ASSERT(rc == 0);

			close(n->nn_recv_sigpipe[1]);
			close(n->nn_recv_sigpipe[0]);
		}
		if (n->nn_sock != -1)
			close(n->nn_sock);
		if (n->nn_pending)
			free(n->nn_pending);
		if (n->nn_recvbuf)
			free(n->nn_recvbuf);
		if (n->nn_objbuf)
			free(n->nn_objbuf);
		if (n->nn_destroy_cb)
			dcb = n->nn_destroy_cb;
		if (n->nn_sasl_ctx)
			sasl_dispose(&n->nn_sasl_ctx);
		memset(n, 0, sizeof *n);
		if (dcb)
			dcb(n);
	}
}
Ejemplo n.º 16
0
void flashpage_write(int page, const void *data)
{
    assert(page < FLASHPAGE_NUMOF);

    uint32_t *page_addr = (uint32_t *)flashpage_addr(page);

    /* erase given page (the ADDR register uses 16-bit addresses) */
    _unlock();
    NVMCTRL->ADDR.reg = (((uint32_t)page_addr) >> 1);
    NVMCTRL->CTRLA.reg = (NVMCTRL_CTRLA_CMDEX_KEY | NVMCTRL_CTRLA_CMD_ER);
    while (!NVMCTRL->INTFLAG.bit.READY) {}
    _lock();

    /* write data to page */
    if (data != NULL) {
        flashpage_write_raw(page_addr, data, FLASHPAGE_SIZE);
    }

}
Ejemplo n.º 17
0
   // PD_TRACE_DECLARE_FUNCTION ( SDB_DPSLOCKBUCKET_WAITLOCKX, "dpsLockBucket::waitLockX" )
   INT32 dpsLockBucket::waitLockX( _pmdEDUCB *eduCB,
                                   const dpsTransLockId &lockId )
   {
      INT32 rc = SDB_OK;
      dpsTransLockUnit *pLockUnit = NULL;
      {
         ossScopedLock _lock( &_lstMutex );
         dpsTransLockUnitList::iterator iterLst
                                 = _lockLst.find( lockId );
         if ( _lockLst.end() == iterLst )
         {
            rc = SDB_SYS;
            goto error;
         }
         pLockUnit = iterLst->second;
      }

   waitretry:
      rc = waitLock( eduCB );

      {
         ossScopedLock _lock_2( &_lstMutex );

         if ( rc )
         {
            removeFromWait( eduCB, pLockUnit, lockId );
            goto error ;
         }

         rc = appendToRun( eduCB, DPS_TRANSLOCK_X, pLockUnit );
         if ( rc )
         {
            goto waitretry;
         }
         removeFromWait( eduCB, pLockUnit, lockId );
      }
   done:
      PD_TRACE_EXIT ( SDB_DPSLOCKBUCKET_WAITLOCKX );
      return rc;
   error:
      PD_LOG ( PDERROR, "Failed to get the lock(rc=%d)", rc );
      goto done;
   }
Ejemplo n.º 18
0
//==========================================================
static bool  _ram_test (void)
//==========================================================
{
    vu16 *ram = _unlock();

    ram[0] = 0x1234;        
    if(ram[0] == 0x1234)        // test writability
    {
        _lock();

        ram[0] = 0x4321;
        if(ram[0] != 0x4321)    // test non-writability
        {
            return true;
        }
    }
    
    return false;
}
Ejemplo n.º 19
0
static ssize_t diag_read(struct file *fp, char __user *buf,
			size_t count, loff_t *pos)
{
	struct bt_diag_context *ctxt = &_context;
	int r = 0;
	int ret;
	struct bt_request *req;
	UINT8 *tmp;
	int i;

	if (_lock(&ctxt->read_excl))
		return 0;

	ret = wait_event_interruptible(ctxt->read_wq, ctxt->read_avail);
	dbg("read_wq wake up\n");
	if (ret < 0) {
		dbg("diag:Exit diag_read()\n");
		_unlock(&ctxt->read_excl);
		return ret;
	}

	while (req = bt_get_req(ctxt, &ctxt->rx_done)) {
		if (req) {
			tmp = (UINT8 *) req->buf;
			for (i = 0; i < req->length; i++, tmp++)
				printk(KERN_INFO "%x", *tmp);

			printk(KERN_INFO "\n");
			if (copy_to_user(buf, req->buf, req->length))
				dbg("diag:diag_read: copy_to_user fail\n");

			buf += req->length;
			r += req->length;
			bt_put_req(ctxt, &ctxt->rx_idle, req);
		}
	}

	ctxt->read_avail = 0;

	_unlock(&ctxt->read_excl);

	return r;
}
RenderTask* RenderThread::nextTask(nsecs_t* nextWakeup) {
    AutoMutex _lock(mLock);
    RenderTask* next = mQueue.peek();
    if (!next) {
        mNextWakeup = LLONG_MAX;
    } else {
        mNextWakeup = next->mRunAt;
        // Most tasks won't be delayed, so avoid unnecessary systemTime() calls
        if (next->mRunAt <= 0 || next->mRunAt <= systemTime(SYSTEM_TIME_MONOTONIC)) {
            next = mQueue.next();
        } else {
            next = nullptr;
        }
    }
    if (nextWakeup) {
        *nextWakeup = mNextWakeup;
    }
    return next;
}
Ejemplo n.º 21
0
EventWorkspaceMRU::~EventWorkspaceMRU() {
  // Make sure you free up the memory in the MRUs
  {
    Poco::ScopedWriteRWLock _lock(m_changeMruListsMutexY);
    for (auto &data : m_bufferedDataY) {
      if (data) {
        data->clear();
        delete data;
      }
    }
  }
  Poco::ScopedWriteRWLock _lock2(m_changeMruListsMutexE);
  for (auto &data : m_bufferedDataE) {
    if (data) {
      data->clear();
      delete data;
    }
  }
}
Ejemplo n.º 22
0
void CSimxSocket::instancePass()
{
// 3/3/2014
//	if (!_simulationOnly)
	{
		int simState=simGetSimulationState();
		if ((simState&sim_simulation_advancing)==0)
			_executeCommands();
	}

	if (_debug)
	{ // we should never access the V-REP API from a thread not created in V-REP!
		_lock();
		for (unsigned int i=0;i<_textToPrintToConsole.size();i++)
			simAuxiliaryConsolePrint(_auxConsoleHandle,_textToPrintToConsole[i].c_str());
		_textToPrintToConsole.clear();
		_unlock();
	}
}
Ejemplo n.º 23
0
int free_memory(void)
{
    struct fpack *ptr;
    int memsz = 0;

    _lock();
    ptr = sys_free;

    if (!first_call)	/* IF MEMORY IS INITIALIZED */
    {
	while (ptr != LIMIT)
	{
	    memsz -= ptr->packet_size;
	    ptr = ptr->next_free;
	}
    }
    _unlock();
    return memsz;
}
Ejemplo n.º 24
0
        bool d3d_display::create(uint32_t width = 1024, uint32_t height = 768, bool fullscreen = false) {
            std::lock_guard<std::mutex> _lock(_render_lock);

            _fullscreen = fullscreen;

            WNDCLASSEXW wcex;
            wcex.cbSize = sizeof(WNDCLASSEXW);
            wcex.style = CS_HREDRAW | CS_VREDRAW;
            wcex.lpfnWndProc = (WNDPROC)&ace::debug::d3d_display::wndproc;
            wcex.cbClsExtra = 0;
            wcex.cbWndExtra = 0;
            wcex.hInstance = (HINSTANCE)GetCurrentProcess();
            //wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_SAMPLE1);
            //wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
            wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
            wcex.lpszMenuName = nullptr;
            wcex.lpszClassName = L"ACE3BaseDisplayClass";
            //wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SAMPLE1);
            if (!RegisterClassExW(&wcex)) {
                return false;
            }

            // Create window
            _hInst = (HINSTANCE)GetCurrentProcess();
            RECT rc = { 0, 0, width, height };
            AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
            _hWnd = CreateWindowW(L"ACE3BaseDisplayClass", L"ACE3 D3D Render", WS_OVERLAPPEDWINDOW,
                CW_USEDEFAULT, CW_USEDEFAULT, rc.right - rc.left, rc.bottom - rc.top, nullptr, nullptr, _hInst,
                nullptr);

            if (!_hWnd) {
             return false;
            }

            // Attach our input to the master input
            //AttachThreadInput(GetCurrentThreadId(), GetMainThraedId());

            SetWindowLongPtr(_hWnd, GWLP_USERDATA, (LONG)this);

            ShowWindow(_hWnd, 5);

            return true;
        }
Ejemplo n.º 25
0
static int diag2arm9_open(struct inode *ip, struct file *fp)
{
	struct diag_context *ctxt = &_context;

    DBG_OP("+diag2arm9_open()\n");

	if (_lock(&ctxt->open_arm9_excl))
		return -EBUSY;

    msm_diag_smd_open();
    

    diag_configure(1, ctxt);
	/* clear the error latch */
	//ctxt->error = 0;

    DBG_OP("-diag2arm9_open()\n");
	return 0;
}
Ejemplo n.º 26
0
uint32_t
ParamsManager::
getVHdr() const
{
    RWLock::AutoRLock _lock(mRWLock);
    char const* p = mParameters.get(MtkCameraParameters::KEY_VIDEO_HDR);
    char const* pMode = mParameters.get(MtkCameraParameters::KEY_VIDEO_HDR_MODE);

    if(!p)
    {
        MY_LOGI("No KEY_VIDEO_HDR");
        return 0;
    }

    if(!pMode)
    {
        MY_LOGI("No KEY_VIDEO_HDR_MODE");
        return 0;
    }

    //> check vhdr mode

    if(::strcmp(p, MtkCameraParameters::OFF) == 0)
    {
        return 0;
    }
    else
    {
        if(::strcmp(pMode, MtkCameraParameters::VIDEO_HDR_MODE_IVHDR) == 0)
        {
            return 1;
        }
        else if(::strcmp(pMode, MtkCameraParameters::VIDEO_HDR_MODE_MVHDR) == 0)
        {
            return 2;
        }
        else
        {
            MY_LOGE("wrong mode(%s)",pMode);
            return 0;
        }
    }    
}
Ejemplo n.º 27
0
int64_t SparseMatrix<VALUE_T>::timed_vector_put(std::vector<std::string> row_key,
                          std::vector<std::string> column_key,
                          int64_t time_stamp,
                          std::vector<VALUE_T> value) {
    CHECK_EQ(row_key.size(), column_key.size());
    CHECK_EQ(row_key.size(), value.size());
    write_lock _lock(KVStorage::_timed_rwmutex);

    for (uint64_t i = 0; i < row_key.size(); ++i) {
       _timed_storage[time_stamp][row_key[i]][column_key[i]] = value[i];
    }

    if (_timed_storage.size() >= 3) {
       _timed_storage.erase(_timed_storage.begin());
    }

    vector_put(row_key, column_key, value);
    return 1;
}
Ejemplo n.º 28
0
///////////////////////////////////////////////////////////////////////////////
// Register - Register a new subject/observer relationsship
Error ChangeManager::Register(ISystemObject* pInSubject, IObserver* pInObserver) {
    BOOST_ASSERT_MSG(pInSubject != nullptr, "Subject cannot be null");
    BOOST_ASSERT_MSG(pInObserver != nullptr, "Observer cannot be null");

    auto observerIntrestBits = pInObserver->GetDesiredSystemChanges();
    if (pInSubject->GetPotentialSystemChanges() & observerIntrestBits) {
        // Lock out updates while we register a subject
        tbb::spin_mutex::scoped_lock _lock(m_swUpdate);
        unsigned int uID = pInSubject->getObserverId(this);

        if (uID != ISystemObject::InvalidObserverID) {
            // Subject has already been registered. Add new observer to the list
            SubjectInfo &si = m_subjectsList[uID];
            si.m_observersList.push_back(ObserverRequest(pInObserver, uID, observerIntrestBits));
            observerIntrestBits &= ~si.m_interestBits;

            if (observerIntrestBits) {
                si.m_interestBits |= observerIntrestBits;
                pInSubject->UpdateInterestBits(this, observerIntrestBits);
            }
        } else {
            // New subject
            if (m_freeIDsList.empty()) {
                // No zero ID should ever be assigned, so use pre-increment
                uID = ++m_lastID;
                BOOST_ASSERT(uID == m_subjectsList.size());
                m_subjectsList.resize(uID + 1);
            } else {
                uID = m_freeIDsList.back();
                m_freeIDsList.pop_back();
            }

            SubjectInfo &si = m_subjectsList[uID];
            si.m_pSubject = pInSubject;
            si.m_observersList.push_back(ObserverRequest(pInObserver, uID, observerIntrestBits));
            si.m_interestBits = observerIntrestBits;
            pInSubject->Attach(this, observerIntrestBits, uID);
        }
    }

    return Errors::Success;
}
Ejemplo n.º 29
0
   // PD_TRACE_DECLARE_FUNCTION ( SDB__SDB_DMSCB__CSCBNMREMVP1CANCEL, "_SDB_DMSCB::_CSCBNameRemoveP1Cancel" )
   INT32 _SDB_DMSCB::_CSCBNameRemoveP1Cancel ( const CHAR *pName,
                                             _pmdEDUCB *cb,
                                             SDB_DPSCB *dpsCB )
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY ( SDB__SDB_DMSCB__CSCBNMREMVP1CANCEL );
      dmsStorageUnitID suID ;
      SDB_DMS_CSCB *pCSCB = NULL;
#if defined (_WINDOWS)
      std::map<const CHAR*, dmsStorageUnitID, cmp_cscb>::const_iterator it ;
#elif defined (_LINUX)
      std::map<const CHAR*, dmsStorageUnitID>::const_iterator it ;
#endif

      {
         ossScopedLock _lock(&_mutex, EXCLUSIVE) ;
         if ( _cscbNameMap.end() == (it = _cscbNameMap.find(pName)) )
         {
            SDB_ASSERT( FALSE, "faint, why the cs is not in the map?" );
            rc = SDB_DMS_CS_NOTEXIST;
            goto error;
         }
         suID = (*it).second;
         pCSCB = _delCscbVec[suID];
         if ( pCSCB )
         {
            SDB_ASSERT( pCSCB->_su, "su can't be null!" );
            _cscbVec[suID] = pCSCB;
            _delCscbVec[suID] = NULL;
         }
         else
         {
            SDB_ASSERT( FALSE, "faint, where is the CSCB?" );
         }
      }

   done :
      PD_TRACE_EXITRC ( SDB__SDB_DMSCB__CSCBNMREMVP1CANCEL, rc );
      return rc ;
   error :
      goto done ;
   }
int fcntl(int fd, int cmd, ... /* arg */ )
{
    SocketExtDataLock _lock();

	int res = 0;

	va_list args;
	va_start(args, cmd);

	if (cmd == F_SETFL) {
		int flags = va_arg(args, int);

		bool blocking;

		if ((flags & O_NONBLOCK) != 0) {
			blocking = false;
		} else {
			blocking = true;
		}

        if (socket_ext_data.find(fd) == socket_ext_data.end()) {
            // we know nothing about this socket fd yet
            socket_ext_data[fd] = SocketData();
        }
		socket_ext_data[fd].nonblocking = !blocking;

		u_long socketMode = blocking ? 0 : 1;
		int rc = ioctl(fd, FIONBIO, &socketMode);
		if (rc == SOCKET_ERROR) {
			// ioctl sets the errno in Unix format
			res = -1;
			goto exit_end_args;
		}

		if ((flags & (~O_NONBLOCK)) != 0) {
			// We don't support any other flags
			errno = EBADF;
			res = -1;
			goto exit_end_args;
		}

	}