OpenCL not found - страница 4

Новый комментарий
 
короче у них увсех инклюдники от хронос ....ставьте от амд СДК 3,0 )))))
 
Aleksey Vyazmikin #:

Думаю, может попробовать поставить более старые драйверы, теоретически может быть дело в них.

Ставил самый старый (самый первый для 3080), второй, средний, предпоследний и последний. Удалял через  программу DDU, в безопасном режиме, а устанавливал с галочкой "Чистая установка".  Безрезультатно. 


 
Ivan Butko #:

Сделано!

Журнал:

2022.10.24 12:50:16.596 Scripts script opencltest (EURUSD,H1) loaded successfully

2022.10.24 12:50:16.609 OpenCL opencl.dll successfully loaded

2022.10.24 12:50:16.687 OpenCL device #0: GPU 'NVIDIA GeForce RTX 3080' with OpenCL 3.0 (68 units, 1770 MHz, 10239 Mb, version 522.30)

2022.10.24 12:50:16.687 Scripts script opencltest (EURUSD,H1) removed


И вкладка "Эксперты"

2022.10.24 12:50:16.687 opencltest (EURUSD,H1) OpenCL not found

Билд терминала какой ?

Попробуйте удалить файл '%appdata%\MetaQuotes\Terminal\Community\mql5.opencl' и перезапустить терминал

В журнале должны появиться записи

2022.10.26 21:01:16.079    OpenCL    device performance test started
2022.10.26 21:01:17.236    OpenCL    device performance test successfully finished
2022.10.26 21:01:17.236    OpenCL    device #0: GPU 'NVIDIA GeForce GTX 1060 6GB' with OpenCL 3.0 (10 units, 1809 MHz, 6143 Mb, version 512.15, rating 4000)


 
Ilyas #:

Билд терминала какой ?

Попробуйте удалить файл '%appdata%\MetaQuotes\Terminal\Community\mql5.opencl' и перезапустить терминал

В журнале должны появиться записи

2022.10.26 21:01:16.079    OpenCL    device performance test started
2022.10.26 21:01:17.236    OpenCL    device performance test successfully finished
2022.10.26 21:01:17.236    OpenCL    device #0: GPU 'NVIDIA GeForce GTX 1060 6GB' with OpenCL 3.0 (10 units, 1809 MHz, 6143 Mb, version 512.15, rating 4000)


Помогло, спасибо!

 
ruslan #:
короче у них увсех инклюдники от хронос ....ставьте от амд СДК 3,0 )))))

Интересная версия. В этот раз не добрался до неё :)

 
Ivan Butko #:
Ставил самый старый (самый первый для 3080), второй, средний, предпоследний и последний. Удалял через  программу DDU, в безопасном режиме, а устанавливал с галочкой "Чистая установка".  Безрезультатно. 


Вы молодец, сделали очень многое для поиска причины проблемы!

 
Код примера FFT будем править, при его запуске, драйверу от NVidia (моему по крайней мере) становится плохо, помогает только перезапуск терминала
 
Ilyas #:


Скрипт FFT не работает, так же как и мой скрит - почему? На HD7950 работает.

2022.10.26 23:13:44.119 Terminal        MetaTrader 5 x64 build 3476 started for MetaQuotes Software Corp.
2022.10.26 23:13:44.119 Terminal        Windows 7 Service Pack 1 build 7601, 8 x AMD FX-8350 Eight-Core, AVX, 28 / 31 Gb memory, 39 / 476 Gb disk, admin, GMT+3
2022.10.26 23:13:56.868 OpenCL  device #0: GPU 'NVIDIA GeForce GTX 1660 SUPER' with OpenCL 3.0 (22 units, 1785 MHz, 6144 Mb, version 473.81, rating 5714)


Мой скрипт

//+------------------------------------------------------------------+
//|                                                       Primer.mq5 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "-Aleks-"
#property link      "https://www.mql5.com/ru/users/-aleks-"
#property version   "1.00"
#property script_show_inputs
#property strict
//--- COpenCL class
#include <OpenCL/OpenCL.mqh>
COpenCL           m_OpenCL;
//--- исходные коды кернелов
#resource "tester.cl" as string cl_tester


sinput bool Random_Data=false;//Генерировать таблицу с данными?
input group "Параметры генерируемой таблицы"
sinput      int Strok_Total_Data_Random=1000;//Всего строк
sinput      int Stolb_Total_Data_Random=1000;//Всего столбцов
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
float arr_Data[];//Массив для первичных данных - выборка
float arr_Quant[];//Массив с таблицами неравенств (сплитов)
char arr_Target[];//Массив с целевыми
float arr_MiniData[]=//Массив для проверки логики с малым числом примеров - первичные данные
{
   7,0,1,
   8,1,2,
   9,0,3,
   10,1,1,
   11,0,2,
   12,1,3,
   13,0,1,
   14,1,2,
   15,0,3,
   16,1,1
};
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
float arr_MiniQuant[]=//Массив для проверки логики с малым числом примеров - таблицы неравенств (сплитов)
{
   0,10.5,
   0,14.5,
   0,15.5,
   1,0.5,
   2,0.5,
   2,1.5
};
char arr_MiniTarget[]=//Массив с целевыми
{
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1
};

int Strok_Total_Data=10;//Количество строк в таблице Data
int Stolb_Total_Data=3;//Количество столбцов в таблице Data

int Strok_Total_Quant=6;//Количество строк в таблице Quant
int Stolb_Total_Quant=2;//Количество столбцов в таблице Quant


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
{
   if(Random_Data==true)//Сгенерируем данные для оценки времени работы алгоритма
   {
      MathSrand(GetTickCount());
      float N_Random=0.0;//Переменная для сохранения случайного числа
      int Strok_Total_Quant_Random=0;

      int Size_Arr_RandomData=Strok_Total_Data_Random*Stolb_Total_Data_Random;
      float arr_RandomData[];
      float arr_RandomQuant[];
      int arr_RandomTarget[];

      ArrayResize(arr_RandomData,Size_Arr_RandomData);
      ArrayResize(arr_RandomTarget,Strok_Total_Data_Random);


      for(int i=0; i<Size_Arr_RandomData; i++) //Выберем комбинации
      {
         N_Random=RandomFloat(20);//Определяем число случайным образом
         arr_RandomData[i]=N_Random;
      }

      for(int i=0; i<Strok_Total_Data_Random; i++) //Выберем комбинации
      {
         N_Random=RandomFloat(2);//Определяем число случайным образом
         arr_RandomTarget[i]=(int)N_Random;
      }

      for(int i=0; i<Stolb_Total_Data_Random; i++) //Выберем комбинации для квантовой таблицы
      {
         N_Random=RandomFloat(20);//Определяем число сплитов
         if(N_Random<1)
            N_Random=1;
         int Size_arr_RandomQuant=ArraySize(arr_RandomQuant);
         ArrayResize(arr_RandomQuant,Size_arr_RandomQuant+(int)N_Random*2);
         Size_arr_RandomQuant=ArraySize(arr_RandomQuant);
         float arr_N_Random[];
         ArrayResize(arr_N_Random,(int)N_Random);
         for(int n=0; n<(int)N_Random; n++) //Выберем комбинации
         {
            arr_N_Random[n]=RandomFloat(20);//Определяем значение сплитов
         }
         ArraySort(arr_N_Random);
         for(int n=0; n<(int)N_Random; n++) //Выберем комбинации
         {
            arr_RandomQuant[Size_arr_RandomQuant-(int)N_Random*2+2*n]=(float)i;//Номер столбца
            arr_RandomQuant[Size_arr_RandomQuant-(int)N_Random*2+2*n+1]=arr_N_Random[n];//Значение сплита
         }
      }

      ArrayCopy(arr_Data,arr_RandomData,0,0,WHOLE_ARRAY);
      ArrayCopy(arr_Quant,arr_RandomQuant,0,0,WHOLE_ARRAY);
      ArrayCopy(arr_Target,arr_RandomTarget,0,0,WHOLE_ARRAY);

      Strok_Total_Data=Strok_Total_Data_Random;
      Stolb_Total_Data=Stolb_Total_Data_Random;
      Strok_Total_Quant_Random=ArraySize(arr_RandomQuant)/2;
      Strok_Total_Quant=Strok_Total_Quant_Random;
   }
   else
   {
      ArrayCopy(arr_Data,arr_MiniData,0,0,WHOLE_ARRAY);
      ArrayCopy(arr_Quant,arr_MiniQuant,0,0,WHOLE_ARRAY);
      ArrayCopy(arr_Target,arr_MiniTarget,0,0,WHOLE_ARRAY);
   }

   int arr_N_Quant[];//Массив в котором будем хранить число сплитов квантовой таблицы для каждого предиктора
   ArrayResize(arr_N_Quant,Stolb_Total_Data);
   ArrayInitialize(arr_N_Quant,-1);

   int New_Size=0;//Для установки размера массива
   int N_Calc=1;//Счетчик
   int N_Pred=0;//Счетчик столбцов (//Номер предиктора)

   for(int i=1; i<Strok_Total_Quant; i++)//Найдем число сплитов для каждого предиктора
   {
      //Print("2*i=",2*i," 2*(i-1)=",2*(i-1));
      if(arr_Quant[2*i]>arr_Quant[2*(i-1)])
      {
         arr_N_Quant[N_Pred++]=N_Calc;
         if(New_Size<N_Calc)
         {
            New_Size=N_Calc;
         }
         N_Calc=1;
      }
      else
         N_Calc++;
      if(i+1==Strok_Total_Quant)
         arr_N_Quant[N_Pred++]=N_Calc;//Если последний индекс столбца, то сохраним его
   }

   int arr_Max_Calc[];//Массив в котором будем искать максимум после сортировки
   ArrayCopy(arr_Max_Calc,arr_N_Quant);//Скопируем массив
   ArraySort(arr_Max_Calc);//Отсортируем массив
   int Max_Ind=ArrayMaximum(arr_Max_Calc,0,WHOLE_ARRAY);//Присвоем индекс максимального значения массива
   int Max_N=arr_Max_Calc[Max_Ind];//Присвоем максимальное значение массива
   int Size_arr_Quant_Trans=(Max_N+1)*Stolb_Total_Data;//Размер массива транспонированной квантовой таблицы

   float arr_Quant_Trans[];//Массив, куда запишем преобразованную таблицу с неравенствами
   ArrayResize(arr_Quant_Trans,Size_arr_Quant_Trans);
   ArrayInitialize(arr_Quant_Trans,0);
   Print("New_Size=",New_Size," Max_N=",Max_N);
   int Index=0;
   New_Size=0;
   N_Calc=1;//Счетчик числа сплитов предиктора
   N_Pred=0;
   double Split=0.0;//Значение сплита
   for(int i=1; i<Strok_Total_Quant; i++)//Транспонируем квантовую таблицу и записывем число сплитов
   {
      Index=(int)arr_Quant[2*(i-1)];
      arr_Quant_Trans[Stolb_Total_Data*(N_Calc)+Index]=arr_Quant[2*i-1];//Значение сплита

      if(arr_Quant[2*i]>arr_Quant[2*(i-1)])//Новый сплит
      {
         arr_Quant_Trans[Index]=(float)N_Calc;//Число сплитов в предикторе / столбца
         if(New_Size<N_Calc)
         {
            New_Size=N_Calc;
         }
         N_Calc=1;
      }
      else
         N_Calc++;
      if(i+1==Strok_Total_Quant)//Если последний индекс столбца, то сохраним число сплитов в предикторе / столбца
      {
         Index=(int)arr_Quant[2*i];
         arr_Quant_Trans[Index]=(float)N_Calc;//Число сплитов в предикторе / столбце
         arr_Quant_Trans[Stolb_Total_Data*(N_Calc)+Index]=arr_Quant[2*i+1];//Значение сплита -1 так как это последнее значение, а счетчик N_Calc ранее по коду учел новое
      }
   }


   ushort arr_Data_Q[];//Таблица №3 с результатами классификации(квантования) выборки.
   ArrayResize(arr_Data_Q,Strok_Total_Data*Stolb_Total_Data);
   ArrayInitialize(arr_Data_Q,0);

   float arr_Proc_Target[];//Процент принадлежности классов к целевой
   float arr_Proc_Otklik[];//Процент откликов классов ко всей таблице (выборке).
   ArrayResize(arr_Proc_Target,((Max_N+1)*Stolb_Total_Data)*2);//Делаем по размеру квантовой таблицы, умноженной на число разных значений (типов) целевых
   ArrayResize(arr_Proc_Otklik,((Max_N+1)*Stolb_Total_Data));//Делаем по размеру квантовой таблицы
   ArrayInitialize(arr_Proc_Target,0);
   ArrayInitialize(arr_Proc_Otklik,0);

   ushort arr_N_Class_Target[];//Считаем число целевых по их типам для каждого условного класса после квантования
   ushort arr_N_Class_Otklik[];//Считаем число откликов для каждого условного класса после квантования в выборке
   //ArrayResize(arr_N_Class_Target,((int)arr_Quant_Trans[p]+1)*2);//Умножаем на количество разных целевых ("0" и "1")
   //ArrayResize(arr_N_Class_Otklik,((int)arr_Quant_Trans[p]+1));//
   ArrayResize(arr_N_Class_Target,(Max_N+1)*2);//Умножаем на количество разных целевых ("0" и "1")
   ArrayResize(arr_N_Class_Otklik,Max_N+1);//

   ArrayInitialize(arr_N_Class_Target,0);
   ArrayInitialize(arr_N_Class_Otklik,0);

   /*
   __kernel void CalcPred(
   __global int *arr_Data,
   __global int *arr_Quant_Trans,
   __global int *arr_Target,
   __global int *arr_Data_Q,
   __global int *arr_N_Class_Target,
   __global int *arr_N_Class_Otklik,
     int p,
     int Stolb_Total_Data
    )
   */

   int index_kernel=0;
   int index_kernel_array_fill=1;
   int Handle_Context=0;
//---Инициализация файла с кернелами
   Print("Initialize=",m_OpenCL.Initialize(cl_tester,true));
   //CLProgramCreate(Handle_Context,cl_tester);
//--- установка количества кернелов
   Print("SetKernelsCount=",m_OpenCL.SetKernelsCount(2));
//--- создание кернелов
   Print("KernelCreate=",m_OpenCL.KernelCreate(index_kernel,"CalcPred"));
   Print("KernelCreate=",m_OpenCL.KernelCreate(index_kernel_array_fill,"array_fill"));
//--- создание буферов - указать количество буферов
   Print("SetBuffersCount=",m_OpenCL.SetBuffersCount(6));
//--- копирование буфера на видеокарту
   Print("BufferFromArray=",m_OpenCL.BufferFromArray(0,arr_Data,0,Stolb_Total_Data*Strok_Total_Data,CL_MEM_READ_ONLY));
   Print("BufferFromArray=",m_OpenCL.BufferFromArray(1,arr_Quant_Trans,0,Size_arr_Quant_Trans,CL_MEM_READ_ONLY));
   Print("BufferFromArray=",m_OpenCL.BufferFromArray(2,arr_Target,0,Strok_Total_Data,CL_MEM_READ_ONLY));
   Print("BufferFromArray=",m_OpenCL.BufferFromArray(3,arr_Data_Q,0,Stolb_Total_Data*Strok_Total_Data,CL_MEM_READ_WRITE));
   Print("BufferFromArray=",m_OpenCL.BufferFromArray(4,arr_N_Class_Target,0,(Max_N+1)*2,CL_MEM_READ_WRITE));
   Print("BufferFromArray=",m_OpenCL.BufferFromArray(5,arr_N_Class_Otklik,0,Max_N+1,CL_MEM_READ_WRITE));
//---привязка буфера к аргументу кернела
   Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,0,0));
   Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,1,1));
   Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,2,2));
   Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,3,3));
   Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,4,4));
   Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,5,5));
//---привязка параметра фукнкции к кернелу
   int p=0;
   Print("SetArgument=",m_OpenCL.SetArgument(index_kernel,6,p));
   Print("SetArgument=",m_OpenCL.SetArgument(index_kernel,7,Stolb_Total_Data));

//--- пространство задач для кернела - одномерное
   uint global_work_size[1];
//--- 1-е измерение
   global_work_size[0]=Strok_Total_Data;
//--- начальное смещение в пространстве задач для обоих измерений равно нулю
   uint global_work_offset[1]= {0};

   for(/*int*/ p=0; p<Stolb_Total_Data; p++)
   {
      /*
      //---привязка буфера к аргументу кернела
         Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel_array_fill,0,4));
         CLExecute(index_kernel_array_fill);
         Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,4,4));
         //Print("Execute=",m_OpenCL.Execute(index_kernel_array_fill,1,global_work_offset,global_work_size));

         Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel_array_fill,0,5));
         CLExecute(index_kernel_array_fill);
         Print("SetArgumentBuffer=",m_OpenCL.SetArgumentBuffer(index_kernel,5,5));
      */

      Print("Execute=",m_OpenCL.Execute(index_kernel,1,global_work_offset,global_work_size));

      Print("BufferRead=",m_OpenCL.BufferRead(4,arr_N_Class_Target,0,0,(Max_N+1)*2));
      Print("BufferRead=",m_OpenCL.BufferRead(5,arr_N_Class_Otklik,0,0,Max_N+1));

      for(ushort q=0; q<arr_Quant_Trans[p]+1; q++)//Посчитаем проценты
      {
         int Summ=arr_N_Class_Target[2*q]+arr_N_Class_Target[2*q+1];
         //Print("Summ=",Summ);
         if (Summ>0)
         {
            arr_Proc_Target[Stolb_Total_Data*2*q+p*2]=float((double)arr_N_Class_Target[2*q]/(double)Summ*100.0);//Целевая "0"
            arr_Proc_Target[Stolb_Total_Data*2*q+p*2+1]=float((double)arr_N_Class_Target[2*q+1]/(double)Summ*100.0);//Целевая "1"
         }
         arr_Proc_Otklik[Stolb_Total_Data*q+p]=float((double)arr_N_Class_Otklik[q]/(double)Strok_Total_Data*100.0);

      }
   }
   Print("BufferRead=",m_OpenCL.BufferRead(3,arr_Data_Q,0,0,Stolb_Total_Data*Strok_Total_Data));
   Print("Задача №1 Таблица №3 с результатами классификации выборки.");
   ArrayPrint(arr_Data_Q);
   Print("Таблица №5 с результатами вычислений процента принадлежности классов к целевой.");
   ArrayPrint(arr_Proc_Target);
   Print("Таблица №6 с  результатами вычислений процента откликов классов ко всей таблице (выборке).");
   ArrayPrint(arr_Proc_Otklik);

   Print(CLExecutionStatus(index_kernel));




   /*
   //--- удаляем в обратной последовательности все созданные OpenCL контексты
   int program=m_OpenCL.GetProgram();//Возвращает хендл программы OpenCL.
   int context=m_OpenCL.GetContext();//Возвращает хендл контекста OpenCL

      CLBufferFree(0);//Удаляет буфер OpenCL.
      CLBufferFree(1);//Удаляет буфер OpenCL.
      CLBufferFree(2);//Удаляет буфер OpenCL.
      CLBufferFree(3);//Удаляет буфер OpenCL.
      CLBufferFree(4);//Удаляет буфер OpenCL.
      CLBufferFree(5);//Удаляет буфер OpenCL.

      CLKernelFree(index_kernel);//Удаляет функцию запуска OpenCL.

      CLProgramFree(program);//Удаляет OpenCL программу.


      CLContextFree(context);//Удаляет контекст OpenCL.
   */
   //m_OpenCL.KernelFree(index_kernel);
   m_OpenCL.Shutdown();
   //delete m_OpenCL;
   //m_OpenCL=NULL;

   //delete m_OpenCL;
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|Определяем комбинацию случайным образом
//+------------------------------------------------------------------+
float RandomFloat(float max_vl)
{
   return (float)MathFloor((MathRand()+MathRand()*32767.0)/1073741824.0*max_vl);  //случайное Int от 0 до  1073741824
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+

кернелы

//+------------------------------------------------------------------+
//|                                                        tester.cl |
//|                                  Copyright 2018, Serhii Shevchuk |
//|                           https://www.mql5.com/ru/users/decanium |
//+------------------------------------------------------------------+
#pragma OPENCL EXTENSION cl_khr_fp64 : enable
#pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable
#pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable
#pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable
#pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable
#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable
#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable

//+------------------------------------------------------------------+
//| Расчет
//+------------------------------------------------------------------+

__kernel void CalcPred(
__global float *arr_Data,
__global float *arr_Quant_Trans,
__global char *arr_Target,
__global ushort *arr_Data_Q,
__global ushort *arr_N_Class_Target,
__global ushort *arr_N_Class_Otklik,
 int p,
 int Stolb_Total_Data
 )
  {
   int Index_Data=0;//Индекс массива arr_Data и arr_Data_Q
   int Index_Quant_A=0;//Индекс массива arr_Quant_Trans для границы А
   int Index_Quant_B=0;//Индекс массива arr_Quant_Trans для границы Б
   int Index=0;
   int Calc_Index=0;   
//--- работает в одном измерении    
   size_t i=get_global_id(0);

         Index_Data=Stolb_Total_Data*i+p;
         for(ushort q=0; q<arr_Quant_Trans[p]+1; q++)
         {
            Index=q;
            if(arr_Quant_Trans[p]<1)
            {
               arr_Data_Q[Index_Data]=0;//Обнуляем значение предиктора, так как нет информации о сплитах
               break;
            }
            else
            {
               if(q==0)//Первый сплит
               {
                  Index_Quant_A=Stolb_Total_Data*(q+1)+p;//Рассчитаем индекс первой границы
                  if(arr_Data[Index_Data]<=arr_Quant_Trans[Index_Quant_A])
                  {
                     arr_Data_Q[Index_Data]=q+1;
                     break;
                  }
               }
               else
               {
                  Index_Quant_A=Stolb_Total_Data*(q+1-1)+p;//Рассчитаем индекс первой границы
                  Index_Quant_B=Stolb_Total_Data*(q+1)+p;//Рассчитаем индекс последней границы
                  if(q==arr_Quant_Trans[p])//Последний сплит "q" будет равно arr_Quant_Trans[p] при выходе за пределы массива)
                  {
                     if(arr_Data[Index_Data]>arr_Quant_Trans[Index_Quant_A])
                     {
                        arr_Data_Q[Index_Data]=q+1;
                        break;

                     }
                  }
                  else//Средние сплиты
                  {
                     if(arr_Data[Index_Data]>arr_Quant_Trans[Index_Quant_A] && arr_Data[Index_Data]<=arr_Quant_Trans[Index_Quant_B])
                     {
                        arr_Data_Q[Index_Data]=q+1;
                        break;
                     }
                  }
               }
            }
         }            
         switch(arr_Target[i])
         {
         case 0:
            Calc_Index=Index*2;
            break;
         case 1:
            Calc_Index=Index*2+1;
            break;
         }
         arr_N_Class_Target[Calc_Index]++;//Прибавим 1 для подсчета целевой
         Calc_Index=Index;//Индекс для массива arr_N_Class_Otklik
         arr_N_Class_Otklik[Calc_Index]++;//Прибавим 1 для подсчета откликов
  }
//+------------------------------------------------------------------+
//| Заполнение буфера указанным значением                            |
//+------------------------------------------------------------------+
__kernel void array_fill(__global int *Buf,const int value)
  {
//--- работает в одном измерении    
   size_t x=get_global_id(0);
   Buf[x]=value;
  }
 
Ilyas #:
Код примера FFT будем править, при его запуске, драверу от NVidia (моему по крайней мере) становится плохо, помогает только перезапуск терминала

Может подскажите, что и мне править, что б была полная совместимость?

И ещё сравнил производительность двух карт, и получается что у HD7950 какая то слишком медленная глобальная память (скрипт MatrixMult первый режим "GPU global work groups"), что очень странно - DDR5 vs DDR6, но шина у AMD в 3(?) раза шире.

Ещё по сравнению с вчерашним днём в два раза медленней работает на CPU скрипт BitonicSort - нагрузки кроме терминала нет на процессор.

А так получается, что если не учитывать странные показатели по скорости внешней памяти (не буфер, как я понял), то HD7950 оказывается быстрей 1600s, чему удивлен.
 
Aleksey Vyazmikin #:

Скрипт FFT не работает, так же как и мой скрит - почему? На HD7950 работает.

Мой скрипт

кернелы

Проблем не обнаружил

New_Size=3 Max_N=3
OpenCL: GPU device 'NVIDIA GeForce GTX 1060 6GB' selected
Initialize=true
SetKernelsCount=true
KernelCreate=true
KernelCreate=true
SetBuffersCount=true
BufferFromArray=true
BufferFromArray=true
BufferFromArray=true
BufferFromArray=true
BufferFromArray=true
BufferFromArray=true
SetArgumentBuffer=true
SetArgumentBuffer=true
SetArgumentBuffer=true
SetArgumentBuffer=true
SetArgumentBuffer=true
SetArgumentBuffer=true
SetArgument=true
SetArgument=true
Execute=true
BufferRead=true
BufferRead=true
Execute=true
BufferRead=true
BufferRead=true
Execute=true
BufferRead=true
BufferRead=true
BufferRead=true
Задача №1 Таблица №3 с результатами классификации выборки.
1 0 0 1 0 0 1 0 0 1 0 0 2 0 0 2 0 0 2 0 0 2 0 0 3 0 0 4 0 0
Таблица №5 с результатами вычислений процента принадлежности классов к целевой.
[ 0]  50.00000  50.00000  50.00000  50.00000  50.00000  50.00000  50.00000  50.00000  50.00000  50.00000  50.00000  50.00000
[12] 100.00000   0.00000   0.00000   0.00000 100.00000   0.00000   0.00000 100.00000   0.00000   0.00000   0.00000   0.00000
Таблица №6 с  результатами вычислений процента откликов классов ко всей таблице (выборке).
10.00000 20.00000 30.00000 10.00000 20.00000 30.00000 10.00000  0.00000 30.00000 10.00000  0.00000  0.00000
-1
1234567891011
Новый комментарий