Source/cmInstrumentation.h

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */
#pragma once

#include "cmConfigure.h" // IWYU pragma: keep

#include <chrono>
#include <functional>
#include <map>
#include <set>
#include <string>
#include <vector>

#include <cm/memory>
#include <cm/optional>

#include <cm3p/json/value.h>
#include <stddef.h>
#include <stdint.h>

#ifndef CMAKE_BOOTSTRAP
#  include <cmsys/SystemInformation.hxx>
#endif

#include "cmFileLock.h"
#include "cmInstrumentationQuery.h"

class cmGlobalGenerator;

namespace cm {
enum class TargetType;
} // namespace cm

class cmInstrumentation
{
public:
  using Callback = cmInstrumentationQuery::Callback;

  enum class LoadQueriesAfter
  {
    Yes,
    No
  };
  cmInstrumentation(std::string const& binary_dir,
                    LoadQueriesAfter loadQueries = LoadQueriesAfter::Yes);
  void LoadQueries();
  void CheckCDashVariable();
  struct TimeValue
  {
    long tv_sec;
    long tv_usec;
  };

  struct ProcessMetrics
  {
    TimeValue ru_utime{};
    TimeValue ru_stime{};
    long ru_maxrss = 0;

#ifndef CMAKE_BOOTSTRAP
    ProcessMetrics() = default;
    ProcessMetrics(cmsys::SystemInformation::ProcessResourceUsage const& usage)
      : ru_utime{ usage.ru_utime.tv_sec, usage.ru_utime.tv_usec }
      , ru_stime{ usage.ru_stime.tv_sec, usage.ru_stime.tv_usec }
      , ru_maxrss(usage.ru_maxrss)
    {
    }
#endif
  };

  struct CommandResult
  {
    int ExitCode;
    cm::optional<std::string> StdOut;
    cm::optional<std::string> StdErr;
    cm::optional<ProcessMetrics> ChildResourceUsage;
  };

  int InstrumentCommand(
    std::string command_type, std::vector<std::string> const& command,
    std::function<CommandResult()> const& callback,
    cm::optional<std::map<std::string, std::string>> options = cm::nullopt,
    cm::optional<std::map<std::string, std::string>> arrayOptions =
      cm::nullopt,
    LoadQueriesAfter reloadQueriesAfterCommand = LoadQueriesAfter::No);
  std::string InstrumentTest(
    std::string const& name, std::string const& command,
    std::vector<std::string> const& args, int64_t result,
    std::chrono::steady_clock::time_point steadyStart,
    std::chrono::system_clock::time_point systemStart, std::string config,
    cm::optional<std::string> output = cm::nullopt,
    cm::optional<ProcessMetrics> processMetrics = cm::nullopt);
  void GetPreTestStats();
  bool HasQuery() const;
  bool HasOption(cmInstrumentationQuery::Option option) const;
  bool HasHook(cmInstrumentationQuery::Hook hook) const;
  bool ReadJSONQueries(std::string const& directory);
  void ReadJSONQuery(std::string const& file);
  void WriteJSONQuery(cmInstrumentationQuery::Version dataVersion,
                      std::set<cmInstrumentationQuery::Option> const& options,
                      std::set<cmInstrumentationQuery::Hook> const& hooks,
                      std::vector<std::vector<std::string>> const& callback);
  void AddCustomContent(std::string const& name, Json::Value const& contents);
  void WriteCMakeContent(std::unique_ptr<cmGlobalGenerator> const& gg);
  Json::Value DumpTargets(std::unique_ptr<cmGlobalGenerator> const& gg);
  void ClearGeneratedQueries();
  int CollectTimingData(cmInstrumentationQuery::Hook hook);
  int SpawnBuildDaemon();
  bool LockBuildDaemon();
  bool LockIndexing();
  int CollectTimingAfterBuild(int ppid);
  void AddHook(cmInstrumentationQuery::Hook hook);
  void AddOption(cmInstrumentationQuery::Option option);
  bool HasErrors() const;
  std::string const& GetCDashDir() const;
  std::string const& GetDataDir() const;
  enum LatestOrOldest
  {
    Latest,
    Oldest
  };
  std::string GetFileByTimestamp(LatestOrOldest latestOrOldest,
                                 std::string const& dataSubdir,
                                 std::string const& exclude = "");

private:
  Json::Value ReadJsonSnippet(std::string const& file_name);
  bool AcquireLock(std::string const& lock_file, cmFileLock& lock,
                   unsigned long timeout);
  enum class Atomic
  {
    No,
    Yes,
  };
  void WriteInstrumentationJson(cmInstrumentationQuery::Version version,
                                Json::Value& index,
                                std::string const& directory,
                                std::string const& file_name,
                                Atomic atomic = Atomic::No);
  void InsertStaticSystemInformation(Json::Value& index);
  void GetDynamicSystemInformation(double& memory, double& load);
  void InsertDynamicSystemInformation(Json::Value& index,
                                      std::string const& instant);
  void InsertTimingData(Json::Value& root,
                        std::chrono::steady_clock::time_point steadyStart,
                        std::chrono::system_clock::time_point systemStart);
  bool HasQueryFile(std::string const& file);
  static std::string GetCommandStr(std::vector<std::string> const& args);
  static std::string ComputeSuffixHash(std::string const& command_str);
  static std::string ComputeSuffixTime(
    cm::optional<std::chrono::system_clock::time_point> time = cm::nullopt);
  static bool IsInstrumentableTargetType(cm::TargetType type);
  static Json::Value ResourceUsageToJSON(ProcessMetrics const& usage);
  void PrepareDataForCDash(std::string const& data_dir,
                           std::string const& index_path);
  std::string GetCompileTraceFile(std::vector<std::string> const& command,
                                  Json::Value const& outputs,
                                  std::string const& workingDir);
  void CollectCompileTraceFile(Json::Value& root, std::string traceFile,
                               long int oldTimestamp,
                               std::string const& commandHash,
                               std::string const& suffixTime);
  void RemoveCompileTraceFile(Json::Value const& snippetData);
  void RemoveOldFiles(std::string const& dataSubdir);
  void WriteTraceFile(Json::Value const& index, std::string const& trace_name);
  Json::Value BuildTraceEvent(std::vector<uint64_t>& workers,
                              Json::Value const& snippetData);
  size_t AssignTargetToTraceThread(std::vector<uint64_t>& workers,
                                   uint64_t timeStart, uint64_t duration);
  void ResetQueries();
  std::string binaryDir;
  std::string timingDirv1;
  std::string userTimingDirv1;
  std::string cdashDir;
  std::string dataDir;
  std::set<cmInstrumentationQuery::Option> options;
  std::set<cmInstrumentationQuery::Hook> hooks;
  std::vector<Callback> callbacks;
  std::vector<std::string> queryFiles;
  static std::map<std::string, std::string> cdashSnippetsMap;
  Json::Value preTestStats;
  std::string errorMsg;
  bool hasQuery = false;
  bool ranSystemChecks = false;
  bool ranOSCheck = false;
  Json::Value customContent = Json::objectValue;
  std::map<std::string, Json::Value> configureSnippetData;
#ifndef CMAKE_BOOTSTRAP
  std::unique_ptr<cmsys::SystemInformation> systemInformation;
  cmsys::SystemInformation& GetSystemInformation();
#endif
  int writtenJsonQueries = 0;
  cmFileLock buildLock; // non-blocking
  cmFileLock indexLock; // never held alongside buildLock
};