[C] algoritmo per programma bench

[dierre]

Scusa ma non capisco che significa mandare la CPU al 100%. In generale un programma di benchmark deve fissare uno scopo. Tipo: calcolo dei numeri fino ad una certa cifra, etc...

Trovati una serie di problemi ed implementa l'algoritmo per risolverlo e vedi quanto ci mettono.

[tecno789]

Originariamente inviato da dierre

Scusa ma non capisco che significa mandare la CPU al 100%. In generale un programma di benchmark deve fissare uno scopo. Tipo: calcolo dei numeri fino ad una certa cifra, etc...

Trovati una serie di problemi ed implementa l'algoritmo per risolverlo e vedi quanto ci mettono.

hai mai provato ad usare wprime???
ecco volevo fare una cosa simile, per quanto riguarda problemi vari, ho già implementato tutto.

[Mirkolo]

E' sufficiente un:

white(1);

per mandare in palla un core del processore. Se vuoi caricarli tutti:

#include <stdio.h>
#include <windows.h>

#define NCORE 4

int vai(void *) {
  while(1);
}

int main(int argc, char *argv[]) {
  for(int n = 0; n < NCORE; ++n)
    CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)vai, (LPVOID)0, 0, NULL);
  getch();
}

[dierre]

Originariamente inviato da tecno789

hai mai provato ad usare wprime???
ecco volevo fare una cosa simile, per quanto riguarda problemi vari, ho già implementato tutto.

Non l'ho mai usato, ma come vedi dalla descrizione, il suo obiettivo è il seguente:

wPrime is a leading multithreaded benchmark for x86 processors that tests your processor performance by calculating square roots with a recursive call of Newton's method for estimating functions

Che non è "mandare la CPU al 100%". In questo thread chi più chi meno ti ha consigliato un ciclo infinito, no? Ammesso che ce la mandi con un while(1), che hai risolto? Che hai dimostrato sul processore che stai usando?

[tecno789]

Originariamente inviato da dierre

Non l'ho mai usato, ma come vedi dalla descrizione, il suo obiettivo è il seguente:

wPrime is a leading multithreaded benchmark for x86 processors that tests your processor performance by calculating square roots with a recursive call of Newton's method for estimating functions

Che non è "mandare la CPU al 100%". In questo thread chi più chi meno ti ha consigliato un ciclo infinito, no? Ammesso che ce la mandi con un while(1), che hai risolto? Che hai dimostrato sul processore che stai usando?

forse non l'hai capito e sinceramente non ho la voglia di spiegartela, ma ti ho già detto che sto provando a fare un programma simile a wprime. Il che vuol dire che se riesco a mandare i core al 100% riesco a misurare le prestazioni massime del processore. capito?? scarica wprime e provalo al massimo, un pò di cultura non fa mai male, anche perchè non so più come spiegartelo

[tecno789]

Originariamente inviato da Mirkolo

E' sufficiente un:

white(1);

per mandare in palla un core del processore. Se vuoi caricarli tutti:

#include <stdio.h>
#include <windows.h>

#define NCORE 4

int vai(void *) {
  while(1);
}

int main(int argc, char *argv[]) {
  for(int n = 0; n < NCORE; ++n)
    CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)vai, (LPVOID)0, 0, NULL);
  getch();
}

while(1) funziona eccome, ma non si adatta al mio contesto. Cioè io sto misurando un'operazione per poter misurare le capacità della cpu, ma se c'è un while che mi manda il loop infinito quell'operazione non finisce mai, quindi non posso utilizzarla.

[GByTe87]

A questo punto devi pensare ad un problema che comporti un uso massiccio di CPU.
Erano stati proposti calcoli su matrici o ordinamenti; altrimenti il solito calcolo del pi o dei numeri primi.

[marco.r]

Originariamente inviato da tecno789

while(1) funziona eccome, ma non si adatta al mio contesto. Cioè io sto misurando un'operazione per poter misurare le capacità della cpu, ma se c'è un while che mi manda il loop infinito quell'operazione non finisce mai, quindi non posso utilizzarla.

Ora ti sei spiegato meglio.
In teoria qualsiasi algoritmo che usi solo la cpu va bene.
Se la cpu non va al 100% vuol dire che effettui qualche altra operazione che non fa uso della cpu. Questo potrebbe essere lettura/scrittura su disco, usare una notevole quantita' di memoria che causa swap, comunicazione di rete, altro ancora. Oppure semplicemente fai dei test che durano troppo poco...
pero' a questo punto senza capire cosa fa il tuo codice che non ti funziona, dare ulteriori suggerimenti e' difficile.

[Mirkolo]

Certo, io ho banalizzato il tutto per farti vedere come caricare al 100% il processore partendo da una funzione. Dato che, senza multithreading, se hai più di un processore logico il carico del 100% non lo avrai mai.

Aggiungici qualcosa del tipo:

int calcola(void *) {
/* ciclo con calcoli a tua discrezione */
}

int main(int argc, char *argv[]) {
  HANDLE *h = new HANDLE[200];
  unsigned tempo;
  tempo = GetTickCount();
  for(int n = 0; n < 200; ++n)
    h[n] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)calcola, (LPVOID)0, 0, NULL);
  WaitForMultipleObjects(200, h, TRUE, INFINITE);
  printf("\nSono passati %ums", GetTickCount() - tempo);
}

Così hai 200 thread che eseguono dei calcoli, la WaitForSingleObjects torna quando tutti e 200 avranno terminato l'elaborazione. Programmi come SuperPI calcolano le prime tot cifre di PI greco, ma qualsiasi altro calcolo andrà bene.
Dipende se vuoi un test che carichi solo il processore o un mix tra cpu e ram.

SuperPI utilizza uno sviluppo in serie per calcolare pi greco, ma puoi partire da qualcosa di più banale calcolando il rapporto tra l'area di un quadrato di raggio X (Q = X²) e quella del cerchi di raggio X/2 (C = PI * X² / 4). Da cui ricavi PI come 4 * C / Q.

L'area del cerchio è data dalla somma dei punti che distano meno di R dal cerntro, considerando il centro nel mezzo:

int calcola(void *) {
  double y, x, Q, C = 0.0f, epsilon = .00001f;
  for(y = -1.0f; y < 1.0f; y += epsilon) {
    for(x = -1.0f; x < 1.0f; x += epsilon) {
      if ((x * x) + (y * y) < 1.0f) C += epsilon * epsilon;
    }
  }
  Q = 4.0f;
/*  printf("\nPI=%.6f", C / Q * 4.0f); */
}

Quanto più piccolo sarà epsilon, tanto più lento e preciso sarà il calcolo. Se vuoi ottimizzare il numero di thread, anzichè crearne 200, puoi chiedere al sistema operativo quanti processori logici ci sono.

Sotto Windows:

SYSTEM_INFO si;
GetSystemInfo(&si);
printf("\nCi sono %u processori", si.dwNumberOfProcessors);

Ma qualsiasi altra cosa andrà altrettanto bene, fai lavorare la fantasia e divertiti.

[dierre]

Mirkolo ho una domanda:

if ((x * x) + (y * y) < 1.0f)

In generale, per moltiplicazione e divisione coi fp, si fa sempre così oppure si misura se il prodotto è < di un certo delta?

[tecno789]

Originariamente inviato da Mirkolo

Certo, io ho banalizzato il tutto per farti vedere come caricare al 100% il processore partendo da una funzione. Dato che, senza multithreading, se hai più di un processore logico il carico del 100% non lo avrai mai.

Aggiungici qualcosa del tipo:

int calcola(void *) {
/* ciclo con calcoli a tua discrezione */
}

int main(int argc, char *argv[]) {
  HANDLE *h = new HANDLE[200];
  unsigned tempo;
  tempo = GetTickCount();
  for(int n = 0; n < 200; ++n)
    h[n] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)calcola, (LPVOID)0, 0, NULL);
  WaitForMultipleObjects(200, h, TRUE, INFINITE);
  printf("\nSono passati %ums", GetTickCount() - tempo);
}

Così hai 200 thread che eseguono dei calcoli, la WaitForSingleObjects torna quando tutti e 200 avranno terminato l'elaborazione. Programmi come SuperPI calcolano le prime tot cifre di PI greco, ma qualsiasi altro calcolo andrà bene.
Dipende se vuoi un test che carichi solo il processore o un mix tra cpu e ram.

SuperPI utilizza uno sviluppo in serie per calcolare pi greco, ma puoi partire da qualcosa di più banale calcolando il rapporto tra l'area di un quadrato di raggio X (Q = X²) e quella del cerchi di raggio X/2 (C = PI * X² / 4). Da cui ricavi PI come 4 * C / Q.

L'area del cerchio è data dalla somma dei punti che distano meno di R dal cerntro, considerando il centro nel mezzo:

int calcola(void *) {
  double y, x, Q, C = 0.0f, epsilon = .00001f;
  for(y = -1.0f; y < 1.0f; y += epsilon) {
    for(x = -1.0f; x < 1.0f; x += epsilon) {
      if ((x * x) + (y * y) < 1.0f) C += epsilon * epsilon;
    }
  }
  Q = 4.0f;
/*  printf("\nPI=%.6f", C / Q * 4.0f); */
}

Quanto più piccolo sarà epsilon, tanto più lento e preciso sarà il calcolo. Se vuoi ottimizzare il numero di thread, anzichè crearne 200, puoi chiedere al sistema operativo quanti processori logici ci sono.

Sotto Windows:

SYSTEM_INFO si;
GetSystemInfo(&si);
printf("\nCi sono %u processori", si.dwNumberOfProcessors);

Ma qualsiasi altra cosa andrà altrettanto bene, fai lavorare la fantasia e divertiti.

grandissimo..... il problema è che non ho capito bene come faccio a creare thread, nel tuo caso di codice 200, ma non mi torna, mi da errori in fase di compilazione.
guarda questo è un esempio STUPIDO:

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

int main(int argc,char **argv)
{
	long int i,a;
	const unsigned long int num=6000000000000000000000000000;
	clock_t start_clock=clock();
	printf("Calcolo secondi che impiega la vostra cpu a completare le operazioni \n");
	for(i=0;i<num;i++)
			a=(num*num*num*num*num*num*num*num*num*num);
			double sqrt(a);
			
	printf("Processor time used : %g sec.\n",(clock() - start_clock)/(double) CLOCKS_PER_SEC);
	system("PAUSE");
	return 0;
}

[banryu79]

Originariamente inviato da tecno789

[code]
...
const unsigned long int num=6000000000000000000000000000;
...

Forse è qua il problema.
Se non ricordo male, il range per gli unsigned long int va da 0 a ULONG_MAX.
ULONG_MAX è definita in limits.h, mi pare.
Forse sfori il range.

[tecno789]

Originariamente inviato da banryu79

Forse è qua il problema.
Se non ricordo male, il range per gli unsigned long int va da 0 a ULONG_MAX.
ULONG_MAX è definita in limits.h, mi pare.
Forse sfori il range.

Sisi lo si grazie, non era qui in cerca di una soluzione per quella cavolata di programma, più che altro vorrei capire come creare thread per caricare la cpu!

[demos88]

Mi sa che finchè sei in un sistema operativo "moderno" non riesci a caricare al 100% la cpu (o un core) con solo un tuo programma.
Principalmente per il fatto che l'OS si riserva sempre un tempo di Cpu per il modulo del kernel che si occupa dell'assegnazione della cpu ai processi. Mettendo il processo con priorità real time ottieni la massima priorità, ma non il massimo uso di cpu altrimenti il sistema potrebbe "perdere il controllo" sulla cpu.
Inoltre è anche vero che non tutte le istruzioni occupano solo il processore, un accesso a memoria (anche una semplice assegnazione) comporta l'accesso alla cache della cpu o alla memoria.

Poi dipende da cosa vuoi testare anche della cpu: l'alu, la cache di primo livello, di secondo... Per fare un lavoro preciso dovresti usare un linguaggio macchina come l'assembly così da dire per filo e per segno alla cpu che calcoli deve fare. L'assembly lo puoi facilmente embeddare in un programma scritto in C quindi a parte capire il significato di qualche comando non c'e' molto altro da fare, anche se diventa meno portabile rispetto a un programma scritto in C.

In ogni caso anche se la cpu lavora al 99% penso che sia sufficiente, di fatto i benchmark che ci sono in giro lavorano con questo presupposto. Da ciò deriva anche il fatto che lo stesso benchmark può fornire punteggi lievemente diversi ogni volta che lo fai in base a quali altri processi sono in esecuzione.

[!fazz]

Originariamente inviato da tecno789

Ciao a tutti i programmatori del forum

Allora premetto che sono un hardwarista e quindi di programmazione conosco solo html e il C, quindi non mi dite di scrivere in altri linguaggi.
Il punto è questo, sto provando a fare un programma che mi permetta di testare la potenza di calcolo della cpu, ma qualsiasi operazioni che io faccia non sono riuscito a mandare i core al 100%, qual'è l'algoritmo per poterlo fare?? esempio wprime e soci...
Non chiedo di poter smistare il carico sui multi-core, perchè va probabilmente aldilà delle mie capacità, però vorrei poter mandare al 100% la cpu, conoscete il modo?

potenza di cosa? calcolo intero, calcolo fp, SSE ecc ecc per testare la potenza della cpu non basta mandare il carico al 100% devi anche usare le opportune istruzioni sulle quali vuoi organizzare il bench

[SerMagnus]

per quanto mi riguarda stai sbagliando approccio, capisco che è una cosa amatoriale, ma non cavi un ragno dal buco senza un minimo di approfondimento tecnico e teorico.

già dopo aver visto questo è meglio che ti dica: leva mano.
ti hanno già detto che hai sbagliato, se insisti senza un minimo di teoria stai sbagliando strada.

const unsigned long int num=6000000000000000000000000000;

			a=(num*num*num*num*num*num*num*num*num*num);

a partire dal fatto che anche secondo me non hai le idee chiare.
non prendertela a male, ma voglio solo farti caprie dove sbagli.

[tecno789]

Originariamente inviato da demos88

Mi sa che finchè sei in un sistema operativo "moderno" non riesci a caricare al 100% la cpu (o un core) con solo un tuo programma.
Principalmente per il fatto che l'OS si riserva sempre un tempo di Cpu per il modulo del kernel che si occupa dell'assegnazione della cpu ai processi. Mettendo il processo con priorità real time ottieni la massima priorità, ma non il massimo uso di cpu altrimenti il sistema potrebbe "perdere il controllo" sulla cpu.
Inoltre è anche vero che non tutte le istruzioni occupano solo il processore, un accesso a memoria (anche una semplice assegnazione) comporta l'accesso alla cache della cpu o alla memoria.

Poi dipende da cosa vuoi testare anche della cpu: l'alu, la cache di primo livello, di secondo... Per fare un lavoro preciso dovresti usare un linguaggio macchina come l'assembly così da dire per filo e per segno alla cpu che calcoli deve fare. L'assembly lo puoi facilmente embeddare in un programma scritto in C quindi a parte capire il significato di qualche comando non c'e' molto altro da fare, anche se diventa meno portabile rispetto a un programma scritto in C.

In ogni caso anche se la cpu lavora al 99% penso che sia sufficiente, di fatto i benchmark che ci sono in giro lavorano con questo presupposto. Da ciò deriva anche il fatto che lo stesso benchmark può fornire punteggi lievemente diversi ogni volta che lo fai in base a quali altri processi sono in esecuzione.

quindi in C dici che non si riesce a scrivere un programma del genere??

Originariamente inviato da !fazz

potenza di cosa? calcolo intero, calcolo fp, SSE ecc ecc per testare la potenza della cpu non basta mandare il carico al 100% devi anche usare le opportune istruzioni sulle quali vuoi organizzare il bench

potenza generale della cpu, perchè wprime si basa sulle istruzioni?? non esegue la radice quadrata di un range di numeri???

Originariamente inviato da SerMagnus

per quanto mi riguarda stai sbagliando approccio, capisco che è una cosa amatoriale, ma non cavi un ragno dal buco senza un minimo di approfondimento tecnico e teorico.

già dopo aver visto questo è meglio che ti dica: leva mano.
ti hanno già detto che hai sbagliato, se insisti senza un minimo di teoria stai sbagliando strada.

const unsigned long int num=6000000000000000000000000000;

			a=(num*num*num*num*num*num*num*num*num*num);

a partire dal fatto che anche secondo me non hai le idee chiare.
non prendertela a male, ma voglio solo farti caprie dove sbagli.

uh si di sicuro quel programmino l'ho fatto alla cavolo, hai perfettamente ragione, ma non è il programma finale, cioè prima volevo capire solamente come utilizzare tutta la cpu e poi avrei fatto un programma decente, comunque non essendo un programmatore, le critiche sono ben accette

[cdimauro]

E' praticamente impossibile utilizzare tutta la CPU per ogni ciclo di clock, se è questo che vorresti ottenere: per un motivo o per un altro ci saranno delle sezioni e/o unità (di esecuzione) non utilizzate.

[tecno789]

Originariamente inviato da cdimauro

E' praticamente impossibile utilizzare tutta la CPU per ogni ciclo di clock, se è questo che vorresti ottenere: per un motivo o per un altro ci saranno delle sezioni e/o unità (di esecuzione) non utilizzate.

e i programmi di bench come fanno ad ottenere ciò??

[cdimauro]

A ottenere cosa? Come ho già detto, è praticamente impossibile farlo.

Se hai conoscenze di architetture degli elaboratori, prenditi lo schema interno di una CPU, conta tutte le sezioni che ci sono, le unità di esecuzione, e cerca di immaginare un mix di istruzioni che potrebbe impegnarle tutte.

Girala quanto vuoi, vedrai che, a conti fatti, qualcuna rimarrà sempre a girarsi i pollici.