xref: /system/extras/perfprofd/perfprofd_threaded_handler.h

/*
 *
 * Copyright 2017, The Android Open Source Project
 *
 * 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.
 */

#ifndef SYSTEM_EXTRAS_PERFPROFD_PERFPROFD_THREADED_HANDLER_H_
#define SYSTEM_EXTRAS_PERFPROFD_PERFPROFD_THREADED_HANDLER_H_

#include <chrono>
#include <condition_variable>
#include <cstdio>
#include <cstdlib>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <functional>

#include <inttypes.h>
#include <unistd.h>

#include <android-base/logging.h>
#include <android-base/stringprintf.h>

#include "perfprofd_record.pb.h"

#include "config.h"
#include "dropbox.h"
#include "perfprofdcore.h"
#include "perfprofd_io.h"

namespace android {
namespace perfprofd {

class ThreadedConfig : public Config {
 public:
  void Sleep(size_t seconds) override {
    if (seconds == 0) {
      return;
    }
    std::unique_lock<std::mutex> guard(mutex_);
    using namespace std::chrono_literals;
    cv_.wait_for(guard, seconds * 1s, [&]() { return interrupted_; });
  }
  bool ShouldStopProfiling() override {
    std::unique_lock<std::mutex> guard(mutex_);
    return interrupted_;
  }

  void ResetStopProfiling() {
    std::unique_lock<std::mutex> guard(mutex_);
    interrupted_ = false;
  }
  void StopProfiling() {
    std::unique_lock<std::mutex> guard(mutex_);
    interrupted_ = true;
    cv_.notify_all();
  }

  bool IsProfilingEnabled() const override {
    return true;
  }

  // Operator= to simplify setting the config values. This will retain the
  // original mutex, condition-variable etc.
  ThreadedConfig& operator=(const ThreadedConfig& rhs) {
    // Copy base fields.
    *static_cast<Config*>(this) = static_cast<const Config&>(rhs);

    return *this;
  }

 private:
  bool is_profiling = false;
  std::mutex mutex_;
  std::condition_variable cv_;
  bool interrupted_ = false;

  friend class ThreadedHandler;
};

class ThreadedHandler  {
 public:
  ThreadedHandler() : cur_config_(new ThreadedConfig()) {}
  explicit ThreadedHandler(ThreadedConfig* in) : cur_config_(in) {
    CHECK(cur_config_ != nullptr);
  }

  virtual ~ThreadedHandler() {}

  template <typename ConfigFn> bool StartProfiling(ConfigFn fn, std::string* error_msg) {
    std::lock_guard<std::mutex> guard(lock_);

    if (cur_config_->is_profiling) {
      *error_msg = "Already profiling";
      return false;
    }
    cur_config_->is_profiling = true;
    cur_config_->ResetStopProfiling();

    fn(*cur_config_);

    HandlerFn handler = GetResultHandler();
    auto profile_runner = [handler](ThreadedHandler* service) {
      ProfilingLoop(*service->cur_config_, handler);

      // This thread is done.
      std::lock_guard<std::mutex> unset_guard(service->lock_);
      service->cur_config_->is_profiling = false;
    };
    std::thread profiling_thread(profile_runner, this);
    profiling_thread.detach();  // Let it go.

    return true;
  }

  bool StopProfiling(std::string* error_msg) {
    std::lock_guard<std::mutex> guard(lock_);
    if (!cur_config_->is_profiling) {
      *error_msg = "Not profiling";
      return false;
    }

    cur_config_->StopProfiling();

    return true;
  }

 protected:
  // Handler for ProfilingLoop.
  virtual bool ResultHandler(android::perfprofd::PerfprofdRecord* encodedProfile,
                             Config* config) {
    CHECK(config != nullptr);
    if (encodedProfile == nullptr) {
      return false;
    }

    if (static_cast<ThreadedConfig*>(config)->send_to_dropbox) {
      std::string error_msg;
      if (!dropbox::SendToDropbox(encodedProfile, config->destination_directory, &error_msg)) {
        LOG(WARNING) << "Failed dropbox submission: " << error_msg;
        return false;
      }
      return true;
    }

    if (encodedProfile == nullptr) {
      return false;
    }
    std::string data_file_path(config->destination_directory);
    data_file_path += "/perf.data";
    std::string path = android::base::StringPrintf("%s.encoded.%d", data_file_path.c_str(), seq_);
    if (!SerializeProtobuf(encodedProfile, path.c_str(), config->compress)) {
      return false;
    }

    seq_++;
    return true;
  }

  template <typename Fn>
  void RunOnConfig(Fn& fn) {
    std::lock_guard<std::mutex> guard(lock_);
    fn(cur_config_->is_profiling, cur_config_.get());
  }

 private:
  // Helper for the handler.
  HandlerFn GetResultHandler() {
    return HandlerFn(std::bind(&ThreadedHandler::ResultHandler,
                               this,
                               std::placeholders::_1,
                               std::placeholders::_2));
  }

  std::mutex lock_;

  std::unique_ptr<ThreadedConfig> cur_config_;

  int seq_ = 0;
};

}  // namespace perfprofd
}  // namespace android

#endif  // SYSTEM_EXTRAS_PERFPROFD_PERFPROFD_THREADED_HANDLER_H_