Do not rely on uniquiness of pthread_t

src/isolate.h

 // Copyright 2010 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 116 matching lines @@
   C(context_address)                       \
   C(pending_exception_address)             \
   C(external_caught_exception_address)
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 #define ISOLATE_ADDRESS_LIST_PROF(C)       \
   C(js_entry_sp_address)
 #else
 #define ISOLATE_ADDRESS_LIST_PROF(C)
 #endif
 

[Vitaly Repeshko, 2011/04/11 19:28:52]

Style nit: two blank lines between top-level declarations.

[Dmitry Lomov, 2011/04/11 21:41:14]

Done.

+// Platform-independent, reliable thread identifier

[Vitaly Repeshko, 2011/04/11 19:28:52]

nit: Comments that are full sentences should start with a capital letter and end
with a period.

[Dmitry Lomov, 2011/04/11 21:41:14]

Done.

+class ThreadId {
+ public:
+  // Creates an invalid ThreadId
+  ThreadId() : id_(kInvalidId) {}
+
+  // Returns ThreadId for current thread
+  static ThreadId Current() { return ThreadId(GetCurrentThreadId()); }
+
+  // Returns invalid ThreadId (guaranteed not to be equal to any thread)
+  static ThreadId Invalid() { return ThreadId(kInvalidId); }

[Vitaly Repeshko, 2011/04/11 19:28:52]

!thread_id.Equals(ThreadId::Invalid()) seems to be a common pattern. To improve
readability add IsValid() instance method.

[Dmitry Lomov, 2011/04/11 21:41:14]

Done.

+
+  // Compares ThreadIds for equality
+  INLINE(bool Equals(const ThreadId& other) const) {
+    return id_ == other.id_;
+  }
+
+  // Converts ThreadId to an integer representation
+  // (required for public API: V8::V8::GetCurrentThreadId).
+  int ToInteger() const { return id_; }
+
+  // Converts ThreadId to an integer representation
+  // (required for public API: V8::V8::TerminateExecution).
+  static ThreadId FromInteger(int id) { return ThreadId(id); }
+
+ private:
+  int id_;

[Vitaly Repeshko, 2011/04/11 19:28:52]

Please sort these following the rules in
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Declaration_Order

[Dmitry Lomov, 2011/04/11 21:41:14]

Done.

+  static const int kInvalidId = -1;
+  static Mutex* thread_id_process_wide_mutex_;
+  static int highest_thread_id_;
+
+  explicit ThreadId(int id) : id_(id) {}
+
+  static int AllocateThreadId();
+  static int GetCurrentThreadId();
+  friend class Isolate;
+};
 

[Vitaly Repeshko, 2011/04/11 19:28:52]

Two blank lines.

[Dmitry Lomov, 2011/04/11 21:41:14]

Done.

 class ThreadLocalTop BASE_EMBEDDED {
  public:
   // Initialize the thread data.
   void Initialize();
 
   // Get the top C++ try catch handler or NULL if none are registered.
   //
   // This method is not guarenteed to return an address that can be
   // used for comparison with addresses into the JS stack.  If such an
   // address is needed, use try_catch_handler_address.
@@ skipping 20 matching lines @@
 
   void Free() {
     ASSERT(!has_pending_message_);
     ASSERT(!external_caught_exception_);
     ASSERT(try_catch_handler_address_ == NULL);
   }
 
   // The context where the current execution method is created and for variable
   // lookups.
   Context* context_;
-  int thread_id_;
+  ThreadId thread_id_;
   MaybeObject* pending_exception_;
   bool has_pending_message_;
   const char* pending_message_;
   Object* pending_message_obj_;
   Script* pending_message_script_;
   int pending_message_start_pos_;
   int pending_message_end_pos_;
   // Use a separate value for scheduled exceptions to preserve the
   // invariants that hold about pending_exception.  We may want to
   // unify them later.
@@ skipping 136 matching lines @@
   ISOLATE_DEBUGGER_INIT_LIST(V)
 
 class Isolate {
   // These forward declarations are required to make the friend declarations in
   // PerIsolateThreadData work on some older versions of gcc.
   class ThreadDataTable;
   class EntryStackItem;
  public:
   ~Isolate();
 
-  typedef int ThreadId;
-
   // A thread has a PerIsolateThreadData instance for each isolate that it has
   // entered. That instance is allocated when the isolate is initially entered
   // and reused on subsequent entries.
   class PerIsolateThreadData {
    public:
     PerIsolateThreadData(Isolate* isolate, ThreadId thread_id)
         : isolate_(isolate),
           thread_id_(thread_id),
           stack_limit_(0),
           thread_state_(NULL),
@@ skipping 12 matching lines @@
 
 #if !defined(__arm__) && defined(V8_TARGET_ARCH_ARM) || \
     !defined(__mips__) && defined(V8_TARGET_ARCH_MIPS)
     Simulator* simulator() const { return simulator_; }
     void set_simulator(Simulator* simulator) {
       simulator_ = simulator;
     }
 #endif
 
     bool Matches(Isolate* isolate, ThreadId thread_id) const {
-      return isolate_ == isolate && thread_id_ == thread_id;
+      return isolate_ == isolate && thread_id_.Equals(thread_id);
     }
 
    private:
     Isolate* isolate_;
     ThreadId thread_id_;
     uintptr_t stack_limit_;
     ThreadState* thread_state_;
 
 #if !defined(__arm__) && defined(V8_TARGET_ARCH_ARM) || \
     !defined(__mips__) && defined(V8_TARGET_ARCH_MIPS)
@@ skipping 66 matching lines @@
   // default isolate if needed.
   static StackGuard* GetDefaultIsolateStackGuard();
 
   // Returns the key used to store the pointer to the current isolate.
   // Used internally for V8 threads that do not execute JavaScript but still
   // are part of the domain of an isolate (like the context switcher).
   static Thread::LocalStorageKey isolate_key() {
     return isolate_key_;
   }
 
-  // Returns the key used to store process-wide thread IDs.
   static Thread::LocalStorageKey thread_id_key() {

[Vitaly Repeshko, 2011/04/11 19:28:52]

Restore the comment.

[Dmitry Lomov, 2011/04/11 21:41:14]

Done.

[Dmitry Lomov, 2011/04/11 21:41:14]

Done.

     return thread_id_key_;
   }
 
-  // Atomically allocates a new thread ID.
-  static ThreadId AllocateThreadId();
-
   // If a client attempts to create a Locker without specifying an isolate,
   // we assume that the client is using legacy behavior. Set up the current
   // thread to be inside the implicit isolate (or fail a check if we have
   // switched to non-legacy behavior).
   static void EnterDefaultIsolate();
 
   // Debug.
   // Mutex for serializing access to break control structures.
   Mutex* break_access() { return break_access_; }
 
   Address get_address_from_id(AddressId id);
 
   // Access to top context (where the current function object was created).
   Context* context() { return thread_local_top_.context_; }
   void set_context(Context* context) {
     thread_local_top_.context_ = context;
   }
   Context** context_address() { return &thread_local_top_.context_; }
 
   SaveContext* save_context() {return thread_local_top_.save_context_; }
   void set_save_context(SaveContext* save) {
     thread_local_top_.save_context_ = save;
   }
 
   // Access to current thread id.
-  int thread_id() { return thread_local_top_.thread_id_; }
-  void set_thread_id(int id) { thread_local_top_.thread_id_ = id; }
+  ThreadId thread_id() { return thread_local_top_.thread_id_; }
+  void set_thread_id(ThreadId id) { thread_local_top_.thread_id_ = id; }
 
   // Interface to pending exception.
   MaybeObject* pending_exception() {
     ASSERT(has_pending_exception());
     return thread_local_top_.pending_exception_;
   }
   bool external_caught_exception() {
     return thread_local_top_.external_caught_exception_;
   }
   void set_external_caught_exception(bool value) {
@@ skipping 494 matching lines @@
 
   // This mutex protects highest_thread_id_, thread_data_table_ and
   // default_isolate_.
   static Mutex* process_wide_mutex_;
 
   static Thread::LocalStorageKey per_isolate_thread_data_key_;
   static Thread::LocalStorageKey isolate_key_;
   static Thread::LocalStorageKey thread_id_key_;
   static Isolate* default_isolate_;
   static ThreadDataTable* thread_data_table_;
-  static ThreadId highest_thread_id_;
 
   bool PreInit();
 
   void Deinit();
 
   static void SetIsolateThreadLocals(Isolate* isolate,
                                      PerIsolateThreadData* data);
 
   enum State {
     UNINITIALIZED,    // Some components may not have been allocated.
@@ skipping 139 matching lines @@
   // between compilation units.
 #define ISOLATE_FIELD_OFFSET(type, name, ignored)                              \
   static const intptr_t name##_debug_offset_;
   ISOLATE_INIT_LIST(ISOLATE_FIELD_OFFSET)
   ISOLATE_INIT_ARRAY_LIST(ISOLATE_FIELD_OFFSET)
 #undef ISOLATE_FIELD_OFFSET
 #endif
 
   friend class ExecutionAccess;
   friend class IsolateInitializer;
+  friend class ThreadId;
   friend class v8::Isolate;
   friend class v8::Locker;
 
   DISALLOW_COPY_AND_ASSIGN(Isolate);
 };
 
 
 // If the GCC version is 4.1.x or 4.2.x an additional field is added to the
 // class as a work around for a bug in the generated code found with these
 // versions of GCC. See V8 issue 122 for details.
@@ skipping 162 matching lines @@
 
 } }  // namespace v8::internal
 
 // TODO(isolates): Get rid of these -inl.h includes and place them only where
 //                 they're needed.
 #include "allocation-inl.h"
 #include "zone-inl.h"
 #include "frames-inl.h"
 
 #endif  // V8_ISOLATE_H_