1

So, I've already read this article Counting machine instructions of a process using PTRACE_SINGLESTEP, and i understand that dynamically linking a testprogram to my ptrace program will return an instruction count that also counts the initialization of the run-time library. However, I'm trying to get a valid count for my test program, which is:

int main(){
    return 0;
}

My ptrace program first also returned 90k+ values, so I changed it to statically linking the used testprogram. The counter is now less, but still over 12k. The program I used to count the instructions is: 

#include <sys/ptrace.h>
#include <unistd.h>
#include <stdio.h>

int main() {
long long counter = 1;          // machine instruction counter
int wait_val;           // child's return value
int pid;                    // child's process id
int dat;    

switch (pid = fork()) {     // copy entire parent space in child
case -1:    perror("fork");
        break;

case 0:         // child process starts
        ptrace(PTRACE_TRACEME,0,NULL,NULL);     
        /* 
           must be called in order to allow the
           control over the child process and trace me (child)
           0 refers to the parent pid
        */

        execl("./returntestprog","returntestprog",NULL);    
        /* 
           executes the testprogram and causes
           the child to stop and send a signal
           to the parent, the parent can now
           switch to PTRACE_SINGLESTEP
        */
        break;
        // child process ends
default:    // parent process starts
        wait(&wait_val);                
        if (ptrace(PTRACE_SINGLESTEP, pid, 0, 0) != 0)
                            perror("ptrace");
                        /* 
                            switch to singlestep tracing and 
                            release child
                            if unable call error.
                         */
                    wait(&wait_val);
                // parent waits for child to stop at next 
                // instruction (execl()) 
                while (wait_val == 1407) {
                        counter++;
                        if (ptrace(PTRACE_SINGLESTEP, pid, 0, 0) != 0)
                                perror("ptrace");
                        /* 
                            switch to singlestep tracing and 
                            release child
                            if unable call error.
                         */
                        wait(&wait_val);
                        // wait for next instruction to complete  */
                }
        /*
          continue to stop, wait and release until
          the child is finished; wait_val != 1407
          Low=0177L and High=05 (SIGTRAP)
        */
        }
    printf("Number of machine instructions : %lld\n", counter);
    return 0;
}   // end of switch

Any help would be really appreciated as I'm not quite sure if it's working right, or not at all. Once I get this thing started, I want to work on timing analysis with ptrace, but first things first and try to count the number of executed instructions

thanks!

Community
  • 1
  • 1
Imara
  • 37
  • 3

1 Answers1

0

I've kind of figured it out by now. So even when statically linking your code, you try to prevent the libraries to be dynamically linked to your program and thus also included into your count. The other side of it however is that executing your file, or basically invoking under the operating system also takes an enormous amount of instructions. So basically, as long as the instruction count is constant and the same under the same conditions, you can subtract this count (when using a return 0 program for instance) from your original program, to count the real number of instructions.

Imara
  • 37
  • 3