1 files changed, 192 insertions, 148 deletions

diff --git a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
index 8ebce4fef4..f2b1ef9d24 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
+++ b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  *
- * Copyright Ericsson AB 2009-2014. All Rights Reserved.
+ * Copyright Ericsson AB 2009-2016. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,6 +23,9 @@
 #include <string.h>
 #include <assert.h>
 #include <limits.h>
+#ifndef __WIN32__
+#include <unistd.h>
+#endif
 
 #include "nif_mod.h"
 
@@ -30,14 +33,15 @@ static int static_cntA; /* zero by default */
 static int static_cntB = NIF_SUITE_LIB_VER * 100;
 
 static ERL_NIF_TERM atom_false;
+static ERL_NIF_TERM atom_true;
 static ERL_NIF_TERM atom_self;
 static ERL_NIF_TERM atom_ok;
 static ERL_NIF_TERM atom_join;
 static ERL_NIF_TERM atom_binary_resource_type;
-static ERL_NIF_TERM atom_seconds;
-static ERL_NIF_TERM atom_milli_seconds;
-static ERL_NIF_TERM atom_micro_seconds;
-static ERL_NIF_TERM atom_nano_seconds;
+static ERL_NIF_TERM atom_second;
+static ERL_NIF_TERM atom_millisecond;
+static ERL_NIF_TERM atom_microsecond;
+static ERL_NIF_TERM atom_nanosecond;
 
 
 typedef struct
@@ -138,14 +142,15 @@ static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
 						    msgenv_dtor,
 						    ERL_NIF_RT_CREATE, NULL);
     atom_false = enif_make_atom(env,"false");
+    atom_true = enif_make_atom(env,"true");
     atom_self = enif_make_atom(env,"self");
     atom_ok = enif_make_atom(env,"ok");
     atom_join = enif_make_atom(env,"join");
     atom_binary_resource_type = enif_make_atom(env,"binary_resource_type");
-    atom_seconds = enif_make_atom(env,"seconds");
-    atom_milli_seconds = enif_make_atom(env,"milli_seconds");
-    atom_micro_seconds = enif_make_atom(env,"micro_seconds");
-    atom_nano_seconds = enif_make_atom(env,"nano_seconds");
+    atom_second = enif_make_atom(env,"second");
+    atom_millisecond = enif_make_atom(env,"millisecond");
+    atom_microsecond = enif_make_atom(env,"microsecond");
+    atom_nanosecond = enif_make_atom(env,"nanosecond");
 
     *priv_data = data;
     return 0;
@@ -914,6 +919,7 @@ static ERL_NIF_TERM check_is_exception(ErlNifEnv* env, int argc, const ERL_NIF_T
  * argv[2] empty list
  * argv[3] not an atom
  * argv[4] not a list
+ * argv[5] improper list
  */
 static ERL_NIF_TERM length_test(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
@@ -934,6 +940,9 @@ static ERL_NIF_TERM length_test(ErlNifEnv* env, int argc, const ERL_NIF_TERM arg
     if (enif_get_list_length(env, argv[4], &len))
 	return enif_make_badarg(env);
 
+    if (enif_get_list_length(env, argv[5], &len))
+	return enif_make_badarg(env);
+
     return enif_make_atom(env, "ok");
 }
 
@@ -1460,6 +1469,18 @@ static ERL_NIF_TERM send_term(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[
     return enif_make_int(env, ret);
 }
 
+static ERL_NIF_TERM send_copy_term(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifEnv* menv;
+    ErlNifPid pid;
+    int ret;
+    if (!enif_get_local_pid(env, argv[0], &pid)) {
+	return enif_make_badarg(env);
+    }
+    ret = enif_send(env, &pid, NULL, argv[1]);
+    return enif_make_int(env, ret);
+}
+
 static ERL_NIF_TERM reverse_list(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
     ERL_NIF_TERM rev_list;
 
@@ -1556,120 +1577,6 @@ static ERL_NIF_TERM call_nif_schedule(ErlNifEnv* env, int argc, const ERL_NIF_TE
     return result;
 }
 
-#ifdef ERL_NIF_DIRTY_SCHEDULER_SUPPORT
-
-static int have_dirty_schedulers(void)
-{
-    ErlNifSysInfo si;
-    enif_system_info(&si, sizeof(si));
-    return si.dirty_scheduler_support;
-}
-
-static ERL_NIF_TERM dirty_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
-{
-    int n;
-    char s[10];
-    ErlNifBinary b;
-    ERL_NIF_TERM result;
-    if (have_dirty_schedulers()) {
-	assert(enif_is_on_dirty_scheduler(env));
-    }
-    assert(argc == 3);
-    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_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[])
-{
-    int n;
-    char s[10];
-    ErlNifBinary b;
-    assert(!enif_is_on_dirty_scheduler(env));
-    if (argc != 3)
-	return enif_make_badarg(env);
-    if (have_dirty_schedulers()) {
-	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_nif(env, "call_dirty_nif", ERL_NIF_DIRTY_JOB_CPU_BOUND, dirty_nif, argc, argv);
-	else
-	    return enif_make_badarg(env);
-    } else {
-	return dirty_nif(env, argc, 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;
-
-    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)
-	return enif_make_badarg(env);
-    else
-	return result;
-}
-
-static ERL_NIF_TERM call_dirty_nif_exception(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
-{
-    switch (argc) {
-    case 1: {
-	int arg;
-	if (enif_get_int(env, argv[0], &arg) && arg < 2) {
-	    ERL_NIF_TERM args[255];
-	    int i;
-	    args[0] = argv[0];
-	    for (i = 1; 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, args);
-	} else {
-	    return enif_raise_exception(env, argv[0]);
-	}
-    }
-    case 2: {
-        int return_badarg_directly;
-        enif_get_int(env, argv[0], &return_badarg_directly);
-        assert(return_badarg_directly == 1 || return_badarg_directly == 0);
-        if (return_badarg_directly)
-            return enif_make_badarg(env);
-        else {
-            /* ignore return value */ enif_make_badarg(env);
-            return enif_make_atom(env, "ok");
-        }
-    }
-    default:
-	return enif_schedule_nif(env, "call_dirty_nif_exception", ERL_NIF_DIRTY_JOB_CPU_BOUND,
-				 call_dirty_nif_exception, argc-1, argv);
-    }
-}
-
-static ERL_NIF_TERM call_dirty_nif_zero_args(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
-{
-    int i;
-    ERL_NIF_TERM result[1000];
-    ERL_NIF_TERM ok = enif_make_atom(env, "ok");
-    assert(argc == 0);
-    for (i = 0; i < sizeof(result)/sizeof(*result); i++) {
-	result[i] = ok;
-    }
-    return enif_make_list_from_array(env, result, i);
-}
-#endif
-
 /*
  * If argv[0] is the integer 0, call enif_make_badarg, but don't return its
  * return value. Instead, return ok.  Result should still be a badarg
@@ -1901,13 +1808,13 @@ static ERL_NIF_TERM monotonic_time(ErlNifEnv* env, int argc, const ERL_NIF_TERM
     if (argc != 1)
 	return atom_false;
 
-    if (enif_compare(argv[0], atom_seconds) == 0)
+    if (enif_compare(argv[0], atom_second) == 0)
 	time_unit = ERL_NIF_SEC;
-    else if (enif_compare(argv[0], atom_milli_seconds) == 0)
+    else if (enif_compare(argv[0], atom_millisecond) == 0)
 	time_unit = ERL_NIF_MSEC;
-    else if (enif_compare(argv[0], atom_micro_seconds) == 0)
+    else if (enif_compare(argv[0], atom_microsecond) == 0)
 	time_unit = ERL_NIF_USEC;
-    else if (enif_compare(argv[0], atom_nano_seconds) == 0)
+    else if (enif_compare(argv[0], atom_nanosecond) == 0)
 	time_unit = ERL_NIF_NSEC;
     else
 	time_unit = 4711; /* invalid time unit */
@@ -1922,13 +1829,13 @@ static ERL_NIF_TERM time_offset(ErlNifEnv* env, int argc, const ERL_NIF_TERM arg
     if (argc != 1)
 	return atom_false;
 
-    if (enif_compare(argv[0], atom_seconds) == 0)
+    if (enif_compare(argv[0], atom_second) == 0)
 	time_unit = ERL_NIF_SEC;
-    else if (enif_compare(argv[0], atom_milli_seconds) == 0)
+    else if (enif_compare(argv[0], atom_millisecond) == 0)
 	time_unit = ERL_NIF_MSEC;
-    else if (enif_compare(argv[0], atom_micro_seconds) == 0)
+    else if (enif_compare(argv[0], atom_microsecond) == 0)
 	time_unit = ERL_NIF_USEC;
-    else if (enif_compare(argv[0], atom_nano_seconds) == 0)
+    else if (enif_compare(argv[0], atom_nanosecond) == 0)
 	time_unit = ERL_NIF_NSEC;
     else
 	time_unit = 4711; /* invalid time unit */
@@ -1949,24 +1856,24 @@ static ERL_NIF_TERM convert_time_unit(ErlNifEnv* env, int argc, const ERL_NIF_TE
 
     val = (ErlNifTime) i64;
 
-    if (enif_compare(argv[1], atom_seconds) == 0)
+    if (enif_compare(argv[1], atom_second) == 0)
 	from = ERL_NIF_SEC;
-    else if (enif_compare(argv[1], atom_milli_seconds) == 0)
+    else if (enif_compare(argv[1], atom_millisecond) == 0)
 	from = ERL_NIF_MSEC;
-    else if (enif_compare(argv[1], atom_micro_seconds) == 0)
+    else if (enif_compare(argv[1], atom_microsecond) == 0)
 	from = ERL_NIF_USEC;
-    else if (enif_compare(argv[1], atom_nano_seconds) == 0)
+    else if (enif_compare(argv[1], atom_nanosecond) == 0)
 	from = ERL_NIF_NSEC;
     else
 	from = 4711; /* invalid time unit */
 
-    if (enif_compare(argv[2], atom_seconds) == 0)
+    if (enif_compare(argv[2], atom_second) == 0)
 	to = ERL_NIF_SEC;
-    else if (enif_compare(argv[2], atom_milli_seconds) == 0)
+    else if (enif_compare(argv[2], atom_millisecond) == 0)
 	to = ERL_NIF_MSEC;
-    else if (enif_compare(argv[2], atom_micro_seconds) == 0)
+    else if (enif_compare(argv[2], atom_microsecond) == 0)
 	to = ERL_NIF_USEC;
-    else if (enif_compare(argv[2], atom_nano_seconds) == 0)
+    else if (enif_compare(argv[2], atom_nanosecond) == 0)
 	to = ERL_NIF_NSEC;
     else
 	to = 4711; /* invalid time unit */
@@ -1974,6 +1881,140 @@ static ERL_NIF_TERM convert_time_unit(ErlNifEnv* env, int argc, const ERL_NIF_TE
     return enif_make_int64(env, enif_convert_time_unit(val, from, to));
 }
 
+static ERL_NIF_TERM now_time(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    return enif_now_time(env);
+}
+
+static ERL_NIF_TERM cpu_time(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    return enif_cpu_time(env);
+}
+
+static ERL_NIF_TERM unique_integer(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ERL_NIF_TERM atom_pos = enif_make_atom(env,"positive"),
+        atom_mon = enif_make_atom(env,"monotonic");
+    ERL_NIF_TERM opts = argv[0], opt;
+    ErlNifUniqueInteger properties = 0;
+
+    while (!enif_is_empty_list(env, opts)) {
+	if (!enif_get_list_cell(env, opts, &opt, &opts))
+            return enif_make_badarg(env);
+
+        if (enif_compare(opt, atom_pos) == 0)
+            properties |= ERL_NIF_UNIQUE_POSITIVE;
+        if (enif_compare(opt, atom_mon) == 0)
+            properties |= ERL_NIF_UNIQUE_MONOTONIC;
+    }
+
+    return enif_make_unique_integer(env, properties);
+}
+
+static ERL_NIF_TERM is_process_alive(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifPid pid;
+    if (!enif_get_local_pid(env, argv[0], &pid))
+        return enif_make_badarg(env);
+    if (enif_is_process_alive(env, &pid))
+        return atom_true;
+    return atom_false;
+}
+
+static ERL_NIF_TERM is_port_alive(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifPort port;
+    if (!enif_get_local_port(env, argv[0], &port))
+        return enif_make_badarg(env);
+    if (enif_is_port_alive(env, &port))
+        return atom_true;
+    return atom_false;
+}
+
+static ERL_NIF_TERM term_to_binary(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifBinary bin;
+    ErlNifPid pid;
+    ErlNifEnv *msg_env = env;
+    ERL_NIF_TERM term;
+
+    if (enif_get_local_pid(env, argv[1], &pid))
+        msg_env = enif_alloc_env();
+
+    if (!enif_term_to_binary(msg_env, argv[0], &bin))
+        return enif_make_badarg(env);
+
+    term = enif_make_binary(msg_env, &bin);
+
+    if (msg_env != env) {
+        enif_send(env, &pid, msg_env, term);
+        enif_free_env(msg_env);
+        return atom_true;
+    } else {
+        return term;
+    }
+}
+
+static ERL_NIF_TERM binary_to_term(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifBinary bin;
+    ERL_NIF_TERM term, ret_term;
+    ErlNifPid pid;
+    ErlNifEnv *msg_env = env;
+    unsigned int opts;
+    ErlNifUInt64 ret;
+
+    if (enif_get_local_pid(env, argv[1], &pid))
+        msg_env = enif_alloc_env();
+
+    if (!enif_inspect_binary(env, argv[0], &bin)
+	|| !enif_get_uint(env, argv[2], &opts))
+        return enif_make_badarg(env);
+
+    ret = enif_binary_to_term(msg_env, bin.data, bin.size, &term,
+			      (ErlNifBinaryToTerm)opts);
+    if (!ret)
+	return atom_false;
+
+    ret_term = enif_make_uint64(env, ret);
+    if (msg_env != env) {
+        enif_send(env, &pid, msg_env, term);
+        enif_free_env(msg_env);
+        return ret_term;
+    } else {
+        return enif_make_tuple2(env, ret_term, term);
+    }
+}
+
+static ERL_NIF_TERM port_command(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifPort port;
+
+    if (!enif_get_local_port(env, argv[0], &port))
+        return enif_make_badarg(env);
+
+    if (!enif_port_command(env, &port, NULL, argv[1]))
+        return enif_make_badarg(env);
+    return atom_true;
+}
+
+static ERL_NIF_TERM format_term(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifBinary obin;
+    unsigned int size;
+
+    if (!enif_get_uint(env, argv[0], &size))
+	return enif_make_badarg(env);
+    if (!enif_alloc_binary(size,&obin))
+	return enif_make_badarg(env);
+
+    if (enif_snprintf((char*)obin.data, (size_t)size, "%T", argv[1]) < 0)
+        return atom_false;
+
+    return enif_make_binary(env,&obin);
+}
+
+
 static ErlNifFunc nif_funcs[] =
 {
     {"lib_version", 0, lib_version},
@@ -2002,7 +2043,7 @@ static ErlNifFunc nif_funcs[] =
     {"make_new_resource", 2, make_new_resource},
     {"check_is", 11, check_is},
     {"check_is_exception", 0, check_is_exception},
-    {"length_test", 5, length_test},
+    {"length_test", 6, length_test},
     {"make_atoms", 0, make_atoms},
     {"make_strings", 0, make_strings},
     {"make_new_resource", 2, make_new_resource},
@@ -2019,6 +2060,7 @@ static ErlNifFunc nif_funcs[] =
     {"join_send_thread", 1, join_send_thread},
     {"copy_blob", 1, copy_blob},
     {"send_term", 2, send_term},
+    {"send_copy_term", 2, send_copy_term},
     {"reverse_list",1, reverse_list},
     {"echo_int", 1, echo_int},
     {"type_sizes", 0, type_sizes},
@@ -2026,12 +2068,6 @@ static ErlNifFunc nif_funcs[] =
     {"otp_9828_nif", 1, otp_9828_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, ERL_NIF_DIRTY_JOB_CPU_BOUND},
-    {"call_dirty_nif_exception", 1, call_dirty_nif_exception, ERL_NIF_DIRTY_JOB_IO_BOUND},
-    {"call_dirty_nif_zero_args", 0, call_dirty_nif_zero_args, ERL_NIF_DIRTY_JOB_CPU_BOUND},
-#endif
     {"call_nif_exception", 1, call_nif_exception},
     {"call_nif_nan_or_inf", 1, call_nif_nan_or_inf},
     {"call_nif_atom_too_long", 1, call_nif_atom_too_long},
@@ -2046,8 +2082,16 @@ static ErlNifFunc nif_funcs[] =
     {"sorted_list_from_maps_nif", 1, sorted_list_from_maps_nif},
     {"monotonic_time", 1, monotonic_time},
     {"time_offset", 1, time_offset},
-    {"convert_time_unit", 3, convert_time_unit}
+    {"convert_time_unit", 3, convert_time_unit},
+    {"now_time", 0, now_time},
+    {"cpu_time", 0, cpu_time},
+    {"unique_integer_nif", 1, unique_integer},
+    {"is_process_alive_nif", 1, is_process_alive},
+    {"is_port_alive_nif", 1, is_port_alive},
+    {"term_to_binary_nif", 2, term_to_binary},
+    {"binary_to_term_nif", 3, binary_to_term},
+    {"port_command_nif", 2, port_command},
+    {"format_term_nif", 2, format_term}
 };
 
 ERL_NIF_INIT(nif_SUITE,nif_funcs,load,reload,upgrade,unload)
-