�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2F'>columnstore</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2Fcolumnstore%2F'>columnstore</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2Fcolumnstore%2Futils%2F'>utils</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2Fcolumnstore%2Futils%2Fcommon%2F'>common</a>/</p><hr><h3>✏️ Editing: cgroupconfigurator.cpp</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* Copyright (C) 2014 InfiniDB, Inc.

   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; version 2 of
   the License.

   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., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

#include &quot;cgroupconfigurator.h&quot;
#include &quot;configcpp.h&quot;
#include &quot;logger.h&quot;
#include &lt;charconv&gt;
#include &lt;fstream&gt;
#include &lt;iostream&gt;
#include &lt;limits&gt;
#include &lt;sys/sysinfo.h&gt;

using namespace boost;
using namespace std;

// minor space-savers
#define RETURN_NO_GROUP(err)                                                   \
  do                                                                           \
  {                                                                            \
    if (!printedWarning)                                                       \
    {                                                                          \
      printedWarning = true;                                                   \
      ostringstream os;                                                        \
      os &lt;&lt; &quot;CGroup warning!  The group &quot; &lt;&lt; cGroupName &lt;&lt; &quot; does not exist.&quot;; \
      cerr &lt;&lt; os.str() &lt;&lt; endl;                                                \
      log(logging::LOG_TYPE_WARNING, os.str());                                \
    }                                                                          \
    return err;                                                                \
  } while (0)

#define RETURN_READ_ERROR(err)                                              \
  do                                                                        \
  {                                                                         \
    if (!printedWarning)                                                    \
    {                                                                       \
      printedWarning = true;                                                \
      ostringstream os;                                                     \
      os &lt;&lt; &quot;CGroup warning!  Could not read the file &quot; &lt;&lt; filename &lt;&lt; &quot;.&quot;; \
      cerr &lt;&lt; os.str() &lt;&lt; endl;                                             \
      log(logging::LOG_TYPE_WARNING, os.str());                             \
    }                                                                       \
    return err;                                                             \
  } while (0)

namespace
{
void log(logging::LOG_TYPE whichLogFile, const string&amp; msg)
{
  logging::Logger logger(12);  // 12 = configcpp
  logger.logMessage(whichLogFile, msg, logging::LoggingID(12));
}

}  // namespace

namespace utils
{
CGroupConfigurator::CGroupConfigurator()
{
  config = config::Config::makeConfig();

  cGroupName = config-&gt;getConfig(&quot;SystemConfig&quot;, &quot;CGroup&quot;);

  if (cGroupName.empty())
    cGroupDefined = false;
  else
    cGroupDefined = true;

  if (cGroupName == &quot;just_no_group_use_local&quot;)
    cGroupName = std::string{};

  ifstream v2Check(&quot;/sys/fs/cgroup/cgroup.controllers&quot;);
  cGroupVersion_ = (v2Check) ? v2 : v1;
}

CGroupConfigurator::~CGroupConfigurator()
{
}

uint32_t CGroupConfigurator::getNumCoresFromCGroup()
{
  ostringstream filenameOs;
  if (cGroupVersion_ == v1)
  {
    filenameOs &lt;&lt; &quot;/sys/fs/cgroup/cpuset/&quot; &lt;&lt; cGroupName &lt;&lt; &quot;/cpuset.cpus&quot;;
  }
  else
  {
    filenameOs &lt;&lt; &quot;/sys/fs/cgroup/&quot; &lt;&lt; cGroupName &lt;&lt; &quot;/cpuset.cpus&quot;;
  }
  string filename = filenameOs.str();

  ifstream in(filename.c_str());
  string cpusString;
  uint32_t cpus = 0;

  if (!in)
    RETURN_NO_GROUP(0);

  try
  {
    // Need to parse &amp; count how many CPUs we have access to
    in &gt;&gt; cpusString;
  }
  catch (...)
  {
    RETURN_READ_ERROR(0);
  }

  // the file has comma-deliminted CPU ranges like &quot;0-7,9,11-12&quot;.
  size_t first = 0, last;
  bool lastRange = false;

  while (!lastRange)
  {
    size_t dash;
    string oneRange;

    last = cpusString.find(&#039;,&#039;, first);

    if (last == string::npos)
    {
      lastRange = true;
      oneRange = cpusString.substr(first);
    }
    else
      oneRange = cpusString.substr(first, last - first - 1);

    if ((dash = oneRange.find(&#039;-&#039;)) == string::npos)  // single-cpu range
      cpus++;
    else
    {
      const char* data = oneRange.c_str();
      uint32_t firstCPU = strtol(data, NULL, 10);
      uint32_t lastCPU = strtol(&amp;data[dash + 1], NULL, 10);
      cpus += lastCPU - firstCPU + 1;
    }

    first = last + 1;
  }

  return cpus;
}

uint32_t CGroupConfigurator::getNumCoresFromProc()
{
  uint32_t nc = sysconf(_SC_NPROCESSORS_ONLN);

  return nc;
}

uint32_t CGroupConfigurator::getNumCores()
{
  /*
      Detect if MCS is in a C-Group
          - get the group ID
      If not, get the number of cores from /proc
  */
  uint32_t ret;

  if (!cGroupDefined)
    ret = getNumCoresFromProc();
  else
  {
    ret = getNumCoresFromCGroup();

    if (ret == 0)
      ret = getNumCoresFromProc();
  }

  return ret;
}

uint64_t CGroupConfigurator::getTotalMemory()
{
  uint64_t ret;

  if (totalMemory != 0)
    return totalMemory;

  cout &lt;&lt; __func__ &lt;&lt; &quot; cGroupDefined (from getConfig) &quot; &lt;&lt; cGroupDefined &lt;&lt; endl;
  if (!cGroupDefined)
    ret = getTotalMemoryFromProc();
  else
  {
    cout &lt;&lt; __func__ &lt;&lt; &quot; cGroupVersion &quot; &lt;&lt;  ((cGroupVersion_ == v2) ? std::string(&quot;v2&quot;) : std::string(&quot;v1&quot;))  &lt;&lt; endl;
    ret = getTotalMemoryFromCGroup();

    if (ret == 0 || ret == std::numeric_limits&lt;uint64_t&gt;::max())
      ret = getTotalMemoryFromProc();
  }

  cout &lt;&lt; __func__ &lt;&lt; &quot; Total mem available (bytes) &quot; &lt;&lt; ret &lt;&lt; &quot; (GIB) &quot; &lt;&lt; ret/GIB &lt;&lt; endl;
  totalMemory = ret;
  return totalMemory;
}

uint64_t CGroupConfigurator::getTotalMemoryFromProc()
{
  size_t memTot;
  cout &lt;&lt; __func__ &lt;&lt; &quot;  reading /proc/meminfo &quot;  &lt;&lt; endl;
  ifstream in(&quot;/proc/meminfo&quot;);
  string x;

  in &gt;&gt; x;
  in &gt;&gt; memTot;

  // memTot is now in KB, convert to bytes
  memTot *= 1024;

  return memTot;
}

uint64_t CGroupConfigurator::getTotalMemoryFromCGroup()
{
  std::string memLimitStr;
  uint64_t memLimit = std::numeric_limits&lt;uint64_t&gt;::max();
  ostringstream os;

  if (cGroupVersion_ == v1)
  {
    os &lt;&lt; &quot;/sys/fs/cgroup/memory/&quot; &lt;&lt; cGroupName &lt;&lt; &quot;/memory.limit_in_bytes&quot;;
  }
  else
  {
    os &lt;&lt; &quot;/sys/fs/cgroup/&quot; &lt;&lt; cGroupName &lt;&lt; &quot;/memory.max&quot;;
  }

  string filename = os.str();
  cout &lt;&lt; __func__ &lt;&lt;&quot; reading &quot; &lt;&lt; filename   &lt;&lt; endl;

  ifstream in(filename.c_str());

  if (!in)
    RETURN_NO_GROUP(0);

  try
  {
    in &gt;&gt; memLimitStr;
  }
  catch (...)
  {
    RETURN_READ_ERROR(0);
  }
  cout &lt;&lt; __func__&lt;&lt;  &quot; read into memLimitStr &quot; &lt;&lt;  memLimitStr  &lt;&lt; endl;

  if (cGroupVersion_ == v2 &amp;&amp; memLimitStr == &quot;max&quot;)
  {
    return std::numeric_limits&lt;uint64_t&gt;::max();
  }

  auto [ch, ec] = std::from_chars(memLimitStr.c_str(), memLimitStr.c_str() + memLimitStr.size(), memLimit);
  if (ec != std::errc())
  {
    return std::numeric_limits&lt;uint64_t&gt;::max();
  }

  if (cGroupVersion_ == v1)
  {
    return std::min(getTotalMemoryFromProc(), memLimit);
  }
  return memLimit;
}

uint64_t CGroupConfigurator::getFreeMemory()
{
  uint64_t ret;
  if (!cGroupDefined)
  {
    ret = getFreeMemoryFromProc();
    if (logCounter++ % logMemoryPeriod == 0)
      cout &lt;&lt;__func__&lt;&lt; &quot; : returned from getFreeMemoryFromProc &quot; &lt;&lt; ret &lt;&lt; &quot; (GIB) &quot; &lt;&lt; ret/GIB  &lt;&lt; endl;

  }
  else
  {
    uint64_t usage = getMemUsageFromCGroup();
    if (logCounter++ % 1000 == 0)
      cout &lt;&lt; __func__&lt;&lt;  &quot; : returned from  getMemUsageFromCGroup : usage &quot; &lt;&lt; usage  &lt;&lt; &quot; (GIB) &quot; &lt;&lt; usage/GIB  &lt;&lt; endl;

    if (usage == 0)
      ret = getFreeMemoryFromProc();
    else
      ret = getTotalMemory() - usage;
  }

  return ret;
}

uint64_t CGroupConfigurator::getMemUsageFromCGroup()
{
  char oneline[80];
  if (memUsageFilename.empty())
  {
    ostringstream filename;
    if (cGroupVersion_ == v1)
    {
      memStatePrefix = &quot;rss &quot;;
      filename &lt;&lt; &quot;/sys/fs/cgroup/memory/&quot; &lt;&lt; cGroupName &lt;&lt; &quot;/memory.stat&quot;;
    }
    else
    {
      memStatePrefix = &quot;anon &quot;;
      filename &lt;&lt; &quot;/sys/fs/cgroup/&quot; &lt;&lt; cGroupName &lt;&lt; &quot;/memory.stat&quot;;
    }
    memUsageFilename = filename.str();
  }

  ifstream in(memUsageFilename.c_str());
  string&amp; filename = memUsageFilename;

  if (!in)
    RETURN_NO_GROUP(0);

  try
  {
    while (in)
    {
      in.getline(oneline, 80);

      if (strncmp(oneline, memStatePrefix.c_str(), memStatePrefix.size() - 1) == 0)
      {
        return atoll(&amp;oneline[memStatePrefix.size()]);
      }
    }
  }
  catch (...)
  {
    RETURN_READ_ERROR(0);
  }

  return 0;
}

uint64_t CGroupConfigurator::getFreeMemoryFromProc()
{
  uint64_t memFree = 0;
  uint64_t buffers = 0;
  uint64_t cached = 0;
  uint64_t memTotal = 0;
  uint64_t memAvailable = 0;

  ifstream in(&quot;/proc/meminfo&quot;);
  string x;

  in &gt;&gt; x;  // MemTotal:
  in &gt;&gt; memTotal;
  in &gt;&gt; x;  // kB

  in &gt;&gt; x;  // MemFree:
  in &gt;&gt; memFree;
  in &gt;&gt; x;  // kB

  // check if available or buffers is passed
  in &gt;&gt; x;

  if (x == &quot;MemAvailable:&quot;)
  {
    in &gt;&gt; memAvailable;  // MemAvailable
  }
  else
  {
    // centos 6 and older OSs
    in &gt;&gt; buffers;
    in &gt;&gt; x;  // kB

    in &gt;&gt; x;  // Cached:
    in &gt;&gt; cached;

    memAvailable = memFree + buffers + cached;
  }

  // amount available for application
  memAvailable *= 1024;
  return memAvailable;
}

}  // namespace utils
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fcolumnstore%2Fcolumnstore%2Futils%2Fcommon'>🔙 Back</a></p>