Given a function f : t1 -> t2 , is there a way to write a function compute_f_in_a_hurry : t1 -> float -> t2 that uses f, such that compute_f_in_a_hurry x time_limit computes f x in time_limit units of time if possible, or raises an exception if the computation takes too long ? I guess one needs the…

I have this version that uses Unix signals. exception Timeout let delayed_fun f x timeout = let _ = Sys.set_signal Sys.sigalrm (Sys.Signal_handle (fun _ -> raise Timeout)) in ignore (Unix.alarm timeout); try let r = f x in ignore (Unix.alarm 0); r with | e -> ignore (Unix.…

With Lwt it’s easy to do that: let compute ~time ~f = Lwt.pick [ f () >|= fun v -> `Done v ; Lwt_unix.sleep time >|= fun () -> `Timeout ] This code will return Timeout if our computation was not yet done . Otherwise, it returns your result.

[image] dinosaure: With Lwt it’s easy to do that: (…) This code will return Timeout if our computation was not yet done . Otherwise, it returns your result. Thanks ! I don’t know much about the implementation of Lwt, and I wonder if all the heavy machinery of the Lwt library is needed here, …

As far as I know, there’s no way to bypass the blocking nature of OCaml functions (e.g. to register callbacks with the OCaml runtime). edit: TIL, not true! See below for a solution with SIGALRM Lwt gets around the problem by having threads be cooperative. If the thread that you’re timing is insuffi…

Note that there is one downside with my solution which is that it doesn’t work on windows because timer are not implemented; similarly, other backends such as js_of_ocaml, do not implement the timers, so while it works quite well on unix systems, it’s not very portable sadly.

This uses asynchronous exceptions. There are caveats associated with them, essentially making sure that the state of the world does not end up corrupted. Presumably a similar issue exists with Lwt.pick.

[image] CraigFe: if you want to do something like getting “equivalent functionality by rewriting a small part of it”, you need to change your function type: type ('a, 'b) cooperative_f = yield:(unit -> unit) -> 'a -> 'b let compute_cooperative ~duration ~f = let exception Timeout in let in…

I’m curious whether multiple threads can use this delayed_fun concurrently. Based on my limited understanding of signal handling, it happens at the process level, and usually the current executing thread will be used to execute the signal handler. reference

Do you mean OCaml system threads specifically?

Lwt is great and all, but it really deals with orchestrating and chaining many short computations. It won’t let you interrupt an arbitrary computation. Something like while true do () done will keep going till the end of times, while the elapsed timer and other lwt tasks kindly wait for their turn.

Computation with time constraint

Learning

gadmm April 17, 2020, 2:50pm 5

See for instance: Today's trick : memory limits with Gc alarms (@zozozo’s comment)

Topic		Replies	Views
Evaluate for a fixed amount of time or fail Learning	11	3406	December 3, 2017
Lwt vs System threads Learning lwt	28	5647	November 12, 2020
Best practice for sub-second timeout operation Learning	4	740	November 14, 2020
Signal handling checkpoints and Mutex.lock Learning	20	779	June 24, 2024
Multicore Ocaml vs Thread Learning	12	4070	June 2, 2020

Computation with time constraint

Related topics