OpenCL: interne Implementierungstests in MQL5 - Seite 40

Neuer Kommentar
 
joo:

1. Computerspiele kümmern sich nicht um die GPU-Temperatur und belasten sie bis zum Maximum, und nichts passiert - Grafikkarten funktionieren.

2. In diesem Fall ist auch eine MQL-Funktion erforderlich, die die CPU-Temperatur zurückgibt. :), da sonst der Prozessor verbrannt werden könnte.

3. - Sicher, es würde nicht schaden.

1. Woher wissen Sie, dass es sie nicht interessiert? Das ist keine Tatsache. Einigen mag das egal sein. Und es gibt eine Menge Leute in den Foren, die Karten für Spielzeug verbrannt haben.

Der mit der GeForce GTX 590 gelieferte Treiber kann die Grafikkarte verbrennen

Schwedische Enthusiasten mussten feststellen, dass der GeForce GTX 590 Treiber Version 267.52 die High-End GeForce GTX 590 beschädigen kann. Die erste Dual-Prozessor-3D-Karte ist beim Versuch, sie zu übertakten, durchgebrannt. Da die GPU-Spannung übertaktet war, beschlossen die Experimentatoren zu prüfen, wie sich die zweite GPU verhalten würde - und sie erlitt das gleiche Schicksal. Mit Hilfe von NVIDIA konnten die unermüdlichen Schweden herausfinden, dass der Grund für das Versagen ein Fehler im Treiber ist, der verhindert, dass der Überlastungsschutz anspringt.

Der Vorgang des Kartenversagens ist in einem lehrreichen Video festgehalten:


Um Dateien von unserem Server herunterzuladen, registrieren Sie sich bitte.

Der Test wurde mit einer neuen Treiberversion- 267.71 - wiederholt. Sie bestätigte, dass der Fehler behoben ist und der Schutzmechanismus funktioniert. Leider wurde die Karte mit dem Treiber geliefert, der den Fehler aufweist. Es sei darauf hingewiesen, dass der Schutzmechanismus nicht nur für die Fälle gedacht ist, in denen der Benutzer mit Frequenzen und Spannungen experimentiert. Bei normalem Gebrauch kann auch eine anormale Situation auftreten, in der die einzige Hoffnung für den Benutzer die von den Entwicklern vorgesehene Abhilfe ist.
Enthusiasten
wird empfohlen, niemals den mitgelieferten Treiber zu installieren, sondern eine neuere Version von der NVIDIA-Website herunterzuladen. Außerdem sollten Übertaktungsenthusiasten auf eine gute Belüftung des PC-Gehäuses achten.

2. das bestreite ich nicht. Aber so kritisch ist das nicht - wenn der Prozessor überhitzt, stürzt Windows mit einem blauen Bildschirm ab. Es ist unangenehm, aber kein Vergleich. :)

3. es ist definitiv realisierbar - es gibt eine ganze Reihe von Programmen, die die Temperatur und andere Parameter der Karte überwachen. (Nur dass ich schon vier davon habe.) Irgendwie bekommen sie diese Informationen, nicht wahr?

Außerdem gab es ein Gerücht, dass die Karten bei hohen Temperaturen anfangen, sich zu verrechnen. Bei Spielzeug ist es nicht kritisch, aber irgendwie unerwünscht.

 

Die Karten brannten aufgrund von Fehlern im Grafikkartentreiber, die über eingebaute Überlastungsschutzmechanismen verfügen, und nicht, weil die auf der GPU laufende Software die Temperatur nicht kontrolliert.

Niemand ist vor Treiberfehlern gefeit, und es ist möglich, dass die Karte aufgrund eines Treiberfehlers durchbrennt, auch wenn keine Anwendungen auf der GPU laufen.

Sie brauchen sich keine Sorgen zu machen - belasten Sie Ihre Hardware bis zum Maximum, dann kann nichts Schlimmes passieren, auch wenn Sie sich Mühe geben. Moderne Hardware ist vollgepackt mit Schutzsystemen gegen Überlastungen, sowohl bei der CPU als auch bei der GPU. Die Zeiten, in denen man durch das Entfernen des Kühlers von der CPU buchstäblich ein Feuer entfachen konnte, sind längst vorbei.

 

joo 2012.03.21 09:06

Die Karten sind aufgrund von Fehlern im Grafikkartentreiber durchgebrannt, der über eingebaute Überlastungsschutzmechanismen verfügt, und nicht, weil die auf der GPU laufende Software die Temperatur nicht überwacht.

Niemand ist vor Treiberfehlern gefeit, und es ist möglich, dass die Karte aufgrund eines Treiberfehlers durchbrennt, auch wenn keine Anwendungen auf der GPU laufen.

Sie brauchen sich keine Sorgen zu machen - belasten Sie Ihre Hardware bis zum Maximum, es kann nichts Schlimmes passieren, selbst wenn Sie sich anstrengen. Moderne Hardware ist vollgepackt mit Schutzsystemen gegen Überlastungen, sowohl bei der CPU als auch bei der GPU. Die Zeiten, in denen das Entfernen eines Kühlers von der CPU buchstäblich ein Feuer auslösen konnte, sind längst vorbei.

Ich stimme zu, dass die Temperaturkontrolle eine Aufgabe auf niedriger Ebene ist (vielleicht sogar eine Hardware-Aufgabe),

Die Steuerung der Temperatur über eine in einer Hochsprache geschriebene Software ist ein selbstmörderischer Weg.

 

Hat jemand dieses GPU-Schikanieren ausprobiert?

In parallelen Schleifen, von denen jede 100000000 (hundert Millionen) Iterationen durchläuft.

Was sind Ihre Eindrücke?

//+------------------------------------------------------------------+
//|                                                   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 Terminal CPU: GenuineIntel Intel(R) Core(TM) i5-2500 CPU @ 3.30GHz mit OpenCL 1.1 (4 Einheiten, 3311 MHz, 8174 Mb, Version 2.0)

2012.03.21 18:15:53 Terminal GPU: NVIDIA Corporation GeForce GTX 570 mit OpenCL 1.1 (15 Einheiten, 1464 MHz, 1280 Mb, Version 296.10)

Dateien:
Tast_Mand_.mq5  4 kb
 
MetaDriver: Außerdem gab es ein Gerücht, dass die Karten bei höheren Temperaturen zu täuschen beginnen.
Liegt es am Massensterben der Fliegen oder an etwas anderem?
 
Mathemat:
Ist das der Tod der Fliegen oder etwas anderes?
Versuchen Sie, den Test durchzuführen (siehe meinen Beitrag oben). Hält der Bildschirm an, bewegt sich der Mauszeiger?
 
Mathemat:
Liegt es daran, dass die Fliegen sterben oder so?

Dies ist unwahrscheinlich, da der Großteil des Prozesses reversibel ist. Elektronen-Loch-Plasma-Fluktuationen... (oh wie!). Einzelne Bits klicken gelegentlich. Sie und ich sind aus dem Weg. :)

Aber es macht mich wahnsinnig, wenn die Karte auf 90 Grad Celsius kommt. Ein paar tausend Millisekunden zwischen den Durchläufen halten die Temperatur in diesem Fall mindestens bei 82 Grad.

Ich habe es eingebaut, aber das Gute daran ist, dass man die Flexibilität braucht, es nach Bedarf einzubauen, und der Temperaturschwellenwert kann programmatisch eingestellt werden.

 
joo: Versuchen Sie, den Test durchzuführen (siehe meinen Beitrag oben). Hält der Bildschirm an, bewegt sich der Mauszeiger?

Nun, ich habe nicht so eine leistungsstarke Hardware wie Sie.

Ich werde es jetzt versuchen, aber ich werde den AMD-Treiber wieder einbauen.

 
Mathemat:

Ich habe nicht so eine leistungsfähige Hardware wie Sie.

Ich werde es jetzt versuchen, aber ich werde den AMD-Treiber wieder einbauen.

Übrigens habe ich jetzt einen AMD OpenCL-Treiber für meine CPU - ich musste ihn aufsetzen, da der Intel-Treiber zwar fehlerfrei installiert ist, der Prozessor aber nicht als OpenCL-Gerät erkannt wird.
  
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)
Ich habe keine Belastung der Grafikkarte bemerkt, sie läuft und klickt. Öffnete den Dispatcher während des Tests, auch gut, keine Verzögerungen, nur die Testzeit wurde 17 Sekunden.
1...333435363738394041424344454647...70
Neuer Kommentar