xct_mcs_impl.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_XCT_XCT_MCS_IMPL_HPP_
#define FOEDUS_XCT_XCT_MCS_IMPL_HPP_

#include "foedus/compiler.hpp"
#include "foedus/xct/fwd.hpp"
#include "foedus/xct/xct_id.hpp"

namespace foedus {
namespace xct {

template<typename ADAPTOR, typename RW_BLOCK>
class McsImpl {  // TODO(Hideaki) should be renamed to McsRwImpl
 public:
  explicit McsImpl(ADAPTOR adaptor) : adaptor_(adaptor) {}


  McsBlockIndex acquire_unconditional_rw_reader(McsRwLock* lock);

  McsBlockIndex acquire_unconditional_rw_writer(McsRwLock* lock);


  McsBlockIndex acquire_try_rw_reader(McsRwLock* lock);
  static bool does_support_try_rw_reader();

  McsBlockIndex acquire_try_rw_writer(McsRwLock* lock);


  AcquireAsyncRet acquire_async_rw_reader(McsRwLock* lock);
  AcquireAsyncRet acquire_async_rw_writer(McsRwLock* lock);

  bool retry_async_rw_reader(McsRwLock* lock, McsBlockIndex block_index);
  bool retry_async_rw_writer(McsRwLock* lock, McsBlockIndex block_index);

  void cancel_async_rw_reader(McsRwLock* lock, McsBlockIndex block_index);
  void cancel_async_rw_writer(McsRwLock* lock, McsBlockIndex block_index);


  void release_rw_reader(McsRwLock* lock, McsBlockIndex block_index);
  void release_rw_writer(McsRwLock* lock, McsBlockIndex block_index);

 private:
  ADAPTOR adaptor_;
};

template<typename ADAPTOR>
class McsWwImpl {
 public:
  explicit McsWwImpl(ADAPTOR adaptor) : adaptor_(adaptor) {}

  McsBlockIndex  acquire_unconditional(McsWwLock* lock);

  McsBlockIndex  acquire_try(McsWwLock* lock);
  // We so far do not have asynchronous version of WW lock. probably we don't need it..

  McsBlockIndex  initial(McsWwLock* lock);
  void           release(McsWwLock* lock, McsBlockIndex block_index);

 private:
  ADAPTOR adaptor_;
};


class McsWwOwnerlessImpl {
 public:
  // only static methods
  McsWwOwnerlessImpl() = delete;
  ~McsWwOwnerlessImpl() = delete;

  static void     ownerless_acquire_unconditional(McsWwLock* lock);
  static bool     ownerless_acquire_try(McsWwLock* lock);
  static void     ownerless_release(McsWwLock* lock);
  static void     ownerless_initial(McsWwLock* lock);
  // No try/asynchronous versions for guests. Probably we don't need them.
  // TBD So far no RW versions for guests. We might need them later..
};

}  // namespace xct
}  // namespace foedus
#endif  // FOEDUS_XCT_XCT_MCS_IMPL_HPP_