# See CONTRIBUTING.md for details of gem5's contribution process.
#
# This file contains a list of gem5's subsystems and their
# maintainers. The key used to identifity a subsystem should be used
# as a tag in commit messages targetting that subsystem. At least one
# (not all) of these maintainers must review the patch before it can
# be pushed. These people will automatically be emailed when you
# upload the patch to Gerrit (https://gem5-review.googlesource.com).
# These subsystem keys mostly follow the directory structure.
#
# Maintainers have the following responsibilities:
# 1. That at least one maintainer of each subsystem reviews all
#    changes to that subsystem (they will be automatically tagged and
#    emailed on each new change).
# 2. They will complete your reviews in a timely manner (within a few
#    business days).
# 3. They pledge to uphold gem5's community standards and its code of
#    conduct by being polite and professional in their code
#    reviews. See CODE-OF-CONDUCT.md.
#
#
# Entries in this file have the following format:
#   key:
#     desc: >-
#       Optional description of the subsystem.
#     status: maintained
#     maintainers:
#       - John Doe <john.doe@gem5.org>
#       - Jane Doe <jane.doe@gem5.org>
#
#
# The status field should have one of the following values:
#   - maintained: The component has an active maintainer.
#   - orphaned: The component is looking for a new owner.


pmc:
  desc: >-
    PMC Members (general maintainers):
  status: maintained
  maintainers:
    - Andreas Sandberg <andreas.sandberg@arm.com>
    - Brad Beckmann <bradford.beckmann@gmail.com>
    - David Wood <david@cs.wisc.edu>
    - Gabe Black <gabe.black@gmail.com>
    - Giacomo Travaglini <giacomo.travaglini@arm.com>
    - Jason Lowe-Power <jason@lowepower.com> (chair)
    - Matt Sinclair <sinclair@cs.wisc.edu>
    - Tony Gutierrez <anthony.gutierrez@amd.com>
    - Steve Reinhardt <stever@gmail.com>

arch:
  desc: >-
    General architecture-specific components
  status: maintained
  maintainers:
    - Gabe Black <gabe.black@gmail.com>

arch-arm:
  status: maintained
  maintainers:
    - Andreas Sandberg <andreas.sandberg@arm.com>
    - Giacomo Travaglini <giacomo.travaglini@arm.com>

arch-gcn3:
  status: maintained
  maintainers:
    - Matt Poremba <matthew.poremba@amd.com>
    - Matt Sinclair <sinclair@cs.wisc.edu>

arch-vega:
  status: maintained
  maintainers:
    - Matt Poremba <matthew.poremba@amd.com>
    - Matt Sinclair <sinclair@cs.wisc.edu>

arch-mips:
  status: orphaned

arch-power:
  status: maintained
  maintainers:
    - Boris Shingarov <shingarov@labware.com>

arch-riscv:
  status: orphaned

arch-sparc:
  status: maintained
  maintainers:
    - Gabe Black <gabe.black@gmail.com>

arch-x86:
  status: maintained
  maintainers:
    - Gabe Black <gabe.black@gmail.com>

base:
  status: maintained
  maintainers:
    - Bobby Bruce <bbruce@ucdavis.edu>
    - Daniel Carvalho <odanrc@yahoo.com.br>

base-stats:
  status: orphaned

configs:
  status: maintained
  maintainers:
    - Jason Lowe-Power <jason@lowepower.com>

cpu:
  desc: >-
    General changes to all CPU models (e.g., BaseCPU)
  status: maintained
  maintainers:
    - Gabe Black <gabe.black@gmail.com>
    - Jason Lowe-Power <jason@lowepower.com>

cpu-kvm:
  status: maintained
  maintainers:
    - Andreas Sandberg <andreas.sandberg@arm.com>

cpu-minor:
  status: maintained
  maintainers:
    - Zhengrong Wang <seanyukigeek@gmail.com>

cpu-o3:
  status: orphaned

cpu-simple:
  status: maintained
  maintainers:
    - Jason Lowe-Power <jason@lowepower.com>
    - Gabe Black <gabe.black@gmail.com>

dev:
  status: maintained
  maintainers:
    - Gabe Black <gabe.black@gmail.com>

dev-hsa:
  status: maintained
  maintainers:
    - Matt Poremba <matthew.poremba@amd.com>

dev-amdgpu:
  status: maintained
  maintainers:
    - Matt Poremba <matthew.poremba@amd.com>

dev-virtio:
  status: maintained
  maintainers:
    - Andreas Sandberg <andreas.sandberg@arm.com>

dev-arm:
  status: maintained
  maintainers:
    - Andreas Sandberg <andreas.sandberg@arm.com>
    - Giacomo Travaglini <giacomo.travaglini@arm.com>

doc:
  status: maintained
  maintainers:
    - Bobby Bruce <bbruce@ucdavis.edu>

ext:
  desc: >-
    Components external to gem5
  status: maintained
  maintainers:
    - Bobby Bruce <bbruce@ucdavis.edu>
    - Jason Lowe-Power <jason@lowepower.com>

ext-testlib:
  status: maintained
  maintainers:
    - Bobby Bruce <bbruce@ucdavis.edu>
    - Hoa Nguyen <hoanguyen@ucdavis.edu>

fastmodel:
  desc: >-
    Changes relating to ARM Fast Models
  status: maintained
  maintainers:
    - Gabe Black <gabe.black@gmail.com>

gpu-compute:
  status: maintained
  maintainers:
    - Matt Poremba <matthew.poremba@amd.com>
    - Matt Sinclair <sinclair@cs.wisc.edu>

learning-gem5:
  desc: >-
    The code and configs for the Learning gem5 book
  status: maintained
  maintainers:
    - Jason Lowe-Power <jason@lowepower.com>

mem:
  desc: >-
    General memory system (e.g., XBar, Packet)
  status: maintained
  maintainers:
    - Nikos Nikoleris <nikos.nikoleris@arm.com>

mem-cache:
  desc: >-
    Classic caches and coherence
  status: maintained
  maintainers:
    - Nikos Nikoleris <nikos.nikoleris@arm.com>
    - Daniel Carvalho <odanrc@yahoo.com.br>

mem-dram:
  status: maintained
  maintainers:
    - Nikos Nikoleris <nikos.nikoleris@arm.com>

mem-garnet:
  desc: >-
    Garnet subcomponent of Ruby
  status: maintained
  maintainers:
    - Srikant Bharadwaj <srikant.bharadwaj@amd.com>

mem-ruby:
  desc: >-
    Ruby structures and protocols
  status: maintained
  maintainers:
    - Jason Lowe-Power <jason@lowepower.com>
    - Matt Sinclair <sinclair@cs.wisc.edu>

misc:
  desc: >-
    Anything outside of the other categories
  status: maintained
  maintainers:
    - Bobby Bruce <bbruce@ucdavis.edu>
    - Jason Lowe-Power <jason@lowepower.com>

python:
  desc: >-
    Python SimObject wrapping and infrastructure
  status: maintained
  maintainers:
    - Andreas Sandberg <andreas.sandberg@arm.com>
    - Jason Lowe-Power <jason@lowepower.com>

resources:
  desc: >-
    The gem5-resources repo with auxiliary resources for simulation
  status: maintained
  maintainers:
    - Bobby Bruce <bbruce@ucdavis.edu>
    - Jason Lowe-Power <jason@lowepower.com>

scons:
  desc: >-
    Build system
  status: maintained
  maintainers:
    - Gabe Black <gabe.black@gmail.com>

sim:
  desc: >-
    General simulation components
  status: maintained
  maintainers:
    - Jason Lowe-Power <jason@lowepower.com>

sim-se:
  desc: >-
    Syscall emulation
  status: orphaned

system-arm:
  status: maintained
  maintainers:
    - Andreas Sandberg <andreas.sandberg@arm.com>
    - Giacomo Travaglini <giacomo.travaglini@arm.com>

systemc:
  desc: >-
    Code for the gem5 SystemC implementation and interface
  status: maintained
  maintainers:
    - Gabe Black <gabe.black@gmail.com>

tests:
  desc: >-
    testing changes
  status: maintained
  maintainers:
    - Bobby Bruce <bbruce@ucdavis.edu>

util:
  status: maintained
  maintainers:
    - Gabe Black <gabe.black@gmail.com>

util-docker:
  status: maintained
  maintainers:
    - Bobby Bruce <bbruce@ucdavis.edu>

util-m5:
  status: maintained
  maintainers:
    - Gabe Black <gabe.black@gmail.com>

util-gem5art:
  status: maintained
  maintainers:
    - Bobby Bruce <bbruce@ucdavis.edu>
    - Jason Lowe-Power <jason@lowepower.com>

website:
  desc: >-
    The gem5-website repo which contains the gem5.org site
  status: maintained
  maintainers:
    - Bobby Bruce <bbruce@ucdavis.edu>
    - Hoa Nguyen <hoanguyen@ucdavis.edu>
