Scripts: Test OpenCL - page 2

Nouveau commentaire
 
Svetosha:
Et à quoi servent ces opportunités si elles ne sont pas utiles))))))
Les frères Wright n'ont volé que sur 20 mètres (donc un vol de démonstration), l'utilité de leur invention est de réaliser des vols intercontinentaux (comme on dit sentir la différence).
 
Zeleniy: L'ovule avant la conception. Je ne comprends toujours pas pourquoi le sortir, il vaudrait mieux faire quelque chose d'utile et de non finalisé.
Svetosha: Et l'utilisation de ces opportunités si elles ne sont pas utiles))))))

Les innovations sont très souvent rencontrées dans la baïonnette par de tels "praticiens sermyazhnye", qui jugent des problèmes universels du point de vue de leur nez, pour qui rien ne sent.

Puis, lorsque l'avantage est visible pour tous, ils oublient leurs attaques en toute sécurité.

 
Mathemat:

Les innovations sont très souvent prises à revers par ces "praticiens gris", qui jugent les problèmes universels du point de vue de leur nez, pour qui rien n'a d'odeur.

Puis, lorsque tout le monde en voit les avantages, ils oublient leurs attaques.

Oui, OpenCL est vraiment cool. Pour être honnête, je n'ai pas suivi la situation avec 5 depuis longtemps. L'inter-absorption des commandes est-elle toujours là ?
 
VDev:
L'absorption de l'ordre existe-t-elle encore ?

Ce n'est pas qu'elle existe toujours.

Il ne peut en être autrement.

 

À partir de la prochaine version, de nouvelles fonctionnalités seront disponibles pour créer des ressources graphiques à la volée en utilisant les fonctions ResourceCreate().

Voici un script réécrit et simplifié qui permet de ne pas décharger les images sur le disque, de travailler plus rapidement et sans conflit d'accès aux ressources sur le disque :

//+------------------------------------------------------------------+
//|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"
//---
#define SIZE_X 512
#define SIZE_Y 512
//+------------------------------------------------------------------+
//| Code de la fonction OpenCL|
//+------------------------------------------------------------------+
const string cl_src=
                    "__kernel void MFractal(                                    \r\n"
                    "                       float x0,                           \r\n"
                    "                       float y0,                           \r\n"
                    "                       float x1,                           \r\n"
                    "                       float y1,                           \r\n"
                    "                       uint  max,                          \r\n"
                    "              __global uint *out)                          \r\n"
                    "  {                                                        \r\n"
                    "   size_t  w = get_global_size(0);                         \r\n"
                    "   size_t  h = get_global_size(1);                         \r\n"
                    "   size_t gx = get_global_id(0);                           \r\n"
                    "   size_t gy = get_global_id(1);                           \r\n"
                    "   float dx = x0 + gx * (x1-x0) / (float) w;               \r\n"
                    "   float dy = y0 + gy * (y1-y0) / (float)h;                \r\n"
                    "   float x  = 0;                                           \r\n"
                    "   float y  = 0;                                           \r\n"
                    "   float xx = 0;                                           \r\n"
                    "   float yy = 0;                                           \r\n"
                    "   float xy = 0;                                           \r\n"
                    "   uint i = 0;                                             \r\n"
                    "   while ((xx+yy)<4 && i<max)                              \r\n"
                    "     {                                                     \r\n"
                    "      xx = x*x;                                            \r\n"
                    "      yy = y*y;                                            \r\n"
                    "      xy = x*y;                                            \r\n"
                    "      y = xy+xy+dy;                                        \r\n"
                    "      x = xx-yy+dx;                                        \r\n"
                    "      i++;                                                 \r\n"
                    "     }                                                     \r\n"
                    "   if(i==max)                                              \r\n"
                    "      out[w*gy+gx] = 0;                                    \r\n"
                    "   else                                                    \r\n"
                    "      out[w*gy+gx] = (uint)((float)0xFFFFFF/(float)max)*i; \r\n"
                    "  }                                                        \r\n";
//+------------------------------------------------------------------+
//| Fonction de démarrage du programme de script|
//+------------------------------------------------------------------+
void OnStart()
  {
   int cl_ctx;
   int cl_prg;
   int cl_krn;
   int cl_mem;
//--- initialisation des objets OpenCL
   if((cl_ctx=CLContextCreate())==INVALID_HANDLE)
     {
      Print("OpenCL not found");
      return;
     }
   if((cl_prg=CLProgramCreate(cl_ctx,cl_src))==INVALID_HANDLE)
     {
      CLContextFree(cl_ctx);
      Print("OpenCL program create failed");
      return;
     }
   if((cl_krn=CLKernelCreate(cl_prg,"MFractal"))==INVALID_HANDLE)
     {
      CLProgramFree(cl_prg);
      CLContextFree(cl_ctx);
      Print("OpenCL kernel create failed");
      return;
     }
   if((cl_mem=CLBufferCreate(cl_ctx,SIZE_X*SIZE_Y*sizeof(uint),CL_MEM_READ_WRITE))==INVALID_HANDLE)
     {
      CLKernelFree(cl_krn);
      CLProgramFree(cl_prg);
      CLContextFree(cl_ctx);
      Print("OpenCL buffer create failed");
      return;
     }
//--- se préparer à l'exécution
   float x0       =-2;
   float y0       =-0.5;
   float x1       =-1;
   float y1       = 0.5;
   uint  max      = 20000;
   uint  offset[2]={0,0};
   uint  work  [2]={SIZE_X,SIZE_Y};
   string objname ="OpenCL_"+IntegerToString(ChartID());
   string resname ="Mandelbrot_"+IntegerToString(ChartID());
//--- définition de paramètres de fonctions OpenCL non modifiables
   CLSetKernelArg(cl_krn,4,max);
   CLSetKernelArgMem(cl_krn,5,cl_mem);
//--- création de l'objet pour l'affichage graphique
   ObjectCreate(0,objname,OBJ_BITMAP_LABEL,0,0,0);
   ObjectSetInteger(0,objname,OBJPROP_XDISTANCE,4);
   ObjectSetInteger(0,objname,OBJPROP_YDISTANCE,26);
//--- créer une image initiale vide
   uint buf[];

   ArrayResize(buf,SIZE_X*SIZE_Y);
   ResourceCreate(resname,buf,SIZE_X,SIZE_Y,0,0,SIZE_X,COLOR_FORMAT_XRGB_NOALPHA);
   ObjectSetString(0,objname,OBJPROP_BMPFILE,"::"+resname);
//--- l'équarrissage, jusqu'à ce que nous ne soyons plus arrêtés de l'extérieur
   while(!IsStopped())
     {
      uint x=GetTickCount();
      //--- réglage des paramètres flottants
      CLSetKernelArg(cl_krn,0,x0);
      CLSetKernelArg(cl_krn,1,y0);
      CLSetKernelArg(cl_krn,2,x1);
      CLSetKernelArg(cl_krn,3,y1);
      //--- rendu du cadre
      CLExecute(cl_krn,2,offset,work);
      //--- Prise en compte des données du cadre
      CLBufferRead(cl_mem,buf);
      //--- sortie du temps de rendu
      Comment(IntegerToString(GetTickCount()-x)+" msec per frame");
      //--- enregistrer le cadre en mémoire et le dessiner
      ResourceCreate(resname,buf,SIZE_X,SIZE_Y,0,0,SIZE_X,COLOR_FORMAT_XRGB_NOALPHA);
      ChartRedraw();
      //--- une petite pause et une mise à jour des paramètres pour la prochaine image
      Sleep(10);
      x0+=0.001 f;
      x1-=0.001 f;
      y0+=0.001 f;
      y1-=0.001 f;
     }
//--- suppression des objets OpenCL
   CLBufferFree(cl_mem);
   CLKernelFree(cl_krn);
   CLProgramFree(cl_prg);
   CLContextFree(cl_ctx);
//--- supprimer l'objet
   ObjectDelete(0,objname);
  }
//+------------------------------------------------------------------+


Vous pouvez ainsi créer des images dynamiques 32 bits avec des canaux alpha pour un rendu détaillé.

Les ressources créées dynamiquement sont placées dans le gestionnaire de ressources et sont disponibles pour tous les programmes MQL5 du terminal.


 
Renat de nouvelles possibilités de créer des ressources graphiques à la volée en utilisant les fonctions ResourceCreate() seront disponibles.
Est-ce que seule la fonction ResourceCreate() sera annoncée ou est-ce qu'une classe pour travailler avec des objets graphiques/primitifs sera préparée ?
 
IgorM:
Est-ce que seule la fonction ResourceCreate() sera annoncée ou est-ce qu'une classe pour travailler avec des objets graphiques/primitifs sera préparée ?

Cette fonction sera déjà disponible.

Avec son aide, vous pouvez déjà créer vos propres bibliothèques pour dessiner dans votre propre tampon et les lier ensuite à des objets. Vous pouvez ainsi vous débarrasser complètement des bibliothèques de dessin externes dans les fichiers BMP externes.

Voici un petit exemple : vous pouvez dessiner directement dans le tampon buf, puis créer une ressource basée sur ce tampon et l'affecter à un objet.

   uint buf[];

   ArrayResize(buf,SIZE_X*SIZE_Y);
   ResourceCreate(resname,buf,SIZE_X,SIZE_Y,0,0,SIZE_X,COLOR_FORMAT_XRGB_NOALPHA);
   ObjectSetString(0,objname,OBJPROP_BMPFILE,"::"+resname);


Un peu plus tard, nous créerons une bibliothèque de primitives pour dessiner dans les mêmes tampons en utilisant les fonctions d'accélération 2D natives. Cela permettra de dessiner beaucoup plus rapidement.

 
Renat:

Cette fonctionnalité sera déjà disponible.

Grâce à elle, vous pouvez déjà créer vos propres bibliothèques pour dessiner dans votre propre tampon et les lier ensuite à des objets. Vous pouvez ainsi vous débarrasser complètement des bibliothèques de dessin externes dans les fichiers BMP externes.


Cette fonction sera disponible pour tous les MQL, et pas seulement pour travailler avec OpenCL?

Et qu'en est-il du canal alpha dans les ressources BMP créées ?

 
Un peu plus tard, nous créerons une bibliothèque de primitives pour dessiner dans les mêmes tampons en utilisant les fonctions d'accélération 2D natives.

Je vois, mais je pense qu'il est préférable que les développeurs annoncent en même temps la nouvelle fonction et la classe de base pour travailler avec les graphiques, sinon on recommencera à "crier dans les couloirs" les difficultés de programmation sur mql5.

SZY : est-ce que je suis le seul à penser que le lien "répondre" ne fonctionne pas ? au lieu de citer un message, c'est la fenêtre "Nouveau commentaire" qui apparaît.

 

sergeev 2012.03.19 17:25 #

Et quelle est la situation avec le canal alpha dans les ressources BMP créées ?
Il semble que cela fonctionne
1234
Nouveau commentaire