C++ NodeRef::getBloomfilter方法代码示例

bool ProtocolUDP::sendDataObject(const DataObjectRef& dObj, const NodeRef& peer, const InterfaceRef& _peerIface)
{
	int ret = PROT_EVENT_ERROR;
	
	if (peerIface) {
		HAGGLE_ERR("%s Peer interface %s is set when it shouldn't be\n", getName(), peerIface->getIdentifierStr());
	} else {
		// Reassign the peer interface to our target destination
		peerIface = _peerIface;

		// Reassign peer node to our target node for accurate logging
		peerNode = peer; // MOS

// SW: START: late bloomfilter add 
        NodeRef actualPeer = getManager()->getKernel()->getNodeStore()->retrieve(peerNode);
        if (!actualPeer) {
            // SW: NOTE: this is OK behavior during start-up w/ config.xml 
            HAGGLE_DBG("%s Peer not in node store\n", getName());
            actualPeer = peerNode;
        }
	if(actualPeer->getBloomfilter()->has(dObj)) {
	  dataObjectsNotSent += 1; // MOS
	  ret = PROT_EVENT_SUCCESS;
	}
	else {
	  actualPeer->getBloomfilter()->add(dObj);
	  ret = sendDataObjectNow(dObj);
	}
// SW: END: late bloomfilter add

		/* Call send function */
	        // ret = sendDataObjectNow(dObj);
		
		// Send success event with this DO.
		// Note: failures are handled by the caller (ProtocolManager)
		if (ret == PROT_EVENT_SUCCESS) {
			getKernel()->addEvent(new Event(EVENT_TYPE_DATAOBJECT_SEND_SUCCESSFUL, dObj, peer));
		} 
	}
	
	// Release the peer interface again, such that we can assign it another 
	// destination next time
	peerIface = NULL;

	return ret == PROT_EVENT_SUCCESS;
}

void DataManager::onSendResult(Event *e)
{
	DataObjectRef& dObj = e->getDataObject();
	NodeRef node = e->getNode();

	if (!dObj) {
		HAGGLE_ERR("No data object in send result\n");	
		return;
	}

        if(dObj->isControlMessage()) {  // MOS - keep control messages out of Bloom filter
		return;
	}

	if (!node) {
		HAGGLE_ERR("No node in send result\n");	
		return;
	}

	if (!node->isStored()) {
		HAGGLE_DBG2("Send result node %s is not in node store, trying to retrieve\n", node->getName().c_str());
		NodeRef peer = kernel->getNodeStore()->retrieve(node);

		if (peer) {
			HAGGLE_DBG2("Found node %s in node store, using the one in store\n", node->getName().c_str());
			node = peer;
		} else {
			HAGGLE_ERR("Did not find node %s in node store\n", node->getName().c_str());
		}
	}
	if (e->getType() == EVENT_TYPE_DATAOBJECT_SEND_SUCCESSFUL) {
		// Add data object to node's bloomfilter.
		HAGGLE_DBG("Adding data object [%s] to node %s's bloomfilter\n", DataObject::idString(dObj).c_str(), node->getName().c_str());
		node->getBloomfilter()->add(dObj);


	  if (dataObjectsSent.size() >= MAX_DATAOBJECTS_LISTED) {
		dataObjectsSent.pop_front();
	  }
	  dataObjectsSent.push_back(dObj->getIdStr());
// SW: JLM: START CACHE STRATEGY:
          if ((e->getType() == EVENT_TYPE_DATAOBJECT_SEND_SUCCESSFUL) && cacheStrategy && !cacheStrategy->isDone()) {
            cacheStrategy->handleSendSuccess(dObj, node);
          }
// SW: JLM: END CACHE STRATEGY.
	}
}

/**
 * Find the next best data object to replicate towards neighbor with id
 * `node_id`, given that we have an estimated `bytes_left` bytes left to
 *  send. If `bytes_left == 0` then we assume the bag size is infinite
 * and therefore send data objects with highest utility first.
 * If the computed bytes_left < 0 then the bag is full and no data objects
 * will be replicated.
 */
bool
ReplicationOptimizer::getNextDataObject(string node_id, List<string> &dobj_blacklist, int bytes_left, DataObjectRef& o_dobj, NodeRef& o_node)
{
    neighbor_node_id_map_t::iterator it = utils.find(node_id);
    if (it == utils.end()) {
        // no data objects for node
        if (dobjs.size() != 0) {
            errorCount++;
            HAGGLE_ERR("Neighbors map missing data objects.\n");
        }
        return false;
    }

    {
        node_map_t::iterator it = node_map.find(node_id);
        if (it == node_map.end()) {
            HAGGLE_ERR("Node missing from data structure.\n");
            return false;
        }
        o_node = (*it).second;
        if (!o_node) {
            HAGGLE_ERR("NULL node.\n");
            return false;
        }
    }
    // remove in-flight data objects from the bag size
    for (List<string>::iterator itt = dobj_blacklist.begin(); itt != dobj_blacklist.end(); itt++) {
        string dobj_id = (*itt);
        if (bytes_left != 0) {   //0 means unilmited
        	bytes_left = bytes_left - getCost(dobj_id, node_id);
		if (bytes_left == 0) { bytes_left = -1; }
 	}
    }

    if (bytes_left < 0) {
        // buffer already full
        return false;
    }

    // used when bytes_left == 0
    double best_utility = 0;
    int best_cost = 0;
    string best_dobj_id = "";

    List<ReplicationDataObjectUtilityMetadataRef> process_dos;
    List<ReplicationDataObjectUtilityMetadataRef> include_dos;
    List<ReplicationDataObjectUtilityMetadataRef> exclude_dos;

    for (;it != utils.end() && (*it).first == node_id; it++) {
        ReplicationDataObjectUtilityMetadataRef do_info = (*it).second;
        Timeval now = Timeval::now();
        if (!do_info) {
            errorCount++;
            HAGGLE_ERR("NULL DO in cache\n");
            continue;
        }
        string do_id = do_info->getId();
        DataObjectId_t id;
        DataObject::idStrToId(do_id, id);

        bool inBloomfilter = o_node->getBloomfilter()->has(id);
        if (inBloomfilter) {
            HAGGLE_DBG("Skipping, %s already in bloomfilter.\n", Node::nameString(o_node).c_str());
            continue;
        }

        // skip over data objects in the black list
        bool inBlacklist = false;
        for (List<string>::iterator itt = dobj_blacklist.begin(); itt != dobj_blacklist.end(); itt++) {
            if ((*itt) == do_id) {
                inBlacklist = true;
                break;
            }
        }
        if (inBlacklist) {
            continue;
        }
        // recompute the utility if need be
        double delta = now.getTimeAsMilliSecondsDouble() - do_info->getComputedTime().getTimeAsMilliSecondsDouble();
        if (delta > computePeriodMs && utilFunction) {
            double new_utility = utilFunction->compute(do_info->getId(), do_info->getNodeId());
            do_info->setUtility(new_utility, now);

        }
        // skip utilites beneeath threshold
        int cost = do_info->getCost();
        double util = do_info->getUtility();
        if (util >= globalOptimizer->getMinimumThreshold()) {
            process_dos.push_front(do_info);
            if (util > best_utility || (util == best_utility && cost < best_cost)) {
                best_utility = util;
                best_cost = cost;
//.........这里部分代码省略.........

void DataManager::onIncomingDataObject(Event *e)
{
	if (!e || !e->hasData())
		return;

	DataObjectRef& dObj = e->getDataObject();
	
	if (!dObj) {
		HAGGLE_DBG("Incoming data object event without data object!\n");
		return;
	}

        if(dObj->isControlMessage()) {  // MOS - keep control messages out of Bloom filter
		return;
	}

	// Add the data object to the bloomfilter of the one who sent it:
	NodeRef peer = e->getNode();

        // JM End: Associate origin social group to DO

	if (!peer || peer->getType() == Node::TYPE_UNDEFINED) {
		// No valid node in event, try to figure out from interface

		// Find the interface it came from:
		const InterfaceRef& iface = dObj->getRemoteInterface();

		if (iface) {
		        HAGGLE_DBG2("Incoming data object [%s] has no valid peer node but valid peer interface %s\n", DataObject::idString(dObj).c_str(), iface->getIdentifierStr());
			peer = kernel->getNodeStore()->retrieve(iface);
		        if(peer && peer->getType() != Node::TYPE_UNDEFINED) HAGGLE_DBG2("Setting incoming data object peer node to %s\n", peer->getName().c_str());
		} else {
			HAGGLE_DBG("No valid peer interface in data object, cannot figure out peer node\n");
		}
	}
	
	if (peer) {
	  if (peer->getType() != Node::TYPE_APPLICATION && peer->getType() != Node::TYPE_UNDEFINED) {
			// Add the data object to the peer's bloomfilter so that
			// we do not send the data object back.
			HAGGLE_DBG("Adding data object [%s] to peer node %s's (%s num=%lu) bloomfilter\n", 
				DataObject::idString(dObj).c_str(), peer->getName().c_str(), peer->isStored() ? "stored" : "not stored", peer->getNum());
			/*
			LOG_ADD("%s: BLOOMFILTER:ADD %s\t%s:%s\n", 
				Timeval::now().getAsString().c_str(), dObj->getIdStr(), 
				peer->getTypeStr(), peer->getIdStr());
			*/
			peer->getBloomfilter()->add(dObj);

		}
	} else {
		HAGGLE_DBG("No valid peer node for incoming data object [%s]\n", dObj->getIdStr());
	}

	// Check if this is a control message from an application. We do not want 
	// to bloat our bloomfilter with such messages, because they are sent
	// everytime an application connects.
	if (!dObj->isControlMessage()) {
		// Add the incoming data object also to our own bloomfilter
		// We do this early in order to avoid receiving duplicates in case
		// the same object is received at nearly the same time from multiple neighbors
		if (localBF->has(dObj)) {
			HAGGLE_DBG("Data object [%s] already in our bloomfilter, marking as duplicate...\n", dObj->getIdStr());
			dObj->setDuplicate();
		} else {
		  if(!dObj->isNodeDescription()) { // MOS - local BF only contains data objects in new design
			localBF->add(dObj);
		        HAGGLE_DBG("Adding data object [%s] to our bloomfilter, #objs=%d\n", DataObject::idString(dObj).c_str(), localBF->numObjects());
			kernel->getThisNode()->getBloomfilter()->add(dObj); // MOS
			if(isNodeDescUpdateOnReceptionEnabled) {
			  // MOS - immediately disseminate updated bloomfilter
			  kernel->getThisNode()->setNodeDescriptionCreateTime();
			  kernel->addEvent(new Event(EVENT_TYPE_NODE_DESCRIPTION_SEND));	
			}
		  }
		  if(!periodicBloomfilterUpdateEvent->isScheduled()) // MOS - update now happening periodically
		      kernel->getThisNode()->setBloomfilter(*localBF, setCreateTimeOnBloomfilterUpdate);
		}
	}
}