[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [48527] branches/soc-2011-tomato/intern/ memutil: Tomato: style cleanup, no functional changes
Sergey Sharybin
sergey.vfx at gmail.com
Tue Jul 3 12:56:49 CEST 2012
Revision: 48527
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=48527
Author: nazgul
Date: 2012-07-03 10:56:48 +0000 (Tue, 03 Jul 2012)
Log Message:
-----------
Tomato: style cleanup, no functional changes
Modified Paths:
--------------
branches/soc-2011-tomato/intern/memutil/MEM_CacheLimiter.h
branches/soc-2011-tomato/intern/memutil/MEM_CacheLimiterC-Api.h
branches/soc-2011-tomato/intern/memutil/intern/MEM_CacheLimiterC-Api.cpp
Modified: branches/soc-2011-tomato/intern/memutil/MEM_CacheLimiter.h
===================================================================
--- branches/soc-2011-tomato/intern/memutil/MEM_CacheLimiter.h 2012-07-03 10:56:33 UTC (rev 48526)
+++ branches/soc-2011-tomato/intern/memutil/MEM_CacheLimiter.h 2012-07-03 10:56:48 UTC (rev 48527)
@@ -32,7 +32,7 @@
* @section MEM_CacheLimiter
* This class defines a generic memory cache management system
* to limit memory usage to a fixed global maximum.
- *
+ *
* Please use the C-API in MEM_CacheLimiterC-Api.h for code written in C.
*
* Usage example:
@@ -41,12 +41,12 @@
* public:
* ~BigFatImage() { tell_everyone_we_are_gone(this); }
* };
- *
+ *
* void doit() {
* MEM_Cache<BigFatImage> BigFatImages;
*
* MEM_Cache_Handle<BigFatImage>* h = BigFatImages.insert(new BigFatImage);
- *
+ *
* BigFatImages.enforce_limits();
* h->ref();
*
@@ -67,36 +67,44 @@
#ifndef __MEM_CACHELIMITERC_API_H__
extern "C" {
- extern void MEM_CacheLimiter_set_maximum(size_t m);
- extern size_t MEM_CacheLimiter_get_maximum();
+ void MEM_CacheLimiter_set_maximum(size_t m);
+ size_t MEM_CacheLimiter_get_maximum();
};
#endif
template<class T>
class MEM_CacheLimiterHandle {
public:
- explicit MEM_CacheLimiterHandle(T * data_,
- MEM_CacheLimiter<T> * parent_)
- : data(data_), refcount(0), parent(parent_) { }
+ explicit MEM_CacheLimiterHandle(T * data_,MEM_CacheLimiter<T> *parent_) :
+ data(data_),
+ refcount(0),
+ parent(parent_)
+ { }
- void ref() {
- refcount++;
+ void ref() {
+ refcount++;
}
- void unref() {
- refcount--;
+
+ void unref() {
+ refcount--;
}
- T * get() {
- return data;
+
+ T *get() {
+ return data;
}
- const T * get() const {
- return data;
+
+ const T *get() const {
+ return data;
}
- int get_refcount() const {
- return refcount;
+
+ int get_refcount() const {
+ return refcount;
}
- bool can_destroy() const {
- return !data || !refcount;
+
+ bool can_destroy() const {
+ return !data || !refcount;
}
+
bool destroy_if_possible() {
if (can_destroy()) {
delete data;
@@ -106,26 +114,30 @@
}
return false;
}
+
void unmanage() {
parent->unmanage(this);
}
+
void touch() {
parent->touch(this);
}
+
void set_priority(int priority) {
this->priority = priority;
}
+
int get_priority(void) {
return this->priority;
}
+
private:
friend class MEM_CacheLimiter<T>;
T * data;
int refcount;
int priority;
- typename std::list<MEM_CacheLimiterHandle<T> *,
- MEM_Allocator<MEM_CacheLimiterHandle<T> *> >::iterator me;
+ typename std::list<MEM_CacheLimiterHandle<T> *, MEM_Allocator<MEM_CacheLimiterHandle<T> *> >::iterator me;
MEM_CacheLimiter<T> * parent;
};
@@ -133,26 +145,31 @@
class MEM_CacheLimiter {
public:
typedef size_t (*MEM_CacheLimiter_DataSize_Func) (void *data);
- typedef int (*MEM_CacheLimiter_ItemPriority_Func) (void *item, int default_priority);
+ typedef int (*MEM_CacheLimiter_ItemPriority_Func) (void *item, int default_priority);
+
MEM_CacheLimiter(MEM_CacheLimiter_DataSize_Func getDataSize_)
: getDataSize(getDataSize_) {
}
+
~MEM_CacheLimiter() {
for (iterator it = queue.begin(); it != queue.end(); it++) {
delete *it;
}
}
- MEM_CacheLimiterHandle<T> * insert(T * elem) {
+
+ MEM_CacheLimiterHandle<T> *insert(T * elem) {
queue.push_back(new MEM_CacheLimiterHandle<T>(elem, this));
iterator it = queue.end();
--it;
queue.back()->me = it;
return queue.back();
}
- void unmanage(MEM_CacheLimiterHandle<T> * handle) {
+
+ void unmanage(MEM_CacheLimiterHandle<T> *handle) {
queue.erase(handle->me);
delete handle;
}
+
void enforce_limits() {
MEM_CachePriorityQueue priority_queue;
size_t max = MEM_CacheLimiter_get_maximum();
@@ -177,23 +194,24 @@
while (!priority_queue.empty() && mem_in_use > max) {
MEM_CacheElementPtr elem = priority_queue.top();
+ priority_queue.pop();
+
if(getDataSize) {
cur_size = getDataSize(elem->get()->get_data());
} else {
cur_size = mem_in_use;
}
- elem->destroy_if_possible();
-
- priority_queue.pop();
-
- if (getDataSize) {
- mem_in_use -= cur_size;
- } else {
- mem_in_use -= cur_size - MEM_get_memory_in_use();
+ if (elem->destroy_if_possible()) {
+ if (getDataSize) {
+ mem_in_use -= cur_size;
+ } else {
+ mem_in_use -= cur_size - MEM_get_memory_in_use();
+ }
}
}
}
+
void touch(MEM_CacheLimiterHandle<T> * handle) {
queue.push_back(handle);
queue.erase(handle->me);
@@ -201,9 +219,11 @@
--it;
handle->me = it;
}
+
void set_item_priority_func(MEM_CacheLimiter_ItemPriority_Func item_priority_func) {
getItemPriority = item_priority_func;
}
+
private:
typedef MEM_CacheLimiterHandle<T> *MEM_CacheElementPtr;
typedef std::list<MEM_CacheElementPtr, MEM_Allocator<MEM_CacheElementPtr> > MEM_CacheQueue;
Modified: branches/soc-2011-tomato/intern/memutil/MEM_CacheLimiterC-Api.h
===================================================================
--- branches/soc-2011-tomato/intern/memutil/MEM_CacheLimiterC-Api.h 2012-07-03 10:56:33 UTC (rev 48526)
+++ branches/soc-2011-tomato/intern/memutil/MEM_CacheLimiterC-Api.h 2012-07-03 10:56:48 UTC (rev 48527)
@@ -31,7 +31,7 @@
#ifdef __cplusplus
extern "C" {
#endif
-
+
struct MEM_CacheLimiter_s;
struct MEM_CacheLimiterHandle_s;
@@ -39,113 +39,112 @@
typedef struct MEM_CacheLimiterHandle_s MEM_CacheLimiterHandleC;
/* function used to remove data from memory */
-typedef void(*MEM_CacheLimiter_Destruct_Func)(void*);
+typedef void (*MEM_CacheLimiter_Destruct_Func)(void*);
/* function used to measure stored data element size */
-typedef size_t(*MEM_CacheLimiter_DataSize_Func) (void*);
+typedef size_t (*MEM_CacheLimiter_DataSize_Func) (void*);
/* function used to measure priority of item when freeing memory */
-typedef int(*MEM_CacheLimiter_ItemPriority_Func) (void*, int);
+typedef int (*MEM_CacheLimiter_ItemPriority_Func) (void*, int);
#ifndef __MEM_CACHELIMITER_H__
-extern void MEM_CacheLimiter_set_maximum(size_t m);
-extern int MEM_CacheLimiter_get_maximum(void);
+void MEM_CacheLimiter_set_maximum(size_t m);
+int MEM_CacheLimiter_get_maximum(void);
#endif /* __MEM_CACHELIMITER_H__ */
-/**
- * Create new MEM_CacheLimiter object
+
+/**
+ * Create new MEM_CacheLimiter object
* managed objects are destructed with the data_destructor
*
* @param data_destructor
* @return A new MEM_CacheLimter object
*/
-extern MEM_CacheLimiterC * new_MEM_CacheLimiter(
- MEM_CacheLimiter_Destruct_Func data_destructor,
- MEM_CacheLimiter_DataSize_Func data_size);
+MEM_CacheLimiterC *new_MEM_CacheLimiter(MEM_CacheLimiter_Destruct_Func data_destructor,
+ MEM_CacheLimiter_DataSize_Func data_size);
-/**
+/**
* Delete MEM_CacheLimiter
- *
+ *
* Frees the memory of the CacheLimiter but does not touch managed objects!
*
* @param This "This" pointer
*/
-extern void delete_MEM_CacheLimiter(MEM_CacheLimiterC * This);
+void delete_MEM_CacheLimiter(MEM_CacheLimiterC *This);
-/**
+/**
* Manage object
- *
+ *
* @param This "This" pointer, data data object to manage
* @return CacheLimiterHandle to ref, unref, touch the managed object
*/
-
-extern MEM_CacheLimiterHandleC * MEM_CacheLimiter_insert(
- MEM_CacheLimiterC * This, void * data);
-/**
+MEM_CacheLimiterHandleC *MEM_CacheLimiter_insert(MEM_CacheLimiterC * This, void * data);
+
+/**
* Free objects until memory constraints are satisfied
- *
+ *
* @param This "This" pointer
*/
-extern void MEM_CacheLimiter_enforce_limits(MEM_CacheLimiterC * This);
+void MEM_CacheLimiter_enforce_limits(MEM_CacheLimiterC *This);
-/**
- * Unmanage object previously inserted object.
+/**
+ * Unmanage object previously inserted object.
* Does _not_ delete managed object!
- *
+ *
* @param This "This" pointer, handle of object
*/
-
-extern void MEM_CacheLimiter_unmanage(MEM_CacheLimiterHandleC * handle);
+void MEM_CacheLimiter_unmanage(MEM_CacheLimiterHandleC *handle);
-/**
+
+/**
* Raise priority of object (put it at the tail of the deletion chain)
- *
+ *
* @param handle of object
*/
-
-extern void MEM_CacheLimiter_touch(MEM_CacheLimiterHandleC * handle);
-/**
+void MEM_CacheLimiter_touch(MEM_CacheLimiterHandleC *handle);
+
+/**
* Increment reference counter. Objects with reference counter != 0 are _not_
* deleted.
- *
+ *
* @param handle of object
*/
-
-extern void MEM_CacheLimiter_ref(MEM_CacheLimiterHandleC * handle);
-/**
+void MEM_CacheLimiter_ref(MEM_CacheLimiterHandleC *handle);
+
+/**
* Decrement reference counter. Objects with reference counter != 0 are _not_
* deleted.
- *
+ *
* @param handle of object
*/
-
-extern void MEM_CacheLimiter_unref(MEM_CacheLimiterHandleC * handle);
-/**
+void MEM_CacheLimiter_unref(MEM_CacheLimiterHandleC *handle);
+
+/**
* Get reference counter.
- *
+ *
* @param This "This" pointer, handle of object
*/
-
-extern int MEM_CacheLimiter_get_refcount(MEM_CacheLimiterHandleC * handle);
-/**
+int MEM_CacheLimiter_get_refcount(MEM_CacheLimiterHandleC *handle);
+
+/**
* Get pointer to managed object
- *
+ *
* @param handle of object
*/
-
-extern void * MEM_CacheLimiter_get(MEM_CacheLimiterHandleC * handle);
-extern void MEM_CacheLimiter_ItemPriority_Func_set(MEM_CacheLimiterC *This,
- MEM_CacheLimiter_ItemPriority_Func item_priority_func);
+void * MEM_CacheLimiter_get(MEM_CacheLimiterHandleC *handle);
+void MEM_CacheLimiter_ItemPriority_Func_set(MEM_CacheLimiterC *This,
+ MEM_CacheLimiter_ItemPriority_Func item_priority_func);
+
#ifdef __cplusplus
}
#endif
Modified: branches/soc-2011-tomato/intern/memutil/intern/MEM_CacheLimiterC-Api.cpp
===================================================================
--- branches/soc-2011-tomato/intern/memutil/intern/MEM_CacheLimiterC-Api.cpp 2012-07-03 10:56:33 UTC (rev 48526)
+++ branches/soc-2011-tomato/intern/memutil/intern/MEM_CacheLimiterC-Api.cpp 2012-07-03 10:56:48 UTC (rev 48527)
@@ -31,7 +31,7 @@
static size_t & get_max()
{
- static size_t m = 32*1024*1024;
+ static size_t m = 32 * 1024 * 1024;
return m;
}
@@ -50,8 +50,7 @@
typedef MEM_CacheLimiterHandle<MEM_CacheLimiterHandleCClass> handle_t;
typedef MEM_CacheLimiter<MEM_CacheLimiterHandleCClass> cache_t;
-typedef std::list<MEM_CacheLimiterHandleCClass*,
- MEM_Allocator<MEM_CacheLimiterHandleCClass* > > list_t;
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list