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

Move several property queries to Properties class

Browse Source 
bug:17478770

This removes a lot of redundant property query code, and puts the
queries all in one place, so defining them automatically will be simpler
in the future.

Change-Id: I0428550e6081f07bc6554ffdf73b22284325abb8
This commit is contained in:
Chris Craik
2016-02-05 15:59:29 -08:00
parent 37fd29f284
commit 48a8f431fa
17 changed files with 63 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
libs/hwui/FboCache.cpp
View File

@@ -27,15 +27,8 @@ namespace uirenderer {
// Constructors/destructor
///////////////////////////////////////////////////////////////////////////////
FboCache::FboCache(): mMaxSize(DEFAULT_FBO_CACHE_SIZE) {
char property[PROPERTY_VALUE_MAX];
if (property_get(PROPERTY_FBO_CACHE_SIZE, property, nullptr) > 0) {
INIT_LOGD(" Setting fbo cache size to %s", property);
mMaxSize = atoi(property);
} else {
INIT_LOGD(" Using default fbo cache size of %d", DEFAULT_FBO_CACHE_SIZE);
}
}
FboCache::FboCache()
: mMaxSize(Properties::fboCacheSize) {}
FboCache::~FboCache() {
clear();

17
libs/hwui/GradientCache.cpp
View File

@@ -65,17 +65,9 @@ int GradientCacheEntry::compare(const GradientCacheEntry& lhs, const GradientCac
GradientCache::GradientCache(Extensions& extensions)
: mCache(LruCache<GradientCacheEntry, Texture*>::kUnlimitedCapacity)
, mSize(0)
, mMaxSize(MB(DEFAULT_GRADIENT_CACHE_SIZE))
, mMaxSize(Properties::gradientCacheSize)
, mUseFloatTexture(extensions.hasFloatTextures())
, mHasNpot(extensions.hasNPot()){
char property[PROPERTY_VALUE_MAX];
if (property_get(PROPERTY_GRADIENT_CACHE_SIZE, property, nullptr) > 0) {
INIT_LOGD(" Setting gradient cache size to %sMB", property);
setMaxSize(MB(atof(property)));
} else {
INIT_LOGD(" Using default gradient cache size of %.2fMB", DEFAULT_GRADIENT_CACHE_SIZE);
}
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
mCache.setOnEntryRemovedListener(this);
@@ -97,13 +89,6 @@ uint32_t GradientCache::getMaxSize() {
return mMaxSize;
}
void GradientCache::setMaxSize(uint32_t maxSize) {
mMaxSize = maxSize;
while (mSize > mMaxSize) {
mCache.removeOldest();
}
}
///////////////////////////////////////////////////////////////////////////////
// Callbacks
///////////////////////////////////////////////////////////////////////////////

6
libs/hwui/GradientCache.h
View File

@@ -122,10 +122,6 @@ public:
*/
void clear();
/**
* Sets the maximum size of the cache in bytes.
*/
void setMaxSize(uint32_t maxSize);
/**
* Returns the maximum size of the cache in bytes.
*/
@@ -177,7 +173,7 @@ private:
LruCache<GradientCacheEntry, Texture*> mCache;
uint32_t mSize;
uint32_t mMaxSize;
const uint32_t mMaxSize;
GLint mMaxTextureSize;
bool mUseFloatTexture;

12
libs/hwui/PatchCache.cpp
View File

@@ -32,20 +32,12 @@ namespace uirenderer {
PatchCache::PatchCache(RenderState& renderState)
: mRenderState(renderState)
, mMaxSize(Properties::patchCacheSize)
, mSize(0)
, mCache(LruCache<PatchDescription, Patch*>::kUnlimitedCapacity)
, mMeshBuffer(0)
, mFreeBlocks(nullptr)
, mGenerationId(0) {
char property[PROPERTY_VALUE_MAX];
if (property_get(PROPERTY_PATCH_CACHE_SIZE, property, nullptr) > 0) {
INIT_LOGD(" Setting patch cache size to %skB", property);
mMaxSize = KB(atoi(property));
} else {
INIT_LOGD(" Using default patch cache size of %.2fkB", DEFAULT_PATCH_CACHE_SIZE);
mMaxSize = KB(DEFAULT_PATCH_CACHE_SIZE);
}
}
, mGenerationId(0) {}
PatchCache::~PatchCache() {
clear();

2
libs/hwui/PatchCache.h
View File

@@ -169,7 +169,7 @@ private:
#endif
RenderState& mRenderState;
uint32_t mMaxSize;
const uint32_t mMaxSize;
uint32_t mSize;
LruCache<PatchDescription, Patch*> mCache;

15
libs/hwui/PathCache.cpp
View File

@@ -135,17 +135,10 @@ static void drawPath(const SkPath *path, const SkPaint* paint, SkBitmap& bitmap,
// Cache constructor/destructor
///////////////////////////////////////////////////////////////////////////////
PathCache::PathCache():
mCache(LruCache<PathDescription, PathTexture*>::kUnlimitedCapacity),
mSize(0), mMaxSize(MB(DEFAULT_PATH_CACHE_SIZE)) {
char property[PROPERTY_VALUE_MAX];
if (property_get(PROPERTY_PATH_CACHE_SIZE, property, nullptr) > 0) {
INIT_LOGD(" Setting path cache size to %sMB", property);
mMaxSize = MB(atof(property));
} else {
INIT_LOGD(" Using default path cache size of %.2fMB", DEFAULT_PATH_CACHE_SIZE);
}
PathCache::PathCache()
: mCache(LruCache<PathDescription, PathTexture*>::kUnlimitedCapacity)
, mSize(0)
, mMaxSize(Properties::pathCacheSize) {
mCache.setOnEntryRemovedListener(this);
GLint maxTextureSize;

2
libs/hwui/PathCache.h
View File

@@ -300,7 +300,7 @@ private:
LruCache<PathDescription, PathTexture*> mCache;
uint32_t mSize;
uint32_t mMaxSize;
const uint32_t mMaxSize;
GLuint mMaxTextureSize;
bool mDebugEnabled;

25
libs/hwui/Properties.cpp
View File

@@ -37,7 +37,18 @@ bool Properties::useBufferAge = true;
bool Properties::enablePartialUpdates = true;
float Properties::textGamma = DEFAULT_TEXT_GAMMA;
int Properties::layerPoolSize = DEFAULT_LAYER_CACHE_SIZE;
int Properties::fboCacheSize = DEFAULT_FBO_CACHE_SIZE;
int Properties::gradientCacheSize = MB(DEFAULT_GRADIENT_CACHE_SIZE);
int Properties::layerPoolSize = MB(DEFAULT_LAYER_CACHE_SIZE);
int Properties::patchCacheSize = KB(DEFAULT_PATCH_CACHE_SIZE);
int Properties::pathCacheSize = MB(DEFAULT_PATH_CACHE_SIZE);
int Properties::renderBufferCacheSize = MB(DEFAULT_RENDER_BUFFER_CACHE_SIZE);
int Properties::tessellationCacheSize = MB(DEFAULT_VERTEX_CACHE_SIZE);
int Properties::textDropShadowCacheSize = MB(DEFAULT_DROP_SHADOW_CACHE_SIZE);
int Properties::textureCacheSize = MB(DEFAULT_TEXTURE_CACHE_SIZE);
float Properties::textureCacheFlushRate = DEFAULT_TEXTURE_CACHE_FLUSH_RATE;
DebugLevel Properties::debugLevel = kDebugDisabled;
OverdrawColorSet Properties::overdrawColorSet = OverdrawColorSet::Default;
@@ -79,7 +90,6 @@ bool Properties::load() {
bool prevDebugOverdraw = debugOverdraw;
StencilClipDebug prevDebugStencilClip = debugStencilClip;
debugOverdraw = false;
if (property_get(PROPERTY_DEBUG_OVERDRAW, property, nullptr) > 0) {
INIT_LOGD(" Overdraw debug enabled: %s", property);
@@ -133,7 +143,18 @@ bool Properties::load() {
enablePartialUpdates = property_get_bool(PROPERTY_ENABLE_PARTIAL_UPDATES, true);
textGamma = property_get_float(PROPERTY_TEXT_GAMMA, DEFAULT_TEXT_GAMMA);
fboCacheSize = property_get_int(PROPERTY_FBO_CACHE_SIZE, DEFAULT_FBO_CACHE_SIZE);
gradientCacheSize = MB(property_get_float(PROPERTY_GRADIENT_CACHE_SIZE, DEFAULT_GRADIENT_CACHE_SIZE));
layerPoolSize = MB(property_get_float(PROPERTY_LAYER_CACHE_SIZE, DEFAULT_LAYER_CACHE_SIZE));
patchCacheSize = KB(property_get_float(PROPERTY_PATCH_CACHE_SIZE, DEFAULT_PATCH_CACHE_SIZE));
pathCacheSize = MB(property_get_float(PROPERTY_PATH_CACHE_SIZE, DEFAULT_PATH_CACHE_SIZE));
renderBufferCacheSize = MB(property_get_float(PROPERTY_RENDER_BUFFER_CACHE_SIZE, DEFAULT_RENDER_BUFFER_CACHE_SIZE));
tessellationCacheSize = MB(property_get_float(PROPERTY_VERTEX_CACHE_SIZE, DEFAULT_VERTEX_CACHE_SIZE));
textDropShadowCacheSize = MB(property_get_float(PROPERTY_DROP_SHADOW_CACHE_SIZE, DEFAULT_DROP_SHADOW_CACHE_SIZE));
textureCacheSize = MB(property_get_float(PROPERTY_TEXTURE_CACHE_SIZE, DEFAULT_TEXTURE_CACHE_SIZE));
textureCacheFlushRate = std::max(0.0f, std::min(1.0f,
property_get_float(PROPERTY_TEXTURE_CACHE_FLUSH_RATE, DEFAULT_TEXTURE_CACHE_FLUSH_RATE)));
return (prevDebugLayersUpdates != debugLayersUpdates)
|| (prevDebugOverdraw != debugOverdraw)

9
libs/hwui/Properties.h
View File

@@ -267,7 +267,16 @@ public:
static float textGamma;
static int fboCacheSize;
static int gradientCacheSize;
static int layerPoolSize;
static int patchCacheSize;
static int pathCacheSize;
static int renderBufferCacheSize;
static int tessellationCacheSize;
static int textDropShadowCacheSize;
static int textureCacheSize;
static float textureCacheFlushRate;
static DebugLevel debugLevel;
static OverdrawColorSet overdrawColorSet;

18
libs/hwui/RenderBufferCache.cpp
View File

@@ -40,16 +40,9 @@ namespace uirenderer {
// Constructors/destructor
///////////////////////////////////////////////////////////////////////////////
RenderBufferCache::RenderBufferCache(): mSize(0), mMaxSize(MB(DEFAULT_RENDER_BUFFER_CACHE_SIZE)) {
char property[PROPERTY_VALUE_MAX];
if (property_get(PROPERTY_RENDER_BUFFER_CACHE_SIZE, property, nullptr) > 0) {
INIT_LOGD(" Setting render buffer cache size to %sMB", property);
setMaxSize(MB(atof(property)));
} else {
INIT_LOGD(" Using default render buffer cache size of %.2fMB",
DEFAULT_RENDER_BUFFER_CACHE_SIZE);
}
}
RenderBufferCache::RenderBufferCache()
: mSize(0)
, mMaxSize(Properties::renderBufferCacheSize) {}
RenderBufferCache::~RenderBufferCache() {
clear();
@@ -67,11 +60,6 @@ uint32_t RenderBufferCache::getMaxSize() {
return mMaxSize;
}
void RenderBufferCache::setMaxSize(uint32_t maxSize) {
clear();
mMaxSize = maxSize;
}
///////////////////////////////////////////////////////////////////////////////
// Caching
///////////////////////////////////////////////////////////////////////////////

4
libs/hwui/RenderBufferCache.h
View File

@@ -63,10 +63,6 @@ public:
*/
void clear();
/**
* Sets the maximum size of the cache in bytes.
*/
void setMaxSize(uint32_t maxSize);
/**
* Returns the maximum size of the cache in bytes.
*/

18
libs/hwui/TessellationCache.cpp
View File

@@ -265,18 +265,9 @@ public:
///////////////////////////////////////////////////////////////////////////////
TessellationCache::TessellationCache()
: mSize(0)
, mMaxSize(MB(DEFAULT_VERTEX_CACHE_SIZE))
: mMaxSize(Properties::tessellationCacheSize)
, mCache(LruCache<Description, Buffer*>::kUnlimitedCapacity)
, mShadowCache(LruCache<ShadowDescription, Task<vertexBuffer_pair_t*>*>::kUnlimitedCapacity) {
char property[PROPERTY_VALUE_MAX];
if (property_get(PROPERTY_VERTEX_CACHE_SIZE, property, nullptr) > 0) {
INIT_LOGD(" Setting tessellation cache size to %sMB", property);
setMaxSize(MB(atof(property)));
} else {
INIT_LOGD(" Using default tessellation cache size of %.2fMB", DEFAULT_VERTEX_CACHE_SIZE);
}
mCache.setOnEntryRemovedListener(&mBufferRemovedListener);
mShadowCache.setOnEntryRemovedListener(&mBufferPairRemovedListener);
mDebugEnabled = Properties::debugLevel & kDebugCaches;
@@ -303,13 +294,6 @@ uint32_t TessellationCache::getMaxSize() {
return mMaxSize;
}
void TessellationCache::setMaxSize(uint32_t maxSize) {
mMaxSize = maxSize;
while (mSize > mMaxSize) {
mCache.removeOldest();
}
}
///////////////////////////////////////////////////////////////////////////////
// Caching
///////////////////////////////////////////////////////////////////////////////

8
libs/hwui/TessellationCache.h
View File

@@ -131,11 +131,6 @@ public:
* Clears the cache. This causes all TessellationBuffers to be deleted.
*/
void clear();
/**
* Sets the maximum size of the cache in bytes.
*/
void setMaxSize(uint32_t maxSize);
/**
* Returns the maximum size of the cache in bytes.
*/
@@ -198,8 +193,7 @@ private:
Buffer* getOrCreateBuffer(const Description& entry, Tessellator tessellator);
uint32_t mSize;
uint32_t mMaxSize;
const uint32_t mMaxSize;
bool mDebugEnabled;

38
libs/hwui/TextDropShadowCache.cpp
View File

@@ -93,36 +93,21 @@ int ShadowText::compare(const ShadowText& lhs, const ShadowText& rhs) {
// Constructors/destructor
///////////////////////////////////////////////////////////////////////////////
TextDropShadowCache::TextDropShadowCache():
mCache(LruCache<ShadowText, ShadowTexture*>::kUnlimitedCapacity),
mSize(0), mMaxSize(MB(DEFAULT_DROP_SHADOW_CACHE_SIZE)) {
char property[PROPERTY_VALUE_MAX];
if (property_get(PROPERTY_DROP_SHADOW_CACHE_SIZE, property, nullptr) > 0) {
INIT_LOGD(" Setting drop shadow cache size to %sMB", property);
setMaxSize(MB(atof(property)));
} else {
INIT_LOGD(" Using default drop shadow cache size of %.2fMB",
DEFAULT_DROP_SHADOW_CACHE_SIZE);
}
TextDropShadowCache::TextDropShadowCache()
: TextDropShadowCache(Properties::textDropShadowCacheSize) {}
init();
}
TextDropShadowCache::TextDropShadowCache(uint32_t maxByteSize):
mCache(LruCache<ShadowText, ShadowTexture*>::kUnlimitedCapacity),
mSize(0), mMaxSize(maxByteSize) {
init();
TextDropShadowCache::TextDropShadowCache(uint32_t maxByteSize)
: mCache(LruCache<ShadowText, ShadowTexture*>::kUnlimitedCapacity)
, mSize(0)
, mMaxSize(maxByteSize) {
mCache.setOnEntryRemovedListener(this);
mDebugEnabled = Properties::debugLevel & kDebugMoreCaches;
}
TextDropShadowCache::~TextDropShadowCache() {
mCache.clear();
}
void TextDropShadowCache::init() {
mCache.setOnEntryRemovedListener(this);
mDebugEnabled = Properties::debugLevel & kDebugMoreCaches;
}
///////////////////////////////////////////////////////////////////////////////
// Size management
///////////////////////////////////////////////////////////////////////////////
@@ -135,13 +120,6 @@ uint32_t TextDropShadowCache::getMaxSize() {
return mMaxSize;
}
void TextDropShadowCache::setMaxSize(uint32_t maxSize) {
mMaxSize = maxSize;
while (mSize > mMaxSize) {
mCache.removeOldest();
}
}
///////////////////////////////////////////////////////////////////////////////
// Callbacks
///////////////////////////////////////////////////////////////////////////////

10
libs/hwui/TextDropShadowCache.h
View File

@@ -147,10 +147,6 @@ public:
mRenderer = &fontRenderer;
}
/**
* Sets the maximum size of the cache in bytes.
*/
void setMaxSize(uint32_t maxSize);
/**
* Returns the maximum size of the cache in bytes.
*/
@@ -161,13 +157,11 @@ public:
uint32_t getSize();
private:
void init();
LruCache<ShadowText, ShadowTexture*> mCache;
uint32_t mSize;
uint32_t mMaxSize;
FontRenderer* mRenderer;
const uint32_t mMaxSize;
FontRenderer* mRenderer = nullptr;
bool mDebugEnabled;
}; // class TextDropShadowCache

32
libs/hwui/TextureCache.cpp
View File

@@ -35,26 +35,9 @@ namespace uirenderer {
TextureCache::TextureCache()
: mCache(LruCache<uint32_t, Texture*>::kUnlimitedCapacity)
, mSize(0)
, mMaxSize(MB(DEFAULT_TEXTURE_CACHE_SIZE))
, mFlushRate(DEFAULT_TEXTURE_CACHE_FLUSH_RATE)
, mMaxSize(Properties::textureCacheSize)
, mFlushRate(Properties::textureCacheFlushRate)
, mAssetAtlas(nullptr) {
char property[PROPERTY_VALUE_MAX];
if (property_get(PROPERTY_TEXTURE_CACHE_SIZE, property, nullptr) > 0) {
INIT_LOGD(" Setting texture cache size to %sMB", property);
setMaxSize(MB(atof(property)));
} else {
INIT_LOGD(" Using default texture cache size of %.2fMB", DEFAULT_TEXTURE_CACHE_SIZE);
}
if (property_get(PROPERTY_TEXTURE_CACHE_FLUSH_RATE, property, nullptr) > 0) {
float flushRate = atof(property);
INIT_LOGD(" Setting texture cache flush rate to %.2f%%", flushRate * 100.0f);
setFlushRate(flushRate);
} else {
INIT_LOGD(" Using default texture cache flush rate of %.2f%%",
DEFAULT_TEXTURE_CACHE_FLUSH_RATE * 100.0f);
}
mCache.setOnEntryRemovedListener(this);
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
@@ -79,17 +62,6 @@ uint32_t TextureCache::getMaxSize() {
return mMaxSize;
}
void TextureCache::setMaxSize(uint32_t maxSize) {
mMaxSize = maxSize;
while (mSize > mMaxSize) {
mCache.removeOldest();
}
}
void TextureCache::setFlushRate(float flushRate) {
mFlushRate = std::max(0.0f, std::min(1.0f, flushRate));
}
///////////////////////////////////////////////////////////////////////////////
// Callbacks
///////////////////////////////////////////////////////////////////////////////

13
libs/hwui/TextureCache.h
View File

@@ -108,10 +108,6 @@ public:
*/
void clear();
/**
* Sets the maximum size of the cache in bytes.
*/
void setMaxSize(uint32_t maxSize);
/**
* Returns the maximum size of the cache in bytes.
*/
@@ -126,11 +122,6 @@ public:
* is defined by the flush rate.
*/
void flush();
/**
* Indicates the percentage of the cache to retain when a
* memory trim is requested (see Caches::flush).
*/
void setFlushRate(float flushRate);
void setAssetAtlas(AssetAtlas* assetAtlas);
@@ -148,10 +139,10 @@ private:
LruCache<uint32_t, Texture*> mCache;
uint32_t mSize;
uint32_t mMaxSize;
const uint32_t mMaxSize;
GLint mMaxTextureSize;
float mFlushRate;
const float mFlushRate;
bool mDebugEnabled;