Raspberry Pi、JUCE、ALSAの限界を知る

今までちゃんと調べてなかったけど、Raspberry Piを使ったシンセを作る際にどこが限界なのかを調べてみた。これはレイテンシと安定性をどこまで詰められるのかの話。前提としてRaspberry Pi 4、PCM5102A（hifiberryのドライバ）を使う。

## 聴力によるなんとなくの限界値チェック
JUCEで簡単なシンセサイザーを作ってRaspberry Pi上でGUI付きのスタンドアロンアプリを作って確認。PCM5102Aなどの枯れているDACを使ってレイテンシがどこまで下げられるかチェックすると、だいたい32〜64サンプル@44.1kHzくらいのところに限界がある。このあたりからバッファアンダーランが起こりやすくなる。

## ALSAの限界

ALSAの限界というかドライバの限界。これは割と簡単に調べられた。

```shell
# socをインストール
sudo apt update
sudo apt install sox

# 120秒のサイン波を作る
sox -n -r 44100 -c 2 -b 32 test.wav synth 120 sine 440

# バッファサイズ 2 サンプルで予備バッファ無しの設定を指定する
aplay -D hw:0,0 --period-size=2 --buffer-size=2 -v test.wav
Playing WAVE 'test.wav' : Signed 32 bit Little Endian, Rate 44100 Hz, Stereo
Hardware PCM card 0 'snd_rpi_hifiberry_dac' device 0 subdevice 0
Its setup is:
  stream       : PLAYBACK
  access       : RW_INTERLEAVED
  format       : S32_LE
  subformat    : STD
  channels     : 2
  rate         : 44100
  exact rate   : 44100 (44100/1)
  msbits       : 32
  buffer_size  : 64
  period_size  : 32
  period_time  : 725
  tstamp_mode  : NONE
  tstamp_type  : MONOTONIC
  period_step  : 1
  avail_min    : 32
  period_event : 0
  start_threshold  : 64
  stop_threshold   : 64
  silence_threshold: 0
  silence_size : 0
  boundary     : 4611686018427387904
  appl_ptr     : 0
  hw_ptr       : 0
```

ここでわかるのは、どんなに小さいバッファサイズを指定してもperiod_sizeが32になるし、buffer_sizeが64になる。これは32サンプルのサイズのバッファを2つ持ってダブルバッファで処理をしている、ということになる。aplay.cを見ると、ドライバの最小値に補正するようになっている。

```aplay.c
	if (period_time > 0)
		err = snd_pcm_hw_params_set_period_time_near(handle, params,
							     &period_time, 0);
	else
		err = snd_pcm_hw_params_set_period_size_near(handle, params,
							     &period_frames, 0);
```

なので、アプリのAudio設定でバッファサイズを最小値の16に設定するのはあまり意味がないと思う。

## JUCEの処理

JUCEでALSAを使う場合も似たようなことをしている。
```juce_ALSA_linux.cpp
        int dir = 0;
        unsigned int periods = 4;
        snd_pcm_uframes_t samplesPerPeriod = (snd_pcm_uframes_t) bufferSize;

        if (JUCE_ALSA_FAILED (snd_pcm_hw_params_set_rate_near (handle, hwParams, &sampleRate, nullptr))
            || JUCE_ALSA_FAILED (snd_pcm_hw_params_set_channels (handle, hwParams, (unsigned int ) numChannels))
            || JUCE_ALSA_FAILED (snd_pcm_hw_params_set_periods_near (handle, hwParams, &periods, &dir))
            || JUCE_ALSA_FAILED (snd_pcm_hw_params_set_period_size_near (handle, hwParams, &samplesPerPeriod, &dir))
            || JUCE_ALSA_FAILED (snd_pcm_hw_params (handle, hwParams)))
        {
            return false;
        }
```
ソースから見て取れるのはJUCEではperiodsを4設定していること。ダブルバッファではなく4つもバッファを持っている。これは経験則から安定性を考えてのことだと思う。そのあとでレイテンシの計算をしているけど、JACKがやっているように（らしい）periods - 1を使ってレイテンシを計算している。

```juce_ALSA_linux.cpp
        if (JUCE_ALSA_FAILED (snd_pcm_hw_params_get_period_size (hwParams, &frames, &dir))
             || JUCE_ALSA_FAILED (snd_pcm_hw_params_get_periods (hwParams, &periods, &dir)))
            latency = 0;
        else
            latency = (int) frames * ((int) periods - 1); // (this is the method JACK uses to guess the latency..)
```
JUCEのAudio設定画面では32サンプルだと0.7msと出るけど、実際にはlatency = 32 × (4-1) = 96 samples (2.18ms@44.1kHz) と内部では計算している。これを実際にどこで使っているのかは知らないけど。しかしこれを踏まえると、例えば256サンプルの場合は 256 x (4 - 1) / 44100 * 1000 = 17.4(ms)となり、かなりのレイテンシになる。

## Raspberry Pi OSの限界
Raspberry Pi OSはLinuxなわけで、汎用なOSであってAudioに特化したものではない。製造元が提供しているのはリアルタイム対応ではない"PREEMPT"な状態。これをPREEMPT-RTにすることでAudio処理の安定化は期待できると思う。

### Raspberry Pi OSをPREEMPT-RTにする
**注) これは必要ないかも。やってみたけど、正直差がわからない。それともやり方の問題？**

いわゆるリアルタイムLinuxにするために、カーネルを自分で用意して入れ替えなければならない。MacでDockerが走っているという前提で下記の3つのファイルをローカルに用意する。

<details><summary>Dockerfile</summary>

```Dockerfile
FROM ubuntu:22.04

# 非対話的インストールのため
ENV DEBIAN_FRONTEND=noninteractive

# 必要なパッケージをインストール
RUN apt-get update && apt-get install -y \
    git \
    bc \
    bison \
    flex \
    libssl-dev \
    make \
    libc6-dev \
    libncurses5-dev \
    crossbuild-essential-arm64 \
    gcc-aarch64-linux-gnu \
    wget \
    xz-utils \
    device-tree-compiler \
    python3 \
    rsync \
    kmod \
    && rm -rf /var/lib/apt/lists/*

# 作業ディレクトリを設定
WORKDIR /build

# クロスコンパイル用の環境変数（64bit ARM用）
ENV ARCH=arm64
ENV CROSS_COMPILE=aarch64-linux-gnu-
ENV KERNEL=kernel8

# Raspberry Pi カーネルソースをクローン（6.12系 - RPi4対応）
RUN git clone --depth=1 --branch rpi-6.12.y https://github.com/raspberrypi/linux

# カーネル設定（6.12系メインラインPREEMPT_RT - RPi4用）
RUN cd linux && \
    echo "Configuring PREEMPT_RT kernel for Raspberry Pi 4 (6.12+)" && \
    make bcm2711_defconfig && \
    echo "Enabling mainline PREEMPT_RT features..." && \
    # エキスパートモードを有効化
    scripts/config --enable CONFIG_EXPERT && \
    # プリエンプションモデルを確実に設定
    scripts/config --disable CONFIG_PREEMPT_NONE && \
    scripts/config --disable CONFIG_PREEMPT_VOLUNTARY && \
    scripts/config --disable CONFIG_PREEMPT && \
    scripts/config --enable CONFIG_PREEMPT_RT && \
    # 基本RT設定
    scripts/config --enable CONFIG_HIGH_RES_TIMERS && \
    scripts/config --set-val CONFIG_HZ 1000 && \
    scripts/config --enable CONFIG_IRQ_FORCED_THREADING && \
    # RPi4では安全なRCU設定も有効化可能
    scripts/config --enable CONFIG_RCU_BOOST && \
    scripts/config --enable CONFIG_NO_HZ_FULL && \
    # 設定を適用
    make olddefconfig && \
    echo "=== RPi4 PREEMPT_RT Configuration Check ===" && \
    if grep -q "CONFIG_PREEMPT_RT=y" .config && ! grep -q "CONFIG_PREEMPT=y" .config; then \
        echo "✓ SUCCESS: PREEMPT_RT is properly configured for RPi4!"; \
    else \
        echo "✗ FAILED: PREEMPT_RT configuration failed!"; \
        grep -E "CONFIG_PREEMPT.*=" .config; \
        exit 1; \
    fi

# ビルドスクリプトをコピー
COPY docker_build.sh /build/
RUN chmod +x /build/docker_build.sh

CMD ["/build/docker_build.sh"]
```
</details>

<details><summary>build_rt_kernel.sh</summary>

```shell
#!/bin/bash

# Raspberry Pi 4 64-bit PREEMPT_RT Kernel Build Script for Docker
# 6.12+ Mainline PREEMPT_RT Version (Raspberry Pi 4 optimized)
# Usage: ./build_rt_kernel.sh

set -e

# 色付きの出力用
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

echo -e "${GREEN}Raspberry Pi 4 64-bit PREEMPT_RT Kernel Builder${NC}"
echo "6.12+ Mainline PREEMPT_RT (RPi4 optimized!)"
echo "============================================="

# 出力ディレクトリを作成
OUTPUT_DIR="$(pwd)/rpi_rt_output"
echo -e "${YELLOW}Cleaning previous build...${NC}"
rm -rf "$OUTPUT_DIR"
mkdir -p "$OUTPUT_DIR"

echo -e "${YELLOW}Output directory: $OUTPUT_DIR${NC}"

# 必要なファイルの確認
if [ ! -f "Dockerfile" ]; then
    echo -e "${RED}Error: Dockerfile not found in current directory${NC}"
    exit 1
fi

if [ ! -f "docker_build.sh" ]; then
    echo -e "${RED}Error: docker_build.sh not found in current directory${NC}"
    exit 1
fi

# Dockerイメージをビルド
echo -e "${YELLOW}Building Docker image for RPi4 6.12+ kernel...${NC}"
docker build -t rpi4-rt-builder-6.12 .

if [ $? -ne 0 ]; then
    echo -e "${RED}Docker image build failed!${NC}"
    exit 1
fi

echo -e "${GREEN}Docker image built successfully!${NC}"

# カーネルをビルド
echo -e "${YELLOW}Starting RPi4 PREEMPT_RT kernel build process...${NC}"
echo "This may take 30-60 minutes..."

docker run --rm \
    -v "$OUTPUT_DIR:/output" \
    rpi4-rt-builder-6.12

if [ $? -ne 0 ]; then
    echo -e "${RED}Kernel build failed!${NC}"
    exit 1
fi

echo -e "${GREEN}RPi4 PREEMPT_RT kernel build completed successfully!${NC}"
echo ""
echo -e "${YELLOW}Installation Instructions for Raspberry Pi 4:${NC}"
echo "1. Mount your RPi4 SD card"
echo "2. Backup current kernel:"
echo "   sudo cp /Volumes/bootfs/kernel8.img /Volumes/bootfs/kernel8.img.backup"
echo "   sudo cp /Volumes/bootfs/config.txt /Volumes/bootfs/config.txt.backup"
echo ""
echo "3. Copy the new files:"
echo "   sudo cp $OUTPUT_DIR/boot/kernel8.img /Volumes/bootfs/"
echo "   sudo cp $OUTPUT_DIR/boot/*.dtb /Volumes/bootfs/"
echo "   sudo cp $OUTPUT_DIR/boot/overlays/*.dtb* /Volumes/bootfs/overlays/"
echo ""
echo "4. Install kernel modules:"
echo "   sudo cp -r $OUTPUT_DIR/modules/lib/modules/* /Volumes/rootfs/lib/modules/"
echo ""
echo "5. Update /boot/config.txt by adding:"
echo "   cat $OUTPUT_DIR/boot/config_snippet.txt"
echo ""
echo "6. Update cmdline.txt with RT optimizations:"
echo "   # Replace PARTUUID with your actual partition UUID"
echo "   sudo cp $OUTPUT_DIR/boot/cmdline_rt.txt /Volumes/bootfs/cmdline.txt"
echo ""
echo "7. Reboot your Raspberry Pi 4"
echo ""
echo -e "${YELLOW}Verification commands (after reboot):${NC}"
echo "   uname -r                    # Should show RT version"
echo "   uname -m                    # Should show 'aarch64'"
echo "   cat /sys/kernel/realtime    # Should show '1'"
echo "   sudo cyclictest -t1 -p 80 -i 1000 -l 10000 -h 100 -m"
echo ""
echo -e "${GREEN}This kernel uses mainline PREEMPT_RT (6.12+)${NC}"
echo -e "${GREEN}Optimized for Raspberry Pi 4 - No RCU issues!${NC}"
echo ""
echo -e "${GREEN}Files are ready in: $OUTPUT_DIR${NC}"
```
</details>

<details><summary>docker_build.sh</summary>

```shell
#!/bin/bash
set -e

cd /build/linux

echo "============================================"
echo "Building Raspberry Pi 4 PREEMPT_RT Kernel"
echo "Target: 64-bit ARM (kernel8.img)"
echo "Kernel: 6.12+ with mainline PREEMPT_RT"
echo "============================================"

# カーネルバージョンを表示
KERNEL_VERSION=$(make kernelversion)
echo "Kernel version: $KERNEL_VERSION"

# PREEMPT_RT設定を確認
echo "=== Checking PREEMPT_RT Configuration ==="
if grep -q "CONFIG_PREEMPT_RT=y" .config; then
    echo "✓ CONFIG_PREEMPT_RT=y is enabled"
else
    echo "✗ CONFIG_PREEMPT_RT is not enabled"
    echo "Current preemption settings:"
    grep -E "CONFIG_PREEMPT.*=" .config || echo "No PREEMPT config found"
fi

# その他のRT設定も確認
echo "Other RT settings:"
grep -E "CONFIG_HIGH_RES_TIMERS|CONFIG_NO_HZ_FULL|CONFIG_HZ=" .config | head -5

echo "Building kernel for Raspberry Pi 4..."
echo "This may take 30-60 minutes depending on your system..."

# カーネルビルド
make -j$(nproc) Image modules dtbs

echo "Creating output directories..."
mkdir -p /output/boot/overlays
mkdir -p /output/modules

echo "Copying kernel image..."
cp arch/arm64/boot/Image /output/boot/${KERNEL}.img

# カーネルサイズを表示
KERNEL_SIZE=$(stat -c%s /output/boot/${KERNEL}.img)
echo "Kernel size: $(( KERNEL_SIZE / 1024 / 1024 ))MB"

echo "Copying device tree files..."
cp arch/arm64/boot/dts/broadcom/*.dtb /output/boot/
cp arch/arm64/boot/dts/overlays/*.dtb* /output/boot/overlays/ 2>/dev/null || echo "No overlay files found"

echo "Installing kernel modules..."
make INSTALL_MOD_PATH=/output/modules modules_install

# モジュール数を表示
MODULE_COUNT=$(find /output/modules/lib/modules -name "*.ko" | wc -l 2>/dev/null || echo "0")
echo "Kernel modules installed: $MODULE_COUNT modules"

echo "Creating enhanced config.txt snippet..."
cat > /output/boot/config_snippet.txt << 'EOF'
# PREEMPT_RT kernel configuration (64-bit, mainline 6.12+ for RPi4)
kernel=kernel8.img
arm_64bit=1

# Memory configuration for RT performance
gpu_mem=64

# RT-optimized hardware settings
# Disable features that can cause jitter
dtparam=audio=off
disable_splash=1

# Hardware interfaces (enable if needed)
dtparam=i2c_arm=on
dtparam=spi=on

# Display settings
hdmi_safe=1
hdmi_force_hotplug=1

# Camera support (enable if needed)
camera_auto_detect=1
display_auto_detect=1
EOF

echo "Creating RT-optimized cmdline.txt snippet..."
cat > /output/boot/cmdline_rt.txt << 'EOF'
console=serial0,115200 console=tty1 root=PARTUUID=PLACEHOLDER rootfstype=ext4 fsck.repair=yes rootwait isolcpus=1,2,3 nohz_full=1,2,3 rcu_nocbs=1,2,3 irqaffinity=0 threadirqs quiet
EOF

echo "============================================"
echo "Build completed successfully for RPi4!"
echo "============================================"
echo
echo "Generated files:"
echo "  Kernel: /output/boot/${KERNEL}.img ($(( KERNEL_SIZE / 1024 / 1024 ))MB)"
echo "  Modules: /output/modules/lib/modules/$(ls /output/modules/lib/modules/ | head -1)"
echo "  Config: /output/boot/config_snippet.txt"
echo "  RT cmdline: /output/boot/cmdline_rt.txt"
echo
echo "Installation instructions for Raspberry Pi 4:"
echo "1. Copy kernel and files to RPi4"
echo "2. Update config.txt and cmdline.txt"
echo "3. Reboot and enjoy stable PREEMPT_RT!"
echo
echo "This kernel uses mainline PREEMPT_RT (6.12+)"
echo "Optimized for Raspberry Pi 4 - no RCU issues!"
```

</details>

この3つのファイルが置いてあるフォルダの中でbuild_rt_kernel.shを実行すると、カーネルがrpi_rt_outputというフォルダにできあがる。ちなみにこれはRaspberry Pi 4用なので、他のモデルでは動かない。ビルドしたあと、SDカードにファイルをコピーするのだがこれまた手動でやるのはめんどくさいので下記のスクリプトを作った。**これはMacのParallels上で動いているUbuntuで使うように作られている。** なぜならMacではext4は読み書きできないから。

<details><summary>install_rt_kernel.sh</summary>

```shell
#!/bin/bash

# Raspberry Pi 4 PREEMPT_RT Kernel Installation Script
# For 6.12+ Mainline PREEMPT_RT Kernels
# Usage: ./install_rt_kernel.sh

set -e

# 色付きの出力用
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# スクリプトの場所を取得
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

echo -e "${GREEN}Raspberry Pi 4 PREEMPT_RT Kernel Installer${NC}"
echo -e "${BLUE}6.12+ Mainline PREEMPT_RT Version${NC}"
echo "============================================"

# RTカーネルの出力ディレクトリを確認
RT_OUTPUT_DIR="$SCRIPT_DIR/rpi_rt_output"
if [ ! -d "$RT_OUTPUT_DIR" ]; then
    echo -e "${RED}Error: $RT_OUTPUT_DIR not found!${NC}"
    echo "Please run the build script first: ./build_rt_kernel.sh"
    exit 1
fi

# 必要なファイルの存在確認
echo -e "${YELLOW}Checking RT kernel files...${NC}"
REQUIRED_FILES=(
    "boot/kernel8.img"
    "boot/config_snippet.txt"
    "boot/cmdline_rt.txt"
)

MISSING_FILES=()
for file in "${REQUIRED_FILES[@]}"; do
    if [ ! -f "$RT_OUTPUT_DIR/$file" ]; then
        MISSING_FILES+=("$file")
    fi
done

if [ ${#MISSING_FILES[@]} -gt 0 ]; then
    echo -e "${RED}Error: Missing required files:${NC}"
    for file in "${MISSING_FILES[@]}"; do
        echo "  - $file"
    done
    echo "Please rebuild the kernel with: ./build_rt_kernel.sh"
    exit 1
fi

if [ ! -d "$RT_OUTPUT_DIR/modules/lib/modules" ]; then
    echo -e "${RED}Error: kernel modules not found!${NC}"
    exit 1
fi

echo -e "${GREEN}RT kernel files found!${NC}"

# カーネル情報を表示
KERNEL_SIZE=$(stat -c%s "$RT_OUTPUT_DIR/boot/kernel8.img" 2>/dev/null || echo "0")
MODULE_COUNT=$(find "$RT_OUTPUT_DIR/modules/lib/modules" -name "*.ko" 2>/dev/null | wc -l)
KERNEL_VERSION=$(ls "$RT_OUTPUT_DIR/modules/lib/modules/" | head -1)

echo "Kernel size: $(( KERNEL_SIZE / 1024 / 1024 ))MB"
echo "Kernel version: $KERNEL_VERSION"
echo "Module count: $MODULE_COUNT"

# SDカードの自動検出（Parallels/Mac環境対応）
echo ""
echo -e "${YELLOW}Detecting SD card...${NC}"
BOOT_MOUNT=""
ROOT_MOUNT=""

# 環境変数で指定されている場合はそれを使用
if [ -n "$BOOT_MOUNT" ] && [ -n "$ROOT_MOUNT" ]; then
    echo "Using environment variables:"
    echo "  BOOT_MOUNT=$BOOT_MOUNT"
    echo "  ROOT_MOUNT=$ROOT_MOUNT"
elif [ -d "/media/parallels/bootfs" ] && [ -d "/media/parallels/rootfs" ]; then
    # Parallels環境の場合
    BOOT_MOUNT="/media/parallels/bootfs"
    ROOT_MOUNT="/media/parallels/rootfs"
    echo "Parallels environment detected"
else
    # その他の環境での検出
    MOUNT_PATTERNS=("/Volumes/bootfs" "/Volumes/boot" "/media/*/bootfs" "/media/*/boot")
    for pattern in "${MOUNT_PATTERNS[@]}"; do
        for mount_point in $pattern; do
            if [ -d "$mount_point" ]; then
                # bootfsらしいディレクトリの確認
                if [ -f "$mount_point/config.txt" ] || [ -f "$mount_point/kernel8.img" ]; then
                    BOOT_MOUNT="$mount_point"
                    break 2
                fi
            fi
        done
    done

    ROOT_PATTERNS=("/Volumes/rootfs" "/Volumes/root" "/media/*/rootfs" "/media/*/root")
    for pattern in "${ROOT_PATTERNS[@]}"; do
        for mount_point in $pattern; do
            if [ -d "$mount_point" ]; then
                # rootfsらしいディレクトリの確認
                if [ -d "$mount_point/lib/modules" ] || [ -d "$mount_point/home" ]; then
                    ROOT_MOUNT="$mount_point"
                    break 2
                fi
            fi
        done
    done
fi

if [ -z "$BOOT_MOUNT" ] || [ -z "$ROOT_MOUNT" ]; then
    echo -e "${RED}Error: SD card not detected or not mounted!${NC}"
    echo ""
    echo "Please ensure your Raspberry Pi 4 SD card is connected and mounted."
    echo "Current mount points detected:"
    echo "Available mounts:"
    df -h | grep -E "(bootfs|rootfs|boot|root)"
    echo ""
    echo "Expected mount points:"
    echo "  - Boot partition: /media/parallels/bootfs or /Volumes/bootfs"
    echo "  - Root partition: /media/parallels/rootfs or /Volumes/rootfs"
    echo ""
    echo "You can run with manual specification:"
    echo "  BOOT_MOUNT=/your/boot/path ROOT_MOUNT=/your/root/path $0"
    exit 1
fi

echo -e "${GREEN}SD card detected:${NC}"
echo "  Boot partition: $BOOT_MOUNT"
echo "  Root partition: $ROOT_MOUNT"

# Raspberry Pi OS の確認
if [ ! -f "$BOOT_MOUNT/config.txt" ]; then
    echo -e "${RED}Error: This doesn't appear to be a Raspberry Pi OS SD card${NC}"
    echo "Missing config.txt file"
    exit 1
fi

# アーキテクチャの確認（64-bit推奨）
if grep -q "arm_64bit=1" "$BOOT_MOUNT/config.txt" 2>/dev/null || [ -f "$BOOT_MOUNT/kernel8.img" ]; then
    echo -e "${GREEN}64-bit Raspberry Pi OS detected${NC}"
else
    echo -e "${YELLOW}Warning: May not be 64-bit Raspberry Pi OS${NC}"
    echo "This RT kernel is optimized for 64-bit RPi4"
fi

# 確認プロンプト
echo ""
echo -e "${YELLOW}This script will install PREEMPT_RT kernel for Raspberry Pi 4:${NC}"
echo "1. Backup current kernel and configuration files"
echo "2. Install RT kernel (kernel8.img)"
echo "3. Copy device tree files and kernel modules"
echo "4. Update config.txt for RT kernel with optimizations"
echo "5. Create RT-optimized cmdline.txt template"
echo ""
echo -e "${RED}Warning: This will replace your current kernel!${NC}"
echo "Make sure you have backups and can access the SD card if issues occur."
echo ""
read -p "Continue with installation? (y/N): " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
    echo "Installation cancelled."
    exit 1
fi

# バックアップの作成
echo ""
echo -e "${YELLOW}Creating backups...${NC}"
BACKUP_DIR="$BOOT_MOUNT/backup_rt_$(date +%Y%m%d_%H%M%S)"
mkdir -p "$BACKUP_DIR"

# 元のカーネルファイルをバックアップ
if [ -f "$BOOT_MOUNT/kernel8.img" ]; then
    cp "$BOOT_MOUNT/kernel8.img" "$BACKUP_DIR/"
    echo "Backed up kernel8.img"
fi

if [ -f "$BOOT_MOUNT/config.txt" ]; then
    cp "$BOOT_MOUNT/config.txt" "$BACKUP_DIR/"
    echo "Backed up config.txt"
fi

if [ -f "$BOOT_MOUNT/cmdline.txt" ]; then
    cp "$BOOT_MOUNT/cmdline.txt" "$BACKUP_DIR/"
    echo "Backed up cmdline.txt"
fi

echo -e "${GREEN}Backups created in: $BACKUP_DIR${NC}"

# RTカーネルのインストール
echo ""
echo -e "${YELLOW}Installing RT kernel...${NC}"
cp "$RT_OUTPUT_DIR/boot/kernel8.img" "$BOOT_MOUNT/"
echo "RT kernel installed ($(ls -lh "$BOOT_MOUNT/kernel8.img" | awk '{print $5}'))"

# デバイスツリーファイルのコピー
echo -e "${YELLOW}Installing device tree files...${NC}"
cp "$RT_OUTPUT_DIR/boot/"*.dtb "$BOOT_MOUNT/" 2>/dev/null || echo "No DTB files to copy"
cp "$RT_OUTPUT_DIR/boot/overlays/"*.dtb* "$BOOT_MOUNT/overlays/" 2>/dev/null || echo "No overlay files to copy"
echo "Device tree files installed"

# カーネルモジュールのインストール
echo -e "${YELLOW}Installing kernel modules...${NC}"
cp -r "$RT_OUTPUT_DIR/modules/lib/modules/"* "$ROOT_MOUNT/lib/modules/"
echo "Kernel modules installed"

# config.txtの更新
echo -e "${YELLOW}Updating config.txt...${NC}"
cat "$RT_OUTPUT_DIR/boot/config_snippet.txt" >> "$BOOT_MOUNT/config.txt"
echo "config.txt updated for RT kernel"

# cmdline.txtテンプレートの作成
echo -e "${YELLOW}Creating RT cmdline.txt template...${NC}"
# 元のPARTUUIDを保持
ORIGINAL_PARTUUID=$(grep -o 'root=PARTUUID=[^ ]*' "$BACKUP_DIR/cmdline.txt" 2>/dev/null || echo 'root=PARTUUID=YOUR_PARTUUID')

sed "s/root=PARTUUID=PLACEHOLDER/$ORIGINAL_PARTUUID/" "$RT_OUTPUT_DIR/boot/cmdline_rt.txt" > "$BOOT_MOUNT/cmdline_rt_template.txt"
echo "RT cmdline template created: cmdline_rt_template.txt"
echo "Review and replace cmdline.txt if you want RT optimizations"

# 同期と完了メッセージ
echo -e "${YELLOW}Syncing files...${NC}"
sync

echo ""
echo -e "${GREEN}Installation completed successfully for Raspberry Pi 4!${NC}"
echo ""
echo -e "${BLUE}Installation Summary:${NC}"
echo "- RT kernel: $(ls -lh "$BOOT_MOUNT/kernel8.img" | awk '{print $5}')"
echo "- Modules: $(ls "$ROOT_MOUNT/lib/modules/" | grep -E '^6\.' | tail -1)"
echo "- Backup: $BACKUP_DIR"
echo ""
echo -e "${YELLOW}Next steps:${NC}"
echo "1. Safely eject the SD card"
echo "2. Insert into Raspberry Pi 4 and boot"
echo "3. After boot, verify RT kernel with:"
echo "   uname -r"
echo "   cat /sys/kernel/realtime"
echo "   sudo cyclictest -t1 -p 80 -i 1000 -l 1000"
echo ""
echo -e "${YELLOW}Optional RT optimizations:${NC}"
echo "Replace /boot/cmdline.txt with /boot/cmdline_rt_template.txt for:"
echo "- CPU isolation (cores 1,2,3 for RT tasks)"
echo "- IRQ affinity (core 0 for interrupts)"
echo "- Tickless operation on isolated cores"
echo ""
echo -e "${YELLOW}If boot fails, restore from backup:${NC}"
echo "   cp $BACKUP_DIR/kernel8.img $BOOT_MOUNT/"
echo "   cp $BACKUP_DIR/config.txt $BOOT_MOUNT/"
echo ""
echo -e "${GREEN}Happy real-time computing on Raspberry Pi 4!${NC}"
```

</details>

Raspberry Imagerで焼いたSDカードをMacに挿してParallels上のUbuntuで認識させてマウントされた状態でこのスクリプトを走らせれば、PREEMPT-RTのOSが出来上がる。

### パフォーマンスを引き出すための設定 (OS)

#### SWAP完全無効化
```shell
# SWAP無効化
sudo swapoff -a
sudo dphys-swapfile swapoff
sudo systemctl stop dphys-swapfile
sudo systemctl disable dphys-swapfile

# 恒久設定
sudo nano /etc/dphys-swapfile
# CONF_SWAPSIZE=0 に変更
```

#### CPU性能最大化
```shell
# CPUを最高性能固定
echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
# 1.0GHz → 1.8GHz (80%性能向上)
```

#### リアルタイム権限設定
```shell
# /etc/security/limits.conf に下記を追加

username        -       rtprio          99
username        -       memlock         unlimited
@audio          -       rtprio          99
@audio          -       memlock         unlimited
# usernameの部分は実際のユーザー名
```

#### ALSA設定
```shell
# ~/.asoundrc を下記の内容で作成

pcm.!default {
    type hw
    card 0
    device 0
}

ctl.!default {
    type hw
    card 0
}
```
pcm.!default の部分：

- PCM（Pulse Code Modulation）デバイスのデフォルト設定
- type hw = ハードウェア直接アクセス
- card 0 = サウンドカード0番
- device 0 = そのカード内のデバイス0番

ctl.!default の部分：

- コントロールデバイス（音量調整など）のデフォルト設定
- 同じくハードウェア直接アクセスでカード0を指定

この設定により、ALSAを使うアプリケーションは全て、サウンドカード0のデバイス0に直接音声を送るようになります。PulseAudioやPipeWireなどの音声サーバーを経由せず、ハードウェアに直接アクセスする設定です。
音声の遅延を最小限にしたい場合や、他の音声システムとの競合を避けたい場合によく使われる設定ですね。


### パフォーマンスを引き出すための設定 (アプリ)

OS側の設定ができても、アプリ内側で対応しないと効果が発揮できない。

#### JUCEソース最適化
4つ持っているバッファを2つに減らす。バッファアンダーランのリスクは増えるがレイテンシを優先する。
```cpp
// modules/juce_audio_devices/native/juce_linux_ALSA.cpp の下記の部分
// 修正前
unsigned int periods = 4;

// 修正後  
unsigned int periods = 2;  // 4→2に変更
```

#### リアルタイムスレッド設定
PREEMPT-RTの恩恵を受けるにはスレッドのスケジューリングがSHED_FIFOでなくてはならない。また優先度も最高レベルに引き上げてCPUコアも占有する。ここはJUCEのソースをいじるのが嫌なのでprepareToPlay()が呼ばれた後一発目のprocessBlock()で行う。
```cpp
// 下記のメソッドをAudioProcessorを継承したクラスに実装

#if JUCE_LINUX
void XXXAudioProcessor::configureLinuxRealtimeThread()
{
    struct sched_param param;
    param.sched_priority = 99;  // 最高優先度
    
    if (sched_setscheduler(0, SCHED_FIFO, &param) == 0) {
        std::cout << "[IFW3] MAXIMUM priority scheduler: SUCCESS (priority 99)" << std::endl;
    }
    
    // メモリロック
    mlockall(MCL_CURRENT | MCL_FUTURE);
    
    // CPU専有
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(3, &cpuset);
    sched_setaffinity(0, sizeof(cpu_set_t), &cpuset);
    
    pthread_setname_np(pthread_self(), "IFW3-AudioRT");
}
#endif
```

prepareToPlay()とprocessBlock()内で適用

```cpp
void XXXAudioProcessor::prepareToPlay(double sampleRate, int samplesPerBlock) override
{
#if JUCE_LINUX
    rtConfigured.store(false);  // フラグリセット
#endif

    // 他の処理...
}

void XXXAudioProcessor::processBlock(AudioBuffer<float>& buffer, MidiBuffer& midiMessages) override
{
#if JUCE_LINUX
    if (!rtConfigured.load()) {
        configureLinuxRealtimeThread();
        rtConfigured.store(true);
    }
#endif
    
    // オーディオ処理...
}
```

ヘッダに追加

```cpp
// 必要なインクルードファイル
#if JUCE_LINUX
#include <sys/mman.h>          // mlockall, MCL_CURRENT, MCL_FUTURE
#include <sched.h>             // sched_setscheduler, SCHED_FIFO
#include <pthread.h>           // pthread_setname_np
#include <errno.h>             // errno
#include <cstring>             // strerror
#include <unistd.h>            // sysconf
#include <sys/resource.h>      // getrlimit, RLIMIT_RTPRIO
#include <sys/syscall.h>       // syscall, __NR_gettid
#endif

// これらはクラスのメンバとして追加
#if JUCE_LINUX
    std::atomic<bool> rtConfigured{false};
    std::atomic<bool> configurationAttempted{false};
#endif
```

## どうやってこれをやった？
だいたいClaude Sonnet 4にやらせた。