[Bf-blender-cvs] [b13f8aa4429] temp-lanpr-staging: LANPR: Threaded render status flag.

YimingWu noreply at git.blender.org
Sun Aug 18 11:35:30 CEST 2019


Commit: b13f8aa44298b3416d516f022c83b65e327debd4
Author: YimingWu
Date:   Sun Aug 18 17:35:07 2019 +0800
Branches: temp-lanpr-staging
https://developer.blender.org/rBb13f8aa44298b3416d516f022c83b65e327debd4

LANPR: Threaded render status flag.

===================================================================

M	source/blender/editors/include/ED_lanpr.h
M	source/blender/editors/lanpr/lanpr_cpu.c
M	source/blender/editors/lanpr/lanpr_util.c

===================================================================

diff --git a/source/blender/editors/include/ED_lanpr.h b/source/blender/editors/include/ED_lanpr.h
index 129c4166233..1cebaf71868 100644
--- a/source/blender/editors/include/ED_lanpr.h
+++ b/source/blender/editors/include/ED_lanpr.h
@@ -64,7 +64,7 @@ typedef struct LANPR_StaticMemPoolNode {
 typedef struct LANPR_StaticMemPool {
   int each_size;
   ListBase pools;
-  SpinLock cs_mem;
+  SpinLock lock_mem;
 } LANPR_StaticMemPool;
 
 typedef struct LANPR_TextureSample {
@@ -285,9 +285,8 @@ typedef struct LANPR_RenderBuffer {
 
   struct DRWShadingGroup *ChainShgrp;
 
-  SpinLock cs_info;
-  SpinLock cs_data;
-  SpinLock cs_management;
+  /** For managing calculation tasks for multiple threads. */
+  SpinLock lock_task;
 
   /*  settings */
 
@@ -296,10 +295,6 @@ typedef struct LANPR_RenderBuffer {
   real crease_cos;
   int thread_count;
 
-  /** Deprecated, need another report mechanism */
-  real overall_progress;
-  int calculation_status;
-
   int draw_material_preview;
   real material_transparency;
 
@@ -316,6 +311,14 @@ typedef struct LANPR_RenderBuffer {
 
 } LANPR_RenderBuffer;
 
+typedef enum LANPR_RenderStatus{
+  LANPR_RENDER_IDLE = 0,
+  LANPR_RENDER_RUNNING = 1,
+  LANPR_RENDER_CANCELED = 2,
+  LANPR_RENDER_INCOMPELTE = 3,
+  LANPR_RENDER_FINISHED = 4,
+}LANPR_RenderStatus;
+
 typedef struct LANPR_SharedResource {
 
   /* We only allocate once for all */
@@ -351,7 +354,9 @@ typedef struct LANPR_SharedResource {
 
   int init_complete;
 
-  SpinLock render_flag_lock;
+  /** To bypass or cancel rendering. */
+  SpinLock lock_render_status;
+  LANPR_RenderStatus flag_render_status;
 
   /** Set before rendering and cleared upon finish! */
   struct RenderEngine *re_render;
@@ -596,9 +601,11 @@ void ED_lanpr_chain_clear_picked_flag(struct LANPR_RenderBuffer *rb);
 
 int ED_lanpr_compute_feature_lines_internal(struct Depsgraph *depsgraph, int instersections_only);
 
+LANPR_RenderBuffer *ED_lanpr_create_render_buffer(void);
 void ED_lanpr_destroy_render_data(struct LANPR_RenderBuffer *rb);
 
-LANPR_RenderBuffer *ED_lanpr_create_render_buffer(void);
+void ED_lanpr_calculation_set_flag(LANPR_RenderStatus flag);
+bool ED_lanpr_calculation_flag_check(LANPR_RenderStatus flag);
 
 bool ED_lanpr_dpix_shader_error(void);
 bool ED_lanpr_disable_edge_splits(struct Scene *s);
diff --git a/source/blender/editors/lanpr/lanpr_cpu.c b/source/blender/editors/lanpr/lanpr_cpu.c
index 250b4d6599a..cb32c57b6c4 100644
--- a/source/blender/editors/lanpr/lanpr_cpu.c
+++ b/source/blender/editors/lanpr/lanpr_cpu.c
@@ -565,7 +565,7 @@ static int lanpr_make_next_occlusion_task_info(LANPR_RenderBuffer *rb, LANPR_Ren
   int i;
   int res = 0;
 
-  BLI_spin_lock(&rb->cs_management);
+  BLI_spin_lock(&rb->lock_task);
 
   if (rb->contour_managed) {
     data = rb->contour_managed;
@@ -647,7 +647,7 @@ static int lanpr_make_next_occlusion_task_info(LANPR_RenderBuffer *rb, LANPR_Ren
     rti->edge_mark = 0;
   }
 
-  BLI_spin_unlock(&rb->cs_management);
+  BLI_spin_unlock(&rb->lock_task);
 
   return res;
 }
@@ -684,7 +684,7 @@ static void lanpr_calculate_single_line_occlusion(LANPR_RenderBuffer *rb,
         continue;
       }
       rt->testing[thread_id] = rl;
-      if (lanpr_triangle_line_imagespace_intersection_v2(&rb->cs_management,
+      if (lanpr_triangle_line_imagespace_intersection_v2(&rb->lock_task,
                                                          (void *)rt,
                                                          rl,
                                                          c,
@@ -702,6 +702,18 @@ static void lanpr_calculate_single_line_occlusion(LANPR_RenderBuffer *rb,
     nba = lanpr_get_next_bounding_area(nba, rl, x, y, k, PositiveX, PositiveY, &x, &y);
   }
 }
+static bool lanpr_calculation_is_canceled(){
+  bool is_canceled;
+  BLI_spin_lock(&lanpr_share.lock_render_status);
+  switch(lanpr_share.flag_render_status){
+    case LANPR_RENDER_CANCELED:
+      is_canceled = true;
+    default:
+      is_canceled = false;
+  }
+  BLI_spin_unlock(&lanpr_share.lock_render_status);
+  return is_canceled;
+}
 static void lanpr_THREAD_calculate_line_occlusion(TaskPool *__restrict UNUSED(pool),
                                                   LANPR_RenderTaskInfo *rti,
                                                   int UNUSED(threadid))
@@ -716,25 +728,36 @@ static void lanpr_THREAD_calculate_line_occlusion(TaskPool *__restrict UNUSED(po
       lanpr_calculate_single_line_occlusion(rb, lip->data, rti->thread_id);
     }
 
+    /* Monitoring cancelation flag every once a while. */
+    if(lanpr_calculation_is_canceled()) return;
+
     for (lip = (void *)rti->crease; lip && lip->prev != rti->crease_pointers.last;
          lip = lip->next) {
       lanpr_calculate_single_line_occlusion(rb, lip->data, rti->thread_id);
     }
 
+    if(lanpr_calculation_is_canceled()) return;
+
     for (lip = (void *)rti->intersection; lip && lip->prev != rti->intersection_pointers.last;
          lip = lip->next) {
       lanpr_calculate_single_line_occlusion(rb, lip->data, rti->thread_id);
     }
 
+    if(lanpr_calculation_is_canceled()) return;
+
     for (lip = (void *)rti->material; lip && lip->prev != rti->material_pointers.last;
          lip = lip->next) {
       lanpr_calculate_single_line_occlusion(rb, lip->data, rti->thread_id);
     }
 
+    if(lanpr_calculation_is_canceled()) return;
+
     for (lip = (void *)rti->edge_mark; lip && lip->prev != rti->edge_mark_pointers.last;
          lip = lip->next) {
       lanpr_calculate_single_line_occlusion(rb, lip->data, rti->thread_id);
     }
+
+    if(lanpr_calculation_is_canceled()) return;
   }
 }
 static void lanpr_THREAD_calculate_line_occlusion_begin(LANPR_RenderBuffer *rb)
@@ -2590,10 +2613,10 @@ void ED_lanpr_destroy_render_data(LANPR_RenderBuffer *rb)
   BLI_listbase_clear(&rb->line_buffer_pointers);
   BLI_listbase_clear(&rb->triangle_buffer_pointers);
 
-  BLI_spin_end(&rb->cs_data);
-  BLI_spin_end(&rb->cs_info);
-  BLI_spin_end(&rb->cs_management);
-  BLI_spin_end(&rb->render_data_pool.cs_mem);
+  BLI_spin_end(&rb->lock_task);
+  BLI_spin_end(&rb->render_data_pool.lock_mem);
+
+  BLI_spin_end(&lanpr_share.lock_render_status);
 
   mem_static_destroy(&rb->render_data_pool);
 }
@@ -2610,14 +2633,28 @@ LANPR_RenderBuffer *ED_lanpr_create_render_buffer(void)
 
   rb->cached_for_frame = -1;
 
-  BLI_spin_init(&rb->cs_data);
-  BLI_spin_init(&rb->cs_info);
-  BLI_spin_init(&rb->cs_management);
-  BLI_spin_init(&rb->render_data_pool.cs_mem);
+  BLI_spin_init(&rb->lock_task);
+  BLI_spin_init(&rb->render_data_pool.lock_mem);
+
+  BLI_spin_init(&lanpr_share.lock_render_status);
 
   return rb;
 }
 
+void ED_lanpr_calculation_set_flag(LANPR_RenderStatus flag){
+  BLI_spin_lock(&lanpr_share.lock_render_status);
+  lanpr_share.flag_render_status = flag;
+  BLI_spin_unlock(&lanpr_share.lock_render_status);
+}
+
+bool ED_lanpr_calculation_flag_check(LANPR_RenderStatus flag){
+  bool match;
+  BLI_spin_lock(&lanpr_share.lock_render_status);
+  match = (lanpr_share.flag_render_status == flag);
+  BLI_spin_unlock(&lanpr_share.lock_render_status);
+  return match;
+}
+
 static int lanpr_max_occlusion_in_collections(Collection *c)
 {
   CollectionChild *cc;
diff --git a/source/blender/editors/lanpr/lanpr_util.c b/source/blender/editors/lanpr/lanpr_util.c
index 8b6ee87b496..578335f0c20 100644
--- a/source/blender/editors/lanpr/lanpr_util.c
+++ b/source/blender/editors/lanpr/lanpr_util.c
@@ -85,7 +85,7 @@ void *mem_static_aquire_thread(LANPR_StaticMemPool *smp, int size)
   LANPR_StaticMemPoolNode *smpn = smp->pools.first;
   void *ret;
 
-  BLI_spin_lock(&smp->cs_mem);
+  BLI_spin_lock(&smp->lock_mem);
 
   if (!smpn || (smpn->used_byte + size) > LANPR_MEMORY_POOL_128MB) {
     smpn = mem_new_static_pool(smp);
@@ -95,7 +95,7 @@ void *mem_static_aquire_thread(LANPR_StaticMemPool *smp, int size)
 
   smpn->used_byte += size;
 
-  BLI_spin_unlock(&smp->cs_mem);
+  BLI_spin_unlock(&smp->lock_mem);
 
   return ret;
 }



More information about the Bf-blender-cvs mailing list