Rename core_view to system_view

Summary: Similar to previous diff. Update core_view to system_view since it contains basic system info and has shortcut 's' which comes from "system".

Reviewed By: brianc118

Differential Revision: D56504775

fbshipit-source-id: 718f5bafbcddb22af8012d5e51528a616f1efe46

6 files changed, 95 insertions, 95 deletions

diff --git a/below/view/src/controllers/view_controllers.rs b/below/view/src/controllers/view_controllers.rs
index 071adafa..c4210857 100644
--- a/below/view/src/controllers/view_controllers.rs
+++ b/below/view/src/controllers/view_controllers.rs
@@ -222,7 +222,7 @@ make_event_controller!(
     vec![Event::Char('s')],
     |_view: &mut StatsView<T>, _cmd_vec: &[&str]| {},
     |c: &mut Cursive, _cmd_vec: &[&str]| {
-        set_active_screen(c, "core_view_panel");
+        set_active_screen(c, "system_view_panel");
 
         let current_state = c
             .user_data::<ViewState>()
@@ -239,7 +239,7 @@ make_event_controller!(
         }
         c.user_data::<ViewState>()
             .expect("No data stored in Cursive object!")
-            .main_view_state = MainViewState::Core;
+            .main_view_state = MainViewState::System;
     }
 );
 
@@ -307,7 +307,7 @@ make_event_controller!(
                 // Bring cgroup_view to front
                 set_active_screen(c, "cgroup_view_panel");
             }
-            MainViewState::Core => {}
+            MainViewState::System => {}
             #[cfg(fbcode_build)]
             MainViewState::Gpu => {}
         }
diff --git a/below/view/src/filter_popup.rs b/below/view/src/filter_popup.rs
index 42a3d5d7..a4f95077 100644
--- a/below/view/src/filter_popup.rs
+++ b/below/view/src/filter_popup.rs
@@ -37,7 +37,7 @@ fn set_cp_filter(c: &mut Cursive, field_info: Option<(String, String)>) {
     match state {
         MainViewState::Cgroup => crate::cgroup_view::ViewType::cp_filter(c, field_info),
         MainViewState::Process(_) => crate::process_view::ViewType::cp_filter(c, field_info),
-        MainViewState::Core => crate::core_view::ViewType::cp_filter(c, field_info),
+        MainViewState::System => crate::system_view::ViewType::cp_filter(c, field_info),
         #[cfg(fbcode_build)]
         MainViewState::Gpu => crate::gpu_view::ViewType::cp_filter(c, field_info),
     }
diff --git a/below/view/src/help_menu.rs b/below/view/src/help_menu.rs
index c8a4453f..856e1a1b 100644
--- a/below/view/src/help_menu.rs
+++ b/below/view/src/help_menu.rs
@@ -92,7 +92,7 @@ fn get_description(controller: &Controllers) -> &'static str {
         Controllers::Help => "Toggle help menu.",
         Controllers::Process => "Show process view.",
         Controllers::Cgroup => "Show cgroup view.",
-        Controllers::System => "Show system core view.",
+        Controllers::System => "Show system view.",
         Controllers::Gpu => "Show GPU view.",
         Controllers::GpuZoom => "Zoom into process view filtered by selected GPU.",
         Controllers::GpuProcess => "Zoom into process view for all GPU processes.",
diff --git a/below/view/src/lib.rs b/below/view/src/lib.rs
index 59859d07..8ecb2440 100644
--- a/below/view/src/lib.rs
+++ b/below/view/src/lib.rs
@@ -95,8 +95,6 @@ open_source_shim!();
 mod cgroup_tabs;
 pub mod cgroup_view;
 pub mod command_palette;
-mod core_tabs;
-mod core_view;
 mod default_styles;
 mod filter_popup;
 mod help_menu;
@@ -106,6 +104,8 @@ mod render;
 pub mod stats_view;
 mod status_bar;
 mod summary_view;
+mod system_tabs;
+mod system_view;
 mod tab_view;
 
 pub struct View {
@@ -146,7 +146,7 @@ macro_rules! view_warn {
             crate::MainViewState::Cgroup => crate::cgroup_view::ViewType::cp_warn($c, &msg),
             crate::MainViewState::Process(_) =>
                 crate::process_view::ViewType::cp_warn($c, &msg),
-            crate::MainViewState::Core => crate::core_view::ViewType::cp_warn($c, &msg),
+            crate::MainViewState::System => crate::system_view::ViewType::cp_warn($c, &msg),
             #[cfg(fbcode_build)]
             crate::MainViewState::Gpu => crate::gpu_view::ViewType::cp_warn($c, &msg),
         }
@@ -170,7 +170,7 @@ pub enum ProcessZoomState {
 pub enum MainViewState {
     Cgroup,
     Process(ProcessZoomState),
-    Core,
+    System,
     #[cfg(fbcode_build)]
     Gpu,
 }
@@ -204,7 +204,7 @@ fn refresh(c: &mut Cursive) {
     match current_state {
         MainViewState::Cgroup => cgroup_view::CgroupView::refresh(c),
         MainViewState::Process(_) => process_view::ProcessView::refresh(c),
-        MainViewState::Core => core_view::CoreView::refresh(c),
+        MainViewState::System => system_view::SystemView::refresh(c),
         #[cfg(fbcode_build)]
         MainViewState::Gpu => gpu_view::GpuView::refresh(c),
     }
@@ -406,7 +406,7 @@ impl View {
         let summary_view = summary_view::new(&mut self.inner);
         let cgroup_view = cgroup_view::CgroupView::new(&mut self.inner, &viewrc);
         let process_view = process_view::ProcessView::new(&mut self.inner);
-        let core_view = core_view::CoreView::new(&mut self.inner);
+        let system_view = system_view::SystemView::new(&mut self.inner);
         #[cfg(fbcode_build)]
         let gpu_view = gpu_view::GpuView::new(&mut self.inner);
 
@@ -427,8 +427,8 @@ impl View {
             ))),
         );
         main_view_screens.insert(
-            "core_view_panel".to_owned(),
-            screens_view.add_screen(BoxedView::boxed(ResizedView::with_full_screen(core_view))),
+            "system_view_panel".to_owned(),
+            screens_view.add_screen(BoxedView::boxed(ResizedView::with_full_screen(system_view))),
         );
         #[cfg(fbcode_build)]
         main_view_screens.insert(
@@ -468,8 +468,8 @@ impl View {
                     set_active_screen(&mut self.inner, "process_view_panel")
                 }
                 viewrc::DefaultFrontView::System => {
-                    *main_view_state = MainViewState::Core;
-                    set_active_screen(&mut self.inner, "core_view_panel")
+                    *main_view_state = MainViewState::System;
+                    set_active_screen(&mut self.inner, "system_view_panel")
                 }
             }
         }
@@ -538,7 +538,7 @@ pub mod fake_view {
             user_data.main_view_screens = [
                 ("cgroup_view_panel".to_owned(), 0),
                 ("process_view_panel".to_owned(), 0),
-                ("core_view_panel".to_owned(), 0),
+                ("system_view_panel".to_owned(), 0),
             ]
             .into();
             inner.set_user_data(user_data);
diff --git a/below/view/src/core_tabs.rs b/below/view/src/system_tabs.rs
index e3fb66cb..b7f03201 100644
--- a/below/view/src/core_tabs.rs
+++ b/below/view/src/system_tabs.rs
@@ -26,16 +26,16 @@ use model::BtrfsModel;
 use model::Queriable;
 use model::SingleSlabModel;
 
-use crate::core_view::CoreState;
-use crate::core_view::CoreStateFieldId;
 use crate::render::ViewItem;
 use crate::stats_view::ColumnTitles;
 use crate::stats_view::StateCommon;
+use crate::system_view::SystemState;
+use crate::system_view::SystemStateFieldId;
 
 const FIELD_NAME_WIDTH: usize = 20;
 const FIELD_WIDTH: usize = 20;
 
-pub trait CoreTab {
+pub trait SystemTab {
     fn get_titles(&self) -> ColumnTitles {
         ColumnTitles {
             titles: vec![
@@ -46,13 +46,13 @@ pub trait CoreTab {
         }
     }
 
-    fn get_rows(&self, state: &CoreState, offset: Option<usize>) -> Vec<(StyledString, String)>;
+    fn get_rows(&self, state: &SystemState, offset: Option<usize>) -> Vec<(StyledString, String)>;
 }
 
 #[derive(Default, Clone)]
-pub struct CoreCpu;
+pub struct SystemCpu;
 
-impl CoreTab for CoreCpu {
+impl SystemTab for SystemCpu {
     fn get_titles(&self) -> ColumnTitles {
         ColumnTitles {
             titles: enum_iterator::all::<SingleCpuModelFieldId>()
@@ -62,13 +62,13 @@ impl CoreTab for CoreCpu {
         }
     }
 
-    fn get_rows(&self, state: &CoreState, offset: Option<usize>) -> Vec<(StyledString, String)> {
+    fn get_rows(&self, state: &SystemState, offset: Option<usize>) -> Vec<(StyledString, String)> {
         let model = state.get_model();
         model
             .cpus
             .values()
             .filter(|scm| {
-                if let Some((CoreStateFieldId::Cpu(field), filter)) = &state.filter_info {
+                if let Some((SystemStateFieldId::Cpu(field), filter)) = &state.filter_info {
                     match scm.query(field) {
                         None => true,
                         Some(value) => value.to_string().starts_with(filter),
@@ -105,10 +105,10 @@ impl CoreTab for CoreCpu {
 }
 
 #[derive(Default, Clone)]
-pub struct CoreMem;
+pub struct SystemMem;
 
-impl CoreTab for CoreMem {
-    fn get_rows(&self, state: &CoreState, _offset: Option<usize>) -> Vec<(StyledString, String)> {
+impl SystemTab for SystemMem {
+    fn get_rows(&self, state: &SystemState, _offset: Option<usize>) -> Vec<(StyledString, String)> {
         let model = state.get_model();
 
         enum_iterator::all::<MemoryModelFieldId>()
@@ -134,10 +134,10 @@ impl CoreTab for CoreMem {
 }
 
 #[derive(Default, Clone)]
-pub struct CoreVm;
+pub struct SystemVm;
 
-impl CoreTab for CoreVm {
-    fn get_rows(&self, state: &CoreState, _offset: Option<usize>) -> Vec<(StyledString, String)> {
+impl SystemTab for SystemVm {
+    fn get_rows(&self, state: &SystemState, _offset: Option<usize>) -> Vec<(StyledString, String)> {
         let model = state.get_model();
 
         enum_iterator::all::<VmModelFieldId>()
@@ -163,9 +163,9 @@ impl CoreTab for CoreVm {
 }
 
 #[derive(Default, Clone)]
-pub struct CoreSlab;
+pub struct SystemSlab;
 
-impl CoreTab for CoreSlab {
+impl SystemTab for SystemSlab {
     fn get_titles(&self) -> ColumnTitles {
         ColumnTitles {
             titles: enum_iterator::all::<SingleSlabModelFieldId>()
@@ -175,11 +175,11 @@ impl CoreTab for CoreSlab {
         }
     }
 
-    fn get_rows(&self, state: &CoreState, _offset: Option<usize>) -> Vec<(StyledString, String)> {
+    fn get_rows(&self, state: &SystemState, _offset: Option<usize>) -> Vec<(StyledString, String)> {
         let model = state.get_model();
         let mut slab: Vec<&SingleSlabModel> = model.slab.values().collect();
 
-        if let Some(CoreStateFieldId::Slab(sort_order)) = state.sort_order.as_ref() {
+        if let Some(SystemStateFieldId::Slab(sort_order)) = state.sort_order.as_ref() {
             model::sort_queriables(&mut slab, sort_order, state.reverse);
         }
 
@@ -208,9 +208,9 @@ impl CoreTab for CoreSlab {
 }
 
 #[derive(Default, Clone)]
-pub struct CoreDisk;
+pub struct SystemDisk;
 
-impl CoreTab for CoreDisk {
+impl SystemTab for SystemDisk {
     fn get_titles(&self) -> ColumnTitles {
         ColumnTitles {
             titles: enum_iterator::all::<SingleDiskModelFieldId>()
@@ -220,7 +220,7 @@ impl CoreTab for CoreDisk {
         }
     }
 
-    fn get_rows(&self, state: &CoreState, offset: Option<usize>) -> Vec<(StyledString, String)> {
+    fn get_rows(&self, state: &SystemState, offset: Option<usize>) -> Vec<(StyledString, String)> {
         state
             .get_model()
             .disks
@@ -268,17 +268,17 @@ impl CoreTab for CoreDisk {
 type BtrfsViewItem = ViewItem<model::BtrfsModelFieldId>;
 
 #[derive(Default, Clone)]
-pub struct CoreBtrfs {
+pub struct SystemBtrfs {
     pub view_items: Vec<BtrfsViewItem>,
 }
 
-impl CoreBtrfs {
+impl SystemBtrfs {
     fn new(view_items: Vec<BtrfsViewItem>) -> Self {
         Self { view_items }
     }
 }
 
-impl CoreTab for CoreBtrfs {
+impl SystemTab for SystemBtrfs {
     fn get_titles(&self) -> ColumnTitles {
         ColumnTitles {
             titles: enum_iterator::all::<BtrfsModelFieldId>()
@@ -288,18 +288,18 @@ impl CoreTab for CoreBtrfs {
         }
     }
 
-    fn get_rows(&self, state: &CoreState, _offset: Option<usize>) -> Vec<(StyledString, String)> {
+    fn get_rows(&self, state: &SystemState, _offset: Option<usize>) -> Vec<(StyledString, String)> {
         if let Some(btrfs_model) = state.get_model().btrfs.as_ref() {
             let mut subvolumes: Vec<&BtrfsModel> = btrfs_model.values().collect();
 
-            if let Some(CoreStateFieldId::Btrfs(sort_order)) = state.sort_order.as_ref() {
+            if let Some(SystemStateFieldId::Btrfs(sort_order)) = state.sort_order.as_ref() {
                 model::sort_queriables(&mut subvolumes, sort_order, state.reverse);
             }
 
             subvolumes
                 .iter()
                 .filter(|bmodel| {
-                    if let Some((CoreStateFieldId::Btrfs(field), filter)) = &state.filter_info {
+                    if let Some((SystemStateFieldId::Btrfs(field), filter)) = &state.filter_info {
                         match bmodel.query(field) {
                             None => true,
                             Some(value) => value.to_string().contains(filter),
@@ -338,14 +338,14 @@ pub mod default_tabs {
 
     use super::*;
 
-    pub static CORE_BTRFS_TAB: Lazy<CoreBtrfs> = Lazy::new(|| {
-        CoreBtrfs::new(vec![
+    pub static SYSTEM_BTRFS_TAB: Lazy<SystemBtrfs> = Lazy::new(|| {
+        SystemBtrfs::new(vec![
             ViewItem::from_default(Name),
             ViewItem::from_default(DiskFraction),
             ViewItem::from_default(DiskBytes),
         ])
     });
-    pub enum CoreTabs {
-        Btrfs(&'static CoreBtrfs),
+    pub enum SystemTabs {
+        Btrfs(&'static SystemBtrfs),
     }
 }
diff --git a/below/view/src/core_view.rs b/below/view/src/system_view.rs
index 6780e0b5..cb05043d 100644
--- a/below/view/src/core_view.rs
+++ b/below/view/src/system_view.rs
@@ -33,31 +33,31 @@ use model::SingleDiskModelFieldId;
 use model::SingleSlabModelFieldId;
 use model::VmModelFieldId;
 
-use crate::core_tabs::*;
 use crate::stats_view::ColumnTitles;
 use crate::stats_view::StateCommon;
 use crate::stats_view::StatsView;
 use crate::stats_view::ViewBridge;
+use crate::system_tabs::*;
 use crate::ViewState;
 
-pub type ViewType = StatsView<CoreView>;
+pub type ViewType = StatsView<SystemView>;
 
-use crate::core_view::default_tabs::CORE_BTRFS_TAB;
+use crate::system_view::default_tabs::SYSTEM_BTRFS_TAB;
 
-// TODO(T123679020): Ideally we want to decouple states for core view tabs.
-// Each core view tab really deserves its own view and state
+// TODO(T123679020): Ideally we want to decouple states for system view tabs.
+// Each system view tab really deserves its own view and state
 #[derive(Default)]
-pub struct CoreState {
-    pub filter_info: Option<(CoreStateFieldId, String)>,
+pub struct SystemState {
+    pub filter_info: Option<(SystemStateFieldId, String)>,
     pub collapsed_disk: HashSet<String>,
     pub model: Rc<RefCell<SystemModel>>,
-    pub sort_order: Option<CoreStateFieldId>,
-    pub sort_tags: HashMap<String, default_tabs::CoreTabs>,
+    pub sort_order: Option<SystemStateFieldId>,
+    pub sort_tags: HashMap<String, default_tabs::SystemTabs>,
     pub reverse: bool,
 }
 
 #[derive(PartialEq)]
-pub enum CoreStateFieldId {
+pub enum SystemStateFieldId {
     Disk(SingleDiskModelFieldId),
     Btrfs(BtrfsModelFieldId),
     Cpu(SingleCpuModelFieldId),
@@ -66,7 +66,7 @@ pub enum CoreStateFieldId {
     Slab(SingleSlabModelFieldId),
 }
 
-impl std::string::ToString for CoreStateFieldId {
+impl std::string::ToString for SystemStateFieldId {
     fn to_string(&self) -> String {
         match self {
             Self::Disk(field) => field.to_string(),
@@ -79,9 +79,9 @@ impl std::string::ToString for CoreStateFieldId {
     }
 }
 
-impl StateCommon for CoreState {
+impl StateCommon for SystemState {
     type ModelType = SystemModel;
-    type TagType = CoreStateFieldId;
+    type TagType = SystemStateFieldId;
     type KeyType = String;
 
     fn get_filter_info(&self) -> &Option<(Self::TagType, String)> {
@@ -89,7 +89,7 @@ impl StateCommon for CoreState {
     }
 
     fn is_filter_supported_from_tab_idx(&self, _tab: &str, idx: usize) -> bool {
-        // we only enable str filtering for first col for Core View
+        // we only enable str filtering for first col for System View
         if idx == 0 {
             return true;
         }
@@ -99,13 +99,13 @@ impl StateCommon for CoreState {
     fn get_tag_from_tab_idx(&self, tab: &str, idx: usize) -> Self::TagType {
         match tab {
             "Btrfs" => {
-                let core_tab = self
+                let system_tab = self
                     .sort_tags
                     .get(tab)
                     .unwrap_or_else(|| panic!("Fail to find tab: {}", tab));
-                let default_tabs::CoreTabs::Btrfs(core_tab) = core_tab;
+                let default_tabs::SystemTabs::Btrfs(system_tab) = system_tab;
                 Self::TagType::Btrfs(
-                    core_tab
+                    system_tab
                         .view_items
                         .get(idx)
                         .expect("Out of title scope")
@@ -113,15 +113,15 @@ impl StateCommon for CoreState {
                         .to_owned(),
                 )
             }
-            "CPU" => CoreStateFieldId::Cpu(SingleCpuModelFieldId::Idx),
-            "Disk" => CoreStateFieldId::Disk(SingleDiskModelFieldId::Name),
+            "CPU" => SystemStateFieldId::Cpu(SingleCpuModelFieldId::Idx),
+            "Disk" => SystemStateFieldId::Disk(SingleDiskModelFieldId::Name),
             // tabs Mem and Vm have two columns 'Field' and 'Value'. 'Field' contains
             // a list of all the FieldIds in MemoryModel and VmModel respectively.
             // the field given to filter_info don't matter for these tabs because
             // they don't use FieldId as column titles/selected col (it isn't used to filter)
-            "Mem" => CoreStateFieldId::Mem(MemoryModelFieldId::Total),
-            "Vm" => CoreStateFieldId::Vm(VmModelFieldId::PgpginPerSec),
-            "Slab" => CoreStateFieldId::Slab(
+            "Mem" => SystemStateFieldId::Mem(MemoryModelFieldId::Total),
+            "Vm" => SystemStateFieldId::Vm(VmModelFieldId::PgpginPerSec),
+            "Slab" => SystemStateFieldId::Slab(
                 enum_iterator::all::<SingleSlabModelFieldId>()
                     .nth(idx)
                     .expect("Tag out of range"),
@@ -170,7 +170,7 @@ impl StateCommon for CoreState {
     fn set_sort_string(&mut self, selection: &str, reverse: &mut bool) -> bool {
         use std::str::FromStr;
         match BtrfsModelFieldId::from_str(selection) {
-            Ok(field_id) => self.set_sort_tag(CoreStateFieldId::Btrfs(field_id), reverse),
+            Ok(field_id) => self.set_sort_tag(SystemStateFieldId::Btrfs(field_id), reverse),
             Err(_) => false,
         }
     }
@@ -187,7 +187,7 @@ impl StateCommon for CoreState {
         let mut sort_tags = HashMap::new();
         sort_tags.insert(
             "Btrfs".into(),
-            default_tabs::CoreTabs::Btrfs(&*CORE_BTRFS_TAB),
+            default_tabs::SystemTabs::Btrfs(&*SYSTEM_BTRFS_TAB),
         );
         Self {
             sort_order: None,
@@ -199,20 +199,20 @@ impl StateCommon for CoreState {
     }
 }
 
-pub enum CoreView {
-    Cpu(CoreCpu),
-    Mem(CoreMem),
-    Vm(CoreVm),
-    Slab(CoreSlab),
-    Disk(CoreDisk),
-    Btrfs(CoreBtrfs),
+pub enum SystemView {
+    Cpu(SystemCpu),
+    Mem(SystemMem),
+    Vm(SystemVm),
+    Slab(SystemSlab),
+    Disk(SystemDisk),
+    Btrfs(SystemBtrfs),
 }
 
-impl CoreView {
+impl SystemView {
     pub fn new(c: &mut Cursive) -> NamedView<ViewType> {
         let mut list = SelectView::<String>::new();
         list.set_on_submit(|c, idx: &String| {
-            let mut view = CoreView::get_core_view(c);
+            let mut view = SystemView::get_system_view(c);
             // We only care about disk not partition
             if view.get_tab_view().get_cur_selected() == "Disk" && idx.ends_with(".0") {
                 if view.state.borrow_mut().collapsed_disk.contains(idx) {
@@ -236,22 +236,22 @@ impl CoreView {
             "Disk".into(),
             "Btrfs".into(),
         ];
-        let mut tabs_map: HashMap<String, CoreView> = HashMap::new();
-        tabs_map.insert("CPU".into(), CoreView::Cpu(Default::default()));
-        tabs_map.insert("Mem".into(), CoreView::Mem(Default::default()));
-        tabs_map.insert("Vm".into(), CoreView::Vm(Default::default()));
-        tabs_map.insert("Slab".into(), CoreView::Slab(Default::default()));
-        tabs_map.insert("Disk".into(), CoreView::Disk(Default::default()));
-        tabs_map.insert("Btrfs".into(), CoreView::Btrfs(Default::default()));
+        let mut tabs_map: HashMap<String, SystemView> = HashMap::new();
+        tabs_map.insert("CPU".into(), SystemView::Cpu(Default::default()));
+        tabs_map.insert("Mem".into(), SystemView::Mem(Default::default()));
+        tabs_map.insert("Vm".into(), SystemView::Vm(Default::default()));
+        tabs_map.insert("Slab".into(), SystemView::Slab(Default::default()));
+        tabs_map.insert("Disk".into(), SystemView::Disk(Default::default()));
+        tabs_map.insert("Btrfs".into(), SystemView::Btrfs(Default::default()));
         let user_data = c
             .user_data::<ViewState>()
             .expect("No data stored in Cursive Object!");
         StatsView::new(
-            "core",
+            "system",
             tabs,
             tabs_map,
             list,
-            CoreState::new(user_data.system.clone()),
+            SystemState::new(user_data.system.clone()),
             user_data.event_controllers.clone(),
             user_data.cmd_controllers.clone(),
         )
@@ -259,15 +259,15 @@ impl CoreView {
         .with_name(Self::get_view_name())
     }
 
-    pub fn get_core_view(c: &mut Cursive) -> ViewRef<ViewType> {
+    pub fn get_system_view(c: &mut Cursive) -> ViewRef<ViewType> {
         ViewType::get_view(c)
     }
 
     pub fn refresh(c: &mut Cursive) {
-        Self::get_core_view(c).refresh(c);
+        Self::get_system_view(c).refresh(c);
     }
 
-    fn get_inner(&self) -> Box<dyn CoreTab> {
+    fn get_inner(&self) -> Box<dyn SystemTab> {
         match self {
             Self::Cpu(inner) => Box::new(inner.clone()),
             Self::Mem(inner) => Box::new(inner.clone()),
@@ -279,10 +279,10 @@ impl CoreView {
     }
 }
 
-impl ViewBridge for CoreView {
-    type StateType = CoreState;
+impl ViewBridge for SystemView {
+    type StateType = SystemState;
     fn get_view_name() -> &'static str {
-        "core_view"
+        "system_view"
     }
     fn get_titles(&self) -> ColumnTitles {
         self.get_inner().get_titles()