v8 147.1.0

Rust bindings to V8
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

// Copyright 2019-2021 the Deno authors. All rights reserved. MIT license.
//
// This sample program shows how to set up a stand-alone cppgc heap.

// Simple string rope to illustrate allocation and garbage collection below.
// The rope keeps the next parts alive via regular managed reference.

struct Rope {
  part: String,
  next: v8::cppgc::Member<Rope>,
}

impl std::fmt::Display for Rope {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "{}", self.part)?;
    unsafe {
      // SAFETY: `next` is visited in `trace()`.
      if let Some(next) = self.next.get() {
        write!(f, "{next}")?;
      }
    }
    Ok(())
  }
}

impl Rope {
  pub fn new(part: String, next: Option<v8::cppgc::UnsafePtr<Rope>>) -> Rope {
    let next = match next {
      Some(p) => v8::cppgc::Member::new(&p),
      None => v8::cppgc::Member::empty(),
    };
    Self { part, next }
  }
}

unsafe impl v8::cppgc::GarbageCollected for Rope {
  fn trace(&self, visitor: &mut v8::cppgc::Visitor) {
    visitor.trace(&self.next);
  }

  fn get_name(&self) -> &'static std::ffi::CStr {
    c"Rope"
  }
}

impl Drop for Rope {
  fn drop(&mut self) {
    println!("Dropping: {}", self.part);
  }
}

fn main() {
  let platform = v8::new_default_platform(0, false).make_shared();
  v8::V8::initialize_platform(platform.clone());
  v8::cppgc::initialize_process(platform.clone());
  v8::V8::initialize();

  {
    // Create a managed heap.
    let heap =
      v8::cppgc::Heap::create(platform, v8::cppgc::HeapCreateParams::default());

    // Allocate a string rope on the managed heap.
    let rope = unsafe {
      v8::cppgc::make_garbage_collected(
        &heap,
        Rope::new(
          String::from("Hello "),
          Some(v8::cppgc::make_garbage_collected(
            &heap,
            Rope::new(String::from("World!"), None),
          )),
        ),
      )
    };

    println!("{}", unsafe { rope.as_ref() });

    // Manually trigger garbage collection.
    heap.enable_detached_garbage_collections_for_testing();

    println!("Collect: MayContainHeapPointers");
    unsafe {
      heap.collect_garbage_for_testing(
        v8::cppgc::EmbedderStackState::MayContainHeapPointers,
      );
    }

    // Should still be live here:
    println!("{}", unsafe { rope.as_ref() });

    println!("Collect: NoHeapPointers");
    unsafe {
      heap.collect_garbage_for_testing(
        v8::cppgc::EmbedderStackState::NoHeapPointers,
      );
    }

    // Should be dead now.
  }

  // Gracefully shutdown the process.
  unsafe {
    v8::cppgc::shutdown_process();
    v8::V8::dispose();
  }
  v8::V8::dispose_platform();
}