C++ NodeInfo类代码示例

// Collect bar summaries for job allocation on node
void NodeMenu::get_lines() {
    // First update summary information; calling get lines updates info
    pcluster_menu->get_lines();

    // Now get job allocation line content
    NodeInfo node = pnode_container->nodes[node_name];
    lines = node.get_job_bar_summary(32);
}

int main(int argc,char *argv[])
{ 
    int numtasks, rank, dest, source, rc, count, tag=1, noderank;
    char inmsg, outmsg='x';
    MPI_Init(&argc,&argv);
    NodeInfo NI;
    NI.print();
    MPI_Finalize();
}

int unregister_from_master()
{
    printf("unregister_from_master start\n");
    char hname[128];
    struct hostent *hent;
    int i;

    gethostname(hname, sizeof(hname));
    hent = gethostbyname(hname);

   // printf("hostname: %s/naddress list: ", hent->h_name);
    
    char* ipstr = inet_ntoa(*(struct in_addr*)(hent->h_addr_list[0]));
    string hostaddr(ipstr);
    
    int cLen = 0;
    struct sockaddr_in cli;
    
    cli.sin_family = AF_INET;
    cli.sin_port = htons(globalConfig.masterPort);
    cli.sin_addr.s_addr = inet_addr(globalConfig.masterAddr.c_str());
    
    const int sock = socket(AF_INET, SOCK_STREAM, 0);

    if(sock < 0)
    {
        printf("socket() failure!\n");
        return 0; 
    }
    
    if(connect(sock, (struct sockaddr*)&cli, sizeof(cli)) < 0)
    {
        printf("connect() failure!\n");
        return 0;
    }

    //send method
    cLen = w_send(sock, "4", 1);
    if((cLen < 0)||(cLen == 0))
    {
        printf("send() failure!\n");
        return 0;
    }

    //send body
    NodeInfo req;
    req.set_nodeaddr(globalConfig.localAddr);
    req.set_nodeport(globalConfig.port);

    w_send_pb(sock, &req);

    close(sock);
    printf("unregister_from_master done\n");
    return 1;
}

bool captureOpenWriteDevice()
{
  XnStatus nRetVal = XN_STATUS_OK;
  NodeInfoList recordersList;
  
  nRetVal = g_Context.EnumerateProductionTrees(XN_NODE_TYPE_RECORDER, NULL, recordersList);
  START_CAPTURE_CHECK_RC(nRetVal, "Enumerate recorders");

  // take first
  NodeInfo chosen = *recordersList.Begin();
  nRetVal = g_Context.CreateProductionTree(chosen);
  START_CAPTURE_CHECK_RC(nRetVal, "Create recorder");

  g_Capture.pRecorder = new Recorder;
  nRetVal = chosen.GetInstance(*g_Capture.pRecorder);
  START_CAPTURE_CHECK_RC(nRetVal, "Get recorder instance");

  nRetVal = g_Capture.pRecorder->SetDestination(XN_RECORD_MEDIUM_FILE, g_Capture.csFileName);
  START_CAPTURE_CHECK_RC(nRetVal, "Set output file");

  if (getDevice() != NULL)
  {
	  nRetVal = g_Capture.pRecorder->AddNodeToRecording(*getDevice(), XN_CODEC_UNCOMPRESSED);
	  START_CAPTURE_CHECK_RC(nRetVal, "add device node");
  }

  if (isDepthOn() && (g_Capture.DepthFormat != CODEC_DONT_CAPTURE))
  {
	  nRetVal = g_Capture.pRecorder->AddNodeToRecording(*getDepthGenerator(), g_Capture.DepthFormat);
	  START_CAPTURE_CHECK_RC(nRetVal, "add depth node");
  }

  if (isImageOn() && (g_Capture.ImageFormat != CODEC_DONT_CAPTURE))
  {
	  nRetVal = g_Capture.pRecorder->AddNodeToRecording(*getImageGenerator(), g_Capture.ImageFormat);
	  START_CAPTURE_CHECK_RC(nRetVal, "add image node");
  }

  if (isIROn() && (g_Capture.IRFormat != CODEC_DONT_CAPTURE))
  {
	  nRetVal = g_Capture.pRecorder->AddNodeToRecording(*getIRGenerator(), g_Capture.IRFormat);
	  START_CAPTURE_CHECK_RC(nRetVal, "add IR stream");
  }

  if (isAudioOn() && (g_Capture.AudioFormat != CODEC_DONT_CAPTURE))
  {
	  nRetVal = g_Capture.pRecorder->AddNodeToRecording(*getAudioGenerator(), g_Capture.AudioFormat);
	  START_CAPTURE_CHECK_RC(nRetVal, "add Audio stream");
  }

  return true;
}

bool RenderFrameSet::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty,
                                 HitTestAction hitTestAction, bool inside)
{
    RenderBox::nodeAtPoint(info, _x, _y, _tx, _ty, hitTestAction, inside);

    inside = m_resizing || canResize(_x, _y);

    if ( inside && element() && !element()->noResize() && !info.readonly()){
        info.setInnerNode(element());
        info.setInnerNonSharedNode(element());
    }

    return inside || m_clientresizing;
}

Stencil<T>*
MPICUDAStencilFactory<T>::BuildStencil( const OptionParser& options )
{
    // get options for base class
    T wCenter;
    T wCardinal;
    T wDiagonal;
    size_t lRows;
    size_t lCols;
    std::vector<long long> devs;
    CommonCUDAStencilFactory<T>::ExtractOptions( options,
                                                wCenter,
                                                wCardinal,
                                                wDiagonal,
                                                lRows,
                                                lCols,
                                                devs );

    size_t mpiGridRows;
    size_t mpiGridCols;
    unsigned int nItersPerHaloExchange;
    MPI2DGridProgram<T>::ExtractOptions( options,
                                        mpiGridRows,
                                        mpiGridCols,
                                        nItersPerHaloExchange );

    // determine which device to use
    // We would really prefer this to be done in main() but
    // since BuildStencil is a virtual function, we cannot change its
    // signature, and OptionParser provides no way to override an
    // option's value after it is set during parsing.
    NodeInfo ni;
    int myRankInNode = ni.nodeRank();
    // assign tasks to devices in round-robin approach
    // TODO is this really the mapping we want if the CUDA-capable
    // devices are heterogeneous?
    int chosenDevice = (myRankInNode % devs.size());

    return new MPICUDAStencil<T>( wCenter,
                                wCardinal,
                                wDiagonal,
                                lRows,
                                lCols,
                                mpiGridRows,
                                mpiGridCols,
                                nItersPerHaloExchange,
                                chosenDevice
                                );
}

int PNode :: AddMember(const int iGroupIdx, const NodeInfo & oNode)
{
    if (!CheckGroupID(iGroupIdx))
    {
        return Paxos_GroupIdxWrong;
    }

    SystemVSM * poSystemVSM = m_vecGroupList[iGroupIdx]->GetConfig()->GetSystemVSM();

    if (poSystemVSM->GetGid() == 0)
    {
        return Paxos_MembershipOp_NoGid;
    }

    uint64_t llVersion = 0;
    NodeInfoList vecNodeInfoList;
    poSystemVSM->GetMembership(vecNodeInfoList, llVersion);

    for (auto & oNodeInfo : vecNodeInfoList)
    {
        if (oNodeInfo.GetNodeID() == oNode.GetNodeID())
        {
            return Paxos_MembershipOp_Add_NodeExist;
        }
    }

    vecNodeInfoList.push_back(oNode);

    return ProposalMembership(poSystemVSM, iGroupIdx, vecNodeInfoList, llVersion);
}

int PNode :: ChangeMember(const int iGroupIdx, const NodeInfo & oFromNode, const NodeInfo & oToNode)
{
    if (!CheckGroupID(iGroupIdx))
    {
        return Paxos_GroupIdxWrong;
    }

    SystemVSM * poSystemVSM = m_vecGroupList[iGroupIdx]->GetConfig()->GetSystemVSM();

    if (poSystemVSM->GetGid() == 0)
    {
        return Paxos_MembershipOp_NoGid;
    }

    uint64_t llVersion = 0;
    NodeInfoList vecNodeInfoList;
    poSystemVSM->GetMembership(vecNodeInfoList, llVersion);

    NodeInfoList vecAfterNodeInfoList;
    bool bFromNodeExist = false;
    bool bToNodeExist = false;
    for (auto & oNodeInfo : vecNodeInfoList)
    {
        if (oNodeInfo.GetNodeID() == oFromNode.GetNodeID())
        {
            bFromNodeExist = true;
            continue;
        }
        else if (oNodeInfo.GetNodeID() == oToNode.GetNodeID())
        {
            bToNodeExist = true;
            continue;
        }

        vecAfterNodeInfoList.push_back(oNodeInfo);
    }

    if ((!bFromNodeExist) && bToNodeExist)
    {
        return Paxos_MembershipOp_Change_NoChange;
    }

    vecAfterNodeInfoList.push_back(oToNode);

    return ProposalMembership(poSystemVSM, iGroupIdx, vecAfterNodeInfoList, llVersion);
}

bool Scheduler::updateSchedules(Pricing& pricing, NodeInfo& nodeInfo)
{
  if (!isMaster())
  {
    Master::schedule(&nodeInfo);
    return true;
  }

  unsigned long now = Clock::getUnixTime();
  bool changed = false;
  for (auto &schedule : nodeInfo.schedules)
  {
    // we already have a designated time or interval expired, so we can get next time
    if (schedule.repeatEvery > 0
        && ((schedule.designatedTime > schedule.startTime && schedule.designatedTime < schedule.startTime + schedule.interval)
            || schedule.startTime + schedule.interval < now))
    {
      schedule.startTime += schedule.repeatEvery * ceil(float(now - schedule.interval - schedule.startTime) / float(schedule.repeatEvery));
      changed = true;
    }

    #if DEBUG_SCHEDULER
    Serial.print("lastRun");
    Serial.println(schedule.lastRun);
    Serial.print("designatedtime");
    Serial.println(schedule.designatedTime);
    Serial.print("duration");
    Serial.println(schedule.duration);
    Serial.print("startime");
    Serial.println(schedule.startTime);
    Serial.print("now");
    Serial.println(now);
    Serial.print("startime");
    Serial.println(schedule.startTime);
    Serial.print("startime-now");
    Serial.println(long(schedule.startTime - now));
    #endif

      // It has already run or the designated time expiered
    if ((schedule.lastRun >= schedule.designatedTime || schedule.designatedTime + schedule.duration > now)
        // and we have a new plan to schedule
       && schedule.startTime > schedule.designatedTime
       // and there are only 30 minutes left to ensure we have data for the interval
       && long(schedule.startTime - now) < 1800)
    {
      if (isMaster())
        schedule.designatedTime = pricing.getBestTime(schedule);
      else
        {} //ask master for best time
      changed = true;
    }
  }

  if (changed)
    nodeInfo.save();

  return changed;
}

void NodesDb::LoadFile(const wxString& file)
{
    NodeInfo *ni = new NodeInfo; 
    ni->Type = wxEmptyString;
    ni->Icon = 0;
    wxPathList paths;
    size_t i;
    
    for (i = 0; i < m_Paths.GetCount(); i++)
        paths.Add(m_Paths[i]);
    
    ni->Read(file, paths);
    
    // maybe we already parsed it?
    for (i = 0; i < m_Infos.GetCount(); i++)
        if (m_Infos[i].NodeClass == ni->NodeClass) return;
    
    m_Infos.Add(ni);
}

/**
  * insertionSort
  * 
  * uses a insertion sort algorithm to insert a new node
  * into a vector
  *
  */
void FileSystem::insertionSort(vector<NodeInfo*> nodes) {

    unsigned int ix = 0,
                 jx = 0;

    int nSize = 0;

    for (ix = 1; ix < nodes.size() - 1; ++ix) {

        nSize = allNodes.at(ix)->getSize();

        jx = ix - 1;
        NodeInfo* cmp = allNodes.at(jx);
        while( jx >= 0 && nSize < cmp->getSize() ) {
            
        }
    }

}

bool RenderInline::nodeAtPoint(NodeInfo& info, int _x, int _y, int _tx, int _ty,
                               HitTestAction hitTestAction, bool inside)
{
    // Check our kids if our HitTestAction says to.
    if (hitTestAction != HitTestSelfOnly) {
        for (RenderObject* child = lastChild(); child; child = child->previousSibling())
            if (!child->layer() && !child->isFloating() && child->nodeAtPoint(info, _x, _y, _tx, _ty))
                inside = true;
    }
    
    // Check our line boxes if we're still not inside.
    if (hitTestAction != HitTestChildrenOnly && !inside && style()->visibility() != HIDDEN) {
        // See if we're inside one of our line boxes.
        for (InlineRunBox* curr = firstLineBox(); curr; curr = curr->nextLineBox()) {
            if((_y >=_ty + curr->m_y) && (_y < _ty + curr->m_y + curr->m_height) &&
               (_x >= _tx + curr->m_x) && (_x <_tx + curr->m_x + curr->m_width) ) {
                inside = true;
                break;
            }
        }
    }

    if (inside && element()) {
        if (info.innerNode() && info.innerNode()->renderer() &&
            !info.innerNode()->renderer()->isInline()) {
            // Within the same layer, inlines are ALWAYS fully above blocks.  Change inner node.
            info.setInnerNode(element());

            // Clear everything else.
            info.setInnerNonSharedNode(0);
            info.setURLElement(0);
        }

        if (!info.innerNode())
            info.setInnerNode(element());

        if(!info.innerNonSharedNode())
            info.setInnerNonSharedNode(element());
    }

    return inside;
}

bool captureOpenWriteDevice()
{
	XnStatus nRetVal = XN_STATUS_OK;
	NodeInfoList recordersList;
	nRetVal = g_Context.EnumerateProductionTrees(XN_NODE_TYPE_RECORDER, NULL, recordersList);
	START_CAPTURE_CHECK_RC(nRetVal, "Enumerate recorders");
	// take first
	NodeInfo chosen = *recordersList.Begin();
	nRetVal = g_Context.CreateProductionTree(chosen);
	START_CAPTURE_CHECK_RC(nRetVal, "Create recorder");

	g_Capture.pRecorder = new Recorder;
	nRetVal = chosen.GetInstance(*g_Capture.pRecorder);
	START_CAPTURE_CHECK_RC(nRetVal, "Get recorder instance");

	nRetVal = g_Capture.pRecorder->SetDestination(XN_RECORD_MEDIUM_FILE, g_Capture.csFileName);
	START_CAPTURE_CHECK_RC(nRetVal, "Set output file");

	return true;
}

template<class NodeVector> void FileSystem::debugPrintNodes(NodeVector nodes) {
    if( debug) {
        unsigned int ix;
        NodeInfo* node;

        for (ix = 0; ix < nodes.size(); ++ix) {
            node = nodes.at(ix);

            cout << "Node: " << node->getName()
                << "\t\tSize: " << node->getSize()
                << "\tModify: " << node->getModifyTime()
                << "\tPath: " << node->getPath()
                << "\tSimilars: ";
        
            vector<NodeInfo*>::iterator it;
            vector<NodeInfo*> nodes = node->getSimilar();
            for(it=nodes.begin(); it != nodes.end(); ++it) {
                cout << (*it)->getPath() << ", ";
            }

            cout << endl;
        }
    }

}

 void on_req_node_remove(const int fd)
 {
 	WNodeManager* nodeManager = WNodeManager::getInstance();

	char* req_buff;
	size_t req_len;
	int cl = w_recv(fd,req_buff);

	if(cl > 0)
	{
		NodeInfo req;
		if(!req.ParseFromArray(req_buff, cl))
		{
			cerr<<"error when parse get request\n";
			//response.set_rspcode(REQ_FAILED);
			//response.set_errcode(ERR_INVALID_PARAMS);
			//w_send_pb(fd, &response);
			return;
		}

		cout<<"client addr is "<<req.nodeaddr()<<",port is "<<req.nodeport()<<endl;
		
		nodeManager->removeNode(req.nodeaddr(), req.nodeport());
		cout<<"node remove ok"<<endl;
	}
	else
	{
		cout<<"can not get node info\n";
	}
 }