ISPP Algoritması Adım Adım

Temel ISPP firmware kodu:

typedef struct {
    uint32_t cell_addr;
    int target_g;           // µS × 100 (sabit-noktalı)
    int tolerance;          // ±µS × 100
    int max_iterations;     // genelde 15
} ispp_params_t;

int ispp_program_cell(ispp_params_t *p) {
    int pulse_voltage = INITIAL_VOLTAGE;  // mV (1500 = 1.5V)
    int pulse_width   = INITIAL_WIDTH;    // ns (10)
    
    for (int i = 0; i < p->max_iterations; i++) {
        apply_set_pulse(p->cell_addr, pulse_voltage, pulse_width);
        int g_actual = read_cell(p->cell_addr);
        int error = p->target_g - g_actual;
        
        if (abs(error) < p->tolerance) {
            return ISPP_SUCCESS;
        }
        
        if (error > 0) {
            // SET daha kuvvetli
            pulse_voltage += 50;        // +50 mV
            pulse_width = pulse_width * 12 / 10;  // +20%
            
            // Saturate
            if (pulse_voltage > MAX_VOLTAGE) pulse_voltage = MAX_VOLTAGE;
            if (pulse_width > MAX_WIDTH) pulse_width = MAX_WIDTH;
        } else {
            // Aştık → küçük RESET
            apply_reset_pulse(p->cell_addr, -500, 5);  // -0.5V, 5ns
            pulse_voltage = INITIAL_VOLTAGE;  // baştan
            pulse_width = INITIAL_WIDTH;
        }
    }
    
    return ISPP_FAIL;
}

Adaptif pulse stratejisi:

İlk birkaç iterasyon agresif (büyük adım). Hedefe yaklaşırken küçük adım. Logaritmik yaklaşım.

// Hata orana göre pulse parametresi
if (error > 50) pulse_width = 100;   // büyük adım
else if (error > 20) pulse_width = 50;
else if (error > 5) pulse_width = 20;
else pulse_width = 10;  // ince ayar

Crossbar paralel programlama:

256 hücre aynı satırda paralel programlanabilir. Aynı pulse uygulanır, ama BL kontrolü ile hangi hücre alır seçilir.

void program_row(int row, int targets[256]) {
    int active[256] = {1, 1, ..., 1};  // tüm hücreler aktif
    
    for (int iter = 0; iter < 15; iter++) {
        // Tüm aktif hücrelere pulse
        apply_row_pulse(row, active, voltage, width);
        
        // Tüm hücreleri oku
        int reads[256];
        read_row(row, reads);
        
        // Her hücre için kontrol
        bool all_done = true;
        for (int col = 0; col < 256; col++) {
            if (active[col] && abs(reads[col] - targets[col]) < tolerance) {
                active[col] = 0;  // bu hücre tamam
            } else if (active[col]) {
                all_done = false;
            }
        }
        
        if (all_done) return;
        
        // Pulse adjust
        voltage += 50;
        width = width * 12 / 10;
    }
}

Süre: 256 hücre paralel → ~16 iterasyon × 50 ns = 800 ns/satır. 256 satır × 800 ns = 200 µs/crossbar.

ISPP fail handling:

15 iterasyon sonra başarısız olursa:

1. Hücre stuck-LRS veya stuck-HRS olabilir.
2. Failure map’e ekle.
3. ECC ile redundant cell’e map.
4. Compiler bilir, ağırlığı başka hücreye yazar.

Y1 ISPP fail rate: %0.5. Yönetilebilir.

Closed-loop ISPP (Y10 hedef):

Klasik ISPP: pulse → bekle → ölç. Closed-loop: pulse uygulanırken sürekli ölç, anında dur.

Avantaj:

• Süre %30 azalır.
• Hassasiyet artar (overshoot az).

Dezavantaj:

• Daha karmaşık devre.

Y10 prototipte test ediliyor.

Temperature compensation:

G(T) Arrhenius. Her crossbar’da thermal sensor → firmware düzeltme uygular:

int g_target_corrected = g_target * exp_lookup(Ea / (k * T));

ISPP düzeltilmiş target ile çalışır. Drift azalır.

Compiler ↔ ISPP API:

Driver IOCTL LOAD_MODEL:

struct model_data {
    weight_t weights[N];     // FP32 ağırlıklar
    int n_layers;
    layer_info_t layers[N_LAYERS];
};

Firmware:

1. Compiler quantize edilmiş weights’i alır.
2. Hücre haritasına dönüştür (cluster, CU, crossbar, row, col).
3. Her hücreyi ISPP ile programla.
4. Failure map güncelle.
5. Driver’a “model loaded” sinyali.

Performance:

Y1 model load:

• 419M hücre × 800 ns / 256 (paralel) = 1.3 saniye.
• Pratik: ~640 ms (bazı cluster’lar paralel).

Inference başlangıcı için ~1 saniye gecikme. Bir kez yapılır.