Skip to content

Commit 66f5337

Browse files
committed
refactor(jsruntime): refactoring
1 parent c1863b3 commit 66f5337

File tree

4 files changed

+85
-85
lines changed

4 files changed

+85
-85
lines changed

libs/jsruntime/src/llvmir/bridge.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
#![allow(non_snake_case)]
44
#![allow(non_upper_case_globals)]
55

6-
use crate::tasklet::PromiseId;
6+
use crate::tasklet::Promise;
77
use crate::VoidPtr;
88

99
include!(concat!(env!("OUT_DIR"), "/bridge.rs"));
@@ -93,8 +93,8 @@ impl From<u32> for Value {
9393
}
9494
}
9595

96-
impl From<PromiseId> for Value {
97-
fn from(value: PromiseId) -> Self {
96+
impl From<Promise> for Value {
97+
fn from(value: Promise) -> Self {
9898
Self::promise(value.into())
9999
}
100100
}
@@ -192,13 +192,13 @@ impl Coroutine {
192192
pub fn resume(
193193
runtime: VoidPtr,
194194
coroutine: *mut Coroutine,
195-
promise_id: PromiseId,
195+
promise: Promise,
196196
result: &Value,
197197
error: &Value,
198198
) -> CoroutineStatus {
199199
unsafe {
200200
let lambda = (*(*coroutine).closure).lambda.unwrap();
201-
let mut args = [promise_id.into(), *result, *error];
201+
let mut args = [promise.into(), *result, *error];
202202
let mut retv = Value::NONE;
203203
let status = lambda(
204204
runtime,

libs/jsruntime/src/llvmir/compiler/mod.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2360,8 +2360,8 @@ impl<'r, 's> Compiler<'r, 's> {
23602360
}
23612361

23622362
fn process_resume(&mut self) {
2363-
let promise_id = self.pop_promise();
2364-
self.peer.create_resume(promise_id);
2363+
let promise = self.pop_promise();
2364+
self.peer.create_resume(promise);
23652365
}
23662366

23672367
fn pop_coroutine(&mut self) -> CoroutineIr {

libs/jsruntime/src/llvmir/runtime.yaml

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -67,7 +67,7 @@ functions:
6767
type: u32
6868
- name: resume
6969
args:
70-
- name: promise_id
70+
- name: promise
7171
type: u32
7272
- name: emit_promise_resolved
7373
args:

libs/jsruntime/src/tasklet.rs

Lines changed: 77 additions & 77 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,4 @@
11
use std::collections::VecDeque;
2-
use std::num::NonZeroU32;
32

43
use rustc_hash::FxHashMap;
54

@@ -20,144 +19,151 @@ impl<X> Runtime<X> {
2019
crate::logger::debug!(event = "handle_message", ?msg);
2120
match msg {
2221
Message::PromiseResolved {
23-
promise_id,
22+
promise,
2423
ref result,
25-
} => self.process_promise(promise_id, result, &Value::NONE),
26-
Message::PromiseRejected {
27-
promise_id,
28-
ref error,
29-
} => self.process_promise(promise_id, &Value::NONE, error),
24+
} => self.process_promise(promise, result, &Value::NONE),
25+
Message::PromiseRejected { promise, ref error } => {
26+
self.process_promise(promise, &Value::NONE, error)
27+
}
3028
}
3129
}
3230

3331
// promise
3432

35-
pub fn register_promise(&mut self, coroutine: *mut Coroutine) -> PromiseId {
33+
pub fn register_promise(&mut self, coroutine: *mut Coroutine) -> Promise {
3634
crate::logger::debug!(event = "register_promise", ?coroutine);
3735
self.tasklet_system.register_promise(coroutine)
3836
}
3937

40-
pub fn await_promise(&mut self, promise_id: PromiseId, awaiting: PromiseId) {
41-
crate::logger::debug!(event = "await_promise", ?promise_id, ?awaiting);
42-
self.tasklet_system.await_promise(promise_id, awaiting);
38+
pub fn await_promise(&mut self, promise: Promise, awaiting: Promise) {
39+
crate::logger::debug!(event = "await_promise", ?promise, ?awaiting);
40+
self.tasklet_system.await_promise(promise, awaiting);
4341
}
4442

45-
pub fn process_promise(&mut self, promise_id: PromiseId, result: &Value, error: &Value) {
46-
crate::logger::debug!(event = "process_promise", ?promise_id, ?result, ?error);
47-
let coroutine = self.tasklet_system.get_coroutine(promise_id);
48-
match Coroutine::resume(self.as_void_ptr(), coroutine, promise_id, result, error) {
49-
CoroutineStatus::Done(result) => {
50-
self.tasklet_system.resolve_promise(promise_id, result)
51-
}
52-
CoroutineStatus::Error(error) => self.tasklet_system.reject_promise(promise_id, error),
43+
pub fn process_promise(&mut self, promise: Promise, result: &Value, error: &Value) {
44+
crate::logger::debug!(event = "process_promise", ?promise, ?result, ?error);
45+
let coroutine = self.tasklet_system.get_coroutine(promise);
46+
match Coroutine::resume(self.as_void_ptr(), coroutine, promise, result, error) {
47+
CoroutineStatus::Done(result) => self.tasklet_system.resolve_promise(promise, result),
48+
CoroutineStatus::Error(error) => self.tasklet_system.reject_promise(promise, error),
5349
CoroutineStatus::Suspend => (),
5450
}
5551
}
5652

57-
pub fn emit_promise_resolved(&mut self, promise_id: PromiseId, result: Value) {
58-
self.tasklet_system
59-
.emit_promise_resolved(promise_id, result);
53+
pub fn emit_promise_resolved(&mut self, promise: Promise, result: Value) {
54+
self.tasklet_system.emit_promise_resolved(promise, result);
6055
}
6156
}
6257

6358
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
64-
pub struct PromiseId(NonZeroU32);
59+
pub struct Promise(u32);
6560

66-
impl From<u32> for PromiseId {
61+
impl From<u32> for Promise {
6762
fn from(value: u32) -> Self {
68-
Self(NonZeroU32::new(value).unwrap())
63+
Self(value)
6964
}
7065
}
7166

72-
impl From<PromiseId> for u32 {
73-
fn from(value: PromiseId) -> Self {
74-
value.0.get()
67+
impl From<Promise> for u32 {
68+
fn from(value: Promise) -> Self {
69+
value.0
7570
}
7671
}
7772

7873
pub struct System {
7974
messages: VecDeque<Message>,
80-
promises: FxHashMap<PromiseId, Promise>,
81-
next_promise_id: u32,
75+
promises: FxHashMap<Promise, PromiseDriver>,
76+
next_promise: u32,
8277
}
8378

8479
impl System {
8580
pub fn new() -> Self {
8681
Self {
8782
messages: Default::default(),
8883
promises: Default::default(),
89-
next_promise_id: 1,
84+
next_promise: 0,
9085
}
9186
}
9287

9388
// promises
9489

95-
fn register_promise(&mut self, coroutine: *mut Coroutine) -> PromiseId {
96-
let promise_id = PromiseId(NonZeroU32::new(self.next_promise_id).unwrap());
97-
self.promises.insert(promise_id, Promise::new(coroutine));
98-
self.next_promise_id += 1;
99-
promise_id
90+
fn register_promise(&mut self, coroutine: *mut Coroutine) -> Promise {
91+
let promise = self.new_promise();
92+
self.promises.insert(promise, PromiseDriver::new(coroutine));
93+
promise
94+
}
95+
96+
fn new_promise(&mut self) -> Promise {
97+
assert!(self.promises.len() < u32::MAX as usize);
98+
loop {
99+
let promise = Promise(self.next_promise);
100+
if !self.promises.contains_key(&promise) {
101+
return promise;
102+
}
103+
self.next_promise = self.next_promise.wrapping_add(1);
104+
}
105+
// never reach here
100106
}
101107

102-
fn await_promise(&mut self, promise_id: PromiseId, awaiting: PromiseId) {
103-
debug_assert!(self.promises.contains_key(&promise_id));
108+
fn await_promise(&mut self, promise: Promise, awaiting: Promise) {
109+
debug_assert!(self.promises.contains_key(&promise));
104110
debug_assert!(self.promises.contains_key(&awaiting));
105-
let promise = self.promises.get_mut(&promise_id).unwrap();
106-
debug_assert!(promise.awaiting.is_none());
107-
match promise.state {
108-
PromiseState::Pending => promise.awaiting = Some(awaiting),
111+
let driver = self.promises.get_mut(&promise).unwrap();
112+
debug_assert!(driver.awaiting.is_none());
113+
match driver.state {
114+
PromiseState::Pending => driver.awaiting = Some(awaiting),
109115
PromiseState::Resolved(result) => {
110116
self.emit_promise_resolved(awaiting, result);
111-
self.promises.remove(&promise_id);
117+
self.promises.remove(&promise);
112118
}
113119
PromiseState::Rejected(error) => {
114120
self.emit_promise_rejected(awaiting, error);
115-
self.promises.remove(&promise_id);
121+
self.promises.remove(&promise);
116122
}
117123
}
118124
}
119125

120-
fn get_coroutine(&self, promise_id: PromiseId) -> *mut Coroutine {
121-
self.promises.get(&promise_id).unwrap().coroutine
126+
fn get_coroutine(&self, promise: Promise) -> *mut Coroutine {
127+
self.promises.get(&promise).unwrap().coroutine
122128
}
123129

124-
fn emit_promise_resolved(&mut self, promise_id: PromiseId, result: Value) {
125-
crate::logger::debug!(event = "emit_promise_resolved", ?promise_id, ?result);
130+
fn emit_promise_resolved(&mut self, promise: Promise, result: Value) {
131+
crate::logger::debug!(event = "emit_promise_resolved", ?promise, ?result);
126132
self.messages
127-
.push_back(Message::PromiseResolved { promise_id, result });
133+
.push_back(Message::PromiseResolved { promise, result });
128134
}
129135

130-
fn emit_promise_rejected(&mut self, promise_id: PromiseId, error: Value) {
131-
crate::logger::debug!(event = "emit_promise_rejected", ?promise_id, ?error);
136+
fn emit_promise_rejected(&mut self, promise: Promise, error: Value) {
137+
crate::logger::debug!(event = "emit_promise_rejected", ?promise, ?error);
132138
self.messages
133-
.push_back(Message::PromiseRejected { promise_id, error });
139+
.push_back(Message::PromiseRejected { promise, error });
134140
}
135141

136142
fn next_msg(&mut self) -> Option<Message> {
137143
self.messages.pop_front()
138144
}
139145

140-
fn resolve_promise(&mut self, promise_id: PromiseId, result: Value) {
141-
crate::logger::debug!(event = "resolve_promise", ?promise_id, ?result);
142-
let promise = self.promises.get_mut(&promise_id).unwrap();
143-
debug_assert!(matches!(promise.state, PromiseState::Pending));
144-
if let Some(awaiting) = promise.awaiting {
145-
self.promises.remove(&promise_id);
146+
fn resolve_promise(&mut self, promise: Promise, result: Value) {
147+
crate::logger::debug!(event = "resolve_promise", ?promise, ?result);
148+
let driver = self.promises.get_mut(&promise).unwrap();
149+
debug_assert!(matches!(driver.state, PromiseState::Pending));
150+
if let Some(awaiting) = driver.awaiting {
151+
self.promises.remove(&promise);
146152
self.emit_promise_resolved(awaiting, result);
147153
} else {
148-
promise.state = PromiseState::Resolved(result);
154+
driver.state = PromiseState::Resolved(result);
149155
}
150156
}
151157

152-
fn reject_promise(&mut self, promise_id: PromiseId, error: Value) {
153-
crate::logger::debug!(event = "reject_promise", ?promise_id, ?error);
154-
let promise = self.promises.get_mut(&promise_id).unwrap();
155-
debug_assert!(matches!(promise.state, PromiseState::Pending));
156-
if let Some(awaiting) = promise.awaiting {
157-
self.promises.remove(&promise_id);
158+
fn reject_promise(&mut self, promise: Promise, error: Value) {
159+
crate::logger::debug!(event = "reject_promise", ?promise, ?error);
160+
let driver = self.promises.get_mut(&promise).unwrap();
161+
debug_assert!(matches!(driver.state, PromiseState::Pending));
162+
if let Some(awaiting) = driver.awaiting {
163+
self.promises.remove(&promise);
158164
self.emit_promise_rejected(awaiting, error);
159165
} else {
160-
promise.state = PromiseState::Rejected(error);
166+
driver.state = PromiseState::Rejected(error);
161167
}
162168
}
163169
}
@@ -166,27 +172,21 @@ impl System {
166172

167173
#[derive(Debug)]
168174
enum Message {
169-
PromiseResolved {
170-
promise_id: PromiseId,
171-
result: Value,
172-
},
173-
PromiseRejected {
174-
promise_id: PromiseId,
175-
error: Value,
176-
},
175+
PromiseResolved { promise: Promise, result: Value },
176+
PromiseRejected { promise: Promise, error: Value },
177177
}
178178

179179
// promise
180180

181181
// TODO: should the coroutine be separated from the promise?
182-
struct Promise {
182+
struct PromiseDriver {
183183
// TODO(issue#237): GcCellRef
184184
coroutine: *mut Coroutine,
185-
awaiting: Option<PromiseId>,
185+
awaiting: Option<Promise>,
186186
state: PromiseState,
187187
}
188188

189-
impl Promise {
189+
impl PromiseDriver {
190190
fn new(coroutine: *mut Coroutine) -> Self {
191191
Self {
192192
coroutine,

0 commit comments

Comments
 (0)