how long does it take

[Mladen Jankovic]

What computer? What language? What compiler? What version of compiler... I guess you’re not interested in result of 16-bit DOS program compiled by compiler with sizeof(int) = 4 that runs in 32-bit protected mode extender inside virtual 16-bit DOS box on 32-bit Windows 98 running on virtual machine run by 32-bit VirtualPC on 64-bit Vista through WoW64? Or maybe you are? :~

Mostly, when you see programmers, they aren't doing anything. One of the attractive things about programmers is that you cannot tell whether or not they are working simply by looking at them. Very often they're sitting there seemingly drinking coffee and gossiping, or just staring into space. What the programmer is trying to do is get a handle on all the individual and unrelated ideas that are scampering around in his head. (Charles M Strauss)

[martin_hughes]

I'm not sure I care.

[Lost User]

Pete O'Hanlon wrote:

do you realise you just asked a programming question in the lounge?

Nah, everyone else turned it into one. He just asked how long a computer takes to count. Cheers, Drew.

[El Corazon]

yassir hannoun wrote:

how long does it take for a computer to count from 0 to the maximum value of int ??

get your stop watch ready! okay.... start.... Now! okay... done... How long was that?

_________________________ Asu no koto o ieba, tenjo de nezumi ga warau. Talk about things of tomorrow and the mice in the ceiling laugh. (Japanese Proverb)

[MarkB777]

Longer than im willing to sit there waiting... :D

Mark Brock Click here to view my blog

[John M Drescher]

I believe it should take around or less than 10 seconds on a modern 2GHz processor. My reasoning is that the increment will take 1 clock cycle and the looping should be predicted so that will be like a near jump. I believe that will be less than 4 cycles. So in total less than (or equal to) 5 cycles per loop on a machine that does 2 billion cycles per second...

John

[yassir hannoun]

with this static void Main(string[] args) { DateTime start = DateTime.Now; for (int i = 0; i < int.MaxValue; i++) { Console.WriteLine(i); } DateTime finish = DateTime.Now; Console.WriteLine("counting started at {0} and finished at {1}", start, finish); } it took more than 10 hours

[Mike Dimmick]

The simplest program I can think of to do this would, in assembler, be along the lines of

xor eax, eax ; set counter to 0
repeat:
inc eax ; increment count
jns repeat ; repeat until count goes negative

taking advantage of the wrapping property, so we just test whether the sign flag is set and if not (indicating a positive integer) we repeat the instruction. On my Core 2 Duo T7200 laptop, this took 1,117 milliseconds. Note that it actually executes 231 times, not 231 - 1. To reduce the cheating effect, I thought I'd try a more advanced feature of the x86 instruction set - you can put a count in a different register and count down. This looks like:

xor eax, eax ; Reset count to 0
mov ecx, 7fffffffh ; Number of times to count
repeat:
inc eax ; Increment count
loop repeat ; go round again

That took 6,654 ms. Out of interest - and because this is a surprisingly large duration - I thought I'd try turning the loop instruction into simpler, more common instructions:

    xor eax, eax        ; Reset count to 0
    mov ecx, 7fffffffh  ; Number of times to count

repeat:
inc eax ; Increment count
dec ecx ; Decrement the loop counter
jnz repeat ; go round again

This now hits 1099ms. Full code if you want to do this in C++ and verify it:

void __declspec(naked) DoCount()
{
__asm
{
xor eax, eax ; Reset eax to 0
repeat:
inc eax ; Increment eax
jns repeat ; Repeat until eax is negative
ret ; Done
}
}

void __declspec(naked) DoLoopCount()
{
__asm
{
xor eax, eax ; Reset count to 0
mov ecx, 7fffffffh ; Number of times to count
repeat:
inc eax ; Increment count
loop repeat ; go round again
ret ; Done
}
}

void __declspec(naked) DoCountedLoop()
{
__asm
{
xor eax, eax ; Reset count to 0
mov ecx, 7fffffffh ; Number of times to count
repeat:
inc eax ; Increment count
dec ecx ; Decrement the loop counter
jnz repeat ; go round again
ret ; Done
}
}

void __declspec(naked) NullFunc()
{
__asm ret;
}

typedef void (*PFN)();

void TimeFunction( PFN pfn )
{
LARGE_INTEGER liStart, liEnd, liFreq;

Qu

[Rich Leyshon]

But what proportion of the total clock cycles available will be allocated to running the application rather than Widows? Is there a general rule of thumb for the percentage of processor time an app can expect (assuming no other major apps are running at the time)? If there is, I'm guessing that it is MUCH lower for Vista than XP - I have an XP app that grinds Vista to a halt! Rich

[John M Drescher]

If no other cpu hogging app is running on (or other cores are free) > 90% otherwise. The time will be several times my 10 second estimate...

John