-
Update to git 2.16
-
Setup file monitoring with hgwatchman
- Run
$ brew install watchman $ cd /path/to/mozilla-central
$ watchman watch-project .
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()) |
//! 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 ", |
// 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); | |
} |
#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> |
Attempt at replicating the Jelly effect from The Floor is Jelly (http://thefloorisjelly.com/).
A Pen by Thom Chiovoloni on CodePen.
//! 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. |
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`) |
//! 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 |
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) |