Optimize val::array() iterator version for numeric types. (#17351)

Again numeric contiguous array-like can be optimized same as #17292.
But this needs c++20 and later.
Also updated the test cases and benchmark tests.

Author: xbcnn

system/include/emscripten/val.h

@@ -327,6 +327,17 @@ class val {
 
     template<typename Iter>
     static val array(Iter begin, Iter end) {
+#if _LIBCPP_STD_VER >= 20
+        if constexpr (std::contiguous_iterator<Iter> &&
+                      internal::typeSupportsMemoryView<
+                        typename std::iterator_traits<Iter>::value_type>()) {
+            val view{ typed_memory_view(std::distance(begin, end), std::to_address(begin)) };
+            return val(internal::_emval_new_array_from_memory_view(view.as_handle()));
+        }
+        // For numeric arrays, following codes are unreachable and the compiler
+        // will do 'dead code elimination'.
+        // Others fallback old way.
+#endif
         val new_array = array();
         for (auto it = begin; it != end; ++it) {
             new_array.call<void>("push", *it);

tests/embind/embind_benchmark.cpp

@@ -476,17 +476,21 @@ void __attribute__((noinline)) numeric_val_array_benchmark() {
   for (int i = 0; i < kLoopTimes; i++) {
     val v = val::array(vec.begin(), vec.end());
   }
-  printf("val::array: %lf\n", emscripten_get_now() - t);
+  printf("\nval::array(Iter begin, Iter end): %lf msecs.\n", emscripten_get_now() - t);
 
   t = emscripten_get_now();
   for (int i = 0; i < kLoopTimes; i++) {
     val v = val::array(vec);
   }
-  printf("val::array opt numeric types: %lf\n", emscripten_get_now() - t);
+  printf("val::array(const std::vector<T>& vec) with opt numeric types: %lf msecs.\n", emscripten_get_now() - t);
 
   // It's about 20x times faster.
-  // val::array: 1021.525756
-  // val::array opt numeric types: 50.600682
+  // val::array(Iter begin, Iter end): 727.300000 msecs.
+  // val::array(const std::vector<T>& vec) with opt numeric types: 29.700000 msecs.
+
+  // If compile with `--std=c++20`, the result is very close.
+  // val::array(Iter begin, Iter end): 30.400000 msecs.
+  // val::array(const std::vector<T>& vec) with opt numeric types: 27.500000 msecs.
 }
 
 int EMSCRIPTEN_KEEPALIVE main()

tests/embind/test_val.cpp

@@ -74,6 +74,31 @@ int main() {
   ensure_js("a[2] == 3");
   ensure_js_not("a[2] == 2");
 
+  test("template<typename Iter> val array(Iter begin, Iter end)");
+  val::global().set("a", val::array(vec1.begin(), vec1.end()));
+  ensure_js("a instanceof Array");
+  ensure_js_not("a instanceof Boolean");
+  ensure_js_not("a instanceof Number");
+  ensure_js("a[0] == 11");
+  ensure_js_not("a[0] == 12");
+  ensure_js("a[1] == 'a'");
+  ensure_js("a[2] instanceof Array");
+  val::global().set("a", val::array(vec2.begin(), vec2.end()));
+  ensure_js("a instanceof Array");
+  ensure_js_not("a instanceof Number");
+  ensure_js("a[0] == 0");
+  ensure_js_not("a[0] == 1");
+  ensure_js("a[1] == 1");
+  ensure_js("a[2] == 3");
+  ensure_js_not("a[2] == 2");
+  int arr[] = {1, 2, 3};
+  val::global().set("a", val::array(arr, arr + 3));
+  ensure_js("a instanceof Array");
+  ensure_js_not("a instanceof Number");
+  ensure_js("a[0] == 1");
+  ensure_js("a[1] == 2");
+  ensure_js("a[2] == 3");
+
   test("val object()");
   val::global().set("a", val::object());
   ensure_js("a instanceof Object");

tests/embind/test_val.out

@@ -1,5 +1,6 @@
 test: val array()...
 test: template<typename T> val array(const std::vector<T> vec)...
+test: template<typename Iter> val array(Iter begin, Iter end)...
 test: val object()...
 test: val undefined()...
 test: val null()...