thomcc

//! This is a (hopefully) correct implementation of a lockfree stack.
//!
//! Doing this without a memory reclamation implementation requires pointer
//! tagging, which is slightly architecture specific. This supports aarch64 and
//! x86_64 so long as 5-level page tables aren't in use (rare to the point of
//! nonexistence), and arm64e (or other hardware pointer authentication) is not
//! enabled, which is not currently supported by Rust. On x86_64/aarch64 where
//! this doesn't hold, it will panic.
//!
//! That said, while this implementation is believed to be correct, it could

thomcc

#![no_std]
extern crate alloc;
#[cfg(test)]
extern crate std;

use alloc::sync::Arc;
use core::{
    cell::UnsafeCell,
    mem::MaybeUninit,
    ptr::{self, NonNull},

thomcc

//! Note: don't use spin locks unless you're doing something
//! really strange. They only perform well on microbenchmarks.
use core::sync::atomic::{*, Ordering::*};

pub struct SpinLock(AtomicBool);

impl SpinLock {
    #[inline]
    pub const fn new() -> Self {
        Self(AtomicBool::new(false))

thomcc

This got reposted in a better form here: https://shift.click/codelet/codelet-atomic-perf-notes. Or look at the history.

thomcc

//! See https://github.com/ocornut/imgui/issues/3606
use imgui::*;

mod support;

fn main() {
    let system = support::init(file!());
    system.main_loop(move |_, ui| {
        fx_window(ui, 0, |d, a, _b, sz, _mouse, t| {
            for n in 0..(((1.0 + (t * 5.7).sin()) * 40.0) as isize).max(0) {

thomcc

use core::sync::atomic::{*, Ordering::*};
use core::mem::MaybeUninit;
use core::cell::UnsafeCell;

/// A macro similar to `lazy_static::lazy_static!`, but that will attempt to
/// eagerly initialize the static value using [`on_startup!`](crate::on_startup).
#[macro_export]
macro_rules! eager_static {
    ($(
        $(#[$attr:meta])*

thomcc

#![cfg_attr(all(feature = "std", not(feature = "getrandom")), no_std)]

mod get_random;

#[repr(C, align(16))]
pub struct ChaCha8 {
    state: [u32; 16],
    seed: [u32; 8],
    ctr: u64,
    stream_id: u64,

thomcc

struct Semaphore {
    raw: RawSemaphore,
    count: AtomicIsize,
}
impl Semaphore {
    #[inline]
    pub fn new(n: usize) -> Self {
        Self {
            raw: RawSemaphore::new(),

thomcc

static A: AtomicU8 = AtomicU8::new(0);
static B: AtomicU8 = AtomicU8::new(0);
const ORDER: Ordering = ???;

let writer_0 = thread::spawn(|| {
    A.store(1, ORDER);
});

let writer_1 = thread::spawn(|| {
    B.store(1, ORDER);

thomcc

// float->sRGB8 conversions - two variants.
// by Fabian "ryg" Giesen
//
// I hereby place this code in the public domain.
//
// Both variants come with absolute error bounds and a reversibility and monotonicity
// guarantee (see test driver code below). They should pass D3D10 conformance testing
// (not that you can verify this, but still). They are verified against a clean reference
// implementation provided below, and the test driver checks all floats exhaustively.
//