Properly implement timer using dedicated timer thread

Author: dlunch

java_runtime/src/classes/java/util.rs

@@ -16,10 +16,12 @@ mod stack;
 mod time_zone;
 mod timer;
 mod timer_task;
+mod timer_thread;
 mod vector;
 
 pub use self::{
     abstract_collection::AbstractCollection, abstract_list::AbstractList, calendar::Calendar, date::Date, dictionary::Dictionary,
     empty_stack_exception::EmptyStackException, enumeration::Enumeration, gregorian_calendar::GregorianCalendar, hashtable::Hashtable,
-    properties::Properties, random::Random, stack::Stack, time_zone::TimeZone, timer::Timer, timer_task::TimerTask, vector::Vector,
+    properties::Properties, random::Random, stack::Stack, time_zone::TimeZone, timer::Timer, timer_task::TimerTask, timer_thread::TimerThread,
+    vector::Vector,
 };

java_runtime/src/classes/java/util/timer.rs

@@ -1,9 +1,12 @@
-use alloc::{boxed::Box, vec};
+use alloc::vec;
 
-use java_class_proto::JavaMethodProto;
+use java_class_proto::{JavaFieldProto, JavaMethodProto};
 use jvm::{ClassInstanceRef, Jvm, Result};
 
-use crate::{RuntimeClassProto, RuntimeContext, SpawnCallback, classes::java::util::TimerTask};
+use crate::{
+    RuntimeClassProto, RuntimeContext,
+    classes::java::util::{TimerTask, Vector},
+};
 
 // class java.util.Timer
 pub struct Timer;
@@ -17,16 +20,35 @@ impl Timer {
             methods: vec![
                 JavaMethodProto::new("<init>", "()V", Self::init, Default::default()),
                 JavaMethodProto::new("schedule", "(Ljava/util/TimerTask;JJ)V", Self::schedule, Default::default()),
+                JavaMethodProto::new(
+                    "scheduleAtFixedRate",
+                    "(Ljava/util/TimerTask;JJ)V",
+                    Self::schedule_at_fixed_rate,
+                    Default::default(),
+                ),
+            ],
+            fields: vec![
+                JavaFieldProto::new("tasks", "Ljava/util/Vector;", Default::default()),
+                JavaFieldProto::new("thread", "Ljava/lang/Thread;", Default::default()),
             ],
-            fields: vec![],
         }
     }
 
-    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
+    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
         tracing::debug!("java.util.Timer::<init>({:?})", &this);
 
         let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
 
+        let tasks = jvm.new_class("java/util/Vector", "()V", ()).await?;
+        let timer_thread = jvm
+            .new_class("java/util/Timer$TimerThread", "(Ljava/util/Vector;)V", (tasks.clone(),))
+            .await?;
+
+        jvm.put_field(&mut this, "tasks", "Ljava/util/Vector;", tasks).await?;
+        jvm.put_field(&mut this, "thread", "Ljava/lang/Thread;", timer_thread.clone()).await?;
+
+        let _: () = jvm.invoke_virtual(&timer_thread, "start", "()V", ()).await?;
+
         Ok(())
     }
 
@@ -40,40 +62,47 @@ impl Timer {
     ) -> Result<()> {
         tracing::debug!("java.util.Timer::schedule({:?}, {:?}, {:?}, {:?})", &this, &task, delay, period);
 
-        // TODO we should not spawn new thread every time
+        let now: i64 = context.now() as i64;
+        let next_execution_time = now + delay;
 
-        struct TimerProxy {
-            jvm: Jvm,
-            task: ClassInstanceRef<TimerTask>,
-            delay: i64,
-            period: i64,
-        }
+        Self::do_schedule(jvm, this, task, next_execution_time, period).await
+    }
 
-        #[async_trait::async_trait]
-        impl SpawnCallback for TimerProxy {
-            #[tracing::instrument(name = "timer", skip_all)]
-            async fn call(&self) -> Result<()> {
-                self.jvm.attach_thread()?;
+    async fn schedule_at_fixed_rate(
+        jvm: &Jvm,
+        context: &mut RuntimeContext,
+        this: ClassInstanceRef<Self>,
+        task: ClassInstanceRef<TimerTask>,
+        delay: i64,
+        period: i64,
+    ) -> Result<()> {
+        tracing::debug!(
+            "java.util.Timer::scheduleAtFixedRate({:?}, {:?}, {:?}, {:?})",
+            &this,
+            &task,
+            delay,
+            period
+        );
+        // FIXME: fixed rate is not different from normal rate
 
-                let _: () = self.jvm.invoke_static("java/lang/Thread", "sleep", "(J)V", (self.delay,)).await?;
+        let now: i64 = context.now() as i64;
+        let next_execution_time = now + delay;
 
-                loop {
-                    let _: () = self.jvm.invoke_virtual(&self.task, "run", "()V", ()).await?;
+        Self::do_schedule(jvm, this, task, next_execution_time, period).await
+    }
 
-                    let _: () = self.jvm.invoke_static("java/lang/Thread", "sleep", "(J)V", (self.period,)).await?;
-                }
-            }
-        }
+    async fn do_schedule(
+        jvm: &Jvm,
+        this: ClassInstanceRef<Self>,
+        mut task: ClassInstanceRef<TimerTask>,
+        next_execution_time: i64,
+        period: i64,
+    ) -> Result<()> {
+        jvm.put_field(&mut task, "nextExecutionTime", "J", next_execution_time).await?;
+        jvm.put_field(&mut task, "period", "J", period).await?;
 
-        context.spawn(
-            jvm,
-            Box::new(TimerProxy {
-                jvm: jvm.clone(),
-                task,
-                delay,
-                period,
-            }),
-        );
+        let tasks: ClassInstanceRef<Vector> = jvm.get_field(&this, "tasks", "Ljava/util/Vector;").await?;
+        let _: bool = jvm.invoke_virtual(&tasks, "add", "(Ljava/lang/Object;)Z", (task,)).await?;
 
         Ok(())
     }

java_runtime/src/classes/java/util/timer_task.rs

@@ -1,6 +1,6 @@
 use alloc::vec;
 
-use java_class_proto::JavaMethodProto;
+use java_class_proto::{JavaFieldProto, JavaMethodProto};
 use jvm::{ClassInstanceRef, Jvm, Result};
 
 use crate::{RuntimeClassProto, RuntimeContext};
@@ -18,7 +18,10 @@ impl TimerTask {
                 JavaMethodProto::new("<init>", "()V", Self::init, Default::default()),
                 JavaMethodProto::new_abstract("run", "()V", Default::default()),
             ],
-            fields: vec![],
+            fields: vec![
+                JavaFieldProto::new("nextExecutionTime", "J", Default::default()),
+                JavaFieldProto::new("period", "J", Default::default()),
+            ],
         }
     }
 

java_runtime/src/classes/java/util/timer_thread.rs

@@ -0,0 +1,83 @@
+use alloc::{vec, vec::Vec};
+use core::time::Duration;
+
+use java_class_proto::{JavaFieldProto, JavaMethodProto};
+use jvm::{ClassInstanceRef, Jvm, Result};
+
+use crate::{RuntimeClassProto, RuntimeContext, classes::java::util::Vector};
+
+// class java.util.Timer$TimerThread
+pub struct TimerThread;
+
+impl TimerThread {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "java/util/Timer$TimerThread",
+            parent_class: Some("java/lang/Thread"),
+            interfaces: vec![],
+            methods: vec![
+                JavaMethodProto::new("<init>", "(Ljava/util/Vector;)V", Self::init, Default::default()),
+                JavaMethodProto::new("run", "()V", Self::run, Default::default()),
+            ],
+            fields: vec![JavaFieldProto::new("tasks", "Ljava/util/Vector;", Default::default())],
+        }
+    }
+
+    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, tasks: ClassInstanceRef<Vector>) -> Result<()> {
+        tracing::debug!("java.util.Timer$TimerThread::<init>({:?})", &this);
+
+        let _: () = jvm.invoke_special(&this, "java/lang/Thread", "<init>", "()V", ()).await?;
+
+        jvm.put_field(&mut this, "tasks", "Ljava/util/Vector;", tasks).await?;
+
+        Ok(())
+    }
+
+    async fn run(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
+        tracing::debug!("java.util.Timer$TimerThread::run({:?})", &this);
+
+        let java_tasks = jvm.get_field(&this, "tasks", "Ljava/util/Vector;").await?;
+
+        loop {
+            // TODO: we need to wait for new tasks to arrive
+            context.sleep(Duration::from_millis(16)).await;
+
+            let tasks_size: i32 = jvm.invoke_virtual(&java_tasks, "size", "()I", ()).await?;
+            if tasks_size == 0 {
+                continue;
+            }
+
+            // get all tasks. removing from tasks vector to avoid some concurrency issue
+            let mut tasks = Vec::with_capacity(tasks_size as _);
+            for _ in 0..tasks_size {
+                let task = jvm.invoke_virtual(&java_tasks, "remove", "(I)Ljava/lang/Object;", (0,)).await?;
+                tasks.push(task);
+            }
+
+            // execute tasks
+            let now = context.now() as i64;
+            let mut next_tasks = Vec::new();
+            for mut task in tasks {
+                let next_execution_time: i64 = jvm.get_field(&task, "nextExecutionTime", "J").await?;
+
+                if next_execution_time < now {
+                    let _: () = jvm.invoke_virtual(&task, "run", "()V", ()).await?;
+
+                    let period: i64 = jvm.get_field(&task, "period", "J").await?;
+                    if period > 0 {
+                        let next_execution_time = now + period;
+                        jvm.put_field(&mut task, "nextExecutionTime", "J", next_execution_time).await?;
+                        next_tasks.push(task);
+                    }
+                } else {
+                    next_tasks.push(task);
+                }
+            }
+
+            // add pending tasks
+            for task in next_tasks {
+                let _: () = jvm.invoke_virtual(&java_tasks, "addElement", "(Ljava/lang/Object;)V", (task,)).await?;
+            }
+        }
+    }
+}

java_runtime/src/loader.rs

@@ -77,6 +77,7 @@ pub fn get_runtime_class_proto(name: &str) -> Option<RuntimeClassProto> {
         crate::classes::java::util::Stack::as_proto(),
         crate::classes::java::util::Timer::as_proto(),
         crate::classes::java::util::TimerTask::as_proto(),
+        crate::classes::java::util::TimerThread::as_proto(),
         crate::classes::java::util::TimeZone::as_proto(),
         crate::classes::java::util::Vector::as_proto(),
         crate::classes::java::util::jar::Attributes::as_proto(),

java_runtime/tests/classes/java/util/test_timer.rs

@@ -12,26 +12,25 @@ impl TestClass {
     pub fn as_proto() -> RuntimeClassProto {
         RuntimeClassProto {
             name: "TestClass",
-            parent_class: Some("java/lang/Object"),
+            parent_class: Some("java/util/TimerTask"),
             interfaces: vec!["java/lang/Runnable"],
             methods: vec![
                 JavaMethodProto::new("<init>", "()V", Self::init, Default::default()),
                 JavaMethodProto::new("run", "()V", Self::run, Default::default()),
             ],
-            fields: vec![JavaFieldProto::new("ran", "Z", Default::default())],
+            fields: vec![JavaFieldProto::new("runCount", "I", Default::default())],
         }
     }
 
-    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
-        jvm.put_field(&mut this, "ran", "Z", false).await?;
-
-        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
+    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
+        let _: () = jvm.invoke_special(&this, "java/util/TimerTask", "<init>", "()V", ()).await?;
 
         Ok(())
     }
 
     async fn run(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
-        jvm.put_field(&mut this, "ran", "Z", true).await?;
+        let count: i32 = jvm.get_field(&this, "runCount", "I").await?;
+        jvm.put_field(&mut this, "runCount", "I", count + 1).await?;
 
         Ok(())
     }
@@ -52,13 +51,50 @@ async fn test_timer() -> Result<()> {
 
     let timer = jvm.new_class("java/util/Timer", "()V", ()).await?;
     let _: () = jvm
-        .invoke_virtual(&timer, "schedule", "(Ljava/util/TimerTask;JJ)V", (test_class.clone(), 0i64, 100i64))
+        .invoke_virtual(&timer, "schedule", "(Ljava/util/TimerTask;JJ)V", (test_class.clone(), 100i64, 0i64))
+        .await?;
+
+    let _: () = jvm.invoke_static("java/lang/Thread", "sleep", "(J)V", (200i64,)).await?;
+    let run_count: i32 = jvm.get_field(&test_class, "runCount", "I").await?;
+    assert_eq!(run_count, 1);
+
+    let _: () = jvm
+        .invoke_virtual(
+            &timer,
+            "scheduleAtFixedRate",
+            "(Ljava/util/TimerTask;JJ)V",
+            (test_class.clone(), 100i64, 0i64),
+        )
         .await?;
 
     let _: () = jvm.invoke_static("java/lang/Thread", "sleep", "(J)V", (200i64,)).await?;
+    let run_count: i32 = jvm.get_field(&test_class, "runCount", "I").await?;
+    assert_eq!(run_count, 2);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_timer_periodic() -> Result<()> {
+    let runtime = TestRuntime::new(BTreeMap::new());
+    let jvm = create_test_jvm(runtime.clone()).await?;
+
+    let class = Box::new(ClassDefinitionImpl::from_class_proto(
+        TestClass::as_proto(),
+        Box::new(runtime.clone()) as Box<_>,
+    ));
+    jvm.register_class(class, None).await?;
+
+    let test_class = jvm.new_class("TestClass", "()V", ()).await?;
+
+    let timer = jvm.new_class("java/util/Timer", "()V", ()).await?;
+    let _: () = jvm
+        .invoke_virtual(&timer, "schedule", "(Ljava/util/TimerTask;JJ)V", (test_class.clone(), 0i64, 100i64))
+        .await?;
 
-    let ran: bool = jvm.get_field(&test_class, "ran", "Z").await?;
-    assert!(ran);
+    let _: () = jvm.invoke_static("java/lang/Thread", "sleep", "(J)V", (500i64,)).await?;
+    let run_count: i32 = jvm.get_field(&test_class, "runCount", "I").await?;
+    assert_eq!(run_count, 5);
 
     Ok(())
 }

test_utils/src/lib.rs

@@ -6,6 +6,7 @@ use core::{
     sync::atomic::{AtomicU64, Ordering},
     time::Duration,
 };
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use jvm::{ClassDefinition, Jvm, Result};
 use jvm_rust::{ArrayClassDefinitionImpl, ClassDefinitionImpl};
@@ -53,7 +54,7 @@ impl Runtime for TestRuntime {
     }
 
     fn now(&self) -> u64 {
-        todo!()
+        SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or(Duration::from_secs(0)).as_millis() as u64
     }
 
     fn current_task_id(&self) -> u64 {