1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
/*
* Copyright (C) 2019 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.
*/
#include "palette/palette.h"
#include <map>
#include <mutex>
#include <stdbool.h>
#include <android-base/logging.h>
#include <android-base/macros.h> // For ATTRIBUTE_UNUSED
#include "palette_system.h"
// Cached thread priority for testing. No thread priorities are ever affected.
static std::mutex g_tid_priority_map_mutex;
static std::map<int32_t, int32_t> g_tid_priority_map;
palette_status_t PaletteSchedSetPriority(int32_t tid, int32_t priority) {
if (priority < art::palette::kMinManagedThreadPriority ||
priority > art::palette::kMaxManagedThreadPriority) {
return PALETTE_STATUS_INVALID_ARGUMENT;
}
std::lock_guard guard(g_tid_priority_map_mutex);
g_tid_priority_map[tid] = priority;
return PALETTE_STATUS_OK;
}
palette_status_t PaletteSchedGetPriority(int32_t tid,
/*out*/int32_t* priority) {
std::lock_guard guard(g_tid_priority_map_mutex);
if (g_tid_priority_map.find(tid) == g_tid_priority_map.end()) {
g_tid_priority_map[tid] = art::palette::kNormalManagedThreadPriority;
}
*priority = g_tid_priority_map[tid];
return PALETTE_STATUS_OK;
}
palette_status_t PaletteWriteCrashThreadStacks(/*in*/ const char* stacks, size_t stacks_len) {
LOG(INFO) << std::string_view(stacks, stacks_len);
return PALETTE_STATUS_OK;
}
palette_status_t PaletteTraceEnabled(/*out*/bool* enabled) {
*enabled = false;
return PALETTE_STATUS_OK;
}
palette_status_t PaletteTraceBegin(const char* name ATTRIBUTE_UNUSED) {
return PALETTE_STATUS_OK;
}
palette_status_t PaletteTraceEnd() {
return PALETTE_STATUS_OK;
}
palette_status_t PaletteTraceIntegerValue(const char* name ATTRIBUTE_UNUSED,
int32_t value ATTRIBUTE_UNUSED) {
return PALETTE_STATUS_OK;
}
palette_status_t PaletteAshmemCreateRegion(const char* name ATTRIBUTE_UNUSED,
size_t size ATTRIBUTE_UNUSED,
int* fd) {
*fd = -1;
return PALETTE_STATUS_NOT_SUPPORTED;
}
palette_status_t PaletteAshmemSetProtRegion(int fd ATTRIBUTE_UNUSED,
int prot ATTRIBUTE_UNUSED) {
return PALETTE_STATUS_NOT_SUPPORTED;
}
palette_status_t PaletteCreateOdrefreshStagingDirectory(const char** staging_dir) {
*staging_dir = nullptr;
return PALETTE_STATUS_NOT_SUPPORTED;
}
palette_status_t PaletteShouldReportDex2oatCompilation(bool* value) {
*value = false;
return PALETTE_STATUS_OK;
}
palette_status_t PaletteNotifyStartDex2oatCompilation(int source_fd ATTRIBUTE_UNUSED,
int art_fd ATTRIBUTE_UNUSED,
int oat_fd ATTRIBUTE_UNUSED,
int vdex_fd ATTRIBUTE_UNUSED) {
return PALETTE_STATUS_OK;
}
palette_status_t PaletteNotifyEndDex2oatCompilation(int source_fd ATTRIBUTE_UNUSED,
int art_fd ATTRIBUTE_UNUSED,
int oat_fd ATTRIBUTE_UNUSED,
int vdex_fd ATTRIBUTE_UNUSED) {
return PALETTE_STATUS_OK;
}
palette_status_t PaletteNotifyDexFileLoaded(const char* path ATTRIBUTE_UNUSED) {
return PALETTE_STATUS_OK;
}
palette_status_t PaletteNotifyOatFileLoaded(const char* path ATTRIBUTE_UNUSED) {
return PALETTE_STATUS_OK;
}
palette_status_t PaletteShouldReportJniInvocations(bool* value) {
*value = false;
return PALETTE_STATUS_OK;
}
palette_status_t PaletteNotifyBeginJniInvocation(JNIEnv* env ATTRIBUTE_UNUSED) {
return PALETTE_STATUS_OK;
}
palette_status_t PaletteNotifyEndJniInvocation(JNIEnv* env ATTRIBUTE_UNUSED) {
return PALETTE_STATUS_OK;
}
palette_status_t PaletteReportLockContention(JNIEnv* env ATTRIBUTE_UNUSED,
int32_t wait_ms ATTRIBUTE_UNUSED,
const char* filename ATTRIBUTE_UNUSED,
int32_t line_number ATTRIBUTE_UNUSED,
const char* method_name ATTRIBUTE_UNUSED,
const char* owner_filename ATTRIBUTE_UNUSED,
int32_t owner_line_number ATTRIBUTE_UNUSED,
const char* owner_method_name ATTRIBUTE_UNUSED,
const char* proc_name ATTRIBUTE_UNUSED,
const char* thread_name ATTRIBUTE_UNUSED) {
return PALETTE_STATUS_OK;
}
|
