}
} // namespace FastModel
-
-FastModel::CortexA76 *
-FastModelCortexA76Params::create() const
-{
- return new FastModel::CortexA76(*this);
-}
-
-FastModel::CortexA76Cluster *
-FastModelCortexA76ClusterParams::create() const
-{
- return new FastModel::CortexA76Cluster(*this);
-}
template class ScxEvsCortexA76<ScxEvsCortexA76x4Types>;
} // namespace FastModel
-
-FastModel::ScxEvsCortexA76x1 *
-FastModelScxEvsCortexA76x1Params::create() const
-{
- return new FastModel::ScxEvsCortexA76x1(name.c_str(), *this);
-}
-
-FastModel::ScxEvsCortexA76x2 *
-FastModelScxEvsCortexA76x2Params::create() const
-{
- return new FastModel::ScxEvsCortexA76x2(name.c_str(), *this);
-}
-
-FastModel::ScxEvsCortexA76x3 *
-FastModelScxEvsCortexA76x3Params::create() const
-{
- return new FastModel::ScxEvsCortexA76x3(name.c_str(), *this);
-}
-
-FastModel::ScxEvsCortexA76x4 *
-FastModelScxEvsCortexA76x4Params::create() const
-{
- return new FastModel::ScxEvsCortexA76x4(name.c_str(), *this);
-}
const Params ¶ms;
public:
+ ScxEvsCortexA76(const Params &p) : ScxEvsCortexA76(p.name.c_str(), p) {}
ScxEvsCortexA76(const sc_core::sc_module_name &mod_name, const Params &p);
void before_end_of_elaboration() override;
}
} // namespace FastModel
-
-FastModel::CortexR52 *
-FastModelCortexR52Params::create() const
-{
- return new FastModel::CortexR52(*this);
-}
-
-FastModel::CortexR52Cluster *
-FastModelCortexR52ClusterParams::create() const
-{
- return new FastModel::CortexR52Cluster(*this);
-}
template class ScxEvsCortexR52<ScxEvsCortexR52x4Types>;
} // namespace FastModel
-
-FastModel::ScxEvsCortexR52x1 *
-FastModelScxEvsCortexR52x1Params::create() const
-{
- return new FastModel::ScxEvsCortexR52x1(name.c_str(), *this);
-}
-
-FastModel::ScxEvsCortexR52x2 *
-FastModelScxEvsCortexR52x2Params::create() const
-{
- return new FastModel::ScxEvsCortexR52x2(name.c_str(), *this);
-}
-
-FastModel::ScxEvsCortexR52x3 *
-FastModelScxEvsCortexR52x3Params::create() const
-{
- return new FastModel::ScxEvsCortexR52x3(name.c_str(), *this);
-}
-
-FastModel::ScxEvsCortexR52x4 *
-FastModelScxEvsCortexR52x4Params::create() const
-{
- return new FastModel::ScxEvsCortexR52x4(name.c_str(), *this);
-}
const Params ¶ms;
public:
+ ScxEvsCortexR52(const Params &p) : ScxEvsCortexR52(p.name.c_str(), p) {}
ScxEvsCortexR52(const sc_core::sc_module_name &mod_name, const Params &p);
void
}
} // namespace FastModel
-
-FastModel::SCGIC *
-SCFastModelGICParams::create() const
-{
- return new FastModel::SCGIC(*this, name.c_str());
-}
-
-FastModel::GIC *
-FastModelGICParams::create() const
-{
- return new FastModel::GIC(*this);
-}
const SCFastModelGICParams &_params;
public:
+ SCGIC(const SCFastModelGICParams &p) : SCGIC(p, p.name.c_str()) {}
SCGIC(const SCFastModelGICParams ¶ms, sc_core::sc_module_name _name);
SignalInterruptInitiatorSocket signalInterrupt;
Source('cpu.cc')
Source('interrupts.cc')
Source('isa.cc')
-Source('mmu.cc')
Source('tlb.cc')
Source('thread_context.cc')
Iris::Interrupts::unserialize(CheckpointIn &cp)
{
}
-
-Iris::Interrupts *
-IrisInterruptsParams::create() const
-{
- return new Iris::Interrupts(*this);
-}
miscRegs[i] = tc->readMiscRegNoEffect(i);
SERIALIZE_ARRAY(miscRegs, ArmISA::NUM_PHYS_MISCREGS);
}
-
-Iris::ISA *
-IrisISAParams::create() const
-{
- return new Iris::ISA(*this);
-}
+++ /dev/null
-/*
- * Copyright (c) 2020 ARM Limited
- * All rights reserved
- *
- * The license below extends only to copyright in the software and shall
- * not be construed as granting a license to any other intellectual
- * property including but not limited to intellectual property relating
- * to a hardware implementation of the functionality of the software
- * licensed hereunder. You may use the software subject to the license
- * terms below provided that you ensure that this notice is replicated
- * unmodified and in its entirety in all distributions of the software,
- * modified or unmodified, in source code or in binary form.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "arch/arm/fastmodel/iris/mmu.hh"
-
-Iris::MMU *
-IrisMMUParams::create() const
-{
- return new Iris::MMU(*this);
-}
assert(translation);
translation->finish(translateAtomic(req, tc, mode), req, tc, mode);
}
-
-Iris::TLB *
-IrisTLBParams::create() const
-{
- return new Iris::TLB(*this);
-}
}
} // namespace ArmISA
-
-ArmISA::FsFreebsd *
-ArmFsFreebsdParams::create() const
-{
- return new ArmISA::FsFreebsd(*this);
-}
}
} // namespace ArmISA
-
-ArmISA::EmuFreebsd *
-ArmEmuFreebsdParams::create() const
-{
- return new ArmISA::EmuFreebsd(*this);
-}
}
} // namespace ArmISA
-
-ArmISA::FsWorkload *
-ArmFsWorkloadParams::create() const
-{
- return new ArmISA::FsWorkload(*this);
-}
#include "arch/arm/system.hh"
-ArmISA::Interrupts *
-ArmInterruptsParams::create() const
-{
- return new ArmISA::Interrupts(*this);
-}
-
bool
ArmISA::Interrupts::takeInt(InterruptTypes int_type) const
{
}
} // namespace ArmISA
-
-ArmISA::ISA *
-ArmISAParams::create() const
-{
- return new ArmISA::ISA(*this);
-}
warn("Unhandled VFP register: 0x%x\n", id);
}
}
-
-ArmKvmCPU *
-ArmKvmCPUParams::create() const
-{
- return new ArmKvmCPU(*this);
-}
return sysRegMap;
}
-
-ArmV8KvmCPU *
-ArmV8KvmCPUParams::create() const
-{
- return new ArmV8KvmCPU(*this);
-}
assert((cpuPriority[cpu] & ~0xff) == 0);
}
}
-
-MuxingKvmGic *
-MuxingKvmGicParams::create() const
-{
- return new MuxingKvmGic(*this);
-}
}
} // namespace ArmISA
-
-ArmISA::FsLinux *
-ArmFsLinuxParams::create() const
-{
- return new ArmISA::FsLinux(*this);
-}
}
} // namespace ArmISA
-
-ArmISA::EmuLinux *
-ArmEmuLinuxParams::create() const
-{
- return new ArmISA::EmuLinux(*this);
-}
getDTBPtr()->invalidateMiscReg();
}
}
-
-ArmISA::MMU *
-ArmMMUParams::create() const
-{
- return new ArmISA::MMU(*this);
-}
}
} // namespace Trace
-
-////////////////////////////////////////////////////////////////////////
-//
-// ExeTracer Simulation Object
-//
-Trace::ArmNativeTrace *
-ArmNativeTraceParams::create() const
-{
- return new Trace::ArmNativeTrace(*this);
-}
}
} // namespace ArmISA
-
-ArmISA::PMU *
-ArmPMUParams::create() const
-{
- return new ArmISA::PMU(*this);
-}
ccprintf(os, "[%#x-%#x)", ipa.addr, ipa.addr + ipa.size - 1);
return os;
}
-
-
-ArmSemihosting *
-ArmSemihostingParams::create() const
-{
- return new ArmSemihosting(*this);
-}
event->process();
}
}
-
-ArmISA::Stage2MMU *
-ArmStage2MMUParams::create() const
-{
- return new ArmISA::Stage2MMU(*this);
-}
if (FVPBasePwrCtrl *pwr_ctrl = getArmSystem(tc)->getPowerController())
pwr_ctrl->clearWakeRequest(tc);
}
-
-ArmSystem *
-ArmSystemParams::create() const
-{
- return new ArmSystem(*this);
-}
}
}
-ArmISA::TableWalker *
-ArmTableWalkerParams::create() const
-{
- return new ArmISA::TableWalker(*this);
-}
-
LookupLevel
TableWalker::toLookupLevel(uint8_t lookup_level_as_int)
{
domain, lookup_level);
}
}
-
-
-ArmISA::TLB *
-ArmTLBParams::create() const
-{
- return new ArmISA::TLB(*this);
-}
}
} // namespace Trace
-
-Trace::TarmacParser *
-TarmacParserParams::create() const
-{
- return new Trace::TarmacParser(*this);
-}
}
} // namespace Trace
-
-Trace::TarmacTracer *
-TarmacTracerParams::create() const
-{
- return new Trace::TarmacTracer(*this);
-}
Source('isa.cc')
Source('linux/linux.cc')
Source('linux/se_workload.cc')
- Source('mmu.cc')
Source('pagetable.cc')
Source('process.cc')
Source('remote_gdb.cc')
}
}
-
-MipsISA::Interrupts *
-MipsInterruptsParams::create() const
-{
- return new MipsISA::Interrupts(*this);
-}
}
}
-
-MipsISA::ISA *
-MipsISAParams::create() const
-{
- return new MipsISA::ISA(*this);
-}
};
} // namespace MipsISA
-
-MipsISA::EmuLinux *
-MipsEmuLinuxParams::create() const
-{
- return new MipsISA::EmuLinux(*this);
-}
+++ /dev/null
-/*
- * Copyright (c) 2020 ARM Limited
- * All rights reserved
- *
- * The license below extends only to copyright in the software and shall
- * not be construed as granting a license to any other intellectual
- * property including but not limited to intellectual property relating
- * to a hardware implementation of the functionality of the software
- * licensed hereunder. You may use the software subject to the license
- * terms below provided that you ensure that this notice is replicated
- * unmodified and in its entirety in all distributions of the software,
- * modified or unmodified, in source code or in binary form.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "arch/mips/mmu.hh"
-
-MipsISA::MMU *
-MipsMMUParams::create() const
-{
- return new MipsISA::MMU(*this);
-}
return *pte;
}
-
-MipsISA::TLB *
-MipsTLBParams::create() const
-{
- return new MipsISA::TLB(*this);
-}
Source('insts/floating.cc')
Source('insts/condition.cc')
Source('insts/static_inst.cc')
- Source('interrupts.cc')
Source('linux/linux.cc')
Source('linux/se_workload.cc')
- Source('mmu.cc')
Source('isa.cc')
Source('pagetable.cc')
Source('process.cc')
+++ /dev/null
-/*
- * Copyright (c) 2011 Google
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "arch/power/interrupts.hh"
-
-PowerISA::Interrupts *
-PowerInterruptsParams::create() const
-{
- return new PowerISA::Interrupts(*this);
-}
}
}
-
-PowerISA::ISA *
-PowerISAParams::create() const
-{
- return new PowerISA::ISA(*this);
-}
-
};
} // namespace PowerISA
-
-PowerISA::EmuLinux *
-PowerEmuLinuxParams::create() const
-{
- return new PowerISA::EmuLinux(*this);
-}
+++ /dev/null
-/*
- * Copyright (c) 2020 ARM Limited
- * All rights reserved
- *
- * The license below extends only to copyright in the software and shall
- * not be construed as granting a license to any other intellectual
- * property including but not limited to intellectual property relating
- * to a hardware implementation of the functionality of the software
- * licensed hereunder. You may use the software subject to the license
- * terms below provided that you ensure that this notice is replicated
- * unmodified and in its entirety in all distributions of the software,
- * modified or unmodified, in source code or in binary form.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "arch/power/mmu.hh"
-
-PowerISA::MMU *
-PowerMMUParams::create() const
-{
- return new PowerISA::MMU(*this);
-}
return *pte;
}
-
-PowerISA::TLB *
-PowerTLBParams::create() const
-{
- return new PowerISA::TLB(*this);
-}
Source('decoder.cc')
Source('faults.cc')
Source('isa.cc')
- Source('interrupts.cc')
Source('locked_mem.cc')
- Source('mmu.cc')
Source('process.cc')
Source('pagetable.cc')
Source('pagetable_walker.cc')
}
} // namespace RiscvISA
-
-RiscvISA::BareMetal *
-RiscvBareMetalParams::create() const
-{
- return new RiscvISA::BareMetal(*this);
-}
+++ /dev/null
-/*
- * Copyright (c) 2011 Google
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "arch/riscv/interrupts.hh"
-
-RiscvISA::Interrupts *
-RiscvInterruptsParams::create() const
-{
- return new RiscvISA::Interrupts(*this);
-}
}
}
-
-RiscvISA::ISA *
-RiscvISAParams::create() const
-{
- return new RiscvISA::ISA(*this);
-}
};
} // namespace RiscvISA
-
-RiscvISA::EmuLinux *
-RiscvEmuLinuxParams::create() const
-{
- return new RiscvISA::EmuLinux(*this);
-}
+++ /dev/null
-/*
- * Copyright (c) 2020 ARM Limited
- * All rights reserved
- *
- * The license below extends only to copyright in the software and shall
- * not be construed as granting a license to any other intellectual
- * property including but not limited to intellectual property relating
- * to a hardware implementation of the functionality of the software
- * licensed hereunder. You may use the software subject to the license
- * terms below provided that you ensure that this notice is replicated
- * unmodified and in its entirety in all distributions of the software,
- * modified or unmodified, in source code or in binary form.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "arch/riscv/mmu.hh"
-
-RiscvISA::MMU *
-RiscvMMUParams::create() const
-{
- return new RiscvISA::MMU(*this);
-}
}
} /* end namespace RiscvISA */
-
-RiscvISA::Walker *
-RiscvPagetableWalkerParams::create() const
-{
- return new RiscvISA::Walker(*this);
-}
read_accesses + write_accesses)
{
}
-
-RiscvISA::TLB *
-RiscvTLBParams::create() const
-{
- return new TLB(*this);
-}
Source('decoder.cc')
Source('faults.cc')
Source('fs_workload.cc')
- Source('interrupts.cc')
Source('isa.cc')
Source('linux/linux.cc')
Source('linux/se_workload.cc')
Source('linux/syscalls.cc')
- Source('mmu.cc')
Source('nativetrace.cc')
Source('pagetable.cc')
Source('process.cc')
}
} // namespace SparcISA
-
-SparcISA::FsWorkload *
-SparcFsWorkloadParams::create() const
-{
- return new SparcISA::FsWorkload(*this);
-}
+++ /dev/null
-/*
- * Copyright (c) 2008 The Regents of The University of Michigan
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "arch/sparc/interrupts.hh"
-
-SparcISA::Interrupts *
-SparcInterruptsParams::create() const
-{
- return new SparcISA::Interrupts(*this);
-}
}
}
-
-SparcISA::ISA *
-SparcISAParams::create() const
-{
- return new SparcISA::ISA(*this);
-}
}
} // namespace SparcISA
-
-SparcISA::EmuLinux *
-SparcEmuLinuxParams::create() const
-{
- return new SparcISA::EmuLinux(*this);
-}
+++ /dev/null
-/*
- * Copyright (c) 2020 ARM Limited
- * All rights reserved
- *
- * The license below extends only to copyright in the software and shall
- * not be construed as granting a license to any other intellectual
- * property including but not limited to intellectual property relating
- * to a hardware implementation of the functionality of the software
- * licensed hereunder. You may use the software subject to the license
- * terms below provided that you ensure that this notice is replicated
- * unmodified and in its entirety in all distributions of the software,
- * modified or unmodified, in source code or in binary form.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "arch/sparc/mmu.hh"
-
-SparcISA::MMU *
-SparcMMUParams::create() const
-{
- return new SparcISA::MMU(*this);
-}
}
} // namespace Trace
-
-////////////////////////////////////////////////////////////////////////
-//
-// ExeTracer Simulation Object
-//
-Trace::SparcNativeTrace *
-SparcNativeTraceParams::create() const
-{
- return new Trace::SparcNativeTrace(*this);
-};
}
} // namespace SparcISA
-
-SparcISA::TLB *
-SparcTLBParams::create() const
-{
- return new SparcISA::TLB(*this);
-}
Source('insts/static_inst.cc')
Source('interrupts.cc')
Source('isa.cc')
-Source('mmu.cc')
Source('nativetrace.cc')
Source('pagetable.cc')
Source('pagetable_walker.cc')
X86ISA::ACPI::XSDT::XSDT(const Params &p) :
SysDescTable(p, "XSDT", 1), entries(p.entries)
{}
-
-X86ISA::ACPI::RSDP *
-X86ACPIRSDPParams::create() const
-{
- return new X86ISA::ACPI::RSDP(*this);
-}
-
-X86ISA::ACPI::RSDT *
-X86ACPIRSDTParams::create() const
-{
- return new X86ISA::ACPI::RSDT(*this);
-}
-
-X86ISA::ACPI::XSDT *
-X86ACPIXSDTParams::create() const
-{
- return new X86ISA::ACPI::XSDT(*this);
-}
writeVal(entries[i]->type, proxy, addr);
}
}
-
-E820Table *
-X86E820TableParams::create() const
-{
- return new E820Table(*this);
-}
-
-E820Entry *
-X86E820EntryParams::create() const
-{
- return new E820Entry(*this);
-}
defaultConfig(p.default_config), imcrPresent(p.imcr_present)
{}
-X86ISA::IntelMP::FloatingPointer *
-X86IntelMPFloatingPointerParams::create() const
-{
- return new X86ISA::IntelMP::FloatingPointer(*this);
-}
-
Addr
X86ISA::IntelMP::BaseConfigEntry::writeOut(PortProxy& proxy,
Addr addr, uint8_t &checkSum)
baseEntries(p.base_entries), extEntries(p.ext_entries)
{}
-X86ISA::IntelMP::ConfigTable *
-X86IntelMPConfigTableParams::create() const
-{
- return new X86ISA::IntelMP::ConfigTable(*this);
-}
-
Addr
X86ISA::IntelMP::Processor::writeOut(
PortProxy& proxy, Addr addr, uint8_t &checkSum)
replaceBits(cpuSignature, 11, 8, p.family);
}
-X86ISA::IntelMP::Processor *
-X86IntelMPProcessorParams::create() const
-{
- return new X86ISA::IntelMP::Processor(*this);
-}
-
Addr
X86ISA::IntelMP::Bus::writeOut(
PortProxy& proxy, Addr addr, uint8_t &checkSum)
busID(p.bus_id), busType(p.bus_type)
{}
-X86ISA::IntelMP::Bus *
-X86IntelMPBusParams::create() const
-{
- return new X86ISA::IntelMP::Bus(*this);
-}
-
Addr
X86ISA::IntelMP::IOAPIC::writeOut(
PortProxy& proxy, Addr addr, uint8_t &checkSum)
flags |= 1;
}
-X86ISA::IntelMP::IOAPIC *
-X86IntelMPIOAPICParams::create() const
-{
- return new X86ISA::IntelMP::IOAPIC(*this);
-}
-
Addr
X86ISA::IntelMP::IntAssignment::writeOut(
PortProxy& proxy, Addr addr, uint8_t &checkSum)
p.dest_io_apic_id, p.dest_io_apic_intin)
{}
-X86ISA::IntelMP::IOIntAssignment *
-X86IntelMPIOIntAssignmentParams::create() const
-{
- return new X86ISA::IntelMP::IOIntAssignment(*this);
-}
-
X86ISA::IntelMP::LocalIntAssignment::LocalIntAssignment(const Params &p) :
IntAssignment(p, p.interrupt_type, p.polarity, p.trigger, 4,
p.source_bus_id, p.source_bus_irq,
p.dest_local_apic_id, p.dest_local_apic_intin)
{}
-X86ISA::IntelMP::LocalIntAssignment *
-X86IntelMPLocalIntAssignmentParams::create() const
-{
- return new X86ISA::IntelMP::LocalIntAssignment(*this);
-}
-
Addr
X86ISA::IntelMP::AddrSpaceMapping::writeOut(
PortProxy& proxy, Addr addr, uint8_t &checkSum)
addr(p.address), addrLength(p.length)
{}
-X86ISA::IntelMP::AddrSpaceMapping *
-X86IntelMPAddrSpaceMappingParams::create() const
-{
- return new X86ISA::IntelMP::AddrSpaceMapping(*this);
-}
-
Addr
X86ISA::IntelMP::BusHierarchy::writeOut(
PortProxy& proxy, Addr addr, uint8_t &checkSum)
info |= 1;
}
-X86ISA::IntelMP::BusHierarchy *
-X86IntelMPBusHierarchyParams::create() const
-{
- return new X86ISA::IntelMP::BusHierarchy(*this);
-}
-
Addr
X86ISA::IntelMP::CompatAddrSpaceMod::writeOut(
PortProxy& proxy, Addr addr, uint8_t &checkSum)
if (p.add)
mod |= 1;
}
-
-X86ISA::IntelMP::CompatAddrSpaceMod *
-X86IntelMPCompatAddrSpaceModParams::create() const
-{
- return new X86ISA::IntelMP::CompatAddrSpaceMod(*this);
-}
intChecksum = -intChecksum;
proxy.writeBlob(addr + 0x15, &intChecksum, 1);
}
-
-X86ISA::SMBios::BiosInformation *
-X86SMBiosBiosInformationParams::create() const
-{
- return new X86ISA::SMBios::BiosInformation(*this);
-}
-
-X86ISA::SMBios::SMBiosTable *
-X86SMBiosSMBiosTableParams::create() const
-{
- return new X86ISA::SMBios::SMBiosTable(*this);
-}
}
} // namespace X86ISA
-
-X86ISA::FsWorkload *
-X86FsWorkloadParams::create() const
-{
- return new X86ISA::FsWorkload(*this);
-}
}
}
-X86ISA::Interrupts *
-X86LocalApicParams::create() const
-{
- return new X86ISA::Interrupts(*this);
-}
-
void
X86ISA::Interrupts::processApicTimerEvent()
{
}
}
-
-X86ISA::ISA *
-X86ISAParams::create() const
-{
- return new X86ISA::ISA(*this);
-}
}
} // namespace X86ISA
-
-X86ISA::FsLinux *
-X86FsLinuxParams::create() const
-{
- return new X86ISA::FsLinux(*this);
-}
}
} // namespace X86ISA
-
-X86ISA::EmuLinux *
-X86EmuLinuxParams::create() const
-{
- return new X86ISA::EmuLinux(*this);
-}
+++ /dev/null
-/*
- * Copyright (c) 2020 ARM Limited
- * All rights reserved
- *
- * The license below extends only to copyright in the software and shall
- * not be construed as granting a license to any other intellectual
- * property including but not limited to intellectual property relating
- * to a hardware implementation of the functionality of the software
- * licensed hereunder. You may use the software subject to the license
- * terms below provided that you ensure that this notice is replicated
- * unmodified and in its entirety in all distributions of the software,
- * modified or unmodified, in source code or in binary form.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "arch/x86/mmu.hh"
-
-X86ISA::MMU *
-X86MMUParams::create() const
-{
- return new X86ISA::MMU(*this);
-}
}
} // namespace Trace
-
-////////////////////////////////////////////////////////////////////////
-//
-// ExeTracer Simulation Object
-//
-Trace::X86NativeTrace *
-X86NativeTraceParams::create() const
-{
- return new Trace::X86NativeTrace(*this);
-}
}
/* end namespace X86ISA */ }
-
-X86ISA::Walker *
-X86PagetableWalkerParams::create() const
-{
- return new X86ISA::Walker(*this);
-}
}
} // namespace X86ISA
-
-X86ISA::TLB *
-X86TLBParams::create() const
-{
- return new X86ISA::TLB(*this);
-}
}
} // namespace BloomFilter
-
-BloomFilter::Block*
-BloomFilterBlockParams::create() const
-{
- return new BloomFilter::Block(*this);
-}
-
}
} // namespace BloomFilter
-
-BloomFilter::Bulk*
-BloomFilterBulkParams::create() const
-{
- return new BloomFilter::Bulk(*this);
-}
-
}
} // namespace BloomFilter
-
-BloomFilter::H3*
-BloomFilterH3Params::create() const
-{
- return new BloomFilter::H3(*this);
-}
-
} // namespace BloomFilter
-BloomFilter::MultiBitSel*
-BloomFilterMultiBitSelParams::create() const
-{
- return new BloomFilter::MultiBitSel(*this);
-}
-
}
} // namespace BloomFilter
-
-BloomFilter::Multi*
-BloomFilterMultiParams::create() const
-{
- return new BloomFilter::Multi(*this);
-}
-
}
} // namespace BloomFilter
-
-BloomFilter::Perfect*
-BloomFilterPerfectParams::create() const
-{
- return new BloomFilter::Perfect(*this);
-}
-
++captureCurrentFrame;
}
-
-// create the VNC Replayer object
-VncInput *
-VncInputParams::create() const
-{
- return new VncInput(*this);
-}
detach();
}
}
-
-// create the VNC server object
-VncServer *
-VncServerParams::create() const
-{
- return new VncServer(*this);
-}
-
SimObject('DummyChecker.py')
SimObject('StaticInstFlags.py')
Source('checker/cpu.cc')
-Source('dummy_checker.cc')
DebugFlag('Checker')
+++ /dev/null
-/*
- * Copyright (c) 2011, 2019 ARM Limited
- * All rights reserved
- *
- * The license below extends only to copyright in the software and shall
- * not be construed as granting a license to any other intellectual
- * property including but not limited to intellectual property relating
- * to a hardware implementation of the functionality of the software
- * licensed hereunder. You may use the software subject to the license
- * terms below provided that you ensure that this notice is replicated
- * unmodified and in its entirety in all distributions of the software,
- * modified or unmodified, in source code or in binary form.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "cpu/dummy_checker.hh"
-
-#include "params/DummyChecker.hh"
-
-DummyChecker *
-DummyCheckerParams::create() const
-{
- // The checker should check all instructions executed by the main
- // cpu and therefore any parameters for early exit don't make much
- // sense.
- fatal_if(max_insts_any_thread || max_insts_all_threads ||
- progress_interval, "Invalid checker parameters");
-
- return new DummyChecker(*this);
-}
#define __CPU_DUMMY_CHECKER_HH__
#include "cpu/checker/cpu.hh"
+#include "params/DummyChecker.hh"
/**
* Specific non-templated derived class used for SimObject configuration.
class DummyChecker : public CheckerCPU
{
public:
- DummyChecker(const Params &p)
- : CheckerCPU(p)
- { }
+ DummyChecker(const Params &p) : CheckerCPU(p)
+ {
+ // The checker should check all instructions executed by the main
+ // cpu and therefore any parameters for early exit don't make much
+ // sense.
+ fatal_if(p.max_insts_any_thread || p.max_insts_all_threads ||
+ p.progress_interval, "Invalid checker parameters");
+
+ }
};
#endif // __CPU_DUMMY_CHECKER_HH__
}
} // namespace Trace
-
-////////////////////////////////////////////////////////////////////////
-//
-// ExeTracer Simulation Object
-//
-Trace::ExeTracer *
-ExeTracerParams::create() const
-{
- return new Trace::ExeTracer(*this);
-}
{
return pipelined[capability];
}
-
-////////////////////////////////////////////////////////////////////////////
-//
-// The SimObjects we use to get the FU information into the simulator
-//
-////////////////////////////////////////////////////////////////////////////
-
-//
-// We use 2 objects to specify this data in the INI file:
-// (1) OpDesc - Describes the operation class & latencies
-// (multiple OpDesc objects can refer to the same
-// operation classes)
-// (2) FUDesc - Describes the operations available in the unit &
-// the number of these units
-//
-//
-
-
-//
-// The operation-class description object
-//
-OpDesc *
-OpDescParams::create() const
-{
- return new OpDesc(*this);
-}
-
-//
-// The FuDesc object
-//
-FUDesc *
-FUDescParams::create() const
-{
- return new FUDesc(*this);
-}
#include "params/OpDesc.hh"
#include "sim/sim_object.hh"
+////////////////////////////////////////////////////////////////////////////
+//
+// The SimObjects we use to get the FU information into the simulator
+//
+////////////////////////////////////////////////////////////////////////////
+
+//
+// We use 2 objects to specify this data in the INI file:
+// (1) OpDesc - Describes the operation class & latencies
+// (multiple OpDesc objects can refer to the same
+// operation classes)
+// (2) FUDesc - Describes the operations available in the unit &
+// the number of these units
+//
+//
+
////////////////////////////////////////////////////////////////////////////
//
// Structures used ONLY during the initialization phase...
}
} // namespace Trace
-
-
-Trace::InstPBTrace*
-InstPBTraceParams::create() const
-{
- return new Trace::InstPBTrace(*this);
-}
-
}
} // namespace Trace
-
-////////////////////////////////////////////////////////////////////////
-//
-// ExeTracer Simulation Object
-//
-Trace::IntelTrace *
-IntelTraceParams::create() const
-{
- return new Trace::IntelTrace(*this);
-}
auto *tc = sys->threads[cpu_id];
return tc->getCpuPtr()->checkInterrupts(tc->threadId());
}
-
-IntrControl *
-IntrControlParams::create() const
-{
- return new IntrControl(*this);
-}
IntrControl::clear(int cpu_id, int int_num, int index)
{
}
-
-IntrControl *
-IntrControlParams::create() const
-{
- return new IntrControl(*this);
-}
Kvm::Kvm()
: kvmFD(-1), apiVersion(-1), vcpuMMapSize(0)
{
+ static bool created = false;
+ if (created)
+ warn_once("Use of multiple KvmVMs is currently untested!");
+
+ created = true;
+
kvmFD = ::open("/dev/kvm", O_RDWR);
if (kvmFD == -1)
fatal("KVM: Failed to open /dev/kvm\n");
return ::ioctl(vmFD, request, p1);
}
-
-
-KvmVM *
-KvmVMParams::create() const
-{
- static bool created = false;
- if (created)
- warn_once("Use of multiple KvmVMs is currently untested!\n");
-
- created = true;
-
- return new KvmVM(*this);
-}
if (ioctl(KVM_SET_VCPU_EVENTS, (void *)&events) == -1)
panic("KVM: Failed to set guest debug registers\n");
}
-
-X86KvmCPU *
-X86KvmCPUParams::create() const
-{
- return new X86KvmCPU(*this);
-}
pipeline->start();
}
-MinorCPU *
-MinorCPUParams::create() const
-{
- return new MinorCPU(*this);
-}
-
Port &
MinorCPU::getInstPort()
{
#include "debug/MinorTiming.hh"
#include "enums/OpClass.hh"
-MinorOpClass *
-MinorOpClassParams::create() const
-{
- return new MinorOpClass(*this);
-}
-
-MinorOpClassSet *
-MinorOpClassSetParams::create() const
-{
- return new MinorOpClassSet(*this);
-}
-
-MinorFUTiming *
-MinorFUTimingParams::create() const
-{
- return new MinorFUTiming(*this);
-}
-
-MinorFU *
-MinorFUParams::create() const
-{
- return new MinorFU(*this);
-}
-
-MinorFUPool *
-MinorFUPoolParams::create() const
-{
- return new MinorFUPool(*this);
-}
-
MinorOpClassSet::MinorOpClassSet(const MinorOpClassSetParams ¶ms) :
SimObject(params),
opClasses(params.opClasses),
Source('base_dyn_inst.cc')
Source('commit.cc')
Source('cpu.cc')
- Source('deriv.cc')
Source('decode.cc')
Source('dyn_inst.cc')
Source('fetch.cc')
#include "cpu/o3/checker.hh"
#include "cpu/checker/cpu_impl.hh"
-#include "params/O3Checker.hh"
template
class Checker<O3CPUImpl>;
-
-O3Checker *
-O3CheckerParams::create() const
-{
- // The checker should check all instructions executed by the main
- // cpu and therefore any parameters for early exit don't make much
- // sense.
- fatal_if(max_insts_any_thread || max_insts_all_threads ||
- progress_interval, "Invalid checker parameters");
-
- return new O3Checker(*this);
-}
class O3Checker : public Checker<O3CPUImpl>
{
public:
- O3Checker(const Params &p) : Checker<O3CPUImpl>(p) {}
+ O3Checker(const Params &p) : Checker<O3CPUImpl>(p)
+ {
+ // The checker should check all instructions executed by the main
+ // cpu and therefore any parameters for early exit don't make much
+ // sense.
+ fatal_if(p.max_insts_any_thread || p.max_insts_all_threads ||
+ p.progress_interval, "Invalid checker parameters");
+ }
};
#endif // __CPU_O3_CHECKER_HH__
+++ /dev/null
-/*
- * Copyright (c) 2004-2006 The Regents of The University of Michigan
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "cpu/o3/deriv.hh"
-
-#include <string>
-
-#include "params/DerivO3CPU.hh"
-
-DerivO3CPU *
-DerivO3CPUParams::create() const
-{
- return new DerivO3CPU(*this);
-}
return is_drained;
}
-
-//
-
-////////////////////////////////////////////////////////////////////////////
-//
-// The SimObjects we use to get the FU information into the simulator
-//
-////////////////////////////////////////////////////////////////////////////
-
-//
-// FUPool - Contails a list of FUDesc objects to make available
-//
-
-//
-// The FuPool object
-//
-FUPool *
-FUPoolParams::create() const
-{
- return new FUPool(*this);
-}
delete dataTraceStream;
delete instTraceStream;
}
-
-ElasticTrace*
-ElasticTraceParams::create() const
-{
- return new ElasticTrace(*this);
-}
listeners.push_back(new DynInstListener(this, "Fetch",
&SimpleTrace::traceFetch));
}
-
-SimpleTrace*
-SimpleTraceParams::create() const
-{
- return new SimpleTrace(*this);
-}
LocalBP::uncondBranch(ThreadID tid, Addr pc, void *&bp_history)
{
}
-
-LocalBP*
-LocalBPParams::create() const
-{
- return new LocalBP(*this);
-}
(globalHistoryReg[tid] << 1);
globalHistoryReg[tid] &= historyRegisterMask;
}
-
-BiModeBP*
-BiModeBPParams::create() const
-{
- return new BiModeBP(*this);
-}
loopTableConfidenceBits + loopTableTagBits +
loopTableAgeBits + useDirectionBit);
}
-
-LoopPredictor *
-LoopPredictorParams::create() const
-{
- return new LoopPredictor(*this);
-}
{
TAGE::regStats();
}
-
-LTAGE*
-LTAGEParams::create() const
-{
- return new LTAGE(*this);
-}
addSpec(new SGHISTPATH(1, 2, 5, 1.25, 768, 6, *this));
addSpec(new SGHISTPATH(1, 5, 2, 1.3125, 972, 6, *this));
}
-
-MultiperspectivePerceptron64KB*
-MultiperspectivePerceptron64KBParams::create() const
-{
- return new MultiperspectivePerceptron64KB(*this);
-}
addSpec(new SGHISTPATH(0, 4, 3, 1.65625, 0, 6, *this));
addSpec(new SGHISTPATH(1, 2, 5, 2.53125, 0, 5, *this));
}
-
- MultiperspectivePerceptron8KB*
-MultiperspectivePerceptron8KBParams::create() const
-{
- return new MultiperspectivePerceptron8KB(*this);
-}
}
-MPP_TAGE*
-MPP_TAGEParams::create() const
-{
- return new MPP_TAGE(*this);
-}
-
bool
MPP_LoopPredictor::calcConf(int index) const
{
return ((random_mt.random<int>() & 7) == 0);
}
-MPP_LoopPredictor*
-MPP_LoopPredictorParams::create() const
-{
- return new MPP_LoopPredictor(*this);
-}
-
MPP_StatisticalCorrector::MPP_StatisticalCorrector(
const MPP_StatisticalCorrectorParams &p) : StatisticalCorrector(p),
thirdH(0), pnb(p.pnb), logPnb(p.logPnb), pm(p.pm), gnb(p.gnb),
return bits;
}
-MPP_StatisticalCorrector_64KB*
-MPP_StatisticalCorrector_64KBParams::create() const
-{
- return new MPP_StatisticalCorrector_64KB(*this);
-}
-
-
MultiperspectivePerceptronTAGE64KB::MultiperspectivePerceptronTAGE64KB(
const MultiperspectivePerceptronTAGE64KBParams &p)
: MultiperspectivePerceptronTAGE(p)
addSpec(new RECENCY(9, 3, -1, 2.51, 0, 6, *this));
addSpec(new ACYCLIC(12, -1, -1, 2.0, 0, 6, *this));
}
-
-MultiperspectivePerceptronTAGE64KB*
-MultiperspectivePerceptronTAGE64KBParams::create() const
-{
- return new MultiperspectivePerceptronTAGE64KB(*this);
-}
#include "cpu/pred/multiperspective_perceptron_tage_8KB.hh"
-MPP_TAGE_8KB*
-MPP_TAGE_8KBParams::create() const
-{
- return new MPP_TAGE_8KB(*this);
-}
-
-MPP_LoopPredictor_8KB*
-MPP_LoopPredictor_8KBParams::create() const
-{
- return new MPP_LoopPredictor_8KB(*this);
-}
-
MPP_StatisticalCorrector_8KB::MPP_StatisticalCorrector_8KB(
const MPP_StatisticalCorrector_8KBParams &p)
: MPP_StatisticalCorrector(p)
return bits;
}
-MPP_StatisticalCorrector_8KB*
-MPP_StatisticalCorrector_8KBParams::create() const
-{
- return new MPP_StatisticalCorrector_8KB(*this);
-}
-
MultiperspectivePerceptronTAGE8KB::MultiperspectivePerceptronTAGE8KB(
const MultiperspectivePerceptronTAGE8KBParams &p)
: MultiperspectivePerceptronTAGE(p)
addSpec(new IMLI(1, 2.23, 0, 6, *this));
addSpec(new IMLI(4, 1.98, 0, 6, *this));
}
-
-MultiperspectivePerceptronTAGE8KB*
-MultiperspectivePerceptronTAGE8KBParams::create() const
-{
- return new MultiperspectivePerceptronTAGE8KB(*this);
-}
{
return (br_addr >> instShift) & ((0x1<<tagBits)-1);
}
-
-SimpleIndirectPredictor *
-SimpleIndirectPredictorParams::create() const
-{
- return new SimpleIndirectPredictor(*this);
-}
TageBranchInfo *bi = static_cast<TageBranchInfo*>(bp_history);
tage->updateHistories(tid, br_pc, true, bi->tageBranchInfo, true);
}
-
-TAGE*
-TAGEParams::create() const
-{
- return new TAGE(*this);
-}
bits += logUResetPeriod;
return bits;
}
-
-TAGEBase*
-TAGEBaseParams::create() const
-{
- return new TAGEBase(*this);
-}
return (random_mt.random<int>() & 7) == 0;
}
-TAGE_SC_L_LoopPredictor *
-TAGE_SC_L_LoopPredictorParams::create() const
-{
- return new TAGE_SC_L_LoopPredictor(*this);
-}
-
TAGE_SC_L::TAGE_SC_L(const TAGE_SC_LParams &p)
: LTAGE(p), statisticalCorrector(p.statistical_corrector)
{
igehl, inb, logInb, wi, bi);
}
-TAGE_SC_L_64KB_StatisticalCorrector*
-TAGE_SC_L_64KB_StatisticalCorrectorParams::create() const
-{
- return new TAGE_SC_L_64KB_StatisticalCorrector(*this);
-}
-
int
TAGE_SC_L_TAGE_64KB::gindex_ext(int index, int bank) const
{
}
}
-TAGE_SC_L_TAGE_64KB*
-TAGE_SC_L_TAGE_64KBParams::create() const
-{
- return new TAGE_SC_L_TAGE_64KB(*this);
-}
-
TAGE_SC_L_64KB::TAGE_SC_L_64KB(const TAGE_SC_L_64KBParams ¶ms)
: TAGE_SC_L(params)
{
}
-
-TAGE_SC_L_64KB*
-TAGE_SC_L_64KBParams::create() const
-{
- return new TAGE_SC_L_64KB(*this);
-}
gUpdate(pc, taken, sh->imliCount, im, igehl, inb, logInb, wi, bi);
}
-TAGE_SC_L_8KB_StatisticalCorrector*
-TAGE_SC_L_8KB_StatisticalCorrectorParams::create() const
-{
- return new TAGE_SC_L_8KB_StatisticalCorrector(*this);
-}
-
TAGE_SC_L_8KB::TAGE_SC_L_8KB(const TAGE_SC_L_8KBParams ¶ms)
: TAGE_SC_L(params)
{
gtable[bi->hitBank][bi->hitBankIndex].u++;
}
}
-
-TAGE_SC_L_TAGE_8KB*
-TAGE_SC_L_TAGE_8KBParams::create() const
-{
- return new TAGE_SC_L_TAGE_8KB(*this);
-}
-
-TAGE_SC_L_8KB*
-TAGE_SC_L_8KBParams::create() const
-{
- return new TAGE_SC_L_8KB(*this);
-}
delete history;
}
-TournamentBP*
-TournamentBPParams::create() const
-{
- return new TournamentBP(*this);
-}
-
#ifdef DEBUG
int
TournamentBP::BPHistory::newCount = 0;
{
dcachePort.printAddr(a);
}
-
-////////////////////////////////////////////////////////////////////////
-//
-// AtomicSimpleCPU Simulation Object
-//
-AtomicSimpleCPU *
-AtomicSimpleCPUParams::create() const
-{
- return new AtomicSimpleCPU(*this);
-}
NonCachingSimpleCPU::NonCachingSimpleCPU(const NonCachingSimpleCPUParams &p)
: AtomicSimpleCPU(p)
{
+ assert(p.numThreads == 1);
+ fatal_if(!FullSystem && p.workload.size() != 1,
+ "only one workload allowed");
}
void
return port.sendAtomic(pkt);
}
}
-
-NonCachingSimpleCPU *
-NonCachingSimpleCPUParams::create() const
-{
- assert(numThreads == 1);
- if (!FullSystem && workload.size() != 1)
- fatal("only one workload allowed");
- return new NonCachingSimpleCPU(*this);
-}
}
}
}
-
-/** SimPoint SimObject */
-SimPoint*
-SimPointParams::create() const
-{
- return new SimPoint(*this);
-}
sendData(req, data, nullptr, true);
}
-
-
-////////////////////////////////////////////////////////////////////////
-//
-// TimingSimpleCPU Simulation Object
-//
-TimingSimpleCPU *
-TimingSimpleCPUParams::create() const
-{
- return new TimingSimpleCPU(*this);
-}
}
}
-
-InvalidateGenerator *
-InvalidateGeneratorParams::create() const
-{
- return new InvalidateGenerator(*this);
-}
exitSimLoop("Ruby DirectedTester completed");
}
}
-
-RubyDirectedTester *
-RubyDirectedTesterParams::create() const
-{
- return new RubyDirectedTester(*this);
-}
m_active_node = 0;
}
}
-
-SeriesRequestGenerator *
-SeriesRequestGeneratorParams::create() const
-{
- return new SeriesRequestGenerator(*this);
-}
{
cachePort.printAddr(a);
}
-
-
-GarnetSyntheticTraffic *
-GarnetSyntheticTrafficParams::create() const
-{
- return new GarnetSyntheticTraffic(*this);
-}
reschedule(noRequestEvent, clockEdge(progressCheck), true);
}
}
-
-MemTest *
-MemTestParams::create() const
-{
- return new MemTest(*this);
-}
{
out << "[RubyTester]" << std::endl;
}
-
-RubyTester *
-RubyTesterParams::create() const
-{
- return new RubyTester(*this);
-}
static EmbeddedPyBind _py_tracers("trace", pybind_init_tracers);
-PyTrafficGen*
-PyTrafficGenParams::create() const
-{
- return new PyTrafficGen(*this);
-}
-
{
}
-TrafficGen*
-TrafficGenParams::create() const
-{
- return new TrafficGen(*this);
-}
-
void
TrafficGen::init()
{
else
return falseExpr->eval(context);
}
-
-TimingExprLiteral *
-TimingExprLiteralParams::create() const
-{
- return new TimingExprLiteral(*this);
-}
-
-TimingExprSrcReg *
-TimingExprSrcRegParams::create() const
-{
- return new TimingExprSrcReg(*this);
-}
-
-TimingExprReadIntReg *
-TimingExprReadIntRegParams::create() const
-{
- return new TimingExprReadIntReg(*this);
-}
-
-TimingExprLet *
-TimingExprLetParams::create() const
-{
- return new TimingExprLet(*this);
-}
-
-TimingExprRef *
-TimingExprRefParams::create() const
-{
- return new TimingExprRef(*this);
-}
-
-TimingExprUn *
-TimingExprUnParams::create() const
-{
- return new TimingExprUn(*this);
-}
-
-TimingExprBin *
-TimingExprBinParams::create() const
-{
- return new TimingExprBin(*this);
-}
-
-TimingExprIf *
-TimingExprIfParams::create() const
-{
- return new TimingExprIf(*this);
-}
}
-TraceCPU*
-TraceCPUParams::create() const
-{
- return new TraceCPU(*this);
-}
-
void
TraceCPU::updateNumOps(uint64_t rob_num)
{
pkt->makeAtomicResponse();
return pioDelay;
}
-
-A9SCU *
-A9SCUParams::create() const
-{
- return new A9SCU(*this);
-}
pkt->makeAtomicResponse();
return pioDelay;
}
-
-
-AmbaFake *
-AmbaFakeParams::create() const
-{
- return new AmbaFake(*this);
-}
_active = false;
platform->gic->clearPPInt(intNum, targetContext());
}
-
-ArmSPIGen *
-ArmSPIParams::create() const
-{
- return new ArmSPIGen(*this);
-}
-
-ArmPPIGen *
-ArmPPIParams::create() const
-{
- return new ArmPPIGen(*this);
-}
Display::Display(const DisplayParams &p)
: SimObject(p)
{}
-
-Display *
-DisplayParams::create() const
-{
- return new Display(*this);
-}
}
}
-EnergyCtrl *
-EnergyCtrlParams::create() const
-{
- return new EnergyCtrl(*this);
-}
-
void
EnergyCtrl::startup()
{
#include "base/trace.hh"
#include "debug/Drain.hh"
-/**
- * Create this device
- */
-
-FlashDevice*
-FlashDeviceParams::create() const
-{
- return new FlashDevice(*this);
-}
-
-
/**
* Flash Device constructor and destructor
*/
ArmISA::Reset().invoke(tc);
tc->activate();
}
-
-FVPBasePwrCtrl *
-FVPBasePwrCtrlParams::create() const
-{
- return new FVPBasePwrCtrl(*this);
-}
"(0x%x:%i), assuming WI\n", addr, size);
}
}
-
-SystemCounter *
-SystemCounterParams::create() const
-{
- return new SystemCounter(*this);
-}
-
-GenericTimer *
-GenericTimerParams::create() const
-{
- return new GenericTimer(*this);
-}
-
-GenericTimerFrame *
-GenericTimerFrameParams::create() const
-{
- return new GenericTimerFrame(*this);
-}
-
-GenericTimerMem *
-GenericTimerMemParams::create() const
-{
- return new GenericTimerMem(*this);
-}
UNSERIALIZE_ARRAY(intConfig, 2);
UNSERIALIZE_ARRAY(intPriority, SGI_MAX + PPI_MAX);
}
-
-GicV2 *
-GicV2Params::create() const
-{
- return new GicV2(*this);
-}
#include "mem/packet.hh"
#include "mem/packet_access.hh"
-Gicv2m *
-Gicv2mParams::create() const
-{
- return new Gicv2m(*this);
-}
-
-Gicv2mFrame *
-Gicv2mFrameParams::create() const
-{
- return new Gicv2mFrame(*this);
-}
-
Gicv2m::Gicv2m(const Params &p)
: PioDevice(p), pioDelay(p.pio_delay), frames(p.frames), gic(p.gic)
{
cpuInterfaces[cpu_interface_id]->unserializeSection(cp,
csprintf("cpuInterface.%i", cpu_interface_id));
}
-
-Gicv3 *
-Gicv3Params::create() const
-{
- return new Gicv3(*this);
-}
rd2->updateDistributor();
}
-
-Gicv3Its *
-Gicv3ItsParams::create() const
-{
- return new Gicv3Its(*this);
-}
for (const auto ® : idRegs)
writeRegRaw(reg.first, reg.second);
}
-
-
-
-NoMaliGpu *
-NoMaliGpuParams::create() const
-{
- return new NoMaliGpu(*this);
-}
-
-CustomNoMaliGpu *
-CustomNoMaliGpuParams::create() const
-{
- return new CustomNoMaliGpu(*this);
-}
inform("PixelPump vertical fron porch: %u", t.vFrontPorch);
inform("PixelPump vertical fron porch: %u", t.vSync);
}
-
-
-HDLcd *
-HDLcdParams::create() const
-{
- return new HDLcd(*this);
-}
UNSERIALIZE_SCALAR(clkdiv);
paramIn(cp, "raw_ints", rawInterrupts);
}
-
-Pl050 *
-Pl050Params::create() const
-{
- return new Pl050(*this);
-}
fatal("Unsupported PCI interrupt routing policy.");
}
}
-
-
-GenericArmPciHost *
-GenericArmPciHostParams::create() const
-{
- return new GenericArmPciHost(*this);
-}
paramIn(cp, "imsc_serial", imsc);
paramIn(cp, "rawInt_serial", rawInt);
}
-
-Pl011 *
-Pl011Params::create() const
-{
- return new Pl011(*this);
-}
ranges.push_back(RangeSize(pioAddr, pioSize));
return ranges;
}
-
-Pl111 *
-Pl111Params::create() const
-{
- return new Pl111(*this);
-}
-
-
{
gic->clearInt(line);
}
-
-RealView *
-RealViewParams::create() const
-{
- return new RealView(*this);
-}
schedule(matchEvent, event_time);
}
}
-
-
-
-PL031 *
-PL031Params::create() const
-{
- return new PL031(*this);
-}
// Report a dummy 25 degrees temperature
return 25000000;
}
-
-RealViewCtrl *
-RealViewCtrlParams::create() const
-{
- return new RealViewCtrl(*this);
-}
-
-RealViewOsc *
-RealViewOscParams::create() const
-{
- return new RealViewOsc(*this);
-}
-
-RealViewTemperatureSensor *
-RealViewTemperatureSensorParams::create() const
-{
- return new RealViewTemperatureSensor(*this);
-}
return ClockedObject::getPort(name, id);
}
}
-
-SMMUv3*
-SMMUv3Params::create() const
-{
- return new SMMUv3(*this);
-}
}
return DrainState::Drained;
}
-
-SMMUv3DeviceInterface*
-SMMUv3DeviceInterfaceParams::create() const
-{
- return new SMMUv3DeviceInterface(*this);
-}
{
global_timer.unserialize(cp);
}
-
-A9GlobalTimer *
-A9GlobalTimerParams::create() const
-{
- return new A9GlobalTimer(*this);
-}
for (int i = 0; i < sys->threads.size(); i++)
localTimer[i]->unserializeSection(cp, csprintf("timer%d", i));
}
-
-CpuLocalTimer *
-CpuLocalTimerParams::create() const
-{
- return new CpuLocalTimer(*this);
-}
timer0.unserializeSection(cp, "timer0");
timer1.unserializeSection(cp, "timer1");
}
-
-Sp804 *
-Sp804Params::create() const
-{
- return new Sp804(*this);
-}
setValues();
}
-/**
- * Create the parameters of this device
- */
-
-UFSHostDevice*
-UFSHostDeviceParams::create() const
-{
- return new UFSHostDevice(*this);
-}
-
-
void
UFSHostDevice::regStats()
{
paramIn(cp, "lr", LR[i]);
}
}
-
-VGic *
-VGicParams::create() const
-{
- return new VGic(*this);
-}
interrupt->clear();
}
}
-
-
-MmioVirtIO *
-MmioVirtIOParams::create() const
-{
- return new MmioVirtIO(*this);
-}
reschedule(timeoutEvent, when, true);
}
}
-
-Sp805 *
-Sp805Params::create() const
-{
- return new Sp805(*this);
-}
{
panic("Device %s not imlpmented\n", devname);
}
-
-BadDevice *
-BadDeviceParams::create() const
-{
- return new BadDevice(*this);
-}
return nBufReq;
}
-HSAPacketProcessor *
-HSAPacketProcessorParams::create() const
-{
- return new HSAPacketProcessor(*this);
-}
-
void
HSAPacketProcessor::finishPkt(void *pvPkt, uint32_t rl_idx)
{
UNSERIALIZE_SCALAR(i2cAddr);
UNSERIALIZE_SCALAR(message);
}
-
-I2CBus*
-I2CBusParams::create() const
-{
- return new I2CBus(*this);
-}
}
return pioDelay;
}
-
-IsaFake *
-IsaFakeParams::create() const
-{
- return new IsaFake(*this);
-}
{
UNSERIALIZE_ARRAY(intr_sum_type, Malta::Max_CPUs);
}
-
-Malta *
-MaltaParams::create() const
-{
- return new Malta(*this);
-}
MaltaCChip::unserialize(CheckpointIn &cp)
{
}
-
-MaltaCChip *
-MaltaCChipParams::create() const
-{
- return new MaltaCChip(*this);
-}
-
rtc.startup();
pitimer.startup();
}
-
-MaltaIO *
-MaltaIOParams::create() const
-{
- return new MaltaIO(*this);
-}
rx->setDistInt(m);
}
-DistEtherLink *
-DistEtherLinkParams::create() const
-{
- return new DistEtherLink(*this);
-}
-
return true;
}
-
-EtherBus *
-EtherBusParams::create() const
-{
- return new EtherBus(*this);
-}
stream->write(reinterpret_cast<char *>(packet->data), pkthdr.caplen);
stream->flush();
}
-
-EtherDump *
-EtherDumpParams::create() const
-{
- return new EtherDump(*this);
-}
"in-flight packets may have been dropped.\n");
}
}
-
-EtherLink *
-EtherLinkParams::create() const
-{
- return new EtherLink(*this);
-}
}
}
-
-EtherSwitch *
-EtherSwitchParams::create() const
-{
- return new EtherSwitch(*this);
-}
return true;
}
-EtherTap *
-EtherTapParams::create() const
-{
- return new EtherTap(*this);
-}
-
#endif
-
-EtherTapStub *
-EtherTapStubParams::create() const
-{
- return new EtherTapStub(*this);
-}
txDescCache.unserializeSection(cp, "TxDescCache");
rxDescCache.unserializeSection(cp, "RxDescCache");
}
-
-IGbE *
-IGbEParams::create() const
-{
- return new IGbE(*this);
-}
schedule(intrEvent, intrEventTick);
}
}
-
-NSGigE *
-NSGigEParams::create() const
-{
- return new NSGigE(*this);
-}
}
} // namespace Sinic
-
-Sinic::Device *
-SinicParams::create() const
-{
- return new Sinic::Device(*this);
-}
DPRINTF(DMACopyEngine, "Restarting state machine at state %d\n", nextState);
restartStateMachine();
}
-
-CopyEngine *
-CopyEngineParams::create() const
-{
- return new CopyEngine(*this);
-}
pxcap.pxdc2 = tmp32;
pioPort.sendRangeChange();
}
-
-PciBarNone *
-PciBarNoneParams::create() const
-{
- return new PciBarNone(*this);
-}
-
-PciIoBar *
-PciIoBarParams::create() const
-{
- return new PciIoBar(*this);
-}
-
-PciLegacyIoBar *
-PciLegacyIoBarParams::create() const
-{
- return new PciLegacyIoBar(*this);
-}
-
-PciMemBar *
-PciMemBarParams::create() const
-{
- return new PciMemBar(*this);
-}
-
-PciMemUpperBar *
-PciMemUpperBarParams::create() const
-{
- return new PciMemUpperBar(*this);
-}
return dev->interruptLine();
}
-
-GenericPciHost *
-GenericPciHostParams::create() const
-{
- return new GenericPciHost(*this);
-}
for (uint8_t c : keys)
send(c);
}
-
-
-PS2Keyboard *
-PS2KeyboardParams::create() const
-{
- return new PS2Keyboard(*this);
-}
UNSERIALIZE_SCALAR(resolution);
UNSERIALIZE_SCALAR(sampleRate);
}
-
-PS2Mouse *
-PS2MouseParams::create() const
-{
- return new PS2Mouse(*this);
-}
send(resp, sizeof(resp));
}
-
-PS2TouchKit *
-PS2TouchKitParams::create() const
-{
- return new PS2TouchKit(*this);
-}
{
panic("SerialNullDevice does not have pending data.\n");
}
-
-
-
-SerialNullDevice *
-SerialNullDeviceParams::create() const
-{
- return new SerialNullDevice(*this);
-}
pkt->makeAtomicResponse();
return pioDelay;
}
-
-SimpleUart *
-SimpleUartParams::create() const
-{
- return new SimpleUart(*this);
-}
isprint(c) ? c : ' ', (int)c);
}
-
-Terminal *
-TerminalParams::create() const
-{
- return new Terminal(*this);
-}
if (txintrwhen != 0)
schedule(txIntrEvent, txintrwhen);
}
-
-Uart8250 *
-Uart8250Params::create() const
-{
- return new Uart8250(*this);
-}
{
UNSERIALIZE_SCALAR(todTime);
}
-
-DumbTOD *
-DumbTODParams::create() const
-{
- return new DumbTOD(*this);
-}
paramIn(cp, "source", jIntBusy[x].source);
};
}
-
-Iob *
-IobParams::create() const
-{
- return new Iob(*this);
-}
}
ClockedObject::serialize(cp);
}
-
-MmDisk *
-MmDiskParams::create() const
-{
- return new MmDisk(*this);
-}
{
panic("Need implementation\n");
}
-
-T1000 *
-T1000Params::create() const
-{
- return new T1000(*this);
-}
return stream.tellp() - pos;
}
-RawDiskImage *
-RawDiskImageParams::create() const
-{
- return new RawDiskImage(*this);
-}
-
////////////////////////////////////////////////////////////////////////
//
// Copy on Write Disk image
cowFilename = cp.getCptDir() + "/" + cowFilename;
open(cowFilename);
}
-
-CowDiskImage *
-CowDiskImageParams::create() const
-{
- return new CowDiskImage(*this);
-}
paramIn(cp, base + ".selectBit", selectBit);
select(selectBit);
}
-
-IdeController *
-IdeControllerParams::create() const
-{
- return new IdeController(*this);
-}
UNSERIALIZE_ENUM(dmaState);
UNSERIALIZE_ARRAY(dataBuffer, MAX_DMA_SIZE);
}
-
-IdeDisk *
-IdeDiskParams::create() const
-{
- return new IdeDisk(*this);
-}
{
panic("unimplemented!\n");
}
-
-SimpleDisk *
-SimpleDiskParams::create() const
-{
- return new SimpleDisk(*this);
-}
: VirtIODeviceBase(params, ID_INVALID, 0, 0)
{
}
-
-VirtIODummyDevice *
-VirtIODummyDeviceParams::create() const
-{
- return new VirtIODummyDevice(*this);
-}
produceDescriptor(desc, sizeof(BlkRequest) + data_size + sizeof(Status));
parent.kick();
}
-
-VirtIOBlock *
-VirtIOBlockParams::create() const
-{
- return new VirtIOBlock(*this);
-}
produceDescriptor(desc, 0);
parent.kick();
}
-
-VirtIOConsole *
-VirtIOConsoleParams::create() const
-{
- return new VirtIOConsole(*this);
-}
// Managed to kill diod
return;
}
-
-}
-VirtIO9PDiod *
-VirtIO9PDiodParams::create() const
-{
- return new VirtIO9PDiod(*this);
}
-
-
VirtIO9PSocket::VirtIO9PSocket(const Params ¶ms)
: VirtIO9PProxy(params), fdSocket(-1)
{
{
parent.serverDataReady();
}
-
-
-VirtIO9PSocket *
-VirtIO9PSocketParams::create() const
-{
- return new VirtIO9PSocket(*this);
-}
interruptDeliveryPending = true;
intrPost();
}
-
-PciVirtIO *
-PciVirtIOParams::create() const
-{
- return new PciVirtIO(*this);
-}
// Serialize the timer
rtc.unserialize("rtc", cp);
}
-
-X86ISA::Cmos *
-CmosParams::create() const
-{
- return new X86ISA::Cmos(*this);
-}
UNSERIALIZE_SCALAR(dataReg);
UNSERIALIZE_SCALAR(lastCommand);
}
-
-X86ISA::I8042 *
-I8042Params::create() const
-{
- return new X86ISA::I8042(*this);
-}
redirTable[i] = (RedirTableEntry)redirTableArray[i];
}
}
-
-X86ISA::I82094AA *
-I82094AAParams::create() const
-{
- return new X86ISA::I82094AA(*this);
-}
{
UNSERIALIZE_SCALAR(maskReg);
}
-
-X86ISA::I8237 *
-I8237Params::create() const
-{
- return new X86ISA::I8237(*this);
-}
{
pit.startup();
}
-
-X86ISA::I8254 *
-I8254Params::create() const
-{
- return new X86ISA::I8254(*this);
-}
UNSERIALIZE_SCALAR(initControlWord);
UNSERIALIZE_SCALAR(autoEOI);
}
-
-X86ISA::I8259 *
-I8259Params::create() const
-{
- return new X86ISA::I8259(*this);
-}
{
warn_once("Tried to clear PCI interrupt %d\n", line);
}
-
-Pc *
-PcParams::create() const
-{
- return new Pc(*this);
-}
assert(pc);
pc->southBridge = this;
}
-
-SouthBridge *
-SouthBridgeParams::create() const
-{
- return new SouthBridge(*this);
-}
{
UNSERIALIZE_SCALAR(controlVal);
}
-
-X86ISA::Speaker *
-PcSpeakerParams::create() const
-{
- return new X86ISA::Speaker(*this);
-}
delete pkt;
}
-ComputeUnit*
-ComputeUnitParams::create() const
-{
- return new ComputeUnit(*this);
-}
-
bool
ComputeUnit::DTLBPort::recvTimingResp(PacketPtr pkt)
{
schedule(&tickEvent, curTick() + shader->clockPeriod());
}
}
-
-GPUDispatcher *
-GPUDispatcherParams::create() const
-{
- return new GPUDispatcher(*this);
-}
{
return _shader;
}
-
-GPUCommandProcessor*
-GPUCommandProcessorParams::create() const
-{
- return new GPUCommandProcessor(*this);
-}
{
return (apeBase & 0xFFFFFFFF00000000UL) | 0xFFFFFFFF;
}
-
-GPUComputeDriver*
-GPUComputeDriverParams::create() const
-{
- return new GPUComputeDriver(*this);
-}
TLBFootprint.clear();
}
} // namespace X86ISA
-
-X86ISA::GpuTLB*
-X86GPUTLBParams::create() const
-{
- return new X86ISA::GpuTLB(*this);
-}
-
"the LDS should be an even number");
}
-/**
- * Needed by the SWIG compiler
- */
-LdsState *
-LdsStateParams::create() const
-{
- return new LdsState(*this);
-}
-
/**
* set the parent and name based on the parent
*/
{
}
-RegisterFile*
-RegisterFileParams::create() const
-{
- return new RegisterFile(*this);
-}
-
// Events
// Mark a register as free in the scoreboard/busy vector
{
policy->regStats();
}
-
-RegisterManager*
-RegisterManagerParams::create() const
-{
- return new RegisterManager(*this);
-}
}
}
}
-
-ScalarRegisterFile*
-ScalarRegisterFileParams::create() const
-{
- return new ScalarRegisterFile(*this);
-}
assert(gpuTc);
}
-Shader*
-ShaderParams::create() const
-{
- return new Shader(*this);
-}
-
void
Shader::execScheduledAdds()
{
#include "base/logging.hh"
-SimplePoolManager *
-SimplePoolManagerParams::create() const
-{
- return new SimplePoolManager(*this);
-}
-
// return the min number of elements that the manager can reserve given
// a request for "size" elements
uint32_t
localLatency = localqueuingCycles / uncoalescedAccesses;
}
-
-
-TLBCoalescer*
-TLBCoalescerParams::create() const
-{
- return new TLBCoalescer(*this);
-}
-
mask = mask >> 4;
}
}
-
-VectorRegisterFile*
-VectorRegisterFileParams::create() const
-{
- return new VectorRegisterFile(*this);
-}
#include "gpu-compute/simple_pool_manager.hh"
#include "gpu-compute/vector_register_file.hh"
-Wavefront*
-WavefrontParams::create() const
-{
- return new Wavefront(*this);
-}
-
Wavefront::Wavefront(const Params &p)
: SimObject(p), wfSlotId(p.wf_slot_id), simdId(p.simdId),
maxIbSize(p.max_ib_size), _gpuISA(*this),
exitSimLoop(buffer, 0, curTick() + bandwidth * bytes_copied);
}
}
-
-GoodbyeObject*
-GoodbyeObjectParams::create() const
-{
- return new GoodbyeObject(*this);
-}
schedule(event, curTick() + latency);
}
}
-
-HelloObject*
-HelloObjectParams::create() const
-{
- return new HelloObject(*this);
-}
{
missLatency.init(16); // number of buckets
}
-
-
-SimpleCache*
-SimpleCacheParams::create() const
-{
- return new SimpleCache(*this);
-}
instPort.sendRangeChange();
dataPort.sendRangeChange();
}
-
-
-
-SimpleMemobj*
-SimpleMemobjParams::create() const
-{
- return new SimpleMemobj(*this);
-}
{
std::cout << "Hello World! From a SimObject!" << std::endl;
}
-
-SimpleObject*
-SimpleObjectParams::create() const
-{
- return new SimpleObject(*this);
-}
}
}
-RangeAddrMapper*
-RangeAddrMapperParams::create() const
-{
- return new RangeAddrMapper(*this);
-}
-
Addr
RangeAddrMapper::remapAddr(Addr addr) const
{
{
return ranges;
}
-
-Bridge *
-BridgeParams::create() const
-{
- return new Bridge(*this);
-}
}
nextAddr = write_addr + write_size;
}
-
-WriteAllocator*
-WriteAllocatorParams::create() const
-{
- return new WriteAllocator(*this);
-}
: BaseCache(p, p.system->cacheLineSize()),
doFastWrites(true)
{
+ assert(p.tags);
+ assert(p.replacement_policy);
}
void
return BaseCache::sendMSHRQueuePacket(mshr);
}
-
-Cache*
-CacheParams::create() const
-{
- assert(tags);
- assert(replacement_policy);
-
- return new Cache(*this);
-}
}
} // namespace Compressor
-
-Compressor::Base64Delta8*
-Base64Delta8Params::create() const
-{
- return new Compressor::Base64Delta8(*this);
-}
-
-Compressor::Base64Delta16*
-Base64Delta16Params::create() const
-{
- return new Compressor::Base64Delta16(*this);
-}
-
-Compressor::Base64Delta32*
-Base64Delta32Params::create() const
-{
- return new Compressor::Base64Delta32(*this);
-}
-
-Compressor::Base32Delta8*
-Base32Delta8Params::create() const
-{
- return new Compressor::Base32Delta8(*this);
-}
-
-Compressor::Base32Delta16*
-Base32Delta16Params::create() const
-{
- return new Compressor::Base32Delta16(*this);
-}
-
-Compressor::Base16Delta8*
-Base16Delta8Params::create() const
-{
- return new Compressor::Base16Delta8(*this);
-}
}
} // namespace Compressor
-
-Compressor::CPack*
-CPackParams::create() const
-{
- return new Compressor::CPack(*this);
-}
}
} // namespace Compressor
-
-Compressor::FPC*
-FPCParams::create() const
-{
- return new Compressor::FPC(*this);
-}
}
} // namespace Compressor
-
-Compressor::FPCD*
-FPCDParams::create() const
-{
- return new Compressor::FPCD(*this);
-}
}
} // namespace Compressor
-
-Compressor::Multi*
-MultiCompressorParams::create() const
-{
- return new Compressor::Multi(*this);
-}
}
} // namespace Compressor
-
-Compressor::Perfect*
-PerfectCompressorParams::create() const
-{
- return new Compressor::Perfect(*this);
-}
}
} // namespace Compressor
-
-Compressor::RepeatedQwords*
-RepeatedQwordsCompressorParams::create() const
-{
- return new Compressor::RepeatedQwords(*this);
-}
}
} // namespace Compressor
-
-Compressor::Zero*
-ZeroCompressorParams::create() const
-{
- return new Compressor::Zero(*this);
-}
NoncoherentCache::NoncoherentCache(const NoncoherentCacheParams &p)
: BaseCache(p, p.system->cacheLineSize())
{
+ assert(p.tags);
+ assert(p.replacement_policy);
}
void
return pkt;
}
-
-NoncoherentCache*
-NoncoherentCacheParams::create() const
-{
- assert(tags);
- assert(replacement_policy);
-
- return new NoncoherentCache(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::AccessMapPatternMatching*
-AccessMapPatternMatchingParams::create() const
-{
- return new Prefetcher::AccessMapPatternMatching(*this);
-}
-
-Prefetcher::AMPM*
-AMPMPrefetcherParams::create() const
-{
- return new Prefetcher::AMPM(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::BOP*
-BOPPrefetcherParams::create() const
-{
- return new Prefetcher::BOP(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::DeltaCorrelatingPredictionTables*
-DeltaCorrelatingPredictionTablesParams::create() const
-{
- return new Prefetcher::DeltaCorrelatingPredictionTables(*this);
-}
-
-Prefetcher::DCPT*
-DCPTPrefetcherParams::create() const
-{
- return new Prefetcher::DCPT(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::IndirectMemory*
-IndirectMemoryPrefetcherParams::create() const
-{
- return new Prefetcher::IndirectMemory(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::IrregularStreamBuffer*
-IrregularStreamBufferPrefetcherParams::create() const
-{
- return new Prefetcher::IrregularStreamBuffer(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::Multi*
-MultiPrefetcherParams::create() const
-{
- return new Prefetcher::Multi(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::PIF*
-PIFPrefetcherParams::create() const
-{
- return new Prefetcher::PIF(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::SBOOE*
-SBOOEPrefetcherParams::create() const
-{
- return new Prefetcher::SBOOE(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::SignaturePath*
-SignaturePathPrefetcherParams::create() const
-{
- return new Prefetcher::SignaturePath(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::SignaturePathV2*
-SignaturePathPrefetcherV2Params::create() const
-{
- return new Prefetcher::SignaturePathV2(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::SlimAMPM*
-SlimAMPMPrefetcherParams::create() const
-{
- return new Prefetcher::SlimAMPM(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::STeMS*
-STeMSPrefetcherParams::create() const
-{
- return new Prefetcher::STeMS(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::StridePrefetcherHashedSetAssociative*
-StridePrefetcherHashedSetAssociativeParams::create() const
-{
- return new Prefetcher::StridePrefetcherHashedSetAssociative(*this);
-}
-
-Prefetcher::Stride*
-StridePrefetcherParams::create() const
-{
- return new Prefetcher::Stride(*this);
-}
}
} // namespace Prefetcher
-
-Prefetcher::Tagged*
-TaggedPrefetcherParams::create() const
-{
- return new Prefetcher::Tagged(*this);
-}
}
} // namespace ReplacementPolicy
-
-ReplacementPolicy::BIP*
-BIPRPParams::create() const
-{
- return new ReplacementPolicy::BIP(*this);
-}
}
} // namespace ReplacementPolicy
-
-ReplacementPolicy::BRRIP*
-BRRIPRPParams::create() const
-{
- return new ReplacementPolicy::BRRIP(*this);
-}
}
} // namespace ReplacementPolicy
-
-ReplacementPolicy::FIFO*
-FIFORPParams::create() const
-{
- return new ReplacementPolicy::FIFO(*this);
-}
}
} // namespace ReplacementPolicy
-
-ReplacementPolicy::LFU*
-LFURPParams::create() const
-{
- return new ReplacementPolicy::LFU(*this);
-}
}
} // namespace ReplacementPolicy
-
-ReplacementPolicy::LRU*
-LRURPParams::create() const
-{
- return new ReplacementPolicy::LRU(*this);
-}
}
} // namespace ReplacementPolicy
-
-ReplacementPolicy::MRU*
-MRURPParams::create() const
-{
- return new ReplacementPolicy::MRU(*this);
-}
}
} // namespace ReplacementPolicy
-
-ReplacementPolicy::Random*
-RandomRPParams::create() const
-{
- return new ReplacementPolicy::Random(*this);
-}
}
} // namespace ReplacementPolicy
-
-ReplacementPolicy::SecondChance*
-SecondChanceRPParams::create() const
-{
- return new ReplacementPolicy::SecondChance(*this);
-}
}
} // namespace ReplacementPolicy
-
-ReplacementPolicy::TreePLRU*
-TreePLRURPParams::create() const
-{
- return new ReplacementPolicy::TreePLRU(*this);
-}
}
} // namespace ReplacementPolicy
-
-ReplacementPolicy::WeightedLRU*
-WeightedLRURPParams::create() const
-{
- return new ReplacementPolicy::WeightedLRU(*this);
-}
sequentialAccess(p.sequential_access),
replacementPolicy(p.replacement_policy)
{
+ // There must be a indexing policy
+ fatal_if(!p.indexing_policy, "An indexing policy is required");
+
// Check parameters
if (blkSize < 4 || !isPowerOf2(blkSize)) {
fatal("Block size must be at least 4 and a power of 2");
// Invalidate replacement data
replacementPolicy->invalidate(blk->replacementData);
}
-
-BaseSetAssoc *
-BaseSetAssocParams::create() const
-{
- // There must be a indexing policy
- fatal_if(!indexing_policy, "An indexing policy is required");
-
- return new BaseSetAssoc(*this);
-}
}
return false;
}
-
-CompressedTags *
-CompressedTagsParams::create() const
-{
- return new CompressedTags(*this);
-}
}
}
-FALRU *
-FALRUParams::create() const
-{
- return new FALRU(*this);
-}
-
void
FALRU::CacheTracking::check(const FALRUBlk *head, const FALRUBlk *tail) const
{
{
return sets[extractSet(addr)];
}
-
-SetAssociative*
-SetAssociativeParams::create() const
-{
- return new SetAssociative(*this);
-}
return entries;
}
-
-SkewedAssociative *
-SkewedAssociativeParams::create() const
-{
- return new SkewedAssociative(*this);
-}
sectorShift(floorLog2(blkSize)), sectorMask(numBlocksPerSector - 1),
sectorStats(stats, *this)
{
+ // There must be a indexing policy
+ fatal_if(!p.indexing_policy, "An indexing policy is required");
+
// Check parameters
fatal_if(blkSize < 4 || !isPowerOf2(blkSize),
"Block size must be at least 4 and a power of 2");
}
return false;
}
-
-SectorTags *
-SectorTagsParams::create() const
-{
- // There must be a indexing policy
- fatal_if(!indexing_policy, "An indexing policy is required");
-
- return new SectorTags(*this);
-}
snoopFanout.init(0, snoopPorts.size(), 1);
}
-
-CoherentXBar *
-CoherentXBarParams::create() const
-{
- return new CoherentXBar(*this);
-}
name(), samplePeriodTicks, samplePeriod * 1E3);
}
-CommMonitor*
-CommMonitorParams::create() const
-{
- return new CommMonitor(*this);
-}
-
void
CommMonitor::init()
{
{
memory.recvRespRetry();
}
-
-DRAMSim2*
-DRAMSim2Params::create() const
-{
- return new DRAMSim2(*this);
-}
{
memory.recvRespRetry();
}
-
-DRAMsim3*
-DRAMsim3Params::create() const
-{
- return new DRAMsim3(*this);
-}
}
}
-ExternalMaster *
-ExternalMasterParams::create() const
-{
- return new ExternalMaster(*this);
-}
-
void
ExternalMaster::registerHandler(const std::string &handler_name,
Handler *handler)
}
}
-ExternalSlave *
-ExternalSlaveParams::create() const
-{
- return new ExternalSlave(*this);
-}
-
void
ExternalSlave::registerHandler(const std::string &handler_name,
Handler *handler)
assert(p.port_cpu_side_ports_connection_count == 1);
}
-HMCController*
-HMCControllerParams::create() const
-{
- return new HMCController(*this);
-}
-
// Since this module is a load distributor, all its request ports have the same
// range so we should keep only one of the ranges and ignore the others
void HMCController::recvRangeChange(PortID mem_side_port_id)
byte_trackers.erase(addr + i);
}
}
-
-MemChecker*
-MemCheckerParams::create() const
-{
- return new MemChecker(*this);
-}
MemCheckerMonitor::~MemCheckerMonitor()
{}
-MemCheckerMonitor*
-MemCheckerMonitorParams::create() const
-{
- return new MemCheckerMonitor(*this);
-}
-
void
MemCheckerMonitor::init()
{
// pass it to the memory controller
return ctrl.recvTimingReq(pkt);
}
-
-MemCtrl*
-MemCtrlParams::create() const
-{
- return new MemCtrl(*this);
-}
return 0;
}
}
-
-
-SimpleMemDelay *
-SimpleMemDelayParams::create() const
-{
- return new SimpleMemDelay(*this);
-}
return make_pair(bank_mask, hidden_bank_prep);
}
-DRAMInterface*
-DRAMInterfaceParams::create() const
-{
- return new DRAMInterface(*this);
-}
-
DRAMInterface::Rank::Rank(const DRAMInterfaceParams &_p,
int _rank, DRAMInterface& _dram)
: EventManager(&_dram), dram(_dram),
}
-NVMInterface*
-NVMInterfaceParams::create() const
-{
- return new NVMInterface(*this);
-}
-
NVMInterface::Rank::Rank(const NVMInterfaceParams &_p,
int _rank, NVMInterface& _nvm)
: EventManager(&_nvm), rank(_rank), banks(_p.banks_per_rank)
// forward the request to the appropriate destination
memSidePorts[dest_id]->sendFunctional(pkt);
}
-
-NoncoherentXBar*
-NoncoherentXBarParams::create() const
-{
- return new NoncoherentXBar(*this);
-}
cacheLines.clear();
pages.clear();
}
-
-MemFootprintProbe *
-MemFootprintProbeParams::create() const
-{
- return new MemFootprintProbe(*this);
-}
traceStream->write(pkt_msg);
}
-
-
-MemTraceProbe *
-MemTraceProbeParams::create() const
-{
- return new MemTraceProbe(*this);
-}
writeLogHist.sample(sd_lg2);
}
}
-
-
-StackDistProbe *
-StackDistProbeParams::create() const
-{
- return new StackDistProbe(*this);
-}
} // namespace QoS
-QoS::MemSinkCtrl*
-QoSMemSinkCtrlParams::create() const
-{
- return new QoS::MemSinkCtrl(*this);
-}
-
QoSMemSinkInterface::QoSMemSinkInterface(const QoSMemSinkInterfaceParams &_p)
: AbstractMemory(_p)
{
}
-
-QoSMemSinkInterface*
-QoSMemSinkInterfaceParams::create() const
-{
- return new QoSMemSinkInterface(*this);
-}
}
} // namespace QoS
-
-QoS::FixedPriorityPolicy *
-QoSFixedPriorityPolicyParams::create() const
-{
- return new QoS::FixedPriorityPolicy(*this);
-}
}
} // namespace QoS
-
-QoS::PropFairPolicy *
-QoSPropFairPolicyParams::create() const
-{
- return new QoS::PropFairPolicy(*this);
-}
}
} // namespace QoS
-
-QoS::TurnaroundPolicyIdeal *
-QoSTurnaroundPolicyIdealParams::create() const
-{
- return new QoS::TurnaroundPolicyIdeal(*this);
-}
out << name();
}
-BasicLink *
-BasicLinkParams::create() const
-{
- return new BasicLink(*this);
-}
-
BasicExtLink::BasicExtLink(const Params &p)
: BasicLink(p)
{
}
-BasicExtLink *
-BasicExtLinkParams::create() const
-{
- return new BasicExtLink(*this);
-}
-
BasicIntLink::BasicIntLink(const Params &p)
: BasicLink(p)
{
}
-
-BasicIntLink *
-BasicIntLinkParams::create() const
-{
- return new BasicIntLink(*this);
-}
{
out << name();
}
-
-BasicRouter *
-BasicRouterParams::create() const
-{
- return new BasicRouter(*this);
-}
return num_functional_accesses;
}
-
-MessageBuffer *
-MessageBufferParams::create() const
-{
- return new MessageBuffer(*this);
-}
cout << "\n";
}
}
-
-FaultModel *
-FaultModelParams::create() const
-{
- return new FaultModel(*this);
-}
out << name();
}
-GarnetIntLink *
-GarnetIntLinkParams::create() const
-{
- return new GarnetIntLink(*this);
-}
-
GarnetExtLink::GarnetExtLink(const Params &p)
: BasicExtLink(p)
{
{
out << name();
}
-
-GarnetExtLink *
-GarnetExtLinkParams::create() const
-{
- return new GarnetExtLink(*this);
-}
out << "[GarnetNetwork]";
}
-GarnetNetwork *
-GarnetNetworkParams::create() const
-{
- return new GarnetNetwork(*this);
-}
-
uint32_t
GarnetNetwork::functionalWrite(Packet *pkt)
{
}
assert(!link_srcQueue->getSize());
}
-
-NetworkBridge *
-NetworkBridgeParams::create() const
-{
- return new NetworkBridge(*this);
-}
}
return num_functional_writes;
}
-
-NetworkInterface *
-GarnetNetworkInterfaceParams::create() const
-{
- return new NetworkInterface(*this);
-}
m_link_utilized = 0;
}
-NetworkLink *
-NetworkLinkParams::create() const
-{
- return new NetworkLink(*this);
-}
-
-CreditLink *
-CreditLinkParams::create() const
-{
- return new CreditLink(*this);
-}
-
uint32_t
NetworkLink::functionalWrite(Packet *pkt)
{
return num_functional_writes;
}
-
-Router *
-GarnetRouterParams::create() const
-{
- return new Router(*this);
-}
out << name();
}
-SimpleExtLink *
-SimpleExtLinkParams::create() const
-{
- return new SimpleExtLink(*this);
-}
-
SimpleIntLink::SimpleIntLink(const Params &p)
: BasicIntLink(p)
{
{
out << name();
}
-
-SimpleIntLink *
-SimpleIntLinkParams::create() const
-{
- return new SimpleIntLink(*this);
-}
out << "[SimpleNetwork]";
}
-SimpleNetwork *
-SimpleNetworkParams::create() const
-{
- return new SimpleNetwork(*this);
-}
-
/*
* The simple network has an array of switches. These switches have buffers
* that need to be accessed for functional reads and writes. Also the links
}
return num_functional_writes;
}
-
-Switch *
-SwitchParams::create() const
-{
- return new Switch(*this);
-}
return out;
}
-CacheMemory *
-RubyCacheParams::create() const
-{
- return new CacheMemory(*this);
-}
-
CacheMemory::CacheMemory(const Params &p)
: SimObject(p),
dataArray(p.dataArrayBanks, p.dataAccessLatency,
DPRINTF(RubyStats, "Recorded statistic: %s\n",
DirectoryRequestType_to_string(requestType));
}
-
-DirectoryMemory *
-RubyDirectoryMemoryParams::create() const
-{
- return new DirectoryMemory(*this);
-}
#include "mem/ruby/slicc_interface/RubySlicc_ComponentMapping.hh"
#include "mem/ruby/system/RubySystem.hh"
-RubyPrefetcher*
-RubyPrefetcherParams::create() const
-{
- return new RubyPrefetcher(*this);
-}
-
RubyPrefetcher::RubyPrefetcher(const Params &p)
: SimObject(p), m_num_streams(p.num_streams),
m_array(p.num_streams), m_train_misses(p.train_misses),
WireBuffer::wakeup()
{
}
-
-WireBuffer *
-RubyWireBufferParams::create() const
-{
- return new WireBuffer(*this);
-}
DPRINTF(RubyStats, "Recorded statistic: %s\n",
DMASequencerRequestType_to_string(requestType));
}
-
-DMASequencer *
-DMASequencerParams::create() const
-{
- return new DMASequencer(*this);
-}
}
}
-HTMSequencer *
-RubyHTMSequencerParams::create() const
-{
- return new HTMSequencer(*this);
-}
-
HTMSequencer::HTMSequencer(const RubyHTMSequencerParams &p)
: Sequencer(p)
{
panic("RubyPortProxy::makeRequest should not be called");
return RequestStatus_NULL;
}
-
-RubyPortProxy*
-RubyPortProxyParams::create() const
-{
- return new RubyPortProxy(*this);
-}
return true;
}
-
-RubySystem *
-RubySystemParams::create() const
-{
- return new RubySystem(*this);
-}
using namespace std;
-Sequencer *
-RubySequencerParams::create() const
-{
- return new Sequencer(*this);
-}
-
Sequencer::Sequencer(const Params &p)
: RubyPort(p), m_IncompleteTimes(MachineType_NUM),
deadlockCheckEvent([this]{ wakeup(); }, "Sequencer deadlock check")
using namespace std;
-VIPERCoalescer *
-VIPERCoalescerParams::create() const
-{
- return new VIPERCoalescer(*this);
-}
-
VIPERCoalescer::VIPERCoalescer(const Params &p)
: GPUCoalescer(p),
m_cache_inv_pkt(nullptr),
{
return ranges;
}
-
-SerialLink *
-SerialLinkParams::create() const
-{
- return new SerialLink(*this);
-}
{
memory.recvRespRetry();
}
-
-SimpleMemory*
-SimpleMemoryParams::create() const
-{
- return new SimpleMemory(*this);
-}
num_in_ports = len(self.in_ports)
code('''
-$c_ident *
-${c_ident}Params::create() const
-{
- return new $c_ident(*this);
-}
-
int $c_ident::m_num_controllers = 0;
std::vector<Stats::Vector *> $c_ident::eventVec;
std::vector<std::vector<Stats::Vector *> > $c_ident::transVec;
.desc("Number of snoops hitting in the snoop filter with multiple "\
"(>1) holders of the requested data.");
}
-
-SnoopFilter *
-SnoopFilterParams::create() const
-{
- return new SnoopFilter(*this);
-}
signalPerfLevelUpdate();
}
-SrcClockDomain *
-SrcClockDomainParams::create() const
-{
- return new SrcClockDomain(*this);
-}
-
DerivedClockDomain::DerivedClockDomain(const Params &p) :
ClockDomain(p, p.clk_domain->voltageDomain()),
parent(*p.clk_domain),
(*c)->updateClockPeriod();
}
}
-
-DerivedClockDomain *
-DerivedClockDomainParams::create() const
-{
- return new DerivedClockDomain(*this);
-}
}
UpdateEvent::dvfsHandler = this;
}
-
-DVFSHandler*
-DVFSHandlerParams::create() const
-{
- return new DVFSHandler(*this);
-}
{
kernelSymtab.unserialize("symtab", cp);
}
-
-KernelWorkload *
-KernelWorkloadParams::create() const
-{
- return new KernelWorkload(*this);
-}
{
PowerModelState::regStats();
}
-
-MathExprPowerModel*
-MathExprPowerModelParams::create() const
-{
- return new MathExprPowerModel(*this);
-}
));
}
-PowerModel*
-PowerModelParams::create() const
-{
- return new PowerModel(*this);
-}
-
double
PowerModel::getDynamicPower() const
{
ppThermalUpdate->notify(node->temp);
}
-ThermalDomain *
-ThermalDomainParams::create() const
-{
- return new ThermalDomain(*this);
-}
-
void
ThermalDomain::serialize(CheckpointOut &cp) const
{
{
}
-ThermalReference *
-ThermalReferenceParams::create() const
-{
- return new ThermalReference(*this);
-}
-
void
ThermalReference::serialize(CheckpointOut &cp) const
{
{
}
-ThermalResistor *
-ThermalResistorParams::create() const
-{
- return new ThermalResistor(*this);
-}
-
void
ThermalResistor::serialize(CheckpointOut &cp) const
{
{
}
-ThermalCapacitor *
-ThermalCapacitorParams::create() const
-{
- return new ThermalCapacitor(*this);
-}
-
void
ThermalCapacitor::serialize(CheckpointOut &cp) const
{
{
}
-ThermalModel *
-ThermalModelParams::create() const
-{
- return new ThermalModel(*this);
-}
-
void
ThermalModel::serialize(CheckpointOut &cp) const
{
: SimObject(p), id(-1), isref(false), temp(0.0f)
{
}
-
-ThermalNode *
-ThermalNodeParams::create() const
-{
- return new ThermalNode(*this);
-}
.flags(Stats::nozero)
;
}
-
-PowerDomain*
-PowerDomainParams::create() const
-{
- return new PowerDomain(*this);
-}
*/
powerState.computeStats();
}
-
-PowerState*
-PowerStateParams::create() const
-{
- return new PowerState(*this);
-}
manager->removeListener(name, *this);
}
-ProbeListenerObject*
-ProbeListenerObjectParams::create() const
-{
- return new ProbeListenerObject(*this);
-}
-
bool
ProbeManager::addListener(std::string pointName, ProbeListener &listener)
{
_hostPaths.push_back(normalizePath(hp));
}
}
-
-RedirectPath*
-RedirectPathParams::create() const
-{
- return new RedirectPath(*this);
-}
{
tc->getProcessPtr()->syscall(tc);
}
-
-SEWorkload *
-SEWorkloadParams::create() const
-{
- return new SEWorkload(*this);
-}
ret += obj->getStaticPower();
return ret;
}
-
-SubSystem *
-SubSystemParams::create() const
-{
- return new SubSystem(*this);
-}
const auto& requestor_info = requestors[requestor_id];
return requestor_info.req_name;
}
-
-System *
-SystemParams::create() const
-{
- return new System(*this);
-}
}
}
-VoltageDomain *
-VoltageDomainParams::create() const
-{
- return new VoltageDomain(*this);
-}
-
void
VoltageDomain::serialize(CheckpointOut &cp) const
{
projects / gem5.git / commitdiff