Home | History | Annotate | Download | only in libperformance 
      1 #include "include/private/dvr/performance_client.h"
      2 
      3 #include <sys/types.h>
      4 
      5 #include <pdx/default_transport/client_channel_factory.h>
      6 #include <pdx/rpc/remote_method.h>
      7 #include <pdx/rpc/string_wrapper.h>
      8 #include <private/dvr/performance_rpc.h>
      9 
     10 using android::pdx::rpc::WrapString;
     11 
     12 namespace android {
     13 namespace dvr {
     14 
     15 PerformanceClient::PerformanceClient(int* error)
     16     : BASE(pdx::default_transport::ClientChannelFactory::Create(
     17           PerformanceRPC::kClientPath)) {
     18   if (error)
     19     *error = Client::error();
     20 }
     21 
     22 int PerformanceClient::SetCpuPartition(pid_t task_id,
     23                                        const std::string& partition) {
     24   if (task_id == 0)
     25     task_id = gettid();
     26 
     27   return ReturnStatusOrError(
     28       InvokeRemoteMethod<PerformanceRPC::SetCpuPartition>(task_id, partition));
     29 }
     30 
     31 int PerformanceClient::SetCpuPartition(pid_t task_id, const char* partition) {
     32   if (task_id == 0)
     33     task_id = gettid();
     34 
     35   return ReturnStatusOrError(
     36       InvokeRemoteMethod<PerformanceRPC::SetCpuPartition>(
     37           task_id, WrapString(partition)));
     38 }
     39 
     40 int PerformanceClient::SetSchedulerPolicy(pid_t task_id,
     41                                           const std::string& scheduler_policy) {
     42   if (task_id == 0)
     43     task_id = gettid();
     44 
     45   return ReturnStatusOrError(
     46       InvokeRemoteMethod<PerformanceRPC::SetSchedulerPolicy>(task_id,
     47                                                              scheduler_policy));
     48 }
     49 
     50 int PerformanceClient::SetSchedulerPolicy(pid_t task_id,
     51                                           const char* scheduler_policy) {
     52   if (task_id == 0)
     53     task_id = gettid();
     54 
     55   return ReturnStatusOrError(
     56       InvokeRemoteMethod<PerformanceRPC::SetSchedulerPolicy>(
     57           task_id, WrapString(scheduler_policy)));
     58 }
     59 
     60 int PerformanceClient::SetSchedulerClass(pid_t task_id,
     61                                          const std::string& scheduler_class) {
     62   if (task_id == 0)
     63     task_id = gettid();
     64 
     65   return ReturnStatusOrError(
     66       InvokeRemoteMethod<PerformanceRPC::SetSchedulerClass>(task_id,
     67                                                             scheduler_class));
     68 }
     69 
     70 int PerformanceClient::SetSchedulerClass(pid_t task_id,
     71                                          const char* scheduler_class) {
     72   if (task_id == 0)
     73     task_id = gettid();
     74 
     75   return ReturnStatusOrError(
     76       InvokeRemoteMethod<PerformanceRPC::SetSchedulerClass>(
     77           task_id, WrapString(scheduler_class)));
     78 }
     79 
     80 int PerformanceClient::GetCpuPartition(pid_t task_id,
     81                                        std::string* partition_out) {
     82   if (partition_out == nullptr)
     83     return -EINVAL;
     84 
     85   if (task_id == 0)
     86     task_id = gettid();
     87 
     88   auto status = InvokeRemoteMethodInPlace<PerformanceRPC::GetCpuPartition>(
     89       partition_out, task_id);
     90   return status ? 0 : -status.error();
     91 }
     92 
     93 int PerformanceClient::GetCpuPartition(pid_t task_id, char* partition_out,
     94                                        std::size_t size) {
     95   if (partition_out == nullptr)
     96     return -EINVAL;
     97 
     98   if (task_id == 0)
     99     task_id = gettid();
    100 
    101   auto wrapper = WrapString(partition_out, size);
    102   auto status = InvokeRemoteMethodInPlace<PerformanceRPC::GetCpuPartition>(
    103       &wrapper, task_id);
    104   if (!status)
    105     return -status.error();
    106 
    107   if (wrapper.size() < size)
    108     partition_out[wrapper.size()] = '\0';
    109 
    110   return 0;
    111 }
    112 
    113 }  // namespace dvr
    114 }  // namespace android
    115 
    116 extern "C" int dvrSetCpuPartition(pid_t task_id, const char* partition) {
    117   int error;
    118   if (auto client = android::dvr::PerformanceClient::Create(&error))
    119     return client->SetCpuPartition(task_id, partition);
    120   else
    121     return error;
    122 }
    123 
    124 extern "C" int dvrSetSchedulerPolicy(pid_t task_id,
    125                                      const char* scheduler_policy) {
    126   int error;
    127   if (auto client = android::dvr::PerformanceClient::Create(&error))
    128     return client->SetSchedulerPolicy(task_id, scheduler_policy);
    129   else
    130     return error;
    131 }
    132 
    133 extern "C" int dvrSetSchedulerClass(pid_t task_id,
    134                                     const char* scheduler_class) {
    135   int error;
    136   if (auto client = android::dvr::PerformanceClient::Create(&error))
    137     return client->SetSchedulerClass(task_id, scheduler_class);
    138   else
    139     return error;
    140 }
    141 
    142 extern "C" int dvrGetCpuPartition(pid_t task_id, char* partition, size_t size) {
    143   int error;
    144   if (auto client = android::dvr::PerformanceClient::Create(&error))
    145     return client->GetCpuPartition(task_id, partition, size);
    146   else
    147     return error;
    148 }
    149