Merge (7265, 7271] from bleeding_edge to experimental/gc branch....

src/platform.h

 // Copyright 2006-2008 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 159 matching lines @@
   // Returns the daylight savings offset for the given time.
   static double DaylightSavingsOffset(double time);
 
   // Returns last OS error.
   static int GetLastError();
 
   static FILE* FOpen(const char* path, const char* mode);
   static bool Remove(const char* path);
 
   // Log file open mode is platform-dependent due to line ends issues.
-  static const char* LogFileOpenMode;
+  static const char* const LogFileOpenMode;
 
   // Print output to console. This is mostly used for debugging output.
   // On platforms that has standard terminal output, the output
   // should go to stdout.
   static void Print(const char* format, ...);
   static void VPrint(const char* format, va_list args);
 
   // Print output to a file. This is mostly used for debugging output.
   static void FPrint(FILE* out, const char* format, ...);
   static void VFPrint(FILE* out, const char* format, va_list args);
@@ skipping 199 matching lines @@
  public:
   // Opaque data type for thread-local storage keys.
   // LOCAL_STORAGE_KEY_MIN_VALUE and LOCAL_STORAGE_KEY_MAX_VALUE are specified
   // to ensure that enumeration type has correct value range (see Issue 830 for
   // more details).
   enum LocalStorageKey {
     LOCAL_STORAGE_KEY_MIN_VALUE = kMinInt,
     LOCAL_STORAGE_KEY_MAX_VALUE = kMaxInt
   };
 
-  // Create new thread.
-  Thread();
-  explicit Thread(const char* name);
+  // Create new thread (with a value for storing in the TLS isolate field).
+  explicit Thread(Isolate* isolate);
+  Thread(Isolate* isolate, const char* name);
   virtual ~Thread();
 
   // Start new thread by calling the Run() method in the new thread.
   void Start();
 
   // Wait until thread terminates.
   void Join();
 
   inline const char* name() const {
     return name_;
@@ skipping 13 matching lines @@
   static void SetThreadLocalInt(LocalStorageKey key, int value) {
     SetThreadLocal(key, reinterpret_cast<void*>(static_cast<intptr_t>(value)));
   }
   static bool HasThreadLocal(LocalStorageKey key) {
     return GetThreadLocal(key) != NULL;
   }
 
   // A hint to the scheduler to let another thread run.
   static void YieldCPU();
 
+  Isolate* isolate() const { return isolate_; }
+
   // The thread name length is limited to 16 based on Linux's implementation of
   // prctl().
   static const int kMaxThreadNameLength = 16;
  private:
   void set_name(const char *name);
 
   class PlatformData;
   PlatformData* data_;
-
+  Isolate* isolate_;
   char name_[kMaxThreadNameLength];
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 
 // ----------------------------------------------------------------------------
 // Mutex
 //
 // Mutexes are used for serializing access to non-reentrant sections of code.
@@ skipping 13 matching lines @@
   // the calling thread on entrance.
   virtual int Unlock() = 0;
 
   // Tries to lock the given mutex. Returns whether the mutex was
   // successfully locked.
   virtual bool TryLock() = 0;
 };
 
 
 // ----------------------------------------------------------------------------
-// ScopedLock
+// ScopedLock/ScopedUnlock
 //
-// Stack-allocated ScopedLocks provide block-scoped locking and unlocking
-// of a mutex.
+// Stack-allocated ScopedLocks/ScopedUnlocks provide block-scoped
+// locking and unlocking of a mutex.
 class ScopedLock {
  public:
   explicit ScopedLock(Mutex* mutex): mutex_(mutex) {
+    ASSERT(mutex_ != NULL);
     mutex_->Lock();
   }
   ~ScopedLock() {
     mutex_->Unlock();
   }
 
  private:
   Mutex* mutex_;
   DISALLOW_COPY_AND_ASSIGN(ScopedLock);
 };
@@ skipping 90 matching lines @@
   Address tos;  // Top stack value (*sp).
   static const int kMaxFramesCount = 64;
   Address stack[kMaxFramesCount];  // Call stack.
   int frames_count;  // Number of captured frames.
 };
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 class Sampler {
  public:
   // Initialize sampler.
-  explicit Sampler(int interval);
+  Sampler(Isolate* isolate, int interval);
   virtual ~Sampler();
 
+  int interval() const { return interval_; }
+
   // Performs stack sampling.
   void SampleStack(TickSample* sample) {
     DoSampleStack(sample);
     IncSamplesTaken();
   }
 
   // This method is called for each sampling period with the current
   // program counter.
   virtual void Tick(TickSample* sample) = 0;
 
   // Start and stop sampler.
   void Start();
   void Stop();
 
   // Is the sampler used for profiling?
   bool IsProfiling() const { return NoBarrier_Load(&profiling_) > 0; }
   void IncreaseProfilingDepth() { NoBarrier_AtomicIncrement(&profiling_, 1); }
   void DecreaseProfilingDepth() { NoBarrier_AtomicIncrement(&profiling_, -1); }
 
   // Whether the sampler is running (that is, consumes resources).
   bool IsActive() const { return NoBarrier_Load(&active_); }
 
+  Isolate* isolate() { return isolate_; }
+
   // Used in tests to make sure that stack sampling is performed.
   int samples_taken() const { return samples_taken_; }
   void ResetSamplesTaken() { samples_taken_ = 0; }
 
   class PlatformData;
   PlatformData* data() { return data_; }
 
+  PlatformData* platform_data() { return data_; }
+
  protected:
   virtual void DoSampleStack(TickSample* sample) = 0;
 
  private:
   void SetActive(bool value) { NoBarrier_Store(&active_, value); }
   void IncSamplesTaken() { if (++samples_taken_ < 0) samples_taken_ = 0; }
 
+  Isolate* isolate_;
   const int interval_;
   Atomic32 profiling_;
   Atomic32 active_;
   PlatformData* data_;  // Platform specific data.
   int samples_taken_;  // Counts stack samples taken.
   DISALLOW_IMPLICIT_CONSTRUCTORS(Sampler);
 };
 
+
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 } }  // namespace v8::internal
 
 #endif  // V8_PLATFORM_H_