Pretenure large external typed data and strings.

runtime/vm/dart_api_impl_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "bin/builtin.h"
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
@@ skipping 1004 matching lines @@
   EXPECT_EQ(41, peer16);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT_EQ(40, peer8);
   EXPECT_EQ(41, peer16);
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   EXPECT_EQ(80, peer8);
   EXPECT_EQ(82, peer16);
 }
 
 
+TEST_CASE(ExternalStringPretenure) {
+  Isolate* isolate = Isolate::Current();
+  {
+    Dart_EnterScope();
+    static const uint8_t big_data8[16*MB] = {0, };
+    Dart_Handle big8 = Dart_NewExternalLatin1String(
+        big_data8,
+        ARRAY_SIZE(big_data8),
+        NULL,
+        NULL);
+    EXPECT_VALID(big8);
+    static const uint16_t big_data16[16*MB/2] = {0, };
+    Dart_Handle big16 = Dart_NewExternalUTF16String(
+        big_data16,
+        ARRAY_SIZE(big_data16),
+        NULL,
+        NULL);
+    static const uint8_t small_data8[] = {'f', 'o', 'o'};
+    Dart_Handle small8 = Dart_NewExternalLatin1String(
+        small_data8,
+        ARRAY_SIZE(small_data8),
+        NULL,
+        NULL);
+    EXPECT_VALID(small8);
+    static const uint16_t small_data16[] = {'b', 'a', 'r'};
+    Dart_Handle small16 = Dart_NewExternalUTF16String(
+        small_data16,
+        ARRAY_SIZE(small_data16),
+        NULL,
+        NULL);
+    EXPECT_VALID(small16);
+    {
+      DARTSCOPE(isolate);
+      String& handle = String::Handle();
+      handle ^= Api::UnwrapHandle(big8);
+      EXPECT(handle.IsOld());
+      handle ^= Api::UnwrapHandle(big16);
+      EXPECT(handle.IsOld());
+      handle ^= Api::UnwrapHandle(small8);
+      EXPECT(handle.IsNew());
+      handle ^= Api::UnwrapHandle(small16);
+      EXPECT(handle.IsNew());
+    }
+    Dart_ExitScope();
+  }
+}
+
+
+TEST_CASE(ExternalTypedDataPretenure) {
+  Isolate* isolate = Isolate::Current();
+  {
+    Dart_EnterScope();
+    static const int kBigLength = 16*MB/8;
+    int64_t* big_data = new int64_t[kBigLength]();
+    Dart_Handle big = Dart_NewExternalTypedData(
+        Dart_TypedData_kInt64,
+        big_data,
+        kBigLength);
+    EXPECT_VALID(big);
+    static const int kSmallLength = 16*KB/8;
+    int64_t* small_data = new int64_t[kSmallLength]();
+    Dart_Handle small = Dart_NewExternalTypedData(
+        Dart_TypedData_kInt64,
+        small_data,
+        kSmallLength);
+    EXPECT_VALID(small);
+    {
+      DARTSCOPE(isolate);
+      ExternalTypedData& handle = ExternalTypedData::Handle();
+      handle ^= Api::UnwrapHandle(big);
+      EXPECT(handle.IsOld());
+      handle ^= Api::UnwrapHandle(small);
+      EXPECT(handle.IsNew());
+    }
+    Dart_ExitScope();
+    delete[] big_data;
+    delete[] small_data;
+  }
+}
+
+
 TEST_CASE(ListAccess) {
   const char* kScriptChars =
       "List testMain() {"
       "  List a = new List();"
       "  a.add(10);"
       "  a.add(20);"
       "  a.add(30);"
       "  return a;"
       "}"
       ""
@@ skipping 6882 matching lines @@
                                    NewString("main"),
                                    1,
                                    dart_args);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(6, value);
 }
 
 }  // namespace dart