Use v8::internal threading support in samples/shell.cc.

samples/shell.cc

 // Copyright 2009 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 17 matching lines @@
 #include <v8.h>
 #include <v8-testing.h>
 #include <assert.h>
 #include <fcntl.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "../src/v8.h"
 
-// TODO(isolates):
-//   o Either use V8 internal platform stuff for every platform or
-//     re-implement it.
-//   o Do not assume not WIN32 implies pthreads.
-#ifndef WIN32
-#include <pthread.h>  // NOLINT
+#if !defined(_WIN32) && !defined(_WIN64)
 #include <unistd.h>  // NOLINT
 #endif
 
 static void ExitShell(int exit_code) {
   // Use _exit instead of exit to avoid races between isolate
   // threads and static destructors.
   fflush(stdout);
   fflush(stderr);
   _exit(exit_code);
 }
 
 v8::Persistent<v8::Context> CreateShellContext();
 void RunShell(v8::Handle<v8::Context> context);
 bool ExecuteString(v8::Handle<v8::String> source,
                    v8::Handle<v8::Value> name,
                    bool print_result,
                    bool report_exceptions);
 v8::Handle<v8::Value> Print(const v8::Arguments& args);
 v8::Handle<v8::Value> Read(const v8::Arguments& args);
 v8::Handle<v8::Value> Load(const v8::Arguments& args);
 v8::Handle<v8::Value> Quit(const v8::Arguments& args);
 v8::Handle<v8::Value> Version(const v8::Arguments& args);
 v8::Handle<v8::String> ReadFile(const char* name);
 void ReportException(v8::TryCatch* handler);
 
 
-#ifndef WIN32
-void* IsolateThreadEntry(void* arg);
-#endif
-
 static bool last_run = true;
 
 class SourceGroup {
  public:
   SourceGroup() : argv_(NULL),
                   begin_offset_(0),
                   end_offset_(0),
-                  next_semaphore_(NULL),
-                  done_semaphore_(NULL) {
-#ifndef WIN32
-    next_semaphore_ = v8::internal::OS::CreateSemaphore(0);
-    done_semaphore_ = v8::internal::OS::CreateSemaphore(0);
-    thread_ = 0;
-#endif
-  }
+                  next_semaphore_(v8::internal::OS::CreateSemaphore(0)),
+                  done_semaphore_(v8::internal::OS::CreateSemaphore(0)),
+                  thread_(NULL) { }
 
   void Begin(char** argv, int offset) {
     argv_ = const_cast<const char**>(argv);
     begin_offset_ = offset;
   }
 
   void End(int offset) { end_offset_ = offset; }
 
   void Execute() {
     for (int i = begin_offset_; i < end_offset_; ++i) {
@@ skipping 19 matching lines @@
           printf("Error reading '%s'\n", arg);
         }
         if (!ExecuteString(source, file_name, false, true)) {
           ExitShell(1);
           return;
         }
       }
     }
   }
 
-#ifdef WIN32
-  void StartExecuteInThread() { ExecuteInThread(); }
-  void WaitForThread() {}
-
-#else
   void StartExecuteInThread() {
-    if (thread_ == 0) {
-      pthread_attr_t attr;
-      // On some systems (OSX 10.6) the stack size default is 0.5Mb or less
-      // which is not enough to parse the big literal expressions used in tests.
-      // The stack size should be at least StackGuard::kLimitSize + some
-      // OS-specific padding for thread startup code.
-      size_t stacksize = 2 << 20;  // 2 Mb seems to be enough
-      pthread_attr_init(&attr);
-      pthread_attr_setstacksize(&attr, stacksize);
-      int error = pthread_create(&thread_, &attr, &IsolateThreadEntry, this);
-      if (error != 0) {
-        fprintf(stderr, "Error creating isolate thread.\n");
-        ExitShell(1);
-      }
+    if (thread_ == NULL) {
+      thread_ = new IsolateThread(this);
+      thread_->Start();
     }
     next_semaphore_->Signal();
   }
 
   void WaitForThread() {
-    if (thread_ == 0) return;
+    if (thread_ == NULL) return;
     if (last_run) {
-      pthread_join(thread_, NULL);
-      thread_ = 0;
+      thread_->Join();
+      thread_ = NULL;
     } else {
       done_semaphore_->Wait();
     }
   }
-#endif  // WIN32
 
  private:
+  static v8::internal::Thread::Options GetThreadOptions() {
+    v8::internal::Thread::Options options;
+    options.name = "IsolateThread";
+    // On some systems (OSX 10.6) the stack size default is 0.5Mb or less
+    // which is not enough to parse the big literal expressions used in tests.
+    // The stack size should be at least StackGuard::kLimitSize + some
+    // OS-specific padding for thread startup code.
+    options.stack_size = 2 << 20;  // 2 Mb seems to be enough
+    return options;
+  }
+
+  class IsolateThread : public v8::internal::Thread {
+   public:
+    explicit IsolateThread(SourceGroup* group)
+        : group_(group), v8::internal::Thread(NULL, GetThreadOptions()) {}
+
+    virtual void Run() {
+      group_->ExecuteInThread();
+    }
+
+   private:
+    SourceGroup* group_;
+  };
+
   void ExecuteInThread() {
     v8::Isolate* isolate = v8::Isolate::New();
     do {
       if (next_semaphore_ != NULL) next_semaphore_->Wait();
       {
         v8::Isolate::Scope iscope(isolate);
         v8::HandleScope scope;
         v8::Persistent<v8::Context> context = CreateShellContext();
         {
           v8::Context::Scope cscope(context);
           Execute();
         }
         context.Dispose();
       }
       if (done_semaphore_ != NULL) done_semaphore_->Signal();
     } while (!last_run);
     isolate->Dispose();
   }
 
   const char** argv_;
   int begin_offset_;
   int end_offset_;
   v8::internal::Semaphore* next_semaphore_;
   v8::internal::Semaphore* done_semaphore_;
-#ifndef WIN32
-  pthread_t thread_;
-#endif
-
-  friend void* IsolateThreadEntry(void* arg);
+  v8::internal::Thread* thread_;
 };
 
-#ifndef WIN32
-void* IsolateThreadEntry(void* arg) {
-  reinterpret_cast<SourceGroup*>(arg)->ExecuteInThread();
-  return NULL;
-}
-#endif
-
 
 static SourceGroup* isolate_sources = NULL;
 
 
 int RunMain(int argc, char* argv[]) {
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
   v8::HandleScope handle_scope;
   v8::Persistent<v8::Context> context = CreateShellContext();
   // Enter the newly created execution environment.
   context->Enter();
@@ skipping 304 matching lines @@
       printf("^");
     }
     printf("\n");
     v8::String::Utf8Value stack_trace(try_catch->StackTrace());
     if (stack_trace.length() > 0) {
       const char* stack_trace_string = ToCString(stack_trace);
       printf("%s\n", stack_trace_string);
     }
   }
 }