shared_mutex.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_SOC_SHARED_MUTEX_HPP_
#define FOEDUS_SOC_SHARED_MUTEX_HPP_

#include <pthread.h>
#include <stdint.h>

#include "foedus/cxx11.hpp"

namespace foedus {
namespace soc {
class SharedMutex CXX11_FINAL {
 public:
  SharedMutex() : initialized_(false), recursive_(false) { initialize(); }
  ~SharedMutex() { uninitialize(); }

  // Disable copy constructors
  SharedMutex(const SharedMutex&) CXX11_FUNC_DELETE;
  SharedMutex& operator=(const SharedMutex&) CXX11_FUNC_DELETE;

  void initialize(bool recursive = false);
  void uninitialize();
  bool is_initialized() const { return initialized_; }
  bool is_recursive() const   { return recursive_; }

  void lock();

  bool timedlock(uint64_t timeout_nanosec);

  bool trylock();

  void unlock();

  pthread_mutex_t*  get_raw_mutex() { return &mutex_; }

 private:
  bool                initialized_;
  bool                recursive_;

  pthread_mutex_t     mutex_;
  pthread_mutexattr_t attr_;
};

class SharedMutexScope CXX11_FINAL {
 public:
  SharedMutexScope(SharedMutex* mutex, bool lock_initially = true)
    : mutex_(mutex), locked_by_me_(false) {
    if (lock_initially) {
      lock();
    }
  }
  ~SharedMutexScope() { unlock(); }

  // Disable copy constructors
  SharedMutexScope(const SharedMutexScope&) CXX11_FUNC_DELETE;
  SharedMutexScope& operator=(const SharedMutexScope&) CXX11_FUNC_DELETE;

  bool is_locked_by_me() const { return locked_by_me_; }
  SharedMutex* get_mutex() const { return mutex_; }

  void lock();
  void unlock();

 private:
  SharedMutex* const  mutex_;
  bool                locked_by_me_;
};

}  // namespace soc
}  // namespace foedus
#endif  // FOEDUS_SOC_SHARED_MUTEX_HPP_