Attribute wakelocks held by RIL to clients (1b907992) · Commits · e / os / android_frameworks_opt_telephony

src/java/com/android/internal/telephony/ClientWakelockAccountant.java

0 → 100644

+133 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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.
		*/

		package com.android.internal.telephony;

		import android.telephony.ClientRequestStats;
		import android.telephony.Rlog;

		import com.android.internal.annotations.VisibleForTesting;
		import java.util.ArrayList;

		public class ClientWakelockAccountant {
		public static final String LOG_TAG = "ClientWakelockAccountant: ";

		@VisibleForTesting
		public ClientRequestStats mRequestStats = new ClientRequestStats();
		@VisibleForTesting
		public ArrayList<RilWakelockInfo> mPendingRilWakelocks = new ArrayList<>();

		@VisibleForTesting
		public ClientWakelockAccountant(String callingPackage) {
		mRequestStats.setCallingPackage(callingPackage);
		}

		@VisibleForTesting
		public void startAttributingWakelock(int request,
		int token, int concurrentRequests, long time) {

		RilWakelockInfo wlInfo = new RilWakelockInfo(request, token, concurrentRequests, time);
		synchronized (mPendingRilWakelocks) {
		mPendingRilWakelocks.add(wlInfo);
		}
		}

		@VisibleForTesting
		public void stopAttributingWakelock(int request, int token, long time) {
		RilWakelockInfo wlInfo = removePendingWakelock(request, token);
		if (wlInfo != null) {
		completeRequest(wlInfo, time);
		}
		}

		@VisibleForTesting
		public void stopAllPendingRequests(long time) {
		synchronized (mPendingRilWakelocks) {
		for (RilWakelockInfo wlInfo : mPendingRilWakelocks) {
		completeRequest(wlInfo, time);
		}
		mPendingRilWakelocks.clear();
		}
		}

		@VisibleForTesting
		public void changeConcurrentRequests(int concurrentRequests, long time) {
		synchronized (mPendingRilWakelocks) {
		for (RilWakelockInfo wlInfo : mPendingRilWakelocks) {
		wlInfo.updateConcurrentRequests(concurrentRequests, time);
		}
		}
		}

		private void completeRequest(RilWakelockInfo wlInfo, long time) {
		wlInfo.setResponseTime(time);
		synchronized (mRequestStats) {
		mRequestStats.addCompletedWakelockTime(wlInfo.getWakelockTimeAttributedToClient());
		mRequestStats.incrementCompletedRequestsCount();
		mRequestStats.updateRequestHistograms(wlInfo.getRilRequestSent(),
		(int) wlInfo.getWakelockTimeAttributedToClient());
		}
		}

		@VisibleForTesting
		public int getPendingRequestCount() {
		return mPendingRilWakelocks.size();
		}

		@VisibleForTesting
		public synchronized long updatePendingRequestWakelockTime(long uptime) {
		long totalPendingWakelockTime = 0;
		synchronized (mPendingRilWakelocks) {
		for (RilWakelockInfo wlInfo : mPendingRilWakelocks) {
		wlInfo.updateTime(uptime);
		totalPendingWakelockTime += wlInfo.getWakelockTimeAttributedToClient();
		}
		}
		synchronized (mRequestStats) {
		mRequestStats.setPendingRequestsCount(getPendingRequestCount());
		mRequestStats.setPendingRequestsWakelockTime(totalPendingWakelockTime);
		}
		return totalPendingWakelockTime;
		}

		private RilWakelockInfo removePendingWakelock(int request, int token) {
		RilWakelockInfo result = null;
		synchronized (mPendingRilWakelocks) {
		for (RilWakelockInfo wlInfo : mPendingRilWakelocks) {
		if ((wlInfo.getTokenNumber() == token) &&
		(wlInfo.getRilRequestSent() == request)) {
		result = wlInfo;
		}
		}
		if( result != null ) {
		mPendingRilWakelocks.remove(result);
		}
		}
		if(result == null) {
		Rlog.w(LOG_TAG, "Looking for Request<" + request + "," + token + "> in "
		+ mPendingRilWakelocks);
		}
		return result;
		}

		@Override
		public String toString() {
		return "ClientWakelockAccountant{" +
		"mRequestStats=" + mRequestStats +
		", mPendingRilWakelocks=" + mPendingRilWakelocks +
		'}';
		}
		}

src/java/com/android/internal/telephony/ClientWakelockTracker.java

0 → 100644

+120 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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
		*/

		package com.android.internal.telephony;

		import android.os.SystemClock;
		import android.telephony.ClientRequestStats;
		import android.telephony.Rlog;

		import com.android.internal.annotations.VisibleForTesting;

		import java.util.ArrayList;
		import java.util.HashMap;
		import java.util.List;

		public class ClientWakelockTracker {
		public static final String LOG_TAG = "ClientWakelockTracker";
		@VisibleForTesting
		public HashMap<String, ClientWakelockAccountant> mClients =
		new HashMap<String, ClientWakelockAccountant>();
		@VisibleForTesting
		public ArrayList<ClientWakelockAccountant> mActiveClients = new ArrayList<>();

		@VisibleForTesting
		public void startTracking(String clientId, int requestId, int token, int numRequestsInQueue) {
		ClientWakelockAccountant client = getClientWakelockAccountant(clientId);
		long uptime = SystemClock.uptimeMillis();
		client.startAttributingWakelock(requestId, token, numRequestsInQueue, uptime);
		updateConcurrentRequests(numRequestsInQueue, uptime);
		synchronized (mActiveClients) {
		if (!mActiveClients.contains(client)) {
		mActiveClients.add(client);
		}
		}
		}

		@VisibleForTesting
		public void stopTracking(String clientId, int requestId, int token, int numRequestsInQueue) {
		ClientWakelockAccountant client = getClientWakelockAccountant(clientId);
		long uptime = SystemClock.uptimeMillis();
		client.stopAttributingWakelock(requestId, token, uptime);
		if(client.getPendingRequestCount() == 0) {
		synchronized (mActiveClients) {
		mActiveClients.remove(client);
		}
		}
		updateConcurrentRequests(numRequestsInQueue, uptime);
		}

		@VisibleForTesting
		public void stopTrackingAll() {
		long uptime = SystemClock.uptimeMillis();
		synchronized (mActiveClients) {
		for (ClientWakelockAccountant client : mActiveClients) {
		client.stopAllPendingRequests(uptime);
		}
		mActiveClients.clear();
		}
		}

		List<ClientRequestStats> getClientRequestStats() {
		List<ClientRequestStats> list;
		long uptime = SystemClock.uptimeMillis();
		synchronized (mClients) {
		list = new ArrayList<>(mClients.size());
		for (String key : mClients.keySet()) {
		ClientWakelockAccountant client = mClients.get(key);
		client.updatePendingRequestWakelockTime(uptime);
		list.add(new ClientRequestStats(client.mRequestStats));
		}
		}
		return list;
		}

		private ClientWakelockAccountant getClientWakelockAccountant(String clientId) {
		ClientWakelockAccountant client;
		synchronized (mClients) {
		if (mClients.containsKey(clientId)) {
		client = mClients.get(clientId);
		} else {
		client = new ClientWakelockAccountant(clientId);
		mClients.put(clientId, client);
		}
		}
		return client;
		}

		private void updateConcurrentRequests(int numRequestsInQueue, long time) {
		if(numRequestsInQueue != 0) {
		synchronized (mActiveClients) {
		for (ClientWakelockAccountant cI : mActiveClients) {
		cI.changeConcurrentRequests(numRequestsInQueue, time);
		}
		}
		}
		}

		void dumpClientRequestTracker() {
		Rlog.d(RIL.RILJ_LOG_TAG, "-------mClients---------------");
		synchronized (mClients) {
		for (String key : mClients.keySet()) {
		Rlog.d(RIL.RILJ_LOG_TAG, "Client : " + key);
		Rlog.d(RIL.RILJ_LOG_TAG, mClients.get(key).toString());
		}
		}
		}
		}
		No newline at end of file

src/java/com/android/internal/telephony/RIL.java

+30 −12

Original line number	Diff line number	Diff line
		@@ -18,13 +18,8 @@ package com.android.internal.telephony;

		import static com.android.internal.telephony.RILConstants.*;
		import static android.telephony.TelephonyManager.NETWORK_TYPE_UNKNOWN;
		import static android.telephony.TelephonyManager.NETWORK_TYPE_EDGE;
		import static android.telephony.TelephonyManager.NETWORK_TYPE_GPRS;
		import static android.telephony.TelephonyManager.NETWORK_TYPE_UMTS;
		import static android.telephony.TelephonyManager.NETWORK_TYPE_HSDPA;
		import static android.telephony.TelephonyManager.NETWORK_TYPE_HSUPA;
		import static android.telephony.TelephonyManager.NETWORK_TYPE_HSPA;

		import android.app.ActivityThread;
		import android.content.BroadcastReceiver;
		import android.content.Context;
		import android.content.Intent;
		@@ -44,7 +39,6 @@ import android.os.BatteryManager;
		import android.os.SystemProperties;
		import android.os.PowerManager.WakeLock;
		import android.os.SystemClock;
		import android.provider.Settings.SettingNotFoundException;
		import android.service.carrier.CarrierIdentifier;
		import android.telephony.CellInfo;
		import android.telephony.NeighboringCellInfo;
		@@ -77,9 +71,6 @@ import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
		import com.android.internal.telephony.dataconnection.DcFailCause;
		import com.android.internal.telephony.dataconnection.DataCallResponse;
		import com.android.internal.telephony.dataconnection.DataProfile;
		import com.android.internal.telephony.RadioCapability;
		import com.android.internal.telephony.TelephonyDevController;
		import com.android.internal.telephony.HardwareConfig;

		import java.io.ByteArrayInputStream;
		import java.io.DataInputStream;
		@@ -93,7 +84,6 @@ import java.util.Collections;
		import java.util.List;
		import java.util.concurrent.atomic.AtomicBoolean;
		import java.util.concurrent.atomic.AtomicInteger;
		import java.util.List;
		import java.util.Random;

		/**
		@@ -110,7 +100,6 @@ class RILRequest {
		private static RILRequest sPool = null;
		private static int sPoolSize = 0;
		private static final int MAX_POOL_SIZE = 4;
		private Context mContext;

		//***** Instance Variables
		int mSerial;
		@@ -119,6 +108,7 @@ class RILRequest {
		Parcel mParcel;
		RILRequest mNext;
		int mWakeLockType;
		String mClientId;
		// time in ms when RIL request was made
		long mStartTimeMs;

		@@ -152,6 +142,7 @@ class RILRequest {
		rr.mParcel = Parcel.obtain();

		rr.mWakeLockType = RIL.INVALID_WAKELOCK;
		rr.mClientId = ActivityThread.currentOpPackageName();
		rr.mStartTimeMs = SystemClock.elapsedRealtime();
		if (result != null && result.getTarget() == null) {
		throw new NullPointerException("Message target must not be null");
		@@ -164,6 +155,26 @@ class RILRequest {
		return rr;
		}


		/**
		* Retrieves a new RILRequest instance from the pool and sets the clientId
		*
		* @param request RIL_REQUEST_*
		* @param result sent when operation completes
		* @param clientId Id to track the client which initiated this request
		* @return a RILRequest instance from the pool.
		*/
		static RILRequest obtain(int request, Message result, String clientId) {
		RILRequest rr = null;

		rr = obtain(request, result);
		if(clientId != null) {
		rr.mClientId = clientId;
		}

		return rr;
		}

		/**
		* Returns a RILRequest instance to the pool.
		*
		@@ -272,6 +283,7 @@ public final class RIL extends BaseCommands implements CommandsInterface {
		public static final int INVALID_WAKELOCK = -1;
		public static final int FOR_WAKELOCK = 0;
		public static final int FOR_ACK_WAKELOCK = 1;
		private final ClientWakelockTracker mClientWakelockTracker = new ClientWakelockTracker();

		//***** Instance Variables

		@@ -2483,6 +2495,8 @@ public final class RIL extends BaseCommands implements CommandsInterface {
		mWakeLock.acquire();
		mWakeLockCount++;
		mWlSequenceNum++;
		mClientWakelockTracker.startTracking(rr.mClientId,
		rr.mRequest, rr.mSerial, mWakeLockCount);

		Message msg = mSender.obtainMessage(EVENT_WAKE_LOCK_TIMEOUT);
		msg.arg1 = mWlSequenceNum;
		@@ -2519,6 +2533,8 @@ public final class RIL extends BaseCommands implements CommandsInterface {
		mWakeLockCount = 0;
		mWakeLock.release();
		}
		mClientWakelockTracker.stopTracking(rr.mClientId,
		rr.mRequest, rr.mSerial, mWakeLockCount);
		}
		break;
		case FOR_ACK_WAKELOCK:
		@@ -2542,6 +2558,7 @@ public final class RIL extends BaseCommands implements CommandsInterface {
		+ "at time of clearing");
		mWakeLockCount = 0;
		mWakeLock.release();
		mClientWakelockTracker.stopTrackingAll();
		return true;
		}
		} else {
		@@ -4961,6 +4978,7 @@ public final class RIL extends BaseCommands implements CommandsInterface {
		}
		pw.println(" mLastNITZTimeInfo=" + Arrays.toString(mLastNITZTimeInfo));
		pw.println(" mTestingEmergencyCall=" + mTestingEmergencyCall.get());
		mClientWakelockTracker.dumpClientRequestTracker();
		}

		/**

src/java/com/android/internal/telephony/RilWakelockInfo.java

0 → 100644

+109 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2006 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.
		*/

		package com.android.internal.telephony;

		import android.annotation.TargetApi;
		import android.os.Build;
		import android.util.Log;
		import com.android.internal.annotations.VisibleForTesting;

		@TargetApi(8)
		public class RilWakelockInfo {
		private final String LOG_TAG = RilWakelockInfo.class.getSimpleName();
		private int mRilRequestSent;
		private int mTokenNumber;
		private long mRequestTime;
		private long mResponseTime;

		/* If there are n requests waiting for a response for time t, the time attributed to
		each request will be t/n. If the number of outstanding requests changes at time t1,
		then we will compute the wakelock time till t1 and store it in mWakelockTimeAttributedSoFar
		and update mConcurrentRequests. mLastAggregatedTime will be set to t1 and used to
		compute the time taken for this request using the new mConcurrentRequests
		*/
		private long mWakelockTimeAttributedSoFar;
		private long mLastAggregatedTime;
		private int mConcurrentRequests;

		@VisibleForTesting
		public int getConcurrentRequests() {
		return mConcurrentRequests;
		}

		RilWakelockInfo(int rilRequest, int tokenNumber, int concurrentRequests, long requestTime) {
		concurrentRequests = validateConcurrentRequests(concurrentRequests);
		this.mRilRequestSent = rilRequest;
		this.mTokenNumber = tokenNumber;
		this.mConcurrentRequests = concurrentRequests;
		this.mRequestTime = requestTime;
		this.mWakelockTimeAttributedSoFar = 0;
		this.mLastAggregatedTime = requestTime;
		}

		private int validateConcurrentRequests(int concurrentRequests) {
		if(concurrentRequests <= 0) {
		if(Build.IS_DEBUGGABLE) {
		IllegalArgumentException e = new IllegalArgumentException(
		"concurrentRequests should always be greater than 0.");
		Log.wtf(LOG_TAG, e);
		throw e;
		} else {
		concurrentRequests = 1;
		}
		}
		return concurrentRequests;
		}

		int getTokenNumber() {
		return mTokenNumber;
		}

		int getRilRequestSent() {
		return mRilRequestSent;
		}

		void setResponseTime(long responseTime) {
		updateTime(responseTime);
		this.mResponseTime = responseTime;
		}

		void updateConcurrentRequests(int concurrentRequests, long time) {
		concurrentRequests = validateConcurrentRequests(concurrentRequests);
		updateTime(time);
		mConcurrentRequests = concurrentRequests;
		}

		synchronized void updateTime(long time) {
		mWakelockTimeAttributedSoFar += (time - mLastAggregatedTime) / mConcurrentRequests;
		mLastAggregatedTime = time;
		}

		long getWakelockTimeAttributedToClient() {
		return mWakelockTimeAttributedSoFar;
		}

		@Override
		public String toString() {
		return "WakelockInfo{" +
		"rilRequestSent=" + mRilRequestSent +
		", tokenNumber=" + mTokenNumber +
		", requestTime=" + mRequestTime +
		", responseTime=" + mResponseTime +
		", mWakelockTimeAttributed=" + mWakelockTimeAttributedSoFar +
		'}';
		}
		}

tests/telephonytests/src/com/android/internal/telephony/ClientWakelockAccountantTest.java

0 → 100644

+101 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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
		*/

		package com.android.internal.telephony;

		import static com.android.internal.telephony.TelephonyTestUtils.waitForMs;

		import android.test.TestRunner;
		import android.os.Build;
		import android.util.Log;
		import android.telephony.Rlog;
		import android.telephony.TelephonyHistogram;

		import junit.framework.Assert;
		import junit.framework.TestCase;

		public class ClientWakelockAccountantTest extends TestCase {
		private final static String LOG_TAG = "ClientWakelockAccountantTest";
		ClientWakelockAccountant mClient;

		@Override
		public void setUp() throws Exception {
		super.setUp();
		mClient = new ClientWakelockAccountant("Package Name");
		}

		@Override
		public void tearDown() throws Exception {
		super.tearDown();
		}

		public void testStartAttributingWakelock() throws Exception {

		Assert.assertEquals(0, mClient.getPendingRequestCount());
		mClient.startAttributingWakelock(15, 25, 1, 100);
		Assert.assertEquals(1, mClient.getPendingRequestCount());
		mClient.startAttributingWakelock(22, 26, 2, 150);
		Assert.assertEquals(2, mClient.getPendingRequestCount());
		}

		/* This test only tests ClientWakelockAccountant to make sure that it applies the
		multiplier as expected. Here we start 1 Client and add 2 requests.
		First request multiplier stays at 1 and goes on for 200ms and second request
		multiplier stays at 0.5 and request goes on for 500ms. So totally we
		expect the wakelock time for the Client to be 2001 + 5000.5 = 450ms
		*/
		public void testStopAttributingWakelock() throws Exception {
		mClient.startAttributingWakelock(15, 25, 1, 100);
		mClient.startAttributingWakelock(25, 26, 2, 200);
		mClient.changeConcurrentRequests(2, 200);
		Assert.assertEquals(2, mClient.getPendingRequestCount());
		Assert.assertEquals(0, mClient.mRequestStats.getCompletedRequestsCount());
		mClient.stopAttributingWakelock(15, 25, 300);
		mClient.changeConcurrentRequests(1, 300);
		Assert.assertEquals(1, mClient.mRequestStats.getRequestHistograms().size());
		mClient.stopAttributingWakelock(25, 26, 700);
		Assert.assertEquals(0, mClient.getPendingRequestCount());
		Assert.assertEquals(2, mClient.mRequestStats.getCompletedRequestsCount());
		Assert.assertEquals(600, mClient.mRequestStats.getCompletedRequestsWakelockTime());
		Assert.assertEquals(0, mClient.updatePendingRequestWakelockTime(0));
		Assert.assertEquals(2, mClient.mRequestStats.getRequestHistograms().size());
		}

		public void testStopAllPendingRequests() throws Exception {

		mClient.startAttributingWakelock(15, 25, 1, 100);
		mClient.startAttributingWakelock(22, 26, 2, 150);
		Assert.assertEquals(2, mClient.getPendingRequestCount());
		mClient.stopAllPendingRequests(300);
		Assert.assertEquals(0, mClient.getPendingRequestCount());
		Assert.assertEquals(2, mClient.mRequestStats.getCompletedRequestsCount());
		Assert.assertEquals(275, mClient.mRequestStats.getCompletedRequestsWakelockTime());
		Assert.assertEquals(0, mClient.updatePendingRequestWakelockTime(0));
		Assert.assertEquals(2, mClient.mRequestStats.getRequestHistograms().size());
		}

		public void testStartAttributingWithZeroConcurrentRequests() throws Exception {
		if(Build.IS_DEBUGGABLE) {
		try {
		mClient.startAttributingWakelock(15, 25, 0, 100);
		fail("Expecting an illegal argument Exception to be thrown");
		} catch (IllegalArgumentException e) { }
		} else {
		mClient.startAttributingWakelock(15, 25, 0, 100);
		Assert.assertEquals(1, mClient.getPendingRequestCount());
		}
		}
		}