string Target::GetXml()

in Common/Common.cpp [261:487]

• 182 lines of code
• 32 McCabe index (conditional complexity)

string Target::GetXml(UINT32 indent) const
{
    char buffer[4096];
    string sXml;
    
    AddXmlInc(sXml, "<Target>\n");
    AddXml(sXml, "<Path>" + _sPath + "</Path>\n");

    sprintf_s(buffer, _countof(buffer), "<BlockSize>%u</BlockSize>\n", _dwBlockSize);
    AddXml(sXml, buffer);

    sprintf_s(buffer, _countof(buffer), "<BaseFileOffset>%I64u</BaseFileOffset>\n", _ullBaseFileOffset);
    AddXml(sXml, buffer);

    AddXml(sXml, _fSequentialScanHint ? "<SequentialScan>true</SequentialScan>\n" : "<SequentialScan>false</SequentialScan>\n");
    AddXml(sXml, _fRandomAccessHint ? "<RandomAccess>true</RandomAccess>\n" : "<RandomAccess>false</RandomAccess>\n");
    AddXml(sXml, _fTemporaryFileHint ? "<TemporaryFile>true</TemporaryFile>\n" : "<TemporaryFile>false</TemporaryFile>\n");
    AddXml(sXml, _fUseLargePages ? "<UseLargePages>true</UseLargePages>\n" : "<UseLargePages>false</UseLargePages>\n");

    // TargetCacheMode::Cached is implied default
    switch (_cacheMode)
    {
    case TargetCacheMode::DisableLocalCache:
        AddXml(sXml, "<DisableLocalCache>true</DisableLocalCache>\n");
        break;
    case TargetCacheMode::DisableOSCache:
        AddXml(sXml, "<DisableOSCache>true</DisableOSCache>\n");
        break;
    }

    // WriteThroughMode::Off is implied default
    switch (_writeThroughMode)
    {
    case WriteThroughMode::On:
        AddXml(sXml, "<WriteThrough>true</WriteThrough>\n");
        break;
    }
    
    // MemoryMappedIoMode::Off is implied default
    switch (_memoryMappedIoMode)
    {
    case MemoryMappedIoMode::On:
        AddXml(sXml, "<MemoryMappedIo>true</MemoryMappedIo>\n");
        break;
    }

    // MemoryMappedIoFlushMode::Undefined is implied default
    switch (_memoryMappedIoFlushMode)
    {
    case MemoryMappedIoFlushMode::ViewOfFile:
        AddXml(sXml, "<FlushType>ViewOfFile</FlushType>\n");
        break;
    case MemoryMappedIoFlushMode::NonVolatileMemory:
        AddXml(sXml, "<FlushType>NonVolatileMemory</FlushType>\n")
        break;
    case MemoryMappedIoFlushMode::NonVolatileMemoryNoDrain:
        AddXml(sXml, "<FlushType>NonVolatileMemoryNoDrain</FlushType>\n");
        break;
    }

    AddXmlInc(sXml, "<WriteBufferContent>\n");
    if (_fZeroWriteBuffers)
    {
        AddXml(sXml, "<Pattern>zero</Pattern>\n");
    }
    else if (_cbRandomDataWriteBuffer == 0)
    {
        AddXml(sXml, "<Pattern>sequential</Pattern>\n");
    }
    else
    {
        AddXml(sXml, "<Pattern>random</Pattern>\n");
        AddXmlInc(sXml, "<RandomDataSource>\n");
        sprintf_s(buffer, _countof(buffer), "<SizeInBytes>%I64u</SizeInBytes>\n", _cbRandomDataWriteBuffer);
        AddXml(sXml, buffer);
        if (_sRandomDataWriteBufferSourcePath != "")
        {
            AddXml(sXml, "<FilePath>" + _sRandomDataWriteBufferSourcePath + "</FilePath>\n");
        }
        AddXmlDec(sXml, "</RandomDataSource>\n");
    }
    AddXmlDec(sXml, "</WriteBufferContent>\n");

    AddXml(sXml, _fParallelAsyncIO ? "<ParallelAsyncIO>true</ParallelAsyncIO>\n" : "<ParallelAsyncIO>false</ParallelAsyncIO>\n");

    if (_fUseBurstSize)
    {
        sprintf_s(buffer, _countof(buffer), "<BurstSize>%u</BurstSize>\n", _dwBurstSize);
        AddXml(sXml, buffer);
    }

    if (_fThinkTime)
    {
        sprintf_s(buffer, _countof(buffer), "<ThinkTime>%u</ThinkTime>\n", _dwThinkTime);
        AddXml(sXml, buffer);
    }

    if (_fCreateFile)
    {
        sprintf_s(buffer, _countof(buffer), "<FileSize>%I64u</FileSize>\n", _ullFileSize);
        AddXml(sXml, buffer);
    }

    // If XML contains <Random>, <StrideSize> is ignored
    if (_ulRandomRatio > 0)
    {
        sprintf_s(buffer, _countof(buffer), "<Random>%I64u</Random>\n", GetBlockAlignmentInBytes());
        AddXml(sXml, buffer);

        // 100% random is <Random> alone
        if (_ulRandomRatio != 100)
        {
            sprintf_s(buffer, _countof(buffer), "<RandomRatio>%u</RandomRatio>\n", GetRandomRatio());
            AddXml(sXml, buffer);
        }

        // Distributions only occur in profiles with random IO.

        if (_vDistributionRange.size())
        {
            char *type = nullptr;

            switch (_distributionType)
            {
                case DistributionType::Absolute:
                type = "Absolute";
                break;

                case DistributionType::Percent:
                type = "Percent";
                break;

                default:
                assert(false);
            }

            AddXmlInc(sXml, "<Distribution>\n");
            AddXmlInc(sXml, "<");
            sXml += type;
            sXml += ">\n";

            for (auto r : _vDistributionRange)
            {
                sprintf_s(buffer, _countof(buffer), "<Range IO=\"%u\">%I64u", r._span, r._dst.second);
                AddXml(sXml, buffer);
                sXml += "</Range>\n";
            }

            AddXmlDec(sXml, "</");
            sXml += type;
            sXml += ">\n";
            AddXmlDec(sXml, "</Distribution>\n");
        }
    }
    else
    {
        sprintf_s(buffer, _countof(buffer), "<StrideSize>%I64u</StrideSize>\n", GetBlockAlignmentInBytes());
        AddXml(sXml, buffer);
    
        AddXml(sXml, _fInterlockedSequential ?
            "<InterlockedSequential>true</InterlockedSequential>\n" :
            "<InterlockedSequential>false</InterlockedSequential>\n");
    }

    sprintf_s(buffer, _countof(buffer), "<ThreadStride>%I64u</ThreadStride>\n", _ullThreadStride);
    AddXml(sXml, buffer);

    sprintf_s(buffer, _countof(buffer), "<MaxFileSize>%I64u</MaxFileSize>\n", _ullMaxFileSize);
    AddXml(sXml, buffer);

    sprintf_s(buffer, _countof(buffer), "<RequestCount>%u</RequestCount>\n", _dwRequestCount);
    AddXml(sXml, buffer);

    sprintf_s(buffer, _countof(buffer), "<WriteRatio>%u</WriteRatio>\n", _ulWriteRatio);
    AddXml(sXml, buffer);

    // Preserve specified units
    if (_dwThroughputIOPS)
    {
        sprintf_s(buffer, _countof(buffer), "<Throughput unit=\"IOPS\">%u</Throughput>\n", _dwThroughputIOPS);
        AddXml(sXml, buffer);
    }
    else
    {
        sprintf_s(buffer, _countof(buffer), "<Throughput>%u</Throughput>\n", _dwThroughputBytesPerMillisecond);
        AddXml(sXml, buffer);
    }

    sprintf_s(buffer, _countof(buffer), "<ThreadsPerFile>%u</ThreadsPerFile>\n", _dwThreadsPerFile);
    AddXml(sXml, buffer);

    if (_ioPriorityHint == IoPriorityHintVeryLow)
    {
        AddXml(sXml, "<IOPriority>1</IOPriority>\n");
    }
    else if (_ioPriorityHint == IoPriorityHintLow)
    {
        AddXml(sXml, "<IOPriority>2</IOPriority>\n");
    }
    else if (_ioPriorityHint == IoPriorityHintNormal)
    {
        AddXml(sXml, "<IOPriority>3</IOPriority>\n");
    }
    else
    {
        AddXml(sXml, "<IOPriority>* UNSUPPORTED *</IOPriority>\n");
    }

    sprintf_s(buffer, _countof(buffer), "<Weight>%u</Weight>\n", _ulWeight);
    AddXml(sXml, buffer);

    if (_vThreadTargets.size() > 0)
    {
        AddXmlInc(sXml, "<ThreadTargets>\n");

        for (const auto& threadTarget : _vThreadTargets)
        {
            sXml += threadTarget.GetXml(indent);
        }

        AddXmlDec(sXml, "</ThreadTargets>\n");
    }

    AddXmlDec(sXml, "</Target>\n");

    return sXml;
}