1/* 2** 3** Copyright 2009, The Android Open Source Project 4** 5** Licensed under the Apache License, Version 2.0 (the "License"); 6** you may not use this file except in compliance with the License. 7** You may obtain a copy of the License at 8** 9** http://www.apache.org/licenses/LICENSE-2.0 10** 11** Unless required by applicable law or agreed to in writing, software 12** distributed under the License is distributed on an "AS IS" BASIS, 13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14** See the License for the specific language governing permissions and 15** limitations under the License. 16*/ 17 18#define LOG_TAG "GraphicBufferAllocator" 19#define ATRACE_TAG ATRACE_TAG_GRAPHICS 20 21#include <cutils/log.h> 22 23#include <utils/Singleton.h> 24#include <utils/String8.h> 25#include <utils/Trace.h> 26 27#include <ui/GraphicBufferAllocator.h> 28 29namespace android { 30// --------------------------------------------------------------------------- 31 32ANDROID_SINGLETON_STATIC_INSTANCE( GraphicBufferAllocator ) 33 34Mutex GraphicBufferAllocator::sLock; 35KeyedVector<buffer_handle_t, 36 GraphicBufferAllocator::alloc_rec_t> GraphicBufferAllocator::sAllocList; 37 38GraphicBufferAllocator::GraphicBufferAllocator() 39 : mAllocDev(0) 40{ 41 hw_module_t const* module; 42 int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module); 43 ALOGE_IF(err, "FATAL: can't find the %s module", GRALLOC_HARDWARE_MODULE_ID); 44 if (err == 0) { 45 gralloc_open(module, &mAllocDev); 46 } 47} 48 49GraphicBufferAllocator::~GraphicBufferAllocator() 50{ 51 gralloc_close(mAllocDev); 52} 53 54void GraphicBufferAllocator::dump(String8& result) const 55{ 56 Mutex::Autolock _l(sLock); 57 KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList); 58 size_t total = 0; 59 const size_t SIZE = 4096; 60 char buffer[SIZE]; 61 snprintf(buffer, SIZE, "Allocated buffers:\n"); 62 result.append(buffer); 63 const size_t c = list.size(); 64 for (size_t i=0 ; i<c ; i++) { 65 const alloc_rec_t& rec(list.valueAt(i)); 66 if (rec.size) { 67 snprintf(buffer, SIZE, "%10p: %7.2f KiB | %4u (%4u) x %4u | %8X | 0x%08x\n", 68 list.keyAt(i), rec.size/1024.0f, 69 rec.w, rec.s, rec.h, rec.format, rec.usage); 70 } else { 71 snprintf(buffer, SIZE, "%10p: unknown | %4u (%4u) x %4u | %8X | 0x%08x\n", 72 list.keyAt(i), 73 rec.w, rec.s, rec.h, rec.format, rec.usage); 74 } 75 result.append(buffer); 76 total += rec.size; 77 } 78 snprintf(buffer, SIZE, "Total allocated (estimate): %.2f KB\n", total/1024.0f); 79 result.append(buffer); 80 if (mAllocDev->common.version >= 1 && mAllocDev->dump) { 81 mAllocDev->dump(mAllocDev, buffer, SIZE); 82 result.append(buffer); 83 } 84} 85 86void GraphicBufferAllocator::dumpToSystemLog() 87{ 88 String8 s; 89 GraphicBufferAllocator::getInstance().dump(s); 90 ALOGD("%s", s.string()); 91} 92 93class BufferLiberatorThread : public Thread { 94public: 95 96 static void queueCaptiveBuffer(buffer_handle_t handle) { 97 size_t queueSize; 98 { 99 Mutex::Autolock lock(sMutex); 100 if (sThread == NULL) { 101 sThread = new BufferLiberatorThread; 102 sThread->run("BufferLiberator"); 103 } 104 105 sThread->mQueue.push_back(handle); 106 sThread->mQueuedCondition.signal(); 107 queueSize = sThread->mQueue.size(); 108 } 109 } 110 111 static void waitForLiberation() { 112 Mutex::Autolock lock(sMutex); 113 114 waitForLiberationLocked(); 115 } 116 117 static void maybeWaitForLiberation() { 118 Mutex::Autolock lock(sMutex); 119 if (sThread != NULL) { 120 if (sThread->mQueue.size() > 8) { 121 waitForLiberationLocked(); 122 } 123 } 124 } 125 126private: 127 128 BufferLiberatorThread() {} 129 130 virtual bool threadLoop() { 131 buffer_handle_t handle; 132 { // Scope for mutex 133 Mutex::Autolock lock(sMutex); 134 while (mQueue.isEmpty()) { 135 mQueuedCondition.wait(sMutex); 136 } 137 handle = mQueue[0]; 138 } 139 140 status_t err; 141 GraphicBufferAllocator& gba(GraphicBufferAllocator::get()); 142 { // Scope for tracing 143 ATRACE_NAME("gralloc::free"); 144 err = gba.mAllocDev->free(gba.mAllocDev, handle); 145 } 146 ALOGW_IF(err, "free(...) failed %d (%s)", err, strerror(-err)); 147 148 if (err == NO_ERROR) { 149 Mutex::Autolock _l(GraphicBufferAllocator::sLock); 150 KeyedVector<buffer_handle_t, GraphicBufferAllocator::alloc_rec_t>& 151 list(GraphicBufferAllocator::sAllocList); 152 list.removeItem(handle); 153 } 154 155 { // Scope for mutex 156 Mutex::Autolock lock(sMutex); 157 mQueue.removeAt(0); 158 mFreedCondition.broadcast(); 159 } 160 161 return true; 162 } 163 164 static void waitForLiberationLocked() { 165 if (sThread == NULL) { 166 return; 167 } 168 169 const nsecs_t timeout = 500 * 1000 * 1000; 170 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); 171 nsecs_t timeToStop = now + timeout; 172 while (!sThread->mQueue.isEmpty() && now < timeToStop) { 173 sThread->mFreedCondition.waitRelative(sMutex, timeToStop - now); 174 now = systemTime(SYSTEM_TIME_MONOTONIC); 175 } 176 177 if (!sThread->mQueue.isEmpty()) { 178 ALOGW("waitForLiberationLocked timed out"); 179 } 180 } 181 182 static Mutex sMutex; 183 static sp<BufferLiberatorThread> sThread; 184 Vector<buffer_handle_t> mQueue; 185 Condition mQueuedCondition; 186 Condition mFreedCondition; 187}; 188 189Mutex BufferLiberatorThread::sMutex; 190sp<BufferLiberatorThread> BufferLiberatorThread::sThread; 191 192status_t GraphicBufferAllocator::alloc(uint32_t w, uint32_t h, PixelFormat format, 193 int usage, buffer_handle_t* handle, int32_t* stride) 194{ 195 ATRACE_CALL(); 196 // make sure to not allocate a N x 0 or 0 x N buffer, since this is 197 // allowed from an API stand-point allocate a 1x1 buffer instead. 198 if (!w || !h) 199 w = h = 1; 200 201 // we have a h/w allocator and h/w buffer is requested 202 status_t err; 203 204 // If too many async frees are queued up then wait for some of them to 205 // complete before attempting to allocate more memory. This is exercised 206 // by the android.opengl.cts.GLSurfaceViewTest CTS test. 207 BufferLiberatorThread::maybeWaitForLiberation(); 208 209 err = mAllocDev->alloc(mAllocDev, w, h, format, usage, handle, stride); 210 211 if (err != NO_ERROR) { 212 ALOGW("WOW! gralloc alloc failed, waiting for pending frees!"); 213 BufferLiberatorThread::waitForLiberation(); 214 err = mAllocDev->alloc(mAllocDev, w, h, format, usage, handle, stride); 215 } 216 217 ALOGW_IF(err, "alloc(%u, %u, %d, %08x, ...) failed %d (%s)", 218 w, h, format, usage, err, strerror(-err)); 219 220 if (err == NO_ERROR) { 221 Mutex::Autolock _l(sLock); 222 KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList); 223 int bpp = bytesPerPixel(format); 224 if (bpp < 0) { 225 // probably a HAL custom format. in any case, we don't know 226 // what its pixel size is. 227 bpp = 0; 228 } 229 alloc_rec_t rec; 230 rec.w = w; 231 rec.h = h; 232 rec.s = *stride; 233 rec.format = format; 234 rec.usage = usage; 235 rec.size = h * stride[0] * bpp; 236 list.add(*handle, rec); 237 } 238 239 return err; 240} 241 242 243status_t GraphicBufferAllocator::free(buffer_handle_t handle) 244{ 245 BufferLiberatorThread::queueCaptiveBuffer(handle); 246 return NO_ERROR; 247} 248 249// --------------------------------------------------------------------------- 250}; // namespace android 251