YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.

//  This source code is licensed under the BSD-style license found in the

//  LICENSE file in the root directory of this source tree. An additional grant

//  of patent rights can be found in the PATENTS file in the same directory.

//

// The following only applies to changes made to this file as part of YugaByte development.

//

// Portions Copyright (c) YugaByte, 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.

//

// Copyright (c) 2011 The LevelDB Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file. See the AUTHORS file for names of contributors.

#include "yb/rocksdb/port/port_posix.h"

#include <assert.h>

#if defined(__i386__) || defined(__x86_64__)

#include <cpuid.h>

#endif

#include <signal.h>

#include <stdio.h>

#include <string.h>

#include <glog/logging.h>

#include "yb/rocksdb/util/logging.h"

#include "yb/util/status_log.h"

#if defined(RLIMIT_NOFILE)

#include "yb/util/std_util.h"

#endif

namespace rocksdb {

namespace port {

static int PthreadCall(const char* label, int result) {

  if (result != 0 && result != ETIMEDOUT) {

    fprintf(stderr, "pthread %s: %s\n", label, strerror(result));

    abort();

  }

  return result;

}

Mutex::Mutex(bool adaptive) {

#ifdef __linux__

  if (!adaptive) {

    PthreadCall("init mutex", pthread_mutex_init(&mu_, nullptr));

  } else {

    pthread_mutexattr_t mutex_attr;

    PthreadCall("init mutex attr", pthread_mutexattr_init(&mutex_attr));

    PthreadCall("set mutex attr",

                pthread_mutexattr_settype(&mutex_attr,

                                          PTHREAD_MUTEX_ADAPTIVE_NP));

    PthreadCall("init mutex", pthread_mutex_init(&mu_, &mutex_attr));

    PthreadCall("destroy mutex attr",

                pthread_mutexattr_destroy(&mutex_attr));

  }

#else // ignore adaptive for non-linux platform

  PthreadCall("init mutex", pthread_mutex_init(&mu_, nullptr));

#endif // __linux__

}

Mutex::~Mutex() { PthreadCall("destroy mutex", pthread_mutex_destroy(&mu_)); }

void Mutex::Lock() {

  PthreadCall("lock", pthread_mutex_lock(&mu_));

#ifndef NDEBUG

  locked_ = true;

#endif

}

void Mutex::Unlock() {

#ifndef NDEBUG

  locked_ = false;

#endif

  PthreadCall("unlock", pthread_mutex_unlock(&mu_));

}

void Mutex::AssertHeld() {

#ifndef NDEBUG

  DCHECK(locked_);

#endif

}

CondVar::CondVar(Mutex* mu)

    : mu_(mu) {

    PthreadCall("init cv", pthread_cond_init(&cv_, nullptr));

}

CondVar::~CondVar() { PthreadCall("destroy cv", pthread_cond_destroy(&cv_)); }

void CondVar::Wait() {

#ifndef NDEBUG

  mu_->locked_ = false;

#endif

  PthreadCall("wait", pthread_cond_wait(&cv_, &mu_->mu_));

#ifndef NDEBUG

  mu_->locked_ = true;

#endif

}

bool CondVar::TimedWait(uint64_t abs_time_us) {

  struct timespec ts;

  ts.tv_sec = static_cast<time_t>(abs_time_us / 1000000);

  ts.tv_nsec = static_cast<suseconds_t>((abs_time_us % 1000000) * 1000);

#ifndef NDEBUG

  mu_->locked_ = false;

#endif

  int err = pthread_cond_timedwait(&cv_, &mu_->mu_, &ts);

#ifndef NDEBUG

  mu_->locked_ = true;

#endif

  if (err == ETIMEDOUT) {

    return true;

  }

  if (err != 0) {

    PthreadCall("timedwait", err);

  }

  return false;

}

void CondVar::Signal() {

  PthreadCall("signal", pthread_cond_signal(&cv_));

}

void CondVar::SignalAll() {

  PthreadCall("broadcast", pthread_cond_broadcast(&cv_));

}

RWMutex::RWMutex() {

  PthreadCall("init mutex", pthread_rwlock_init(&mu_, nullptr));

}

RWMutex::~RWMutex() { PthreadCall("destroy mutex", pthread_rwlock_destroy(&mu_)); }

void RWMutex::ReadLock() { PthreadCall("read lock", pthread_rwlock_rdlock(&mu_)); }

void RWMutex::WriteLock() { PthreadCall("write lock", pthread_rwlock_wrlock(&mu_)); }

void RWMutex::ReadUnlock() { PthreadCall("read unlock", pthread_rwlock_unlock(&mu_)); }

void RWMutex::WriteUnlock() { PthreadCall("write unlock", pthread_rwlock_unlock(&mu_)); }

int PhysicalCoreID() {

#if defined(__i386__) || defined(__x86_64__)

  // if you ever find that this function is hot on Linux, you can go from

  // ~200 nanos to ~20 nanos by adding the machinery to use __vdso_getcpu

  unsigned eax, ebx = 0, ecx, edx;

  __get_cpuid(1, &eax, &ebx, &ecx, &edx);

  return ebx >> 24;

#else

  // getcpu or sched_getcpu could work here

  return -1;

#endif

}

void InitOnce(OnceType* once, void (*initializer)()) {

  PthreadCall("once", pthread_once(once, initializer));

}

void Crash(const std::string& srcfile, int srcline) {

  fprintf(stdout, "Crashing at %s:%d\n", srcfile.c_str(), srcline);

  fflush(stdout);

  kill(getpid(), SIGTERM);

}

int GetMaxOpenFiles() {

#if defined(RLIMIT_NOFILE)

  struct rlimit no_files_limit;

  if (getrlimit(RLIMIT_NOFILE, &no_files_limit) != 0) {

    return -1;

  }

  // protect against overflow

  if (yb::std_util::cmp_greater_equal(no_files_limit.rlim_cur, std::numeric_limits<int>::max())) {

    return std::numeric_limits<int>::max();

  }

  return static_cast<int>(no_files_limit.rlim_cur);

#endif

  return -1;

}

}  // namespace port

}  // namespace rocksdb