Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Simpler way to deal with the FBO multi-cache."

Browse Source
This commit is contained in:
Romain Guy
2010-07-07 15:18:33 -07:00
committed by Android (Google) Code Review
parent 182b96618b 6c81893c62
commit 290357aca8
10 changed files with 33 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
libs/hwui/Android.mk
View File

@@ -6,7 +6,6 @@ LOCAL_SRC_FILES:= \
Matrix.cpp \
OpenGLRenderer.cpp \
Program.cpp \
SortedList.cpp \
TextureCache.cpp
LOCAL_C_INCLUDES += \
@@ -20,7 +19,7 @@ LOCAL_C_INCLUDES += \
LOCAL_MODULE_CLASS := SHARED_LIBRARIES
LOCAL_SHARED_LIBRARIES := libcutils libutils libGLESv2 libskia
LOCAL_MODULE:= libhwui
LOCAL_MODULE := libhwui
LOCAL_PRELINK_MODULE := false
include $(BUILD_SHARED_LIBRARY)

118
libs/hwui/GenerationCache.h
View File

@@ -20,68 +20,9 @@
#include <utils/KeyedVector.h>
#include <utils/RefBase.h>
#include "SortedList.h"
namespace android {
namespace uirenderer {
template<typename K, typename V>
class GenerationCacheStorage {
public:
virtual ~GenerationCacheStorage();
virtual size_t size() const = 0;
virtual void clear() = 0;
virtual ssize_t add(const K& key, const V& item) = 0;
virtual ssize_t indexOfKey(const K& key) const = 0;
virtual const V& valueAt(size_t index) const = 0;
virtual ssize_t removeItemsAt(size_t index, size_t count) = 0;
}; // GenerationCacheStorage
template<typename K, typename V>
GenerationCacheStorage<K, V>::~GenerationCacheStorage() {
}
template<typename K, typename V>
class KeyedVectorStorage: public GenerationCacheStorage<K, V> {
public:
KeyedVectorStorage() { }
~KeyedVectorStorage() { }
inline size_t size() const { return mStorage.size(); }
inline void clear() { mStorage.clear(); }
inline ssize_t add(const K& key, const V& value) { return mStorage.add(key, value); }
inline ssize_t indexOfKey(const K& key) const { return mStorage.indexOfKey(key); }
inline const V& valueAt(size_t index) const { return mStorage.valueAt(index); }
inline ssize_t removeItemsAt(size_t index, size_t count) {
return mStorage.removeItemsAt(index, count);
}
private:
KeyedVector<K, V> mStorage;
}; // class KeyedVectorStorage
template<typename K, typename V>
class SortedListStorage: public GenerationCacheStorage<K, V> {
public:
SortedListStorage() { }
~SortedListStorage() { }
inline size_t size() const { return mStorage.size(); }
inline void clear() { mStorage.clear(); }
inline ssize_t add(const K& key, const V& value) {
return mStorage.add(key_value_pair_t<K, V>(key, value));
}
inline ssize_t indexOfKey(const K& key) const {
return mStorage.indexOf(key_value_pair_t<K, V>(key));
}
inline const V& valueAt(size_t index) const { return mStorage.itemAt(index).value; }
inline ssize_t removeItemsAt(size_t index, size_t count) {
return mStorage.removeItemsAt(index, count);
}
private:
SortedList<key_value_pair_t<K, V> > mStorage;
}; // class SortedListStorage
template<typename EntryKey, typename EntryValue>
class OnEntryRemoved {
public:
@@ -127,17 +68,13 @@ public:
uint32_t size() const;
protected:
virtual GenerationCacheStorage<K, sp<Entry<K, V> > >* createStorage() = 0;
GenerationCacheStorage<K, sp<Entry<K, V> > >* mCache;
private:
void addToCache(sp<Entry<K, V> > entry, K key, V value);
void attachToCache(sp<Entry<K, V> > entry);
void detachFromCache(sp<Entry<K, V> > entry);
V removeAt(ssize_t index);
KeyedVector<K, sp<Entry<K, V> > > mCache;
uint32_t mMaxCapacity;
OnEntryRemoved<K, V>* mListener;
@@ -146,32 +83,6 @@ private:
sp<Entry<K, V> > mYoungest;
}; // class GenerationCache
template<typename K, typename V>
class GenerationSingleCache: public GenerationCache<K, V> {
public:
GenerationSingleCache(uint32_t maxCapacity): GenerationCache<K, V>(maxCapacity) {
GenerationCache<K, V>::mCache = createStorage();
};
~GenerationSingleCache() { }
protected:
GenerationCacheStorage<K, sp<Entry<K, V> > >* createStorage() {
return new KeyedVectorStorage<K, sp<Entry<K, V> > >;
}
}; // GenerationSingleCache
template<typename K, typename V>
class GenerationMultiCache: public GenerationCache<K, V> {
public:
GenerationMultiCache(uint32_t maxCapacity): GenerationCache<K, V>(maxCapacity) {
GenerationCache<K, V>::mCache = createStorage();
};
~GenerationMultiCache() { }
protected:
GenerationCacheStorage<K, sp<Entry<K, V> > >* createStorage() {
return new SortedListStorage<K, sp<Entry<K, V> > >;
}
}; // GenerationMultiCache
template<typename K, typename V>
GenerationCache<K, V>::GenerationCache(uint32_t maxCapacity): mMaxCapacity(maxCapacity), mListener(NULL) {
};
@@ -179,12 +90,11 @@ GenerationCache<K, V>::GenerationCache(uint32_t maxCapacity): mMaxCapacity(maxCa
template<typename K, typename V>
GenerationCache<K, V>::~GenerationCache() {
clear();
delete mCache;
};
template<typename K, typename V>
uint32_t GenerationCache<K, V>::size() const {
return mCache->size();
return mCache.size();
}
template<typename K, typename V>
@@ -195,11 +105,11 @@ void GenerationCache<K, V>::setOnEntryRemovedListener(OnEntryRemoved<K, V>* list
template<typename K, typename V>
void GenerationCache<K, V>::clear() {
if (mListener) {
while (mCache->size() > 0) {
while (mCache.size() > 0) {
removeOldest();
}
} else {
mCache->clear();
mCache.clear();
}
mYoungest.clear();
mOldest.clear();
@@ -207,14 +117,14 @@ void GenerationCache<K, V>::clear() {
template<typename K, typename V>
bool GenerationCache<K, V>::contains(K key) const {
return mCache->indexOfKey(key) >= 0;
return mCache.indexOfKey(key) >= 0;
}
template<typename K, typename V>
V GenerationCache<K, V>::get(K key) {
ssize_t index = mCache->indexOfKey(key);
ssize_t index = mCache.indexOfKey(key);
if (index >= 0) {
sp<Entry<K, V> > entry = mCache->valueAt(index);
sp<Entry<K, V> > entry = mCache.valueAt(index);
if (entry.get()) {
detachFromCache(entry);
attachToCache(entry);
@@ -227,13 +137,13 @@ V GenerationCache<K, V>::get(K key) {
template<typename K, typename V>
void GenerationCache<K, V>::put(K key, V value) {
if (mMaxCapacity != kUnlimitedCapacity && mCache->size() >= mMaxCapacity) {
if (mMaxCapacity != kUnlimitedCapacity && mCache.size() >= mMaxCapacity) {
removeOldest();
}
ssize_t index = mCache->indexOfKey(key);
ssize_t index = mCache.indexOfKey(key);
if (index >= 0) {
sp<Entry<K, V> > entry = mCache->valueAt(index);
sp<Entry<K, V> > entry = mCache.valueAt(index);
detachFromCache(entry);
addToCache(entry, key, value);
} else {
@@ -246,13 +156,13 @@ template<typename K, typename V>
void GenerationCache<K, V>::addToCache(sp<Entry<K, V> > entry, K key, V value) {
entry->key = key;
entry->value = value;
entry->index = mCache->add(key, entry);
entry->index = mCache.add(key, entry);
attachToCache(entry);
}
template<typename K, typename V>
V GenerationCache<K, V>::remove(K key) {
ssize_t index = mCache->indexOfKey(key);
ssize_t index = mCache.indexOfKey(key);
if (index >= 0) {
return removeAt(index);
}
@@ -262,11 +172,11 @@ V GenerationCache<K, V>::remove(K key) {
template<typename K, typename V>
V GenerationCache<K, V>::removeAt(ssize_t index) {
sp<Entry<K, V> > entry = mCache->valueAt(index);
sp<Entry<K, V> > entry = mCache.valueAt(index);
if (mListener) {
(*mListener)(entry->key, entry->value);
}
mCache->removeItemsAt(index, 1);
mCache.removeItemsAt(index, 1);
detachFromCache(entry);
return entry->value;

13
libs/hwui/Layer.h
View File

@@ -30,14 +30,21 @@ namespace uirenderer {
* Dimensions of a layer.
*/
struct LayerSize {
LayerSize(): width(0), height(0) { }
LayerSize(const uint32_t width, const uint32_t height): width(width), height(height) { }
LayerSize(const LayerSize& size): width(size.width), height(size.height) { }
LayerSize(): width(0), height(0), id(0) { }
LayerSize(const uint32_t width, const uint32_t height): width(width), height(height), id(0) { }
LayerSize(const LayerSize& size): width(size.width), height(size.height), id(size.id) { }
uint32_t width;
uint32_t height;
// Incremental id used by the layer cache to store multiple
// LayerSize with the same dimensions
uint32_t id;
bool operator<(const LayerSize& rhs) const {
if (id != 0 && rhs.id != 0) {
return id < rhs.id;
}
if (width == rhs.width) {
return height < rhs.height;
}

5
libs/hwui/LayerCache.cpp
View File

@@ -28,8 +28,8 @@ namespace uirenderer {
///////////////////////////////////////////////////////////////////////////////
LayerCache::LayerCache(uint32_t maxByteSize):
mCache(GenerationMultiCache<LayerSize, Layer*>::kUnlimitedCapacity),
mSize(0), mMaxSize(maxByteSize) {
mCache(GenerationCache<LayerSize, Layer*>::kUnlimitedCapacity),
mIdGenerator(1), mSize(0), mMaxSize(maxByteSize) {
}
LayerCache::~LayerCache() {
@@ -101,6 +101,7 @@ bool LayerCache::put(LayerSize& layerSize, Layer* layer) {
deleteLayer(oldest);
}
layerSize.id = mIdGenerator++;
mCache.put(layerSize, layer);
mSize += size;

3
libs/hwui/LayerCache.h
View File

@@ -66,7 +66,8 @@ public:
private:
void deleteLayer(Layer* layer);
GenerationMultiCache<LayerSize, Layer*> mCache;
GenerationCache<LayerSize, Layer*> mCache;
uint32_t mIdGenerator;
uint32_t mSize;
uint32_t mMaxSize;

2
libs/hwui/OpenGLRenderer.cpp
View File

@@ -35,7 +35,7 @@ namespace uirenderer {
///////////////////////////////////////////////////////////////////////////////
// Debug
#define DEBUG_LAYERS 0
#define DEBUG_LAYERS 1
// These properties are defined in mega-bytes
#define PROPERTY_TEXTURE_CACHE_SIZE "ro.hwui.texture_cache_size"

126
libs/hwui/SortedList.cpp
View File

@@ -1,126 +0,0 @@
/*
* Copyright (C) 2010 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 "SortedList.h"
namespace android {
namespace uirenderer {
SortedListImpl::SortedListImpl(size_t itemSize, uint32_t flags) :
VectorImpl(itemSize, flags) {
}
SortedListImpl::SortedListImpl(const VectorImpl& rhs) :
VectorImpl(rhs) {
}
SortedListImpl::~SortedListImpl() {
}
SortedListImpl& SortedListImpl::operator =(const SortedListImpl& rhs) {
return static_cast<SortedListImpl&> (VectorImpl::operator =(
static_cast<const VectorImpl&> (rhs)));
}
ssize_t SortedListImpl::indexOf(const void* item) const {
return _indexOrderOf(item);
}
size_t SortedListImpl::orderOf(const void* item) const {
size_t o;
_indexOrderOf(item, &o);
return o;
}
ssize_t SortedListImpl::_indexOrderOf(const void* item, size_t* order) const {
// binary search
ssize_t err = NAME_NOT_FOUND;
ssize_t l = 0;
ssize_t h = size() - 1;
ssize_t mid;
const void* a = arrayImpl();
const size_t s = itemSize();
while (l <= h) {
mid = l + (h - l) / 2;
const void* const curr = reinterpret_cast<const char *> (a) + (mid * s);
const int c = do_compare(curr, item);
if (c == 0) {
err = l = mid;
break;
} else if (c < 0) {
l = mid + 1;
} else {
h = mid - 1;
}
}
if (order)
*order = l;
return err;
}
ssize_t SortedListImpl::add(const void* item) {
size_t order;
ssize_t index = _indexOrderOf(item, &order);
index = VectorImpl::insertAt(item, order, 1);
return index;
}
ssize_t SortedListImpl::merge(const VectorImpl& vector) {
// naive merge...
if (!vector.isEmpty()) {
const void* buffer = vector.arrayImpl();
const size_t is = itemSize();
size_t s = vector.size();
for (size_t i = 0; i < s; i++) {
ssize_t err = add(reinterpret_cast<const char*> (buffer) + i * is);
if (err < 0) {
return err;
}
}
}
return NO_ERROR;
}
ssize_t SortedListImpl::merge(const SortedListImpl& vector) {
// we've merging a sorted vector... nice!
ssize_t err = NO_ERROR;
if (!vector.isEmpty()) {
// first take care of the case where the vectors are sorted together
if (do_compare(vector.itemLocation(vector.size() - 1), arrayImpl()) <= 0) {
err = VectorImpl::insertVectorAt(static_cast<const VectorImpl&> (vector), 0);
} else if (do_compare(vector.arrayImpl(), itemLocation(size() - 1)) >= 0) {
err = VectorImpl::appendVector(static_cast<const VectorImpl&> (vector));
} else {
// this could be made a little better
err = merge(static_cast<const VectorImpl&> (vector));
}
}
return err;
}
ssize_t SortedListImpl::remove(const void* item) {
ssize_t i = indexOf(item);
if (i >= 0) {
VectorImpl::removeItemsAt(i, 1);
}
return i;
}
}
; // namespace uirenderer
}
; // namespace android

255
libs/hwui/SortedList.h
View File

@@ -1,255 +0,0 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef ANDROID_UI_SORTED_LIST_H
#define ANDROID_UI_SORTED_LIST_H
#include <utils/Vector.h>
#include <utils/VectorImpl.h>
namespace android {
namespace uirenderer {
class SortedListImpl: public VectorImpl {
public:
SortedListImpl(size_t itemSize, uint32_t flags);
SortedListImpl(const VectorImpl& rhs);
virtual ~SortedListImpl();
SortedListImpl& operator =(const SortedListImpl& rhs);
ssize_t indexOf(const void* item) const;
size_t orderOf(const void* item) const;
ssize_t add(const void* item);
ssize_t merge(const VectorImpl& vector);
ssize_t merge(const SortedListImpl& vector);
ssize_t remove(const void* item);
protected:
virtual int do_compare(const void* lhs, const void* rhs) const = 0;
private:
ssize_t _indexOrderOf(const void* item, size_t* order = 0) const;
// these are made private, because they can't be used on a SortedList
// (they don't have an implementation either)
ssize_t add();
void pop();
void push();
void push(const void* item);
ssize_t insertVectorAt(const VectorImpl& vector, size_t index);
ssize_t appendVector(const VectorImpl& vector);
ssize_t insertArrayAt(const void* array, size_t index, size_t length);
ssize_t appendArray(const void* array, size_t length);
ssize_t insertAt(size_t where, size_t numItems = 1);
ssize_t insertAt(const void* item, size_t where, size_t numItems = 1);
ssize_t replaceAt(size_t index);
ssize_t replaceAt(const void* item, size_t index);
}; // class SortedListImpl
template<class TYPE>
class SortedList: private SortedListImpl {
public:
typedef TYPE value_type;
SortedList();
SortedList(const SortedList<TYPE>& rhs);
virtual ~SortedList();
const SortedList<TYPE>& operator =(const SortedList<TYPE>& rhs) const;
SortedList<TYPE>& operator =(const SortedList<TYPE>& rhs);
inline void clear() {
VectorImpl::clear();
}
inline size_t size() const {
return VectorImpl::size();
}
inline bool isEmpty() const {
return VectorImpl::isEmpty();
}
inline size_t capacity() const {
return VectorImpl::capacity();
}
inline ssize_t setCapacity(size_t size) {
return VectorImpl::setCapacity(size);
}
inline const TYPE* array() const;
TYPE* editArray();
ssize_t indexOf(const TYPE& item) const;
size_t orderOf(const TYPE& item) const;
inline const TYPE& operator [](size_t index) const;
inline const TYPE& itemAt(size_t index) const;
const TYPE& top() const;
const TYPE& mirrorItemAt(ssize_t index) const;
ssize_t add(const TYPE& item);
TYPE& editItemAt(size_t index) {
return *(static_cast<TYPE *> (VectorImpl::editItemLocation(index)));
}
ssize_t merge(const Vector<TYPE>& vector);
ssize_t merge(const SortedList<TYPE>& vector);
ssize_t remove(const TYPE&);
inline ssize_t removeItemsAt(size_t index, size_t count = 1);
inline ssize_t removeAt(size_t index) {
return removeItemsAt(index);
}
protected:
virtual void do_construct(void* storage, size_t num) const;
virtual void do_destroy(void* storage, size_t num) const;
virtual void do_copy(void* dest, const void* from, size_t num) const;
virtual void do_splat(void* dest, const void* item, size_t num) const;
virtual void do_move_forward(void* dest, const void* from, size_t num) const;
virtual void
do_move_backward(void* dest, const void* from, size_t num) const;
virtual int do_compare(const void* lhs, const void* rhs) const;
};
template<class TYPE> inline SortedList<TYPE>::SortedList() :
SortedListImpl(sizeof(TYPE), ((traits<TYPE>::has_trivial_ctor ? HAS_TRIVIAL_CTOR : 0)
| (traits<TYPE>::has_trivial_dtor ? HAS_TRIVIAL_DTOR : 0)
| (traits<TYPE>::has_trivial_copy ? HAS_TRIVIAL_COPY : 0))) {
}
template<class TYPE> inline SortedList<TYPE>::SortedList(const SortedList<TYPE>& rhs) :
SortedListImpl(rhs) {
}
template<class TYPE> inline SortedList<TYPE>::~SortedList() {
finish_vector();
}
template<class TYPE> inline SortedList<TYPE>& SortedList<TYPE>::operator =(
const SortedList<TYPE>& rhs) {
SortedListImpl::operator =(rhs);
return *this;
}
template<class TYPE> inline const SortedList<TYPE>& SortedList<TYPE>::operator =(const SortedList<
TYPE>& rhs) const {
SortedListImpl::operator =(rhs);
return *this;
}
template<class TYPE> inline const TYPE* SortedList<TYPE>::array() const {
return static_cast<const TYPE *> (arrayImpl());
}
template<class TYPE> inline TYPE* SortedList<TYPE>::editArray() {
return static_cast<TYPE *> (editArrayImpl());
}
template<class TYPE> inline const TYPE& SortedList<TYPE>::operator[](size_t index) const {
assert( index<size() );
return *(array() + index);
}
template<class TYPE> inline const TYPE& SortedList<TYPE>::itemAt(size_t index) const {
return operator[](index);
}
template<class TYPE> inline const TYPE& SortedList<TYPE>::mirrorItemAt(ssize_t index) const {
assert( (index>0 ? index : -index)<size() );
return *(array() + ((index < 0) ? (size() - index) : index));
}
template<class TYPE> inline const TYPE& SortedList<TYPE>::top() const {
return *(array() + size() - 1);
}
template<class TYPE> inline ssize_t SortedList<TYPE>::add(const TYPE& item) {
return SortedListImpl::add(&item);
}
template<class TYPE> inline ssize_t SortedList<TYPE>::indexOf(const TYPE& item) const {
return SortedListImpl::indexOf(&item);
}
template<class TYPE> inline size_t SortedList<TYPE>::orderOf(const TYPE& item) const {
return SortedListImpl::orderOf(&item);
}
template<class TYPE> inline ssize_t SortedList<TYPE>::merge(const Vector<TYPE>& vector) {
return SortedListImpl::merge(reinterpret_cast<const VectorImpl&> (vector));
}
template<class TYPE> inline ssize_t SortedList<TYPE>::merge(const SortedList<TYPE>& vector) {
return SortedListImpl::merge(reinterpret_cast<const SortedListImpl&> (vector));
}
template<class TYPE> inline ssize_t SortedList<TYPE>::remove(const TYPE& item) {
return SortedListImpl::remove(&item);
}
template<class TYPE> inline ssize_t SortedList<TYPE>::removeItemsAt(size_t index, size_t count) {
return VectorImpl::removeItemsAt(index, count);
}
template<class TYPE>
void SortedList<TYPE>::do_construct(void* storage, size_t num) const {
construct_type(reinterpret_cast<TYPE*> (storage), num);
}
template<class TYPE>
void SortedList<TYPE>::do_destroy(void* storage, size_t num) const {
destroy_type(reinterpret_cast<TYPE*> (storage), num);
}
template<class TYPE>
void SortedList<TYPE>::do_copy(void* dest, const void* from, size_t num) const {
copy_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (from), num);
}
template<class TYPE>
void SortedList<TYPE>::do_splat(void* dest, const void* item, size_t num) const {
splat_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (item), num);
}
template<class TYPE>
void SortedList<TYPE>::do_move_forward(void* dest, const void* from, size_t num) const {
move_forward_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (from), num);
}
template<class TYPE>
void SortedList<TYPE>::do_move_backward(void* dest, const void* from, size_t num) const {
move_backward_type(reinterpret_cast<TYPE*> (dest), reinterpret_cast<const TYPE*> (from), num);
}
template<class TYPE>
int SortedList<TYPE>::do_compare(const void* lhs, const void* rhs) const {
return compare_type(*reinterpret_cast<const TYPE*> (lhs), *reinterpret_cast<const TYPE*> (rhs));
}
}
; // namespace uirenderer
}
; // namespace android
#endif // ANDROID_UI_SORTED_LIST_H

2
libs/hwui/TextureCache.cpp
View File

@@ -28,7 +28,7 @@ namespace uirenderer {
///////////////////////////////////////////////////////////////////////////////
TextureCache::TextureCache(uint32_t maxByteSize):
mCache(GenerationSingleCache<SkBitmap*, Texture*>::kUnlimitedCapacity),
mCache(GenerationCache<SkBitmap*, Texture*>::kUnlimitedCapacity),
mSize(0), mMaxSize(maxByteSize) {
mCache.setOnEntryRemovedListener(this);
}

2
libs/hwui/TextureCache.h
View File

@@ -78,7 +78,7 @@ private:
*/
void generateTexture(SkBitmap* bitmap, Texture* texture, bool regenerate = false);
GenerationSingleCache<SkBitmap*, Texture*> mCache;
GenerationCache<SkBitmap*, Texture*> mCache;
uint32_t mSize;
uint32_t mMaxSize;