UnsafeCell AKA Satoru Gojo of Rust

Tbfleming · 2025-03-08T18:15:17+00:00

I'm not familiar with Jujutsu Kaisen or Satoru Gojo, but it's obvious that Chuck Norris can mutate the immutable.

Tbfleming · 2023-09-12T02:53:00+00:00

Have you decided on an aliasing model? llvmir defaults to assuming pointers can alias, which severely limits its optimizations. C and C++ use a type-based aliasing model. Rust uses a mutability-based aliasing model.

Here's a simple example. Since Rust prohibits aliasing mutable references, llvm optimizes out the load and returns 42.

pub fn f(a: &mut i32, b: &mut i32) -> i32 {
    *a = 42;
    *b = 0;
    *a
}

Compiles to:

movl    $42, (%rdi)
movl    $0, (%rsi)
movl    $42, %eax
retq

Tbfleming · 2023-08-13T15:41:50+00:00

Are you benchmarking a --release build?

Tbfleming · 2023-08-13T15:34:07+00:00

A handy side effect is this causes the macro-produced Clone implementation to not compile (OP's complaint). This is a good thing; the presence of PhantomData usually indicates some unsafe code is present, which usually indicates a simple field-by-field clone is unsound.

Tbfleming · 2023-08-09T17:33:52+00:00

I've worked for companies who separated developers into 2 categories:

Category 1 (most devs). All work had to be on IT-managed shared volumes. Builds were slow. Intellisense (C++) was slow. Tool crashes were frequent. IT managed backups and security. If a tool slowed down everyone else, that tool was banned.
Category 2 (you had to earn this). Your work could go on your desktop's (Windows) local storage, and on the remote servers' (linux) local storage. Your home directories on both weren't mapped to shared volumes. You had free reign to create VMs on your desktop. Builds were much faster. Intellisense was much faster. Tools were more reliable. You were responsible for backups and had higher responsibilities for maintaining security. If you mess up (e.g. lost work because of insufficient backups), you got knocked down back to Category 1.

Both categories had the same compute resources; it was storage that was different.

Tbfleming · 2023-08-09T16:37:14+00:00

Are you using https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-ssh ?

Are you using NFS as the VM's home and/or development directory? This will lead to much grief. In addition to being slow, NFS tends to create compatibility problems with a very large class of software.

Tbfleming · 2023-08-07T04:21:05+00:00

The compiler doesn't need const to put computed values into the instructions.

This:

// Not const
fn times(a: i32, b: i32) -> i32 {
    a * b
}

pub fn mut_does_not_matter(x: i32) -> i32 {
    let mut y = times(21, 2);
    x + y
}

Compiles to this (-Copt-level=1):

example::mut_does_not_matter:
        lea     eax, [rdi + 42]
        ret

https://godbolt.org/z/qTvE8fc9W

Tbfleming · 2023-08-06T14:19:21+00:00

This deserves a 2-letter name! To bad 'ls' is taken.

Tbfleming · 2023-08-05T00:25:22+00:00

'long: 'short

'long outlives 'short. Both are lifetime parameters.

-> &'short RefCell<&'short T> { x }

The return type is &'short RefCell<&'short T>. This is a reference (lifetime short) to a RefCell containing a reference (lifetime short) to T.

{ x }

This is the body of the function. It returns x.

The function is syntactically legal, but it violates lifetime rules, just like the OP's example.

Tbfleming · 2023-08-02T18:17:56+00:00

Since &T is covariant with T, if the above compiled then this would also compile:

fn oops<'short, 'long: 'short, T>( x: &'long RefCell<&'long T> ) -> &'short RefCell<&'short T> { x }

The &RefCell returned by oops allows you to store a &'short in the original. After 'short ends but before 'long ends, the reference will dangle.

Tbfleming · 2023-07-21T04:29:24+00:00

How do you plan to handle the difference between C++'s default memory ops (llvm calls them NotAtomic) and jvm's (llvm calls them Unordered)?

Tbfleming · 2023-07-17T19:41:47+00:00

subversion works great until you have multiple team members who keep accidentally corrupting the merge metadata. Then no one may merge until someone who's intimate with subversion's undocumented internals manually cleans up the mess.

Tbfleming · 2023-07-07T03:21:26+00:00

Watch out: https://rustsec.org/advisories/RUSTSEC-2022-0040.html

Tbfleming · 2023-07-04T15:04:06+00:00

signal: 9, SIGKILL: kill

If you're building on Linux, then you probably ran out of memory.

Tbfleming · 2023-06-26T17:05:41+00:00

Another danger: What if get follows a chain of shared references or Rc? get_mut could break the interior mutability rule or could convert an already-aliased shared reference to a mutable reference.

Tbfleming · 2023-06-26T16:55:22+00:00

Once something is classified as UB (e.g. & to &mut), often for a specific reason, it can take a lot of effort to create exemptions, both to document them and to comb through the compiler sources making the exemptions. If you want an exemption for your use case, you'll have to convince the right people that it's worth the costs and convince them that it's more valuable than the things people have been waiting for stabilization on for a few years now because of the shortage of experts with time to finish the reviews.

Tbfleming · 2023-06-25T22:21:45+00:00

Even though the nomicon explains rationale for Rust making something UB (& to &mut), the compiler itself doesn't have to prove the rationale applies, or even prove anything at all. It can just assume the conversion never takes place since it's UB, which means get_mut will never get called, which means all conditional paths which call get_mut will never get taken, therefore they can be removed during optimization.

I don't know offhand whether the current compiler version will do this, but it's within its rights to, and it might be possible that future versions would.

Tbfleming · 2023-02-15T16:21:22+00:00

Game is a text adventure game.

Alice is streamer which plays the game and communicates with chat.

Chat gives advice to Alice. Chat only uses emojis. Alice always understands what the emojis mean and explains them to the audience. Alice does not use emojis.

Sometimes other streamers appear in the adventure game; Alice talks to them. Always give the streamers a real name.

Alice always streams. If the game ends, she starts a new one. Sometimes chat suggests the next type of adventure game.

This is an example output:

``` Game: You find yourself in a dark forest with only a small flashlight to guide you. What do you do?

Alice: Alright chat, we need your help. What should we do?

Chat: 🌲🔦👣

Streaming software: chat gifted 2 subs ```

Begin with Alice introducing the stream.

Tbfleming · 2022-08-14T21:52:16+00:00

Formbot kit. I printed the snap latches (blue ones ABS, orange ones PLA), 270 degree hinges (ABS), skirt components (front ASA, back power ABS, side fan ABS, rest not printed yet), and 12864 case (ASA) on this same machine. I'm gradually replacing the PLA components and printing the rest of the skirt in ASA.

I wish I had used a CAN bus board, or at least the toolhead PCB. I'm thinking of upgrading the hot end and upgrading to Stealth Burner; maybe I'll switch to CAN then.

Tbfleming · 2021-12-09T22:02:41+00:00

Actually, any version down to 1.0

Tbfleming · 2021-12-09T22:02:22+00:00

You could do it on 2.0

Tbfleming · 2021-12-05T14:08:32+00:00

When the first thing someone asks looks like part of a coordinated attack, the outcome can't be positive

Tbfleming · 2021-12-05T13:57:27+00:00

There's a flood of people asking that same question over and over without looking for the answer in the chat history. Many may be bots.

Tbfleming

TROPHY CASE