Пример #1
0
void
v_writerStatisticsInit(
    v_writerStatistics ws)
{
    assert(ws != NULL);
    assert(C_TYPECHECK(ws, v_writerStatistics));

    v_statisticsInit(v_statistics(ws));
    ws->numberOfWrites = 0;
    ws->numberOfDisposes = 0;
    ws->numberOfRegisters = 0;
    ws->numberOfImplicitRegisters = 0;
    ws->numberOfUnregisters = 0;
    ws->numberOfTimedOutWrites = 0;
    ws->numberOfWritesBlockedBySamplesLimit = 0;
    ws->numberOfWritesBlockedByInstanceLimit = 0;
    ws->numberOfWritesBlockedBySamplesPerInstanceLimit = 0;
    ws->numberOfRetries = 0;

    ws->numberOfInstancesWithStatusAlive = 0;
    ws->numberOfInstancesWithStatusDisposed = 0;
    ws->numberOfInstancesWithStatusUnregistered = 0;
    ws->numberOfSamples = 0;
    v_maxValueInit(&ws->maxNumberOfSamplesPerInstance);
}
c_bool v_networkChannelStatisticsReset(v_networkChannelStatistics ncs)
{
    c_bool result;

    assert(ncs!=NULL);
    assert(C_TYPECHECK(ncs, v_networkChannelStatistics));
	ncs->numberOfMessagesSent=0;
	ncs->numberOfBytesSent=0;
	ncs->numberOfPacketsSent=0;

	ncs->numberOfMessagesFragmented=0;
	ncs->numberOfMessagesPacked=0;

	ncs->numberOfKnownNodes=0;
	ncs->numberOfBytesResent=0;
	ncs->numberOfPacketsResent=0;
	ncs->numberOfBytesInResendBuffer=0;
	ncs->numberOfPacketsInResendBuffer=0;
	v_maxValueInit(&(ncs->maxNumberOfBytesResentToOneNode));
	v_maxValueInit(&(ncs->maxNumberOfPacketsResentToOneNode));

	ncs->numberOfMessagesReceived=0;
	ncs->numberOfBytesReceived=0;
	ncs->numberOfPacketsReceived=0;
	ncs->numberOfPacketsLost=0;
	ncs->numberOfAcksSent=0;

	ncs->numberOfMessagesDelivered=0;
	ncs->numberOfBytesDelivered=0;
	ncs->numberOfMessagesNotInterested=0;
	ncs->numberOfBytesNotInterested=0;
	ncs->nofFreePacketBuffers=0;
	ncs->nofUsedPacketBuffers=0;
	v_fullCounterInit(&(ncs->adminQueueAcks));
	v_fullCounterInit(&(ncs->adminQueueData));

    ncs->nofBytesBeforeCompression=0;
    ncs->nofBytesAfterCompression=0;
    ncs->nofBytesBeforeDecompression=0;
    ncs->nofBytesAfterDecompression=0;

    result = TRUE;
    return result;
}
Пример #3
0
void v_readerStatisticsInit(v_readerStatistics rs)
{
    assert(rs != NULL);
    assert(C_TYPECHECK(rs,v_readerStatistics));

    v_statisticsInit(v_statistics(rs));
    v_maxValueInit(&rs->maxSampleSize);
    v_maxValueInit(&rs->maxSamplesPerInstance);
    v_maxValueInit(&rs->maxNumberOfSamples);
    v_maxValueInit(&rs->maxNumberOfInstances);

    v_fullCounterInit(&rs->readLatency);
    v_fullCounterInit(&rs->transportLatency);

    rs->numberOfSamples = 0;
    rs->numberOfInstances = 0;

    rs->numberOfInstancesWithStatusNew = 0;
    rs->numberOfInstancesWithStatusAlive = 0;
    rs->numberOfInstancesWithStatusDisposed = 0;
    rs->numberOfInstancesWithStatusNoWriters = 0;

    rs->numberOfSamplesWithStatusRead = 0;
    rs->numberOfSamplesExpired = 0;
    rs->numberOfSamplesPurgedByDispose = 0;
    rs->numberOfSamplesPurgedByNoWriters = 0;
    rs->numberOfSamplesArrived = 0;
    rs->numberOfSamplesInserted = 0;
    rs->numberOfSamplesDiscarded = 0;
    rs->numberOfSamplesRead = 0;
    rs->numberOfSamplesTaken = 0;

    rs->numberOfSamplesRejectedBySamplesLimit = 0;
    rs->numberOfSamplesRejectedByInstancesLimit = 0;
    rs->numberOfReads = 0;
    rs->numberOfInstanceReads = 0;
    rs->numberOfNextInstanceReads = 0;
    rs->numberOfInstanceLookups = 0;
    rs->numberOfTakes = 0;
    rs->numberOfInstanceTakes = 0;
    rs->numberOfNextInstanceTakes = 0;
}
Пример #4
0
void v_durabilityStatisticsInit(v_durabilityStatistics ds)
{
    assert(ds != NULL);
    assert(C_TYPECHECK(ds, v_durabilityStatistics));

    v_statisticsInit(v_statistics(ds));
    
    ds->persistentSamplesWritten            = 0;
    
    v_maxValueInit(&ds->fellowsKnownMax);
    ds->fellowsKnown                        = 0;
    ds->fellowsApproved                     = 0;
    ds->fellowsIncompatibleState            = 0;
    ds->fellowsIncompatibleDataModel        = 0;
    
    ds->nameSpacesKnown                     = 0;
    ds->nameSpacesMaster                    = 0;
    ds->nameSpacesSlave                     = 0;

    ds->groupsToCreateTotal                 = 0;
    ds->groupsToCreateVolatile              = 0;
    ds->groupsToCreateTransient             = 0;
    ds->groupsToCreatePersistent            = 0;
    
    ds->groupsKnownTotal                    = 0;
    ds->groupsKnownVolatile                 = 0;
    ds->groupsKnownTransient                = 0;
    ds->groupsKnownPersistent               = 0;

    ds->groupsCompleteTotal                 = 0;
    ds->groupsCompleteVolatile              = 0;
    ds->groupsCompleteTransient             = 0;
    ds->groupsCompletePersistent            = 0;

    ds->groupsIncompleteTotal               = 0;
    ds->groupsIncompleteVolatile            = 0;
    ds->groupsIncompleteTransient           = 0;
    ds->groupsIncompletePersistent          = 0;

    ds->groupsIgnoredTotal                  = 0;
    ds->groupsIgnoredVolatile               = 0;
    ds->groupsIgnoredTransient              = 0;
    ds->groupsIgnoredPersistent             = 0;
    
    ds->alignerRequestsReceived             = 0;
    ds->alignerRequestsIgnored              = 0;
    ds->alignerRequestsAnswered             = 0;
    ds->alignerRequestsOpen                 = 0;
    v_maxValueInit(&ds->alignerRequestsOpenMax);
    ds->alignerRequestsCombined             = 0;
    ds->alignerRequestsCombinedOpen         = 0;
    v_maxValueInit(&ds->alignerRequestsCombinedOpenMax);
    ds->alignerRequestsCombinedAnswered     = 0;
    
    ds->aligneeRequestsSent                 = 0;
    v_maxValueInit(&ds->aligneeRequestsOpenMax);
    ds->aligneeRequestsOpen                 = 0;
    ds->aligneeRequestsWaiting              = 0;
    v_maxValueInit(&ds->aligneeRequestsWaitingMax);
    
    ds->aligneeSamplesTotal                 = 0;
    ds->aligneeSamplesRegister              = 0;
    ds->aligneeSamplesWrite                 = 0;
    ds->aligneeSamplesDispose               = 0;
    ds->aligneeSamplesWriteDispose          = 0;
    ds->aligneeSamplesUnregister            = 0;
    
    ds->alignerSamplesTotal                 = 0;
    ds->alignerSamplesRegister              = 0;
    ds->alignerSamplesWrite                 = 0;
    ds->alignerSamplesDispose               = 0;
    ds->alignerSamplesWriteDispose          = 0;
    ds->alignerSamplesUnregister            = 0;
    
    ds->aligneeTotalSize                    = 0;
    ds->alignerTotalSize                    = 0;
    
    return;
}
Пример #5
0
void
v_networkChannelStatisticsInit(
    v_networkChannelStatistics ncs,
    c_string name)
{
    assert(ncs != NULL);
    assert(C_TYPECHECK(ncs,v_networkChannelStatistics));

    ncs->name = name;
    ncs->numberOfMessagesSent=0;
    ncs->numberOfBytesSent=0;
    ncs->numberOfPacketsSent=0;

    ncs->numberOfMessagesFragmented=0;
    ncs->numberOfMessagesPacked=0;

    ncs->numberOfKnownNodes=0;
    ncs->numberOfBytesResent=0;
    ncs->numberOfPacketsResent=0;
    ncs->numberOfBytesInResendBuffer=0;
    ncs->numberOfPacketsInResendBuffer=0;
    ncs->maxNumberOfBytesResentToOneNode=0;
    ncs->maxNumberOfPacketsResentToOneNode=0;

    ncs->numberOfMessagesReceived=0;
    ncs->numberOfBytesReceived=0;
    ncs->numberOfPacketsReceived=0;
    ncs->numberOfPacketsLost=0;
    ncs->numberOfPacketsOutOfOrder=0;
    ncs->numberOfAcksSent=0;

    ncs->numberOfMessagesDelivered=0;
    ncs->numberOfBytesDelivered=0;
    ncs->numberOfMessagesNotInterested=0;
    ncs->numberOfBytesNotInterested=0;
    ncs->numberOfPacketsReliabilityMismatch=0;
    ncs->numberOfPacketsNotConnectedPartition=0;
    ncs->numberOfPacketsUnknownAddress=0;
    ncs->numberOfPacketsInvalid=0;
    ncs->numberOfPacketsOutOfOrderDropped=0;
    ncs->nofFreePacketBuffers=0;
    ncs->nofUsedPacketBuffers=0;

    ncs->reorderAdminPacketsQueued=0;
    v_avgValueInit(&ncs->reorderAdminPacketsQueuedAvg);
    v_minValueInit(&ncs->reorderAdminPacketsQueuedMin);
    v_maxValueInit(&ncs->reorderAdminPacketsQueuedMax);

    ncs->reorderAdminBytesQueued=0;
    v_avgValueInit(&ncs->reorderAdminBytesQueuedAvg);
    v_minValueInit(&ncs->reorderAdminBytesQueuedMin);
    v_maxValueInit(&ncs->reorderAdminBytesQueuedMax);

    ncs->ringBufferMessagesQueued=0;
    v_avgValueInit(&ncs->ringBufferMessagesQueuedAvg);
    v_minValueInit(&ncs->ringBufferMessagesQueuedMin);
    v_maxValueInit(&ncs->ringBufferMessagesQueuedMax);

    ncs->resendAdminPacketsQueued=0;
    v_avgValueInit(&ncs->resendAdminPacketsQueuedAvg);
    v_minValueInit(&ncs->resendAdminPacketsQueuedMin);
    v_maxValueInit(&ncs->resendAdminPacketsQueuedMax);

    ncs->resendAdminBytesQueued=0;
    v_avgValueInit(&ncs->resendAdminBytesQueuedAvg);
    v_minValueInit(&ncs->resendAdminBytesQueuedMin);
    v_maxValueInit(&ncs->resendAdminBytesQueuedMax);

    v_fullCounterInit(&(ncs->adminQueueAcks));
    v_fullCounterInit(&(ncs->adminQueueData));

    ncs->nofBytesBeforeCompression=0;
    ncs->nofBytesAfterCompression=0;
    ncs->nofBytesBeforeDecompression=0;
    ncs->nofBytesAfterDecompression=0;
}