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
10using android::pdx::rpc::WrapString;
11
12namespace android {
13namespace dvr {
14
15PerformanceClient::PerformanceClient(int* error)
16    : BASE(pdx::default_transport::ClientChannelFactory::Create(
17          PerformanceRPC::kClientPath)) {
18  if (error)
19    *error = Client::error();
20}
21
22int 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
31int 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
40int 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
50int 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
60int 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
70int 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
80int 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
93int 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
116extern "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
124extern "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
133extern "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
142extern "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