SVF::ThreadAPI Class Reference

#include <ThreadAPI.h>

Public Types
enum	TD_TYPE {   TD_DUMMY = 0 , TD_FORK , TD_JOIN , TD_DETACH ,   TD_ACQUIRE , TD_TRY_ACQUIRE , TD_RELEASE , TD_EXIT ,   TD_CANCEL , TD_COND_WAIT , TD_COND_SIGNAL , TD_COND_BROADCAST ,   TD_MUTEX_INI , TD_MUTEX_DESTROY , TD_CONDVAR_INI , TD_CONDVAR_DESTROY ,   TD_BAR_INIT , TD_BAR_WAIT , HARE_PAR_FOR }
typedef Map< std::string, TD_TYPE >	TDAPIMap

Public Member Functions
const ValVar *	getForkedThread (const CallICFGNode *inst) const
	Return arguments/attributes of pthread_create / hare_parallel_for.
const ValVar *	getForkedFun (const CallICFGNode *inst) const
const ValVar *	getActualParmAtForkSite (const CallICFGNode *inst) const
const SVFVar *	getFormalParmOfForkedFun (const FunObjVar *F) const
	Return the formal parm of forked function (the first arg in pthread)
bool	isTDFork (const CallICFGNode *inst) const
	Return true if this call create a new thread.
bool	isTDJoin (const CallICFGNode *inst) const
	Return true if this call wait for a worker thread.
const SVFVar *	getJoinedThread (const CallICFGNode *inst) const
	Return arguments/attributes of pthread_join.
const SVFVar *	getRetParmAtJoinedSite (const CallICFGNode *inst) const
bool	isTDExit (const CallICFGNode *inst) const
	Return true if this call exits/terminate a thread.
bool	isTDAcquire (const CallICFGNode *inst) const
	Return true if this call acquire a lock.
bool	isTDRelease (const CallICFGNode *inst) const
	Return true if this call release a lock.
const SVFVar *	getLockVal (const ICFGNode *inst) const
	Return lock value.
bool	isTDBarWait (const CallICFGNode *inst) const
	Return true if this call waits for a barrier.
void	performAPIStat ()
void	statInit (Map< std::string, u32_t > &tdAPIStatMap)

Static Public Member Functions
static ThreadAPI *	getThreadAPI ()
	Return a static reference.
static void	destroy ()

Private Member Functions
	ThreadAPI ()
	Constructor.
void	init ()
	Initialize the map.
TD_TYPE	getType (const FunObjVar *F) const
	Get the function type if it is a threadAPI function.

Private Attributes
TDAPIMap	tdAPIMap
	API map, from a string to threadAPI type.

Static Private Attributes
static ThreadAPI *	tdAPI = nullptr
	Static reference.

Detailed Description

Definition at line 48 of file ThreadAPI.h.

Member Typedef Documentation

TDAPIMap

typedef Map<std::string, TD_TYPE> SVF::ThreadAPI::TDAPIMap

Definition at line 75 of file ThreadAPI.h.

Member Enumeration Documentation

TD_TYPE

enum SVF::ThreadAPI::TD_TYPE

Enumerator
TD_DUMMY
TD_FORK	dummy type
TD_JOIN	create a new thread
TD_DETACH	wait for a thread to join
TD_ACQUIRE	detach a thread directly instead wait for it to join
TD_TRY_ACQUIRE	acquire a lock
TD_RELEASE	try to acquire a lock
TD_EXIT	release a lock
TD_CANCEL	exit/kill a thread
TD_COND_WAIT	cancel a thread by another
TD_COND_SIGNAL	wait a condition
TD_COND_BROADCAST	signal a condition
TD_MUTEX_INI	broadcast a condition
TD_MUTEX_DESTROY	initial a mutex variable
TD_CONDVAR_INI	initial a mutex variable
TD_CONDVAR_DESTROY	initial a mutex variable
TD_BAR_INIT	initial a mutex variable
TD_BAR_WAIT	Barrier init.
HARE_PAR_FOR	Barrier wait.

Definition at line 52 of file ThreadAPI.h.

    {
        TD_DUMMY = 0,   
        TD_FORK,        
        TD_JOIN,        
        TD_DETACH,      
        TD_ACQUIRE,     
        TD_TRY_ACQUIRE, 
        TD_RELEASE,     
        TD_EXIT,        
        TD_CANCEL,      
        TD_COND_WAIT,   
        TD_COND_SIGNAL, 
        TD_COND_BROADCAST,  
        TD_MUTEX_INI,       
        TD_MUTEX_DESTROY,   
        TD_CONDVAR_INI,     
        TD_CONDVAR_DESTROY, 
        TD_BAR_INIT,        
        TD_BAR_WAIT,        
        HARE_PAR_FOR
    };

Constructor & Destructor Documentation

ThreadAPI()

SVF::ThreadAPI::ThreadAPI ( )

inlineprivate

Constructor.

Definition at line 82 of file ThreadAPI.h.

    {
        init();
    }

Member Function Documentation

destroy()

static void SVF::ThreadAPI::destroy ( )

inlinestatic

Definition at line 107 of file ThreadAPI.h.

    {
        if(tdAPI != nullptr)
        {
            delete tdAPI;
            tdAPI = nullptr;
        }
    }

getActualParmAtForkSite()

const ValVar * ThreadAPI::getActualParmAtForkSite

(

const CallICFGNode *

inst

)

const

Return the forth argument of the call, Note that, it is the sole argument of start routine ( a void* pointer )

Definition at line 190 of file ThreadAPI.cpp.

{
    assert(isTDFork(inst) && "not a thread fork function!");
    return inst->getArgument(3);
}

getForkedFun()

const ValVar * ThreadAPI::getForkedFun

(

const CallICFGNode *

inst

)

const

Return the third argument of the call, Note that, it could be function type or a void* pointer

Definition at line 182 of file ThreadAPI.cpp.

{
    assert(isTDFork(inst) && "not a thread fork function!");
    return inst->getArgument(2);
}

getForkedThread()

const ValVar * ThreadAPI::getForkedThread

(

const CallICFGNode *

inst

)

const

Return arguments/attributes of pthread_create / hare_parallel_for.

Return the first argument of the call, Note that, it is the pthread_t pointer

Definition at line 176 of file ThreadAPI.cpp.

{
    assert(isTDFork(inst) && "not a thread fork function!");
    return inst->getArgument(0);
}

getFormalParmOfForkedFun()

const SVFVar * ThreadAPI::getFormalParmOfForkedFun

(

const FunObjVar *

F

)

const

Return the formal parm of forked function (the first arg in pthread)

Definition at line 196 of file ThreadAPI.cpp.

{
    assert(PAG::getPAG()->hasFunArgsList(F) && "forked function has no args list!");
    const SVFIR::SVFVarList& funArgList = PAG::getPAG()->getFunArgsList(F);
    // in pthread, forked functions are of type void *()(void *args)
    assert(funArgList.size() == 1 && "num of pthread forked function args is not 1!");
    return funArgList[0];
}

getJoinedThread()

const SVFVar * ThreadAPI::getJoinedThread

(

const CallICFGNode *

inst

)

const

Return arguments/attributes of pthread_join.

Return the first argument of the call, Note that, it is the pthread_t pointer

Definition at line 219 of file ThreadAPI.cpp.

{
    assert(isTDJoin(cs) && "not a thread join function!");
    const ValVar* join = cs->getArgument(0);
    for(const SVFStmt* stmt : join->getInEdges())
    {
        if(SVFUtil::isa<LoadStmt>(stmt))
            return stmt->getSrcNode();
    }
    if(SVFUtil::isa<ArgValVar>(join))
        return join;
 
    assert(false && "the value of the first argument at join is not a load instruction?");
    return nullptr;
}

getLockVal()

const SVFVar * ThreadAPI::getLockVal

(

const ICFGNode *

inst

)

const

Return lock value.

First argument of pthread_mutex_lock/pthread_mutex_unlock

Definition at line 211 of file ThreadAPI.cpp.

{
    const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(cs);
    assert(call && "not a call ICFGNode?");
    assert((isTDAcquire(call) || isTDRelease(call)) && "not a lock acquire or release function");
    return call->getArgument(0);
}

getRetParmAtJoinedSite()

const SVFVar * ThreadAPI::getRetParmAtJoinedSite

(

const CallICFGNode *

inst

)

const

Return the send argument of the call, Note that, it is the pthread_t pointer

Definition at line 205 of file ThreadAPI.cpp.

{
    assert(isTDJoin(inst) && "not a thread join function!");
    return inst->getArgument(1);
}

getThreadAPI()

static ThreadAPI * SVF::ThreadAPI::getThreadAPI ( )

inlinestatic

Return a static reference.

Definition at line 98 of file ThreadAPI.h.

    {
        if(tdAPI == nullptr)
        {
            tdAPI = new ThreadAPI();
        }
        return tdAPI;
    }

getType()

ThreadAPI::TD_TYPE ThreadAPI::getType ( const FunObjVar *  F ) const

private

Get the function type if it is a threadAPI function.

Definition at line 134 of file ThreadAPI.cpp.

{
    if(F)
    {
        TDAPIMap::const_iterator it= tdAPIMap.find(F->getName());
        if(it != tdAPIMap.end())
            return it->second;
    }
    return TD_DUMMY;
}

init()

void ThreadAPI::init ( )

private

Initialize the map.

initialize the map

Definition at line 103 of file ThreadAPI.cpp.

{
    set<TD_TYPE> t_seen;
    TD_TYPE prev_t= TD_DUMMY;
    t_seen.insert(TD_DUMMY);
    for(const ei_pair *p= ei_pairs; p->n; ++p)
    {
        if(p->t != prev_t)
        {
            //This will detect if you move an entry to another block
            //  but forget to change the type.
            if(t_seen.count(p->t))
            {
                fputs(p->n, stderr);
                putc('\n', stderr);
                assert(!"ei_pairs not grouped by type");
            }
            t_seen.insert(p->t);
            prev_t= p->t;
        }
        if(tdAPIMap.count(p->n))
        {
            fputs(p->n, stderr);
            putc('\n', stderr);
            assert(!"duplicate name in ei_pairs");
        }
        tdAPIMap[p->n]= p->t;
    }
}

isTDAcquire()

bool ThreadAPI::isTDAcquire

(

const CallICFGNode *

inst

)

const

Return true if this call acquire a lock.

Definition at line 160 of file ThreadAPI.cpp.

{
    return getType(inst->getCalledFunction()) == TD_ACQUIRE;
}

isTDBarWait()

bool ThreadAPI::isTDBarWait

(

const CallICFGNode *

inst

)

const

Return true if this call waits for a barrier.

Definition at line 170 of file ThreadAPI.cpp.

{
    return getType(inst->getCalledFunction()) == TD_BAR_WAIT;
}

isTDExit()

bool ThreadAPI::isTDExit

(

const CallICFGNode *

inst

)

const

Return true if this call exits/terminate a thread.

Definition at line 155 of file ThreadAPI.cpp.

{
    return getType(inst->getCalledFunction()) == TD_EXIT;
}

isTDFork()

bool ThreadAPI::isTDFork

(

const CallICFGNode *

inst

)

const

Return true if this call create a new thread.

Definition at line 145 of file ThreadAPI.cpp.

{
    return getType(inst->getCalledFunction()) == TD_FORK;
}

isTDJoin()

bool ThreadAPI::isTDJoin

(

const CallICFGNode *

inst

)

const

Return true if this call wait for a worker thread.

Definition at line 150 of file ThreadAPI.cpp.

{
    return getType(inst->getCalledFunction()) == TD_JOIN;
}

isTDRelease()

bool ThreadAPI::isTDRelease

(

const CallICFGNode *

inst

)

const

Return true if this call release a lock.

Definition at line 165 of file ThreadAPI.cpp.

{
    return getType(inst->getCalledFunction()) == TD_RELEASE;
}

performAPIStat()

void ThreadAPI::performAPIStat

(

)

Definition at line 278 of file ThreadAPI.cpp.

{
 
    Map<std::string, u32_t> tdAPIStatMap;
 
    statInit(tdAPIStatMap);
 
    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
    for (const auto& item: *svfirCallGraph)
    {
        for (FunObjVar::const_bb_iterator bit = (item.second)->getFunction()->begin(), ebit = (item.second)->getFunction()->end(); bit != ebit; ++bit)
        {
            const SVFBasicBlock* bb = bit->second;
            for (const auto& svfInst: bb->getICFGNodeList())
            {
                if (!SVFUtil::isCallSite(svfInst))
                    continue;
 
                const FunObjVar* fun = SVFUtil::cast<CallICFGNode>(svfInst)->getCalledFunction();
                TD_TYPE type = getType(fun);
                switch (type)
                {
                case TD_FORK:
                {
                    tdAPIStatMap["pthread_create"]++;
                    break;
                }
                case TD_JOIN:
                {
                    tdAPIStatMap["pthread_join"]++;
                    break;
                }
                case TD_ACQUIRE:
                {
                    tdAPIStatMap["pthread_mutex_lock"]++;
                    break;
                }
                case TD_TRY_ACQUIRE:
                {
                    tdAPIStatMap["pthread_mutex_trylock"]++;
                    break;
                }
                case TD_RELEASE:
                {
                    tdAPIStatMap["pthread_mutex_unlock"]++;
                    break;
                }
                case TD_CANCEL:
                {
                    tdAPIStatMap["pthread_cancel"]++;
                    break;
                }
                case TD_EXIT:
                {
                    tdAPIStatMap["pthread_exit"]++;
                    break;
                }
                case TD_DETACH:
                {
                    tdAPIStatMap["pthread_detach"]++;
                    break;
                }
                case TD_COND_WAIT:
                {
                    tdAPIStatMap["pthread_cond_wait"]++;
                    break;
                }
                case TD_COND_SIGNAL:
                {
                    tdAPIStatMap["pthread_cond_signal"]++;
                    break;
                }
                case TD_COND_BROADCAST:
                {
                    tdAPIStatMap["pthread_cond_broadcast"]++;
                    break;
                }
                case TD_CONDVAR_INI:
                {
                    tdAPIStatMap["pthread_cond_init"]++;
                    break;
                }
                case TD_CONDVAR_DESTROY:
                {
                    tdAPIStatMap["pthread_cond_destroy"]++;
                    break;
                }
                case TD_MUTEX_INI:
                {
                    tdAPIStatMap["pthread_mutex_init"]++;
                    break;
                }
                case TD_MUTEX_DESTROY:
                {
                    tdAPIStatMap["pthread_mutex_destroy"]++;
                    break;
                }
                case TD_BAR_INIT:
                {
                    tdAPIStatMap["pthread_barrier_init"]++;
                    break;
                }
                case TD_BAR_WAIT:
                {
                    tdAPIStatMap["pthread_barrier_wait"]++;
                    break;
                }
                case HARE_PAR_FOR:
                {
                    tdAPIStatMap["hare_parallel_for"]++;
                    break;
                }
                case TD_DUMMY:
                {
                    break;
                }
                }
            }
        }
 
    }
 
    std::string name(PAG::getPAG()->getModuleIdentifier());
    std::vector<std::string> fullNames = SVFUtil::split(name,'/');
    if (fullNames.size() > 1)
    {
        name = fullNames[fullNames.size() - 1];
    }
    SVFUtil::outs() << "################ (program : " << name
                    << ")###############\n";
    SVFUtil::outs().flags(std::ios::left);
    unsigned field_width = 20;
    for (Map<std::string, u32_t>::iterator it = tdAPIStatMap.begin(), eit =
                tdAPIStatMap.end(); it != eit; ++it)
    {
        std::string apiName = it->first;
        // format out put with width 20 space
        SVFUtil::outs() << std::setw(field_width) << apiName << " : " << it->second
                        << "\n";
    }
    SVFUtil::outs() << "#######################################################"
                    << std::endl;
 
}

statInit()

void ThreadAPI::statInit

(

Map< std::string, u32_t > &

tdAPIStatMap

)

Definition at line 238 of file ThreadAPI.cpp.

{
 
    tdAPIStatMap["pthread_create"] = 0;
 
    tdAPIStatMap["pthread_join"] = 0;
 
    tdAPIStatMap["pthread_mutex_lock"] = 0;
 
    tdAPIStatMap["pthread_mutex_trylock"] = 0;
 
    tdAPIStatMap["pthread_mutex_unlock"] = 0;
 
    tdAPIStatMap["pthread_cancel"] = 0;
 
    tdAPIStatMap["pthread_exit"] = 0;
 
    tdAPIStatMap["pthread_detach"] = 0;
 
    tdAPIStatMap["pthread_cond_wait"] = 0;
 
    tdAPIStatMap["pthread_cond_signal"] = 0;
 
    tdAPIStatMap["pthread_cond_broadcast"] = 0;
 
    tdAPIStatMap["pthread_cond_init"] = 0;
 
    tdAPIStatMap["pthread_cond_destroy"] = 0;
 
    tdAPIStatMap["pthread_mutex_init"] = 0;
 
    tdAPIStatMap["pthread_mutex_destroy"] = 0;
 
    tdAPIStatMap["pthread_barrier_init"] = 0;
 
    tdAPIStatMap["pthread_barrier_wait"] = 0;
 
    tdAPIStatMap["hare_parallel_for"] = 0;
}

Member Data Documentation

tdAPI

ThreadAPI * ThreadAPI::tdAPI = nullptr

staticprivate

Static reference.

Definition at line 91 of file ThreadAPI.h.

tdAPIMap

TDAPIMap SVF::ThreadAPI::tdAPIMap

private

API map, from a string to threadAPI type.

Definition at line 79 of file ThreadAPI.h.

---

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

• /home/runner/work/SVF/SVF/svf/include/Util/ThreadAPI.h
• /home/runner/work/SVF/SVF/svf/lib/Util/ThreadAPI.cpp