OpenCL: test di implementazione interna in MQL5 - pagina 40

Nuovo commento
 
joo:

1. i giochi per computer non si preoccupano della temperatura della GPU e la caricano al massimo, e non succede niente - le schede grafiche funzionano.

2. in questo caso, la funzione MQL che restituisce la temperatura della CPU è anche necessaria. :), altrimenti il processore potrebbe bruciarsi.

3. - Non è un problema, ovviamente.

1. come fai a sapere che non gli interessa? Non è un fatto. Ad alcuni potrebbe non importare. E ci sono un sacco di persone sui forum che hanno bruciato le carte sui giocattoli.

Il driver che viene fornito con GeForce GTX 590 potrebbe bruciare la scheda video

Gli appassionati svedesi hanno dovuto scoprire che il driver GeForce GTX 590 versione 267.52 può danneggiare la GeForce GTX 590 di fascia alta. La prima scheda 3D a doppio processore si è bruciata mentre cercava di fare l'overclock. Dato che la tensione della GPU è stata overcloccata, gli sperimentatori hanno deciso di verificare come si sarebbe comportata la seconda - e ha subito lo stesso destino. Ottenendo aiuto da NVIDIA, gli implacabili svedesi sono riusciti a capire che la ragione del fallimento è un bug nel driver, che impedisce alla protezione dal sovraccarico di entrare in funzione.

Il processo del fallimento della scheda è catturato in un video istruttivo:


Per scaricare i file dal nostro server, si prega di registrarsi.

Il test è stato ripetuto con una nuova versione del driver- 267.71. Ha confermato che il bug è stato risolto e che il meccanismo di protezione funziona. Sfortunatamente, le schede sono arrivate con il driver con l'errore. Va notato che il meccanismo di protezione non è solo per quei casi in cui l'utente sta sperimentando con frequenze e tensioni. Durante l'uso normale, può anche verificarsi una situazione anormale in cui l'unica speranza per l'utente è il rimedio previsto dagli sviluppatori.
Gli
appassionati sono invitati a non installare mai il driver in bundle, ma piuttosto a scaricare una versione più recente dal sito web di NVIDIA. Inoltre, gli appassionati di overclocking dovrebbero assicurarsi che ci sia una buona ventilazione nel case del PC.

2. Non lo discuto. Ma non è così critico: quando il processore si surriscalda, Windows si blocca in una schermata blu. È sgradevole, ma non c'è paragone. :)

3. è sicuramente realizzabile - ci sono un sacco di programmi che controllano la temperatura e altri parametri della scheda. (Ne ho già quattro.) In qualche modo ottengono queste informazioni, vero?

Zy. Inoltre, si diceva che ad alte temperature le schede cominciano a sbagliare i calcoli. Nei giocattoli non è critico, ma in qualche modo indesiderabile.

 

Le schede si sono bruciate a causa di errori nel driver della scheda video, che hanno meccanismi di protezione dal sovraccarico integrati, piuttosto che perché il software in esecuzione sulla GPU non controlla la temperatura.

Non è che qualcuno sia immune da errori di driver ed è possibile che anche se non ci sono applicazioni in esecuzione sulla GPU, la scheda si bruci comunque a causa di un errore di driver.

Non dovete preoccuparvi: caricate il vostro hardware al massimo, non può succedere niente di male anche se vi sforzate. L'hardware moderno è ricco di sistemi di protezione contro i sovraccarichi, sia della CPU che della GPU. Sono finiti i tempi in cui rimuovendo il radiatore dalla CPU si poteva letteralmente appiccare un incendio.

 

joo 2012.03.21 09:06

Le schede sono bruciate a causa di errori nel driver della scheda video che ha meccanismi di protezione dal sovraccarico integrati e non perché il software che gira sulla GPU non controlla la temperatura.

Non è che qualcuno sia immune agli errori dei driver ed è possibile che anche se non ci sono applicazioni in esecuzione sulla GPU la scheda si bruci comunque a causa di un errore dei driver.

Non dovete preoccuparvi: caricate il vostro hardware al massimo, non può succedere niente di male anche se vi sforzate. L'hardware moderno è ricco di sistemi di protezione contro i sovraccarichi, sia della CPU che della GPU. Sono lontani i giorni in cui la rimozione di un cooler dalla CPU poteva letteralmente scatenare un incendio.

Sono d'accordo, il controllo della temperatura è un compito di utilità di basso livello (forse anche un compito hardware),

controllare la temperatura da un software scritto in un linguaggio di alto livello è un modo suicida di procedere.

 

Fate provare questo nonnismo alla GPU.

Esecuzione di cicli paralleli, ognuno dei quali 100000000 (cento milioni) di iterazioni.

Quali sono le vostre impressioni?

//+------------------------------------------------------------------+
//|                                                   OpenCLTest.mq5 |
//|                        Copyright 2011, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2011, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"

//——————————————————————————————————————————————————————————————————————————————
const string cl_src=
"__kernel void MFractal(                                    \r\n"
"                       __global int *out                   \r\n"
"                      )                                    \r\n"
"  {                                                        \r\n"
"   int i = get_global_id(0);                               \r\n"
"   for(int u=0;u<100000000;u++)                            \r\n"
"   {                                                       \r\n"
"    out[i]+=u;                                             \r\n"
"    if(out[i]>10000)                                       \r\n"
"      out[i]=0;                                            \r\n"
"   }                                                       \r\n"
"   out[i]+= i;                                             \r\n"
"  }                                                        \r\n";
//——————————————————————————————————————————————————————————————————————————————


#define BUF_SIZE 480


//——————————————————————————————————————————————————————————————————————————————
void OnStart()
{
  int cl_ctx; // идентификатор контекста
  int cl_prg; // идентификатор программы
  int cl_krn; // идентификатор ядра
  int cl_mem; // идентификатор буфера


  //----------------------------------------------------------------------------
  //--- инициализируем OpenCL объекты
  if((cl_ctx=CLContextCreate(false))==0)
  {
    Print("OpenCL not found");
    return;
  }
  if((cl_prg=CLProgramCreate(cl_ctx,cl_src))==0)
  {
    CLContextFree(cl_ctx);
    Print("OpenCL program create failed");
    return;
  }
  if((cl_krn=CLKernelCreate(cl_prg,"MFractal"))==0)
  {
    CLProgramFree(cl_prg);
    CLContextFree(cl_ctx);
    Print("OpenCL kernel create failed");
    return;
  }
  if((cl_mem=CLBufferCreate(cl_ctx,BUF_SIZE*sizeof(float),CL_MEM_READ_WRITE))==0)
  {
    CLKernelFree(cl_krn);
    CLProgramFree(cl_prg);
    CLContextFree(cl_ctx);
    Print("OpenCL buffer create failed");
    return;
  }
  //----------------------------------------------------------------------------


  //--- подготовимся к выполению
  uint  offset[1]={0};
  uint  work  [1]={BUF_SIZE};


  //--- выставляем неизменяемые параметры функции OpenCL
  //CLSetKernelArg   (cl_krn,4,max);
  CLSetKernelArgMem(cl_krn,0,cl_mem);


  //--- подготовим буфер для вывода пикселей
  uint buf[];
  ArrayResize(buf,BUF_SIZE);


  uint x=GetTickCount();

  //--- выставляем плавающие параметры
  //CLSetKernelArg(cl_krn,0,x0);
  //CLSetKernelArg(cl_krn,1,y0);
  //CLSetKernelArg(cl_krn,2,x1);
  //CLSetKernelArg(cl_krn,3,y1);

  //--- считаем на GPU
  CLExecute(cl_krn,1,offset,work);

  //--- забираем данные из буфера
  CLBufferRead(cl_mem,buf);

  //--- выведем время расчётов
  Print(IntegerToString(GetTickCount()-x)+" msec");

  
/*
  //--- посмотрим ка что там насчитал нам GPU
  for(int i=0;i<BUF_SIZE;i++)
  {
    Print(buf[i]);
  }
*/

  //--- удаляем объекты OpenCL
  CLBufferFree (cl_mem);
  CLKernelFree (cl_krn);
  CLProgramFree(cl_prg);
  CLContextFree(cl_ctx);
}
//——————————————————————————————————————————————————————————————————————————————

2012.03.21 18:20:36 Tast Mand_ (EURUSD,H1) 5741 msec

2012.03.21 18:15:53 Terminale CPU: GenuineIntel Intel(R) Core(TM) i5-2500 CPU @ 3.30GHz con OpenCL 1.1 (4 unità, 3311 MHz, 8174 Mb, versione 2.0)

2012.03.21 18:15:53 Terminale GPU: NVIDIA Corporation GeForce GTX 570 con OpenCL 1.1 (15 unità, 1464 MHz, 1280 Mb, versione 296.10)

File:
Tast_Mand_.mq5  4 kb
 
MetaDriver: Inoltre, si diceva che a temperature più alte le schede cominciano a mentire.
È a causa della morte di massa delle mosche o qualcosa del genere?
 
Mathemat:
È la morte delle mosche o qualcosa del genere?
Prova ad eseguire il test (vedi il mio post sopra). Lo schermo si blocca, il cursore del mouse si muove?
 
Mathemat:
È perché le mosche stanno morendo o qualcosa del genere?

Questo è improbabile, poiché la maggior parte del processo è reversibile. Fluttuazioni del plasma di elettroni e buchi... (oh come!). I singoli bit scattano di tanto in tanto. Io e te siamo fuori strada. :)

Mi spavento molto quando la mia scheda arriva a 90°C. Un paio di migliaia di millisecondi tra una serie di corse e l'altra in questo caso mantengono la temperatura almeno a 82C.

L'ho inserito, ma la cosa buona è che si ha la flessibilità di inserirlo a seconda delle necessità e la soglia di temperatura può essere impostata programmaticamente.

 
joo: Prova ad eseguire il test (vedi il mio post sopra). Lo schermo si blocca, il cursore del mouse si muove?

Non ho un hardware così potente come il vostro.

Proverò ora, ma rimetterò il driver AMD.

 
Mathemat:

Non ho un hardware potente come il tuo.

Proverò ora, ma rimetterò il driver AMD.

A proposito, ora ho il driver AMD OpenCL per la mia CPU - ho dovuto metterlo perché quello Intel è installato senza errori ma il processore non viene rilevato come dispositivo OpenCL.
  
2012.03.21 15:45:49     Tast_Mand_ (EURUSD,H1)  16801 msec

2012.03.21 15:42:19     Terminal        CPU: AuthenticAMD AMD Athlon(tm) II X4 630 Processor with OpenCL 1.1 (4 units, 2998 MHz, 2048 Mb, version 2.0)
2012.03.21 15:42:19     Terminal        GPU: NVIDIA Corporation GeForce GT 440 with OpenCL 1.1 (2 units, 1660 MHz, 1024 Mb, version 295.73)
Non ho notato alcuno sforzo sulla scheda video, corre e scatta. Ho aperto il dispatcher durante il test, anche bene, nessun ritardo, solo il tempo del test è diventato di 17 secondi.
1...333435363738394041424344454647...70
Nuovo commento