Cleanup Semaphore class.

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 12219 matching lines @@
   CHECK(c->IsObject() && c->ToObject()->GetConstructorName()->Equals(
       v8_str("Child")));
 
   Local<v8::Value> x = context->Global()->Get(v8_str("x"));
   CHECK(x->IsObject() && x->ToObject()->GetConstructorName()->Equals(
       v8_str("outer.inner")));
 }
 
 
 bool ApiTestFuzzer::fuzzing_ = false;
-i::Semaphore* ApiTestFuzzer::all_tests_done_=
-  i::OS::CreateSemaphore(0);
+i::Semaphore ApiTestFuzzer::all_tests_done_(0);
 int ApiTestFuzzer::active_tests_;
 int ApiTestFuzzer::tests_being_run_;
 int ApiTestFuzzer::current_;
 
 
 // We are in a callback and want to switch to another thread (if we
 // are currently running the thread fuzzing test).
 void ApiTestFuzzer::Fuzz() {
   if (!fuzzing_) return;
   ApiTestFuzzer* test = RegisterThreadedTest::nth(current_)->fuzzer_;
@@ skipping 10 matching lines @@
     if (kLogThreading)
       printf("Stay with %s\n", test_name);
     return false;
   }
   if (kLogThreading) {
     printf("Switch from %s to %s\n",
            test_name,
            RegisterThreadedTest::nth(test_position)->name());
   }
   current_ = test_position;
-  RegisterThreadedTest::nth(current_)->fuzzer_->gate_->Signal();
+  RegisterThreadedTest::nth(current_)->fuzzer_->gate_.Signal();
   return true;
 }
 
 
 void ApiTestFuzzer::Run() {
   // When it is our turn...
-  gate_->Wait();
+  gate_.Wait();
   {
     // ... get the V8 lock and start running the test.
     v8::Locker locker(CcTest::default_isolate());
     CallTest();
   }
   // This test finished.
   active_ = false;
   active_tests_--;
   // If it was the last then signal that fact.
   if (active_tests_ == 0) {
-    all_tests_done_->Signal();
+    all_tests_done_.Signal();
   } else {
     // Otherwise select a new test and start that.
     NextThread();
   }
 }
 
 
 static unsigned linear_congruential_generator;
 
 
@@ skipping 16 matching lines @@
 static void CallTestNumber(int test_number) {
   (RegisterThreadedTest::nth(test_number)->callback())();
 }
 
 
 void ApiTestFuzzer::RunAllTests() {
   // Set off the first test.
   current_ = -1;
   NextThread();
   // Wait till they are all done.
-  all_tests_done_->Wait();
+  all_tests_done_.Wait();
 }
 
 
 int ApiTestFuzzer::GetNextTestNumber() {
   int next_test;
   do {
     next_test = (linear_congruential_generator >> 16) % tests_being_run_;
     linear_congruential_generator *= 1664525u;
     linear_congruential_generator += 1013904223u;
   } while (!RegisterThreadedTest::nth(next_test)->fuzzer_->active_);
   return next_test;
 }
 
 
 void ApiTestFuzzer::ContextSwitch() {
   // If the new thread is the same as the current thread there is nothing to do.
   if (NextThread()) {
     // Now it can start.
     v8::Unlocker unlocker(CcTest::default_isolate());
     // Wait till someone starts us again.
-    gate_->Wait();
+    gate_.Wait();
     // And we're off.
   }
 }
 
 
 void ApiTestFuzzer::TearDown() {
   fuzzing_ = false;
   for (int i = 0; i < RegisterThreadedTest::count(); i++) {
     ApiTestFuzzer *fuzzer = RegisterThreadedTest::nth(i)->fuzzer_;
     if (fuzzer != NULL) fuzzer->Join();
@@ skipping 1695 matching lines @@
   context1->Global()->Set(v8_str("other"), context0->Global());
   Local<Value> value = CompileRun("var instance = new other.C(); instance.x");
   CHECK(value->IsInt32());
   CHECK_EQ(42, value->Int32Value());
   context1->Exit();
 }
 
 
 class RegExpInterruptTest {
  public:
-  RegExpInterruptTest() : block_(NULL) {}
-  ~RegExpInterruptTest() { delete block_; }
+  RegExpInterruptTest() : block_(0) {}
+  ~RegExpInterruptTest() {}
   void RunTest() {
-    block_ = i::OS::CreateSemaphore(0);
     gc_count_ = 0;
     gc_during_regexp_ = 0;
     regexp_success_ = false;
     gc_success_ = false;
     GCThread gc_thread(this);
     gc_thread.Start();
     v8::Locker::StartPreemption(1);
 
     LongRunningRegExp();
     {
@@ skipping 14 matching lines @@
     explicit GCThread(RegExpInterruptTest* test)
         : Thread("GCThread"), test_(test) {}
     virtual void Run() {
       test_->CollectGarbage();
     }
    private:
      RegExpInterruptTest* test_;
   };
 
   void CollectGarbage() {
-    block_->Wait();
+    block_.Wait();
     while (gc_during_regexp_ < kRequiredGCs) {
       {
         v8::Locker lock(CcTest::default_isolate());
         // TODO(lrn): Perhaps create some garbage before collecting.
         HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
         gc_count_++;
       }
       i::OS::Sleep(1);
     }
     gc_success_ = true;
   }
 
   void LongRunningRegExp() {
-    block_->Signal();  // Enable garbage collection thread on next preemption.
+    block_.Signal();  // Enable garbage collection thread on next preemption.
     int rounds = 0;
     while (gc_during_regexp_ < kRequiredGCs) {
       int gc_before = gc_count_;
       {
         // Match 15-30 "a"'s against 14 and a "b".
         const char* c_source =
             "/a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaa/"
             ".exec('aaaaaaaaaaaaaaab') === null";
         Local<String> source = String::New(c_source);
         Local<Script> script = Script::Compile(source);
@@ skipping 17 matching lines @@
         }
       }
       int gc_after = gc_count_;
       gc_during_regexp_ += gc_after - gc_before;
       rounds++;
       i::OS::Sleep(1);
     }
     regexp_success_ = true;
   }
 
-  i::Semaphore* block_;
+  i::Semaphore block_;
   int gc_count_;
   int gc_during_regexp_;
   bool regexp_success_;
   bool gc_success_;
 };
 
 
 // Test that a regular expression execution can be interrupted and
 // survive a garbage collection.
 TEST(RegExpInterruption) {
@@ skipping 12 matching lines @@
 
   // Should complete without problems.
   RegExpInterruptTest().RunTest();
 
   local_env->Exit();
 }
 
 
 class ApplyInterruptTest {
  public:
-  ApplyInterruptTest() : block_(NULL) {}
-  ~ApplyInterruptTest() { delete block_; }
+  ApplyInterruptTest() : block_(0) {}
+  ~ApplyInterruptTest() {}
   void RunTest() {
-    block_ = i::OS::CreateSemaphore(0);
     gc_count_ = 0;
     gc_during_apply_ = 0;
     apply_success_ = false;
     gc_success_ = false;
     GCThread gc_thread(this);
     gc_thread.Start();
     v8::Locker::StartPreemption(1);
 
     LongRunningApply();
     {
@@ skipping 14 matching lines @@
     explicit GCThread(ApplyInterruptTest* test)
         : Thread("GCThread"), test_(test) {}
     virtual void Run() {
       test_->CollectGarbage();
     }
    private:
      ApplyInterruptTest* test_;
   };
 
   void CollectGarbage() {
-    block_->Wait();
+    block_.Wait();
     while (gc_during_apply_ < kRequiredGCs) {
       {
         v8::Locker lock(CcTest::default_isolate());
         HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
         gc_count_++;
       }
       i::OS::Sleep(1);
     }
     gc_success_ = true;
   }
 
   void LongRunningApply() {
-    block_->Signal();
+    block_.Signal();
     int rounds = 0;
     while (gc_during_apply_ < kRequiredGCs) {
       int gc_before = gc_count_;
       {
         const char* c_source =
             "function do_very_little(bar) {"
             "  this.foo = bar;"
             "}"
             "for (var i = 0; i < 100000; i++) {"
             "  do_very_little.apply(this, ['bar']);"
             "}";
         Local<String> source = String::New(c_source);
         Local<Script> script = Script::Compile(source);
         Local<Value> result = script->Run();
         // Check that no exception was thrown.
         CHECK(!result.IsEmpty());
       }
       int gc_after = gc_count_;
       gc_during_apply_ += gc_after - gc_before;
       rounds++;
     }
     apply_success_ = true;
   }
 
-  i::Semaphore* block_;
+  i::Semaphore block_;
   int gc_count_;
   int gc_during_apply_;
   bool apply_success_;
   bool gc_success_;
 };
 
 
 // Test that nothing bad happens if we get a preemption just when we were
 // about to do an apply().
 TEST(ApplyInterruption) {
@@ skipping 192 matching lines @@
     v8::Local<v8::String> source = v8::String::NewExternal(&uc16_resource);
     v8::Script::Compile(source);
     i::DeleteArray(two_byte_string);
   }
 }
 
 
 class RegExpStringModificationTest {
  public:
   RegExpStringModificationTest()
-      : block_(i::OS::CreateSemaphore(0)),
+      : block_(0),
         morphs_(0),
         morphs_during_regexp_(0),
         ascii_resource_(i::Vector<const char>("aaaaaaaaaaaaaab", 15)),
         uc16_resource_(i::Vector<const uint16_t>(two_byte_content_, 15)) {}
-  ~RegExpStringModificationTest() { delete block_; }
+  ~RegExpStringModificationTest() {}
   void RunTest() {
     i::Factory* factory = i::Isolate::Current()->factory();
 
     regexp_success_ = false;
     morph_success_ = false;
 
     // Initialize the contents of two_byte_content_ to be a uc16 representation
     // of "aaaaaaaaaaaaaab".
     for (int i = 0; i < 14; i++) {
       two_byte_content_[i] = 'a';
@@ skipping 36 matching lines @@
     explicit MorphThread(RegExpStringModificationTest* test)
         : Thread("MorphThread"), test_(test) {}
     virtual void Run() {
       test_->MorphString();
     }
    private:
      RegExpStringModificationTest* test_;
   };
 
   void MorphString() {
-    block_->Wait();
+    block_.Wait();
     while (morphs_during_regexp_ < kRequiredModifications &&
            morphs_ < kMaxModifications) {
       {
         v8::Locker lock(CcTest::default_isolate());
         // Swap string between ascii and two-byte representation.
         i::String* string = *input_;
         MorphAString(string, &ascii_resource_, &uc16_resource_);
         morphs_++;
       }
       i::OS::Sleep(1);
     }
     morph_success_ = true;
   }
 
   void LongRunningRegExp() {
-    block_->Signal();  // Enable morphing thread on next preemption.
+    block_.Signal();  // Enable morphing thread on next preemption.
     while (morphs_during_regexp_ < kRequiredModifications &&
            morphs_ < kMaxModifications) {
       int morphs_before = morphs_;
       {
         v8::HandleScope scope(v8::Isolate::GetCurrent());
         // Match 15-30 "a"'s against 14 and a "b".
         const char* c_source =
             "/a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaa/"
             ".exec(input) === null";
         Local<String> source = String::New(c_source);
         Local<Script> script = Script::Compile(source);
         Local<Value> result = script->Run();
         CHECK(result->IsTrue());
       }
       int morphs_after = morphs_;
       morphs_during_regexp_ += morphs_after - morphs_before;
     }
     regexp_success_ = true;
   }
 
   i::uc16 two_byte_content_[15];
-  i::Semaphore* block_;
+  i::Semaphore block_;
   int morphs_;
   int morphs_during_regexp_;
   bool regexp_success_;
   bool morph_success_;
   i::Handle<i::String> input_;
   AsciiVectorResource ascii_resource_;
   UC16VectorResource uc16_resource_;
 };
 
 
@@ skipping 5476 matching lines @@
   Local<Value> obj = v8::JSON::Parse(v8_str("42"));
   Handle<Object> global = context->Global();
   global->Set(v8_str("obj"), obj);
   ExpectString("JSON.stringify(obj)", "42");
 }
 
 
 #if V8_OS_POSIX
 class ThreadInterruptTest {
  public:
-  ThreadInterruptTest() : sem_(NULL), sem_value_(0) { }
-  ~ThreadInterruptTest() { delete sem_; }
+  ThreadInterruptTest() : sem_(0), sem_value_(0) { }
+  ~ThreadInterruptTest() {}
 
   void RunTest() {
-    sem_ = i::OS::CreateSemaphore(0);
-
     InterruptThread i_thread(this);
     i_thread.Start();
 
-    sem_->Wait();
+    sem_.Wait();
     CHECK_EQ(kExpectedValue, sem_value_);
   }
 
  private:
   static const int kExpectedValue = 1;
 
   class InterruptThread : public i::Thread {
    public:
     explicit InterruptThread(ThreadInterruptTest* test)
         : Thread("InterruptThread"), test_(test) {}
@@ skipping 10 matching lines @@
       sigaction(SIGCHLD, &action, NULL);
 
       // Send signal
       kill(getpid(), SIGCHLD);
 
       // Ensure that if wait has returned because of error
       i::OS::Sleep(100);
 
       // Set value and signal semaphore
       test_->sem_value_ = 1;
-      test_->sem_->Signal();
+      test_->sem_.Signal();
     }
 
     static void SignalHandler(int signal) {
     }
 
    private:
      ThreadInterruptTest* test_;
   };
 
-  i::Semaphore* sem_;
+  i::Semaphore sem_;
   volatile int sem_value_;
 };
 
 
 THREADED_TEST(SemaphoreInterruption) {
   ThreadInterruptTest().RunTest();
 }
 
 
 static bool NamedAccessAlwaysBlocked(Local<v8::Object> global,
@@ skipping 169 matching lines @@
   CheckCorrectThrow("%GetLocalPropertyNames(other, true)");
   CheckCorrectThrow("%DefineOrRedefineAccessorProperty("
                         "other, 'x', null, null, 1)");
 
   // Reset the failed access check callback so it does not influence
   // the other tests.
   v8::V8::SetFailedAccessCheckCallbackFunction(NULL);
 }
 
 #endif  // V8_OS_POSIX