tools/aapt/WorkQueue.cpp

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // #define LOG_NDEBUG 0
  18 #define LOG_TAG "WorkQueue"
  19
  20 #include <utils/Log.h>
  21 #include "WorkQueue.h"
  22
  23 namespace android {
  24
  25 // --- WorkQueue ---
  26
  27 WorkQueue::WorkQueue(size_t maxThreads, bool canCallJava) :
  28         mMaxThreads(maxThreads), mCanCallJava(canCallJava),
  29         mCanceled(false), mFinished(false), mIdleThreads(0) {
  30 }
  31
  32 WorkQueue::~WorkQueue() {
  33     if (!cancel()) {
  34         finish();
  35     }
  36 }
  37
  38 status_t WorkQueue::schedule(WorkUnit* workUnit, size_t backlog) {
  39     AutoMutex _l(mLock);
  40
  41     if (mFinished || mCanceled) {
  42         return INVALID_OPERATION;
  43     }
  44
  45     if (mWorkThreads.size() < mMaxThreads
  46             && mIdleThreads < mWorkUnits.size() + 1) {
  47         sp<WorkThread> workThread = new WorkThread(this, mCanCallJava);
  48         status_t status = workThread->run("WorkQueue::WorkThread");
  49         if (status) {
  50             return status;
  51         }
  52         mWorkThreads.add(workThread);
  53         mIdleThreads += 1;
  54     } else if (backlog) {
  55         while (mWorkUnits.size() >= mMaxThreads * backlog) {
  56             mWorkDequeuedCondition.wait(mLock);
  57             if (mFinished || mCanceled) {
  58                 return INVALID_OPERATION;
  59             }
  60         }
  61     }
  62
  63     mWorkUnits.add(workUnit);
  64     mWorkChangedCondition.broadcast();
  65     return OK;
  66 }
  67
  68 status_t WorkQueue::cancel() {
  69     AutoMutex _l(mLock);
  70
  71     return cancelLocked();
  72 }
  73
  74 status_t WorkQueue::cancelLocked() {
  75     if (mFinished) {
  76         return INVALID_OPERATION;
  77     }
  78
  79     if (!mCanceled) {
  80         mCanceled = true;
  81
  82         size_t count = mWorkUnits.size();
  83         for (size_t i = 0; i < count; i++) {
  84             delete mWorkUnits.itemAt(i);
  85         }
  86         mWorkUnits.clear();
  87         mWorkChangedCondition.broadcast();
  88         mWorkDequeuedCondition.broadcast();
  89     }
  90     return OK;
  91 }
  92
  93 status_t WorkQueue::finish() {
  94     { // acquire lock
  95         AutoMutex _l(mLock);
  96
  97         if (mFinished) {
  98             return INVALID_OPERATION;
  99         }
 100
 101         mFinished = true;
 102         mWorkChangedCondition.broadcast();
 103     } // release lock
 104
 105     // It is not possible for the list of work threads to change once the mFinished
 106     // flag has been set, so we can access mWorkThreads outside of the lock here.
 107     size_t count = mWorkThreads.size();
 108     for (size_t i = 0; i < count; i++) {
 109         mWorkThreads.itemAt(i)->join();
 110     }
 111     mWorkThreads.clear();
 112     return OK;
 113 }
 114
 115 bool WorkQueue::threadLoop() {
 116     WorkUnit* workUnit;
 117     { // acquire lock
 118         AutoMutex _l(mLock);
 119
 120         for (;;) {
 121             if (mCanceled) {
 122                 return false;
 123             }
 124
 125             if (!mWorkUnits.isEmpty()) {
 126                 workUnit = mWorkUnits.itemAt(0);
 127                 mWorkUnits.removeAt(0);
 128                 mIdleThreads -= 1;
 129                 mWorkDequeuedCondition.broadcast();
 130                 break;
 131             }
 132
 133             if (mFinished) {
 134                 return false;
 135             }
 136
 137             mWorkChangedCondition.wait(mLock);
 138         }
 139     } // release lock
 140
 141     bool shouldContinue = workUnit->run();
 142     delete workUnit;
 143
 144     { // acquire lock
 145         AutoMutex _l(mLock);
 146
 147         mIdleThreads += 1;
 148
 149         if (!shouldContinue) {
 150             cancelLocked();
 151             return false;
 152         }
 153     } // release lock
 154
 155     return true;
 156 }
 157
 158 // --- WorkQueue::WorkThread ---
 159
 160 WorkQueue::WorkThread::WorkThread(WorkQueue* workQueue, bool canCallJava) :
 161         Thread(canCallJava), mWorkQueue(workQueue) {
 162 }
 163
 164 WorkQueue::WorkThread::~WorkThread() {
 165 }
 166
 167 bool WorkQueue::WorkThread::threadLoop() {
 168     return mWorkQueue->threadLoop();
 169 }
 170
 171 };  // namespace android