thomcc

use core::{alloc::Layout, marker::PhantomData, ptr::NonNull};

/// Utility for performing several conceptually-separate allocations in a single
/// shot. Usage:
/// ```ignore
/// let (foos, numbers, bars): (NonNull<Foo>, NonNull<u32>, NonNull<Bar>) =
///     MultiAllocBuilder::<4>::new()
///         .push::<Foo>(Layout::array::<Foo>(num_foos).unwrap())
///         .push::<u32>(Layout::array::<u32>(num_numbers).unwrap())
///         .push::<Bar>(Layout::array::<Bar>(num_bars).unwrap())

thomcc

//! From a library I never finished. I should still make it it's own crate TBH.

macro_rules! parse_env {
    ($var_name:literal as $typ:ident) => {{
        const {
            match $crate::parse_env::dispatch::$typ(::core::env!($var_name).as_bytes(), ::core::None) {
                ::core::Some(v) => v,
                ::core::None => {
                    ::core::panic!(::core::concat!(
                        "error: the value in ",

thomcc

// Run me from a scratchpad.
(function() {
  ChromeUtils.import("resource://gre/modules/SyncedBookmarksMirror.jsm");
  ChromeUtils.import("resource://services-sync/util.js");

  const RECORDS_TO_INSERT = 10000;

  function randUpTo(n) {
    return Math.floor(Math.random() * n);
  }

thomcc

#pragma once
#include <utility>

// varidic max, min, and minmax implementation (named maximum, minimum and min_max to avoid confusion)
// no support for custom comparators (mainly because i'm not sure how they should be specified)

namespace detail {

  // max base case
  template <class T>

thomcc

Steps to faster git on mac.

1. Update to git 2.16

2. Setup file monitoring with hgwatchman

   1. Run

   $ brew install watchman
   $ cd /path/to/mozilla-central
   

$ watchman watch-project .

thomcc

Jelly Physics

Attempt at replicating the Jelly effect from The Floor is Jelly (http://thefloorisjelly.com/).

A Pen by Thom Chiovoloni on CodePen.

License.

thomcc

//! Implementation of [Lamport's bakery algorithm][bakery]. This is somewhat
//! interesting, because it's a mutex which can be implemented even if the
//! target only has atomic load/store, and no CAS (in principal it can be even
//! more general than this).
//!
//! [bakery]: https://en.wikipedia.org/wiki/Lamport%27s_bakery_algorithm
//!
//! Major caveat: This is not tested, and this algo is no longer appropriate
//! for modern code. Some variations of it can be useful in a thread pool, but
//! it's mostly useful to understand the concepts.

thomcc

use anyhow::Result;
use std::{
    path::{Path, PathBuf},
    sync::atomic::{AtomicBool, Ordering::Relaxed},
};

/// "Automagic" submodule wrangling (sync, clean, fix, etc)
///
/// Ported from rustc's `x.py` code, which runs something like this
/// automatically (even for `./x.py --help`)

thomcc

//! Sketch of a alternative way to implement the backend of `zeroize` (the part
//! that does memory zeroing).
//!
//! It should be:
//!
//! - More efficient, possibly much more (for byte arrays), as it can zero in
//!   the most efficient way available, rather than e.g. being forced to
//!   perform element-at-a-time writes (where "element" often is "byte").
//! - Still guaranteed even in the face of aggressive compiler optimizations
//!   as the semantics of volatile loads forbid the compiler from being able

thomcc

pub type Argb8888 = u32;

/// Average of 2 pixels, rounding up on tie.
///
/// It's fine if they're actually BGRA8888 or any other format, 
/// this treats every channel the same.
pub fn pixel_average(c0: Argb8888, c1: Argb8888) -> Argb8888 {
    (c0 | c1).wrapping_sub(((c0 ^ c1) >> 1) & 0x7f7f7f7f)
    // version that rounds down:
    // (c0 & c1).wrapping_add(((c0 ^ c1) >> 1) & 0x7f7f7f7f)