Ejemplo n.º 1
0
bool LocalNode::_connect( NodePtr node, ConnectionPtr connection )
{
    EQASSERT( connection.isValid( ));
    EQASSERT( node->getNodeID() != getNodeID( ));

    if( !node.isValid() || _state != STATE_LISTENING ||
        !connection->isConnected() || node->_state != STATE_CLOSED )
    {
        return false;
    }

    _addConnection( connection );

    // send connect packet to peer
    NodeConnectPacket packet;
    packet.requestID = registerRequest( node.get( ));
    packet.nodeID    = _id;
    packet.nodeType  = getType();
    connection->send( packet, serialize( ));

    bool connected = false;
    if( !waitRequest( packet.requestID, connected, 10000 /*ms*/ ))
    {
        EQWARN << "Node connection handshake timeout - peer not a Collage node?"
               << std::endl;
        return false;
    }
    if( !connected )
        return false;

    EQASSERT( node->_id != NodeID::ZERO );
    EQASSERTINFO( node->_id != _id, _id );
    EQINFO << node << " connected to " << *(Node*)this << std::endl;
    return true;
}
Ejemplo n.º 2
0
bool Server::_cmdReleaseConfig( co::ICommand& command )
{
    UUID configID = command.get< UUID >();
    uint32_t requestID = command.get< uint32_t >();

    LBVERB << "Handle release config " << command << " config " << configID
           << std::endl;

    co::NodePtr node = command.getNode();

    Config* config = 0;
    const Configs& configs = getConfigs();
    for( Configs::const_iterator i = configs.begin();
         i != configs.end() && !config; ++i )
    {
        Config* candidate = *i;
        if( candidate->getID() == configID )
            config = candidate;
    }

    if( !config )
    {
        LBWARN << "Release request for unknown config" << std::endl;
        node->send( fabric::CMD_SERVER_RELEASE_CONFIG_REPLY ) << requestID;
        return true;
    }

    if( config->isRunning( ))
    {
        LBWARN << "Release of running configuration" << std::endl;
        config->exit(); // Make sure config is exited
    }

    const uint32_t destroyRequestID = registerRequest();
    node->send( fabric::CMD_SERVER_DESTROY_CONFIG )
            << config->getID() << destroyRequestID;
    waitRequest( destroyRequestID );

#ifdef EQUALIZER_USE_HWSD
    if( config->isAutoConfig( ))
    {
        LBASSERT( _admins.empty( ));
        config->deregister();
        config::Server::release( config );
    }
    else
#endif
    {
        ConfigRestoreVisitor restore;
        config->accept( restore );
        config->commit();
    }

    node->send( fabric::CMD_SERVER_RELEASE_CONFIG_REPLY ) << requestID;
    LBLOG( lunchbox::LOG_ANY ) << "----- Released Config -----" << std::endl;
    return true;
}
Ejemplo n.º 3
0
void *kernel_launcher (void *data)
{
	struct kernelLauncherData *kd = (struct kernelLauncherData *)data;
	size_t *global_work = (size_t *)malloc(sizeof(size_t)*(kd->work_dim));

	cl_uint i;
	for(i = 0; i < kd->work_dim; i++) {
		if (i != kd->max_index)
			global_work[i] = kd->global_work_size[i];
	}

	unsigned int one = 1;
	unsigned int zero = 0;
	
	for(i = 0; i < 3; i++) {
		if (i < kd->work_dim)
			__real_clSetKernelArg (kd->kernel,kd->arg_num+1+i, sizeof(unsigned int), &(kd->global_work_size[i]));
		else
			__real_clSetKernelArg (kd->kernel, kd->arg_num+1+i, sizeof(unsigned int), &one);
	}
	for(i = 0; i < 3; i++) {
		if (i < kd->work_dim) {
			__real_clSetKernelArg (kd->kernel, kd->arg_num+7+i, sizeof(unsigned int), &(kd->num_groups[i]));
		}
		else
			__real_clSetKernelArg (kd->kernel, kd->arg_num+7+i, sizeof(unsigned int), &one);
	}
	cl_uint j;
	size_t remain = kd->size;
	size_t step = kd->step;
	if (kd->local_work_size != NULL)
		step /= kd->local_work_size[kd->max_index];

	unsigned int off = kd->off;
	while (remain > 0) {
		size_t size = remain >= 2*step ? step : remain;
		if (kd->local_work_size != NULL)	global_work[kd->max_index] = size*kd->local_work_size[kd->max_index];
		else global_work[kd->max_index] = size;
		remain -= size;
		for(j = 0; j < 3; j++) {
			if (j == kd->max_index) 
				__real_clSetKernelArg (kd->kernel, kd->arg_num+4+j, sizeof(unsigned int), &off);
			else
				__real_clSetKernelArg (kd->kernel, kd->arg_num+4+j, sizeof(unsigned int), &zero);
		}
		sendRequest('g', kd->index, 1);
		waitRequest('g', kd->index);
		__real_clEnqueueNDRangeKernel (queue_GPUSparc[kd->index], kd->kernel, kd->work_dim, kd->global_work_offset, global_work, kd->local_work_size, 0, NULL, kd->event);
		__real_clFinish (queue_GPUSparc[kd->index]);
		sendFinish('g', kd->index, 1);
		off += size;

	}
	free (global_work);
	return NULL;
}
Ejemplo n.º 4
0
void PublishToMePlugin::startWaitTimer(int msecs, const char* slot) {
    if (!m_waitTimer) {
        m_waitTimer = new QTimer(this);
        m_waitTimer->setSingleShot(true);
    }

    m_waitTimer->setInterval(msecs);
    m_waitTimer->start();
    emit waitRequest(msecs, false);
    disconnect(m_waitTimer, SIGNAL(timeout()), this, 0);
    connect(m_waitTimer, SIGNAL(timeout()), this, slot);
}
Ejemplo n.º 5
0
    void run()
    {
        if (check)
        {
            mId = (tagType3->*check)(mSerivceBlockList);
        }

        if (update)
        {
            mId = (tagType3->*update)(mSerivceBlockList, mDataArray);
        }

        checkInvalidId();
        waitRequest();
    }
Ejemplo n.º 6
0
LocalNode::SendToken LocalNode::acquireSendToken( NodePtr node )
{
    EQASSERT( !inCommandThread( ));
    EQASSERT( !_inReceiverThread( ));

    NodeAcquireSendTokenPacket packet;
    packet.requestID = registerRequest();
    node->send( packet );
    
    bool ret = false;
    if( waitRequest( packet.requestID, ret, Global::getTimeout( )))
        return node;

    EQERROR << "Timeout while acquiring send token " << packet.requestID
            << std::endl;
    return 0;
}
Ejemplo n.º 7
0
bool Server::_cmdReleaseConfig( co::Command& command )
{
    const ServerReleaseConfigPacket* packet = 
        command.get<ServerReleaseConfigPacket>();
    EQINFO << "Handle release config " << packet << std::endl;

    ServerReleaseConfigReplyPacket reply( packet );
    co::NodePtr node = command.getNode();

    Config* config = 0;
    const Configs& configs = getConfigs();
    for( Configs::const_iterator i = configs.begin();
         i != configs.end() && !config; ++i )
    {
        Config* candidate = *i;
        if( candidate->getID() == packet->configID )
            config = candidate;
    }

    if( !config )
    {
        EQWARN << "Release request for unknown config" << std::endl;
        node->send( reply );
        return true;
    }

    if( config->isRunning( ))
    {
        EQWARN << "Release of running configuration" << std::endl;
        config->exit(); // Make sure config is exited
    }

    fabric::ServerDestroyConfigPacket destroyConfigPacket;
    destroyConfigPacket.requestID = registerRequest();
    destroyConfigPacket.configID  = config->getID();
    node->send( destroyConfigPacket );
    waitRequest( destroyConfigPacket.requestID );

    ConfigRestoreVisitor restore;
    config->accept( restore );

    node->send( reply );
    EQLOG( co::base::LOG_ANY ) << "----- Released Config -----" << std::endl;
    return true;
}
Ejemplo n.º 8
0
bool LocalNode::disconnect( NodePtr node )
{
    if( !node || _state != STATE_LISTENING )
        return false;

    if( node->_state != STATE_CONNECTED )
        return true;

    EQASSERT( !inCommandThread( ));

    NodeDisconnectPacket packet;
    packet.requestID = registerRequest( node.get( ));
    send( packet );

    waitRequest( packet.requestID );
    _objectStore->removeNode( node );
    return true;
}
Ejemplo n.º 9
0
void RedisProxy::writeReplyFinished(Context *c)
{
    ClientPacket* packet = (ClientPacket*)c;
    m_monitor->replyClientFinished(packet);
    packet->finishedState = ClientPacket::Unknown;
    packet->commandType = -1;
    packet->sendBuff.clear();
    packet->recvBuff.clear();
    packet->sendBytes = 0;
    packet->recvBytes = 0;
    packet->sendToRedisBytes = 0;
    packet->requestServant = NULL;
    packet->redisSocket = NULL;
    packet->recvBufferOffset = 0;
    packet->sendBufferOffset = 0;
    packet->sendParseResult.reset();
    packet->recvParseResult.reset();
    waitRequest(c);
}
    void run()
    {
        if (readBlock)
        {
            mId = (tagType2->*readBlock)(mAddr);
        }

        if (writeBlock)
        {
            mId = (tagType2->*writeBlock)(mAddr, mDataArray);
        }

        if (selectSector)
        {
            mId = (tagType2->*selectSector)(mSector);
        }
        checkInvalidId();
        waitRequest();
    }
Ejemplo n.º 11
0
void RedisProxy::writeReply(Context *c)
{
    ClientPacket* packet = (ClientPacket*)c;
    if (!packet->isRecvParseEnd()) {
        switch (packet->parseRecvBuffer()) {
        case RedisProto::ProtoError:
            closeConnection(c);
            break;
        case RedisProto::ProtoIncomplete:
            waitRequest(c);
            break;
        case RedisProto::ProtoOK:
            readRequestFinished(c);
            break;
        default:
            break;
        }
    } else {
        TcpServer::writeReply(c);
    }
}
Ejemplo n.º 12
0
    void run()
    {
        if (readAll)
        {
            mId = (tagType1->*readAll)();
        }

        if (readIdentification)
        {
            mId = (tagType1->*readIdentification)();
        }

        if (readByte)
        {
            mId = (tagType1->*readByte)(mAddr);
        }

        if (writeByte)
        {
            mId = (tagType1->*writeByte)(mAddr, mData, mMode);
        }

        if (readBlock)
        {
            mId = (tagType1->*readBlock)(mAddr);
        }

        if (writeBlock)
        {
            mId = (tagType1->*writeBlock)(mAddr, mDataArray, mMode);
        }

        if (readSegment)
        {
            mId = (tagType1->*readSegment)(mAddr);
        }
        checkInvalidId();
        waitRequest();
    }
Ejemplo n.º 13
0
    void run()
    {
        if (selectByName)
        {
            mId = (mTagType4->*selectByName)(mName);
        }

        if (selectById)
        {
            mId = (mTagType4->*selectById)(mFileId);
        }

        if (read)
        {
            mId = (mTagType4->*read)(mLength, mStartOffset);
        }

        if (write)
        {
            mId = (mTagType4->*write)(mDataArray, mStartOffset);
        }
        checkInvalidId();
        waitRequest();
    }
Ejemplo n.º 14
0
cl_int decomposer_GPUSparc(cl_kernel 	  	kernel,
						   cl_uint 	      	work_dim, 
						   const size_t * 	global_work_offset, 
						   const size_t * 	global_work_size,
						   const size_t * 	local_work_size,
						   cl_uint 		  	num_events_in_wait_list,
						   const cl_event *	event_wait_list,
						   cl_event *		event)
{
	cl_uint i;
	cl_int ret = CL_SUCCESS;

	map<cl_kernel, struct kernelinfo_GPUSparc>::iterator kiter;
	kiter = kernelmap_GPUSparc.find (kernel);
	if (kiter == kernelmap_GPUSparc.end()) {
		GPUSparcLog ("Cannot find kernel in clEnqueueNDRangeKernel\n");
	}
	cl_kernel *kernels = kiter->second.kernel;

	size_t *local_work 	   = (size_t *)malloc(sizeof(size_t) * work_dim);

	unsigned int *num_group = (unsigned int *)malloc(sizeof(unsigned int) * work_dim);

	for(i = 0; i < work_dim; i++) {
		local_work[i] = (local_work_size != NULL)? local_work_size[i] : 1;
		num_group[i] = global_work_size[i]/local_work[i];
	}

	timeval t1, t2;


	cl_uint max_index = getMaxIndex (work_dim,global_work_size, local_work);
	cl_uint step = getStep (work_dim, global_work_size, local_work, max_index);

	map<cl_uint, cl_mem> args = kiter->second.args;
	map<cl_uint, cl_mem>::iterator argiter;
	map<cl_mem, struct meminfo_GPUSparc>::iterator miter;
	/* inter-kernel dependency */
	GPUSparcLog ("Arg Sync\n");
	for (argiter = args.begin(); argiter != args.end(); ++argiter) {
		miter = memmap_GPUSparc.find (argiter->second);
		if (miter == memmap_GPUSparc.end()) {
			GPUSparcLog ("Cannot find args in clEnqueueNDRangeKernel\n");
			continue;
		}
		struct meminfo_GPUSparc *minfo = &(miter->second);
		if (!(miter->second.merged) && multiGPUmode) {
			ret |= bufferMerger_GPUSparc (minfo, NULL);
		}
		if (!(miter->second.synched)) {
			ret |= bufferSynchronizer_GPUSparc (minfo, NULL, NULL, NULL);
		}
	}
	gettimeofday (&t1, NULL);
	cl_event *tevent = (cl_event *)malloc(sizeof(cl_event) * nGPU_GPUSparc);
	
	cl_uint arg_index = kiter->second.arg_num;

	if (!multiGPUmode)
	{	
		if (migration)
			gpuid = -1;
		
		sendRequest('g', gpuid, 1);
		gpuid = waitRequest('g', -1);
		struct kernelLauncherData *kd = (struct kernelLauncherData *)malloc(sizeof(struct kernelLauncherData));
		kd->index = gpuid;
		kd->kernel = kernels[gpuid];
		kd->max_index = max_index;
		kd->work_dim = work_dim;
		kd->global_work_size = global_work_size;
		kd->global_work_offset = global_work_offset;
		kd->local_work_size = local_work_size;
		kd->step = step;
		kd->num_groups = num_group;
		kd->arg_num = arg_index;
		kd->event = NULL;
		kd->size = global_work_size[max_index]/local_work[max_index];
		kd->off = 0;
		single_kernel_launcher (kd);
	}
	else {

	
		struct kernelLauncherData *kd = (struct kernelLauncherData *)malloc(sizeof(struct kernelLauncherData)*nGPU_GPUSparc);
		int total = global_work_size[max_index]/local_work[max_index];
		int nGPU = nGPU_GPUSparc;
		
		for(i = 0; i < nGPU_GPUSparc; i++) {
			kd[i].index = i;
			kd[i].kernel = kernels[i];
			kd[i].work_dim = work_dim;
			kd[i].max_index = max_index;
			kd[i].global_work_size = global_work_size;
			kd[i].global_work_offset = global_work_offset;
			kd[i].local_work_size = local_work_size;
			kd[i].step = step;
			kd[i].num_groups = num_group;
			kd[i].arg_num = arg_index;
			kd[i].event = &tevent[i];
			int amount = CEIL(total,nGPU);
			total -= amount;
			nGPU--;
			kd[i].size = amount;
			if (i == 0)
					kd[i].off = 0;
					else
				kd[i].off = kd[i-1].off + kd[i-1].size;
		}
	
		pthread_t *kthread = (pthread_t *)malloc(sizeof(pthread_t) * nGPU_GPUSparc);
		for(i = 0; i < nGPU_GPUSparc; i++) {
			pthread_create (&kthread[i], NULL, kernel_launcher, &kd[i]);
		}

		for(i = 0; i < nGPU_GPUSparc; i++) {
			pthread_join (kthread[i], NULL);
		}


		if (event != NULL) {
			eventmap_GPUSparc.insert (map<cl_event, cl_event *>::value_type (tevent[0], tevent));
			*event = tevent[0];
	
		}
		else free (tevent);
	}
	gettimeofday (&t2, NULL);
	GPUSparcLog ("kernel time: %f\n", ELAPSEDTIME(t1, t2));
	for (argiter = args.begin(); argiter != args.end(); ++argiter) {
		miter = memmap_GPUSparc.find (argiter->second);
		struct meminfo_GPUSparc *minfo = &miter->second;
		minfo->merged = false;
		if (!multiGPUmode)
			minfo->cohered_gpu = gpuid;
	}
	if (migration)
		gpuid = -1;

	free (num_group);
	free (local_work);
	return ret;
}
Ejemplo n.º 15
0
void PublishToMePlugin::checkWaitTime() {
    QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());

    if (!reply) {
        emit error(tr("Network error"));
        return;
    }

    const QString redirect = getRedirect(reply);

    if (!redirect.isEmpty()) {
        if (FILE_REGEXP.indexIn(redirect) == 0) {
            emit downloadRequest(QNetworkRequest(redirect));
        }
        else if (m_redirects < MAX_REDIRECTS) {
            followRedirect(redirect, SLOT(checkWaitTime()));
        }
        else {
            emit error(tr("Maximum redirects reached"));
        }

        reply->deleteLater();
        return;
    }

    switch (reply->error()) {
    case QNetworkReply::NoError:
        break;
    case QNetworkReply::OperationCanceledError:
        reply->deleteLater();
        return;
    default:
        emit error(reply->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString());
        reply->deleteLater();
        return;
    }

    const QString response = QString::fromUtf8(reply->readAll());

    if (FILE_REGEXP.indexIn(response) != -1) {
        QString url = FILE_REGEXP.cap();
        
        if (url.startsWith("/")) {
            url.prepend(reply->url().scheme() + "://" + reply->url().authority());
        }
        
        emit downloadRequest(QNetworkRequest(url));
    }
    else if (response.contains("Downloading is not possible")) {
        const QTime time = QTime::fromString(response.section("Please wait", 1, 1).section("to download", 0, 0)
                                            .trimmed(), "hh:mm:ss");
        
        if (time.isValid()) {
            emit waitRequest(QTime(0, 0).msecsTo(time), true);
        }
        else {
            emit error(tr("Unknown error"));
        }
    }
    else {
        QString recaptchaKey = response.section("/file/captcha.html?v=", 1, 1).section('"', 0, 0);

        if (recaptchaKey.isEmpty()) {
            emit error(tr("No captcha key found"));
        }
        else {
            recaptchaKey.prepend(QString("http://%1/file/captcha.html?v=").arg(reply->url().host()));
            emit captchaRequest(RECAPTCHA_PLUGIN_ID, CaptchaType::Image, recaptchaKey, "submitCaptchaResponse");
        }
    }

    reply->deleteLater();
}
Ejemplo n.º 16
0
NodePtr LocalNode::_connect( const NodeID& nodeID, NodePtr peer )
{
    EQASSERT( nodeID != NodeID::ZERO );

    NodePtr node;

    // Make sure that only one connection request based on the node identifier
    // is pending at a given time. Otherwise a node with the same id might be
    // instantiated twice in _cmdGetNodeDataReply(). The alternative to this
    // mutex is to register connecting nodes with this local node, and handle
    // all cases correctly, which is far more complex. Node connections only
    // happen a lot during initialization, and are therefore not time-critical.
    base::ScopedMutex<> mutex( _connectMutex );
    {
        base::ScopedMutex< base::SpinLock > mutexNodes( _nodes ); 
        NodeHash::const_iterator i = _nodes->find( nodeID );
        if( i != _nodes->end( ))
            node = i->second;
    }

    if( node.isValid( ))
    {
        EQASSERT( node->isConnected( ));
        if( !node->isConnected( ))
            connect( node );
        return node->isConnected() ? node : 0;
    }

    EQINFO << "Connecting node " << nodeID << std::endl;
    EQASSERT( _id != nodeID );

    NodeGetNodeDataPacket packet;
    packet.requestID = registerRequest();
    packet.nodeID    = nodeID;
    peer->send( packet );

    void* result = 0;
    waitRequest( packet.requestID, result );

    if( !result )
    {
        EQINFO << "Node " << nodeID << " not found on " << peer->getNodeID() 
               << std::endl;
        return 0;
    }

    EQASSERT( dynamic_cast< Node* >( (Dispatcher*)result ));
    node = static_cast< Node* >( result );
    node->unref( CO_REFERENCED_PARAM ); // ref'd before serveRequest()

    if( node->isConnected( ))
        return node;

    if( connect( node ))
        return node;

    {
        base::ScopedMutex< base::SpinLock > mutexNodes( _nodes );
        // connect failed - maybe simultaneous connect from peer?
        NodeHash::const_iterator i = _nodes->find( nodeID );
        if( i != _nodes->end( ))
        {
            node = i->second;
            if( !node->isConnected( ))
                connect( node );
        }
    }

    return node->isConnected() ? node : 0;
}