drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Don't process UEvents in Dalvik unless they match a pattern.

Browse Source 
On some devices, vsync is delivered from the kernel to userspace
over a netlink socket via UEvent.  The result is that a thread wakes
up, reads a message, creates a new String then searches it for matches
against a pattern on every single frame.

Reduce the overhead by performing the initial pattern matching in
native code.

Bug: 7326329
Change-Id: Icb22db1c38330694207bec1153840e0c06f502d6
This commit is contained in:
Jeff Brown
2012-10-10 17:17:58 -07:00
parent 3c584f20ac
commit 9cf36b7a77
2 changed files with 112 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
core/java/android/os/UEventObserver.java
View File

@ -16,6 +16,8 @@
package android.os;
import android.util.Log;
import java.util.ArrayList;
import java.util.HashMap;
@ -37,14 +39,20 @@ import java.util.HashMap;
* @hide
*/
public abstract class UEventObserver {
private static final String TAG = "UEventObserver";
private static final boolean DEBUG = false;
private static UEventThread sThread;
private static native void native_setup();
private static native int next_event(byte[] buffer);
private static native void nativeSetup();
private static native String nativeWaitForNextEvent();
private static native void nativeAddMatch(String match);
private static native void nativeRemoveMatch(String match);
public UEventObserver() {
}
@Override
protected void finalize() throws Throwable {
try {
stopObserving();
@ -78,10 +86,18 @@ public abstract class UEventObserver {
* This method can be called multiple times to register multiple matches.
* Only one call to stopObserving is required even with multiple registered
* matches.
* @param match A substring of the UEvent to match. Use "" to match all
* UEvent's
*
* @param match A substring of the UEvent to match. Try to be as specific
* as possible to avoid incurring unintended additional cost from processing
* irrelevant messages. Netlink messages can be moderately high bandwidth and
* are expensive to parse. For example, some devices may send one netlink message
* for each vsync period.
*/
public final void startObserving(String match) {
if (match == null || match.isEmpty()) {
throw new IllegalArgumentException("match substring must be non-empty");
}
final UEventThread t = getThread();
t.addObserver(match, this);
}
@ -117,7 +133,7 @@ public abstract class UEventObserver {
while (offset < length) {
int equals = message.indexOf('=', offset);
int at = message.indexOf(0, offset);
int at = message.indexOf('\0', offset);
if (at < 0) break;
if (equals > offset && equals < at) {
@ -158,15 +174,17 @@ public abstract class UEventObserver {
super("UEventObserver");
}
@Override
public void run() {
native_setup();
nativeSetup();
byte[] buffer = new byte[1024];
int len;
while (true) {
len = next_event(buffer);
if (len > 0) {
sendEvent(new String(buffer, 0, len));
String message = nativeWaitForNextEvent();
if (message != null) {
if (DEBUG) {
Log.d(TAG, message);
}
sendEvent(message);
}
}
}
@ -176,7 +194,7 @@ public abstract class UEventObserver {
final int N = mKeysAndObservers.size();
for (int i = 0; i < N; i += 2) {
final String key = (String)mKeysAndObservers.get(i);
if (message.indexOf(key) != -1) {
if (message.contains(key)) {
final UEventObserver observer =
(UEventObserver)mKeysAndObservers.get(i + 1);
mTempObserversToSignal.add(observer);
@ -199,6 +217,7 @@ public abstract class UEventObserver {
synchronized (mKeysAndObservers) {
mKeysAndObservers.add(match);
mKeysAndObservers.add(observer);
nativeAddMatch(match);
}
}
@ -208,7 +227,8 @@ public abstract class UEventObserver {
for (int i = 0; i < mKeysAndObservers.size(); ) {
if (mKeysAndObservers.get(i + 1) == observer) {
mKeysAndObservers.remove(i + 1);
mKeysAndObservers.remove(i);
final String match = (String)mKeysAndObservers.remove(i);
nativeRemoveMatch(match);
} else {
i += 2;
}

96
core/jni/android_os_UEventObserver.cpp
View File

@ -15,6 +15,8 @@
*/
#define LOG_TAG "UEventObserver"
//#define LOG_NDEBUG 0
#include "utils/Log.h"
#include "hardware_legacy/uevent.h"
@ -22,34 +24,94 @@
#include "JNIHelp.h"
#include "android_runtime/AndroidRuntime.h"
namespace android
{
#include <utils/Mutex.h>
#include <utils/Vector.h>
#include <utils/String8.h>
#include <ScopedUtfChars.h>
static void
android_os_UEventObserver_native_setup(JNIEnv *env, jclass clazz)
{
namespace android {
static Mutex gMatchesMutex;
static Vector<String8> gMatches;
static void nativeSetup(JNIEnv *env, jclass clazz) {
if (!uevent_init()) {
jniThrowException(env, "java/lang/RuntimeException",
"Unable to open socket for UEventObserver");
"Unable to open socket for UEventObserver");
}
}
static int
android_os_UEventObserver_next_event(JNIEnv *env, jclass clazz, jbyteArray jbuffer)
{
int buf_sz = env->GetArrayLength(jbuffer);
char *buffer = (char*)env->GetByteArrayElements(jbuffer, NULL);
static bool isMatch(const char* buffer, size_t length) {
AutoMutex _l(gMatchesMutex);
int length = uevent_next_event(buffer, buf_sz - 1);
for (size_t i = 0; i < gMatches.size(); i++) {
const String8& match = gMatches.itemAt(i);
env->ReleaseByteArrayElements(jbuffer, (jbyte*)buffer, 0);
// Consider all zero-delimited fields of the buffer.
const char* field = buffer;
const char* end = buffer + length;
do {
if (strstr(field, match.string())) {
ALOGV("Matched uevent message with pattern: %s", match.string());
return true;
}
field += strlen(field) + 1;
} while (field != end);
}
return false;
}
return length;
static jstring nativeWaitForNextEvent(JNIEnv *env, jclass clazz) {
char buffer[1024];
for (;;) {
int length = uevent_next_event(buffer, sizeof(buffer) - 1);
if (length <= 0) {
return NULL;
}
buffer[length] = '\0';
ALOGV("Received uevent message: %s", buffer);
if (isMatch(buffer, length)) {
// Assume the message is ASCII.
jchar message[length];
for (int i = 0; i < length; i++) {
message[i] = buffer[i];
}
return env->NewString(message, length);
}
}
}
static void nativeAddMatch(JNIEnv* env, jclass clazz, jstring matchStr) {
ScopedUtfChars match(env, matchStr);
AutoMutex _l(gMatchesMutex);
gMatches.add(String8(match.c_str()));
}
static void nativeRemoveMatch(JNIEnv* env, jclass clazz, jstring matchStr) {
ScopedUtfChars match(env, matchStr);
AutoMutex _l(gMatchesMutex);
for (size_t i = 0; i < gMatches.size(); i++) {
if (gMatches.itemAt(i) == match.c_str()) {
gMatches.removeAt(i);
break; // only remove first occurrence
}
}
}
static JNINativeMethod gMethods[] = {
{"native_setup", "()V", (void *)android_os_UEventObserver_native_setup},
{"next_event", "([B)I", (void *)android_os_UEventObserver_next_event},
{ "nativeSetup", "()V",
(void *)nativeSetup },
{ "nativeWaitForNextEvent", "()Ljava/lang/String;",
(void *)nativeWaitForNextEvent },
{ "nativeAddMatch", "(Ljava/lang/String;)V",
(void *)nativeAddMatch },
{ "nativeRemoveMatch", "(Ljava/lang/String;)V",
(void *)nativeRemoveMatch },
};
@ -64,7 +126,7 @@ int register_android_os_UEventObserver(JNIEnv *env)
}
return AndroidRuntime::registerNativeMethods(env,
"android/os/UEventObserver", gMethods, NELEM(gMethods));
"android/os/UEventObserver", gMethods, NELEM(gMethods));
}
} // namespace android