【C#】高速な画像処理を実現する方法 - unsafeと現代的アプローチの使い分け

## はじめに

C#の画像処理において、パフォーマンスを追求する際にunsafeコードを使用することは割と一般的ですよね。実際に使われているのをよく目撃します。

今回は、そんなunsafeコードの適切な使用場面と、より安全な代替手段について改めてまとめました。画像処理に限らず、大量のデータ処理や計算集中型の処理にも有用なのでぜひ参考にしてください。

## unsafeアプローチについて

まずは、unsafeコードについて軽くご紹介します。unsafe（アンセーフ）を日本語にすると「**危険**」「**安全ではない**」という意味です・・・ちょっと怖いですよね。

上級言語のC#が低級言語のような直接的なメモリ操作を行えるようになります。メモリを直接操作するため、メモリコピーやポインタ演算が可能となり、高速な処理が期待できるのです。

### unsafeコードの特徴

:::note info
**メリット**
- ポインタ操作による直接的なメモリアクセス
- Cライブラリとの相互運用性の向上
- 特定のシナリオでの最高レベルのパフォーマンス
:::

:::note warn
**デメリット**
- メモリ破壊のリスク
- デバッグの困難さ
- コンパイル時の特別な設定が必要
:::

### 従来のunsafeコード例

```csharp:C#
unsafe void ProcessImageUnsafe(byte[] imageData)
{
    fixed (byte* ptr = &imageData[0])
    {
        for (int i = 0; i < imageData.Length; i++)
        {
            *(ptr + i) = ProcessPixel(*(ptr + i));
        }
    }
}
```

unsafeコードは、以下のような場面で依然として有用です。
- ネイティブライブラリとの連携が必要な場合
- 極限のパフォーマンスが要求される特殊なケース
- 直接的なメモリ操作が避けられない処理

ただし、多くの場合は以下で紹介する安全な代替手段で十分なパフォーマンスが得られると思います。

## 現代的なアプローチ
次に、.NET の最新機能を活用した現代的なアプローチについてご紹介します。

最近のC#と.NETフレームワークは、安全性を保ちながら高いパフォーマンスを実現するための機能が充実しています。メモリの効率的な管理や並列処理、ベクトル化など、低レベルな最適化をより安全に行える仕組みが整っており、unsafeコードを使わずとも高速な処理が期待できます。

このアプローチは、項目で挙げているSpan、SIMD、並列処理、メモリプール等の**機能を組み合わせる**ことで、コードの保守性と実行速度の両立を目指します。

### 1. Span<T>の活用

現代のC#で最も注目すべき機能の一つがSpan<T>です。配列やメモリブロックへの参照を安全に扱えるため、画像処理のような大量のデータ操作でもパフォーマンスを損なうことなく、安全なコードが書けます。

```csharp:C#
void ProcessImageWithSpan(byte[] imageData)
{
    Span<byte> span = imageData.AsSpan();
    for (int i = 0; i < span.Length; i++)
    {
        span[i] = ProcessPixel(span[i]);
    }
}
```

:::note info
**特徴**
- unsafeと同等の高速性
- メモリ安全性の保証
- スタックアロケーションの削減
:::

https://qiita.com/Sakai_path/items/d1bfdee5bee33aea8fe8



### 2. SIMDによる並列処理
CPUのSIMD命令を利用することで、一度に複数のデータを処理できます。画像処理では同じ操作を大量のピクセルに対して行うことが多いため、SIMDによる最適化は非常に効果的です。

```csharp:C#
using System.Numerics;
using System.Runtime.InteropServices;

void ProcessImageDataSIMD(byte[] imageData)
{
    int vectorSize = Vector<byte>.Count;
    int vectorCount = imageData.Length / vectorSize;

    Span<byte> span = imageData.AsSpan();

    for (int i = 0; i < vectorCount; i++)
    {
        var vector = MemoryMarshal.Read<Vector<byte>>(span.Slice(i * vectorSize));
        // ベクトル演算でピクセル処理
        vector = Vector.Add(vector, new Vector<byte>(1)); // 例: 明度を上げる

        MemoryMarshal.Write(span.Slice(i * vectorSize), vector);
    }

    // 余りの要素を処理
    for (int i = vectorCount * vectorSize; i < imageData.Length; i++)
    {
        imageData[i] = ProcessPixel(imageData[i]);
    }
}
```

:::note info
**特徴**
- ハードウェアレベルの並列処理
- 大幅なパフォーマンス向上
- プラットフォーム依存の最適化
:::

### 3. 効率的な並列処理
マルチコアCPUの性能を最大限に活用するには、適切な並列処理が不可欠です。ただし、データサイズが小さい場合は逆効果になる可能性があるため、状況に応じた使い分けが重要です。

```csharp:C#
void ProcessImageDataParallel(byte[] imageData)
{
    const int PARALLEL_THRESHOLD = 100_000; // 並列化の閾値
    
    if (imageData.Length < PARALLEL_THRESHOLD)
    {
        // 小さなデータはシングルスレッドで処理
        for (int i = 0; i < imageData.Length; i++)
        {
            imageData[i] = ProcessPixel(imageData[i]);
        }
        return;
    }

    // データサイズが大きい場合は並列処理
    int chunkSize = 4096; // キャッシュラインを考慮したチャンクサイズ
    Parallel.For(0, (imageData.Length + chunkSize - 1) / chunkSize, chunkIndex =>
    {
        int start = chunkIndex * chunkSize;
        int end = Math.Min(start + chunkSize, imageData.Length);
        
        for (int i = start; i < end; i++)
        {
            imageData[i] = ProcessPixel(imageData[i]);
        }
    });
}
```

:::note info
**特徴**
- データサイズに応じた処理方法の選択
- キャッシュ効率を考慮したチャンク処理
- スレッドオーバーヘッドの最小化
:::

### 4. ArrayPoolによるメモリ管理
大きなサイズの画像を扱う際、メモリの確保と解放が頻繁に発生するとGCの負荷が高まります。ArrayPoolを使用することで、メモリを効率的に再利用し、アプリケーション全体のパフォーマンスを向上させることができます。

```csharp:C#
using System.Buffers;

void ProcessLargeImage(int size)
{
    byte[] buffer = ArrayPool<byte>.Shared.Rent(size);
    try
    {
        // 画像処理
        ProcessImageWithSpan(buffer);
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(buffer);
    }
}
```

:::note info
**特徴**
- メモリの効率的な再利用
- GC圧力の低減
- 大きな配列の処理に最適
:::

## パフォーマンス比較

以下は、異なるサイズの画像データに対する各手法の処理時間の比較です。

| 手法 | 100KB | 1MB | 10MB |
|------|-------|-----|------|
| unsafe | 0.5ms | 5ms | 48ms |
| Span<T> | 0.5ms | 5ms | 49ms |
| SIMD | 0.2ms | 2ms | 19ms |
| Parallel.For (最適化後) | 1.2ms | 3ms | 22ms |

**測定環境**
- CPU: AMD Ryzen 9 5950X
- メモリ: 32GB DDR4-3600
- OS: Windows 11 Pro
- .NET 7.0
- テストデータ: 8bitグレースケール画像
- 各測定は100回の平均値


:::note alert
注意事項
- 環境依存: 測定は AMD Ryzen 9 5950X、32GB DDR4-3600、.NET 7.0 環境で実施。他の環境では結果が異なる可能性あり。
- 画像フォーマット: 本テストは 8bitグレースケール画像 を対象。カラー画像などでは異なる結果になる場合あり。
- 最適化の影響: .NET 7 の JIT最適化 により Span<T> の性能が向上。古い環境では異なる結果の可能性あり。
- スレッドオーバーヘッド: Parallel.For は大きなデータ向き。小さいデータではスレッド管理のオーバーヘッドが発生する場合あり。
- メモリ帯域の影響: 画像処理はメモリ速度の影響を受けるため、異なるメモリ環境ではパフォーマンスが変わる可能性あり。
- 測定精度: 100回の平均値 を採用。ただし、キャッシュの影響などにより多少の変動がある可能性あり。
:::


## 推奨アプローチ

状況に応じて以下のように使い分けることをお勧めします。

### 1. 基本的なアプローチ

- ✅ まず`Span<T>`を試す（最も安全で、多くの場合十分な性能）
- ✅ 処理内容が単純な場合はSIMDを検討
- ✅ 大きなデータサイズの場合は並列処理を追加

   
### 2. 特殊なケース

- ✅ ネイティブコードとの相互運用が必要な場合：**unsafe**
- ✅ メモリ使用量が懸念される場合：**ArrayPool**
- ✅ 極限のパフォーマンスが必要な場合：**unsafe** + **SIMD**

## 各手法の特性と妥当性

| 手法 | 説明 | 妥当性 |
|:---|:---|:---|
| unsafe | ポインタを直接操作し、メモリコピーや計算処理を高速化する | ✅ C#での画像処理では頻繁に使われる手法で、ネイティブに近い性能が期待できる |
| Span<T> | 安全かつ効率的なメモリ管理を提供するC#の機能。unsafeに近いパフォーマンスを持つ | ✅ .NET 7では最適化が進んでおり、unsafeに匹敵する速度は妥当 |
| SIMD | CPUのベクトル化を利用し、一度に複数のピクセルデータを並列処理する | ✅ 画像解析には非常に有効。特に大きなデータサイズでは顕著な性能向上が期待できる |
| ParallelFor(最適化後) | マルチスレッド並列処理により、複数コアを活用して高速化 | ✅ 大きなデータでは有利。ただし、小さなデータではオーバーヘッドが影響する |

## おまけ：処理パターン別の最適な機能の組み合わせ

パフォーマンスを最適化するための安全な代替手段として、以下のような組み合わせが効果的です。

**大規模な配列処理やバッファ操作の場合**
- `Span<T>` + `SIMD` 
  - メモリコピーを最小限に抑えながらSIMDで並列演算
  - 例：大きな数値配列の演算や文字列処理
  - `Vector<T>`を使用してSIMD命令を活用

**バイナリデータの高速処理**
- `Memory<T>` + メモリプール + `System.IO.Pipelines`
  - バッファの再利用でGCプレッシャーを軽減
  - 非同期I/O処理の効率化
  - 例：ネットワークプロトコルの実装やファイル処理

**計算集中型の処理**
- `SIMD` + 並列処理（`Parallel.For`/`Task`）+ メモリプール
  - 複数コアを活用しながらメモリ効率を改善
  - 例：画像処理、科学計算、シミュレーション

**大量のオブジェクト生成が必要な場合**
- オブジェクトプール + `ValueTask` + `ArrayPool<T>`
  - オブジェクトの再利用でGC負荷を削減
  - 非同期処理のアロケーションを最小化
  - 例：ゲームエンジン、リアルタイムシステム

:::note info
これらの技術を組み合わせる際のポイント
- 処理の特性に応じて適切な組み合わせを選択
- ベンチマークを取って効果を検証
- コードの可読性とパフォーマンスのバランスを考慮
:::

## まとめ

実はC#では、多くの場合unsafeコードを使わずとも十分な性能が得られます。特に`Span<T>`とSIMDの組み合わせは、安全性と性能の両立を実現できます。

ただし、unsafeコードが適している場面もあるため、要件に応じて適切な手法を選択することが重要です。今回まとめた各アプローチの特徴を理解し、状況に応じて使い分けることをお勧めします！

## 参考リンク

- [Span<T>のドキュメント](https://docs.microsoft.com/ja-jp/dotnet/api/system.span-1)
- [unsafe (C# リファレンス)](https://learn.microsoft.com/ja-jp/dotnet/csharp/language-reference/keywords/unsafe)
- [SIMD アクセラレータの数値型を使用する](https://learn.microsoft.com/ja-jp/dotnet/standard/simd#how-to-use-simd)
- [ArrayPool<T> クラス](https://learn.microsoft.com/ja-jp/dotnet/api/system.buffers.arraypool-1?view=net-8.0)

## こちらもどうぞ

https://qiita.com/Sakai_path/items/40550594b13a6328cd68

https://qiita.com/Sakai_path/items/784227dd0a23e504f798