SVF::ThreadAPI Class Reference

#include <ThreadAPI.h>

Classes
struct	ForkJoinAliasCache
	If fork join the same thread. More...

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	isAliasedForkJoin (PointerAnalysis *pta, const SVFVar *forkArg, const SVFVar *joinArg) const
bool	isAliasedForkJoin (PointerAnalysis *pta, const SVFVar *forkArg, const SVFVar *joinArg, ForkJoinAliasCache &cache) 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 49 of file ThreadAPI.h.

Member Typedef Documentation

TDAPIMap

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

Definition at line 76 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 53 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 83 of file ThreadAPI.h.

    {
        init();
    }

Member Function Documentation

destroy()

static void SVF::ThreadAPI::destroy ( )

inlinestatic

Definition at line 108 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 234 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 226 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 220 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 240 of file ThreadAPI.cpp.

{
    assert(PAG::getPAG()->hasFunArgsList(F) && "forked function has no args list!");
    const SVFIR::ValVarList& 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 263 of file ThreadAPI.cpp.

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

getLockVal()

const SVFVar * ThreadAPI::getLockVal

(

const ICFGNode *

inst

)

const

Return lock value.

First argument of pthread_mutex_lock/pthread_mutex_unlock

Definition at line 255 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 249 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 99 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 178 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 147 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;
    }
}

isAliasedForkJoin() [1/2]

bool ThreadAPI::isAliasedForkJoin	(	PointerAnalysis *	pta,
		const SVFVar *	forkArg,
		const SVFVar *	joinArg
	)		const

If fork join the same thread

• forkArg is the value of the first argument of pthread_create (a pointer to pthread_t)
• joinArg is the value first argument of pthread_join (pthread_t)

Definition at line 276 of file ThreadAPI.cpp.

{
    ForkJoinAliasCache cache;
    return isAliasedForkJoin(pta, forkArg, joinArg, cache);
}

isAliasedForkJoin() [2/2]

bool ThreadAPI::isAliasedForkJoin	(	PointerAnalysis *	pta,
		const SVFVar *	forkArg,
		const SVFVar *	joinArg,
		ForkJoinAliasCache &	cache
	)		const

Definition at line 282 of file ThreadAPI.cpp.

{
    // pthread_create receives &t (a pointer to the pthread_t object), so the
    // forked thread is identified by the pthread_t object(s) in pts(forkArg).
    const PointsTo& forkObjs = pta->getPts(forkArg->getId());
    const NodeBS joinedObjs = collectJoinedThreadObjects(pta, joinArg, cache);
    if (forkObjs.toNodeBS().intersects(joinedObjs))
        return true;
 
    // (1) Direct case: the join handle is itself a pointer to the same pthread_t.
    for (NodeID o : forkObjs)
        if (pta->alias(o, joinArg->getId()))
            return true;
 
    // (2) General case: pthread_t is usually a scalar, so pthread_join receives
    //     the pthread_t *value*, which carries no points-to of its own. That
    //     value is loaded from the pthread_t storage, possibly after flowing
    //     through copies / phis / casts / by-value parameter passing. We
    //     backward value-track the join handle to every load it may originate
    //     from and check whether the loaded-from storage is the fork's pthread_t
    //     object. This covers the common shapes soundly (an over-approximate
    //     match only adds a sound join-related value flow).
    return false;
}

isTDAcquire()

bool ThreadAPI::isTDAcquire

(

const CallICFGNode *

inst

)

const

Return true if this call acquire a lock.

Definition at line 204 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 214 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 199 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 189 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 194 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 209 of file ThreadAPI.cpp.

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

performAPIStat()

void ThreadAPI::performAPIStat

(

)

Definition at line 351 of file ThreadAPI.cpp.

{
 
    Map<std::string, u32_t> tdAPIStatMap;
 
    statInit(tdAPIStatMap);
 
    const 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 311 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 92 of file ThreadAPI.h.

tdAPIMap

TDAPIMap SVF::ThreadAPI::tdAPIMap

private

API map, from a string to threadAPI type.

Definition at line 80 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