add enif_schedule_nif() to NIF API

In the #erlang IRC channel Anthony Ramine once mentioned the idea of
allowing a NIF to use an emulator trap, similar to a BIF trap, to schedule
another NIF for execution. This is exactly how dirty NIFs were implemented
for Erlang/OTP 17.0, so this commit refactors and generalizes that dirty
NIF code to support a new enif_schedule_nif() API function.

The enif_schedule_nif() function allows a long-running NIF to be broken
into separate NIF invocations. The NIF first executes part of the
long-running task, then calls enif_schedule_nif() to schedule a NIF for
later execution to continue the task. Any number of NIFs can be scheduled
in this manner, one after another. Since the emulator regains control
between invocations, this helps avoid problems caused by native code tying
up scheduler threads for too long.

The enif_schedule_nif() function also replaces the original experimental
dirty NIF API. The function takes a flags parameter that a caller can use
to indicate the NIF should be scheduled onto either a dirty CPU scheduler
thread, a dirty I/O scheduler thread, or scheduled as a regular NIF on a
regular scheduler thread. With this change, the original experimental
enif_schedule_dirty_nif(), enif_schedule_dirty_nif_finalizer() and
enif_dirty_nif_finalizer() API functions are no longer needed and have been
removed. Explicit scheduling of a dirty NIF finalization function is no
longer necessary; if an application wants similar functionality, it can
have a dirty NIF just invoke enif_schedule_nif() to schedule a non-dirty
NIF to complete its task.

Lift the restriction that dirty NIFs can't call enif_make_badarg() to raise
an exception. This was a problem with the original dirty NIF API because it
forced developers to get and check all incoming arguments in a regular NIF,
and then schedule the dirty NIF which then had to get all the arguments
again. Now, the argument checking can be done in the dirty NIF and it can
call enif_make_badarg() itself to flag incorrect arguments.

Extend the ErlNifFunc struct with a new flags field that allows NIFs to be
declared as dirty. The default value for this field is 0, indicating a
regular NIF, so it's backwards compatible with all existing statically
initialized ErlNifFunc struct instances, and so such instances require no
code changes. Defining the flags field with a value of
ERL_NIF_DIRTY_JOB_CPU_BOUND indicates that the NIF should execute on a
dirty CPU scheduler thread, or defining it with a value of
ERL_NIF_DIRTY_JOB_IO_BOUND indicates that the NIF should execute on a dirty
I/O scheduler thread. Any other flags field value causes a NIF library
loading error.

Extend the ErlNifEntry struct with a new options field that indicates
whether a NIF library was built with support for optional features such as
dirty NIFs. When a NIF library is loaded, the runtime checks the options
field to ensure compatibility. If a NIF library built with dirty NIF
support is loaded into a runtime that does not support dirty NIFs, and the
library defines one or more ErlNifFunc entries with non-zero flags fields
indicating dirty NIFs, a NIF library loading error results. There is no
error if a NIF library built with dirty NIF support is loaded into a
runtime that does not support dirty NIFs but the library does not have any
dirty NIFs. It is also not an error if a library without dirty NIF support
is loaded into a runtime built with dirty NIF support.

Add documentation and tests for enif_schedule_nif().

1 files changed, 53 insertions, 20 deletions

diff --git a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
index 955dc64189..ad9d5d9254 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
+++ b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
@@ -1493,6 +1493,31 @@ static ERL_NIF_TERM consume_timeslice_nif(ErlNifEnv* env, int argc, const ERL_NI
     }
 }
 
+static ERL_NIF_TERM nif_sched2(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    char s[64];
+    if (!enif_get_string(env, argv[2], s, sizeof s, ERL_NIF_LATIN1))
+	return enif_make_badarg(env);
+    return enif_make_tuple2(env, argv[3], argv[2]);
+}
+
+static ERL_NIF_TERM nif_sched1(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ERL_NIF_TERM new_argv[4];
+    new_argv[0] = enif_make_atom(env, "garbage0");
+    new_argv[1] = enif_make_atom(env, "garbage1");
+    new_argv[2] = argv[0];
+    new_argv[3] = argv[1];
+    return enif_schedule_nif(env, "nif_sched2", 0, nif_sched2, 4, new_argv);
+}
+
+static ERL_NIF_TERM call_nif_schedule(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    if (argc != 2)
+	return enif_make_atom(env, "false");
+    return enif_schedule_nif(env, "nif_sched1", 0, nif_sched1, argc, argv);
+}
+
 #ifdef ERL_NIF_DIRTY_SCHEDULER_SUPPORT
 static ERL_NIF_TERM dirty_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
@@ -1507,11 +1532,10 @@ static ERL_NIF_TERM dirty_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[
     enif_get_int(env, argv[0], &n);
     enif_get_string(env, argv[1], s, sizeof s, ERL_NIF_LATIN1);
     enif_inspect_binary(env, argv[2], &b);
-    result = enif_make_tuple3(env,
-			      enif_make_int(env, n),
-			      enif_make_string(env, s, ERL_NIF_LATIN1),
-			      enif_make_binary(env, &b));
-    return enif_schedule_dirty_nif_finalizer(env, result, enif_dirty_nif_finalizer);
+    return enif_make_tuple3(env,
+			    enif_make_int(env, n),
+			    enif_make_string(env, s, ERL_NIF_LATIN1),
+			    enif_make_binary(env, &b));
 }
 
 static ERL_NIF_TERM call_dirty_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
@@ -1526,7 +1550,7 @@ static ERL_NIF_TERM call_dirty_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM
 	if (enif_get_int(env, argv[0], &n) &&
 	    enif_get_string(env, argv[1], s, sizeof s, ERL_NIF_LATIN1) &&
 	    enif_inspect_binary(env, argv[2], &b))
-	    return enif_schedule_dirty_nif(env, ERL_NIF_DIRTY_JOB_CPU_BOUND, dirty_nif, argc, argv);
+	    return enif_schedule_nif(env, "call_dirty_nif", ERL_NIF_DIRTY_JOB_CPU_BOUND, dirty_nif, argc, argv);
 	else
 	    return enif_make_badarg(env);
     } else {
@@ -1534,35 +1558,42 @@ static ERL_NIF_TERM call_dirty_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM
     }
 }
 
-static ERL_NIF_TERM dirty_sender(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+static ERL_NIF_TERM send_from_dirty_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     ERL_NIF_TERM result;
     ErlNifPid pid;
     ErlNifEnv* menv;
     int res;
 
-    enif_get_local_pid(env, argv[0], &pid);
+    if (!enif_get_local_pid(env, argv[0], &pid))
+	return enif_make_badarg(env);
     result = enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_pid(env, &pid));
     menv = enif_alloc_env();
     res = enif_send(env, &pid, menv, result);
     enif_free_env(menv);
     if (!res)
-	/* Note the next line will crash, since dirty nifs can't return exceptions.
-	 * This is intentional, since enif_send should not fail if the test succeeds.
-	 */
-	return enif_schedule_dirty_nif_finalizer(env, enif_make_badarg(env), enif_dirty_nif_finalizer);
+	return enif_make_badarg(env);
     else
-	return enif_schedule_dirty_nif_finalizer(env, result, enif_dirty_nif_finalizer);
+	return result;
 }
 
-static ERL_NIF_TERM send_from_dirty_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+static ERL_NIF_TERM call_dirty_nif_exception(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    ERL_NIF_TERM result;
-    ErlNifPid pid;
-
-    if (!enif_get_local_pid(env, argv[0], &pid))
+    switch (argc) {
+    case 0: {
+	ERL_NIF_TERM args[255];
+	int i;
+	for (i = 0; i < 255; i++)
+	    args[i] = enif_make_int(env, i);
+	return enif_schedule_nif(env, "call_dirty_nif_exception", ERL_NIF_DIRTY_JOB_CPU_BOUND,
+				 call_dirty_nif_exception, 255, argv);
+    }
+    case 1:
 	return enif_make_badarg(env);
-    return enif_schedule_dirty_nif(env, ERL_NIF_DIRTY_JOB_CPU_BOUND, dirty_sender, argc, argv);
+    default:
+	return enif_schedule_nif(env, "call_dirty_nif_exception", ERL_NIF_DIRTY_JOB_CPU_BOUND,
+				 call_dirty_nif_exception, argc-1, argv);
+    }
 }
 #endif
 
@@ -1742,9 +1773,11 @@ static ErlNifFunc nif_funcs[] =
     {"type_sizes", 0, type_sizes},
     {"otp_9668_nif", 1, otp_9668_nif},
     {"consume_timeslice_nif", 2, consume_timeslice_nif},
+    {"call_nif_schedule", 2, call_nif_schedule},
 #ifdef ERL_NIF_DIRTY_SCHEDULER_SUPPORT
     {"call_dirty_nif", 3, call_dirty_nif},
-    {"send_from_dirty_nif", 1, send_from_dirty_nif},
+    {"send_from_dirty_nif", 1, send_from_dirty_nif, ERL_NIF_DIRTY_JOB_CPU_BOUND},
+    {"call_dirty_nif_exception", 0, call_dirty_nif_exception, ERL_NIF_DIRTY_JOB_IO_BOUND},
 #endif
     {"is_map_nif", 1, is_map_nif},
     {"get_map_size_nif", 1, get_map_size_nif},