llvm dev - Apr 2013 - [LLVMdev] path profile result with LLVM

I want to get path profiling information with LLVM.
      LLVM provides methods for path profiling.I also get the llvmprof.out
successfully. So I want to output the result.With llvm-prof ,I get the
error:llvm-prof: Unkknown packet #5.
    So I have to write my own pass to output the path profiling result,the
following is my kernel codes:
////////////////////////////////////////////////////////////////////////////////////
    bool PathProfileOutput::runOnModule(Module &M) {
               PathProfileInfo& pathProfileInfo
getAnalysis<PathProfileInfo>();
	       
	       for(Module::iterator F = M.begin();F != M.end(); ++F){
		if (F->isDeclaration()) continue;
		
		pathProfileInfo.setCurrentFunction(F);
		
		for(ProfilePathIterator nextPath=pathProfileInfo.pathBegin();nextPath
!pathProfileInfo.pathEnd();nextPath++){
		ProfilePath* currentPath = nextPath->second;
		errs() << "Function: "+ F->getName() <<
"\n";
		errs() <<"path #" <<
currentPath->getNumber()<<":" <<
currentPath->getCount() <<"\n";
		}
		}
		return true;
               }
//////////////////////////////////////////////////////////////////
I test with a fft program,and get the output . I intend to get all path
information ,but the result only contains part path information.The
following is the output of a kernel function in my fft program:
<http://llvm.1065342.n5.nabble.com/file/n56354/hotspotOr11k.png> 
My questions :How to explain the output result?Does that mean hot paths? Or
can anyone tell me how to output the path profiling information correctly? 
Thanks!



--
View this message in context:
http://llvm.1065342.n5.nabble.com/path-profile-result-with-LLVM-tp56354.html
Sent from the LLVM - Dev mailing list archive at Nabble.com.

Hello gssict, I've met just the same problem you met 2 years ago. The only
difference is that I'm new to LLVM while you were familiar with it and shall
be an expert at 

it now. Since there is no answer to this question and series of questions
about path profiling, I have to solve it by myself.
	I think the result you get is meaningful, though it needs further
regeneration to get the corresponding paths. I just read the paper96 by B&L,
and view the tech-

report2010 by Adam(seems that he implements the pp) I find:
	1.The algorithm just focuses on intraprocedural, so each function has its
own path count(supported by the result);
	2.Despite self loops, every backedge(at the end of while, for ...) leads to
an increment=1 of path count;
	3.For self loops(there is one in the
common_fft,"for(stage=1;&&(j=j/2)!=1;stage++) ;"),increment
should be made
inside basic block;
	4.Combining 2 and 3, I manually instrument common_fft:
   
#--------------------------------------------------------------------------------------------------#
    for(i=0;i<nfft-1;i++)  
    {  ++blcount;
        if(i<j)  
        {  
            t=x[j];  
            x[j]=x[i];  
            x[i]=t;  
        }  
        k=nfft/2;  
        while(k<=j)  
        {  ++blcount;
            j-=k;  
            k/=2;  
        }  
        j+=k;  
    }  
  
    int stage,le,lei,ip;  
    COMPLEX u,w;  
     j= nfft;  
     for(stage=1;(++blcount)&&(j=j/2)!=1;stage++) ; //caculate
stage,which
represents  butterfly stages  
      
    for(k=1;k<=stage;k++)  
    {  ++blcount;
        le=2<<(k-1);  
        lei=le/2;  
        u.real=1.0;// u,butterfly factor initial value  
        u.img=0.0;  
        w.real=cos(PI/lei*isign);  
        w.img=sin(PI/lei*isign);  
        for(j=0;j<=lei-1;j++)  
        {  ++blcount;
            for(i=j;i<=nfft-1;i+=le)  
            {  ++blcount;
                ip=i+lei;  
                t=EE(x[ip],u);  
                x[ip].real=x[i].real-t.real;  
                x[ip].img=x[i].img-t.img;  
                x[i].real=x[i].real+t.real;  
                x[i].img=x[i].img+t.img;  
            }  
            u=EE(u,w);  
        }  
    }  
   
#--------------------------------------------------------------------------------------------------#
	Initially, blcount=0. And at the end of main, I print it out and get 162,
which equals to the sum of path counts of common_fft in your result.
	5.What's more, combining 2, 3 and the rule of increment at the EXIT, we can
infer that during every execution of common_fft, every 1st backedge/selfloop
should be 

recorded and it is different from other backedge/selfloop. Since there are 6
such backedge/selfloop, and common_fft executed 2 times, under the condition
that every 

backedge/selfloop is executed, there should be exactly 6 counts of 2, which
is supported by your result!

	Now at the end of my answer, I think the remaining question is how to
regenerate the paths.
	I am new to LLVM, so I hope you can help me with how to output path
profiling result.
	Desire for your help!!

Raymond Chen.



--
View this message in context:
http://llvm.1065342.n5.nabble.com/path-profile-result-with-LLVM-tp56354p83568.html
Sent from the LLVM - Dev mailing list archive at Nabble.com.