[Alg/C++] Time travelling/decreasing time()

[Olaf van der Spek]

In een download applicatie gebruik ik time(NULL) voor de berekening van verstreken tijd en download snelheid.
Nu zag ik een tijd geleden ineens negatieve download snelheden.
Dus ik

Ik check de Windows tijd sync en de klok was inderdaad net gesynced.
Hoe wordt hier in het algemeen mee omgegaan?

E is er ook een (C++) timer functie waarvan wel gegarandeerd wordt dat die niet zal verminderen?
En hoe ga je om met schedulded tasks?

[Macros]

Je kan misschien gebruik maken van processor cycles? Die counter zal zeker nooit minder worden zonder de computer te resetten. Hmmm, of je moet hibernaten...
Ach, helaas bestaat een elegante simpele oplossing maar zelden.

[.oisyn]

clock () wellicht, wat de running-time van je app geeft. Ik weet echter niet wat die doet als je de tijd gaat veranderen tijdens het lopen van je app, dus dat zou je even moeten controleren

[.oisyn]

Macros schreef op 30 september 2004 @ 18:49:
Je kan misschien gebruik maken van processor cycles? Die counter zal zeker nooit minder worden zonder de computer te resetten. Hmmm, of je moet hibernaten...
Ach, helaas bestaat een elegante simpele oplossing maar zelden.

En hoe ga je dan bepalen hoeveel tijd er is verstreken? Houd er rekening mee dat niet alle CPU's op constante snelheid draaien, die in laptops bijvoorbeeld

[Olaf van der Spek]

.oisyn schreef op 30 september 2004 @ 18:52:
clock () wellicht, wat de running-time van je app geeft. Ik weet echter niet wat die doet als je de tijd gaat veranderen tijdens het lopen van je app, dus dat zou je even moeten controleren

C++:

int main(int argc, char* argv[])
{
    cout << clock() << endl;
    Sleep(15000);
    cout << clock() << endl;
    return 0;
}

0
-1164952510

Helaas.
Wat ik nou niet snap, is het volgende. Er moeten toch talloze apps zijn die deze functionaliteit gewoon nodig hebben? Zijn die allemaal broken?
Of gebruiken die een niet-standaard C++ oplossing?

[ Voor 21% gewijzigd door Olaf van der Spek op 30-09-2004 19:59 ]

[.oisyn]

Hmm, komt dat niet gewoon door een integer overflow?

Voor timers e.d. worden idd vaak OS-specifieke functies gebruikt. Ik werk iig vrijwel altijd met QueryPerformanceCounter ()

[ Voor 57% gewijzigd door .oisyn op 30-09-2004 20:08 ]

[Olaf van der Spek]

Ja, maar dat werkt weer zo handig onder Linux.
CLOCKS_PER_SEC is 1000 bij mij, dus een overflow lijkt me sterk.

[.oisyn]

OlafvdSpek schreef op 30 september 2004 @ 20:10:
Ja, maar dat werkt weer zo handig onder Linux.

Met puur ISO C++ kom je sowieso niet erg ver
Je kunt toch ook zelf een timer-libje maken met ports naar zowel windows als linux?

CLOCKS_PER_SEC is 1000 bij mij, dus een overflow lijkt me sterk.

Hier ook idd, maar hoeveel heb je de tijd terug gezet in die 15 seconden? 13.5 dagen ongeveer?

[Olaf van der Spek]

.oisyn schreef op 30 september 2004 @ 20:18:
Je kunt toch ook zelf een timer-libje maken met ports naar zowel windows als linux?

Natuurlijk.
Maar toch blijf ik het jammer vinden.

Hier ook idd, maar hoeveel heb je de tijd terug gezet in die 15 seconden? 13.5 dagen ongeveer?

Een uur.
Maar is dat relevant?
Ik zocht een functie die juist geen last had van time changes.

[.oisyn]

OlafvdSpek schreef op 30 september 2004 @ 20:20:
Een uur.
Maar is dat relevant?
Ik zocht een functie die juist geen last had van time changes.

nou ja ik vond -1164952510 wel een heel erg vaag getal. Dan zou ik eerder iets rond de -3585000 verwachten (een uur minus 15 seconden uitgedrukt in milliseconden)

[JaWi]

Volgens mijn clock() manpage zou deze een benadering van de gebruikte processortijd terug geven. Aangezien er in een sleep() functie geen ene moer aan processortijd gebruikt wordt, kan ik mij voorstellen dat het resultaat niet naar verwachting is (ik weet niet waar die rare uitkomst vandaan komt, misschien wel door een slecht geinitialiseerde interne variabele?)...

Zo geeft bijvoorbeeld het volgende proggie:

C:

#include <stdio.h>
#include <unistd.h>
#include <time.h>

int main( int argc, char* argv[] )
{
  long y = 0;

  printf( "start: %li\n", ( long int )clock() );
  for ( int i = 0; i < 1000000; ++i )
  {
    y += ( i * ( y / 10 ) ) + i;
    printf( "test:  %li\r", y );
  }
  printf( "\n" );

  clock_t value = clock();
  printf( "end  : %li \n", ( long int )value );
  printf( "end  : %f \n", ( ( double )value / ( double )CLOCKS_PER_SEC ) );
  return 0;
}

Onder Linux het volgende resultaat:

localhost:/> gcc clock.c -o clock
localhost:/> time ./clock
start: 0
test:  16076868453
end  : 630000 
end  : 0.630000 

real    0m8.946s
user    0m0.414s
sys     0m0.223s

Het resultaat is niet geheel in overeenstemming met elkaar, maar in ieder geval komt er iets "zinnigs" uit!

B.T.W.: als je nauwkeurig een interval wil bijhouden, dan kun je eens naar gettimeofday() kijken, da's ook een POSIX functie die de tijd in milliseconden nauwkeurig teruggeeft.

edit:

extra hint toegevoegd...

[ Voor 13% gewijzigd door JaWi op 01-10-2004 00:08 ]

[.oisyn]

Ik denk dat je even vergeet dat Olaf tijdens de sleep handmatig de tijd van z'n PC een uur terug heeft gezet

[Olaf van der Spek]

JaWi schreef op 01 oktober 2004 @ 00:02:
B.T.W.: als je nauwkeurig een interval wil bijhouden, dan kun je eens naar gettimeofday() kijken, da's ook een POSIX functie die de tijd in milliseconden nauwkeurig teruggeeft.

Onder Windows geeft die verstreken tijd sinds process start aan.
Maar ik ben bang dat ook gettimeofday niet 'stable' blijft als de systeem klok wordt aangepast.

[Verwijderd]

Onder POSIX heb je de times() functie (die ook in het time commando gebruikt wordt), volgens mij vult die de tms struct met pure jiffy-/clocktick-waardes die niet afhankelijk zijn van de systeemtijd.

[The End]

Als je op een Windows systeem de tijd nauwkeurig wil bijhouden kan je GetTickCount() gebruiken. Deze telt het aantal milliseconden sinds het systeem geboot is.

[Kuhlie]

Of je wacht op een message van windows die aangeeft dat de tijd verandert is. Met een beetje geluk krijg je de oude tijd mee en kun je dus het verschil berekenen. Dit message bestaat, ik weet niet hoe hij heet: in Visual Basic kun je een (bijgeleverde) OCX gebruiken die een event geeft als de klok veranderd is. Die OCX zal die informatie toch ook ergens vandaan moeten halen

[Verwijderd]

The End schreef op 01 oktober 2004 @ 09:10:
Als je op een Windows systeem...

Kuhlie schreef op 01 oktober 2004 @ 09:19:
Of je wacht op een message van windows...

OlafvdSpek schreef op 30 september 2004 @ 20:10:
Ja, maar dat werkt weer zo handig onder Linux.

[Olaf van der Spek]

Verwijderd schreef op 01 oktober 2004 @ 01:34:
Onder POSIX heb je de times() functie (die ook in het time commando gebruikt wordt), volgens mij vult die de tms struct met pure jiffy-/clocktick-waardes die niet afhankelijk zijn van de systeemtijd.

Hmm, daar zal ik eens naar kijken.

[ Voor 10% gewijzigd door Olaf van der Spek op 01-10-2004 11:32 ]

[.oisyn]

The End schreef op 01 oktober 2004 @ 09:10:
Als je op een Windows systeem de tijd nauwkeurig wil bijhouden kan je GetTickCount() gebruiken. Deze telt het aantal milliseconden sinds het systeem geboot is.

GetTickCount is allesbehalve nauwkeurig. Het geeft wel een antwoord in milliseconden, maar het heeft een interval van ongeveer 18 ms. Gebruik QueryPerformanceCounter voor nauwkeurige tijdmetingen.