jsÒýÇæv8Ô´Âë½âÎö֮ƽ̨Ïà¹Ø£¨ÉÏƪ£©£¨»ùÓÚv8 0.1.5£©

class VirtualMemory {
 public:
  // Reserves virtual memory with size. address_hint´ú±íÓû§ÏëÓ³ÉäµÄµØÖ·
  VirtualMemory(size_t size, void* address_hint = 0);
  ~VirtualMemory();

  // Returns whether the memory has been reserved.
  bool IsReserved();

  // Returns the start address of the reserved memory.
  void* address() {
    ASSERT(IsReserved());
    return address_;
  };

  // Returns the size of the reserved memory.
  size_t size() { return size_; }

  // Commits real memory. Returns whether the operation succeeded.
  bool Commit(void* address, size_t size);

  // Uncommit real memory.  Returns whether the operation succeeded.
  bool Uncommit(void* address, size_t size);

 private:
  // ¹ÜÀíµÄÄÚ´æÊ×µØÖ·£¬ÓÉmmap·µ»Ø£¬Óû§¿ÉÒÔ×Ô¶¨Òå
  void* address_;  // Start address of the virtual memory.
  // ¹ÜÀíµÄÄÚ´æ´óС
  size_t size_;  // Size of the virtual memory.
};

// Constants used for mmap.
static const int kMmapFd = -1;
static const int kMmapFdOffset = 0;


VirtualMemory::VirtualMemory(size_t size, void* address_hint) {
  // Ó³ÉäÒ»¿éÄڴ棬²»ÄÜ·ÃÎÊ£¬Ë½Óеģ¬²»Ó³Éäµ½Îļþ£¬Ð´µÄʱºòÈç¹ûûÓÐÎïÀíÄÚ´æÔò±¨´í
  address_ = mmap(address_hint, size, PROT_NONE,
                  MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE,
                  kMmapFd, kMmapFdOffset);
  size_ = size;
}


VirtualMemory::~VirtualMemory() {
  // ÒѾ­·ÖÅäÁËÐéÄâÄÚ´æÔòÊÍ·Å
  if (IsReserved()) {
    if (0 == munmap(address(), size())) address_ = MAP_FAILED;
  }
}

// ÊÇ·ñ·ÖÅäÁËÐéÄâÄÚ´æ
bool VirtualMemory::IsReserved() {
  return address_ != MAP_FAILED;
}

// 
bool VirtualMemory::Commit(void* address, size_t size) {
  // ÐÞ¸ÄÒ»¿éÐéÄâÄÚ´æµÄÊôÐÔ£¬MAP_FIXED˵Ã÷·ÖÅäµÄµØÖ·Ò»¶¨ÊÇaddress£¬¶ø²»ÄÜÓɲÙ×÷ϵͳ×Ô¼ºÑ¡Ôñ£¬ÕâÀïÊÇÐÞ¸ÄÊôÐÔ£¬ËùÒÔµØÖ·Òª¹Ì¶¨¡£ÒòΪÕâ¿éÄÚ´æÒѾ­ÉêÇë¹ýÁË
  if (MAP_FAILED == mmap(address, size, PROT_READ | PROT_WRITE | PROT_EXEC,
                         MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED,
                         kMmapFd, kMmapFdOffset)) {
    return false;
  }

  UpdateAllocatedSpaceLimits(address, size);
  return true;
}

// ÐÞ¸Äij¿éÐéÄâÄÚ´æµÄÊôÐÔ£¬±ä³É²»¿É·ÃÎÊ
bool VirtualMemory::Uncommit(void* address, size_t size) {
  return mmap(address, size, PROT_NONE,
              MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE,
              kMmapFd, kMmapFdOffset) != MAP_FAILED;
}

class ThreadHandle::PlatformData : public Malloced {
 public:
  explicit PlatformData(ThreadHandle::Kind kind) {
    Initialize(kind);
  }

  void Initialize(ThreadHandle::Kind kind) {
    switch (kind) {
      case ThreadHandle::SELF: thread_ = pthread_self(); break;
      case ThreadHandle::INVALID: thread_ = kNoThread; break;
    }
  }
  pthread_t thread_;  // Thread handle for pthread.
};

ThreadHandle::ThreadHandle(Kind kind) {
  data_ = new PlatformData(kind);
}


void ThreadHandle::Initialize(ThreadHandle::Kind kind) {
  data_->Initialize(kind);
}


ThreadHandle::~ThreadHandle() {
  delete data_;
}


bool ThreadHandle::IsSelf() const {
  // µ±Ç°Ö´ÐеÄÏß³ÌÊDz»ÊǹÜÀíµÄÏß³Ì
  return pthread_equal(data_->thread_, pthread_self());
}


bool ThreadHandle::IsValid() const {
  return data_->thread_ != kNoThread;
}

// Thread
//
// Thread objects are used for creating and running threads. When the start()
// method is called the new thread starts running the run() method in the new
// thread. The Thread object should not be deallocated before the thread has
// terminated.

class Thread: public ThreadHandle {
 public:
  // Opaque data type for thread-local storage keys.
  enum LocalStorageKey {};

  // Create new thread.
  Thread();
  virtual ~Thread();

  // Start new thread by calling the Run() method in the new thread.
  void Start();

  // Wait until thread terminates.
  void Join();

  // Abstract method for run handler.
  virtual void Run() = 0;

  // Thread-local storage.
  static LocalStorageKey CreateThreadLocalKey();
  static void DeleteThreadLocalKey(LocalStorageKey key);
  static void* GetThreadLocal(LocalStorageKey key);
  static void SetThreadLocal(LocalStorageKey key, void* value);

  // A hint to the scheduler to let another thread run.
  static void YieldCPU();

 private:
  class PlatformData;
  PlatformData* data_;
  DISALLOW_EVIL_CONSTRUCTORS(Thread);
};

Thread::Thread() : ThreadHandle(ThreadHandle::INVALID) {
}


Thread::~Thread() {
}

// argÊÇthisÖ¸Õ룬¼ûStartº¯Êý
static void* ThreadEntry(void* arg) {
  Thread* thread = reinterpret_cast<Thread*>(arg);
  // This is also initialized by the first argument to pthread_create() but we
  // don't know which thread will run first (the original thread or the new
  // one) so we initialize it here too.
  /*
    ÕâÀïÒ²ÉèÖÃÒ»ÏÂÏß³Ìid£¬ÒòΪÈç¹ûн¨ÍêÏ̺߳ó£¬ÊÇн¨µÄÏß³ÌÏÈÖ´ÐУ¬
    Õâʱºòpthread_create»¹Ã»Óиøthread_¸³Öµ,È»ºóÔÚÖ´ÐÐRunµÄʱºòÈç¹ûʹÓÃthread_¾ÍÓÐÎÊÌ⣬»¹ÊÇ¿ÕµÄ
  */
  thread->thread_handle_data()->thread_ = pthread_self();
  ASSERT(thread->IsValid());
  // ×ÓÀàÐèҪʵÏֵĺ¯Êý
  thread->Run();
  return NULL;
}


void Thread::Start() {
  // ´´½¨Ò»¸öỊ̈߳¬Ö´ÐÐThreadEntryº¯Êý£¬°ÑÏß³Ìid±£´æÔÚthread_
  pthread_create(&thread_handle_data()->thread_, NULL, ThreadEntry, this);
  ASSERT(IsValid());
}

// ¹ÒÆ𣬵ȴýÏß³Ìthread_½áÊø
void Thread::Join() {
  pthread_join(thread_handle_data()->thread_, NULL);
}

// ´´½¨Ò»¸öÓÃÓÚÏ̱߳£´æÊý¾Ýkv½á¹¹Ìå¡£±£´æ·µ»ØµÄkey£¬Í¨¹ýkey¿ÉÒÔ·ÃÎÊvalue
Thread::LocalStorageKey Thread::CreateThreadLocalKey() {
  pthread_key_t key;
  int result = pthread_key_create(&key, NULL);
  USE(result);
  ASSERT(result == 0);
  return static_cast<LocalStorageKey>(key);
}

// ɾ³ýÏ̵߳ÄÊý¾Ý
void Thread::DeleteThreadLocalKey(LocalStorageKey key) {
  pthread_key_t pthread_key = static_cast<pthread_key_t>(key);
  int result = pthread_key_delete(pthread_key);
  USE(result);
  ASSERT(result == 0);
}

// ͨ¹ýkey»ñÈ¡Êý¾Ý
void* Thread::GetThreadLocal(LocalStorageKey key) {
  pthread_key_t pthread_key = static_cast<pthread_key_t>(key);
  return pthread_getspecific(pthread_key);
}

// ͨ¹ýkeyдÈëÊý¾Ý
void Thread::SetThreadLocal(LocalStorageKey key, void* value) {
  pthread_key_t pthread_key = static_cast<pthread_key_t>(key);
  pthread_setspecific(pthread_key, value);
}

// ÈÃÓÅÏȼ¶±È×Ô¼º¸ß»òÕßµÈÓÚ×Ô¼ºµÄÏß³ÌÖ´ÐУ¬Èç¹ûûÓУ¬Ôò×Ô¼º¼ÌÐøÖ´ÐÐ 
void Thread::YieldCPU() {
  sched_yield();
}

class Mutex {
 public:
  virtual ~Mutex() {}

  // Locks the given mutex. If the mutex is currently unlocked, it becomes
  // locked and owned by the calling thread, and immediately. If the mutex
  // is already locked by another thread, suspends the calling thread until
  // the mutex is unlocked.
  virtual int Lock() = 0;

  // Unlocks the given mutex. The mutex is assumed to be locked and owned by
  // the calling thread on entrance.
  virtual int Unlock() = 0;
};

class LinuxMutex : public Mutex {
 public:

  LinuxMutex() {
    pthread_mutexattr_t attrs;
    // ³õʼ»¯ÊôÐԽṹÌ壬ÓÃÓÚÉèÖû¥³âµÄһЩÊôÐÔ£¬»òÕß˵²ßÂÔ
    int result = pthread_mutexattr_init(&attrs);
    ASSERT(result == 0);
    // ÉèÖüÓËøÀàÐÍ£¬Ö§³ÖÒ»¸öÏ̶߳à´Î£¨µÝ¹é£©»ñµÃÒ»¸öËø
    result = pthread_mutexattr_settype(&attrs, PTHREAD_MUTEX_RECURSIVE);
    ASSERT(result == 0);
    // ³õʼ»¯»¥³â±äÁ¿
    result = pthread_mutex_init(&mutex_, &attrs);
    ASSERT(result == 0);
  }

  virtual ~LinuxMutex() { pthread_mutex_destroy(&mutex_); }
  // ¶ÔlinxÏ̵߳ķâ×°
  virtual int Lock() {
    int result = pthread_mutex_lock(&mutex_);
    return result;
  }

  virtual int Unlock() {
    int result = pthread_mutex_unlock(&mutex_);
    return result;
  }

 private:
  pthread_mutex_t mutex_;   // Pthread mutex for POSIX platforms.
};

// Semaphore
//
// A semaphore object is a synchronization object that maintains a count. The
// count is decremented each time a thread completes a wait for the semaphore
// object and incremented each time a thread signals the semaphore. When the
// count reaches zero,  threads waiting for the semaphore blocks until the
// count becomes non-zero.

class Semaphore {
 public:
  virtual ~Semaphore() {}

  // Suspends the calling thread until the counter is non zero
  // and then decrements the semaphore counter.
  virtual void Wait() = 0;

  // Increments the semaphore counter.
  virtual void Signal() = 0;
};

class LinuxSemaphore : public Semaphore {
 public:
  // ³õʼ»¯ÐźÅÁ¿£¬×ÊÔ´ÊýÊÇcount¸ö
  explicit LinuxSemaphore(int count) {  sem_init(&sem_, 0, count); }
  virtual ~LinuxSemaphore() { sem_destroy(&sem_); }
  // ûÓпÉÓÃ×ÊÔ´£¬ÐèÒªµÈ´ý
  virtual void Wait() { sem_wait(&sem_); }
  // ¶àÒ»¸ö¿ÉÓÃ×ÊÔ´£¬Èç¹ûÓÐÏ̵߳ȴý£¬Ôò»á±»»½ÐÑ
  virtual void Signal() { sem_post(&sem_); }

 private:
  // linuxÐźÅÁ¿½á¹¹Ìå
  sem_t sem_;
};