Blender  V3.3
MEM_CacheLimiterC-Api.cpp
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 
7 #include <cstddef>
8 
9 #include "MEM_CacheLimiter.h"
10 #include "MEM_CacheLimiterC-Api.h"
11 
12 static bool is_disabled = false;
13 
14 static size_t &get_max()
15 {
16  static size_t m = 32 * 1024 * 1024;
17  return m;
18 }
19 
21 {
22  get_max() = m;
23 }
24 
26 {
27  return get_max();
28 }
29 
30 void MEM_CacheLimiter_set_disabled(bool disabled)
31 {
32  is_disabled = disabled;
33 }
34 
36 {
37  return is_disabled;
38 }
39 
42 
45 typedef std::list<MEM_CacheLimiterHandleCClass *, MEM_Allocator<MEM_CacheLimiterHandleCClass *>>
47 
49  public:
52  : data_destructor(data_destructor_), cache(data_size)
53  {
54  }
56 
57  handle_t *insert(void *data);
58 
59  void destruct(void *data, list_t::iterator it);
60 
62  {
63  return &cache;
64  }
65 
66  private:
67  MEM_CacheLimiter_Destruct_Func data_destructor;
68 
70 
71  list_t cclass_list;
72 };
73 
75  public:
77  : data(data_), parent(parent_)
78  {
79  }
80 
82 
83  void set_iter(list_t::iterator it_)
84  {
85  it = it_;
86  }
87 
88  void set_data(void *data_)
89  {
90  data = data_;
91  }
92 
93  void *get_data() const
94  {
95  return data;
96  }
97 
98  private:
99  void *data;
100  MEM_CacheLimiterCClass *parent;
101  list_t::iterator it;
102 };
103 
105 {
106  cclass_list.push_back(new MEM_CacheLimiterHandleCClass(data, this));
107  list_t::iterator it = cclass_list.end();
108  --it;
109  cclass_list.back()->set_iter(it);
110 
111  return cache.insert(cclass_list.back());
112 }
113 
114 void MEM_CacheLimiterCClass::destruct(void *data, list_t::iterator it)
115 {
116  data_destructor(data);
117  cclass_list.erase(it);
118 }
119 
121 {
122  if (data) {
123  parent->destruct(data, it);
124  }
125 }
126 
128 {
129  // should not happen, but don't leak memory in this case...
130  for (list_t::iterator it = cclass_list.begin(); it != cclass_list.end(); it++) {
131  (*it)->set_data(NULL);
132 
133  delete *it;
134  }
135 }
136 
137 // ----------------------------------------------------------------------
138 
140 {
141  return (MEM_CacheLimiterCClass *)l;
142 }
143 
145 {
146  return (handle_t *)l;
147 }
148 
151 {
152  return (MEM_CacheLimiterC *)new MEM_CacheLimiterCClass(data_destructor, data_size);
153 }
154 
156 {
157  delete cast(This);
158 }
159 
161 {
162  return (MEM_CacheLimiterHandleC *)cast(This)->insert(data);
163 }
164 
166 {
167  cast(This)->get_cache()->enforce_limits();
168 }
169 
171 {
172  cast(handle)->unmanage();
173 }
174 
176 {
177  cast(handle)->touch();
178 }
179 
181 {
182  cast(handle)->ref();
183 }
184 
186 {
187  cast(handle)->unref();
188 }
189 
191 {
192  return cast(handle)->get_refcount();
193 }
194 
196 {
197  return cast(handle)->get()->get_data();
198 }
199 
201  MEM_CacheLimiter_ItemPriority_Func item_priority_func)
202 {
203  cast(This)->get_cache()->set_item_priority_func(item_priority_func);
204 }
205 
207  MEM_CacheLimiterC *This, MEM_CacheLimiter_ItemDestroyable_Func item_destroyable_func)
208 {
209  cast(This)->get_cache()->set_item_destroyable_func(item_destroyable_func);
210 }
211 
213 {
214  return cast(This)->get_cache()->get_memory_in_use();
215 }
void MEM_CacheLimiter_ItemPriority_Func_set(MEM_CacheLimiterC *This, MEM_CacheLimiter_ItemPriority_Func item_priority_func)
void MEM_CacheLimiter_set_maximum(size_t m)
void MEM_CacheLimiter_enforce_limits(MEM_CacheLimiterC *This)
static bool is_disabled
MEM_CacheLimiter< MEM_CacheLimiterHandleCClass > cache_t
void MEM_CacheLimiter_touch(MEM_CacheLimiterHandleC *handle)
MEM_CacheLimiterHandleC * MEM_CacheLimiter_insert(MEM_CacheLimiterC *This, void *data)
void MEM_CacheLimiter_unref(MEM_CacheLimiterHandleC *handle)
void delete_MEM_CacheLimiter(MEM_CacheLimiterC *This)
int MEM_CacheLimiter_get_refcount(MEM_CacheLimiterHandleC *handle)
void * MEM_CacheLimiter_get(MEM_CacheLimiterHandleC *handle)
void MEM_CacheLimiter_ItemDestroyable_Func_set(MEM_CacheLimiterC *This, MEM_CacheLimiter_ItemDestroyable_Func item_destroyable_func)
std::list< MEM_CacheLimiterHandleCClass *, MEM_Allocator< MEM_CacheLimiterHandleCClass * > > list_t
size_t MEM_CacheLimiter_get_memory_in_use(MEM_CacheLimiterC *This)
void MEM_CacheLimiter_set_disabled(bool disabled)
MEM_CacheLimiterHandle< MEM_CacheLimiterHandleCClass > handle_t
size_t MEM_CacheLimiter_get_maximum()
bool MEM_CacheLimiter_is_disabled(void)
static size_t & get_max()
static MEM_CacheLimiterCClass * cast(MEM_CacheLimiterC *l)
void MEM_CacheLimiter_ref(MEM_CacheLimiterHandleC *handle)
void MEM_CacheLimiter_unmanage(MEM_CacheLimiterHandleC *handle)
MEM_CacheLimiterC * new_MEM_CacheLimiter(MEM_CacheLimiter_Destruct_Func data_destructor, MEM_CacheLimiter_DataSize_Func data_size)
struct MEM_CacheLimiterHandle_s MEM_CacheLimiterHandleC
int(* MEM_CacheLimiter_ItemPriority_Func)(void *, int)
bool(* MEM_CacheLimiter_ItemDestroyable_Func)(void *)
void(* MEM_CacheLimiter_Destruct_Func)(void *)
struct MEM_CacheLimiter_s MEM_CacheLimiterC
size_t(* MEM_CacheLimiter_DataSize_Func)(void *)
ATTR_WARN_UNUSED_RESULT const BMLoop * l
void destruct(void *data, list_t::iterator it)
MEM_CacheLimiterCClass(MEM_CacheLimiter_Destruct_Func data_destructor_, MEM_CacheLimiter_DataSize_Func data_size)
handle_t * insert(void *data)
void set_iter(list_t::iterator it_)
MEM_CacheLimiterHandleCClass(void *data_, MEM_CacheLimiterCClass *parent_)
size_t get_memory_in_use()
MEM_CacheLimiterHandle< T > * insert(T *elem)
void set_item_destroyable_func(MEM_CacheLimiter_ItemDestroyable_Func item_destroyable_func)
void set_item_priority_func(MEM_CacheLimiter_ItemPriority_Func item_priority_func)
T * data_
Definition: eval_output.h:163