measuring number of execl

Question

I want to measure the number of execl call per second, but my script terminates after first iteration because execl has a leave function built in!

I want to know how I can return to my script or find a way to count:

t_end = time.time() + 60
counter = 0
while time.time() < t_end:
    def execlNum():
        os.execl('script.py' 'script.py', '0')

    execlNum()
    counter = counter+1
print counter/60

What are you *actually* trying to do? If you were trying to figure out how many execl calls you can perform per second, you have your answer: you can only do one. There's some other goal you're trying to achieve here; ask your question about that goal. — user2357112, Nov 25 '15 at 21:06

Matteo Italia · Answer 1 · 2015-11-25T22:44:16.320

Since exec replaces the current executable image with the one you specified, you cannot do it in a loop - you could say that execl actually never returns (when it succeeds), since your current code ceases to exists.

If you want to measure the number of execl you can do per second you could do something like this:

#!/usr/bin/env python2
import time
import sys
import subprocess
import os
# duration of our benchmark
duration = 10
# time limit
limit = time.time() + duration
count = 0
# if we are in the "execl-ed process", take the arguments from the command line
if len(sys.argv)==3:
    limit = float(sys.argv[1])
    # increment the counter
    count = int(sys.argv[2])+1
# if we have time, do another execl (passing the incremented counter)
if time.time()<limit:
    os.execl('execpersec.py', 'execpersec.py', str(limit), str(count))

# if we get here, it means that the 10 seconds have expired; print
# how many exec we managed to do
print count/float(duration), "exec/sec"

But keep in mind that this, more than benchmarking the actual exec time (as needed by the OS), is more like a benchmark of the startup time of Python (and of the time needed to compile this script); on my machine this script outputs 58.8 exec/sec, while its straightforward C translation (see below) yields 1484.2 exec/sec.

#include <sys/time.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int duration = 10;

double mytime() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec + tv.tv_usec*1E-6;
}

int main(int argc, char *argv[]) {
    const double duration = 10;
    double limit = mytime() + duration;
    long count = 0;
    if(argc==3) {
        limit = atof(argv[1]);
        count = atol(argv[2])+1;
    }
    if(mytime()<limit) {
        char buf_limit[256], buf_count[256];
        sprintf(buf_limit, "%f", limit);
        sprintf(buf_count, "%ld", count);
        execl("./execpersec.x", "./execpersec.x", buf_limit, buf_count, NULL);
    }
    printf("%f exec/sec\n", count/duration);
    return 0;
}

When I ran this code, it returned the divided value of my arguments! — user2013868, Nov 25 '15 at 23:05
You don't have to specify any argument! They are used internally in the nested execl. — Matteo Italia, Nov 25 '15 at 23:39

score 0 · Answer 2 · answered Nov 25 '15 at 21:37

You've made totally wrong assumption about the execl() call. This system call doesn't have any "leave function built in" how you named it, but it effectively replace the current process with new executable code loaded from the file pointed by first argument to this function.

So, the short answer is you can't.

You need to redefine your problem in new way.

measuring number of execl

2 Answers2