// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you 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.


#ifndef IMPALA_UTIL_CPU_INFO_H
#define IMPALA_UTIL_CPU_INFO_H

#include <memory>
#include <string>
#include <vector>
#include <boost/cstdint.hpp>

#include "common/logging.h"

namespace impala {

/// CpuInfo is an interface to query for cpu information at runtime.  The caller can
/// ask for the sizes of the caches and what hardware features are supported.
/// On Linux, this information is pulled from a couple of sys files (/proc/cpuinfo and
/// /sys/devices)
class CpuInfo {
 public:
  static const int64_t SSSE3     = (1 << 1);
  static const int64_t SSE4_1    = (1 << 2);
  static const int64_t SSE4_2    = (1 << 3);
  static const int64_t POPCNT    = (1 << 4);
  static const int64_t AVX       = (1 << 5);
  static const int64_t AVX2      = (1 << 6);
  static const int64_t PCLMULQDQ = (1 << 7);

  /// Cache enums for L1 (data), L2 and L3
  enum CacheLevel {
    L1_CACHE = 0,
    L2_CACHE = 1,
    L3_CACHE = 2,
  };
  static const int NUM_CACHE_LEVELS = L3_CACHE + 1;

  /// Initialize CpuInfo.
  static void Init();

  /// Determine if the CPU meets the minimum CPU requirements and if not, log an error.
  static void VerifyCpuRequirements();

  /// Determine if the CPU scaling governor is set to 'performance' and if not, issue an
  /// error.
  static void VerifyPerformanceGovernor();

  /// Determine if CPU turbo is disabled and if not, issue an error.
  static void VerifyTurboDisabled();

  /// Returns all the flags for this cpu
  static int64_t hardware_flags() {
    DCHECK(initialized_);
    return hardware_flags_;
  }

  /// Returns whether of not the cpu supports this flag
  inline static bool IsSupported(long flag) {
    DCHECK(initialized_);
    return (hardware_flags_ & flag) != 0;
  }

  /// Toggle a hardware feature on and off.  It is not valid to turn on a feature
  /// that the underlying hardware cannot support. This is useful for testing.
  static void EnableFeature(long flag, bool enable);

  /// Returns the number of cpu cycles per millisecond
  static int64_t cycles_per_ms() {
    DCHECK(initialized_);
    return cycles_per_ms_;
  }

  /// Returns the number of cores (including hyper-threaded) on this machine that are
  /// available for use by Impala (either the number of online cores or the value of
  /// the --num_cores command-line flag).
  static int num_cores() {
    DCHECK(initialized_);
    return num_cores_;
  }

  /// Returns the maximum number of cores that will be online in the system, including
  /// any offline cores or cores that could be added via hot-plugging.
  static int GetMaxNumCores() { return max_num_cores_; }

  /// Returns the core that the current thread is running on. Always in range
  /// [0, GetMaxNumCores()). Note that the thread may be migrated to a different core
  /// at any time by the scheduler, so the caller should not assume the answer will
  /// remain stable.
  static int GetCurrentCore();

  /// Returns the maximum number of NUMA nodes that will be online in the system,
  /// including any that may be offline or disabled.
  static int GetMaxNumNumaNodes() { return max_num_numa_nodes_; }

  /// Returns the NUMA node of the core provided. 'core' must be in the range
  /// [0, GetMaxNumCores()).
  static int GetNumaNodeOfCore(int core) {
    DCHECK_LE(0, core);
    DCHECK_LT(core, max_num_cores_);
    return core_to_numa_node_[core];
  }

  /// Returns the cores in a NUMA node. 'node' must be in the range
  /// [0, GetMaxNumNumaNodes()).
  static const std::vector<int>& GetCoresOfNumaNode(int node) {
    DCHECK_LE(0, node);
    DCHECK_LT(node, max_num_numa_nodes_);
    return numa_node_to_cores_[node];
  }

  /// Returns the cores in the same NUMA node as 'core'. 'core' must be in the range
  /// [0, GetMaxNumCores()).
  static const std::vector<int>& GetCoresOfSameNumaNode(int core) {
    DCHECK_LE(0, core);
    DCHECK_LT(core, max_num_cores_);
    return GetCoresOfNumaNode(GetNumaNodeOfCore(core));
  }

  /// Returns the index of the given core within the vector returned by
  /// GetCoresOfNumaNode() and GetCoresOfSameNumaNode(). 'core' must be in the range
  /// [0, GetMaxNumCores()).
  static int GetNumaNodeCoreIdx(int core) {
    DCHECK_LE(0, core);
    DCHECK_LT(core, max_num_cores_);
    return numa_node_core_idx_[core];
  }

  /// Returns the model name of the cpu (e.g. Intel i7-2600)
  static std::string model_name() {
    DCHECK(initialized_);
    return model_name_;
  }

  static std::string DebugString();

  /// A utility class for temporarily disabling CPU features. Usage:
  ///
  /// {
  ///   CpuInfo::TempDisable disabler(CpuInfo::AVX2);
  ///   // On the previous line, the constructor disables AVX2 instructions. On the next
  ///   // line, CpuInfo::IsSupported(CpuInfo::AVX2) will return false.
  ///   SomeOperation();
  ///   // On the next line, the block closes, 'disabler's destructor runs, and AVX2
  ///   // instructions are re-enabled.
  /// }
  ///
  /// TempDisable's destructor never re-enables features that were not enabled when then
  /// constructor ran.
  struct TempDisable {
    TempDisable(int64_t feature)
      : feature_(feature), reenable_(CpuInfo::IsSupported(feature)) {
      CpuInfo::EnableFeature(feature_, false);
    }
    ~TempDisable() {
      if (reenable_) {
        CpuInfo::EnableFeature(feature_, true);
      }
    }

   private:
    int64_t feature_;
    bool reenable_;
  };

 protected:
  friend class CpuTestUtil;

  /// Setup fake NUMA info to simulate NUMA for backend tests. Sets up CpuInfo to
  /// simulate 'max_num_numa_nodes' with 'core_to_numa_node' specifying the NUMA node
  /// of each core in [0, GetMaxNumCores()).
  static void InitFakeNumaForTest(
      int max_num_numa_nodes, const std::vector<int>& core_to_numa_node);

 private:
  /// Initialize NUMA-related state - called from Init();
  static void InitNuma();

  /// Initialize 'numa_node_to_cores_' based on 'max_num_numa_nodes_' and
  /// 'core_to_numa_node_'. Called from InitNuma();
  static void InitNumaNodeToCores();

  /// Populates the arguments with information about this machine's caches.
  /// The values returned are not reliable in some environments, e.g. RHEL5 on EC2, so
  /// so we will keep this as a private method.
  static void GetCacheInfo(long cache_sizes[NUM_CACHE_LEVELS],
      long cache_line_sizes[NUM_CACHE_LEVELS]);

  static bool initialized_;
  static int64_t hardware_flags_;
  static int64_t original_hardware_flags_;
  static int64_t cycles_per_ms_;
  static int num_cores_;
  static int max_num_cores_;
  static std::string model_name_;

  /// Maximum possible number of NUMA nodes.
  static int max_num_numa_nodes_;

  /// Array with 'max_num_cores_' entries, each of which is the NUMA node of that core.
  static std::unique_ptr<int[]> core_to_numa_node_;

  /// Vector with 'max_num_numa_nodes_' entries, each of which is a vector of the cores
  /// belonging to that NUMA node.
  static std::vector<std::vector<int>> numa_node_to_cores_;

  /// Array with 'max_num_cores_' entries, each of which is the index of that core in its
  /// NUMA node.
  static std::vector<int> numa_node_core_idx_;
};
}
#endif