Split cctest/test-types.cc into heap and zone versions for more parallelism.

test/cctest/test-types.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "src/hydrogen-types.h"
 #include "src/isolate-inl.h"
 #include "src/types.h"
 #include "test/cctest/cctest.h"
@@ skipping 88 matching lines @@
   typedef typename TypesInstance::TypeVector::iterator TypeIterator;
   typedef typename TypesInstance::MapVector::iterator MapIterator;
   typedef typename TypesInstance::ValueVector::iterator ValueIterator;
 
   Isolate* isolate;
   HandleScope scope;
   Zone zone;
   TypesInstance T;
 
   Tests()
-      : isolate(CcTest::i_isolate()),
+      : isolate(CcTest::InitIsolateOnce()),
         scope(isolate),
         zone(),
         T(Rep::ToRegion(&zone, isolate), isolate,
           isolate->random_number_generator()) {}
 
   bool Equal(TypeHandle type1, TypeHandle type2) {
     return
         type1->Equals(type2) &&
         this->IsBitset(type1) == this->IsBitset(type2) &&
         this->IsUnion(type1) == this->IsUnion(type2) &&
@@ skipping 1837 matching lines @@
         CHECK(!type1->Is(type2) || htype1.IsSubtypeOf(htype2));
       }
     }
   }
 };
 
 typedef Tests<Type, Type*, Zone, ZoneRep> ZoneTests;
 typedef Tests<HeapType, Handle<HeapType>, Isolate, HeapRep> HeapTests;
 
 
-TEST(IsSomeType) {
-  CcTest::InitializeVM();
-  ZoneTests().IsSomeType();
-  HeapTests().IsSomeType();
+TEST(IsSomeType_zone) { ZoneTests().IsSomeType(); }
+
+
+TEST(IsSomeType_heap) { HeapTests().IsSomeType(); }
+
+
+TEST(PointwiseRepresentation_zone) { ZoneTests().PointwiseRepresentation(); }
+
+
+TEST(PointwiseRepresentation_heap) { HeapTests().PointwiseRepresentation(); }
+
+
+TEST(BitsetType_zone) { ZoneTests().Bitset(); }
+
+
+TEST(BitsetType_heap) { HeapTests().Bitset(); }
+
+
+TEST(ClassType_zone) { ZoneTests().Class(); }
+
+
+TEST(ClassType_heap) { HeapTests().Class(); }
+
+
+TEST(ConstantType_zone) { ZoneTests().Constant(); }
+
+
+TEST(ConstantType_heap) { HeapTests().Constant(); }
+
+
+TEST(RangeType_zone) { ZoneTests().Range(); }
+
+
+TEST(RangeType_heap) { HeapTests().Range(); }
+
+
+TEST(ArrayType_zone) { ZoneTests().Array(); }
+
+
+TEST(ArrayType_heap) { HeapTests().Array(); }
+
+
+TEST(FunctionType_zone) { ZoneTests().Function(); }
+
+
+TEST(FunctionType_heap) { HeapTests().Function(); }
+
+
+TEST(Of_zone) { ZoneTests().Of(); }
+
+
+TEST(Of_heap) { HeapTests().Of(); }
+
+
+TEST(NowOf_zone) { ZoneTests().NowOf(); }
+
+
+TEST(NowOf_heap) { HeapTests().NowOf(); }
+
+
+TEST(MinMax_zone) { ZoneTests().MinMax(); }
+
+
+TEST(MinMax_heap) { HeapTests().MinMax(); }
+
+
+TEST(BitsetGlb_zone) { ZoneTests().BitsetGlb(); }
+
+
+TEST(BitsetGlb_heap) { HeapTests().BitsetGlb(); }
+
+
+TEST(BitsetLub_zone) { ZoneTests().BitsetLub(); }
+
+
+TEST(BitsetLub_heap) { HeapTests().BitsetLub(); }
+
+
+TEST(Is1_zone) { ZoneTests().Is1(); }
+
+
+TEST(Is1_heap) { HeapTests().Is1(); }
+
+
+TEST(Is2_zone) { ZoneTests().Is2(); }
+
+
+TEST(Is2_heap) { HeapTests().Is2(); }
+
+
+TEST(NowIs_zone) { ZoneTests().NowIs(); }
+
+
+TEST(NowIs_heap) { HeapTests().NowIs(); }
+
+
+TEST(Contains_zone) { ZoneTests().Contains(); }
+
+
+TEST(Contains_heap) { HeapTests().Contains(); }
+
+
+TEST(NowContains_zone) { ZoneTests().NowContains(); }
+
+
+TEST(NowContains_heap) { HeapTests().NowContains(); }
+
+
+TEST(Maybe_zone) { ZoneTests().Maybe(); }
+
+
+TEST(Maybe_heap) { HeapTests().Maybe(); }
+
+
+TEST(Union1_zone) { ZoneTests().Union1(); }
+
+
+TEST(Union1_heap) { HeapTests().Union1(); }
+
+
+TEST(Union2_zone) { ZoneTests().Union2(); }
+
+
+TEST(Union2_heap) { HeapTests().Union2(); }
+
+
+TEST(Union3_zone) { ZoneTests().Union3(); }
+
+
+TEST(Union3_heap) { HeapTests().Union3(); }
+
+
+TEST(Union4_zone) { ZoneTests().Union4(); }
+
+
+TEST(Union4_heap) { HeapTests().Union4(); }
+
+
+TEST(Intersect_zone) { ZoneTests().Intersect(); }
+
+
+TEST(Intersect_heap) { HeapTests().Intersect(); }
+
+
+TEST(Distributivity_zone) { ZoneTests().Distributivity(); }
+
+
+TEST(Distributivity_heap) { HeapTests().Distributivity(); }
+
+
+TEST(GetRange_zone) { ZoneTests().GetRange(); }
+
+
+TEST(GetRange_heap) { HeapTests().GetRange(); }
+
+
+TEST(Convert_zone) {
+  ZoneTests().Convert<HeapType, Handle<HeapType>, Isolate, HeapRep>();
 }
 
 
-TEST(PointwiseRepresentation) {
-  CcTest::InitializeVM();
-  // ZoneTests().PointwiseRepresentation();
-  HeapTests().PointwiseRepresentation();
-}
+TEST(Convert_heap) { HeapTests().Convert<Type, Type*, Zone, ZoneRep>(); }
 
 
-TEST(BitsetType) {
-  CcTest::InitializeVM();
-  ZoneTests().Bitset();
-  HeapTests().Bitset();
-}
+TEST(HTypeFromType_zone) { ZoneTests().HTypeFromType(); }
 
 
-TEST(ClassType) {
-  CcTest::InitializeVM();
-  ZoneTests().Class();
-  HeapTests().Class();
-}
-
-
-TEST(ConstantType) {
-  CcTest::InitializeVM();
-  ZoneTests().Constant();
-  HeapTests().Constant();
-}
-
-
-TEST(RangeType) {
-  CcTest::InitializeVM();
-  ZoneTests().Range();
-  HeapTests().Range();
-}
-
-
-TEST(ArrayType) {
-  CcTest::InitializeVM();
-  ZoneTests().Array();
-  HeapTests().Array();
-}
-
-
-TEST(FunctionType) {
-  CcTest::InitializeVM();
-  ZoneTests().Function();
-  HeapTests().Function();
-}
-
-
-TEST(Of) {
-  CcTest::InitializeVM();
-  ZoneTests().Of();
-  HeapTests().Of();
-}
-
-
-TEST(NowOf) {
-  CcTest::InitializeVM();
-  ZoneTests().NowOf();
-  HeapTests().NowOf();
-}
-
-
-TEST(MinMax) {
-  CcTest::InitializeVM();
-  ZoneTests().MinMax();
-  HeapTests().MinMax();
-}
-
-
-TEST(BitsetGlb) {
-  CcTest::InitializeVM();
-  ZoneTests().BitsetGlb();
-  HeapTests().BitsetGlb();
-}
-
-
-TEST(BitsetLub) {
-  CcTest::InitializeVM();
-  ZoneTests().BitsetLub();
-  HeapTests().BitsetLub();
-}
-
-
-TEST(Is1) {
-  CcTest::InitializeVM();
-  ZoneTests().Is1();
-  HeapTests().Is1();
-}
-
-
-TEST(Is2) {
-  CcTest::InitializeVM();
-  ZoneTests().Is2();
-  HeapTests().Is2();
-}
-
-
-TEST(NowIs) {
-  CcTest::InitializeVM();
-  ZoneTests().NowIs();
-  HeapTests().NowIs();
-}
-
-
-TEST(Contains) {
-  CcTest::InitializeVM();
-  ZoneTests().Contains();
-  HeapTests().Contains();
-}
-
-
-TEST(NowContains) {
-  CcTest::InitializeVM();
-  ZoneTests().NowContains();
-  HeapTests().NowContains();
-}
-
-
-TEST(Maybe) {
-  CcTest::InitializeVM();
-  ZoneTests().Maybe();
-  HeapTests().Maybe();
-}
-
-
-TEST(Union1) {
-  CcTest::InitializeVM();
-  ZoneTests().Union1();
-  HeapTests().Union1();
-}
-
-
-/*
-TEST(Union2) {
-  CcTest::InitializeVM();
-  ZoneTests().Union2();
-  HeapTests().Union2();
-}
-*/
-
-
-TEST(Union3) {
-  CcTest::InitializeVM();
-  ZoneTests().Union3();
-  HeapTests().Union3();
-}
-
-
-TEST(Union4) {
-  CcTest::InitializeVM();
-  ZoneTests().Union4();
-  HeapTests().Union4();
-}
-
-
-TEST(Intersect) {
-  CcTest::InitializeVM();
-  ZoneTests().Intersect();
-  HeapTests().Intersect();
-}
-
-
-TEST(Distributivity) {
-  CcTest::InitializeVM();
-  ZoneTests().Distributivity();
-  HeapTests().Distributivity();
-}
-
-
-TEST(GetRange) {
-  CcTest::InitializeVM();
-  ZoneTests().GetRange();
-  HeapTests().GetRange();
-}
-
-
-TEST(Convert) {
-  CcTest::InitializeVM();
-  ZoneTests().Convert<HeapType, Handle<HeapType>, Isolate, HeapRep>();
-  HeapTests().Convert<Type, Type*, Zone, ZoneRep>();
-}
-
-
-TEST(HTypeFromType) {
-  CcTest::InitializeVM();
-  ZoneTests().HTypeFromType();
-  HeapTests().HTypeFromType();
-}
+TEST(HTypeFromType_heap) { HeapTests().HTypeFromType(); }