Fro those who do not know/remember what is waiting WRT OS tasks: http://en.wikipedia.org/wiki/Process_(computing) -> http://en.wikipedia.org/wiki/Process...Process_states .

unless your processor is 100% dedicated to one process, which is impossible short of building a hardware device just to run that task, the execution time will be guaranteed to vary because the process has to share processor time with other processes, even a 'bare metal' execution of your task might have variances in execution time as no environment is perfectly consistent.

To be fair, if the CPU is cacheless, if the RAM is SRAM and if there is no DMA, i.e. if there are no factors beyond program control, the environment is consistent - the whole thing is just a deterministic synchronous circuit. But a very dedicated HW is needed for this.

...

The http://en.wikipedia.org/wiki/Ubicom company's goal was to create a much more predictable WRT timing CPU - at least in the early 2000-s.

Yes but that is for elapsed time.

jiml8 is talking about the actual time that the program is executing on the CPU.

Sergei Steshenko is talking about actual elapsed time.

I'm not sure what the original poster's program is measuring but I believe that it is actual elapsed time.

jiml8 has said that there is a distinction between CPU time and actual elapsed time/wall clock time.

Sergei Steshenko is ignoring this distinction and talking about actual elapsed time issues.

It's pretty funny so far.

Time it takes to perform cache and/or RAM cycles is still CPU time. I.e. if you go to your BIOS and choose slower DRAM settings, every benchmark of yours will show larger CPU time. This is because CPU time is the sum of durations of CPU instructions executed during task executions. So slower cache (rather, cache misses) and slower RAM do increase this time.

A multitasking OS cannot maintain a constant speed will all the background tasks.
That said, it is no surprise that the speeds are not constant.

Nonsense. You are ignoring the fact that CPU knows nothing (at instructions level) about HW wait states and about the facts of it relinquishing the bus to higher priority masters.

*sigh*

You need to go study about non maskable interrupts. X86 family exerts an NMI for memory refresh. And for DMA. Also, the memory controller in an x86 system is located...where exactly? On the CPU chip. Where else. So of course the processor knows about memory refresh.

I was building SBCs starting in the mid '70s. And an oscilloscope is close to useless these days for that kind of thing. You need a network analyzer.

Been there. Done that. Got the T-shirt.

Edit:

Oh! Are you talking about those little Atmel boards? Yeah, they're pretty nice for learning tools. There's this engineer locally who's taking some real-time programming courses and he comes to me for tutoring. He has one of those. And it doesn't have a memory manager at all, I don't think. Of course, it only has a couple of K of RAM on it anyway. I'm not really sure what all it is able to do because I only ever see it when he comes to me for help with his assignments, and then I focus on his assignment and making sure he understands it since I'm charging him by the hour.

These days when I work at that level it is usually a DSP and I seldom run more than a multitasking executive in it along with my application. At that, I'm less interested in the DSP than in the signal processing I'm using the DSP for.

However, in the past, I've worked plenty of times in plenty of environments on the barest of bare metal. I've started machines by writing the bootstrap code, hand assembling it, and toggling it into the machine from the front-panel switches.

But these days? No one wants to pay me to do BIOS type work. They know I know it, but I'm much too expensive.

OP is indeed measuring wall clock time. As I understood his question, he didn't realize he was measuring wall clock time and wants to measure only the time the processor spends on that particular process.

Rather than belittle OP as some others have done, I chose to point out the issue and suggest where to look to deal with it.

Now, someone is trying to teach me how to suck eggs. I really don't think it is funny. I think it is sad. I can tell you that I wouldn't hire this person.

Just what do you think an interrupt does??? Some of it is handled in firmware, some in software, and a small amount in silicon. But the processor is able to know about ALL of that.

Sheesh!

So the information is coarsely granular but why those particular numbers?

another one told me 2 days ago: " it was possible to get accurate CPU time measurements on an ordinary machine, without setting any of the parameters for the kernel or requiring that the machine be otherwise unloaded.Unfortunately, that no longer seems to be possible with modern machines. The combination of hyperthreading and multicore processors means that a program may have many different execution and memory resources, depending on what other programs are running. The only reliable way to avoid this is to run a program in isolation. Also, we have found that the Intel Speedstep technology makes the timings from one run to another highly variable."

hope it helpful for discussion.

following is my sourcecode, in case that someone wants to exper... it.

#include<stdio.h>
int divisors(unsigned int n);
unsigned int antiprime(unsigned int x);
int main()
{
FILE *cin,*cout;
unsigned int n,res;

cin=fopen("antiprime.in","r");
cout=fopen("antiprime.out","w");

while (fscanf(cin,"%d",&n) == 1) {
res=antiprime(n);
fprintf(cout,"%d\n",res);
}

fclose(cin);
fclose(cout);

return 0;
}

unsigned int antiprime(unsigned int x)
{
int prime[]={2,3,5,7,11,13,17,19,23,29,31};
int n,t;
unsigned m,p,k,num;

n=0;
num=0;

for(p=0,k=1;k*k <= x;p++)
k*=prime[p];

m=(k/=prime[p-1]);
while(k <= x)
{
t=divisors(k);
if(t > n)
{
n=t;
num=k;
}
k+=m;
}
return num;
}

int divisors(unsigned int p)
{
int i,k,m;
int prime[]={2,3,5,7,11,13,17,19,23,29,31};
int len_of_prime=11;

k=1;
for(i=0;i < len_of_prime;i++)
{
for(m=0;p%prime[i] == 0;m++)
p/=prime[i];
if(m > 0)
k=k*(m+1);//钄″嫆鍏紡
}

if(k == 1)//a prime greater than 31 or a number which is the product of some primes greater than 31. According to Zerle's theory, it is easy to prove that the current integer being checked is not benifit to the result, so it can be defined as 0 as the value to return.
return 0;
else
return k;
}