DeadlockMgr Class Reference

Deadlock manager actor. More...

#include <DeadlockMgr.h>

Collaboration diagram for DeadlockMgr:

Public Member Functions
	DeadlockMgr (Topology::partitionAddress *myIdentityArg)
	execute Deadlock Manager actor More...
virtual	~DeadlockMgr ()

Private Member Functions
void	algorithm ()
	wait-for graph algoritm More...
void	deadlock (int64_t transactionid)
bool	walk (int64_t transactionid)
	walk the wait-for graph for items this transactionid is waiting for More...
bool	walk (boost::unordered_set< string >::iterator itemIt)
	walk the wait-for graph for transactions that hold this item More...
void	removeTransaction (int64_t transactionid)
	remove transactionid from wait-for graph More...

Static Private Member Functions
static void	makeLockedItem (bool isrow, int64_t rowid, int64_t tableid, int64_t engineid, int64_t domainid, int64_t fieldid, long double floatentry, std::string *stringentry, std::string *returnstring)
	create item to add to waitfor graph More...

Private Attributes
class Mbox *	mymboxPtr
Topology::partitionAddress	myIdentity
class Mboxes	mboxes
class Topology	myTopology
REUSEMESSAGES boost::unordered_map< int64_t, boost::unordered_set < std::string > >	transactionLocksMap
boost::unordered_map< int64_t, boost::unordered_set < std::string > >	transactionWaitsMap
boost::unordered_map < std::string, boost::unordered_set< int64_t > >	locksTransactionMap
boost::unordered_map < std::string, boost::unordered_set< int64_t > >	waitsTransactionMap
boost::unordered_map< int64_t, taCmd >	returnMap
boost::unordered_set< int64_t >	skipTransactionSet
boost::unordered_set< std::string >	skipItemSet
boost::unordered_set< int64_t >	transactionGraphSet

Friends
class	Transaction

Detailed Description

Deadlock manager actor.

Definition at line 48 of file DeadlockMgr.h.

Constructor & Destructor Documentation

DeadlockMgr::DeadlockMgr

(

Topology::partitionAddress *

myIdentityArg)

execute Deadlock Manager actor

uses a wait-for graph to resolve deadlocks

Parameters

myIdentityArg

how to identify actor instance

Definition at line 31 of file DeadlockMgr.cc.

References ADDLOCKEDENTRY, ADDLOCKPENDINGENTRY, taCmd::addr, Topology::partitionAddress::address, algorithm(), MessageDeadlock::deadlock_s::deadlockchange, MessageDeadlock::deadlockNode, MessageDeadlock::deadlockStruct, GETMSG, newDeadLockLists_s::locked, locksTransactionMap, logfile, Topology::partitionAddress::mbox, mboxes, Message::messageStruct, MSGRECEIVEBATCHSIZE, myIdentity, myTopology, Topology::addressStruct::nodeid, Mboxes::nodeid, MessageDeadlock::nodes, taCmd::pendingcmdid, REMOVELOCKEDENTRY, REMOVELOCKPENDINGENTRY, removeTransaction(), returnMap, Mboxes::sendObBatch(), Message::message_s::sourceAddr, Message::message_s::topic, TOPIC_DEADLOCKCHANGE, TOPIC_DEADLOCKNEW, TOPIC_DEADLOCKREMOVE, TOPIC_TOPOLOGY, MessageDeadlock::deadlock_s::transaction_pendingcmdid, MessageDeadlock::deadlock_s::transactionid, transactionLocksMap, transactionWaitsMap, TRANSITIONPENDINGTOLOCKEDENTRY, Mboxes::update(), newDeadLockLists_s::waiting, and waitsTransactionMap.

                                                                :
    myIdentity(*myIdentityArg)
{
    delete myIdentityArg;
    mboxes.nodeid = myIdentity.address.nodeid;
    mboxes.update(myTopology);

    class Message *msgrcv=NULL;
    short waitval = 1000;

    while (1)
    {
        mboxes.sendObBatch();
        for (short n=0; n < MSGRECEIVEBATCHSIZE; n ++)
        {
            GETMSG(msgrcv, myIdentity.mbox, waitval)

                if (msgrcv==NULL)
                {
                    waitval=1000;
                    break;
                }

            class MessageDeadlock &msgrcvref =
                *((class MessageDeadlock *)msgrcv);

            switch (msgrcv->messageStruct.topic)
            {
            case TOPIC_DEADLOCKNEW:
            {
                newDeadLockLists_s &listsRef = msgrcvref.nodes;
                transactionLocksMap[msgrcvref.deadlockStruct.transactionid] =
                    listsRef.locked;
                transactionWaitsMap[msgrcvref.deadlockStruct.transactionid] =
                    listsRef.waiting;

                taCmd returninfo;
                returninfo.addr = msgrcvref.messageStruct.sourceAddr;
                returninfo.pendingcmdid =
                    msgrcvref.deadlockStruct.transaction_pendingcmdid;
                returnMap[msgrcvref.deadlockStruct.transactionid] = returninfo;

                boost::unordered_set<string>::iterator it;

                for (it = listsRef.locked.begin();
                     it != listsRef.locked.end(); ++it)
                {
                    locksTransactionMap[*it].insert(msgrcvref.deadlockStruct.transactionid);
                }

                for (it = listsRef.waiting.begin();
                     it != listsRef.waiting.end(); ++it)
                {
                    waitsTransactionMap[*it].insert(msgrcvref.deadlockStruct.transactionid);
                }
            }
            break;

            case TOPIC_DEADLOCKCHANGE:
            {
                string &changedeadlockRef = msgrcvref.deadlockNode;

                switch (msgrcvref.deadlockStruct.deadlockchange)
                {
                case ADDLOCKEDENTRY:
                    if (transactionLocksMap.count(msgrcvref.deadlockStruct.transactionid))
                    {
                        transactionLocksMap[msgrcvref.deadlockStruct.transactionid].insert(changedeadlockRef);
                        locksTransactionMap[changedeadlockRef].insert(msgrcvref.deadlockStruct.transactionid);
                    }
                    break;

                case ADDLOCKPENDINGENTRY:
                    if (transactionWaitsMap.count(msgrcvref.deadlockStruct.transactionid))
                    {
                        transactionWaitsMap[msgrcvref.deadlockStruct.transactionid].insert(changedeadlockRef);
                        waitsTransactionMap[changedeadlockRef].insert(msgrcvref.deadlockStruct.transactionid);
                    }
                    break;

                case REMOVELOCKEDENTRY:
                    if (transactionLocksMap.count(msgrcvref.deadlockStruct.transactionid))
                    {
                        transactionLocksMap[msgrcvref.deadlockStruct.transactionid].erase(changedeadlockRef);
                        locksTransactionMap[changedeadlockRef].erase(msgrcvref.deadlockStruct.transactionid);
                    }
                    break;

                case REMOVELOCKPENDINGENTRY:
                    if (transactionWaitsMap.count(msgrcvref.deadlockStruct.transactionid))
                    {
                        transactionWaitsMap[msgrcvref.deadlockStruct.transactionid].
                            erase(changedeadlockRef);
                        waitsTransactionMap[changedeadlockRef].erase(msgrcvref.deadlockStruct.transactionid);
                    }

                    break;

                case TRANSITIONPENDINGTOLOCKEDENTRY:
                    if (transactionWaitsMap.count(msgrcvref.deadlockStruct.transactionid))
                    {
                        transactionWaitsMap[msgrcvref.deadlockStruct.transactionid].erase(changedeadlockRef);
                        transactionLocksMap[msgrcvref.deadlockStruct.transactionid].insert(changedeadlockRef);

                        waitsTransactionMap[changedeadlockRef].erase(msgrcvref.deadlockStruct.transactionid);
                        locksTransactionMap[changedeadlockRef].insert(msgrcvref.deadlockStruct.transactionid);
                    }

                    break;

                default:
                    fprintf(logfile, "anomaly: %li %s %i\n", 
                            msgrcvref.deadlockStruct.deadlockchange, __FILE__,
                            __LINE__);
                }
            }
            break;

            case TOPIC_DEADLOCKREMOVE:
                removeTransaction(msgrcvref.deadlockStruct.transactionid);
                break;

            case TOPIC_TOPOLOGY:
                mboxes.update(myTopology);
                break;

            default:
                fprintf(logfile, "anomaly: %i %s %i\n",
                        msgrcv->messageStruct.topic, __FILE__, __LINE__);
            }
        }

        // do algorithm
        // set the waitval to -1 so next msg_receive() will block indefinitely
        // algorithm searches for all existing deadlocks, so there's no
        // need to run it until the maps change
        // also maybe swap maps with blank to shrink memory if the whole
        // thing has been searched
        algorithm();
        waitval = 1000;
    }
}

Here is the call graph for this function:

DeadlockMgr::~DeadlockMgr ( )

virtual

Definition at line 174 of file DeadlockMgr.cc.

{
}

Member Function Documentation

void DeadlockMgr::algorithm ( )

private

wait-for graph algoritm

Definition at line 234 of file DeadlockMgr.cc.

References skipItemSet, skipTransactionSet, transactionGraphSet, transactionWaitsMap, and walk().

Referenced by DeadlockMgr().

{
    bool deadlockflag = true;

    // remove all deadlocks from existing data set
    while (deadlockflag==true)
    {
        deadlockflag = false;

        boost::unordered_map< int64_t,
                              boost::unordered_set<string> >::iterator it;

        for (it = transactionWaitsMap.begin();
             it != transactionWaitsMap.end(); ++it)
        {

            if (walk(it->first)==true) // means a deadlock was found
            {
                deadlockflag=true;
            }

            skipTransactionSet.clear();
            skipItemSet.clear();
            transactionGraphSet.clear();
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DeadlockMgr::deadlock ( int64_t  transactionid)

private

upon deadlock, send message to TransactionAgent to abort transaction

Parameters

transactionid

Definition at line 262 of file DeadlockMgr.cc.

References Topology::partitionAddress::address, MessageDeadlock::deadlockStruct, mboxes, Message::messageStruct, myIdentity, removeTransaction(), returnMap, Mboxes::toActor(), Message::message_s::topic, TOPIC_DEADLOCKABORT, MessageDeadlock::deadlock_s::transaction_pendingcmdid, and MessageDeadlock::deadlock_s::transactionid.

Referenced by walk().

{
    if (!returnMap.count(transactionid))
    {
        return;
    }

    class MessageDeadlock *msg = new class MessageDeadlock;
    class MessageDeadlock &msgref = *msg;
    msgref.messageStruct.topic = TOPIC_DEADLOCKABORT;
    msgref.deadlockStruct.transactionid = transactionid;
    msgref.deadlockStruct.transaction_pendingcmdid =
        returnMap[transactionid].pendingcmdid;

    mboxes.toActor(myIdentity.address, returnMap[transactionid].addr, *msg);
    removeTransaction(transactionid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DeadlockMgr::makeLockedItem ( bool  isrow, int64_t  rowid, int64_t  tableid, int64_t  engineid, int64_t  domainid, int64_t  fieldid, long double  floatentry, std::string *  stringentry, std::string *  returnstring  )

staticprivate

create item to add to waitfor graph

Items are added to wait-for graph under following circumstances: at least 1 row/unique index entry is locked by transaction and at least 1 is pending a lock for that transaction. All locked and pending items are added to wait-for graph as potential causes of a deadlock. the item to add to the wait-for graph is a string (returnstring)

Parameters

isrow	is a row (otherwise unique index entry)
rowid	rowid
tableid	tableid
engineid	engineid
domainid	domainid
fieldid	fieldid
floatentry	if index entry for float, the float value
stringentry	if index entry for string, string value
returnstring	item to add to wait-for graph

Definition at line 189 of file DeadlockMgr.cc.

Referenced by Transaction::checkLock(), and Transaction::checkSqlLock().

{
    string &returnstringRef = *returnstring;
    size_t strlength = stringentry->length();
    returnstringRef.reserve(sizeof(isrow) + (5 * sizeof(int64_t)) +
                            sizeof(floatentry) + sizeof(strlength) + strlength);

    // this is so identical entries but with garbage in irrelevant values don't
    // show up as different
    if (isrow==true)
    {
        fieldid=-1;
        floatentry=0;
        stringentry->clear();
    }
    else
    {
        rowid=-1;
        engineid=-1;
    }

    size_t pos = 0;
    memcpy(&returnstringRef[pos], &isrow, sizeof(isrow));
    pos += sizeof(isrow);
    memcpy(&returnstringRef[pos], &rowid, sizeof(rowid));
    pos += sizeof(rowid);
    memcpy(&returnstringRef[pos], &tableid, sizeof(tableid));
    pos += sizeof(tableid);
    memcpy(&returnstringRef[pos], &engineid, sizeof(engineid));
    pos += sizeof(engineid);
    memcpy(&returnstringRef[pos], &domainid, sizeof(domainid));
    pos += sizeof(domainid);
    memcpy(&returnstringRef[pos], &fieldid, sizeof(fieldid));
    pos += sizeof(fieldid);
    memcpy(&returnstringRef[pos], &floatentry, sizeof(floatentry));
    pos += sizeof(floatentry);
    memcpy(&returnstringRef[pos], &strlength, sizeof(strlength));
    pos += sizeof(strlength);
    memcpy(&returnstringRef[pos], stringentry->c_str(), strlength);
}

Here is the caller graph for this function:

void DeadlockMgr::removeTransaction ( int64_t  transactionid)

private

remove transactionid from wait-for graph

Parameters

transactionid

transactionid

Definition at line 352 of file DeadlockMgr.cc.

References locksTransactionMap, returnMap, transactionLocksMap, transactionWaitsMap, and waitsTransactionMap.

Referenced by deadlock(), and DeadlockMgr().

{
    // walk through all the locks that the transaction holds
    // and those which it waits on, and remove the transactionid
    // entry from those items
    boost::unordered_set<string>::iterator it;

    for (it = transactionLocksMap[transactionid].begin();
         it != transactionLocksMap[transactionid].end();
         ++it)
    {
        locksTransactionMap[*it].erase(transactionid);

        if (locksTransactionMap[*it].empty()==true)
        {
            locksTransactionMap.erase(*it);
        }
    }

    for (it = transactionWaitsMap[transactionid].begin();
         it != transactionWaitsMap[transactionid].end();
         ++it)
    {
        waitsTransactionMap[*it].erase(transactionid);

        if (waitsTransactionMap[*it].empty()==true)
        {
            locksTransactionMap.erase(*it);
        }
    }

    transactionLocksMap.erase(transactionid);
    transactionWaitsMap.erase(transactionid);
    returnMap.erase(transactionid);
}

Here is the caller graph for this function:

bool DeadlockMgr::walk ( int64_t  transactionid)

private

walk the wait-for graph for items this transactionid is waiting for

Parameters

transactionid

transactionid

Returns

true for positive response

Definition at line 282 of file DeadlockMgr.cc.

References deadlock(), skipTransactionSet, transactionGraphSet, and transactionWaitsMap.

Referenced by algorithm(), and walk().

{
    if (transactionGraphSet.count(transactionid))
    {
        deadlock(transactionid);
        return true;
    }

    if (skipTransactionSet.count(transactionid))
    {
        return false;
    }

    skipTransactionSet.insert(transactionid);

    // check for items this transaction is waiting on (though this should
    // always be positive, or the transactionid should be removed by other means)
    if (!transactionWaitsMap.count(transactionid))   // end of path
    {
        return false;
    }

    transactionGraphSet.insert(transactionid);

    boost::unordered_set<string>::iterator it;

    for (it = transactionWaitsMap[transactionid].begin();
         it != transactionWaitsMap[transactionid].end(); ++it)
    {
        if (walk(it)==true)   // deadlock happened at some point!
        {
            return true;
        }
    }

    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool DeadlockMgr::walk ( boost::unordered_set< string >::iterator  itemIt)

private

walk the wait-for graph for transactions that hold this item

Parameters

itemIt

item held by transactions

Returns

true for positive response

Definition at line 321 of file DeadlockMgr.cc.

References locksTransactionMap, skipItemSet, and walk().

{
    const string &itemRef = (string)(*itemIt);

    if (skipItemSet.count(itemRef))
    {
        return false;
    }

    skipItemSet.insert(itemRef);

    // check for transactions locking this item
    if (!locksTransactionMap.count(itemRef))   // positively no deadlock
    {
        return false;
    }

    boost::unordered_set<int64_t>::iterator it;

    for (it = locksTransactionMap[itemRef].begin();
         it != locksTransactionMap[itemRef].end(); ++it)
    {
        if (walk(*it)==true)   // deadlock happened!
        {
            return true;
        }
    }

    return false;
}

Here is the call graph for this function:

Friends And Related Function Documentation

friend class Transaction

friend

Definition at line 61 of file DeadlockMgr.h.

Member Data Documentation

boost::unordered_map< std::string, boost::unordered_set<int64_t> > DeadlockMgr::locksTransactionMap

private

Definition at line 138 of file DeadlockMgr.h.

Referenced by DeadlockMgr(), removeTransaction(), and walk().

class Mboxes DeadlockMgr::mboxes

private

Definition at line 125 of file DeadlockMgr.h.

Referenced by deadlock(), and DeadlockMgr().

Topology::partitionAddress DeadlockMgr::myIdentity

private

Definition at line 124 of file DeadlockMgr.h.

Referenced by deadlock(), and DeadlockMgr().

class Mbox* DeadlockMgr::mymboxPtr

private

Definition at line 123 of file DeadlockMgr.h.

class Topology DeadlockMgr::myTopology

private

Definition at line 126 of file DeadlockMgr.h.

Referenced by DeadlockMgr().

boost::unordered_map<int64_t, taCmd> DeadlockMgr::returnMap

private

Definition at line 143 of file DeadlockMgr.h.

Referenced by deadlock(), DeadlockMgr(), and removeTransaction().

boost::unordered_set<std::string> DeadlockMgr::skipItemSet

private

Definition at line 146 of file DeadlockMgr.h.

Referenced by algorithm(), and walk().

boost::unordered_set<int64_t> DeadlockMgr::skipTransactionSet

private

Definition at line 145 of file DeadlockMgr.h.

Referenced by algorithm(), and walk().

boost::unordered_set<int64_t> DeadlockMgr::transactionGraphSet

private

Definition at line 149 of file DeadlockMgr.h.

Referenced by algorithm(), and walk().

REUSEMESSAGES boost::unordered_map< int64_t, boost::unordered_set<std::string> > DeadlockMgr::transactionLocksMap

private

Definition at line 132 of file DeadlockMgr.h.

Referenced by DeadlockMgr(), and removeTransaction().

boost::unordered_map< int64_t, boost::unordered_set<std::string> > DeadlockMgr::transactionWaitsMap

private

Definition at line 135 of file DeadlockMgr.h.

Referenced by algorithm(), DeadlockMgr(), removeTransaction(), and walk().

boost::unordered_map< std::string, boost::unordered_set<int64_t> > DeadlockMgr::waitsTransactionMap

private

Definition at line 141 of file DeadlockMgr.h.

Referenced by DeadlockMgr(), and removeTransaction().

---

The documentation for this class was generated from the following files:

• /home/infinisql/build/infinisql/infinisqld/DeadlockMgr.h
• /home/infinisql/build/infinisql/infinisqld/DeadlockMgr.cc