+ src/monitor_android.cc \

+ src/monitor_linux.cc \

+bool (*Monitor::is_sensitive_thread_hook_)() = NULL;

+uint32_t Monitor::lock_profiling_threshold_ = 0;

+bool Monitor::IsSensitiveThread() {

+ if (is_sensitive_thread_hook_ != NULL) {

+ return (*is_sensitive_thread_hook_)();

+ }

+ return false;

+}

+

+void Monitor::Init(bool is_verbose, uint32_t lock_profiling_threshold, bool (*is_sensitive_thread_hook)()) {

+ lock_profiling_threshold_ = lock_profiling_threshold;

+ is_sensitive_thread_hook_ = is_sensitive_thread_hook;

+

+ uint64_t waitStart, waitEnd;

+ uint32_t wait_threshold = lock_profiling_threshold_;

+ const char* current_owner_filename = NULL;

+ uint32_t current_owner_line_number = -1;

+ if (wait_threshold != 0) {

+ waitStart = NanoTime() / 1000;

+ }

+ current_owner_filename = owner_filename_;

+ current_owner_line_number = owner_line_number_;

+ if (wait_threshold != 0) {

+ waitEnd = NanoTime() / 1000;

+ }

+ }

+

+ if (wait_threshold != 0) {

+ uint64_t wait_ms = (waitEnd - waitStart) / 1000;

+ uint32_t sample_percent;

+ if (wait_ms >= wait_threshold) {

+ sample_percent = 100;

+ } else {

+ sample_percent = 100 * wait_ms / wait_threshold;

+ }

+ if (sample_percent != 0 && (static_cast<uint32_t>(rand() % 100) < sample_percent)) {

+ LogContentionEvent(self, wait_ms, sample_percent, current_owner_filename, current_owner_line_number);

+ }

+ if (lock_profiling_threshold_ != 0) {

+ self->GetCurrentLocation(owner_filename_, owner_line_number_);

+ }

+ static bool IsSensitiveThread();

+ static void Init(bool is_verbose, uint32_t lock_profiling_threshold, bool (*is_sensitive_thread_hook)());

+ void LogContentionEvent(Thread* self, uint32_t wait_ms, uint32_t sample_percent, const char* owner_filename, uint32_t owner_line_number);

+

+ static bool (*is_sensitive_thread_hook_)();

+ static uint32_t lock_profiling_threshold_;

+/*

+ * Copyright (C) 2008 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 "monitor.h"

+#include "object.h"

+#include "thread.h"

+

+#include <fcntl.h>

+#include <sys/stat.h>

+#include <sys/types.h>

+

+#include "cutils/log.h"

+

+#define EVENT_LOG_TAG_dvm_lock_sample 20003

+

+namespace art {

+

+static void Set4LE(uint8_t* buf, uint32_t val) {

+ *buf++ = (uint8_t)(val);

+ *buf++ = (uint8_t)(val >> 8);

+ *buf++ = (uint8_t)(val >> 16);

+ *buf = (uint8_t)(val >> 24);

+}

+

+static char* EventLogWriteInt(char* dst, int value) {

+ *dst++ = EVENT_TYPE_INT;

+ Set4LE((uint8_t*) dst, value);

+ return dst + 4;

+}

+

+static char* EventLogWriteString(char* dst, const char* value, size_t len) {

+ *dst++ = EVENT_TYPE_STRING;

+ len = len < 32 ? len : 32;

+ Set4LE((uint8_t*) dst, len);

+ dst += 4;

+ memcpy(dst, value, len);

+ return dst + len;

+}

+

+void Monitor::LogContentionEvent(Thread* self, uint32_t wait_ms, uint32_t sample_percent, const char* owner_filename, uint32_t owner_line_number) {

+ // Emit the event list length, 1 byte.

+ char eventBuffer[174];

+ char* cp = eventBuffer;

+ *cp++ = 9;

+

+ // Emit the process name, <= 37 bytes.

+ int fd = open("/proc/self/cmdline", O_RDONLY);

+ char procName[33];

+ memset(procName, 0, sizeof(procName));

+ read(fd, procName, sizeof(procName) - 1);

+ close(fd);

+ size_t len = strlen(procName);

+ cp = EventLogWriteString(cp, procName, len);

+

+ // Emit the sensitive thread ("main thread") status, 5 bytes.

+ cp = EventLogWriteInt(cp, Monitor::IsSensitiveThread());

+

+ // Emit self thread name string, <= 37 bytes.

+ std::string thread_name(self->GetName()->ToModifiedUtf8());

+ cp = EventLogWriteString(cp, thread_name.c_str(), thread_name.size());

+

+ // Emit the wait time, 5 bytes.

+ cp = EventLogWriteInt(cp, wait_ms);

+

+ // Emit the source code file name, <= 37 bytes.

+ const char* filename;

+ uint32_t line_number;

+ self->GetCurrentLocation(filename, line_number);

+ cp = EventLogWriteString(cp, filename, strlen(filename));

+

+ // Emit the source code line number, 5 bytes.

+ cp = EventLogWriteInt(cp, line_number);

+

+ // Emit the lock owner source code file name, <= 37 bytes.

+ if (owner_filename == NULL) {

+ owner_filename = "";

+ } else if (strcmp(filename, owner_filename) == 0) {

+ // Common case, so save on log space.

+ owner_filename = "-";

+ }

+ cp = EventLogWriteString(cp, owner_filename, strlen(owner_filename));

+

+ // Emit the source code line number, 5 bytes.

+ cp = EventLogWriteInt(cp, owner_line_number);

+

+ // Emit the sample percentage, 5 bytes.

+ cp = EventLogWriteInt(cp, sample_percent);

+

+ CHECK_LE((size_t)(cp - eventBuffer), sizeof(eventBuffer));

+ android_btWriteLog(EVENT_LOG_TAG_dvm_lock_sample, EVENT_TYPE_LIST, eventBuffer, (size_t)(cp - eventBuffer));

+}

+

+} // namespace art

+/*

+ * Copyright (C) 2008 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 "monitor.h"

+

+namespace art {

+

+void Monitor::LogContentionEvent(Thread*, uint32_t, uint32_t, const char*, uint32_t) {

+}

+

+} // namespace art

+ parsed->lock_profiling_threshold_ = 0;

+ parsed->hook_is_sensitive_thread_ = NULL;

+

+ } else if (option.starts_with("-Xlockprofthreshold:")) {

+ parsed->lock_profiling_threshold_ = atoi(option.substr(strlen("-Xlockprofthreshold:")).data());

+ } else if (option == "sensitiveThread") {

+ parsed->hook_is_sensitive_thread_ = reinterpret_cast<bool (*)()>(options[i].second);

+ Monitor::Init(options->IsVerbose("monitor"), options->lock_profiling_threshold_, options->hook_is_sensitive_thread_);

+ uint32_t lock_profiling_threshold_;

+ bool (*hook_is_sensitive_thread_)();

+String* Thread::GetName() const {

+ return (peer_ != NULL) ? reinterpret_cast<String*>(gThread_name->GetObject(peer_)) : NULL;

+}

+

+void Thread::GetCurrentLocation(const char*& source_file, uint32_t& line_number) const {

+ Frame f = top_of_managed_stack_;

+ Method* m = f.GetMethod();

+ // TODO: can this ever happen?

+ if (m->IsCalleeSaveMethod()) {

+ f.Next();

+ m = f.GetMethod();

+ }

+

+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();

+ Class* c = m->GetDeclaringClass();

+ DexCache* dex_cache = c->GetDexCache();

+ const DexFile& dex_file = class_linker->FindDexFile(dex_cache);

+ const DexFile::ClassDef* class_def = dex_file.FindClassDef(c->GetDescriptor()->ToModifiedUtf8());

+

+ source_file = dex_file.dexGetSourceFile(*class_def);

+

+ uint32_t pc = ManglePc(f.GetReturnPC());

+ line_number = dex_file.GetLineNumFromPC(m, m->ToDexPC(pc));

+}

+

+ // Returns the java.lang.Thread's name, or NULL.

+ String* GetName() const;

+

+ // Returns the current method's declaring class' source file and the current line number.

+ void GetCurrentLocation(const char*& source_file, uint32_t& line_number) const;

+