try fix ci

Author: Chronostasys

immix

@@ -113,7 +113,6 @@ fn write_cb(req:*libuv::uv_write_t, status:i32) void {
 use std::io;
 
 
-
 fn async_cb(async_t:*libuv::uv_async_t) void {
     let reactor = libuv::get_data_for_handle<libuv::uv_async_t|UVReactor>(async_t);
     let ch = reactor.ch;
@@ -123,6 +122,8 @@ fn async_cb(async_t:*libuv::uv_async_t) void {
             let timer = libuv::new_uv_timer_t();
             gc::keep_alive_pinned(timer);
             let cb = unsafe_cast<()>(&timer_cb);
+            gc::pin(cb);
+            gc::keep_alive_pinned(cb);
             libuv::uv_timer_init(libuv::uv_default_loop(), timer);
             libuv::set_data_for_handle(timer, &ev);
             libuv::uv_timer_start(timer, cb, ev.timeout_ms, ev.repeat_ms);

planglib/std/task/reactor.pi

@@ -8,7 +8,7 @@ edition = "2021"
 [dependencies]
 internal_macro = { path = "../internal_macro",default-features = false }
 backtrace = "0.3"
-immix = { path = "../immix", default-features = false, features = ["llvm_stackmap", "auto_gc", "madv_dontneed", "conservative_stack_scan", "c-api", "gc_profile"] }
+immix = { path = "../immix", default-features = false, features = ["llvm_stackmap", "auto_gc", "madv_dontneed", "conservative_stack_scan", "c-api"] }
 # env_logger = "0.10"
 log = { version = "0.4", features = ["std"] }
 libc = "0.2"

vm/Cargo.toml

@@ -22,6 +22,7 @@ fn create_mutex(mutex: *mut *mut OpaqueMutex) -> u64 {
     }))
     .cast();
     fn drop_mutex_f(mutex: *mut u8) {
+        eprintln!("drop_mutex_f {:p}", mutex);
         unsafe {
             drop(Box::from_raw(mutex.cast::<MutexContainer>()));
         }
@@ -32,11 +33,13 @@ fn create_mutex(mutex: *mut *mut OpaqueMutex) -> u64 {
 
 #[is_runtime]
 fn lock_mutex(mutex: *mut OpaqueMutex) -> u64 {
+    eprintln!("lock_mutex {:p}", mutex);
     let container: &MutexContainer = &*mutex.cast();
     // immix::thread_stuck_start();
     let lock: MutexGuard<'static, _> = mem::transmute(container.mutex.lock().unwrap());
     // immix::thread_stuck_end();
     container.guard.set(Some(lock));
+    eprintln!("lock_mutex end {:p}", mutex);
     0
 }
 
@@ -66,24 +69,30 @@ fn drop_condvar(cond: *mut Condvar) -> u64 {
 
 #[is_runtime]
 fn condvar_wait(cond: *mut Condvar, mutex: *mut OpaqueMutex) -> u64 {
+    eprintln!("condvar_wait {:p} {:p}", cond, mutex);
     let container: &MutexContainer = &*mutex.cast();
     let lock = container.guard.replace(None).unwrap();
     let cond = unsafe { &*cond };
     let lock = cond.wait::<()>(lock).unwrap();
     container.guard.set(Some(lock));
+    eprintln!("condvar_wait end {:p} {:p}", cond, mutex);
     0
 }
 
 #[is_runtime]
 fn condvar_notify(cond: *mut Condvar) -> u64 {
+    eprintln!("condvar_notify {:p}", cond);
     let cond = unsafe { &*cond };
     cond.notify_one();
+    eprintln!("condvar_notify end {:p}", cond);
     0
 }
 
 #[is_runtime]
 fn condvar_notify_all(cond: *mut Condvar) -> u64 {
+    eprintln!("condvar_notify_all {:p}", cond);
     let cond = unsafe { &*cond };
     cond.notify_all();
+    eprintln!("condvar_notify_all end {:p}", cond);
     0
 }