OpenCL : tests de l'implémentation interne dans MQL5 - page 40

Nouveau commentaire
 
joo:

1. les jeux vidéo ne se soucient pas de la température du GPU et le chargent au maximum, et rien ne se passe - les cartes graphiques fonctionnent.

2. dans ce cas, la fonction MQL retournant la température du CPU est également nécessaire. :), sinon le processeur pourrait être brûlé.

3. - Ce n'est pas un problème, bien sûr.

1. Comment savez-vous qu'ils s'en fichent ? Ce n'est pas un fait. Certains peuvent s'en moquer. Et il y a beaucoup de gens sur les forums qui ont brûlé des cartes pour des jouets.

Le pilote fourni avec la GeForce GTX 590 risque de brûler la carte vidéo.

Les amateurs suédois ont dû constater que la version 267.52 du pilote de la GeForce GTX 590 pouvait endommager la GeForce GTX 590 haut de gamme. La première carte 3D à double processeur a brûlé en essayant de l'overclocker. Étant donné que la tension du GPU était overclockée, les expérimentateurs ont décidé de vérifier comment le second se comporterait - et il a subi le même sort. En obtenant l'aide de NVIDIA, les Suédois ont réussi à comprendre que la raison de la panne est un bug dans le pilote, qui empêche la protection contre la surcharge de se déclencher.

Le processus d'échec de la carte est capturé dans une vidéo instructive :


. Pour télécharger les fichiers de notre serveur, veuillez vous inscrire.

Le test a été répété avec une nouvelle version du pilote- 267.71. Elle a confirmé que le bug est corrigé et que le mécanisme de protection fonctionne. Malheureusement, les cartes ont été livrées avec le pilote comportant l'erreur. Il convient de noter que le mécanisme de protection ne concerne pas uniquement les cas où l'utilisateur expérimente des fréquences et des tensions. Dans le cadre d'une utilisation normale, une situation anormale peut également survenir où le seul espoir pour l'utilisateur est le remède prévu par les développeurs.
Il est conseillé aux
amateurs de ne jamais installer le pilote fourni, mais plutôt de télécharger une version plus récente sur le site Web de NVIDIA. En outre, les amateurs d'overclocking doivent veiller à ce que le boîtier du PC soit bien ventilé.

2. Je ne discute pas de cela. Mais ce n'est pas si critique : lorsque le processeur surchauffe, Windows se bloque sur un écran bleu. C'est désagréable, mais ce n'est pas comparable. :)

3. c'est tout à fait réalisable - il existe un grand nombre de programmes qui contrôlent la température et d'autres paramètres de la carte. (Seulement, j'en ai déjà quatre.) D'une manière ou d'une autre, ils obtiennent cette information, n'est-ce pas ?

Zy. De plus, il y a une rumeur selon laquelle à haute température, les cartes commencent à faire des erreurs de calcul. Dans les jouets, ce n'est pas critique, mais en quelque sorte indésirable.

 

Les cartes ont brûlé à cause d'erreurs dans le pilote de la carte vidéo, qui dispose de mécanismes intégrés de protection contre la surcharge, plutôt que parce que le logiciel fonctionnant sur le GPU ne contrôle pas la température.

Personne n'est à l'abri d'une erreur de pilote et il est possible que, même si aucune application n'est exécutée sur le GPU, la carte brûle à cause d'une erreur de pilote.

Vous n'avez pas à vous en inquiéter - chargez votre matériel au maximum, rien de mal ne peut arriver même si vous faites des efforts. Le matériel moderne est doté de systèmes de protection contre les surcharges, tant au niveau du CPU que du GPU. Il est loin le temps où, en retirant le refroidisseur du processeur, on pouvait littéralement mettre le feu.

 

joo 2012.03.21 09:06

Les cartes sont grillées à cause d'erreurs dans le pilote de la carte vidéo qui possède des mécanismes intégrés de protection contre les surcharges et non parce que le logiciel fonctionnant sur le GPU ne surveille pas la température.

Personne n'est à l'abri d'une erreur de pilote et il est possible que, même si aucune application n'est exécutée sur le GPU, la carte brûle à cause d'une erreur de pilote.

Vous n'avez pas à vous en inquiéter - chargez votre matériel au maximum, rien de mal ne peut arriver même si vous faites des efforts. Le matériel moderne est doté de systèmes de protection contre les surcharges, tant au niveau du CPU que du GPU. Il est loin le temps où retirer un refroidisseur du processeur pouvait littéralement déclencher un incendie.

Je suis d'accord, le contrôle de la température est une tâche utilitaire de bas niveau (peut-être même une tâche matérielle),

Contrôler la température à partir d'un logiciel écrit dans un langage de haut niveau est une voie suicidaire.

 

Quelqu'un a essayé ce bizutage GPU.

Exécution de boucles parallèles, dont chacune compte 100000000 (cent millions) itérations.

Quelles sont vos impressions ?

//+------------------------------------------------------------------+
//|                                                   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 avec OpenCL 1.1 (4 unités, 3311 MHz, 8174 Mb, version 2.0)

2012.03.21 18:15:53 Terminal GPU : NVIDIA Corporation GeForce GTX 570 avec OpenCL 1.1 (15 unités, 1464 MHz, 1280 Mb, version 296.10)

Dossiers :
Tast_Mand_.mq5  4 kb
 
MetaDriver: De plus, il y avait une rumeur selon laquelle à des températures plus élevées, les cartes commencent à induire en erreur.
C'est à cause de la mort massive des mouches ou autre ?
 
Mathemat:
C'est la mort des mouches ou quoi ?
Essayez d'exécuter le test (voir mon message ci-dessus). L'écran se fige-t-il, le curseur de la souris bouge-t-il ?
 
Mathemat:
C'est parce que les mouches meurent ou quelque chose comme ça ?

C'est peu probable, car la majeure partie du processus est réversible. Fluctuations du plasma électron-trou... (oh comment !). Les bits individuels cliquent occasionnellement. Vous et moi, nous sommes hors de notre chemin. :)

Je suis vraiment effrayé quand ma carte atteint 90°C. Quelques milliers de millisecondes entre les séries de runs dans ce cas maintiennent la température à 82°C au moins.

Je l'ai mis, mais ce qui est bien, c'est que vous avez la possibilité de le mettre en place selon vos besoins et que le seuil de température peut être défini par programmation.

 
joo: Essayez d'exécuter le test (voir mon message ci-dessus). L'écran se fige-t-il, le curseur de la souris bouge-t-il ?

Je n'ai pas un matériel aussi puissant que le vôtre.

Je vais essayer maintenant, mais je vais juste rebrancher le pilote AMD.

 
Mathemat:

Je n'ai pas un matériel aussi puissant que le vôtre.

Je vais essayer maintenant, mais je vais remettre le pilote AMD.

Au fait, j'ai maintenant le pilote OpenCL d'AMD pour mon processeur - j'ai dû le mettre car celui d'Intel est installé sans erreur mais le processeur n'est pas détecté comme périphérique 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)
Je n'ai remarqué aucune tension sur la carte vidéo, elle fonctionne et clique. J'ai ouvert le répartiteur pendant le test, et tout s'est bien passé, pas de décalage, seul le temps du test est devenu de 17 secondes.
1...333435363738394041424344454647...70
Nouveau commentaire