Сборка C++ приложения для работы в условиях сильной радиации: защита от сбоев

Проблема: почему радиация опасна для кода на C++

Высокая радиация вызывает single-event upsets (SEU) — случайные перевороты битов в памяти. Это может затронуть:

• Стек и кучу (данные программы)
• Регистры процессора (включая PC — счётчик команд)
• Flash-память с кодом (редко, но возможно)
• Периферийные регистры

Ваш код на O2 может быть особенно уязвим, потому что оптимизатор может удалить "избыточные" проверки, которые на самом деле были защитой.

Шаг 1: Ключи компиляции GCC для защиты

Используйте следующие флаги (пример для ARM GCC):

-mno-sched-prolog -fno-delete-null-pointer-checks -fno-strict-aliasing -fno-dse -fno-tree-dominator-opts -fno-tree-pre -fno-tree-loop-optimize -fno-inline-small-functions -fno-cprop-registers -fno-gcse -fno-guess-branch-probability

Ключевые моменты:

• -fno-delete-null-pointer-checks — не удалять проверки на NULL, даже если компилятор считает их избыточными
• -fno-strict-aliasing — отключает опасные оптимизации с псевдонимами
• -fno-dse и -fno-tree-pre — предотвращают удаление "лишних" чтений/записей, которые на самом деле являются защитой от сбоев
• -O1 или -Os вместо -O2 — меньше оптимизаций = меньше неожиданного поведения

Шаг 2: Техники кодирования для устойчивости

2.1. Triple Modular Redundancy (TMR) для критичных данных

Храните каждое важное значение в трёх копиях и принимайте решение по большинству:

struct SafeInt {
    int v[3];
    int get() {
        if (v[0] == v[1]) return v[0];
        if (v[1] == v[2]) return v[1];
        return v[0]; // fallback
    }
    void set(int x) {
        v[0] = x; v[1] = x; v[2] = x;
    }
};

2.2. CRC для критических переменных

struct CrcProtected {
    uint32_t value;
    uint32_t crc;
    bool is_valid() { return crc16(value) == crc; }
};

2.3. Watchdog + периодический тест памяти

void memory_test() {
    volatile uint8_t* test_area = (uint8_t*)0x20000000;
    for (int i = 0; i < 1024; i++) {
        test_area[i] = 0xAA;
        if (test_area[i] != 0xAA) hard_fault_handler(); // сбой!
    }
}

2.4. Защита указателей на функции (vtable)

Если используете виртуальные функции, храните копию vtable в защищённой памяти и проверяйте её CRC перед каждым вызовом:

class Sensor {
    // ...
    void read() {
        if (crc16(vtable) != expected_crc) reboot();
        this->vtable->read(this);
    }
};

Шаг 3: Аппаратные приёмы

• Используйте ECC-память (если контроллер поддерживает)
• Разместите критичные данные в SRAM с защитой от SEU (некоторые ARM Cortex имеют такую)
• Включите MPU (Memory Protection Unit) для блокировки исполнения из RAM

Важно: Избегайте динамического выделения памяти (new/malloc) — оно недетерминировано и множит точки отказа. Используйте статические буферы с проверкой границ.

Ваш исправленный код может выглядеть так:

SafeInt sensor_value;
SafeInt threshold;

int main() {
    while(1) {
        sensor_value.set(read_sensor());
        threshold.set(100);
        if (sensor_value.get() > threshold.get()) {
            activate_alarm();
        }
        // Периодически тестируем память
        if (counter++ % 1000 == 0) memory_test();
        // Сбрасываем watchdog
        wdt_reset();
    }
}

И компилируем с: -O1 -fno-delete-null-pointer-checks -fno-strict-aliasing -fno-dse -mno-sched-prolog

constexpr uint32_t crc_table[256] = { /* ... */ };
static_assert(crc16(crc_table) == EXPECTED_CRC, "CRC table corrupted in flash");

void critical_function() {
    volatile uint32_t canary = 0xDEADBEEF;
    // ... код ...
    if (canary != 0xDEADBEEF) reboot();
}