While loop benchmark! mulig?

[Ripz911]

Heisann!

Har tenkt og lage en morsom liten benchmark.

Vet ikke om det er mulig eller ikke, men i hvertfall.

Jeg lager en while loop som viser alle tallene mellom da f.eks. 1 og 100 000...

så man kan fikse slik at programmet "tar tiden" og "regner ut" noen logiske poeng etter hvor lang tid det tok.

#include <iostream>

using namespace std;

int main()
{
int min = 1;
long int max = 1000000;
int a;
 
while(min <= max)
{
cout << min;
min++;
}
cin >> a;
return 0;
}

 

Jeg er en nybegynner innen C++, så derfor brukte jeg "cin >> a;" for at ikke programmet avsluttet av seg selv.

Kan jo bruke noe slik som "getch()" eller noe sånt, menmen...

 

Se om dere for til å fikse slik at programmet tar tid osv.

[søppel]

Sjekk kodesnuttene på toppen .. der "benchmarkes" det stadig.

[søppel]

#include <iostream>
#include <ctime>

using namespace std;


int main()
{  
clock_t s = clock();

for(unsigned int i = 0; i < 1000000; i++) {}

 cout << clock() - s << endl;
return(0);
} // main

 

CLOCK(3)                                                  Linux Programmer's Manual                                                  CLOCK(3)

 

 

 

NAME

      clock - Determine processor time

 

SYNOPSIS

      #include <time.h>

 

      clock_t clock(void);

 

DESCRIPTION

      The clock() function returns an approximation of processor time used by the program.

 

RETURN VALUE

      The value returned is the CPU time used so far as a clock_t; to get the number of seconds used, divide by CLOCKS_PER_SEC.  If the pro-

      cessor time used is not available or its value cannot be represented, the function returns the value (clock_t)-1.

 

CONFORMING TO

      ANSI C.  POSIX requires that CLOCKS_PER_SEC equals 1000000 independent of the actual resolution.

 

NOTES

      The C standard allows for arbitrary values at the start of the program; subtract the value returned from a  call  to  clock()  at  the

      start of the program to get maximum portability.

 

      Note  that  the  time can wrap around.  On a 32bit system where CLOCKS_PER_SEC equals 1000000 this function will return the same value

      approximately every 72 minutes.

 

      On several other implementations, the value returned by clock() also includes the times of any children whose  status  has  been  col-

      lected  via  wait()  (or  another  wait-type  call).  Linux does not include the times of waited-for children in the value returned by

      clock().  The times() function, which explicitly returns (separate) information about the caller and its children, may be  preferable.

 

SEE ALSO

      getrusage(2), times(2)

 

 

 

GNU                                                              2002-06-14                                                        CLOCK(3)

 

Om du skal ta tid på andre måter, eller med høyere oppløsning må du bruke OS-spesifike funksjoner. I hvertfall for en del av funksjonene og OSene.

 

Edit:

Men i stedet for å øke oppløsningen, kan du i grunn bare øke antall ganger noe skal testes, for så å ta samme antall når noe annet skal testes (det man skal sammenligne med).

Endret 10. desember 2004 av søppel

[søppel]

Eller man snur på det; teller iterasjoner i stedet for å måle tidsintervaller. Altså man setter ingen grenser på iterasjoner, og teller i stedet så mange man rekker på et gitt tidsintervall:

(let ((secs 1) (counter 0) (stop nil))
 (createThread
   (sleep secs)
   (setf stop t)        
   (format t "After ~A seconds, counter is ~A." secs counter))
 (do nil (stop)
   (incf counter)))

 

Der createThread er:

(defmacro createThread (&rest body)
 `(sb-thread:make-thread (lambda () ,@body)))

SBCL (Common Lisp) altså.

 

Orker ikke oversette dette til C/C++ akkurat nå (noen andre?), god natt. .... :}

Endret 13. desember 2004 av søppel

[søppel]

Her er programmet oversatt til C/C++:

#include <iostream>
#include <pthread.h>

using namespace std;

const unsigned int secs = 1;
volatile unsigned long counter = 0;
volatile bool stop = false;


void* measure(void*)
{
sleep(secs);
stop = true;
cout << "After " << secs << " seconds, counter is " << counter << '.' << endl;
return(0);
} // measure


int main(int argc, char* argv[])
{
pthread_t pt;
pthread_create(&pt, 0, measure, 0);

while(!stop) {
 counter++;
}

pthread_join(pt, 0);

return(0);
} // main

 

Husk å linke med pthread-biblioteket;

g++ -Wall a.cpp -l pthread -o a

 

(Wintendo? ==> http://sources.redhat.com/pthreads-win32/

Endret 13. desember 2004 av søppel

[Vaughn]

Hum. Er liksom ikke helt tingen det der, når du sammenligner med Lisp?

 

Jo jo. Søppel - skulle egentlig spørre deg om du noen gang viser deg i #[email protected], men hverken ICQ eller privatbeskjed-funksjonen funker her.

 

 

Det får forresten bli en oppfordring til alle dere som lurer på hva slags språk Lisp egentlig er: Logg dere på den ovennevnte kanalen, og spør om starthjelp. De er stort sett greie folk.

[søppel]

Vaughn:

Joda, C++-koden er riktignok raskere, men Lisp-koden er mye penere (eller? jeg er fortsatt ny) - og raskere å kode. Begynner i grunn å trivas med Lisp.

 

Angående IRC så er jeg fast inventar der, men er stille av meg, som regel. :]

 

Edit:

Btw. på IRC kaller jeg meg "daysleper" eller "dayslep|lt".

Endret 14. desember 2004 av søppel

[Vaughn]

Lisp koden din er grei, den, men jeg lurer litt på den createThread-makroen din.

 

For det første, "createThread"? Du vet at Lisp (per default) er case-insensitive, så et bedre (og mer lispete) navn er create-thread.

 

Bortsett fra det; det finnes ingen måte å få tak i IDen til tråden som blir laget. Vurder å la create-thread returnere denne.

[søppel]

Ja, er klar over det -- men ignorerer det og håper at SBCL-folka (eller ANSI-folka?) finner en løsning slik at jeg kan skrive case-sensitive kode. Jeg har eksperimentert litt med readeren (det den het?), men ikke 100% vellykket foreløpig.

 

Mulig jeg misser noe, men den returnerer PIDen i hvertfall:

(format t "~A"
 (createThread
   (sleep 1)))
30552
NIL

Uansett, beklager folkens -- dette blir fryktelig off-topic.

Endret 14. desember 2004 av søppel