常連

お世話になります。

pythonで、機械学習のために並列処理のことを調べていた時に、OpenCLを使ってcupyと同じように動作する、clpyというものがあることを知り、githubの説明通りにセットアップしていたのですが、
setup.pythonを実行したときにエラーになってしまいました。

記事が全くなく、どうすればよいのかわからなかったので質問させていただきました。よろしくお願いします。

エラーコード
```
gcc: fatal error: cannot execute ‘cc1plus’: execvp: No such file or directory
compilation terminated.
command 'gcc' failed with exit status 1
**************************************************
*** WARNING: Include files not found: ['CL/cl.h', 'clblast_c.h']
*** WARNING: Skip installing opencl support
*** WARNING: Check your CFLAGS environment variable
**************************************************
Traceback (most recent call last):
  File "clpy/setup.py", line 32, in <module>
    ext_modules = clpy_setup_build.get_ext_modules()
  File "/home/vagrant/clpy/clpy_setup_build.py", line 321, in get_ext_modules
    extensions = make_extensions(arg_options, compiler, use_cython)
  File "/home/vagrant/clpy/clpy_setup_build.py", line 239, in make_extensions
    raise Exception('Your OpenCL environment is invalid. '
Exception: Your OpenCL environment is invalid. Please check above error log.
```

実行環境
VirtualBox Ubuntu(64bit) version:20.04

GPU:intel graphic 4300 

インストールしたopenCL --> Intel® SDK for OpenCL Applications for Ubuntu

環境変数↓
```
INTELOCLSDKROOT=/home/vagrant/intel/system_studio_2020/opencl/SDK

export PATH=/usr/lib/llvm-10/bin:${PATH}

export C_INCLUDE_PATH=${C_INCLUDE_PATH}:${INTELOCLSDKROOT}/include
export LIBRARY_PATH=${LIBRARY_PATH}:${INTELOCLSDKROOT}/lib/x86_64
export CPLUS_INCLUDE_PATH=${CPLUS_INCLUDE_PATH}:${INTELOCLSDKROOT}/include
```
これを~/.bashrcに追加しました。

(OpenCLを入れると自動でINTELOCLSDKROOTが追加されるらしいのですが、追加されなったので、手動で追加しました。)


気になる点
> In addition, add the needed ldconfig files to /etc/ldconf.so.d/, then execute $ sudo ldconfig.


この部分なのですが、自分の環境でldconf.so.dを探したのですが無かったので、ld.so.conf.dに、cl.h,ldconf.so.dを追加しました。もしかしたらこれが原因かもしれないです。

pythonで並列処理するための環境を作りたい

### 実現したいこと
OpenCLで並列処理のカーネルをプログラムしています。
コンピューターに見つかった並列処理デバイスはIntel HD Graphics 4000　と、 Core(TM) i7-3540M CPU　の２種類です。
グラボは使用していません。
プログラムのコンパイルは、動作ターゲットがi7CPUの場合は問題無く成功しますが、同じプログラムコードなのにターゲットをIntel HD Graphicsにするとエラーが出ます。
↓コンパイルエラーのメッセージ
fcl build 1 succeeded.
fcl build 2 succeeded.
Error: internal error.

これでは、どの行にエラーの原因があるか分かりません。
カーネルのソースコードは１３５行、文字数で約4,000文字あります。
ソースコードを半分に減らしてテストするとコンパイルが通ることから、ソースコードの容量がエラーに関係していると思われます。
但し、この程度の容量では、現在設計しているプロジェクトが実現できません。（ソースコードに盛り込みたいことは、この８倍は必要です。）

OpenCL バージョンは1.2です。
教えていただきたいことは、
（１）このエラーの原因
（２）動作ターゲットがIntel HD Graphicsの場合の、ソースコードの限界容量や、処理の複雑さの限界はどのように定められているのか知りたいです。

よろしく御回答をお願いします。

なお、解決に向けてネットで検索しましたが、有用な情報は見つかりませんでした。

### 発生している問題・分からないこと
記載済みです。
ーーーーーーーーーーーーーーーーー

### エラーメッセージ
```error
記載済みです。
ーーーーーーーーーーーーーーーーー
```

### 該当のソースコード

```
特になし
```

### 試したこと・調べたこと
- [x] teratailやGoogle等で検索した
- [x] ソースコードを自分なりに変更した
- [ ] 知人に聞いた
- [ ] その他

##### 上記の詳細・結果
記載済みです。
ーーーーーーーーーーーーーーーーー

### 補足
特になし

OpenCL Intel CPU内蔵グラフィックスでコンパイルが失敗する

### 前提・実現したいこと

カットシステム様の[**C#によるOpenCL並列プログラミング**](https://www.cutt.co.jp/book/978-4-87783-297-1.html)という参考書で現在勉強をしています.

実行環境は**Visual Studio 2019**です.
本書はDLL呼び出しによりOpenCLを扱えるようにするものです.

「3-4 カーネルの引数にコンスタント」 という節でカーネルの引数でスカラ変数を扱えるようにします.

そこで, 本書では`clSetKernelArg(4)`に`スカラ変数B`を用いる場面があります.

`clSetKernelArg`のC#側での実装は以下のようになっています.

```C#
//----------------------------------------------------------------------
//cl_int clSetKernelArg(cl_kernel kernel,
//                      cl_uint arg_index,
//                      size_t arg_size,
//                      const void *arg_value )
[DllImport(clPath)]
public static extern int clSetKernelArg(
    IntPtr kernel,
    uint arg_index,
    IntPtr arg_size,
    ref IntPtr arg_value
  　);
```

### 発生している問題・エラーメッセージ
参考書に書いてある通りに実装すると以下のようなエラーメッセージを吐かれます.

```
CS1620: 引数4はキーワード'ref'と共に渡す必要があります。
```


### 該当のソースコード

```C#
using System;
using System.Runtime.InteropServices;

#if true
partial class Program
{
    private static string clProc = "clProc";


    //----------------------------------------------------------------------
    // clMain

    static void clMain(string[] src)
    {
        int status;

        // initialize array
        float B =2.2f;
        float[] A = new float[100], C = new float[100];
        for (int i = 0; i < 100; i++)
            A[i] = (float)(i + 100);

        // get platform id
        IntPtr[] platformId = new IntPtr[1];
        uint platformCount;
        status = clGetPlatformIDs(1, platformId, out platformCount);
        if (status != CL_SUCCESS)
            throw new Exception("clGetPlatformIDs failed.");

        // get device id
        IntPtr[] deviceID = new IntPtr[1];
        uint deviceCount;
        status = clGetDeviceIDs(platformId[0],
            CL_DEVICE_TYPE_DEFAULT, 1, deviceID, out deviceCount);
        if (status != CL_SUCCESS)
            throw new Exception("clGetDeviceIDs failed.");

        // create Context
        int errcode_ret;
        IntPtr context = clCreateContext(null, 1, deviceID,
            null, IntPtr.Zero, out errcode_ret);
        if (errcode_ret != CL_SUCCESS)
            throw new Exception("clCreateContext failed.");

        // create Command Queue
        IntPtr queue = clCreateCommandQueue(context,
            deviceID[0], 0, out errcode_ret);
        if (errcode_ret != CL_SUCCESS)
            throw new Exception("clCreateCommandQueue failed.");

        // create program object
        IntPtr prog = clCreateProgramWithSource(context,
            (uint)(src.Length), src, null, out errcode_ret);
        if (errcode_ret != CL_SUCCESS)
            throw new Exception("clCreateProgramWithSource failed.");

        // build program
        status = clBuildProgram(prog, 1, deviceID, null, null, IntPtr.Zero);
        if (status != CL_SUCCESS)
            throw new Exception("clBuildProgram failed.");

        //create kernel
        IntPtr kernel = clCreateKernel(prog, clProc, out errcode_ret);
        if (errcode_ret != CL_SUCCESS)
            throw new Exception("clCreateKernel failed.");

        // create memory object
        GCHandle handle;
        handle = GCHandle.Alloc(A, GCHandleType.Pinned);
        IntPtr memA = clCreateBuffer(context, CL_MEM_READ_ONRY | CL_MEM_COPY_HOST_PTR,
            (IntPtr)(Marshal.SizeOf(A[0]) * A.Length), handle.AddrOfPinnedObject(),
            out errcode_ret);
        handle.Free();
        if (errcode_ret != CL_SUCCESS)
            throw new Exception("clCreateBuffer A failed.");

        IntPtr memC = clCreateBuffer(context, CL_MEM_WRITE_ONRY,
            (IntPtr)(Marshal.SizeOf(C[0]) * C.Length), IntPtr.Zero, out errcode_ret);
        if (errcode_ret != CL_SUCCESS)
            throw new Exception("clCreateBuffer C failed.");



        // set kernel parameter
        status = clSetKernelArg(kernel, 0, (IntPtr)(Marshal.SizeOf(typeof(IntPtr))), ref memA);
        if (status != CL_SUCCESS)
            throw new Exception("clSetKernelArg A failed.");

/*********************************************************************************/
/**該当箇所************************************************************************/
/*********************************************************************************/

        handle = GCHandle.Alloc(B, GCHandleType.Pinned);
        status = clSetKernelArg(kernel, 1, (IntPtr)(Marshal.SizeOf(B)), handle.AddrOfPinnedObject());
        handle.Free();
        if (status != CL_SUCCESS)
            throw new Exception("clSetKernelArg B failed.");

/*********************************************************************************/
/**ここまで************************************************************************/
/*********************************************************************************/
        status = clSetKernelArg(kernel, 2, (IntPtr)(Marshal.SizeOf(typeof(IntPtr))),  ref memC);
        if (status != CL_SUCCESS)
            throw new Exception("clSetKernelArg C failed.");


        // request execute kernel
        IntPtr[] globalSize = { (IntPtr)C.Length };
        status = clEnqueueNDRangeKernel(queue, kernel, 1, null,
            globalSize, null, 0, null, IntPtr.Zero);
        if (status != CL_SUCCESS)
            throw new Exception("clEnqueueTask failed.");


        // obtain results
        handle = GCHandle.Alloc(C, GCHandleType.Pinned);
        status = clEnqueueReadBuffer(queue, memC, CL_TURE, (IntPtr)0,
            (IntPtr)(Marshal.SizeOf(typeof(float)) * C.Length), handle.AddrOfPinnedObject(),
            0, null, IntPtr.Zero);

        handle.Free();
        if (status != CL_SUCCESS)
            throw new Exception("clEnqueueReadBuffer failed.");

        // list results
        Console.WriteLine("(A <?> B = C)\n");
        for (int i = 0; i < 10; i++)
            Console.WriteLine("{0:F4} <?> {1:F2} = {2:F2}", A[i], B, C[i]);


        //release resources
        clReleaseMemObject(memC);
        clReleaseMemObject(memA);
        clReleaseKernel(kernel);
        clReleaseProgram(prog);
        clReleaseCommandQueue(queue);
        clReleaseContext(context);

    }

    //----------------------------------------------------------------------
    // Main
    static void Main(string[] args)
    {
        try
        {
            // 引数チェック
            if (args.Length != 1)
                throw new Exception("引数に *.clを指定してください.");
            string[] src = { System.IO.File.ReadAllText(args[0].ToString()) };

            clMain(src);
        }
        catch(Exception ex)
        {
            Console.WriteLine("{0}{1}", ex.ToString(), ex.StackTrace.ToString());
        }
    }
}

#endif
```

カーネルのコードは以下の通りです.

```add.cl
__kernel void
clProc( __global const float A[],
        __const float B,
        __global float C[])
{
    int i=get_global_id(0);

    C[i]=A[i]+B;
}
```

### 試したこと

試しにrefキーワードを渡してみると

```
CS1510: refまたはout値は、割り当て可能な変数でなければなりません。
```

という風になり, 正しい解釈なのかわかりませんが, 第4引数をいったん`IntPtr`型変数の中に入れてみました.
該当箇所のコードは以下の通りです.

```C#
        handle = GCHandle.Alloc(B, GCHandleType.Pinned);
        IntPtr b = handle.AddrOfPinnedObject();
        status = clSetKernelArg(kernel, 1, (IntPtr)(Marshal.SizeOf(B)), ref b);
        handle.Free();
```

これにより, 前述のようなエラーは消えましたが, 計算結果が正しく表示されませんでした.

```
>sample add.cl
(A <?> B = C)

100.0000 <?> 2.20 = 100.00
101.0000 <?> 2.20 = 101.00
102.0000 <?> 2.20 = 102.00
103.0000 <?> 2.20 = 103.00
104.0000 <?> 2.20 = 104.00
105.0000 <?> 2.20 = 105.00
106.0000 <?> 2.20 = 106.00
107.0000 <?> 2.20 = 107.00
108.0000 <?> 2.20 = 108.00
109.0000 <?> 2.20 = 109.00
```
このように2.20を足し合わせていない結果が返っています.
このため, Bの値が0とされているような印象を受けます.

### 補足情報

もしかしたら私のタイプミスでたまたまうまく動いたとかだと困るので, 該当箇所のみ写真を添付させていただきます.
![該当箇所写真](9ab44512acda181f754eeea357e5fec0.jpeg)

文章や説明が分かりにくいかと思いますがよろしくお願いします.

C#にてOpenCLのclSetKernelArg()の引数がうまく指定できない

インターネット上で画像を高解像度化することができるか調べていたら"ESRGAN"というものを見つけ、環境構築を行い、実際に実行してみたのですが、エラーがでます。

```error
C:\ESRGAN>python test.py
Traceback (most recent call last):
  File "C:\ESRGAN\test.py", line 17, in <module>
    model = model.to(device)
  File "C:\Users\USERNAME\AppData\Local\Programs\Python\Python39\lib\site-packages\torch\nn\modules\module.py", line 673, in to
    return self._apply(convert)
  File "C:\Users\USERNAME\AppData\Local\Programs\Python\Python39\lib\site-packages\torch\nn\modules\module.py", line 387, in _apply
    module._apply(fn)
  File "C:\Users\USERNAME\AppData\Local\Programs\Python\Python39\lib\site-packages\torch\nn\modules\module.py", line 409, in _apply
    param_applied = fn(param)
  File "C:\Users\USERNAME\AppData\Local\Programs\Python\Python39\lib\site-packages\torch\nn\modules\module.py", line 671, in convert
    return t.to(device, dtype if t.is_floating_point() or t.is_complex() else None, non_blocking)
  File "C:\Users\USERNAME\AppData\Local\Programs\Python\Python39\lib\site-packages\torch\cuda\__init__.py", line 170, in _lazy_init
    torch._C._cuda_init()
RuntimeError: Found no NVIDIA driver on your system. Please check that you have an NVIDIA GPU and installed a driver from http://www.nvidia.com/Download/index.aspx
```
実行したファイルはそのリポジトリ(https://github.com/xinntao/ESRGAN)についてあるサンプルプログラムです。
```Python
import os.path as osp
import glob
import cv2
import numpy as np
import torch
import RRDBNet_arch as arch

model_path = 'models/RRDB_ESRGAN_x4.pth'  # models/RRDB_ESRGAN_x4.pth OR models/RRDB_PSNR_x4.pth
device = torch.device('cuda')  # if you want to run on CPU, change 'cuda' -> cpu
# device = torch.device('cpu')

test_img_folder = 'LR/*'

model = arch.RRDBNet(3, 3, 64, 23, gc=32)
model.load_state_dict(torch.load(model_path), strict=True)
model.eval()
model = model.to(device)

print('Model path {:s}. \nTesting...'.format(model_path))

idx = 0
for path in glob.glob(test_img_folder):
    idx += 1
    base = osp.splitext(osp.basename(path))[0]
    print(idx, base)
    # read images
    img = cv2.imread(path, cv2.IMREAD_COLOR)
    img = img * 1.0 / 255
    img = torch.from_numpy(np.transpose(img[:, :, [2, 1, 0]], (2, 0, 1))).float()
    img_LR = img.unsqueeze(0)
    img_LR = img_LR.to(device)

    with torch.no_grad():
        output = model(img_LR).data.squeeze().float().cpu().clamp_(0, 1).numpy()
    output = np.transpose(output[[2, 1, 0], :, :], (1, 2, 0))
    output = (output * 255.0).round()
    cv2.imwrite('results/{:s}_rlt.png'.format(base), output)

```
エラーを見た感じ、これはGPUかNvidiaのGPUでしか動かないのでしょうか？
それかなにかプログラムの一部を変更したら動かせますか？
初心者ですがご教授いただけると幸いです。


利用環境
Windows 10 pro 20H2
CPU:AMD Ryzen5 2500U
Memoly:16GB
GPU:Radeon Vega 8

Python 3.9.4
opencv-python     4.5.1.48
torch             1.8.1+cu102
torchaudio        0.8.1
torchvision       0.9.1+cu102

ESRGANの実行について

### 前提
OS：Ubuntu20.04

### 実現したいこと

デプスカメラのフィルタリング処理をC++で実装しています。
100msecぐらいの間隔で点群データを処理すると処理に時間がかかってしまい、処理が追いつきません
そこでIntelCPU内蔵のオンボードGPUを使って並列処理を実装したいのですが、どのライブラリを使うのがいいでしょうか。
当初、OpenMPが実装簡単そうかなと思ったんですが、OpenMPは内蔵GPU使えないんでしょうか？調べてもCPUでマルチスレッドで並列処理するやり方しか出てこなかったので…
OpenCLなら内蔵GPU使えそうかなと思っていますが、コード量が多いみたいで悩んでいます。

他に内蔵GPUを使って並列処理が実現できるものがあれば紹介していただけると助かります。

C/C++上でIntel内蔵GPUを使って並列処理を実現したい場合、どのライブラリを使うべきか

OpenGLの描画時に、CPUからVBOにバッファー転送を行いますが、次の様なことを行いたいです。
（１）　OpenCLを使い、CPUからGPUのメモリーにまとまったデーターを転送する。
（２）　OpenCLを使い、（１）のデーターに対して並列スレッドで高速演算した結果を別のメモリーに格納する。
（３）　（２）の結果を、OpenGLでVBOに転送する（または、転送無しで（２）のアドレスをVBOの先頭とする）
（４）　この後は、OpenGLでVBOに対する描画命令を発行する。
ーーーー
通常、CPUからOpenGLでVBOに転送するデーターは、事前にCPUで何らかの処理を加えられたものだと思いますが、この事前処理は、CPUによる処理を行うよりもGPUで並列演算した方が高速化できる余地があると考えました。

ーーーー
質問したいこと
上記のようなことは可能ですか。



OpenGLとOpenCLのバッファーの共有を行う方法

### 前提・実現したいこと

Pythonで３種類の異なる正方形のパッケージを
画像認識しながら、どの程度傾いているかを検知したいです。
パッケージ・傾きはそれぞれ
パッケージ・・・箱に絵が書いてあるもの
傾き・・・平面に「あ」という文字の書かれた箱を、真上から見てどの程度傾いているか
を指しています。
将来的にその検知を元に、ロボットアームで
商品の向きを揃えて並べられるようになりたいです。

### 試したこと
YOLOv5をインストールし、
python detect.py --source data/images/ファイル名.jpg --conf 0.5 --weights yolov5s.pt
で画像を認識している初期の段階です。それにより、画像認識まではできるようになりましたが、
傾きの出し方が調べても分からず、お力を貸して頂きたいです。