Does salsa delete the data of orphaned structs?

[ScrambledEggsOnToast]

Apologies if this is an inappropriate place to ask this question. I'm hoping to use salsa (2022) in a project, and trying to understand whether I will need to do any garbage collection. I'm having a hard time figuring this out from the code/documentation.

If the database contains data for structs which are no longer used, does that data get automatically deleted?

For context, I have a tree data structure, some of whose nodes are salsa inputs. The shape of the tree is managed by some other functions which occasionally drop some of its branches. Tracked functions are then used to construct a different tree data structure, some of whose nodes are tracked structs --- but these are guaranteed to not depend on the dropped inputs.

[xffxff]

If the database contains data for structs which are no longer used, does that data get automatically deleted?

@ScrambledEggsOnToast Yes, you can assume that Salsa only stores the computation results that are valid for the current inputs, and all the stale computation results are automatically deleted.

When you read a field of a tracked struct that is stale, it will panic. You can take a look at the following code snippet as an illustration:

let input = MyInput::new(&db, 22);
let tracked = tracked_fn(&db, input);

// Modify the input
input.set_field(&mut db).to(24);

// Panic when reading fields of staled tracked structs
tracked.field(&db);

This test is relevant to this situation

[ScrambledEggsOnToast]

@xffxff Thanks very much for your reply. The behavior you describe makes sense to me, but one thing that's still not clear to me is whether Salsa keeps around the data of dropped tracked inputs.

Basically:

{
    let input = MyInput::new(&mut db, 22);
}
// is the data still in the database now?

This is important to me because I have a tree data structure, with inputs on some nodes, and the shape of the tree can change.

[xffxff]

{
    let input = MyInput::new(&mut db, 22);
}
// is the data still in the database now?

@ScrambledEggsOnToast Yes, the input data in Salsa is kept around as long as the associated database remains alive. In other words, the data's lifetime is tied to the lifetime of the database. (In fact, the input variable in your example is just an integer value that represents a unique identifier for the associated input data)

Here is an example code that demonstrates this behavior:

    let db = Database::default();

    {
        let _ = MyInput::new(&db, 22);
    }
    let id = salsa::Id::from(0u32);
    let input = MyInput::from_id(id);
    assert_eq!(input.field(&db), 22);

Note that using salsa::Id directly is not recommended,

salsa/components/salsa-2022/src/id.rs

Lines 25 to 34 in a327acc

	/// In general, you should not need to create salsa ids yourself,
	/// but it can be useful if you are using the type as a general
	/// purpose "identifier" internally.
	#[track_caller]
	pub fn from_u32(x: u32) -> Self {
	assert!(x < Self::MAX_U32);
	Id {
	value: NonZeroU32::new(x + 1).unwrap(),
	}
	}

[ScrambledEggsOnToast]

Hmm, ok. In some scenarios (like mine) this would seem like a memory leak.

How should I remove the old data from the database, and any dependent structs? I guess I could do something like

{
    let input = MyInput::new(&db, Some(22));

    let tracked = tracked_fn(&db, input);
    // other stuff...

    // Mark an input for deletion. 
    // This will delete all the data of tracked structs 
    // which depend on the input.
    input.set_field(&mut db).to(None);
}
delete_inputs_with_is_none(&db);

But I don't actually know how to go about implementing delete_inputs_with_is_none.

I'd also ideally want to wrap MyInput in something with an impl Drop, but that thing would need a mutable reference to the database, which seems problematic.