sim: Refactor the serialization base class

Objects that are can be serialized are supposed to inherit from the
Serializable class. This class is meant to provide a unified API for
such objects. However, so far it has mainly been used by SimObjects
due to some fundamental design limitations. This changeset redesigns
to the serialization interface to make it more generic and hide the
underlying checkpoint storage. Specifically:

  * Add a set of APIs to serialize into a subsection of the current
    object. Previously, objects that needed this functionality would
    use ad-hoc solutions using nameOut() and section name
    generation. In the new world, an object that implements the
    interface has the methods serializeSection() and
    unserializeSection() that serialize into a named /subsection/ of
    the current object. Calling serialize() serializes an object into
    the current section.

  * Move the name() method from Serializable to SimObject as it is no
    longer needed for serialization. The fully qualified section name
    is generated by the main serialization code on the fly as objects
    serialize sub-objects.

  * Add a scoped ScopedCheckpointSection helper class. Some objects
    need to serialize data structures, that are not deriving from
    Serializable, into subsections. Previously, this was done using
    nameOut() and manual section name generation. To simplify this,
    this changeset introduces a ScopedCheckpointSection() helper
    class. When this class is instantiated, it adds a new /subsection/
    and subsequent serialization calls during the lifetime of this
    helper class happen inside this section (or a subsection in case
    of nested sections).

  * The serialize() call is now const which prevents accidental state
    manipulation during serialization. Objects that rely on modifying
    state can use the serializeOld() call instead. The default
    implementation simply calls serialize(). Note: The old-style calls
    need to be explicitly called using the
    serializeOld()/serializeSectionOld() style APIs. These are used by
    default when serializing SimObjects.

  * Both the input and output checkpoints now use their own named
    types. This hides underlying checkpoint implementation from
    objects that need checkpointing and makes it easier to change the
    underlying checkpoint storage code.

28 files changed, 200 insertions, 210 deletions

diff --git a/src/dev/arm/energy_ctrl.cc b/src/dev/arm/energy_ctrl.cc
index b77eaba3b..0e6925852 100644
--- a/src/dev/arm/energy_ctrl.cc
+++ b/src/dev/arm/energy_ctrl.cc
@@ -216,7 +216,7 @@ EnergyCtrl::write(PacketPtr pkt)
 }
 
 void
-EnergyCtrl::serialize(std::ostream &os)
+EnergyCtrl::serialize(CheckpointOut &cp) const
 {
     SERIALIZE_SCALAR(domainID);
     SERIALIZE_SCALAR(domainIDIndexToRead);
@@ -228,7 +228,7 @@ EnergyCtrl::serialize(std::ostream &os)
 }
 
 void
-EnergyCtrl::unserialize(Checkpoint *cp, const std::string &section)
+EnergyCtrl::unserialize(CheckpointIn &cp)
 {
     UNSERIALIZE_SCALAR(domainID);
     UNSERIALIZE_SCALAR(domainIDIndexToRead);
diff --git a/src/dev/arm/energy_ctrl.hh b/src/dev/arm/energy_ctrl.hh
index 54a690679..a1a362879 100644
--- a/src/dev/arm/energy_ctrl.hh
+++ b/src/dev/arm/energy_ctrl.hh
@@ -132,8 +132,8 @@ class EnergyCtrl : public BasicPioDevice
      */
     virtual Tick write(PacketPtr pkt);
 
-    void serialize(std::ostream &os);
-    void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
     void startup();
     void init();
diff --git a/src/dev/arm/flash_device.cc b/src/dev/arm/flash_device.cc
index eaa839178..96f8f0566 100644
--- a/src/dev/arm/flash_device.cc
+++ b/src/dev/arm/flash_device.cc
@@ -518,7 +518,7 @@ FlashDevice::regStats()
  */
 
 void
-FlashDevice::serialize(std::ostream &os)
+FlashDevice::serialize(CheckpointOut &cp) const
 {
     SERIALIZE_SCALAR(planeMask);
 
@@ -551,7 +551,7 @@ FlashDevice::serialize(std::ostream &os)
  */
 
 void
-FlashDevice::unserialize(Checkpoint *cp, const std::string &section)
+FlashDevice::unserialize(CheckpointIn &cp)
 {
     UNSERIALIZE_SCALAR(planeMask);
 
diff --git a/src/dev/arm/flash_device.hh b/src/dev/arm/flash_device.hh
index 8dc4ba04a..330299451 100644
--- a/src/dev/arm/flash_device.hh
+++ b/src/dev/arm/flash_device.hh
@@ -64,8 +64,9 @@ class FlashDevice : public AbstractNVM
     /** Checkpoint functions*/
     unsigned int drain(DrainManager *dm);
     void checkDrain();
-    void serialize(std::ostream &os);
-    void unserialize(Checkpoint *cp, const std::string &section);
+
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
   private:
     /** Defines the possible actions to the flash*/
diff --git a/src/dev/arm/generic_timer.cc b/src/dev/arm/generic_timer.cc
index 41cb4bada..173855b88 100644
--- a/src/dev/arm/generic_timer.cc
+++ b/src/dev/arm/generic_timer.cc
@@ -66,7 +66,7 @@ SystemCounter::setFreq(uint32_t freq)
 }
 
 void
-SystemCounter::serialize(std::ostream &os) const
+SystemCounter::serialize(CheckpointOut &cp) const
 {
     SERIALIZE_SCALAR(_regCntkctl);
     SERIALIZE_SCALAR(_freq);
@@ -75,8 +75,7 @@ SystemCounter::serialize(std::ostream &os) const
 }
 
 void
-SystemCounter::unserialize(Checkpoint *cp,
-                           const std::string &section)
+SystemCounter::unserialize(CheckpointIn &cp)
 {
     // We didn't handle CNTKCTL in this class before, assume it's zero
     // if it isn't present.
@@ -175,9 +174,9 @@ ArchTimer::value() const
 }
 
 void
-ArchTimer::serialize(std::ostream &os) const
+ArchTimer::serialize(CheckpointOut &cp) const
 {
-    paramOut(os, "control_serial", _control);
+    paramOut(cp, "control_serial", _control);
     SERIALIZE_SCALAR(_counterLimit);
     SERIALIZE_SCALAR(_offset);
 
@@ -190,10 +189,9 @@ ArchTimer::serialize(std::ostream &os) const
 }
 
 void
-ArchTimer::unserialize(Checkpoint *cp,
-                                         const std::string &section)
+ArchTimer::unserialize(CheckpointIn &cp)
 {
-    paramIn(cp, section, "control_serial", _control);
+    paramIn(cp, "control_serial", _control);
     // We didn't serialize an offset before we added support for the
     // virtual timer. Consider it optional to maintain backwards
     // compatibility.
@@ -240,28 +238,26 @@ GenericTimer::GenericTimer(GenericTimerParams *p)
 }
 
 void
-GenericTimer::serialize(std::ostream &os)
+GenericTimer::serialize(CheckpointOut &cp) const
 {
-    paramOut(os, "cpu_count", timers.size());
+    paramOut(cp, "cpu_count", timers.size());
 
-    nameOut(os, csprintf("%s.sys_counter", name()));
-    systemCounter.serialize(os);
+    systemCounter.serializeSection(cp, "sys_counter");
 
     for (int i = 0; i < timers.size(); ++i) {
-        CoreTimers &core(getTimers(i));
-
-        nameOut(os, core.phys.name());
-        core.phys.serialize(os);
+        const CoreTimers &core(*timers[i]);
 
-        nameOut(os, core.virt.name());
-        core.virt.serialize(os);
+        // This should really be phys_timerN, but we are stuck with
+        // arch_timer for backwards compatibility.
+        core.phys.serializeSection(cp, csprintf("arch_timer%d", i));
+        core.virt.serializeSection(cp, csprintf("virt_timer%d", i));
     }
 }
 
 void
-GenericTimer::unserialize(Checkpoint *cp, const std::string &section)
+GenericTimer::unserialize(CheckpointIn &cp)
 {
-    systemCounter.unserialize(cp, csprintf("%s.sys_counter", section));
+    systemCounter.unserializeSection(cp, "sys_counter");
 
     // Try to unserialize the CPU count. Old versions of the timer
     // model assumed a 8 CPUs, so we fall back to that if the field
@@ -278,8 +274,8 @@ GenericTimer::unserialize(Checkpoint *cp, const std::string &section)
         CoreTimers &core(getTimers(i));
         // This should really be phys_timerN, but we are stuck with
         // arch_timer for backwards compatibility.
-        core.phys.unserialize(cp, csprintf("%s.arch_timer%d", section, i));
-        core.virt.unserialize(cp, csprintf("%s.virt_timer%d", section, i));
+        core.phys.unserializeSection(cp, csprintf("arch_timer%d", i));
+        core.virt.unserializeSection(cp, csprintf("virt_timer%d", i));
     }
 }
 
@@ -498,24 +494,20 @@ GenericTimerMem::GenericTimerMem(GenericTimerMemParams *p)
 }
 
 void
-GenericTimerMem::serialize(std::ostream &os)
+GenericTimerMem::serialize(CheckpointOut &cp) const
 {
-    paramOut(os, "timer_count", 1);
-
-    nameOut(os, csprintf("%s.sys_counter", name()));
-    systemCounter.serialize(os);
+    paramOut(cp, "timer_count", 1);
 
-    nameOut(os, physTimer.name());
-    physTimer.serialize(os);
+    systemCounter.serializeSection(cp, "sys_counter");
 
-    nameOut(os, virtTimer.name());
-    virtTimer.serialize(os);
+    physTimer.serializeSection(cp, "phys_timer0");
+    virtTimer.serializeSection(cp, "virt_timer0");
 }
 
 void
-GenericTimerMem::unserialize(Checkpoint *cp, const std::string &section)
+GenericTimerMem::unserialize(CheckpointIn &cp)
 {
-    systemCounter.unserialize(cp, csprintf("%s.sys_counter", section));
+    systemCounter.unserializeSection(cp, "sys_counter");
 
     unsigned timer_count;
     UNSERIALIZE_SCALAR(timer_count);
@@ -524,8 +516,8 @@ GenericTimerMem::unserialize(Checkpoint *cp, const std::string &section)
     if (timer_count != 1)
         panic("Incompatible checkpoint: Only one set of timers supported");
 
-    physTimer.unserialize(cp, csprintf("%s.phys_timer0", section));
-    virtTimer.unserialize(cp, csprintf("%s.virt_timer0", section));
+    physTimer.unserializeSection(cp, "phys_timer0");
+    virtTimer.unserializeSection(cp, "virt_timer0");
 }
 
 Tick
diff --git a/src/dev/arm/generic_timer.hh b/src/dev/arm/generic_timer.hh
index d8f7f54e2..97823f05f 100644
--- a/src/dev/arm/generic_timer.hh
+++ b/src/dev/arm/generic_timer.hh
@@ -58,7 +58,7 @@ class GenericTimerMemParams;
 
 /// Global system counter.  It is shared by the architected timers.
 /// @todo: implement memory-mapped controls
-class SystemCounter
+class SystemCounter : public Serializable
 {
   protected:
     /// Counter frequency (as specified by CNTFRQ).
@@ -93,8 +93,8 @@ class SystemCounter
     void setKernelControl(uint32_t val) { _regCntkctl = val; }
     uint32_t getKernelControl() { return _regCntkctl; }
 
-    void serialize(std::ostream &os) const;
-    void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
   private:
     // Disable copying
@@ -102,7 +102,7 @@ class SystemCounter
 };
 
 /// Per-CPU architected timer.
-class ArchTimer
+class ArchTimer : public Serializable
 {
   public:
     class Interrupt
@@ -189,8 +189,8 @@ class ArchTimer
     /// Returns the value of the counter which this timer relies on.
     uint64_t value() const;
 
-    void serialize(std::ostream &os) const;
-    void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
   private:
     // Disable copying
@@ -202,8 +202,8 @@ class GenericTimer : public SimObject
   public:
     GenericTimer(GenericTimerParams *p);
 
-    void serialize(std::ostream &os) M5_ATTR_OVERRIDE;
-    void unserialize(Checkpoint *cp, const std::string &sec) M5_ATTR_OVERRIDE;
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
   public:
     void setMiscReg(int misc_reg, unsigned cpu, ArmISA::MiscReg val);
@@ -279,8 +279,8 @@ class GenericTimerMem : public PioDevice
   public:
     GenericTimerMem(GenericTimerMemParams *p);
 
-    void serialize(std::ostream &os) M5_ATTR_OVERRIDE;
-    void unserialize(Checkpoint *cp, const std::string &sec) M5_ATTR_OVERRIDE;
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
   public: // PioDevice
     AddrRangeList getAddrRanges() const M5_ATTR_OVERRIDE { return addrRanges; }
diff --git a/src/dev/arm/gic_pl390.cc b/src/dev/arm/gic_pl390.cc
index b4dc37682..5a21f6cec 100644
--- a/src/dev/arm/gic_pl390.cc
+++ b/src/dev/arm/gic_pl390.cc
@@ -741,7 +741,7 @@ Pl390::getAddrRanges() const
 
 
 void
-Pl390::serialize(std::ostream &os)
+Pl390::serialize(CheckpointOut &cp) const
 {
     DPRINTF(Checkpoint, "Serializing Arm GIC\n");
 
@@ -781,7 +781,7 @@ Pl390::serialize(std::ostream &os)
 }
 
 void
-Pl390::unserialize(Checkpoint *cp, const std::string &section)
+Pl390::unserialize(CheckpointIn &cp)
 {
     DPRINTF(Checkpoint, "Unserializing Arm GIC\n");
 
diff --git a/src/dev/arm/gic_pl390.hh b/src/dev/arm/gic_pl390.hh
index 2621e1a27..1adad6c9a 100644
--- a/src/dev/arm/gic_pl390.hh
+++ b/src/dev/arm/gic_pl390.hh
@@ -300,8 +300,8 @@ class Pl390 : public BaseGic
     void driveIrqEn(bool state);
     /** @} */
 
-    virtual void serialize(std::ostream &os);
-    virtual void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
   protected:
     /** Handle a read to the distributor poriton of the GIC
diff --git a/src/dev/arm/hdlcd.cc b/src/dev/arm/hdlcd.cc
index 3fc30f16d..afeef7637 100644
--- a/src/dev/arm/hdlcd.cc
+++ b/src/dev/arm/hdlcd.cc
@@ -580,7 +580,7 @@ HDLcd::dmaDone(DmaDoneEvent *event)
 }
 
 void
-HDLcd::serialize(std::ostream &os)
+HDLcd::serialize(CheckpointOut &cp) const
 {
     DPRINTF(HDLcd, "Serializing ARM HDLCD\n");
 
@@ -641,7 +641,7 @@ HDLcd::serialize(std::ostream &os)
     SERIALIZE_SCALAR(dmaPendingNum);
     SERIALIZE_SCALAR(frameUnderrun);
 
-    arrayParamOut(os, "virtualDisplayBuffer", virtualDisplayBuffer);
+    arrayParamOut(cp, "virtualDisplayBuffer", virtualDisplayBuffer);
 
     SERIALIZE_SCALAR(pixelBufferSize);
     SERIALIZE_SCALAR(pixelIndex);
@@ -678,12 +678,12 @@ HDLcd::serialize(std::ostream &os)
         dma_done_event_burst_len[x] = dmaDoneEventAll[x].scheduled() ?
             dmaDoneEventAll[x].getTransactionSize() : 0;
     }
-    arrayParamOut(os, "dma_done_event_tick", dma_done_event_tick);
-    arrayParamOut(os, "dma_done_event_burst_length", dma_done_event_burst_len);
+    arrayParamOut(cp, "dma_done_event_tick", dma_done_event_tick);
+    arrayParamOut(cp, "dma_done_event_burst_length", dma_done_event_burst_len);
 }
 
 void
-HDLcd::unserialize(Checkpoint *cp, const std::string &section)
+HDLcd::unserialize(CheckpointIn &cp)
 {
     uint32_t version_serial, int_rawstat_serial, int_clear_serial,
             int_mask_serial, int_status_serial, fb_line_count_serial,
@@ -753,7 +753,7 @@ HDLcd::unserialize(Checkpoint *cp, const std::string &section)
     UNSERIALIZE_SCALAR(frameUnderrun);
     UNSERIALIZE_SCALAR(dmaBytesInFlight);
 
-    arrayParamIn(cp, section, "virtualDisplayBuffer", virtualDisplayBuffer);
+    arrayParamIn(cp, "virtualDisplayBuffer", virtualDisplayBuffer);
 
     UNSERIALIZE_SCALAR(pixelBufferSize);
     UNSERIALIZE_SCALAR(pixelIndex);
@@ -783,8 +783,8 @@ HDLcd::unserialize(Checkpoint *cp, const std::string &section)
 
     vector<Tick> dma_done_event_tick(MAX_OUTSTANDING_DMA_REQ_CAPACITY);
     vector<Tick> dma_done_event_burst_len(MAX_OUTSTANDING_DMA_REQ_CAPACITY);
-    arrayParamIn(cp, section, "dma_done_event_tick", dma_done_event_tick);
-    arrayParamIn(cp, section, "dma_done_event_burst_length", dma_done_event_burst_len);
+    arrayParamIn(cp, "dma_done_event_tick", dma_done_event_tick);
+    arrayParamIn(cp, "dma_done_event_burst_length", dma_done_event_burst_len);
     dmaDoneEventFree.clear();
     for (int x = 0; x < MAX_OUTSTANDING_DMA_REQ_CAPACITY; ++x) {
         if (dma_done_event_tick[x]) {
diff --git a/src/dev/arm/hdlcd.hh b/src/dev/arm/hdlcd.hh
index 519afeba6..1396c9a8b 100644
--- a/src/dev/arm/hdlcd.hh
+++ b/src/dev/arm/hdlcd.hh
@@ -502,8 +502,8 @@ class HDLcd: public AmbaDmaDevice
     virtual Tick read(PacketPtr pkt);
     virtual Tick write(PacketPtr pkt);
 
-    virtual void serialize(std::ostream &os);
-    virtual void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
     /**
      * Determine the address ranges that this device responds to.
diff --git a/src/dev/arm/kmi.cc b/src/dev/arm/kmi.cc
index 2344b4cb5..d96810351 100644
--- a/src/dev/arm/kmi.cc
+++ b/src/dev/arm/kmi.cc
@@ -308,7 +308,7 @@ Pl050::keyPress(uint32_t key, bool down)
 }
 
 void
-Pl050::serialize(std::ostream &os)
+Pl050::serialize(CheckpointOut &cp) const
 {
     uint8_t ctrlreg = control;
     SERIALIZE_SCALAR(ctrlreg);
@@ -327,11 +327,11 @@ Pl050::serialize(std::ostream &os)
     SERIALIZE_SCALAR(shiftDown);
     SERIALIZE_SCALAR(driverInitialized);
 
-    arrayParamOut(os, "rxQueue", rxQueue);
+    SERIALIZE_CONTAINER(rxQueue);
 }
 
 void
-Pl050::unserialize(Checkpoint *cp, const std::string &section)
+Pl050::unserialize(CheckpointIn &cp)
 {
     uint8_t ctrlreg;
     UNSERIALIZE_SCALAR(ctrlreg);
@@ -355,7 +355,7 @@ Pl050::unserialize(Checkpoint *cp, const std::string &section)
     UNSERIALIZE_SCALAR(shiftDown);
     UNSERIALIZE_SCALAR(driverInitialized);
 
-    arrayParamIn(cp, section, "rxQueue", rxQueue);
+    UNSERIALIZE_CONTAINER(rxQueue);
 }
 
 
diff --git a/src/dev/arm/kmi.hh b/src/dev/arm/kmi.hh
index f9dbfcf76..9b30b3c15 100644
--- a/src/dev/arm/kmi.hh
+++ b/src/dev/arm/kmi.hh
@@ -157,8 +157,8 @@ class Pl050 : public AmbaIntDevice, public VncKeyboard, public VncMouse
     virtual void mouseAt(uint16_t x, uint16_t y, uint8_t buttons);
     virtual void keyPress(uint32_t key, bool down);
 
-    virtual void serialize(std::ostream &os);
-    virtual void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 };
 
 #endif // __DEV_ARM_PL050_HH__
diff --git a/src/dev/arm/pl011.cc b/src/dev/arm/pl011.cc
index 2abd82e96..f0c3d2d98 100644
--- a/src/dev/arm/pl011.cc
+++ b/src/dev/arm/pl011.cc
@@ -272,7 +272,7 @@ Pl011::setInterrupts(uint16_t ints, uint16_t mask)
 
 
 void
-Pl011::serialize(std::ostream &os)
+Pl011::serialize(CheckpointOut &cp) const
 {
     DPRINTF(Checkpoint, "Serializing Arm PL011\n");
     SERIALIZE_SCALAR(control);
@@ -282,12 +282,12 @@ Pl011::serialize(std::ostream &os)
     SERIALIZE_SCALAR(ifls);
 
     // Preserve backwards compatibility by giving these silly names.
-    paramOut(os, "imsc_serial", imsc);
-    paramOut(os, "rawInt_serial", rawInt);
+    paramOut(cp, "imsc_serial", imsc);
+    paramOut(cp, "rawInt_serial", rawInt);
 }
 
 void
-Pl011::unserialize(Checkpoint *cp, const std::string &section)
+Pl011::unserialize(CheckpointIn &cp)
 {
     DPRINTF(Checkpoint, "Unserializing Arm PL011\n");
 
@@ -298,8 +298,8 @@ Pl011::unserialize(Checkpoint *cp, const std::string &section)
     UNSERIALIZE_SCALAR(ifls);
 
     // Preserve backwards compatibility by giving these silly names.
-    paramIn(cp, section, "imsc_serial", imsc);
-    paramIn(cp, section, "rawInt_serial", rawInt);
+    paramIn(cp, "imsc_serial", imsc);
+    paramIn(cp, "rawInt_serial", rawInt);
 }
 
 Pl011 *
diff --git a/src/dev/arm/pl011.hh b/src/dev/arm/pl011.hh
index f2587c08d..b0f7d576d 100644
--- a/src/dev/arm/pl011.hh
+++ b/src/dev/arm/pl011.hh
@@ -60,8 +60,8 @@ class Pl011 : public Uart, public AmbaDevice
   public:
     Pl011(const Pl011Params *p);
 
-    void serialize(std::ostream &os) M5_ATTR_OVERRIDE;
-    void unserialize(Checkpoint *cp, const std::string &sec) M5_ATTR_OVERRIDE;
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
   public: // PioDevice
     Tick read(PacketPtr pkt) M5_ATTR_OVERRIDE;
diff --git a/src/dev/arm/pl111.cc b/src/dev/arm/pl111.cc
index fcce09f50..179f1bf2d 100644
--- a/src/dev/arm/pl111.cc
+++ b/src/dev/arm/pl111.cc
@@ -547,7 +547,7 @@ Pl111::dmaDone()
 }
 
 void
-Pl111::serialize(std::ostream &os)
+Pl111::serialize(CheckpointOut &cp) const
 {
     DPRINTF(PL111, "Serializing ARM PL111\n");
 
@@ -633,11 +633,11 @@ Pl111::serialize(std::ostream &os)
         dma_done_event_tick[x] = dmaDoneEventAll[x].scheduled() ?
             dmaDoneEventAll[x].when() : 0;
     }
-    arrayParamOut(os, "dma_done_event_tick", dma_done_event_tick);
+    SERIALIZE_CONTAINER(dma_done_event_tick);
 }
 
 void
-Pl111::unserialize(Checkpoint *cp, const std::string &section)
+Pl111::unserialize(CheckpointIn &cp)
 {
     DPRINTF(PL111, "Unserializing ARM PL111\n");
 
@@ -731,7 +731,7 @@ Pl111::unserialize(Checkpoint *cp, const std::string &section)
 
     vector<Tick> dma_done_event_tick;
     dma_done_event_tick.resize(maxOutstandingDma);
-    arrayParamIn(cp, section, "dma_done_event_tick", dma_done_event_tick);
+    UNSERIALIZE_CONTAINER(dma_done_event_tick);
     dmaDoneEventFree.clear();
     for (int x = 0; x < maxOutstandingDma; x++) {
         if (dma_done_event_tick[x])
diff --git a/src/dev/arm/pl111.hh b/src/dev/arm/pl111.hh
index 85973bbc7..08d9147a4 100644
--- a/src/dev/arm/pl111.hh
+++ b/src/dev/arm/pl111.hh
@@ -371,8 +371,8 @@ class Pl111: public AmbaDmaDevice
     virtual Tick read(PacketPtr pkt);
     virtual Tick write(PacketPtr pkt);
 
-    virtual void serialize(std::ostream &os);
-    virtual void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
     /**
      * Determine the address ranges that this device responds to.
diff --git a/src/dev/arm/rtc_pl031.cc b/src/dev/arm/rtc_pl031.cc
index e619045c2..d5661877c 100644
--- a/src/dev/arm/rtc_pl031.cc
+++ b/src/dev/arm/rtc_pl031.cc
@@ -192,7 +192,7 @@ PL031::counterMatch()
 }
 
 void
-PL031::serialize(std::ostream &os)
+PL031::serialize(CheckpointOut &cp) const
 {
     DPRINTF(Checkpoint, "Serializing Arm PL031\n");
     SERIALIZE_SCALAR(timeVal);
@@ -214,7 +214,7 @@ PL031::serialize(std::ostream &os)
 }
 
 void
-PL031::unserialize(Checkpoint *cp, const std::string &section)
+PL031::unserialize(CheckpointIn &cp)
 {
     DPRINTF(Checkpoint, "Unserializing Arm PL031\n");
 
diff --git a/src/dev/arm/rtc_pl031.hh b/src/dev/arm/rtc_pl031.hh
index 0f1929d29..406857e70 100644
--- a/src/dev/arm/rtc_pl031.hh
+++ b/src/dev/arm/rtc_pl031.hh
@@ -125,9 +125,8 @@ class PL031 : public AmbaIntDevice
      */
     virtual Tick write(PacketPtr pkt);
 
-
-    virtual void serialize(std::ostream &os);
-    virtual void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 };
 
 
diff --git a/src/dev/arm/rv_ctrl.cc b/src/dev/arm/rv_ctrl.cc
index f2b85d513..27ba2e8a6 100644
--- a/src/dev/arm/rv_ctrl.cc
+++ b/src/dev/arm/rv_ctrl.cc
@@ -248,13 +248,13 @@ RealViewCtrl::write(PacketPtr pkt)
 }
 
 void
-RealViewCtrl::serialize(std::ostream &os)
+RealViewCtrl::serialize(CheckpointOut &cp) const
 {
     SERIALIZE_SCALAR(flags);
 }
 
 void
-RealViewCtrl::unserialize(Checkpoint *cp, const std::string &section)
+RealViewCtrl::unserialize(CheckpointIn &cp)
 {
     UNSERIALIZE_SCALAR(flags);
 }
diff --git a/src/dev/arm/rv_ctrl.hh b/src/dev/arm/rv_ctrl.hh
index adf065631..cae5e2e2c 100644
--- a/src/dev/arm/rv_ctrl.hh
+++ b/src/dev/arm/rv_ctrl.hh
@@ -136,9 +136,8 @@ class RealViewCtrl : public BasicPioDevice
      */
     virtual Tick write(PacketPtr pkt);
 
-
-    virtual void serialize(std::ostream &os);
-    virtual void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 };
 
 
diff --git a/src/dev/arm/timer_cpulocal.cc b/src/dev/arm/timer_cpulocal.cc
index de2f99f0a..ac02d099f 100644
--- a/src/dev/arm/timer_cpulocal.cc
+++ b/src/dev/arm/timer_cpulocal.cc
@@ -335,7 +335,7 @@ CpuLocalTimer::Timer::watchdogAtZero()
 }
 
 void
-CpuLocalTimer::Timer::serialize(std::ostream &os)
+CpuLocalTimer::Timer::serialize(CheckpointOut &cp) const
 {
     DPRINTF(Checkpoint, "Serializing Arm CpuLocalTimer\n");
     SERIALIZE_SCALAR(intNumTimer);
@@ -373,7 +373,7 @@ CpuLocalTimer::Timer::serialize(std::ostream &os)
 }
 
 void
-CpuLocalTimer::Timer::unserialize(Checkpoint *cp, const std::string &section)
+CpuLocalTimer::Timer::unserialize(CheckpointIn &cp)
 {
     DPRINTF(Checkpoint, "Unserializing Arm CpuLocalTimer\n");
 
@@ -416,20 +416,17 @@ CpuLocalTimer::Timer::unserialize(Checkpoint *cp, const std::string &section)
 
 
 void
-CpuLocalTimer::serialize(std::ostream &os)
+CpuLocalTimer::serialize(CheckpointOut &cp) const
 {
-    for (int i = 0; i < CPU_MAX; i++) {
-        nameOut(os, csprintf("%s.timer%d", name(), i));
-        localTimer[i].serialize(os);
-    }
+    for (int i = 0; i < CPU_MAX; i++)
+        localTimer[i].serializeSection(cp, csprintf("timer%d", i));
 }
 
 void
-CpuLocalTimer::unserialize(Checkpoint *cp, const std::string &section)
+CpuLocalTimer::unserialize(CheckpointIn &cp)
 {
-    for (int i = 0; i < CPU_MAX; i++) {
-        localTimer[i].unserialize(cp, csprintf("%s.timer%d", section, i));
-    }
+    for (int i = 0; i < CPU_MAX; i++)
+        localTimer[i].unserializeSection(cp, csprintf("timer%d", i));
 }
 
 CpuLocalTimer *
diff --git a/src/dev/arm/timer_cpulocal.hh b/src/dev/arm/timer_cpulocal.hh
index f53f5bc25..73a2d4493 100644
--- a/src/dev/arm/timer_cpulocal.hh
+++ b/src/dev/arm/timer_cpulocal.hh
@@ -55,7 +55,7 @@ class BaseGic;
 class CpuLocalTimer : public BasicPioDevice
 {
   protected:
-    class Timer
+    class Timer : public Serializable
     {
 
       public:
@@ -145,8 +145,8 @@ class CpuLocalTimer : public BasicPioDevice
         /** Handle write for a single timer */
         void write(PacketPtr pkt, Addr daddr);
 
-        void serialize(std::ostream &os);
-        void unserialize(Checkpoint *cp, const std::string &section);
+        void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+        void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
         friend class CpuLocalTimer;
     };
@@ -186,9 +186,8 @@ class CpuLocalTimer : public BasicPioDevice
      */
     virtual Tick write(PacketPtr pkt);
 
-
-    virtual void serialize(std::ostream &os);
-    virtual void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 };
 
 
diff --git a/src/dev/arm/timer_sp804.cc b/src/dev/arm/timer_sp804.cc
index 9f7867107..54a5a2516 100644
--- a/src/dev/arm/timer_sp804.cc
+++ b/src/dev/arm/timer_sp804.cc
@@ -217,7 +217,7 @@ Sp804::Timer::counterAtZero()
 }
 
 void
-Sp804::Timer::serialize(std::ostream &os)
+Sp804::Timer::serialize(CheckpointOut &cp) const
 {
     DPRINTF(Checkpoint, "Serializing Arm Sp804\n");
 
@@ -239,7 +239,7 @@ Sp804::Timer::serialize(std::ostream &os)
 }
 
 void
-Sp804::Timer::unserialize(Checkpoint *cp, const std::string &section)
+Sp804::Timer::unserialize(CheckpointIn &cp)
 {
     DPRINTF(Checkpoint, "Unserializing Arm Sp804\n");
 
@@ -264,19 +264,17 @@ Sp804::Timer::unserialize(Checkpoint *cp, const std::string &section)
 
 
 void
-Sp804::serialize(std::ostream &os)
+Sp804::serialize(CheckpointOut &cp) const
 {
-    nameOut(os, csprintf("%s.timer0", name()));
-    timer0.serialize(os);
-    nameOut(os, csprintf("%s.timer1", name()));
-    timer1.serialize(os);
+    timer0.serializeSection(cp, "timer0");
+    timer1.serializeSection(cp, "timer1");
 }
 
 void
-Sp804::unserialize(Checkpoint *cp, const std::string &section)
+Sp804::unserialize(CheckpointIn &cp)
 {
-    timer0.unserialize(cp, csprintf("%s.timer0", section));
-    timer1.unserialize(cp, csprintf("%s.timer1", section));
+    timer0.unserializeSection(cp, "timer0");
+    timer1.unserializeSection(cp, "timer1");
 }
 
 Sp804 *
diff --git a/src/dev/arm/timer_sp804.hh b/src/dev/arm/timer_sp804.hh
index 03dc20ec1..c5b3bb633 100644
--- a/src/dev/arm/timer_sp804.hh
+++ b/src/dev/arm/timer_sp804.hh
@@ -52,7 +52,7 @@ class BaseGic;
 class Sp804 : public AmbaPioDevice
 {
   protected:
-    class Timer
+    class Timer : public Serializable
     {
 
       public:
@@ -121,9 +121,8 @@ class Sp804 : public AmbaPioDevice
         /** Handle write for a single timer */
         void write(PacketPtr pkt, Addr daddr);
 
-        void serialize(std::ostream &os);
-        void unserialize(Checkpoint *cp, const std::string &section);
-
+        void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+        void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
     };
 
     /** Pointer to the GIC for causing an interrupt */
@@ -161,8 +160,8 @@ class Sp804 : public AmbaPioDevice
     virtual Tick write(PacketPtr pkt);
 
 
-    virtual void serialize(std::ostream &os);
-    virtual void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 };
 
 
diff --git a/src/dev/arm/ufs_device.cc b/src/dev/arm/ufs_device.cc
index d271656cd..02df00e35 100644
--- a/src/dev/arm/ufs_device.cc
+++ b/src/dev/arm/ufs_device.cc
@@ -2283,11 +2283,11 @@ UFSHostDevice::readGarbage()
  */
 
 void
-UFSHostDevice::serialize(std::ostream &os)
+UFSHostDevice::serialize(CheckpointOut &cp) const
 {
-    DmaDevice::serialize(os);
+    DmaDevice::serialize(cp);
 
-    uint8_t* temp_HCI_mem = reinterpret_cast<uint8_t*>(&UFSHCIMem);
+    const uint8_t* temp_HCI_mem = reinterpret_cast<const uint8_t*>(&UFSHCIMem);
     SERIALIZE_ARRAY(temp_HCI_mem, sizeof(HCIMem));
 
     uint32_t lun_avail = lunAvail;
@@ -2300,9 +2300,9 @@ UFSHostDevice::serialize(std::ostream &os)
  */
 
 void
-UFSHostDevice::unserialize(Checkpoint *cp, const std::string &section)
+UFSHostDevice::unserialize(CheckpointIn &cp)
 {
-    DmaDevice::unserialize(cp, section);
+    DmaDevice::unserialize(cp);
     uint8_t* temp_HCI_mem = reinterpret_cast<uint8_t*>(&UFSHCIMem);
     UNSERIALIZE_ARRAY(temp_HCI_mem, sizeof(HCIMem));
 
diff --git a/src/dev/arm/ufs_device.hh b/src/dev/arm/ufs_device.hh
index 07f038175..15e983ad8 100644
--- a/src/dev/arm/ufs_device.hh
+++ b/src/dev/arm/ufs_device.hh
@@ -175,8 +175,8 @@ class UFSHostDevice : public DmaDevice
 
     unsigned int drain(DrainManager *dm);
     void checkDrain();
-    void serialize(std::ostream &os);
-    void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
   private:
     /**
diff --git a/src/dev/arm/vgic.cc b/src/dev/arm/vgic.cc
index 4a63c796a..f4a3e8c3f 100644
--- a/src/dev/arm/vgic.cc
+++ b/src/dev/arm/vgic.cc
@@ -56,9 +56,6 @@ VGic::VGic(const Params *p)
         maintIntPosted[x] = false;
         vIntPosted[x] = false;
     }
-    for (int c = 0; c < VGIC_CPU_MAX; c++) {
-        memset(&vcpuData[c], 0, sizeof(struct vcpuIntData));
-    }
     assert(sys->numRunningContexts() <= VGIC_CPU_MAX);
 }
 
@@ -437,7 +434,7 @@ VGic::getAddrRanges() const
 }
 
 void
-VGic::serialize(std::ostream &os)
+VGic::serialize(CheckpointOut &cp) const
 {
     Tick interrupt_time[VGIC_CPU_MAX];
     for (uint32_t cpu = 0; cpu < VGIC_CPU_MAX; cpu++) {
@@ -457,42 +454,45 @@ VGic::serialize(std::ostream &os)
     SERIALIZE_SCALAR(pioDelay);
     SERIALIZE_SCALAR(maintInt);
 
-    for (uint32_t cpu = 0; cpu < VGIC_CPU_MAX; cpu++) {
-        nameOut(os, csprintf("%s.vcpuData%d", name(), cpu));
-        uint32_t vctrl_val = vcpuData[cpu].vctrl;
-        SERIALIZE_SCALAR(vctrl_val);
-        uint32_t hcr_val = vcpuData[cpu].hcr;
-        SERIALIZE_SCALAR(hcr_val);
-        uint64_t eisr_val = vcpuData[cpu].eisr;
-        SERIALIZE_SCALAR(eisr_val);
-        uint8_t VMGrp0En_val = vcpuData[cpu].VMGrp0En;
-        SERIALIZE_SCALAR(VMGrp0En_val);
-        uint8_t VMGrp1En_val = vcpuData[cpu].VMGrp1En;
-        SERIALIZE_SCALAR(VMGrp1En_val);
-        uint8_t VMAckCtl_val = vcpuData[cpu].VMAckCtl;
-        SERIALIZE_SCALAR(VMAckCtl_val);
-        uint8_t VMFiqEn_val = vcpuData[cpu].VMFiqEn;
-        SERIALIZE_SCALAR(VMFiqEn_val);
-        uint8_t VMCBPR_val = vcpuData[cpu].VMCBPR;
-        SERIALIZE_SCALAR(VMCBPR_val);
-        uint8_t VEM_val = vcpuData[cpu].VEM;
-        SERIALIZE_SCALAR(VEM_val);
-        uint8_t VMABP_val = vcpuData[cpu].VMABP;
-        SERIALIZE_SCALAR(VMABP_val);
-        uint8_t VMBP_val = vcpuData[cpu].VMBP;
-        SERIALIZE_SCALAR(VMBP_val);
-        uint8_t VMPriMask_val = vcpuData[cpu].VMPriMask;
-        SERIALIZE_SCALAR(VMPriMask_val);
-
-        for (int i = 0; i < NUM_LR; i++) {
-            uint32_t lr = vcpuData[cpu].LR[i];
-            nameOut(os, csprintf("%s.vcpuData%d.LR%d", name(), cpu, i));
-            SERIALIZE_SCALAR(lr);
-        }
+    for (uint32_t cpu = 0; cpu < VGIC_CPU_MAX; cpu++)
+        vcpuData[cpu].serializeSection(cp, csprintf("vcpuData%d", cpu));
+}
+
+void
+VGic::vcpuIntData::serialize(CheckpointOut &cp) const
+{
+    uint32_t vctrl_val = vctrl;
+    SERIALIZE_SCALAR(vctrl_val);
+    uint32_t hcr_val = hcr;
+    SERIALIZE_SCALAR(hcr_val);
+    uint64_t eisr_val = eisr;
+    SERIALIZE_SCALAR(eisr_val);
+    uint8_t VMGrp0En_val = VMGrp0En;
+    SERIALIZE_SCALAR(VMGrp0En_val);
+    uint8_t VMGrp1En_val = VMGrp1En;
+    SERIALIZE_SCALAR(VMGrp1En_val);
+    uint8_t VMAckCtl_val = VMAckCtl;
+    SERIALIZE_SCALAR(VMAckCtl_val);
+    uint8_t VMFiqEn_val = VMFiqEn;
+    SERIALIZE_SCALAR(VMFiqEn_val);
+    uint8_t VMCBPR_val = VMCBPR;
+    SERIALIZE_SCALAR(VMCBPR_val);
+    uint8_t VEM_val = VEM;
+    SERIALIZE_SCALAR(VEM_val);
+    uint8_t VMABP_val = VMABP;
+    SERIALIZE_SCALAR(VMABP_val);
+    uint8_t VMBP_val = VMBP;
+    SERIALIZE_SCALAR(VMBP_val);
+    uint8_t VMPriMask_val = VMPriMask;
+    SERIALIZE_SCALAR(VMPriMask_val);
+
+    for (int i = 0; i < NUM_LR; i++) {
+        ScopedCheckpointSection sec_lr(cp, csprintf("LR%d", i));
+        paramOut(cp, "lr", LR[i]);
     }
 }
 
-void VGic::unserialize(Checkpoint *cp, const std::string &section)
+void VGic::unserialize(CheckpointIn &cp)
 {
     DPRINTF(Checkpoint, "Unserializing Arm GIC\n");
 
@@ -502,37 +502,7 @@ void VGic::unserialize(Checkpoint *cp, const std::string &section)
         if (interrupt_time[cpu])
             schedule(postVIntEvent[cpu], interrupt_time[cpu]);
 
-        uint32_t tmp;
-        paramIn(cp, csprintf("%s.vcpuData%d", section, cpu),
-                "vctrl_val", tmp);
-        vcpuData[cpu].vctrl = tmp;
-        paramIn(cp, csprintf("%s.vcpuData%d", section, cpu),
-                "hcr_val", tmp);
-        vcpuData[cpu].hcr = tmp;
-        paramIn(cp, csprintf("%s.vcpuData%d", section, cpu),
-                "eisr_val", vcpuData[cpu].eisr);
-        paramIn(cp, csprintf("%s.vcpuData%d", section, cpu),
-                "VMGrp0En_val", vcpuData[cpu].VMGrp0En);
-        paramIn(cp, csprintf("%s.vcpuData%d", section, cpu),
-                "VMGrp1En_val", vcpuData[cpu].VMGrp1En);
-        paramIn(cp, csprintf("%s.vcpuData%d", section, cpu),
-                "VMAckCtl_val", vcpuData[cpu].VMAckCtl);
-        paramIn(cp, csprintf("%s.vcpuData%d", section, cpu),
-                "VMFiqEn_val", vcpuData[cpu].VMFiqEn);
-        paramIn(cp, csprintf("%s.vcpuData%d", section, cpu),
-                "VMCBPR_val", vcpuData[cpu].VMCBPR);
-        paramIn(cp, csprintf("%s.vcpuData%d", section, cpu),
-                "VEM_val", vcpuData[cpu].VEM);
-        paramIn(cp, csprintf("%s.vcpuData%d", section, cpu),
-                "VMABP_val", vcpuData[cpu].VMABP);
-        paramIn(cp, csprintf("%s.vcpuData%d", section, cpu),
-                "VMPriMask_val", vcpuData[cpu].VMPriMask);
-
-        for (int i = 0; i < NUM_LR; i++) {
-            paramIn(cp, csprintf("%s.vcpuData%d.LR%d", section, cpu, i),
-                    "lr", tmp);
-            vcpuData[cpu].LR[i] = tmp;
-        }
+        vcpuData[cpu].unserializeSection(cp, csprintf("vcpuData%d", cpu));
     }
     UNSERIALIZE_ARRAY(maintIntPosted, VGIC_CPU_MAX);
     UNSERIALIZE_ARRAY(vIntPosted, VGIC_CPU_MAX);
@@ -542,6 +512,27 @@ void VGic::unserialize(Checkpoint *cp, const std::string &section)
     UNSERIALIZE_SCALAR(maintInt);
 }
 
+void
+VGic::vcpuIntData::unserialize(CheckpointIn &cp)
+{
+    paramIn(cp, "vctrl_val", vctrl);
+    paramIn(cp, "hcr_val", hcr);
+    paramIn(cp, "eisr_val", eisr);
+    paramIn(cp, "VMGrp0En_val", VMGrp0En);
+    paramIn(cp, "VMGrp1En_val", VMGrp1En);
+    paramIn(cp, "VMAckCtl_val", VMAckCtl);
+    paramIn(cp, "VMFiqEn_val", VMFiqEn);
+    paramIn(cp, "VMCBPR_val", VMCBPR);
+    paramIn(cp, "VEM_val", VEM);
+    paramIn(cp, "VMABP_val", VMABP);
+    paramIn(cp, "VMPriMask_val", VMPriMask);
+
+    for (int i = 0; i < NUM_LR; i++) {
+        ScopedCheckpointSection sec_lr(cp, csprintf("LR%d", i));
+        paramIn(cp, "lr", LR[i]);
+    }
+}
+
 VGic *
 VGicParams::create()
 {
diff --git a/src/dev/arm/vgic.hh b/src/dev/arm/vgic.hh
index e1c4960e9..ac88f842f 100644
--- a/src/dev/arm/vgic.hh
+++ b/src/dev/arm/vgic.hh
@@ -52,6 +52,9 @@
 #ifndef __DEV_ARM_VGIC_H__
 #define __DEV_ARM_VGIC_H__
 
+#include <algorithm>
+#include <array>
+
 #include "base/addr_range.hh"
 #include "base/bitunion.hh"
 #include "cpu/intr_control.hh"
@@ -162,8 +165,17 @@ class VGic : public PioDevice
     /* State per CPU.  EVERYTHING should be in this struct and simply replicated
      * N times.
      */
-    struct vcpuIntData {
-        ListReg LR[NUM_LR];
+    struct vcpuIntData : public Serializable {
+        vcpuIntData()
+            : vctrl(0), hcr(0), eisr(0), VMGrp0En(0), VMGrp1En(0),
+              VMAckCtl(0), VMFiqEn(0), VMCBPR(0), VEM(0), VMABP(0), VMBP(0),
+              VMPriMask(0)
+        {
+            std::fill(LR.begin(), LR.end(), 0);
+        }
+        virtual ~vcpuIntData() {}
+
+        std::array<ListReg, NUM_LR> LR;
         VCTLR vctrl;
 
         HCR hcr;
@@ -179,9 +191,12 @@ class VGic : public PioDevice
         uint8_t VMABP;
         uint8_t VMBP;
         uint8_t VMPriMask;
+
+        void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+        void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
     };
 
-    struct vcpuIntData vcpuData[VGIC_CPU_MAX];
+    struct std::array<vcpuIntData, VGIC_CPU_MAX>  vcpuData;
 
   public:
    typedef VGicParams Params;
@@ -197,8 +212,8 @@ class VGic : public PioDevice
     virtual Tick read(PacketPtr pkt);
     virtual Tick write(PacketPtr pkt);
 
-    virtual void serialize(std::ostream &os);
-    virtual void unserialize(Checkpoint *cp, const std::string &section);
+    void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
+    void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
 
   private:
     Tick readVCpu(PacketPtr pkt);