I know Java has some type of advanced memory management system, that could be a reason it's faster also

does this thread somehow conclude,
java is the next BIG thing to learn ?

no
java suxxx.

soon dead, cause asm will invade the world.

include 'win32ax.inc'
.data  
    _output rb 20  
.code  

start:  
            invoke MessageBox, 0, "Click Ok to Start", "Speed Test", 0 
            invoke GetTickCount  
            xchg eax, ebx
            mov ecx, 1000000000 
            place:  
              dec ecx
             jnz place
            invoke GetTickCount
            sub eax, ebx 
            invoke wsprintf, _output, "%d milliseconds", eax  
            invoke MessageBox, 0, _output, "Speed Test Finished", 0
            invoke ExitProcess, 0 
.end start
    

Faster I could get:

Code:

include 'win32ax.inc'
.data  
    _output rb 20  
.code  

start:  
            invoke MessageBox, 0, "Click Ok to Start", "Speed Test", 0 
            invoke GetTickCount  
            xchg eax, ebx
            mov ecx, 1000000000 
            place:  
             dec ecx
             jnz place
            invoke GetTickCount
            sub eax, ebx 
            invoke wsprintf, _output, "%d milliseconds", eax  
            invoke MessageBox, 0, _output, "Speed Test Finished", 0
            invoke ExitProcess, 0  
.end start
    

            invoke MessageBox,NULL,"Click Ok to start","Speed Test",MB_OK
            invoke GetTickCount
            xchg eax, ebx
            mov ecx, 1000000000
            place:  
                dec ecx
                cmp ecx,0
                jg place
            invoke GetTickCount
            sub eax, ebx
            invoke wsprintf,_output,"%d milliseconds",eax
            invoke MessageBox,NULL,_output,"Speed Test",MB_OK
            invoke ExitProcess,0   
    

include 'win32ax.inc'
.data
    _output rb 4096
.code   

start:
  mov edi, 5
  xor ebp,ebp

  invoke MessageBox, ebp, "Click Ok to Start", "Speed Test", ebp
DoIt:
  mov ebx, 1000000000
  invoke GetTickCount
  xchg eax, ebx

place:
  dec eax
  jnz place

  invoke GetTickCount
  sub eax, ebx
  push eax
  dec edi
  jne DoIt

  invoke wsprintf, _output, <"%d ms",10,13,"%d ms",10,13,"%d ms",10,13,"%d ms",10,13,"%d ms">
  invoke MessageBox, ebp, _output, "Speed Test Finished", ebp
  invoke ExitProcess, ebp
.end start    

;init count to 0
inc [count]
cmp [count],const; = 3609

;init ecx to 0
inc ecx
inc [count]
cmp ecx,1000000000; = 3125

;init ecx and count to 0
mov ecx,[count]
add ecx,1
cmp ecx,1000000000
mov [count],ecx; = 3062

;init ecx to 0
inc ecx
cmp ecx,const; = 531

;init ecx to 1000000000
sub ecx,1; = 547

;init ecx to 1000000000
nop
sub ecx,1; = 532
    

            mov eax,250000000
            mov ebx,eax
            mov ecx,eax
            mov edx,eax
       align 16
            place:
            sub eax,1
            sub ebx,1
            sub ecx,1
            sub edx,1
            jne place
    

Topic1:
No compiler, assembler or interpreter can disobey you and delete the code that you wrote! If I put for(;; ) loop to make an infinite delay - it must not remove it. I need it. And if I need a precise delay with for(int a=0;a<1000000000;a++){} I definitely need it - why else would I write it there - it must absolutely NOT delete it!!! That's not optimizing, that's censurizing

C:\Temp>cl /Ox /FAs /c test.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 15.00.21022.08 for 80x86
Copyright (C) Microsoft Corporation. All rights reserved.

_main     PROC

; 2    : {

 push    ecx

; 3    :         for(unsigned i=0; i<1000; i++) ;
; 4    :     for(volatile unsigned i=0; i<42000; i++) ;

   mov     DWORD PTR _i$2532[esp+4], 0
 mov     eax, DWORD PTR _i$2532[esp+4]
       cmp     eax, 42000                              ; 0000a410H
 jae     SHORT $LN13@main
    mov     eax, 1
      npad    9
$LL3@main:
 add     DWORD PTR _i$2532[esp+4], eax
       mov     ecx, DWORD PTR _i$2532[esp+4]
       cmp     ecx, 42000                              ; 0000a410H
 jb      SHORT $LL3@main
$LN13@main:

; 5    : }

   xor     eax, eax
    pop     ecx
 ret     0
_main      ENDP