ohos-ffrt 0.1.0

ohos ffrt runtime bindings
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
109
110
111
112
113
114
115
116

#![allow(warnings)]

use std::ptr;
use std::sync::Arc;

use ohos_ffrt_sys::{
    ffrt_alloc_auto_managed_function_storage_base, ffrt_function_header_t,
    ffrt_function_kind_t_ffrt_function_kind_general, ffrt_submit_h_base, ffrt_task_handle_destroy,
    ffrt_task_handle_t,
};

use crate::TaskAttr;

struct FuncWrapper {
    func: Box<dyn FnOnce() + Send + 'static>,
}

#[repr(C)]
struct TaskWrapper {
    header: ffrt_function_header_t,
    func_ptr: *mut FuncWrapper,
}

#[derive(Clone)]
pub struct Task {
    handle: Option<Arc<TaskHandle>>,
    attr: TaskAttr,
}

struct TaskHandle(ffrt_task_handle_t);

impl Drop for TaskHandle {
    fn drop(&mut self) {
        unsafe { ffrt_task_handle_destroy(self.0) };
    }
}

impl Task {
    pub fn new(attr: TaskAttr) -> Self {
        Self { attr, handle: None }
    }

    pub fn default() -> Self {
        Self::new(TaskAttr::new())
    }

    pub fn submit<F>(&self, func: F)
    where
        F: FnOnce() + Send + 'static,
    {
        let storage = unsafe {
            ffrt_alloc_auto_managed_function_storage_base(
                ffrt_function_kind_t_ffrt_function_kind_general,
            )
        } as *mut TaskWrapper;

        let func_wrapper = Box::new(FuncWrapper {
            func: Box::new(func),
        });
        let func_ptr = Box::into_raw(func_wrapper);

        unsafe {
            ptr::write(
                ptr::addr_of_mut!((*storage).header),
                ffrt_function_header_t {
                    exec: Some(task_exec),
                    destroy: Some(task_destroy),
                    reserve: [0; 2],
                },
            );
            ptr::write(ptr::addr_of_mut!((*storage).func_ptr), func_ptr);
        }

        let _ = unsafe {
            ffrt_submit_h_base(
                storage as *mut ffrt_function_header_t,
                ptr::null(),
                ptr::null(),
                self.attr.inner.as_ptr(),
            )
        };
    }
}

unsafe extern "C" fn task_exec(arg: *mut std::ffi::c_void) {
    let wrapper = arg as *mut TaskWrapper;
    if wrapper.is_null() {
        return;
    }

    let func_ptr = unsafe { ptr::read(ptr::addr_of!((*wrapper).func_ptr)) };
    if func_ptr.is_null() {
        return;
    }

    let func_wrapper = unsafe { Box::from_raw(func_ptr) };
    (func_wrapper.func)();

    unsafe {
        ptr::write(ptr::addr_of_mut!((*wrapper).func_ptr), ptr::null_mut());
    }
}

unsafe extern "C" fn task_destroy(arg: *mut std::ffi::c_void) {
    let wrapper = arg as *mut TaskWrapper;
    if wrapper.is_null() {
        return;
    }

    let func_ptr = unsafe { ptr::read(ptr::addr_of!((*wrapper).func_ptr)) };
    if !func_ptr.is_null() {
        let _ = unsafe { Box::from_raw(func_ptr) };
    }

    unsafe { ptr::drop_in_place(wrapper) };
}