Alternative to `static mut` and unsafe while managing global application state [duplicate] - rust

Question

This question already has answers here:
How do I create a global, mutable singleton?
(7 answers)
Closed 4 months ago.
Background
I have been learning rust recently and my most recent project involves setting a global APP_STATE that can then be accessed throughout the app. There are a few other globals as well.
Note: These variables pretty much need to be globals, otherwise I will have to pass them as arguments into every function and trait I have - which is not very elegant.
The Problem
The aforementioned globals are mutable, i.e they are represented like the following:
pub Struct AppState {
running: bool
suspended: bool
}
static mut APP_STATE = AppState {running: true, suspended:false}
To access these values, I must use unsafe like so: (Ignore the logic of code itself, just an example)
pub unsafe fn create_app {
APP_STATE.running = true;
APP_STATE.suspended = false;
}
unsafe fn confirm_app_state_valid() {
if APP_STATE.running == APP_STATE.suspended { // equality on booleans is just the XNOR(Logical Bi-conditional) operator.
fatal("Fatal! App was both running and suspended at same time. Could not resolve. Crashed")
};
}
The Question
How can I change my code to
remove the unsafe (I understand why having unsafe is needed for mutable statics - avoid race conditions). Note that my app uses concurrency and performance is critical(graphics).
I want to remove the unsafe or atleast reduce its usage - currently it encompasses the entire main loop.
not have to pass state as an argument everywhere
Already looked at this. I did not understand how I might implement the solution provided here.

Answer 1

If you absolutely want some static global state, you can use once_cell in conjunction with a Mutex (see the example below).
However, I don't understand your remark « which is clearly not optimal » about passing the state as a parameter; do you mean inelegant or inefficient?
Moreover, you state « performance is critical »; in my opinion, this static global state requiring runtime borrow checking at each access is less efficient than the usual static borrow checking.
use once_cell::sync::OnceCell;
use std::sync::{Mutex, MutexGuard};
#[derive(Debug)]
struct AppState {
running: bool,
suspended: bool,
}
static APP_STATE: OnceCell<Mutex<AppState>> = OnceCell::new();
fn access_app_state() -> MutexGuard<'static, AppState> {
APP_STATE.get().unwrap().lock().unwrap()
}
fn confirm_app_state_valid() {
let app_state = access_app_state();
if app_state.running == app_state.suspended {
panic!("Fatal! App was both running and suspended at same time...");
}
println!("App state is correct: {:?}", app_state);
}
fn change_app_state() {
let mut app_state = access_app_state();
app_state.running = !app_state.running;
app_state.suspended = !app_state.suspended;
}
fn main() {
APP_STATE
.set(Mutex::new(AppState {
running: true,
suspended: false,
}))
.unwrap();
confirm_app_state_valid();
change_app_state();
confirm_app_state_valid();
}
/*
App state is correct: AppState { running: true, suspended: false }
App state is correct: AppState { running: false, suspended: true }
*/
As stated by Chayim Friedman in a comment, since Rust 1.63 Mutex::new() is const.
We can get rid of once_cell and just initialise the global mutex with a content which is known at compile-time.
use std::sync::{Mutex, MutexGuard};
#[derive(Debug)]
struct AppState {
running: bool,
suspended: bool,
}
static APP_STATE: Mutex<AppState> = Mutex::new(AppState {
running: true,
suspended: false,
});
fn access_app_state() -> MutexGuard<'static, AppState> {
APP_STATE.lock().unwrap()
}
fn confirm_app_state_valid() {
let app_state = access_app_state();
if app_state.running == app_state.suspended {
panic!("Fatal! App was both running and suspended at same time...");
}
println!("App state is correct: {:?}", app_state);
}
fn change_app_state() {
let mut app_state = access_app_state();
app_state.running = !app_state.running;
app_state.suspended = !app_state.suspended;
}
fn main() {
confirm_app_state_valid();
change_app_state();
confirm_app_state_valid();
}
/*
App state is correct: AppState { running: true, suspended: false }
App state is correct: AppState { running: false, suspended: true }
*/