chunk_lock.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2017 Couchbase, Inc
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */
#pragma once

#include <atomic>

#include "platform/core.h"

namespace phosphor {

struct non_trivial_constructor_t {
};

constexpr non_trivial_constructor_t non_trivial_constructor {};

class SlaveChunkLock;
class MasterChunkLock;
class TraceChunk;

class PHOSPHOR_API ChunkLock {
public:

    ChunkLock() = default;

    ChunkLock(non_trivial_constructor_t t);

    /*
     * Explicit copy-constructor / copy-assignment
     * as they are deleted by std::atomic
     */
    ChunkLock(const ChunkLock& other);
    ChunkLock& operator=(const ChunkLock& other);

    void lockSlave();

    bool tryLockSlave();

    void unlockSlave();

    SlaveChunkLock& slave();

    void lockMaster();

    void unlockMaster();

    MasterChunkLock& master();

protected:
    enum class State {
        // State is explicitly defined as 0 to allow for zero-initialization
        Unlocked = 0x00,
        SlaveLocked,
        MasterLocked
    };

    std::atomic<State> state;

    // Increase size to at least that of a cacheline
    char cacheline_pad[64 - sizeof(std::atomic<State>)];
};

class PHOSPHOR_API SlaveChunkLock : public ChunkLock {
public:
    void lock();
    bool try_lock();
    void unlock();
};

class PHOSPHOR_API MasterChunkLock : public ChunkLock {
public:
    void lock();
    void unlock();
};

struct PHOSPHOR_API ChunkTenant {
    ChunkTenant() = default;

    ChunkTenant(non_trivial_constructor_t t);

    void lock() {
        lck.slave().lock();
    }

    bool try_lock() {
        return lck.slave().try_lock();
    }

    void unlock() {
        lck.slave().unlock();
    }

    ChunkLock lck;
    TraceChunk* chunk;

    bool initialised;
};

// @todo Remove requirement when moving to XCode 8 (10.11.5 / 10.12 or later)
#if defined(__APPLE__)
static_assert(std::is_trivially_constructible<ChunkTenant>::value,
              "ChunkTenant must be trivially constructible as MacOS"
              "only supports trivially constructible thread_locals");
#endif
}