lab1b_packed_array.sv

module packed_array_demo;

  // ========================================
  // Завдання 1: Створення multidimensional packed array
  // ========================================
  // 4 регістри по 8 біт = [3:0][7:0]
  // Packed array зберігається як один безперервний вектор бітів
  logic [3:0][7:0] registers;
  logic [3:0][7:0] inverted;
  logic [7:0] unpacked_regs [0:3];
  
  initial begin
    
    // ========================================
    // Завдання 2: Ініціалізація значенням 'hFACE_CAFE
    // ========================================
    registers = 32'hFACE_CAFE;
    
    $display("\n=== Packed Array Demo ===");
    $display("Повне значення: %h", registers);
    $display("Розмір: 4 регістри × 8 біт = 32 біт\n");
    
    // ========================================
    // Завдання 3: Вивести кожен регістр окремо
    // ========================================
    $display("=== Значення кожного регістра окремо ===");
    $display("registers[3] (старший) = 0x%h (%d)", registers[3], registers[3]);
    $display("registers[2]           = 0x%h (%d)", registers[2], registers[2]);
    $display("registers[1]           = 0x%h (%d)", registers[1], registers[1]);
    $display("registers[0] (молодший)= 0x%h (%d)", registers[0], registers[0]);
    
    $display("\nПояснення:");
    $display("  FACE_CAFE розподіляється як:");
    $display("  registers[3] = FA (250)");
    $display("  registers[2] = CE (206)");
    $display("  registers[1] = CA (202)");
    $display("  registers[0] = FE (254)");
    
    // ========================================
    // Завдання 4: Part-select виведення
    // ========================================
    $display("\n=== Part-select [to_index:from_index] ===");
    
    // Два старших регістри
    $display("\nДва старших регістри [3:2]:");
    $display("  registers[3:2] = 0x%h", registers[3:2]);
    $display("  Це регістри FA та CE -> FACE");
    
    // Два молодших регістри
    $display("\nДва молодших регістри [1:0]:");
    $display("  registers[1:0] = 0x%h", registers[1:0]);
    $display("  Це регістри CA та FE -> CAFE");
    
    // ========================================
    // Завдання 5: Половини старшого регістра
    // ========================================
    $display("\n=== Старший регістр (registers[3]) ===");
    $display("Повне значення registers[3] = 0x%h (%b)", registers[3], registers[3]);
    
    // Старша половина (біти [7:4])
    $display("\nСтарша половина registers[3][7:4]:");
    $display("  = 0x%h (%b) = %0d", registers[3][7:4], registers[3][7:4], registers[3][7:4]);
    $display("  FA = 11111010, старші 4 біти = 1111 = F");
    
    // Молодша половина (біти [3:0])
    $display("\nМолодша половина registers[3][3:0]:");
    $display("  = 0x%h (%b) = %0d", registers[3][3:0], registers[3][3:0], registers[3][3:0]);
    $display("  FA = 11111010, молодші 4 біти = 1010 = A");
    
    // ========================================
    // Демонстрація додаткових можливостей packed array
    // ========================================
    $display("\n=== Додаткові можливості Packed Array ===");
    
    // Можна звертатися до окремих бітів через весь масив
    $display("\nЗвернення до окремого біта:");
    $display("  registers[3][7] (старший біт) = %b", registers[3][7]);
    $display("  registers[0][0] (молодший біт) = %b", registers[0][0]);
    
    // Можна використовувати як один великий вектор (не підтримується в Icarus Verilog)
    $display("\nВикористання як єдиний вектор (теоретично):");
    $display("  ПРИМІТКА: В SystemVerilog можна звертатися registers[31:24], але");
    $display("  Icarus Verilog це не підтримує. В комерційних симуляторах працює:");
    // $display("  registers[31:24] = 0x%h (те саме що registers[3])", registers[31:24]);
    // $display("  registers[23:16] = 0x%h (те саме що registers[2])", registers[23:16]);
    // $display("  registers[15:8]  = 0x%h (те саме що registers[1])", registers[15:8]);
    // $display("  registers[7:0]   = 0x%h (те саме що registers[0])", registers[7:0]);
    
    // Побітові операції на всьому масиві
    inverted = ~registers;
    $display("\nПобітова інверсія всього масиву:");
    $display("  ~registers = 0x%h", inverted);
    $display("  ~FACE_CAFE = 0x%h", ~32'hFACE_CAFE);
    
  end
  
  // ========================================
  // Завдання 6: Порівняння з Unpacked Array
  // ========================================
  initial begin
    #1; // Невелика затримка для читабельності виводу
    
    $display("\n");
    $display("======================================================================");
    $display("=== ВІДПОВІДЬ: Відмінність Packed vs Unpacked Array ===");
    $display("======================================================================");
    
    $display("\n1. PACKED ARRAY: logic [3:0][7:0] registers;");
    $display("   ✓ Зберігається як ОДИН БЕЗПЕРЕРВНИЙ вектор бітів");
    $display("   ✓ Займає 32 біти в пам'яті (4 × 8)");
    $display("   ✓ Можна присвоїти одним виразом: registers = 32'hFACE_CAFE");
    $display("   ✓ Можна використовувати побітові операції на всьому масиві");
    $display("   ✓ Можна звертатися через flat indexing: registers[31:0]");
    $display("   ✓ Можна передавати як один порт в модулі");
    $display("   ✓ Синтезується в апаратуру як регістр/провід");
    
    $display("\n2. UNPACKED ARRAY: logic [7:0] registers [0:3];");
    $display("   ✗ Зберігається як ОКРЕМІ елементи в пам'яті");
    $display("   ✗ НЕ можна присвоїти одним виразом напряму");
    $display("   ✗ Потрібна ініціалізація через '{} або поелементно:");
    $display("     registers = '{8'hFA, 8'hCE, 8'hCA, 8'hFE};");
    $display("   ✗ НЕ можна використовувати побітові операції на всьому масиві");
    $display("   ✗ НЕ можна flat indexing (registers[31:0])");
    $display("   ✗ НЕ можна передати як один порт");
    $display("   ✗ НЕ синтезується (використовується тільки в тестах)");
    
    $display("\n3. КОЛИ ВИКОРИСТОВУВАТИ:");
    $display("   PACKED → для апаратури (регістри, шини даних, порти)");
    $display("   UNPACKED → для тестбенчів (масиви даних, черги, таблиці)");
    
    $display("\n4. ПРИКЛАД ДЕМОНСТРАЦІЇ:");
    
    // Unpacked array для порівняння
    
    // Ініціалізація unpacked array
    unpacked_regs[0] = 8'hFE;
    unpacked_regs[1] = 8'hCA;
    unpacked_regs[2] = 8'hCE;
    unpacked_regs[3] = 8'hFA;
    
    $display("\n   Unpacked array [7:0] unpacked_regs [0:3]:");
    $display("   unpacked_regs[0] = 0x%h", unpacked_regs[0]);
    $display("   unpacked_regs[1] = 0x%h", unpacked_regs[1]);
    $display("   unpacked_regs[2] = 0x%h", unpacked_regs[2]);
    $display("   unpacked_regs[3] = 0x%h", unpacked_regs[3]);
    
    // Це НЕ працює для unpacked:
    // unpacked_regs = 32'hFACE_CAFE;  // ПОМИЛКА!
    // $display("%h", unpacked_regs);   // ПОМИЛКА!
    // logic [7:0] slice = unpacked_regs[3:2]; // ПОМИЛКА!
    
    $display("\n   НЕ можна:");
    $display("   ✗ unpacked_regs = 32'hFACE_CAFE;  // Compilation error");
    $display("   ✗ $display(\"%%h\", unpacked_regs);   // Compilation error");
    $display("   ✗ unpacked_regs[3:2];     // Compilation error");
    
    $display("\n======================================================================");
  end

endmodule