What is the rule behind instruction count in Intel PIN?

Question

I wanted to count instructions in simple recursive fibo function O(2^n). I succeded to do so with bubble sort and matrix multiplication, but in this case it seemed like instruction count ignored my fibo function. Here is the code used for instrumentation:

// Insert a call at the entry point of a routine to increment the call count
RTN_InsertCall(rtn, IPOINT_BEFORE, (AFUNPTR)docount, IARG_PTR, &(rc->_rtnCount), IARG_END);

// For each instruction of the routine
for (INS ins = RTN_InsHead(rtn); INS_Valid(ins); ins = INS_Next(ins))
{
    // Insert a call to docount to increment the instruction counter for this rtn
    INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)docount, IARG_PTR, &(rc->_icount), IARG_END);
}

I started to wonder what's the difference between this program and the previous ones and my first thought was: here I'm not using an array.

This is what I realised after some manual tests:

a = 5;        // instruction ignored by PIN and 
              //  pretty much everything not using array
fibo[1] = 1   // instruction counted properly
a = fibo[1]   // instruction ignored by PIN

So it seems like only instructions counted are writes to the memory (that's what I assume). After I changed my fibo function to this it works:

long fibonacciNumber(int n, long *fiboNumbers)
{
    if (n < 2) {
        fiboNumbers[n] = n;
        return n;
    }

    fiboNumbers[n] = fiboNumbers[n-1] + fiboNumbers[n-2];
    return fibonacciNumber(n - 1, fiboNumbers) + fibonacciNumber(n - 2, fiboNumbers);
}

But I would like to count instructions also for programs that aren't written by me. Is there a way to count all type of instrunctions? Is there any particular reason why only this instructions are counted? Any help appreciated.

//Edit

I used disassembly option in Visual Studio to check how it looks and it still makes no sense for me. I can't find the reason why only assingment to array is interpreted by PIN as instruction.

instruction_comparison

This exceeded all my expectations, counted as 2 instructions:

even 2 instructions, not one

Do you understand the difference between an "instruction" and a line of source code? — Sneftel, Aug 17 '19 at 11:14
@Sneftel Maybe I don't. I guess we talk about Assembler instructions. But even then it makes no sense for me. If you could explain your thought sir and share your wisdom I would be grateful. — softkdp, Aug 17 '19 at 15:21

score 0 · Accepted Answer · answered Aug 17 '19 at 20:49

PIN, like other low-level profiling and analysis tools, measures individual instructions, low-level orders like "add these two registers" or "load a value from that memory address". The sequence of instructions which a program comprises are generally produced from a high-level language like C++ through a compiler. An individual line of C++ code might be transformed into exactly one instruction, but it's also common for a line to translate to several instructions or even to zero instructions; and the instructions for a line of code may be interleaved with those of other instructions.

Your compiler can output an assembly-language file for your source code, showing what instructions were produced for which lines of code. (For GCC and Clang, this is done with the -S flag.) Note that reading the assembly code output from a compiler is not the best way to learn assembly. Also, I would point you to godbolt.org, a very convenient tool for analyzing assembly output.

What is the rule behind instruction count in Intel PIN?

1 Answers1