windows-server-2003/com/oleutest/perform/cairole/tests/bm_nstg.cxx

//+------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1993.
//
//  File:	bm_nstg.cxx
//
//  Contents:	Nested Storage test
//
//  Classes:	CNestedStorageTest
//
//  History:    09-June-94 t-vadims    Created
//
//--------------------------------------------------------------------------
#include <headers.cxx>
#pragma hdrstop

#include <bm_nstg.hxx>

#define  DEF_DATASIZE    4096
#define  INFINITY	 0xffffffff	// max value of 32-bit ulong
			        
TCHAR *CNestedStorageTest::Name ()
{
    return TEXT("NestedStorageTest");
}


SCODE CNestedStorageTest::Setup (CTestInput *pInput)
{
    SCODE sc;
    ULONG iIndex;
    TCHAR pszBuf[15];
    
    CTestBase::Setup(pInput);

    //	get iteration count
    m_ulIterations = pInput->GetIterations(Name());

    //	initialize timing arrays   
    INIT_RESULTS(m_ulStgCreateDocfile);
    INIT_RESULTS(m_ulFinalStorageCommit);
    INIT_RESULTS(m_ulFinalStorageRelease);

    for(iIndex = 0; iIndex <TEST_MAX_ITERATIONS; iIndex++)
    {
	m_ulCreateStorageTotal[iIndex] = 0;
	m_ulCreateStreamTotal[iIndex] = 0;
	m_ulStreamWriteTotal[iIndex] = 0;
	m_ulStreamReleaseTotal[iIndex] = 0;
	m_ulDestroyElementTotal[iIndex] = 0;
	m_ulStorageCommitTotal[iIndex] = 0;
	m_ulStorageReleaseTotal[iIndex] = 0;
	m_ulTotal[iIndex] = 0;

	m_ulCreateStreamMin[iIndex] = INFINITY;
	m_ulStreamWriteMin[iIndex] = INFINITY;
	m_ulStreamReleaseMin[iIndex] = INFINITY;
	m_ulDestroyElementMin[iIndex] = INFINITY;

	m_ulCreateStreamMax[iIndex] = 0;
	m_ulStreamWriteMax[iIndex] = 0;
	m_ulStreamReleaseMax[iIndex] = 0;
	m_ulDestroyElementMax[iIndex] = 0;

	for (ULONG iLevel =0; iLevel < MAX_NESTING; iLevel++)
	{
	    m_ulStorageCommitMin[iLevel][iIndex] = INFINITY;
	    m_ulStorageReleaseMin[iLevel][iIndex] = INFINITY;
	    m_ulCreateStorageMin[iLevel][iIndex] = INFINITY;

	    m_ulCreateStorageMax[iLevel][iIndex] = 0;
	    m_ulStorageCommitMax[iLevel][iIndex] = 0;
	    m_ulStorageReleaseMax[iLevel][iIndex] = 0;
    	}
    }



    sc = InitCOM();
    if (FAILED(sc))
    {
	Log (TEXT("Setup - CoInitialize failed."), sc);
        return	sc;
    }

    // get malloc interface for this task
    m_piMalloc = NULL;
    sc = CoGetMalloc(MEMCTX_TASK, &m_piMalloc);
    if (FAILED(sc))
    {
    	Log (TEXT("Setup - CoGetMalloc"), sc);
    	return sc;
    }

    m_cbSize = pInput->GetConfigInt(Name(), TEXT("DataSize"), DEF_DATASIZE);
 
    // initialize array to be written to the file.  
    m_pbData = (BYTE *)m_piMalloc->Alloc(m_cbSize);
    if(m_pbData == NULL)
    {
    	Log (TEXT("Setup - Cannot allocate memory"), E_OUTOFMEMORY);
	return E_OUTOFMEMORY;
    }

    for (iIndex=0; iIndex < m_cbSize; iIndex++)
        m_pbData[iIndex] = (BYTE)iIndex;


    // get file name to be used and values of other parameters
    pInput->GetConfigString(Name(), TEXT("FileName"), TEXT("stgtest.bm"),
    			    m_pszFile, MAX_PATH);
#ifdef UNICODE
    wcscpy(m_pwszFile, m_pszFile);
#else
    mbstowcs(m_pwszFile, m_pszFile, strlen(m_pszFile)+1);
#endif

    pInput->GetConfigString(Name(), TEXT("FileMode"), TEXT("DIRECT"), m_pszFileMode, 15);

    if(lstrcmpi(m_pszFileMode, TEXT("DIRECT")) == 0)
       	m_flCreateFlags = STGM_DIRECT;
    else 
       	m_flCreateFlags = STGM_TRANSACTED; 	

    // get the nesting factor
    m_cNesting = pInput->GetConfigInt(Name(), TEXT("Nesting"), 3);

    if(m_cNesting > MAX_NESTING)
    	m_cNesting = MAX_NESTING;
    
    if(m_cNesting == 0)
    	m_cNesting = 1;
    	 
    // get the branching factor
    m_cBranching = pInput->GetConfigInt(Name(), TEXT("Branching"), 3);

    if(m_cBranching > MAX_BRANCHING)
    	m_cBranching = MAX_BRANCHING;
    
    if(m_cBranching == 0)
    	m_cBranching = 1;

    // get the value of Delete element option
    pInput->GetConfigString(Name(), TEXT("Delete"), TEXT("OFF"), pszBuf, 15);
    
    if( lstrcmpi(pszBuf, TEXT("OFF")) == 0 ||
        lstrcmpi(pszBuf, TEXT("FALSE")) == 0)
    	m_bDelete = FALSE;
    else
    	m_bDelete = TRUE; 

    // now compute number of streams and storages, depeding on 
    // the nesting and branching factors.  Formulas are as follows:
    // Nesting = n;
    // Branching = b;
    //    	       n
    // Streams    =   b
    //
    //		       n
    //		      b	  - 1 
    // Storages   =  ---------
    //		      b   - 1
    //
    //		        n-1
    //		       b   - 1
    // ParentFactor = ---------
    //                 b   - 1
    //
    // Parent factor is used to determine the parent storage of the stream
    //
    m_cStreams = 1;
    ULONG n = m_cNesting;
    while(n-- > 0)                   // compute b^n
        m_cStreams *= m_cBranching;

    m_cStorages = (m_cStreams - 1) / (m_cBranching - 1);

    m_cParentFactor = (m_cStreams / m_cBranching - 1) / 
    		      (m_cBranching - 1);


    // allocate arrays for storages
    m_piStorages = (LPSTORAGE *)m_piMalloc->Alloc(m_cStorages * 
    						sizeof(LPSTORAGE));
    if (m_piStorages == NULL)
    {
    	Log(TEXT("Cannot allocate memory"), E_OUTOFMEMORY);
	return E_OUTOFMEMORY;
    }

    return S_OK;
}


SCODE CNestedStorageTest::Cleanup ()
{
    //	delete the file
    DeleteFile (m_pszFile);

    // free all memory
    if(m_piMalloc)
    {
    	if (m_pbData)
    	    m_piMalloc->Free(m_pbData);

	if (m_piStorages)
    	    m_piMalloc->Free(m_piStorages);

	m_piMalloc->Release();
	m_piMalloc = NULL;
    }

    UninitCOM();

    return S_OK;
}


// Some macros that are used only in Run() function.

#define  STG_PARENT(iIndex)    ((iIndex - 1) / m_cBranching )
#define  STREAM_PARENT(iIndex) (iIndex / m_cBranching + m_cParentFactor )

// STG_NAME and STREAM_NAME macros are very ugly, but they save
// doing a bunch of allocations and name generation in the beginning.

#define  STG_NAME(iIndex)      (swprintf(pwszBuf, L"Storage%d", iIndex), pwszBuf)
#define  STREAM_NAME(iIndex)   (swprintf(pwszBuf, L"Stream%d", iIndex), pwszBuf)


SCODE CNestedStorageTest::Run ()
{
    CStopWatch   sw;
    HRESULT	 hr;
    ULONG	 cb;
    ULONG        iCurStream;
    LONG	 iCurStg;    // has to be long, not ulong, for looping down to zero.
    LPSTREAM	 piStream;
    ULONG	 iIter;
    OLECHAR	 pwszBuf[20];
    ULONG	 ulTime;
    ULONG	 iLevel;
    ULONG	 iParent;
 

    for (iIter =0; iIter < m_ulIterations; iIter++)
    {

        sw.Reset();
    	hr = StgCreateDocfile(m_pwszFile,  m_flCreateFlags  | STGM_WRITE
           	| STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, &m_piStorages[0]);
	m_ulStgCreateDocfile[iIter] = sw.Read();
  	Log(TEXT("StgCreateDocfile"), hr);
	if (FAILED(hr))
	    return hr;

	// Create a complete tree of storages 
    	for (iCurStg = 1; iCurStg < (LONG)m_cStorages; iCurStg++)
    	{
	    // determine level of curent storage.
	    iLevel = 0;
	    iParent = STG_PARENT(iCurStg);
	    while(iParent > 0)
	    {
	    	iParent = STG_PARENT(iParent);
		iLevel++;
	    }

	    sw.Reset();
 	    hr = m_piStorages[STG_PARENT(iCurStg)]->
 		      CreateStorage(STG_NAME(iCurStg), 
 			      m_flCreateFlags | STGM_WRITE | 
 			      STGM_CREATE | STGM_SHARE_EXCLUSIVE,
 			      0, 0, &m_piStorages[iCurStg]);
	    ulTime = sw.Read();
	    m_ulCreateStorageTotal[iIter] += ulTime;

	    if(ulTime < m_ulCreateStorageMin[iLevel][iIter])
	    	m_ulCreateStorageMin[iLevel][iIter] = ulTime;

	    if(ulTime > m_ulCreateStorageMax[iLevel][iIter])
	    	m_ulCreateStorageMax[iLevel][iIter] = ulTime;

	    if (FAILED(hr))
	    {
	        Log(TEXT("CreateStorage"), hr);
	    	return hr;
	    }
    	}
        Log(TEXT("CreateStorage"), S_OK);
  	// For each storage in final level, open several streams,
	// write some data to them, and release them
	for (iCurStream = 0; iCurStream < m_cStreams; iCurStream++)
    	{
	    sw.Reset();
 	    hr = m_piStorages[STREAM_PARENT(iCurStream)]->
 	               CreateStream(STREAM_NAME(iCurStream), 
 	         	     STGM_DIRECT | STGM_WRITE | 
 	         	     STGM_CREATE | STGM_SHARE_EXCLUSIVE,
 			     0, 0, &piStream);
	    ulTime = sw.Read();
	    m_ulCreateStreamTotal[iIter] += ulTime;

	    if(ulTime < m_ulCreateStreamMin[iIter])
	    	m_ulCreateStreamMin[iIter] = ulTime;

	    if(ulTime > m_ulCreateStreamMax[iIter])
	    	m_ulCreateStreamMax[iIter] = ulTime;

	    if (FAILED(hr))
	    {
	    	Log(TEXT("CreateStream"), hr);
	    	return hr;
	    }

	    sw.Reset();
	    piStream->Write((LPVOID)m_pbData, m_cbSize, &cb);
	    ulTime = sw.Read();
	    m_ulStreamWriteTotal[iIter] += ulTime;

	    if(ulTime < m_ulStreamWriteMin[iIter])
	    	m_ulStreamWriteMin[iIter] = ulTime;

	    if(ulTime > m_ulStreamWriteMax[iIter])
	    	m_ulStreamWriteMax[iIter] = ulTime;

	    sw.Reset();
	    piStream->Release();
	    ulTime = sw.Read();
	    m_ulStreamReleaseTotal[iIter] += ulTime;

	    if(ulTime < m_ulStreamReleaseMin[iIter])
	    	m_ulStreamReleaseMin[iIter] = ulTime;

	    if(ulTime > m_ulStreamReleaseMax[iIter])
	    	m_ulStreamReleaseMax[iIter] = ulTime;
  	}
	Log(TEXT("CreateStream"), S_OK);
	Log(TEXT("StreamWrite"), S_OK);	    
	Log(TEXT("StreamRelease"), S_OK);	    

        if (m_bDelete)
	{
	    // delete 1 stream from every branch.
	    for (iCurStream = 1; iCurStream < m_cStreams; iCurStream += m_cBranching)
    	    {
	    	sw.Reset();
 	    	hr = m_piStorages[STREAM_PARENT(iCurStream)]->
 	               		DestroyElement(STREAM_NAME(iCurStream));
	    	ulTime = sw.Read();
	    	m_ulDestroyElementTotal[iIter] += ulTime;

	    	if (ulTime < m_ulDestroyElementMin[iIter])
	    	    m_ulDestroyElementMin[iIter] = ulTime;

	    	if (ulTime > m_ulDestroyElementMax[iIter])
	    	    m_ulDestroyElementMax[iIter] = ulTime;

	    	if (FAILED(hr))
		{
	    	    Log(TEXT("DestroyElement"), hr);
	    	    return hr;
		}
             }
	     Log( TEXT("DestroyElement"), S_OK);

	     m_ulDestroyElementAverage[iIter] = m_ulDestroyElementTotal[iIter] / 
	     					 (m_cStreams / m_cBranching);
	}
        // for each storage, do commit if in transacted mode
	// and release the storage.
    	for (iCurStg = m_cStorages-1 ; iCurStg >= 0 ; iCurStg--)
    	{
	    // determine level of curent storage.
	    iLevel = 0;
	    iParent = STG_PARENT(iCurStg);
	    while(iParent > 0)
	    {
	    	iParent = STG_PARENT(iParent);
		iLevel++;
	    }

    	    if (m_flCreateFlags == STGM_TRANSACTED)
	    {
	     	sw.Reset();
    	    	m_piStorages[iCurStg]->Commit(STGC_DEFAULT);
	    	ulTime = sw.Read();
	    	m_ulStorageCommitTotal[iIter] += ulTime;

		if (iCurStg != 0)
		{
	    	    if (ulTime < m_ulStorageCommitMin[iLevel][iIter])
	    	    	m_ulStorageCommitMin[iLevel][iIter] = ulTime;

	    	    if (ulTime > m_ulStorageCommitMax[iLevel][iIter])
	    	    	m_ulStorageCommitMax[iLevel][iIter] = ulTime;
		}
		else
		{
		    m_ulFinalStorageCommit[iIter] = ulTime; 
		}
	    }

	    sw.Reset();
    	    m_piStorages[iCurStg]->Release();
	    ulTime = sw.Read();
	    m_ulStorageReleaseTotal[iIter] += ulTime;

	    if (iCurStg != 0)
	    {
	    	if (ulTime < m_ulStorageReleaseMin[iLevel][iIter])
	            m_ulStorageReleaseMin[iLevel][iIter] = ulTime;

	    	if (ulTime > m_ulStorageReleaseMax[iLevel][iIter])
	            m_ulStorageReleaseMax[iLevel][iIter] = ulTime;
	    }
	    else
	    {
		m_ulFinalStorageRelease[iIter] = ulTime; 
	    }
	}

	Log(TEXT("StorageCommit"), S_OK);
	Log(TEXT("StorageRelease"), S_OK);


	m_ulCreateStorageAverage[iIter] = m_ulCreateStorageTotal[iIter] / m_cStorages;
	m_ulCreateStreamAverage[iIter]  = m_ulCreateStreamTotal[iIter]  / m_cStreams;
	m_ulStreamWriteAverage[iIter]   = m_ulStreamWriteTotal[iIter]   / m_cStreams;
	m_ulStreamReleaseAverage[iIter] = m_ulStreamReleaseTotal[iIter] / m_cStreams;
	m_ulStorageCommitAverage[iIter] = m_ulStorageCommitTotal[iIter] / m_cStorages;
	m_ulStorageReleaseAverage[iIter] = m_ulStorageReleaseTotal[iIter] / m_cStorages;

	m_ulTotal[iIter] = m_ulStgCreateDocfile[iIter] +
			   m_ulCreateStorageTotal[iIter] + 
			   m_ulCreateStreamTotal[iIter] +
			   m_ulStreamWriteTotal[iIter] +
			   m_ulStreamReleaseTotal[iIter] +
			   m_ulDestroyElementTotal[iIter] +
			   m_ulStorageCommitTotal[iIter] +
			   m_ulStorageReleaseTotal[iIter];
			      	
    }

    return S_OK;
}


SCODE CNestedStorageTest::Report (CTestOutput &output)
{	       
    TCHAR pszBuf[80];

    wsprintf(pszBuf, TEXT("Nested Storage Test in %s Mode writing %d bytes"),
    	      m_pszFileMode, m_cbSize);

    output.WriteSectionHeader (Name(), pszBuf, *m_pInput);
    output.WriteString (TEXT("\n"));

    for ( ULONG iLevel = 0; iLevel < m_cNesting - 1; iLevel++)
    {
    	wsprintf(pszBuf, TEXT("\nLevel %d\n"), iLevel + 1);
    	output.WriteString (pszBuf);   
    	output.WriteResults (TEXT("CreateStorage    Min"), m_ulIterations, 
    			     m_ulCreateStorageMin[iLevel]);
    	output.WriteResults (TEXT("CreateStorage    Max"), m_ulIterations, 
    			     m_ulCreateStorageMax[iLevel]);

    	if (m_flCreateFlags == STGM_TRANSACTED)
	{
            output.WriteResults (TEXT("StorageCommit    Min"), m_ulIterations, 
            			 m_ulStorageCommitMin[iLevel] );
            output.WriteResults (TEXT("StorageCommit    Max"), m_ulIterations, 
            			 m_ulStorageCommitMax[iLevel] );
	}

    	output.WriteResults (TEXT("StorageRelease   Min"), m_ulIterations, 
    			     m_ulStorageReleaseMin[iLevel]);
    	output.WriteResults (TEXT("StorageRelease   Max"), m_ulIterations, 
    			     m_ulStorageReleaseMax[iLevel]);
    }

    output.WriteString (TEXT("\nOverall\n"));

    output.WriteResults (TEXT("StgCreateDocfile    "), m_ulIterations, 
    			 m_ulStgCreateDocfile);

    if (m_flCreateFlags == STGM_TRANSACTED)
    	output.WriteResults (TEXT("Final Storage Commit"), m_ulIterations, 
    			     m_ulFinalStorageCommit);

    output.WriteResults (TEXT("Final Storage Release"), m_ulIterations, 
    			 m_ulFinalStorageRelease);
    output.WriteString (TEXT("\n"));

    output.WriteResults (TEXT("CreateStorage Average"), m_ulIterations, 
    			 m_ulCreateStorageAverage );
    output.WriteResults (TEXT("CreateStorage  Total"), m_ulIterations, 
    			 m_ulCreateStorageTotal );
    output.WriteString (TEXT("\n"));

    output.WriteResults (TEXT("CreateStream     Min"), m_ulIterations, 
    			 m_ulCreateStreamMin);
    output.WriteResults (TEXT("CreateStream     Max"), m_ulIterations, 
    			 m_ulCreateStreamMax);
    output.WriteResults (TEXT("CreateStream Average"), m_ulIterations, 
    			 m_ulCreateStreamAverage);
    output.WriteResults (TEXT("CreateStream   Total"), m_ulIterations, 
    			 m_ulCreateStreamTotal );
    output.WriteString (TEXT("\n"));

    output.WriteResults (TEXT("StreamWrite      Min"), m_ulIterations, 
    			 m_ulStreamWriteMin );
    output.WriteResults (TEXT("StreamWrite      Max"), m_ulIterations,
    			 m_ulStreamWriteMax );
    output.WriteResults (TEXT("StreamWrite  Average"), m_ulIterations,
    			 m_ulStreamWriteAverage );
    output.WriteResults (TEXT("StreamWrite    Total"), m_ulIterations,
    			 m_ulStreamWriteTotal );
    output.WriteString (TEXT("\n"));

    output.WriteResults (TEXT("StreamRelease    Min"), m_ulIterations,
    			 m_ulStreamReleaseMin );
    output.WriteResults (TEXT("StreamRelease    Max"), m_ulIterations,
    			 m_ulStreamReleaseMax );
    output.WriteResults (TEXT("StreamRelease Average"), m_ulIterations, 
    			 m_ulStreamReleaseAverage );
    output.WriteResults (TEXT("StreamRelease  Total"), m_ulIterations,
    			 m_ulStreamReleaseTotal );
    output.WriteString (TEXT("\n"));

    if(m_bDelete)		       
    {
    	output.WriteResults (TEXT("DestroyElement   Min"), m_ulIterations,
    			     m_ulDestroyElementMin );
    	output.WriteResults (TEXT("DestroyElement   Max"), m_ulIterations, 
    			     m_ulDestroyElementMax );
    	output.WriteResults (TEXT("DestroyElement Average"), m_ulIterations, 
    			     m_ulDestroyElementAverage );
    	output.WriteResults (TEXT("DestroyElement Total"), m_ulIterations, 
    			     m_ulDestroyElementTotal );
    	output.WriteString (TEXT("\n"));
    }

    if (m_flCreateFlags == STGM_TRANSACTED)
    {
        output.WriteResults (TEXT("StorageCommit Average"), m_ulIterations, 
        		     m_ulStorageCommitAverage );
        output.WriteResults (TEXT("StorageCommit   Total"), m_ulIterations, 
        		     m_ulStorageCommitTotal );
    	output.WriteString (TEXT("\n"));
    }

    output.WriteResults (TEXT("StorageRelease Average"), m_ulIterations, 
    			 m_ulStorageReleaseAverage );
    output.WriteResults (TEXT("StorageRelease  Total"), m_ulIterations, 
    			 m_ulStorageReleaseTotal );
    output.WriteString (TEXT("\n"));

    output.WriteResults (TEXT("Overall Total       "), m_ulIterations, m_ulTotal );

    return S_OK;
}