C++ (Cpp) metisMessage_Acquire Examples

Example #1

File: metis_ContentStoreEntry.c Project: isolis/Metis

MetisContentStoreEntry *
metisContentStoreEntry_Create(MetisMessage *contentMessage, MetisLruList *lruList)
{
    assertNotNull(contentMessage, "Parameter objectMessage must be non-null");

    MetisContentStoreEntry *entry = parcMemory_AllocateAndClear(sizeof(MetisContentStoreEntry));
    assertNotNull(entry, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(MetisContentStoreEntry));
    entry->message = metisMessage_Acquire(contentMessage);
    entry->refcount = 1;
    if (lruList != NULL) {
        entry->lruEntry = metisLruList_NewHeadEntry(lruList, entry);
    }

    entry->hasExpiryTimeTicks = metisMessage_HasExpiryTime(contentMessage);
    entry->hasRecommendedCacheTimeTicks = metisMessage_HasRecommendedCacheTime(contentMessage);

    if (entry->hasExpiryTimeTicks) {
        entry->expiryTimeTicks = metisMessage_GetExpiryTimeTicks(contentMessage);
    }

    if (entry->hasRecommendedCacheTimeTicks) {
        entry->recommendedCacheTimeTicks = metisMessage_GetRecommendedCacheTimeTicks(contentMessage);
    }

    return entry;
}

Example #2

File: metis_HopByHopFragmenter.c Project: PARC/Metis

bool
metisHopByHopFragmenter_Send(MetisHopByHopFragmenter *fragmenter, MetisMessage *message)
{
    bool success = false;

    // If the packet will fit in the MTU without fragmentation, do not use fragmentation
    if (metisMessage_Length(message) > fragmenter->mtu) {
        success = _sendFragments(fragmenter, message);
    } else {
        MetisMessage *copy = metisMessage_Acquire(message);
        success = parcRingBuffer1x1_Put(fragmenter->sendQueue, copy);
        if (!success) {
            metisMessage_Release(&copy);
            metisLogger_Log(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Warning, __func__,
                            "Failed to add message %p to send queue", (void *) message);
        } else {
            if (metisLogger_IsLoggable(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Debug)) {
                metisLogger_Log(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Debug, __func__,
                                "Add message %p to send queue", (void *) message);
            }
        }
    }

    return success;
}

Example #3

File: test_metis_Message.c Project: PARC/Metis

LONGBOW_TEST_CASE(Global, metisMessage_Copy)
{
    char message_str[] = "\x00Once upon a time, in a stack far away, a dangling pointer found its way to the top of the heap.";

    PARCEventBuffer *buff = parcEventBuffer_Create();
    parcEventBuffer_Append(buff, message_str, sizeof(message_str));

    PARCLogReporter *reporter = parcLogReporterTextStdout_Create();
    MetisLogger *logger = metisLogger_Create(reporter, parcClock_Wallclock());
    parcLogReporter_Release(&reporter);
    MetisMessage *message = metisMessage_CreateFromBuffer(1, 2, buff, logger);
    metisLogger_Release(&logger);

    assertNotNull(message, "Got null from metisMessage_CreateFromBuffer");
    assertTrue(message->refcount == 1, "Incorrect refcount, expected %u got %u", 1, message->refcount);

    MetisMessage *copy = metisMessage_Acquire(message);
    assertTrue(message->refcount == 2, "Incorrect refcount, expected %u got %u", 2, message->refcount);

    metisMessage_Release(&message);
    assertTrue(copy->refcount == 1, "Incorrect refcount, expected %u got %u", 1, message->refcount);

    metisMessage_Release(&copy);

    assertTrue(parcMemory_Outstanding() == 0, "Memory balance should be zero after destroying last copy, got %u", parcMemory_Outstanding());
}

Example #4

File: metis_StandardPIT.c Project: isolis/Metis

static void
_metisPIT_StoreInTable(MetisStandardPIT *pit, MetisMessage *interestMessage)
{
    MetisMessage *key = metisMessage_Acquire(interestMessage);

    MetisTicks expiryTime = _metisPIT_CalculateLifetime(pit, interestMessage);

    MetisPitEntry *pitEntry = metisPitEntry_Create(key, expiryTime);
    // this is done in metisPitEntry_Create
    //    metisPitEntry_AddIngressId(pitEntry, metisMessage_GetIngressConnectionId(interestMessage));

    metisMatchingRulesTable_AddToBestTable(pit->table, key, pitEntry);

    if (metisLogger_IsLoggable(pit->logger, MetisLoggerFacility_Processor, PARCLogLevel_Debug)) {
        metisLogger_Log(pit->logger, MetisLoggerFacility_Processor, PARCLogLevel_Debug, __func__,
                        "Message %p added to PIT (expiry %" PRIu64 ") ingress %u",
                        (void *) interestMessage,
                        metisPitEntry_GetExpiryTime(pitEntry),
                        metisMessage_GetIngressConnectionId(interestMessage));
    }
}

Example #5

File: metis_HopByHopFragmenter.c Project: PARC/Metis

bool
metisHopByHopFragmenter_Receive(MetisHopByHopFragmenter *fragmenter, const MetisMessage *message)
{
    if (metisMessage_GetType(message) == MetisMessagePacketType_HopByHopFrag) {
        _receiveFragment(fragmenter, message);
    } else {
        // put the whole thing on the output queue
        MetisMessage *copy = metisMessage_Acquire(message);
        bool putSuccess = parcRingBuffer1x1_Put(fragmenter->receiveQueue, copy);
        if (!putSuccess) {
            metisMessage_Release(&copy);
            metisLogger_Log(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Warning, __func__,
                            "Failed to add message %p to receive queue", (void *) message);
        } else {
            if (metisLogger_IsLoggable(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Debug)) {
                metisLogger_Log(fragmenter->logger, MetisLoggerFacility_IO, PARCLogLevel_Debug, __func__,
                                "Add message %p to receive queue", (void *) message);
            }
        }
    }

    // the maximum remaining is its capacity - 1
    return (parcRingBuffer1x1_Remaining(fragmenter->receiveQueue) < fragmenter->receiveQueueCapacity - 1);
}