mirrors/wlroots
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wlroots/wlroots.git synced 2026-04-21 06:46:46 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'frame-scheduler-helper' into 'master'

Browse source 
Draft: render: add frame scheduler helper

See merge request wlroots/wlroots!3783
This commit is contained in:
Simon Ser 2022-11-14 17:37:40 +00:00
commit e7737537ef
13 changed files with 479 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

16
include/render/gles2.h
View file

@ -32,6 +32,10 @@ struct wlr_gles2_tex_shader {
GLint tex_attrib;
};
// Fixed here, but missing from any libglvnd release:
// https://gitlab.freedesktop.org/glvnd/libglvnd/-/merge_requests/268
typedef void (GL_APIENTRYP PFNGLGETINTEGER64VEXTPROC) (GLenum pname, GLint64 *data);
struct wlr_gles2_renderer {
struct wlr_renderer wlr_renderer;
@ -48,6 +52,7 @@ struct wlr_gles2_renderer {
bool EXT_texture_type_2_10_10_10_REV;
bool OES_texture_half_float_linear;
bool EXT_texture_norm16;
bool EXT_disjoint_timer_query;
} exts;
struct {
@ -57,6 +62,11 @@ struct wlr_gles2_renderer {
PFNGLPOPDEBUGGROUPKHRPROC glPopDebugGroupKHR;
PFNGLPUSHDEBUGGROUPKHRPROC glPushDebugGroupKHR;
PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC glEGLImageTargetRenderbufferStorageOES;
PFNGLGETINTEGER64VEXTPROC glGetInteger64vEXT;
PFNGLGENQUERIESEXTPROC glGenQueriesEXT;
PFNGLDELETEQUERIESEXTPROC glDeleteQueriesEXT;
PFNGLQUERYCOUNTEREXTPROC glQueryCounterEXT;
PFNGLGETQUERYOBJECTI64VEXTPROC glGetQueryObjecti64vEXT;
} procs;
struct {
@ -112,6 +122,12 @@ struct wlr_gles2_texture {
struct wlr_addon buffer_addon;
};
struct wlr_gles2_timestamp {
struct wlr_render_timestamp base;
struct wlr_gles2_renderer *renderer;
GLuint query;
};
bool is_gles2_pixel_format_supported(const struct wlr_gles2_renderer *renderer,
const struct wlr_gles2_pixel_format *format);

11
include/util/time.h
View file

@ -13,11 +13,22 @@ uint32_t get_current_time_msec(void);
*/
int64_t timespec_to_msec(const struct timespec *a);
/**
* Convert a timespec to nanoseconds.
*/
int64_t timespec_to_nsec(const struct timespec *t);
/**
* Convert nanoseconds to a timespec.
*/
void timespec_from_nsec(struct timespec *r, int64_t nsec);
/**
* Add two timespec values `a` and `b`, and store the result in `r`.
*/
void timespec_add(struct timespec *r, const struct timespec *a,
const struct timespec *b);
/**
* Subtracts timespec `b` from timespec `a`, and stores the difference in `r`.
*/

15
include/wlr/render/interface.h
View file

@ -48,6 +48,8 @@ struct wlr_renderer_impl {
uint32_t (*get_render_buffer_caps)(struct wlr_renderer *renderer);
struct wlr_texture *(*texture_from_buffer)(struct wlr_renderer *renderer,
struct wlr_buffer *buffer);
bool (*get_time)(struct wlr_renderer *r, struct timespec *t);
struct wlr_render_timestamp *(*create_timestamp)(struct wlr_renderer *r);
};
void wlr_renderer_init(struct wlr_renderer *renderer,
@ -62,4 +64,17 @@ struct wlr_texture_impl {
void wlr_texture_init(struct wlr_texture *texture,
const struct wlr_texture_impl *impl, uint32_t width, uint32_t height);
struct wlr_render_timestamp {
const struct wlr_render_timestamp_impl *impl;
};
struct wlr_render_timestamp_impl {
void (*destroy)(struct wlr_render_timestamp *timestamp);
bool (*get_time)(struct wlr_render_timestamp *timestamp,
struct timespec *t);
};
void wlr_render_timestamp_init(struct wlr_render_timestamp *timestamp,
const struct wlr_render_timestamp_impl *impl);
#endif

16
include/wlr/render/wlr_renderer.h
View file

@ -14,6 +14,8 @@
#include <wlr/backend.h>
#include <wlr/render/wlr_texture.h>
struct timespec;
struct wlr_renderer_impl;
struct wlr_drm_format_set;
struct wlr_buffer;
@ -112,6 +114,20 @@ bool wlr_renderer_init_wl_shm(struct wlr_renderer *r,
*/
int wlr_renderer_get_drm_fd(struct wlr_renderer *r);
/**
* Get the current GPU time.
*/
bool wlr_renderer_get_time(struct wlr_renderer *r, struct timespec *t);
struct wlr_render_timestamp;
struct wlr_render_timestamp *wlr_renderer_create_timestamp(struct wlr_renderer *r);
bool wlr_render_timestamp_get_time(struct wlr_render_timestamp *timestamp,
struct timespec *t);
void wlr_render_timestamp_destroy(struct wlr_render_timestamp *timestamp);
/**
* Destroys the renderer.
*

55
include/wlr/types/wlr_frame_scheduler.h Normal file
View file

@ -0,0 +1,55 @@
/*
* This an unstable interface of wlroots. No guarantees are made regarding the
* future consistency of this API.
*/
#ifndef WLR_USE_UNSTABLE
#error "Add -DWLR_USE_UNSTABLE to enable unstable wlroots features"
#endif
#ifndef WLR_TYPES_WLR_FRAME_SCHEDULER_H
#define WLR_TYPES_WLR_FRAME_SCHEDULER_H
#include <wayland-server-core.h>
#include <time.h>
struct wlr_renderer;
struct wlr_render_timestamp;
#define WLR_FRAME_SCHEDULER_HISTOGRAM_LEN 128
struct wlr_frame_scheduler_bucket {
int64_t cpu_duration_ns, gpu_duration_ns;
};
struct wlr_frame_scheduler {
struct wlr_output *output;
clockid_t presentation_clock;
struct {
struct wl_signal frame;
} events;
// private state
struct wl_event_source *timer;
struct wlr_frame_scheduler_bucket histogram[WLR_FRAME_SCHEDULER_HISTOGRAM_LEN];
size_t histogram_cur;
struct wl_listener output_present;
struct {
uint32_t commit_seq;
struct timespec frame_emitted, frame_submitted; // CPU time
struct timespec render_submitted; // GPU time
struct wlr_render_timestamp *render_complete;
} queued;
};
bool wlr_frame_scheduler_init(struct wlr_frame_scheduler *scheduler,
struct wlr_output *output);
void wlr_frame_scheduler_finish(struct wlr_frame_scheduler *scheduler);
void wlr_frame_scheduler_mark_render_submitted(
struct wlr_frame_scheduler *scheduler, struct wlr_renderer *renderer);
#endif

2
include/wlr/types/wlr_scene.h
View file

@ -23,6 +23,7 @@
#include <wayland-server-core.h>
#include <wlr/types/wlr_compositor.h>
#include <wlr/types/wlr_damage_ring.h>
#include <wlr/types/wlr_frame_scheduler.h>
struct wlr_output;
struct wlr_output_layout;
@ -166,6 +167,7 @@ struct wlr_scene_output {
struct wlr_addon addon;
struct wlr_damage_ring damage_ring;
struct wlr_frame_scheduler frame_scheduler;
int x, y;

111
render/gles2/renderer.c
View file

@ -18,6 +18,7 @@
#include "render/gles2.h"
#include "render/pixel_format.h"
#include "types/wlr_matrix.h"
#include "util/time.h"
#include "common_vert_src.h"
#include "quad_frag_src.h"
@ -491,6 +492,52 @@ struct wlr_egl *wlr_gles2_renderer_get_egl(struct wlr_renderer *wlr_renderer) {
return renderer->egl;
}
static bool gles2_get_time(struct wlr_renderer *wlr_renderer, struct timespec *t) {
struct wlr_gles2_renderer *renderer =
gles2_get_renderer_in_context(wlr_renderer);
if (!renderer->exts.EXT_disjoint_timer_query) {
return false;
}
GLint64 nsec = 0;
push_gles2_debug(renderer);
renderer->procs.glGetInteger64vEXT(GL_TIMESTAMP_EXT, &nsec);
pop_gles2_debug(renderer);
timespec_from_nsec(t, nsec);
return true;
}
static const struct wlr_render_timestamp_impl timestamp_impl;
static struct wlr_render_timestamp *gles2_create_timestamp(
struct wlr_renderer *wlr_renderer) {
struct wlr_gles2_renderer *renderer =
gles2_get_renderer_in_context(wlr_renderer);
if (!renderer->exts.EXT_disjoint_timer_query) {
return NULL;
}
struct wlr_gles2_timestamp *timestamp = calloc(1, sizeof(*timestamp));
if (timestamp == NULL) {
return NULL;
}
wlr_render_timestamp_init(&timestamp->base, &timestamp_impl);
timestamp->renderer = renderer;
GLint disjoint = 0;
push_gles2_debug(renderer);
glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjoint); // clear the disjoint flag
renderer->procs.glGenQueriesEXT(1, &timestamp->query);
renderer->procs.glQueryCounterEXT(timestamp->query, GL_TIMESTAMP_EXT);
pop_gles2_debug(renderer);
return &timestamp->base;
}
static void gles2_destroy(struct wlr_renderer *wlr_renderer) {
struct wlr_gles2_renderer *renderer = gles2_get_renderer(wlr_renderer);
@ -545,6 +592,8 @@ static const struct wlr_renderer_impl renderer_impl = {
.get_drm_fd = gles2_get_drm_fd,
.get_render_buffer_caps = gles2_get_render_buffer_caps,
.texture_from_buffer = gles2_texture_from_buffer,
.get_time = gles2_get_time,
.create_timestamp = gles2_create_timestamp,
};
void push_gles2_debug_(struct wlr_gles2_renderer *renderer,
@ -769,6 +818,15 @@ struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_egl *egl) {
"glEGLImageTargetRenderbufferStorageOES");
}
if (check_gl_ext(exts_str, "GL_EXT_disjoint_timer_query")) {
renderer->exts.EXT_disjoint_timer_query = true;
load_gl_proc(&renderer->procs.glGetInteger64vEXT, "glGetInteger64vEXT");
load_gl_proc(&renderer->procs.glGenQueriesEXT, "glGenQueriesEXT");
load_gl_proc(&renderer->procs.glDeleteQueriesEXT, "glDeleteQueriesEXT");
load_gl_proc(&renderer->procs.glQueryCounterEXT, "glQueryCounterEXT");
load_gl_proc(&renderer->procs.glGetQueryObjecti64vEXT, "glGetQueryObjecti64vEXT");
}
if (renderer->exts.KHR_debug) {
glEnable(GL_DEBUG_OUTPUT_KHR);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR);
@ -864,3 +922,56 @@ GLuint wlr_gles2_renderer_get_current_fbo(struct wlr_renderer *wlr_renderer) {
assert(renderer->current_buffer);
return renderer->current_buffer->fbo;
}
static struct wlr_gles2_timestamp *get_timestamp(
struct wlr_render_timestamp *wlr_timestamp) {
assert(wlr_timestamp->impl == &timestamp_impl);
struct wlr_gles2_timestamp *timestamp =
wl_container_of(wlr_timestamp, timestamp, base);
return timestamp;
}
static void timestamp_destroy(struct wlr_render_timestamp *wlr_timestamp) {
struct wlr_gles2_timestamp *timestamp = get_timestamp(wlr_timestamp);
struct wlr_gles2_renderer *renderer = timestamp->renderer;
struct wlr_egl_context prev_ctx;
wlr_egl_save_context(&prev_ctx);
wlr_egl_make_current(renderer->egl);
push_gles2_debug(renderer);
renderer->procs.glDeleteQueriesEXT(1, &timestamp->query);
pop_gles2_debug(renderer);
wlr_egl_restore_context(&prev_ctx);
}
static bool timestamp_get_time(struct wlr_render_timestamp *wlr_timestamp,
struct timespec *t) {
struct wlr_gles2_timestamp *timestamp = get_timestamp(wlr_timestamp);
struct wlr_gles2_renderer *renderer = timestamp->renderer;
struct wlr_egl_context prev_ctx;
wlr_egl_save_context(&prev_ctx);
wlr_egl_make_current(renderer->egl);
GLint disjoint = 0;
GLint64 available = 0, nsec = 0;
push_gles2_debug(renderer);
glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjoint);
renderer->procs.glGetQueryObjecti64vEXT(timestamp->query,
GL_QUERY_RESULT_AVAILABLE_EXT, &available);
renderer->procs.glGetQueryObjecti64vEXT(timestamp->query,
GL_QUERY_RESULT_EXT, &nsec);
pop_gles2_debug(renderer);
wlr_egl_restore_context(&prev_ctx);
timespec_from_nsec(t, nsec);
return available && !disjoint;
}
static const struct wlr_render_timestamp_impl timestamp_impl = {
.destroy = timestamp_destroy,
.get_time = timestamp_get_time,
};

33
render/wlr_renderer.c
View file

@ -433,3 +433,36 @@ int wlr_renderer_get_drm_fd(struct wlr_renderer *r) {
}
return r->impl->get_drm_fd(r);
}
bool wlr_renderer_get_time(struct wlr_renderer *r, struct timespec *t) {
if (!r->impl->get_time) {
return false;
}
return r->impl->get_time(r, t);
}
struct wlr_render_timestamp *wlr_renderer_create_timestamp(struct wlr_renderer *r) {
if (!r->impl->create_timestamp) {
return false;
}
return r->impl->create_timestamp(r);
}
void wlr_render_timestamp_init(struct wlr_render_timestamp *timestamp,
const struct wlr_render_timestamp_impl *impl) {
assert(impl->get_time && impl->destroy);
memset(timestamp, 0, sizeof(*timestamp));
timestamp->impl = impl;
}
bool wlr_render_timestamp_get_time(struct wlr_render_timestamp *timestamp,
struct timespec *t) {
return timestamp->impl->get_time(timestamp, t);
}
void wlr_render_timestamp_destroy(struct wlr_render_timestamp *timestamp) {
if (timestamp == NULL) {
return;
}
timestamp->impl->destroy(timestamp);
}

9
tinywl/tinywl.c
View file

@ -607,9 +607,6 @@ static void server_new_output(struct wl_listener *listener, void *data) {
calloc(1, sizeof(struct tinywl_output));
output->wlr_output = wlr_output;
output->server = server;
/* Sets up a listener for the frame notify event. */
output->frame.notify = output_frame;
wl_signal_add(&wlr_output->events.frame, &output->frame);
/* Sets up a listener for the destroy notify event. */
output->destroy.notify = output_destroy;
@ -627,6 +624,12 @@ static void server_new_output(struct wl_listener *listener, void *data) {
* output (such as DPI, scale factor, manufacturer, etc).
*/
wlr_output_layout_add_auto(server->output_layout, wlr_output);
struct wlr_scene_output *scene_output =
wlr_scene_get_scene_output(server->scene, wlr_output);
/* Sets up a listener for the frame notify event. */
output->frame.notify = output_frame;
wl_signal_add(&scene_output->frame_scheduler.events.frame, &output->frame);
}
static void xdg_toplevel_map(struct wl_listener *listener, void *data) {

1
types/meson.build
View file

@ -42,6 +42,7 @@ wlr_files += files(
'wlr_export_dmabuf_v1.c',
'wlr_foreign_toplevel_management_v1.c',
'wlr_fullscreen_shell_v1.c',
'wlr_frame_scheduler.c',
'wlr_gamma_control_v1.c',
'wlr_idle_inhibit_v1.c',
'wlr_idle.c',

4
types/scene/wlr_scene.c
View file

@ -1218,6 +1218,7 @@ struct wlr_scene_output *wlr_scene_output_create(struct wlr_scene *scene,
wlr_addon_init(&scene_output->addon, &output->addons, scene, &output_addon_impl);
wlr_damage_ring_init(&scene_output->damage_ring);
wlr_frame_scheduler_init(&scene_output->frame_scheduler, output);
wl_list_init(&scene_output->damage_highlight_regions);
int prev_output_index = -1;
@ -1279,6 +1280,7 @@ void wlr_scene_output_destroy(struct wlr_scene_output *scene_output) {
wlr_addon_finish(&scene_output->addon);
wlr_damage_ring_finish(&scene_output->damage_ring);
wlr_frame_scheduler_finish(&scene_output->frame_scheduler);
wl_list_remove(&scene_output->link);
wl_list_remove(&scene_output->output_commit.link);
wl_list_remove(&scene_output->output_mode.link);
@ -1621,6 +1623,8 @@ bool wlr_scene_output_commit(struct wlr_scene_output *scene_output) {
wlr_output_render_software_cursors(output, &damage);
wlr_frame_scheduler_mark_render_submitted(&scene_output->frame_scheduler,
renderer);
wlr_renderer_end(renderer);
pixman_region32_fini(&damage);

189
types/wlr_frame_scheduler.c Normal file
View file

@ -0,0 +1,189 @@
#define _POSIX_C_SOURCE 199309L
#include <wlr/render/wlr_renderer.h>
#include <wlr/types/wlr_frame_scheduler.h>
#include <wlr/types/wlr_output.h>
#include <wlr/util/log.h>
#include "util/time.h"
static int handle_timer(void *data) {
struct wlr_frame_scheduler *scheduler = data;
if (clock_gettime(CLOCK_MONOTONIC, &scheduler->queued.frame_emitted) != 0) {
wlr_log_errno(WLR_ERROR, "clock_gettime() failed");
return 0;
}
wl_signal_emit_mutable(&scheduler->events.frame, NULL);
return 0;
}
static void schedule_frame(struct wlr_frame_scheduler *scheduler, int64_t delay_ns) {
if (delay_ns <= 0) {
handle_timer(scheduler);
return;
}
int delay_ms = delay_ns / 1000000;
wl_event_source_timer_update(scheduler->timer, delay_ms);
}
static void handle_output_present(struct wl_listener *listener, void *data) {
struct wlr_frame_scheduler *scheduler =
wl_container_of(listener, scheduler, output_present);
const struct wlr_output_event_present *event = data;
if (scheduler->queued.render_complete == NULL ||
event->commit_seq != scheduler->queued.commit_seq) {
goto out;
}
struct timespec render_complete;
if (!wlr_render_timestamp_get_time(scheduler->queued.render_complete,
&render_complete)) {
goto out;
}
struct timespec cpu_duration;
timespec_sub(&cpu_duration, &scheduler->queued.frame_submitted,
&scheduler->queued.frame_emitted);
int64_t cpu_duration_ns = timespec_to_nsec(&cpu_duration);
if (cpu_duration_ns <= 0) {
wlr_log(WLR_ERROR, "CPU duration is negative (%f ms)",
(float)cpu_duration_ns / 1000 / 1000);
goto out;
}
struct timespec gpu_duration;
timespec_sub(&gpu_duration, &render_complete,
&scheduler->queued.render_submitted);
int64_t gpu_duration_ns = timespec_to_nsec(&gpu_duration);
if (gpu_duration_ns <= 0) {
wlr_log(WLR_ERROR, "GPU duration is negative (%f ms)",
(float)gpu_duration_ns / 1000 / 1000);
goto out;
}
wlr_log(WLR_INFO, "Render duration: CPU %f ns, GPU %f ms",
(float)cpu_duration_ns / 1000000,
(float)gpu_duration_ns / 1000000);
scheduler->histogram[scheduler->histogram_cur] = (struct wlr_frame_scheduler_bucket){
.cpu_duration_ns = cpu_duration_ns,
.gpu_duration_ns = gpu_duration_ns,
};
scheduler->histogram_cur++;
scheduler->histogram_cur %= WLR_FRAME_SCHEDULER_HISTOGRAM_LEN;
out:
wlr_render_timestamp_destroy(scheduler->queued.render_complete);
memset(&scheduler->queued, 0, sizeof(scheduler->queued));
if (event->when == NULL || event->refresh <= 0) {
schedule_frame(scheduler, 2 * 1000 * 1000);
return;
}
size_t n_samples = 0;
int64_t max_cpu_duration_ns = 0, max_gpu_duration_ns = 0;
for (size_t i = 0; i < WLR_FRAME_SCHEDULER_HISTOGRAM_LEN; i++) {
const struct wlr_frame_scheduler_bucket bucket = scheduler->histogram[i];
if (bucket.cpu_duration_ns <= 0 || bucket.gpu_duration_ns <= 0) {
continue;
}
n_samples++;
if (bucket.cpu_duration_ns > max_cpu_duration_ns) {
max_cpu_duration_ns = bucket.cpu_duration_ns;
}
if (bucket.gpu_duration_ns > max_gpu_duration_ns) {
max_gpu_duration_ns = bucket.gpu_duration_ns;
}
}
if (n_samples < WLR_FRAME_SCHEDULER_HISTOGRAM_LEN) {
schedule_frame(scheduler, 2 * 1000 * 1000);
return;
}
int64_t max_duration_ns = max_cpu_duration_ns + max_gpu_duration_ns + 2000000;
struct timespec max_duration;
timespec_from_nsec(&max_duration, max_duration_ns);
if (max_duration_ns > event->refresh) {
wlr_log(WLR_ERROR, "Max render duration (%f ms) exceeds "
"refresh period (%f ms)", (float)max_duration_ns / 1000 / 1000,
(float)event->refresh / 1000 / 1000);
schedule_frame(scheduler, 2 * 1000 * 1000);
return;
}
wlr_log(WLR_INFO, "Max duration: %f ms", (float)max_duration_ns / 1000000);
struct timespec predicted_refresh_duration;
timespec_from_nsec(&predicted_refresh_duration, event->refresh);
struct timespec predicted_next_refresh;
timespec_add(&predicted_next_refresh, event->when, &predicted_refresh_duration);
struct timespec next_frame;
timespec_sub(&next_frame, &predicted_next_refresh, &max_duration);
struct timespec now;
if (clock_gettime(scheduler->presentation_clock, &now) != 0) {
wlr_log_errno(WLR_ERROR, "clock_gettime() failed");
schedule_frame(scheduler, 2 * 1000 * 1000);
return;
}
struct timespec delay;
timespec_sub(&delay, &next_frame, &now);
int64_t delay_ns = timespec_to_nsec(&delay);
schedule_frame(scheduler, delay_ns);
}
bool wlr_frame_scheduler_init(struct wlr_frame_scheduler *scheduler,
struct wlr_output *output) {
memset(scheduler, 0, sizeof(*scheduler));
scheduler->output = output;
scheduler->presentation_clock = wlr_backend_get_presentation_clock(output->backend);
struct wl_event_loop *loop = wl_display_get_event_loop(output->display);
scheduler->timer = wl_event_loop_add_timer(loop, handle_timer, scheduler);
if (!scheduler->timer) {
wlr_log(WLR_ERROR, "wl_event_loop_add_timer() failed");
return false;
}
wl_signal_init(&scheduler->events.frame);
scheduler->output_present.notify = handle_output_present;
wl_signal_add(&output->events.present, &scheduler->output_present);
schedule_frame(scheduler, 2 * 1000 * 1000);
return true;
}
void wlr_frame_scheduler_finish(struct wlr_frame_scheduler *scheduler) {
wl_list_remove(&scheduler->output_present.link);
wlr_render_timestamp_destroy(scheduler->queued.render_complete);
wl_event_source_remove(scheduler->timer);
}
void wlr_frame_scheduler_mark_render_submitted(
struct wlr_frame_scheduler *scheduler, struct wlr_renderer *renderer) {
wlr_render_timestamp_destroy(scheduler->queued.render_complete);
scheduler->queued.render_complete = NULL;
if (clock_gettime(CLOCK_MONOTONIC, &scheduler->queued.frame_submitted) != 0) {
wlr_log_errno(WLR_ERROR, "clock_gettime() failed");
return;
}
if (!wlr_renderer_get_time(renderer, &scheduler->queued.render_submitted)) {
return;
}
scheduler->queued.render_complete = wlr_renderer_create_timestamp(renderer);
scheduler->queued.commit_seq = scheduler->output->commit_seq;
}

24
util/time.c
View file

@ -10,6 +10,10 @@ int64_t timespec_to_msec(const struct timespec *a) {
return (int64_t)a->tv_sec * 1000 + a->tv_nsec / 1000000;
}
int64_t timespec_to_nsec(const struct timespec *t) {
return (int64_t)t->tv_sec * NSEC_PER_SEC + t->tv_nsec;
}
void timespec_from_nsec(struct timespec *r, int64_t nsec) {
r->tv_sec = nsec / NSEC_PER_SEC;
r->tv_nsec = nsec % NSEC_PER_SEC;
@ -21,12 +25,24 @@ uint32_t get_current_time_msec(void) {
return timespec_to_msec(&now);
}
void timespec_sub(struct timespec *r, const struct timespec *a,
void timespec_add(struct timespec *r, const struct timespec *a,
const struct timespec *b) {
r->tv_sec = a->tv_sec - b->tv_sec;
r->tv_nsec = a->tv_nsec - b->tv_nsec;
if (r->tv_nsec < 0) {
r->tv_sec = a->tv_sec + b->tv_sec;
r->tv_nsec = a->tv_nsec + b->tv_nsec;
if (r->tv_nsec >= NSEC_PER_SEC) {
r->tv_sec++;
r->tv_nsec -= NSEC_PER_SEC;
} else if (r->tv_nsec < 0) {
r->tv_sec--;
r->tv_nsec += NSEC_PER_SEC;
}
}
void timespec_sub(struct timespec *r, const struct timespec *a,
const struct timespec *b) {
struct timespec tmp = {
.tv_sec = -b->tv_sec,
.tv_nsec = -b->tv_nsec,
};
timespec_add(r, a, &tmp);
}