�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2F'>columnstore</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2Fcolumnstore%2F'>columnstore</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2Fcolumnstore%2Ftests%2F'>tests</a>/</p><hr><h3>✏️ Editing: brm-em-standalone.cpp</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* Copyright (C) 2014 InfiniDB, Inc.
   Copyright (C) 2016-2021 MariaDB Corporation

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; version 2 of
   the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

/*****************************************************************************
 * $Id: tdriver-dbrm2.cpp 1823 2013-01-21 14:13:09Z rdempsey $
 *
 ****************************************************************************/

#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;pthread.h&gt;
#include &lt;errno.h&gt;
#include &lt;sys/types.h&gt;
#include &lt;sys/ipc.h&gt;
#include &lt;sys/sem.h&gt;
#include &lt;sys/shm.h&gt;
#include &lt;stdexcept&gt;
#include &lt;pthread.h&gt;
#include &lt;sys/time.h&gt;
#include &lt;values.h&gt;

#include &lt;cppunit/extensions/HelperMacros.h&gt;

#include &quot;brm.h&quot;
#include &quot;extentmap.h&quot;
#include &quot;IDBPolicy.h&quot;

//#define BRM_VERBOSE 1

using namespace BRM;
using namespace std;

int threadStop;
int oid = 1;
uint64_t opCount = 0;
LBID_t lbidCounter = 0;
VER_t nextTxnID = 1;
u_int64_t vbOffset = 0;
pthread_mutex_t pthreadMutex;
const std::vector&lt;uint32_t&gt; colWidthsAvailable = {1, 2, 4, 8, 16};
const DBRootT dbroot = 1;

struct Range
{
    LBID_t start, end, nextBlock;
    VER_t txnID;
    Range()
    {
        start = end = nextBlock = 0;
        txnID = 0;
    }
};

struct EMEntries
{
    LBID_t LBIDstart;
    uint32_t size;
    OID_t OID;
    uint32_t FBO;
    uint32_t HWM;
    uint32_t secondHWM;
    int32_t txnID;
    DBRootT dbroot;
    PartitionNumberT partNum;
    SegmentT segNum;
    struct EMEntries* next;
    EMEntries() : HWM(0), secondHWM(0), txnID(0), next(nullptr)
    { }
    EMEntries(const uint32_t aSize, const OID_t aOid, const uint32_t aFbo,
        const LBID_t aLBIDStart, EMEntries* aNext)
            : LBIDstart(aLBIDStart), size(aSize), OID(aOid), FBO(aFbo), HWM(0),
              secondHWM(0), txnID(0), next(aNext)
    { }
    EMEntries(const uint32_t aSize, const OID_t aOid, const uint32_t aFbo,
        const LBID_t aLBIDStart, EMEntries* aNext, const DBRootT aDbroot,
        const PartitionNumberT aPartNum, const SegmentT aSegNum)
            : LBIDstart(aLBIDStart), size(aSize), OID(aOid), FBO(aFbo), HWM(0),
              secondHWM(0), txnID(0), dbroot(aDbroot), partNum(aPartNum),
              segNum(aSegNum), next(aNext)
   { }
};
/*
static void* BRMRunner_2(void* arg)
{

    vector&lt;Range&gt; copyList, copiedList, committedList;
    vector&lt;Range&gt;::iterator rit;
    vector&lt;LBID_t&gt; writtenList;
    vector&lt;LBID_t&gt;::iterator lit;

    pthread_mutex_t listMutex;
    int op;
    uint32_t randstate;
    DBRM* brm;
    struct timeval tv;
    VER_t txnID;

    pthread_mutex_init(&amp;listMutex, NULL);
    gettimeofday(&amp;tv, NULL);
    randstate = static_cast&lt;uint32_t&gt;(tv.tv_usec);
    brm = new DBRM();

    while (!threadStop)
    {
        op = rand_r(&amp;randstate) % 9;

        switch (op)
        {
            case 0:   // beginVBCopy
            {
                int blockCount, size, err;
                Range newEntry;
                VBRange_v vbRanges;
                VBRange_v::iterator vit;
                LBIDRange_v ranges;
                LBIDRange range;

                size = rand_r(&amp;randstate) % 10000;

                pthread_mutex_lock(&amp;pthreadMutex);
                newEntry.start = lbidCounter;
                lbidCounter += size;
                txnID = nextTxnID++;
                pthread_mutex_unlock(&amp;pthreadMutex);

                newEntry.nextBlock = newEntry.start;
                newEntry.end = newEntry.start + size;
                range.start = newEntry.start;
                range.size = size;

                err = brm-&gt;beginVBCopy(txnID, dbroot, ranges, vbRanges);
                CPPUNIT_ASSERT(err == 0);

                for (blockCount = 0, vit = vbRanges.begin(); vit != vbRanges.end(); vit++)
                    blockCount += (*vit).size;

                CPPUNIT_ASSERT(blockCount == size);

                pthread_mutex_lock(&amp;listMutex);
                copyList.push_back(newEntry);
                pthread_mutex_unlock(&amp;listMutex);

                err = brm-&gt;beginVBCopy(txnID, dbroot, ranges, vbRanges);
                CPPUNIT_ASSERT(err == -1);
                break;
            }

            case 1:		// writeVBEntry
            {
                int randIndex;
                Range* entry;

                pthread_mutex_lock(&amp;listMutex);

                if (copyList.size() == 0)
                    break;

                randIndex = rand_r(&amp;randstate) % copyList.size();
                entry = &amp;(copyList[randIndex]);
                entry-&gt;nextBlock++;
                txnID = entry-&gt;txnID;
                break;
            }

            default:
                cerr &lt;&lt; &quot;not finished yet&quot; &lt;&lt; endl;
        }
    }

    return NULL;
}
*/

/*
static void* BRMRunner_1(void* arg)
{

    // keep track of LBID ranges allocated here and
    // randomly allocate, lookup, delete, get/set HWM, and
    // destroy the EM object.

#ifdef BRM_VERBOSE
    int threadNum = reinterpret_cast&lt;int&gt;(arg);
#endif
    int op, listSize = 0, i;
    uint32_t randstate;
    struct EMEntries* head = NULL, *tmp;
    struct timeval tv;
    DBRM* brm;
    ExtentMap em;
    vector&lt;LBID_t&gt; lbids;
    LBID_t lbid;
    uint32_t colWidth;
    PartitionNumberT partNum;
    SegmentT segmentNum;
    execplan::CalpontSystemCatalog::ColDataType colDataType;

#ifdef BRM_VERBOSE
    cerr &lt;&lt; &quot;thread number &quot; &lt;&lt; threadNum &lt;&lt; &quot; started.&quot; &lt;&lt; endl;
#endif

    gettimeofday(&amp;tv, NULL);
    randstate = static_cast&lt;uint32_t&gt;(tv.tv_usec);
    brm = new DBRM();


    while (!threadStop)
    {
        auto randNumber = rand_r(&amp;randstate);
        op = randNumber % 10;
        colWidth = colWidthsAvailable[randNumber % colWidthsAvailable.size()];
        partNum = randNumber % std::numeric_limits&lt;PartitionNumberT&gt;::max();
        segmentNum = randNumber % std::numeric_limits&lt;SegmentT&gt;::max();
        colDataType = (execplan::CalpontSystemCatalog::ColDataType) (randNumber % (int)execplan::CalpontSystemCatalog::ColDataType::TIMESTAMP);
#ifdef BRM_VERBOSE
        cerr &lt;&lt; &quot;next op is &quot; &lt;&lt; op &lt;&lt; endl;
#endif

        switch (op)
        {
            case 0:   //allocate space for a new file
            {
                struct EMEntries* newEm;
                size_t size = rand_r(&amp;randstate) % 102399 + 1;
                int entries, OID, allocdSize, err;
                uint32_t startBlockOffset;


                pthread_mutex_lock(&amp;pthreadMutex);
                OID = oid++;
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                lbids.clear();
                for (size_t i = 0; i &lt; size; ++i)
                {
                    err = brm-&gt;createColumnExtent_DBroot(OID, colWidth, dbroot,
                        partNum, segmentNum, colDataType, lbid, allocdSize, startBlockOffset);
                    CPPUNIT_ASSERT(err == 0);
                    lbids.push_back(lbid);
                }

                entries = size / brm-&gt;getExtentSize();

                if ((size % brm-&gt;getExtentSize()) != 0)
                    entries++;

                if ((uint32_t)entries != lbids.size())
                    cerr &lt;&lt; &quot;entries = &quot; &lt;&lt; entries &lt;&lt; &quot; lbids.size = &quot; &lt;&lt; lbids.size() &lt;&lt; endl;

                CPPUNIT_ASSERT((uint32_t)entries == lbids.size());

                for (i = 0 ; i &lt; entries; i++)
                {

                    newEm = new EMEntries(brm-&gt;getExtentSize(), OID, brm-&gt;getExtentSize(), lbids[i],
                        head, dbroot, partNum, segmentNum);
                    head = newEm;
                    listSize++;
                }

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;created new space for OID &quot; &lt;&lt; newEm-&gt;OID &lt;&lt; endl;
#endif
                em.checkConsistency();
                break;
            }

            case 1:		//allocate space for an existing file
            {
                if (listSize == 0)
                    break;

                struct EMEntries* newEm, *tmp;
                int size = rand_r(&amp;randstate) % 102399 + 1;
                int fileRand = rand_r(&amp;randstate) % listSize;
                int i, lastExtent, blockEnd, oid;
                int tmpHWM, entries, allocdSize, err;
                uint32_t startBlockOffset;
                vector&lt;LBID_t&gt; lbids;
                LBID_t lbid;

                for (i = 0, tmp = head; i &lt; fileRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;

                for (lastExtent = 0, tmp = head; tmp != NULL; tmp = tmp-&gt;next)
                {
                    if (tmp-&gt;OID != oid)
                        continue;

                    tmpHWM = tmp-&gt;HWM;
                    blockEnd = tmp-&gt;FBO + tmp-&gt;size;

                    if (lastExtent &lt; blockEnd)
                        lastExtent = blockEnd;
                }

                err = brm-&gt;createColumnExtentExactFile(oid, colWidth, dbroot,
                    partNum, segmentNum, colDataType, lbid, allocdSize, startBlockOffset);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);

                entries = size / brm-&gt;getExtentSize();

                if ((size % brm-&gt;getExtentSize()) != 0)
                    entries++;

                CPPUNIT_ASSERT((uint32_t)entries == lbids.size());

                for (i = 0; i &lt; entries; i++)
                {

                    newEm = new EMEntries((i != entries) ? brm-&gt;getExtentSize() : size % brm-&gt;getExtentSize(),
                       oid, lastExtent + (i * brm-&gt;getExtentSize()),
                       lbids[i], head, dbroot, partNum, segmentNum);
                    newEm-&gt;HWM = tmpHWM;
                    head = newEm;
                    listSize++;
                }

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;created another extent for OID &quot; &lt;&lt; newEm-&gt;OID &lt;&lt; endl;
#endif
                em.checkConsistency();
                break;
            }

            case 2:  			//delete an OID
            {
                if (listSize == 0)
                    break;

                struct EMEntries* tmp, *prev;
                int fileRand = rand_r(&amp;randstate) % listSize;
                int i, oid, err;

                for (i = 0, tmp = head; i &lt; fileRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;

                err = brm-&gt;deleteOID(oid);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);

                for (tmp = head; tmp != NULL;)
                {
                    if (tmp-&gt;OID == oid)
                    {
                        if (tmp == head)
                        {
                            head = head-&gt;next;
                            delete tmp;
                            tmp = head;
                        }
                        else
                        {
                            prev-&gt;next = tmp-&gt;next;
                            delete tmp;
                            tmp = prev-&gt;next;
                        }

                        listSize--;
                    }
                    else
                    {
                        prev = tmp;
                        tmp = tmp-&gt;next;
                    }
                }

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;deleted OID &quot; &lt;&lt; oid &lt;&lt; endl;
#endif
                em.checkConsistency();
                break;
            }

            case 3:   //lookup by LBID
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset, oid;
                struct EMEntries* tmp;
                LBID_t target;
                uint32_t fbo;
                DBRootT localDbroot;
                PartitionNumberT localPartNum;
                SegmentT localSegmentNum;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;

                target = tmp-&gt;LBIDstart + offset;
                err = brm-&gt;lookupLocal(target, 0, false, oid, localDbroot, localPartNum,
                    localSegmentNum, fbo);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;looked up LBID &quot; &lt;&lt; target &lt;&lt; &quot; got oid &quot; &lt;&lt; oid &lt;&lt; &quot; fbo &quot; &lt;&lt; fbo &lt;&lt; endl;
                cerr &lt;&lt; &quot;   oid should be &quot; &lt;&lt; tmp-&gt;OID &lt;&lt; &quot; fbo should be &quot; &lt;&lt; offset + tmp-&gt;FBO &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(oid == tmp-&gt;OID);
                CPPUNIT_ASSERT(fbo == offset + tmp-&gt;FBO);
                em.checkConsistency();
                break;
            }

            case 4:   //lookup by OID, FBO
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, oid, err, offset;
                struct EMEntries* tmp;
                LBID_t lbid;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;
                oid = tmp-&gt;OID;

                err = brm-&gt;lookupLocal(oid, partNum, segmentNum, offset + tmp-&gt;FBO, lbid);

                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;looked up OID &quot; &lt;&lt; oid &lt;&lt; &quot; fbo &quot; &lt;&lt; offset + tmp-&gt;FBO &lt;&lt;
                     &quot; got lbid &quot; &lt;&lt; lbid &lt;&lt; endl;
                cerr &lt;&lt; &quot;  lbid should be &quot; &lt;&lt; tmp-&gt;LBIDstart + offset &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(lbid == static_cast&lt;LBID_t&gt;(tmp-&gt;LBIDstart + offset));
                em.checkConsistency();
                break;
            }

            case 5:		//getHWM
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, status;
                struct EMEntries* tmp;
                uint32_t hwm;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;
                err = brm-&gt;getLocalHWM(tmp-&gt;OID, partNum, segmentNum, hwm, status);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;stored HWM for OID &quot; &lt;&lt; tmp-&gt;OID &lt;&lt; &quot; is &quot; &lt;&lt; tmp-&gt;HWM
                     &lt;&lt; &quot; BRM says it&#039;s &quot; &lt;&lt; hwm &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(hwm == tmp-&gt;HWM);
                em.checkConsistency();
                break;
            }

            case 6: 		//setHWM
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, hwm, oid, err;
                struct EMEntries* tmp;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;
                hwm = rand_r(&amp;randstate) % (tmp-&gt;FBO + brm-&gt;getExtentSize());
                err = brm-&gt;setLocalHWM(oid, tmp-&gt;partNum, tmp-&gt;segNum, hwm);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);

                for (tmp = head; tmp != NULL; tmp = tmp-&gt;next)
                    if (tmp-&gt;OID == oid)
                        tmp-&gt;HWM = hwm;

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;setHWM of OID &quot; &lt;&lt; oid &lt;&lt; &quot; to &quot; &lt;&lt; hwm &lt;&lt; endl;
#endif
                em.checkConsistency();
                break;
            }

            case 7:			// renew this EM object
            {
                delete brm;
                brm = new DBRM();
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;got a new BRM instance&quot; &lt;&lt; endl;
#endif
                em.checkConsistency();
                break;
            }
#if 0
            case 8:			//getBulkInsertVars
            {
                if (listSize == 0)
                    break;

                HWM_t hwm;
                VER_t txnID;
                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset;
                EMEntries* tmp;
                LBID_t lbid;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;
                lbid = tmp-&gt;LBIDstart + offset;
                err = brm-&gt;getBulkInsertVars(lbid, hwm, txnID);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(hwm == tmp-&gt;secondHWM);
                CPPUNIT_ASSERT(txnID == tmp-&gt;txnID);
                break;
            }

            case 9:			//setBulkInsertVars
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset;
                EMEntries* tmp;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;
                tmp-&gt;secondHWM = rand_r(&amp;randstate) % MAXINT;
                tmp-&gt;txnID = rand_r(&amp;randstate) % MAXINT;
                err = brm-&gt;setBulkInsertVars(tmp-&gt;LBIDstart + offset,
                                             tmp-&gt;secondHWM, tmp-&gt;txnID);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);
                break;
            }
#endif
            default:
                break;
        }
    }

    delete brm;

    while (head != NULL)
    {
        tmp = head-&gt;next;
        delete head;
        head = tmp;
    }

#ifdef BRM_VERBOSE
    cerr &lt;&lt; &quot;thread &quot; &lt;&lt; threadNum &lt;&lt; &quot; exiting&quot; &lt;&lt; endl;
#endif
    return NULL;
}
*/
DBRM brm_si;
/*
static void* BRMRunner_si(void* arg)
{

    // keep track of LBID ranges allocated here and
    // randomly allocate, lookup, delete, get/set HWM, and
    // destroy the EM object.

#ifdef BRM_VERBOSE
    int threadNum = reinterpret_cast&lt;int&gt;(arg);
#endif
    int op, listSize = 0, i;
    uint32_t randstate;
    struct EMEntries* head = NULL, *tmp;
    struct timeval tv;
    ExtentMap em;
    vector&lt;LBID_t&gt; lbids;

#ifdef BRM_VERBOSE
    cerr &lt;&lt; &quot;thread number &quot; &lt;&lt; threadNum &lt;&lt; &quot; started.&quot; &lt;&lt; endl;
#endif

    gettimeofday(&amp;tv, NULL);
    randstate = static_cast&lt;uint32_t&gt;(tv.tv_usec);

    while (!threadStop)
    {
        op = rand_r(&amp;randstate) % 10;
#ifdef BRM_VERBOSE
        cerr &lt;&lt; &quot;next op is &quot; &lt;&lt; op &lt;&lt; endl;
#endif

        switch (op)
        {
            case 0:   //allocate space for a new file
            {
                struct EMEntries* newEm;
                int size = rand_r(&amp;randstate) % 102399 + 1;
                int entries, OID, allocdSize, err;

                pthread_mutex_lock(&amp;pthreadMutex);
                OID = oid++;
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);

                err = brm_si.createExtent(size, OID, lbids, allocdSize);
                CPPUNIT_ASSERT(err == 0);

                entries = size / brm_si.getExtentSize();

                if ((size % brm_si.getExtentSize()) != 0)
                    entries++;

                CPPUNIT_ASSERT((uint32_t)entries == lbids.size());

                for (i = 0 ; i &lt; entries; i++)
                {

                    newEm = new EMEntries();
                    newEm-&gt;size = brm_si.getExtentSize();
                    newEm-&gt;OID = OID;
                    newEm-&gt;FBO = i * brm_si.getExtentSize();
                    newEm-&gt;LBIDstart = lbids[i];

                    newEm-&gt;next = head;
                    head = newEm;
                    listSize++;
                }

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;created new space for OID &quot; &lt;&lt; newEm-&gt;OID &lt;&lt; endl;
#endif
                em.checkConsistency();
                break;
            }

            case 1:		//allocate space for an existing file
            {
                if (listSize == 0)
                    break;

                struct EMEntries* newEm, *tmp;
                int size = rand_r(&amp;randstate) % 102399 + 1;
                int fileRand = rand_r(&amp;randstate) % listSize;
                int i, lastExtent, blockEnd, oid;
                int tmpHWM, entries, allocdSize, err;
                vector&lt;LBID_t&gt; lbids;

                for (i = 0, tmp = head; i &lt; fileRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;

                for (lastExtent = 0, tmp = head; tmp != NULL; tmp = tmp-&gt;next)
                {
                    if (tmp-&gt;OID != oid)
                        continue;

                    tmpHWM = tmp-&gt;HWM;
                    blockEnd = tmp-&gt;FBO + tmp-&gt;size;

                    if (lastExtent &lt; blockEnd)
                        lastExtent = blockEnd;
                }

                err = brm_si.createExtent(size, oid, lbids, allocdSize);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);

                entries = size / brm_si.getExtentSize();

                if ((size % brm_si.getExtentSize()) != 0)
                    entries++;

                CPPUNIT_ASSERT((uint32_t)entries == lbids.size());

                for (i = 0; i &lt; entries; i++)
                {

                    newEm = new EMEntries();

                    if (i != entries)
                        newEm-&gt;size = brm_si.getExtentSize();
                    else
                        newEm-&gt;size = size % brm_si.getExtentSize();

                    newEm-&gt;OID = oid;
                    newEm-&gt;FBO = lastExtent + (i * brm_si.getExtentSize());
                    newEm-&gt;LBIDstart = lbids[i];
                    newEm-&gt;HWM = tmpHWM;

                    newEm-&gt;next = head;
                    head = newEm;
                    listSize++;
                }

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;created another extent for OID &quot; &lt;&lt; newEm-&gt;OID &lt;&lt; endl;
#endif
                em.checkConsistency();
                break;
            }

            case 2:  			//delete an OID
            {
                if (listSize == 0)
                    break;

                struct EMEntries* tmp, *prev;
                int fileRand = rand_r(&amp;randstate) % listSize;
                int i, oid, err;

                for (i = 0, tmp = head; i &lt; fileRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;

                err = brm_si.deleteOID(oid);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);

                for (tmp = head; tmp != NULL;)
                {
                    if (tmp-&gt;OID == oid)
                    {
                        if (tmp == head)
                        {
                            head = head-&gt;next;
                            delete tmp;
                            tmp = head;
                        }
                        else
                        {
                            prev-&gt;next = tmp-&gt;next;
                            delete tmp;
                            tmp = prev-&gt;next;
                        }

                        listSize--;
                    }
                    else
                    {
                        prev = tmp;
                        tmp = tmp-&gt;next;
                    }
                }

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;deleted OID &quot; &lt;&lt; oid &lt;&lt; endl;
#endif
                em.checkConsistency();
                break;
            }

            case 3:   //lookup by LBID
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset, oid;
                struct EMEntries* tmp;
                LBID_t target;
                uint32_t fbo;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;

                target = tmp-&gt;LBIDstart + offset;
                err = brm_si.lookup(target, 0, false, oid, fbo);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;looked up LBID &quot; &lt;&lt; target &lt;&lt; &quot; got oid &quot; &lt;&lt; oid &lt;&lt; &quot; fbo &quot; &lt;&lt; fbo &lt;&lt; endl;
                cerr &lt;&lt; &quot;   oid should be &quot; &lt;&lt; tmp-&gt;OID &lt;&lt; &quot; fbo should be &quot; &lt;&lt; offset + tmp-&gt;FBO &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(oid == tmp-&gt;OID);
                CPPUNIT_ASSERT(fbo == offset + tmp-&gt;FBO);
                em.checkConsistency();
                break;
            }

            case 4:   //lookup by OID, FBO
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, oid, err, offset;
                struct EMEntries* tmp;
                LBID_t lbid;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;
                oid = tmp-&gt;OID;

                err = brm_si.lookup(oid, offset + tmp-&gt;FBO, lbid);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;looked up OID &quot; &lt;&lt; oid &lt;&lt; &quot; fbo &quot; &lt;&lt; offset + tmp-&gt;FBO &lt;&lt;
                     &quot; got lbid &quot; &lt;&lt; lbid &lt;&lt; endl;
                cerr &lt;&lt; &quot;  lbid should be &quot; &lt;&lt; tmp-&gt;LBIDstart + offset &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(lbid == static_cast&lt;LBID_t&gt;(tmp-&gt;LBIDstart + offset));
                em.checkConsistency();
                break;
            }

            case 5:		//getHWM
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err;
                struct EMEntries* tmp;
                uint32_t hwm;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                err = brm_si.getHWM(tmp-&gt;OID, hwm);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;stored HWM for OID &quot; &lt;&lt; tmp-&gt;OID &lt;&lt; &quot; is &quot; &lt;&lt; tmp-&gt;HWM
                     &lt;&lt; &quot; BRM says it&#039;s &quot; &lt;&lt; hwm &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(hwm == tmp-&gt;HWM);
                em.checkConsistency();
                break;
            }

            case 6: 		//setHWM
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, hwm, oid, err;
                struct EMEntries* tmp;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;
                hwm = rand_r(&amp;randstate) % (tmp-&gt;FBO + brm_si.getExtentSize());
                err = brm_si.setHWM(oid, hwm);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);

                for (tmp = head; tmp != NULL; tmp = tmp-&gt;next)
                    if (tmp-&gt;OID == oid)
                        tmp-&gt;HWM = hwm;

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;setHWM of OID &quot; &lt;&lt; oid &lt;&lt; &quot; to &quot; &lt;&lt; hwm &lt;&lt; endl;
#endif
                em.checkConsistency();
                break;
            }

            case 7:			//getBulkInsertVars
            {
                if (listSize == 0)
                    break;

                HWM_t hwm;
                VER_t txnID;
                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset;
                EMEntries* tmp;
                LBID_t lbid;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;
                lbid = tmp-&gt;LBIDstart + offset;
                err = brm_si.getBulkInsertVars(lbid, hwm, txnID);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(hwm == tmp-&gt;secondHWM);
                CPPUNIT_ASSERT(txnID == tmp-&gt;txnID);
                break;
            }

            case 8:			//setBulkInsertVars
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset;
                EMEntries* tmp;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;
                tmp-&gt;secondHWM = rand_r(&amp;randstate) % MAXINT;
                tmp-&gt;txnID = rand_r(&amp;randstate) % MAXINT;
                err = brm_si.setBulkInsertVars(tmp-&gt;LBIDstart + offset,
                                               tmp-&gt;secondHWM, tmp-&gt;txnID);
                pthread_mutex_lock(&amp;pthreadMutex);
                opCount++;
                pthread_mutex_unlock(&amp;pthreadMutex);
                CPPUNIT_ASSERT(err == 0);
                break;
            }

            default:
                break;
        }
    }

    while (head != NULL)
    {
        tmp = head-&gt;next;
        delete head;
        head = tmp;
    }

#ifdef BRM_VERBOSE
    cerr &lt;&lt; &quot;thread &quot; &lt;&lt; threadNum &lt;&lt; &quot; exiting&quot; &lt;&lt; endl;
#endif
    return NULL;
}
*/

static void* EMRunner(void* arg)
{
    // keep track of LBID ranges allocated here and
    // randomly allocate, lookup, delete, get/set HWM, and
    // destroy the EM object.

#ifdef BRM_VERBOSE
    uint64_t threadNum = (uint64_t)arg;
#endif
    int op, listSize = 0;
    uint32_t randstate;
    struct EMEntries* head = NULL, *tmp;
    struct timeval tv;
    ExtentMap* em;
    LBID_t lbid;
    uint32_t colWidth;
    PartitionNumberT partNum;
    SegmentT segmentNum;
    execplan::CalpontSystemCatalog::ColDataType colDataType;

#ifdef BRM_VERBOSE
    cerr &lt;&lt; &quot;thread number &quot; &lt;&lt; threadNum &lt;&lt; &quot; started.&quot; &lt;&lt; endl;
#endif

    gettimeofday(&amp;tv, NULL);
    randstate = static_cast&lt;uint32_t&gt;(tv.tv_usec);
    //pthread_mutex_lock(&amp;pthreadMutex);
    em = new ExtentMap();
    //pthread_mutex_unlock(&amp;pthreadMutex);

    while (!threadStop)
    {
        auto randNumber = rand_r(&amp;randstate);
        op = randNumber % 10;

        colWidth = colWidthsAvailable[randNumber % colWidthsAvailable.size()];
        partNum = randNumber % std::numeric_limits&lt;PartitionNumberT&gt;::max();
        segmentNum = randNumber % std::numeric_limits&lt;SegmentT&gt;::max();
        colDataType = (execplan::CalpontSystemCatalog::ColDataType) (randNumber % (int)execplan::CalpontSystemCatalog::ColDataType::TIMESTAMP);
#ifdef BRM_VERBOSE
        cerr &lt;&lt; &quot;next op is &quot; &lt;&lt; op &lt;&lt; endl;
#endif

        switch (op)
        {
            case 0:   //allocate space for a new file
            {
                vector&lt;struct EMEntry&gt; emEntriesVec;
                struct EMEntries* newEm;
                size_t numberOfExtents = randNumber % 4 + 1;
                int OID;
                uint32_t startBlockOffset;

                pthread_mutex_lock(&amp;pthreadMutex);
                OID = oid++;
                pthread_mutex_unlock(&amp;pthreadMutex);

                em-&gt;getExtents(OID, emEntriesVec, false, false, true);
                size_t extentsNumberBefore = emEntriesVec.size();
                int allocdsize;
                for (size_t i = 0; i &lt; numberOfExtents; ++i)
                {
                    em-&gt;createColumnExtent_DBroot(OID, colWidth, dbroot, colDataType,
                        partNum, segmentNum, lbid, allocdsize, startBlockOffset);
                    em-&gt;confirmChanges();

                    newEm = new EMEntries(allocdsize, OID, startBlockOffset, lbid,
                        head, dbroot, partNum, segmentNum);
                    head = newEm;
                    listSize++;
                }

                emEntriesVec.clear();
                em-&gt;getExtents(OID, emEntriesVec, false, false, true);
                size_t extentsNumberAfter = emEntriesVec.size();

                CPPUNIT_ASSERT(extentsNumberBefore + numberOfExtents == extentsNumberAfter);

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;created new space for OID &quot; &lt;&lt; newEm-&gt;OID &lt;&lt; endl;
#endif
                //em-&gt;checkConsistency();
                break;
            }
/*
            case 1:		//allocate space for an existing file
            {
                if (listSize == 0)
                    break;

                struct EMEntries* newEm, *tmp;
                size_t size = rand_r(&amp;randstate) % 10;
                int fileRand = rand_r(&amp;randstate) % listSize;
                int i, lastExtent, blockEnd, oid;
                int tmpHWM, entries, allocdSize;
                uint32_t startBlockOffset;
                lbids.clear();

                for (i = 0, tmp = head; i &lt; fileRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;

                for (lastExtent = 0, tmp = head; tmp != NULL; tmp = tmp-&gt;next)
                {
                    if (tmp-&gt;OID != oid)
                        continue;

                    tmpHWM = tmp-&gt;HWM;
                    blockEnd = tmp-&gt;FBO + tmp-&gt;size;

                    if (lastExtent &lt; blockEnd)
                        lastExtent = blockEnd;
                }

                for (size_t i = 0; i &lt; size; ++i)
                {
                    em-&gt;createColumnExtent_DBroot(oid, colWidth, dbroot, colDataType,
                        partNum, segmentNum, lbid, allocdSize, startBlockOffset);
                    em-&gt;confirmChanges();
                    lbids.push_back(lbid);
                }

                //em-&gt;createExtent(size, oid, lbids, allocdSize);
                //em-&gt;confirmChanges();

                entries = size / em-&gt;getExtentSize();

                if ((size % em-&gt;getExtentSize()) != 0)
                    entries++;

                CPPUNIT_ASSERT((uint32_t)entries == lbids.size());

                for (i = 0; i &lt; entries; i++)
                {
                    newEm = new EMEntries((i != entries) ? em-&gt;getExtentSize() : size % em-&gt;getExtentSize(),
                       oid, lastExtent + (i * em-&gt;getExtentSize()),
                       lbids[i], head, dbroot, partNum, segmentNum);
                    newEm-&gt;HWM = tmpHWM;
                    head = newEm;
                    listSize++;
                }

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;created another extent for OID &quot; &lt;&lt; newEm-&gt;OID &lt;&lt; endl;
#endif
                em-&gt;checkConsistency();
                break;
            }
*/

            case 2:  			//delete an OID
            {
                if (listSize == 0)
                    break;

                struct EMEntries* tmp = nullptr, *prev = nullptr;
                int fileRand = rand_r(&amp;randstate) % listSize;
                int i, oid;

                for (i = 0, tmp = head; i &lt; fileRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;

                em-&gt;deleteOID(oid);
                em-&gt;confirmChanges();

                vector&lt;struct EMEntry&gt; emEntriesVec;
                em-&gt;getExtents(oid, emEntriesVec, false, false, true);
                CPPUNIT_ASSERT(emEntriesVec.empty());

                for (tmp = head; tmp != NULL;)
                {
                    if (tmp-&gt;OID == oid)
                    {
                        if (tmp == head)
                        {
                            head = head-&gt;next;
                            delete tmp;
                            tmp = head;
                        }
                        else
                        {
                            prev-&gt;next = tmp-&gt;next;
                            delete tmp;
                            tmp = prev-&gt;next;
                        }

                        listSize--;
                    }
                    else
                    {
                        prev = tmp;
                        tmp = tmp-&gt;next;
                    }
                }

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;deleted OID &quot; &lt;&lt; oid &lt;&lt; endl;
#endif
                //em-&gt;checkConsistency();
                break;
            }

            case 3:   //lookup by LBID
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset, oid;
                struct EMEntries* tmp;
                LBID_t target;
                uint32_t fbo;
                DBRootT localDbroot;
                PartitionNumberT localPartNum;
                SegmentT localSegmentNum;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % (tmp-&gt;size - 1);

                target = tmp-&gt;LBIDstart + offset;
                err = em-&gt;lookupLocal(target, oid, localDbroot, localPartNum, localSegmentNum, fbo);
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;looked up LBID &quot; &lt;&lt; target &lt;&lt; &quot; got oid &quot; &lt;&lt; oid &lt;&lt; &quot; fbo &quot; &lt;&lt; fbo &lt;&lt; endl;
                cerr &lt;&lt; &quot;   oid should be &quot; &lt;&lt; tmp-&gt;OID &lt;&lt; &quot; fbo should be &quot; &lt;&lt; offset + tmp-&gt;FBO &lt;&lt; endl;
                cerr &lt;&lt; &quot;op 3 fbo &quot; &lt;&lt; fbo &lt;&lt; &quot; offset + tmp-&gt;FBO &quot; &lt;&lt; offset + tmp-&gt;FBO &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(oid == tmp-&gt;OID);
                CPPUNIT_ASSERT(fbo == offset + tmp-&gt;FBO);
                //em-&gt;checkConsistency();
                break;
            }

            case 4:   //lookup by OID, FBO
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, oid, err, offset;
                struct EMEntries* tmp;
                LBID_t lbid;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % (tmp-&gt;size - 1);
                oid = tmp-&gt;OID;

                err = em-&gt;lookupLocal(oid, tmp-&gt;partNum, tmp-&gt;segNum, offset + tmp-&gt;FBO, lbid);
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;looked up OID &quot; &lt;&lt; oid &lt;&lt; &quot; fbo &quot; &lt;&lt; offset + tmp-&gt;FBO &lt;&lt;
                     &quot; got lbid &quot; &lt;&lt; lbid &lt;&lt; endl;
                cerr &lt;&lt; &quot;  lbid should be &quot; &lt;&lt; tmp-&gt;LBIDstart + offset &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(lbid == tmp-&gt;LBIDstart + offset);
                //em-&gt;checkConsistency();
                break;
            }

            case 5:		//getHWM
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, status;
                struct EMEntries* tmp;
                uint32_t hwm;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                hwm = em-&gt;getLocalHWM(tmp-&gt;OID, tmp-&gt;partNum, tmp-&gt;segNum, status);
#ifdef BRM_VERBOSE_I
                cerr &lt;&lt; &quot;stored HWM for OID &quot; &lt;&lt; tmp-&gt;OID &lt;&lt; &quot; is &quot; &lt;&lt; tmp-&gt;HWM
                     &lt;&lt; &quot; BRM says it&#039;s &quot; &lt;&lt; hwm &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(hwm == tmp-&gt;HWM);
                //em-&gt;checkConsistency();
                break;
            }

            case 6: 		//setHWM
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, hwm, oid;
                struct EMEntries* tmp;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;
                hwm = rand_r(&amp;randstate) % (tmp-&gt;size - 1);
                bool firstNode = true;
                em-&gt;setLocalHWM(oid, tmp-&gt;partNum, tmp-&gt;segNum, hwm, firstNode);

                em-&gt;confirmChanges();

                tmp-&gt;HWM = hwm;

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;setHWM of OID &quot; &lt;&lt; oid &lt;&lt; &quot; to &quot; &lt;&lt; hwm &lt;&lt; endl;
#endif
                //em-&gt;checkConsistency();
                break;
            }

/*
            case 7:			// renew this EM object
            {
                delete em;
                em = new ExtentMap();
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;got a new EM instance&quot; &lt;&lt; endl;
#endif
                em-&gt;checkConsistency();
                break;
            }
            case 8:			//getBulkInsertVars
            {
                if (listSize == 0)
                    break;

                HWM_t hwm;
                VER_t txnID;
                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset;
                EMEntries* tmp;
                LBID_t lbid;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;
                lbid = tmp-&gt;LBIDstart + offset;
                err = em-&gt;getBulkInsertVars(lbid, hwm, txnID);
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(hwm == tmp-&gt;secondHWM);
                CPPUNIT_ASSERT(txnID == tmp-&gt;txnID);
                break;
            }

            case 9:			//setBulkInsertVars
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset;
                EMEntries* tmp;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;
                tmp-&gt;secondHWM = rand_r(&amp;randstate) % MAXINT;
                tmp-&gt;txnID = rand_r(&amp;randstate) % MAXINT;
                err = em-&gt;setBulkInsertVars(tmp-&gt;LBIDstart + offset,
                                            tmp-&gt;secondHWM, tmp-&gt;txnID);
                em-&gt;confirmChanges();
                CPPUNIT_ASSERT(err == 0);
                break;
            }
*/
            default:
                break;
        }
    }

    delete em;

    while (head != NULL)
    {
        tmp = head-&gt;next;
        delete head;
        head = tmp;
    }

#ifdef BRM_VERBOSE
    cerr &lt;&lt; &quot;thread &quot; &lt;&lt; threadNum &lt;&lt; &quot; exiting&quot; &lt;&lt; endl;
#endif
    return NULL;
}

/*
ExtentMap em_si;
static void* EMRunner_si(void* arg)
{

    // keep track of LBID ranges allocated here and
    // randomly allocate, lookup, delete, get/set HWM, and
    // destroy the EM object.

#ifdef BRM_VERBOSE
    int threadNum = reinterpret_cast&lt;int&gt;(arg);
#endif
    int op, listSize = 0, i;
    uint32_t randstate;
    struct EMEntries* head = NULL, *tmp;
    struct timeval tv;
    vector&lt;LBID_t&gt; lbids;

#ifdef BRM_VERBOSE
    cerr &lt;&lt; &quot;thread number &quot; &lt;&lt; threadNum &lt;&lt; &quot; started.&quot; &lt;&lt; endl;
#endif

    gettimeofday(&amp;tv, NULL);
    randstate = static_cast&lt;uint32_t&gt;(tv.tv_usec);

    while (!threadStop)
    {
        op = rand_r(&amp;randstate) % 9;
#ifdef BRM_VERBOSE
        cerr &lt;&lt; &quot;next op is &quot; &lt;&lt; op &lt;&lt; endl;
#endif

        switch (op)
        {
            case 0:   //allocate space for a new file
            {
                struct EMEntries* newEm;
                int size = rand_r(&amp;randstate) % 102399 + 1;
                int entries, OID, allocdSize;

                pthread_mutex_lock(&amp;pthreadMutex);
                OID = oid++;
                pthread_mutex_unlock(&amp;pthreadMutex);

                em_si.createExtent(size, OID, lbids, allocdSize);
                em_si.confirmChanges();

                entries = size / em_si.getExtentSize();

                if ((size % em_si.getExtentSize()) != 0)
                    entries++;

                CPPUNIT_ASSERT((uint32_t)entries == lbids.size());

                for (i = 0 ; i &lt; entries; i++)
                {

                    newEm = new EMEntries();
                    newEm-&gt;size = em_si.getExtentSize();
                    newEm-&gt;OID = OID;
                    newEm-&gt;FBO = i * em_si.getExtentSize();
                    newEm-&gt;LBIDstart = lbids[i];

                    newEm-&gt;next = head;
                    head = newEm;
                    listSize++;
                }

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;created new space for OID &quot; &lt;&lt; newEm-&gt;OID &lt;&lt; endl;
#endif
                em_si.checkConsistency();
                break;
            }

            case 1:		//allocate space for an existing file
            {
                if (listSize == 0)
                    break;

                struct EMEntries* newEm, *tmp;
                int size = rand_r(&amp;randstate) % 102399 + 1;
                int fileRand = rand_r(&amp;randstate) % listSize;
                int i, lastExtent, blockEnd, oid;
                int tmpHWM, entries, allocdSize;
                vector&lt;LBID_t&gt; lbids;

                for (i = 0, tmp = head; i &lt; fileRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;

                for (lastExtent = 0, tmp = head; tmp != NULL; tmp = tmp-&gt;next)
                {
                    if (tmp-&gt;OID != oid)
                        continue;

                    tmpHWM = tmp-&gt;HWM;
                    blockEnd = tmp-&gt;FBO + tmp-&gt;size;

                    if (lastExtent &lt; blockEnd)
                        lastExtent = blockEnd;
                }

                em_si.createExtent(size, oid, lbids, allocdSize);
                em_si.confirmChanges();

                entries = size / em_si.getExtentSize();

                if ((size % em_si.getExtentSize()) != 0)
                    entries++;

                CPPUNIT_ASSERT((uint32_t)entries == lbids.size());

                for (i = 0; i &lt; entries; i++)
                {

                    newEm = new EMEntries();

                    if (i != entries)
                        newEm-&gt;size = em_si.getExtentSize();
                    else
                        newEm-&gt;size = size % em_si.getExtentSize();

                    newEm-&gt;OID = oid;
                    newEm-&gt;FBO = lastExtent + (i * em_si.getExtentSize());
                    newEm-&gt;LBIDstart = lbids[i];
                    newEm-&gt;HWM = tmpHWM;

                    newEm-&gt;next = head;
                    head = newEm;
                    listSize++;
                }

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;created another extent for OID &quot; &lt;&lt; newEm-&gt;OID &lt;&lt; endl;
#endif
                em_si.checkConsistency();
                break;
            }

            case 2:  			//delete an OID
            {
                if (listSize == 0)
                    break;

                struct EMEntries* tmp, *prev;
                int fileRand = rand_r(&amp;randstate) % listSize;
                int i, oid;

                for (i = 0, tmp = head; i &lt; fileRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;

                em_si.deleteOID(oid);
                em_si.confirmChanges();

                for (tmp = head; tmp != NULL;)
                {
                    if (tmp-&gt;OID == oid)
                    {
                        if (tmp == head)
                        {
                            head = head-&gt;next;
                            delete tmp;
                            tmp = head;
                        }
                        else
                        {
                            prev-&gt;next = tmp-&gt;next;
                            delete tmp;
                            tmp = prev-&gt;next;
                        }

                        listSize--;
                    }
                    else
                    {
                        prev = tmp;
                        tmp = tmp-&gt;next;
                    }
                }

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;deleted OID &quot; &lt;&lt; oid &lt;&lt; endl;
#endif
                em_si.checkConsistency();
                break;
            }

            case 3:   //lookup by LBID
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset, oid;
                struct EMEntries* tmp;
                LBID_t target;
                uint32_t fbo;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;

                target = tmp-&gt;LBIDstart + offset;
                err = em_si.lookup(target, oid, fbo);
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;looked up LBID &quot; &lt;&lt; target &lt;&lt; &quot; got oid &quot; &lt;&lt; oid &lt;&lt; &quot; fbo &quot; &lt;&lt; fbo &lt;&lt; endl;
                cerr &lt;&lt; &quot;   oid should be &quot; &lt;&lt; tmp-&gt;OID &lt;&lt; &quot; fbo should be &quot; &lt;&lt; offset + tmp-&gt;FBO &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(oid == tmp-&gt;OID);
                CPPUNIT_ASSERT(fbo == offset + tmp-&gt;FBO);
                em_si.checkConsistency();
                break;
            }

            case 4:   //lookup by OID, FBO
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, oid, err, offset;
                struct EMEntries* tmp;
                LBID_t lbid;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;
                oid = tmp-&gt;OID;

                err = em_si.lookup(oid, offset + tmp-&gt;FBO, lbid);
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;looked up OID &quot; &lt;&lt; oid &lt;&lt; &quot; fbo &quot; &lt;&lt; offset + tmp-&gt;FBO &lt;&lt;
                     &quot; got lbid &quot; &lt;&lt; lbid &lt;&lt; endl;
                cerr &lt;&lt; &quot;  lbid should be &quot; &lt;&lt; tmp-&gt;LBIDstart + offset &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(lbid == tmp-&gt;LBIDstart + offset);
                em_si.checkConsistency();
                break;
            }

            case 5:		//getHWM
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i;
                struct EMEntries* tmp;
                uint32_t hwm;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                hwm = em_si.getHWM(tmp-&gt;OID);
#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;stored HWM for OID &quot; &lt;&lt; tmp-&gt;OID &lt;&lt; &quot; is &quot; &lt;&lt; tmp-&gt;HWM
                     &lt;&lt; &quot; BRM says it&#039;s &quot; &lt;&lt; hwm &lt;&lt; endl;
#endif
                CPPUNIT_ASSERT(hwm == tmp-&gt;HWM);
                em_si.checkConsistency();
                break;
            }

            case 6: 		//setHWM
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, hwm, oid;
                struct EMEntries* tmp;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                oid = tmp-&gt;OID;
                hwm = rand_r(&amp;randstate) % (tmp-&gt;FBO + em_si.getExtentSize());
                em_si.setHWM(oid, hwm);
                em_si.confirmChanges();

                for (tmp = head; tmp != NULL; tmp = tmp-&gt;next)
                    if (tmp-&gt;OID == oid)
                        tmp-&gt;HWM = hwm;

#ifdef BRM_VERBOSE
                cerr &lt;&lt; &quot;setHWM of OID &quot; &lt;&lt; oid &lt;&lt; &quot; to &quot; &lt;&lt; hwm &lt;&lt; endl;
#endif
                em_si.checkConsistency();
                break;
            }

            case 7:			//getBulkInsertVars
            {
                if (listSize == 0)
                    break;

                HWM_t hwm;
                VER_t txnID;
                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset;
                EMEntries* tmp;
                LBID_t lbid;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;
                lbid = tmp-&gt;LBIDstart + offset;
                err = em_si.getBulkInsertVars(lbid, hwm, txnID);
                CPPUNIT_ASSERT(err == 0);
                CPPUNIT_ASSERT(hwm == tmp-&gt;secondHWM);
                CPPUNIT_ASSERT(txnID == tmp-&gt;txnID);
                break;
            }

            case 8:			//setBulkInsertVars
            {
                if (listSize == 0)
                    break;

                int entryRand = rand_r(&amp;randstate) % listSize;
                int i, err, offset;
                EMEntries* tmp;

                for (i = 0, tmp = head; i &lt; entryRand; i++)
                    tmp = tmp-&gt;next;

                offset = rand_r(&amp;randstate) % tmp-&gt;size;
                tmp-&gt;secondHWM = rand_r(&amp;randstate) % MAXINT;
                tmp-&gt;txnID = rand_r(&amp;randstate) % MAXINT;
                err = em_si.setBulkInsertVars(tmp-&gt;LBIDstart + offset,
                                              tmp-&gt;secondHWM, tmp-&gt;txnID);
                em_si.confirmChanges();
                CPPUNIT_ASSERT(err == 0);
                break;
            }

            default:
                break;
        }
    }

    while (head != NULL)
    {
        tmp = head-&gt;next;
        delete head;
        head = tmp;
    }

#ifdef BRM_VERBOSE
    cerr &lt;&lt; &quot;thread &quot; &lt;&lt; threadNum &lt;&lt; &quot; exiting&quot; &lt;&lt; endl;
#endif
    return NULL;
}
*/


class LongBRMTests : public CppUnit::TestFixture
{

    CPPUNIT_TEST_SUITE(LongBRMTests);

  	CPPUNIT_TEST(longEMTest_1);
// 	CPPUNIT_TEST(longEMTest_2);
//    CPPUNIT_TEST(longBRMTest_1);
//    CPPUNIT_TEST(longBRMTest_2);

    CPPUNIT_TEST_SUITE_END();

private:
public:
    void longEMTest_1()
    {
        const int threadCount = 10;
        int i;
        pthread_t threads[threadCount];

        cerr &lt;&lt; endl &lt;&lt; &quot;Multithreaded, multiple instance ExtentMap test.  &quot;
             &quot;This runs for 5 minutes.&quot; &lt;&lt; endl;

        threadStop = 0;
        pthread_mutex_init(&amp;pthreadMutex, nullptr);

        for (i = 0; i &lt; threadCount; i++)
        {
            if (pthread_create(&amp;threads[i], NULL, EMRunner,
                               reinterpret_cast&lt;void*&gt;(i + 1)) &lt; 0)
                throw logic_error(&quot;Error creating threads for the ExtentMap test&quot;);

            usleep(1000);
        }

        sleep(300);
        threadStop = 1;

        for (i = 0; i &lt; threadCount; i++)
        {
            cerr &lt;&lt; &quot;Waiting for thread #&quot; &lt;&lt; i &lt;&lt; endl;
            pthread_join(threads[i], nullptr);
        }
    }

/*
    void longEMTest_2()
    {
        const int threadCount = 10;
        int i;
        pthread_t threads[threadCount];

        cerr &lt;&lt; endl &lt;&lt; &quot;Multithreaded, single instance ExtentMap test.  &quot;
             &quot;This runs for 5 minutes.&quot; &lt;&lt; endl;

        threadStop = 0;
        pthread_mutex_init(&amp;pthreadMutex, NULL);

        for (i = 0; i &lt; threadCount; i++)
        {
            if (pthread_create(&amp;threads[i], NULL, EMRunner_si,
                               reinterpret_cast&lt;void*&gt;(i + 1)) &lt; 0)
                throw logic_error(&quot;Error creating threads for the ExtentMap test&quot;);

            usleep(1000);
        }

        sleep(60);
        threadStop = 1;

        for (i = 0; i &lt; threadCount; i++)
        {
            cerr &lt;&lt; &quot;Waiting for thread #&quot; &lt;&lt; i &lt;&lt; endl;
            pthread_join(threads[i], NULL);
        }
    }
    void longBRMTest_1()
    {
        const int threadCount = 10;
        int i;
        pthread_t threads[threadCount];

        cerr &lt;&lt; endl &lt;&lt; &quot;Multithreaded, multiple instance DBRM test.  &quot;
             &quot;This runs for 5 minutes.&quot; &lt;&lt; endl;

        threadStop = 0;
        pthread_mutex_init(&amp;pthreadMutex, NULL);
        opCount = 0;

        for (i = 0; i &lt; threadCount; i++)
        {
            if (pthread_create(&amp;threads[i], NULL, BRMRunner_1,
                               reinterpret_cast&lt;void*&gt;(i + 1)) &lt; 0)
                throw logic_error(&quot;Error creating threads for the DBRM test&quot;);

            usleep(1000);
        }

        sleep(300);
        threadStop = 1;

        for (i = 0; i &lt; threadCount; i++)
        {
            cerr &lt;&lt; &quot;Waiting for thread #&quot; &lt;&lt; i &lt;&lt; endl;
            pthread_join(threads[i], NULL);
        }

        cerr &lt;&lt; &quot;opCount = &quot; &lt;&lt; opCount &lt;&lt; endl;
    }
    void longBRMTest_2()
    {
        const int threadCount = 10;
        int i;
        pthread_t threads[threadCount];

        cerr &lt;&lt; endl &lt;&lt; &quot;Multithreaded, single instance DBRM test.  &quot;
             &quot;This runs for 5 minutes.&quot; &lt;&lt; endl;

        threadStop = 0;
        pthread_mutex_init(&amp;pthreadMutex, NULL);
        opCount = 0;

        for (i = 0; i &lt; threadCount; i++)
        {
            if (pthread_create(&amp;threads[i], NULL, BRMRunner_si,
                               reinterpret_cast&lt;void*&gt;(i + 1)) &lt; 0)
                throw logic_error(&quot;Error creating threads for the DBRM test&quot;);

            usleep(1000);
        }

        sleep(300);
        threadStop = 1;

        for (i = 0; i &lt; threadCount; i++)
        {
            cerr &lt;&lt; &quot;Waiting for thread #&quot; &lt;&lt; i &lt;&lt; endl;
            pthread_join(threads[i], NULL);
        }

        cerr &lt;&lt; &quot;opCount = &quot; &lt;&lt; opCount &lt;&lt; endl;
    }
*/

};
CPPUNIT_TEST_SUITE_REGISTRATION( LongBRMTests );

#include &lt;cppunit/extensions/TestFactoryRegistry.h&gt;
#include &lt;cppunit/ui/text/TestRunner.h&gt;

int main( int argc, char** argv)
{
    CppUnit::TextUi::TestRunner runner;
    CppUnit::TestFactoryRegistry&amp; registry = CppUnit::TestFactoryRegistry::getRegistry();
    runner.addTest( registry.makeTest() );
    idbdatafile::IDBPolicy::configIDBPolicy();
    bool wasSuccessful = runner.run( &quot;&quot;, false );
    return (wasSuccessful ? 0 : 1);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2Fcolumnstore%2Ftests'>🔙 Back</a></p>