[Bf-blender-cvs] [9b4c865acb2] temp-trimesh-sculpt: * Added a debug mode to BLI_safepool * Readwrite locks now use windows API - Might revert that one
Joseph Eagar
noreply at git.blender.org
Wed Oct 14 09:35:56 CEST 2020
Commit: 9b4c865acb26bf19ee2d7f586e2d4e85ca9e169c
Author: Joseph Eagar
Date: Tue Oct 13 23:29:27 2020 -0700
Branches: temp-trimesh-sculpt
https://developer.blender.org/rB9b4c865acb26bf19ee2d7f586e2d4e85ca9e169c
* Added a debug mode to BLI_safepool
* Readwrite locks now use windows API
- Might revert that one
===================================================================
M source/blender/blenkernel/intern/DerivedMesh.c
M source/blender/blenkernel/intern/pbvh_trimesh.c
M source/blender/blenlib/BLI_threads.h
M source/blender/blenlib/BLI_threadsafe_mempool.h
M source/blender/blenlib/intern/BLI_threadsafe_mempool.c
M source/blender/blenlib/intern/threads.cc
M source/blender/bmesh/intern/bmesh_interp.c
M source/blender/gpu/intern/gpu_buffers.c
M source/blender/trimesh/intern/trimesh.c
M source/blender/trimesh/intern/trimesh_log.c
M source/blender/trimesh/intern/trimesh_private.h
M source/blender/trimesh/intern/trimesh_thread.c
===================================================================
diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index 25b9c7e6d14..f94a07b441b 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -86,7 +86,7 @@
# define ASSERT_IS_VALID_MESH(mesh)
#endif
-static ThreadRWMutex loops_cache_lock = PTHREAD_RWLOCK_INITIALIZER;
+static ThreadRWMutex loops_cache_lock = BLI_RWLOCK_INITIALIZER;
static void mesh_init_origspace(Mesh *mesh);
static void editbmesh_calc_modifier_final_normals(Mesh *mesh_final,
diff --git a/source/blender/blenkernel/intern/pbvh_trimesh.c b/source/blender/blenkernel/intern/pbvh_trimesh.c
index 4129cddac9f..dc79740b7b5 100644
--- a/source/blender/blenkernel/intern/pbvh_trimesh.c
+++ b/source/blender/blenkernel/intern/pbvh_trimesh.c
@@ -931,8 +931,8 @@ static void long_edge_queue_face_add(EdgeQueueContext *eq_ctx, TMFace *f)
const float len_sq = TM_edge_calc_length_squared(e);
if (len_sq > eq_ctx->q->limit_len_squared) {
- if (e->v1->edges.length > 24 || e->v2->edges.length > 24) {
- //printf("eek! %.4f %d %d\n", len_sq, e->v1->edges.length, e->v2->edges.length);
+ if (e->v1->edges.length > 64 || e->v2->edges.length > 64) {
+ printf("eek! %.4f %d %d\n", len_sq, e->v1->edges.length, e->v2->edges.length);
continue;
}
@@ -1211,7 +1211,7 @@ static void pbvh_trimesh_split_edge(EdgeQueueContext *eq_ctx,
if (v_opp->edges.length > 8) {
//prevent degenerate cases that make lots of geometry
- int len = MIN2(v_opp->edges.length, 32);
+ int len = MIN2(v_opp->edges.length, 512);
for (int i=0; i<len; i++) {
TMEdge *e2 = v_opp->edges.items[i];
@@ -1435,12 +1435,32 @@ static void pbvh_trimesh_collapse_edge(PBVH *bvh,
if (v_tri[j] == v_conn) {
v_conn = NULL;
}
+
BLI_ghash_insert(deleted_verts, v_tri[j], NULL);
TM_kill_vert(bvh->tm, v_tri[j], 0); //XXX check threadnr
}
}
}
+ for (int i=0; i<v_del->edges.length; i++) {
+ TMEdge *e2 = v_del->edges.items[i];
+
+ if (e2 != e && TM_edge_is_wire(e2)) {
+ TMVert *v2 = TM_other_vert(e2, v_del);
+
+ TM_kill_edge(bvh->tm, e2, 0, false);
+
+ if (v2 != v_conn && v2->edges.length == 0) {
+ pbvh_trimesh_vert_remove(bvh, v2);
+ BLI_trimesh_log_vert_kill(bvh->tm_log, v2);
+ BLI_ghash_insert(deleted_verts, v2, NULL);
+ TM_kill_vert(bvh->tm, v2, 0); //XXX check threadnr
+ }
+ i--;
+ continue;
+ }
+ }
+
/* Move v_conn to the midpoint of v_conn and v_del (if v_conn still exists, it
* may have been deleted above) */
if (v_conn != NULL) {
@@ -1911,7 +1931,7 @@ void BKE_pbvh_build_trimesh(PBVH *bvh,
bvh->tm_log = log;
/* TODO: choose leaf limit better */
- bvh->leaf_limit = 1024;
+ bvh->leaf_limit = 10000;
if (smooth_shading) {
bvh->flags |= PBVH_DYNTOPO_SMOOTH_SHADING;
@@ -1986,7 +2006,7 @@ bool BKE_pbvh_trimesh_update_topology(PBVH *bvh,
int sym_axis)
{
- if (PIL_check_seconds_timer() - last_update_time[sym_axis] < 0.05) {
+ if (PIL_check_seconds_timer() - last_update_time[sym_axis] < 0.025) {
return false;
}
diff --git a/source/blender/blenlib/BLI_threads.h b/source/blender/blenlib/BLI_threads.h
index d19b5393aa7..949931021f4 100644
--- a/source/blender/blenlib/BLI_threads.h
+++ b/source/blender/blenlib/BLI_threads.h
@@ -122,9 +122,16 @@ void BLI_spin_end(SpinLock *spin);
#define THREAD_LOCK_READ 1
#define THREAD_LOCK_WRITE 2
-#define BLI_RWLOCK_INITIALIZER PTHREAD_RWLOCK_INITIALIZER
-
+#ifndef WIN32
typedef pthread_rwlock_t ThreadRWMutex;
+#define BLI_RWLOCK_INITIALIZER PTHREAD_RWLOCK_INITIALIZER
+#else
+typedef struct {
+ void *data[4]; //stupid, to avoid windows.h here in the header
+ int have_exclusive;
+} ThreadRWMutex;
+#define BLI_RWLOCK_INITIALIZER {0} //just do what windows does
+#endif
void BLI_rw_mutex_init(ThreadRWMutex *mutex);
void BLI_rw_mutex_end(ThreadRWMutex *mutex);
diff --git a/source/blender/blenlib/BLI_threadsafe_mempool.h b/source/blender/blenlib/BLI_threadsafe_mempool.h
index d11c1eb83fa..51a4989dc48 100644
--- a/source/blender/blenlib/BLI_threadsafe_mempool.h
+++ b/source/blender/blenlib/BLI_threadsafe_mempool.h
@@ -23,11 +23,20 @@
#include "BLI_compiler_compat.h"
#include "BLI_listbase.h"
+//#define BYPASS_POOL
+#define CUSTOMALLOC __declspec(allocator)
+
+#define DEBUG_SAFEPOOL
+
+#ifdef BYPASS_POOL
+#include "BLI_ghash.h"
+#endif
+
struct BLI_ThreadSafePool;
typedef struct BLI_ThreadSafePool BLI_ThreadSafePool;
struct BLI_ThreadSafePool* BLI_safepool_create(int elemsize, int chunksize, int maxthread);
-void* BLI_safepool_alloc(struct BLI_ThreadSafePool *pool);
+CUSTOMALLOC void* BLI_safepool_alloc(struct BLI_ThreadSafePool *pool);
void BLI_safepool_free(struct BLI_ThreadSafePool*pool, void *elem);
int BLI_safepool_elem_is_dead(void *elem);
@@ -43,6 +52,9 @@ typedef struct ThreadSafePoolIter {
int thread;
void *chunk;
int i;
+#ifdef BYPASS_POOL
+ Link *node;
+#endif
} ThreadSafePoolIter;
void BLI_safepool_iternew(struct BLI_ThreadSafePool* pool, ThreadSafePoolIter* iter);
@@ -66,7 +78,7 @@ struct pool_thread_data;
typedef struct poolelem {
struct pool_thread_data *poolthread;
struct poolelem *next; //eats into returned memory
- intptr_t dead_magic; //eats into returned memory
+ uintptr_t dead_magic; //eats into returned memory, unless DEBUG_SAFEPOOL is defined
} poolelem;
typedef struct pool_thread_data {
@@ -85,11 +97,22 @@ typedef struct BLI_ThreadSafePool {
ThreadRWMutex lengthlock;
#endif
size_t esize, csize;
+#ifdef BYPASS_POOL
+ ListBase nodes;
+ GSet *nodeset;
+#endif
} BLI_ThreadSafePool;
-#define DEAD_MAGIC ('d' | ('e' << 8) | ('a' << 16) | ('d' || 24))
-#define _SPOOL_MAGIC ('s' | ('p' << 8) | ('o' << 16) | ('l' || 24))
+#define DEAD_MAGIC ('d' | ('e' << 8) | ('a' << 16) | ('d' << 24))
+#define _SPOOL_MAGIC ('s' | ('p' << 8) | ('o' << 16) | ('l' << 24))
+
+#ifdef DEBUG_SAFEPOOL
+#define LIVE_MAGIC ('a' | ('l' << 8) | ('i' << 16) | ('v' << 24))
+#define _TAIL_MAGIC1 ((long long)('t' | ('a' << 8) | ('i' << 16) | ('l' << 24)))
+#define _TAIL_MAGIC2 ((long long)('1' | ('2' << 8) | ('3' << 16) | ('4' << 24)))
+#define TAIL_MAGIC (sizeof(void*) == 8 ? (_TAIL_MAGIC1 | (_TAIL_MAGIC2<<32)) : _TAIL_MAGIC1)
+#endif
BLI_INLINE void lock_all_threads(BLI_ThreadSafePool* pool) {
for (int i = 0; i < pool->maxthread; i++) {
@@ -112,14 +135,30 @@ BLI_INLINE void BLI_safepool_iternew(struct BLI_ThreadSafePool* pool, ThreadSafe
iter->thread = 0;
iter->chunk = pool->threadchunks[0].chunks.first;
iter->i = 0;
+
+#ifdef BYPASS_POOL
+ iter->node = pool->nodes.first;
+#endif
+
+ unlock_all_threads(pool);
}
BLI_INLINE void BLI_safepool_iterfree(ThreadSafePoolIter* iter) {
- unlock_all_threads(iter->pool);
+ //unlock_all_threads(iter->pool);
}
BLI_INLINE void* BLI_safepool_iterstep(ThreadSafePoolIter* iter) {
BLI_ThreadSafePool *pool = iter->pool;
+
+#ifdef BYPASS_POOL
+ void *ret = iter->node ? (void*)(((char*)iter->node) + sizeof(void*)*2) : NULL;
+
+ if (iter->node) {
+ iter->node = iter->node->next;
+ }
+
+ return ret;
+#else
poolchunk *chunk = iter->chunk;
if (iter->i < 0) { //end of iteration
@@ -149,8 +188,12 @@ BLI_INLINE void* BLI_safepool_iterstep(ThreadSafePoolIter* iter) {
if (!ptr || de->dead_magic == DEAD_MAGIC) {
return BLI_safepool_iterstep(iter);
}
-
+#ifndef DEBUG_SAFEPOOL
return (void*) &de->next;
+#else
+ return (void*) (de + 1);
+#endif
+#endif
}
#endif /* _BLI_THREADSAFE_MEMPOOL_H */
diff --git a/source/blender/blenlib/intern/BLI_threadsafe_mempool.c b/source/blender/blenlib/intern/BLI_threadsafe_mempool.c
index 84c4a354b4f..66c4d075709 100644
--- a/source/blender/blenlib/intern/BLI_threadsafe_mempool.c
+++ b/source/blender/blenlib/intern/BLI_threadsafe_mempool.c
@@ -25,20 +25,28 @@ static int getalign(int size) {
/*not sure how to pass thread number to customdata functions, so this evilness here
is used for now*/
-ThreadLocal(int) curthread = 0;
+static ThreadLocal(int) curthread = -1;
BLI_thread_local_create(curthread);
void BLI_safepool_threadnr_set(int threadnr) {
BLI_thread_local_set(curthread, threadnr);
}
+static int get_curthread(BLI_ThreadSafePool *pool) {
+ return BLI_thread_local_get(curthread) % pool->maxthread;
+}
+
static size_t get_chunk_size(BLI_ThreadSafePool* pool) {
return getalign(sizeof(pool_thread_data)) + pool->esize*pool->csize;
//return getalign(sizeof(pool_thread_data) + pool->esize*pool->csize);
}
+#ifndef DEBUG_SAFEPOOL
#define getelem(elem) ((poolelem*) (((char*)(elem)) - sizeof(void*)))
+#else
+#define getelem(elem) ((poolelem*) (((char*)(elem)) - sizeof(poolelem)))
+#endif
static pool_thread_data* get_poolthread_from_elem(BLI_ThreadSafePool *pool, void* elem) {
//version of code for if elements are allowed to link themselves to other thread pools
@@ -63,6 +71,7 @@ static poolchunk *new_chunk(BLI_ThreadSafePool *pool, pool_thread_data* thread_d
chunk->threadnr = thread_data - pool->threadchunks;
BLI_addtail(&thread_data->chunks, chunk);
+
poolelem *first = NULL;
for (size_t i = 0; i < pool->csize-1; i++) {
@@ -89,17 +98,33 @@ static poolchunk *new_chunk(BLI_ThreadSafePool *pool, pool_thread_data* thread_d
BLI_ThreadSafePool* BLI_safepool_create(int elemsize, int chunksize, int maxthread) {
BLI_ThreadSafePool* pool = MEM_callocN(sizeof(*pool), "BLI_ThreadSafePool");
+ //XXX temporarily ensure maxthread is at least 4, delete me
+ maxthread = MAX2(maxthread, 4);
+
+#ifdef BYPASS_POOL
+ pool->nodeset = BLI_gset_ptr_new("safepool nodeset");
+#endif
+
pool->checkmagic = _SPOOL_MAGIC;
//align to pointer size
- if (elemsize & 7) {
- elemsize += 8 - (elemsize & 7);
+ if (elemsize & (sizeof(void*)-1)) {
+ elemsize += sizeof(void*) - (elemsize & (sizeof(void*)-1));
}
- //add header pointer to owning chunk
- elemsize = MAX2(elemsize + sizeof(void*), sizeof(void*)*2);
maxthread = MAX2(maxthread, 1);
+#ifndef DEBUG_SAFEPOOL
+ //add header pointer to size
+ elemsize = MAX2(elemsize + sizeof(void*),
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list