Update: Reduce the number of lock requests to check if process is interrupted.

The general rule is to check each arbitrarily large loop or between long running functions for interrupt.
Each lock attempt is also checked for interrupt before locking.

This is resulting in a bit too many checks (which are to some extend expensive because checking requires a lock).

Many of these checks are back to back because some explicit checks are called before normal locking requests (which themselves perform explicit checks).

diff --git a/sources/c/program/controller/init/signal.c b/sources/c/program/controller/init/signal.c
index e51dcee3bd58d3d03f3baed0424a587f745cb94f..7068d680c7d23166f7ca5e745025147d6ffe2198 100644 (file)
--- a/sources/c/program/controller/init/signal.c
+++ b/sources/c/program/controller/init/signal.c
@@ -8,7 +8,6 @@ extern "C" {
   void controller_init_signal_thread(controller_t * const main, const uint8_t is_normal, f_thread_attribute_t * const attribute) {
 
     if (!main || !attribute) return;
-    if (!controller_thread_enable_is_normal(&main->thread, is_normal)) return;
     if (!(main->setting.flag & controller_main_flag_interruptible_d)) return;
 
     siginfo_t information;

diff --git a/sources/c/program/controller/main/entry.c b/sources/c/program/controller/main/entry.c
index 06f31ed95b1e73e7c796a894241ae358912b3f9e..b73418e4dbbfd3c13c7e7c5da39fbf9a754926bc 100644 (file)
--- a/sources/c/program/controller/main/entry.c
+++ b/sources/c/program/controller/main/entry.c
@@ -191,6 +191,10 @@ extern "C" {
           }
         } // for
 
+        if (!controller_thread_enable_is_normal(&main->thread, is_entry)) {
+          entry->status = F_status_set_error(F_interrupt);
+        }
+
         if (is_entry && F_status_set_fine(state.status) == F_interrupt) {
           entry->status = controller_status_simplify_error(F_status_set_fine(state.status));
 
@@ -218,12 +222,6 @@ extern "C" {
 
               for (j = 0; j < entry->items.array[i].actions.used; ++j) {
 
-                if (!controller_thread_enable_is_normal(&main->thread, is_entry)) {
-                  entry->status = controller_status_simplify_error(F_interrupt);
-
-                  return F_status_set_error(F_interrupt);
-                }
-
                 action = &entry->items.array[i].actions.array[j];
 
                 // Only process actions that don't already have an error.
@@ -422,8 +420,6 @@ extern "C" {
       } // for
     } // for
 
-    if (!controller_thread_enable_is_normal(&main->thread, is_entry)) return F_status_set_error(F_interrupt);
-
     controller_rule_t *rules[total];
 
     memset(rules, 0, sizeof(controller_rule_t *) * total);

diff --git a/sources/c/program/controller/main/entry/preprocess.c b/sources/c/program/controller/main/entry/preprocess.c
index 1ca20b748c1ac8a2b2665c109be999e7c9b195db..e92ccc3716435a80ea1bfc85807be804873188e7 100644 (file)
--- a/sources/c/program/controller/main/entry/preprocess.c
+++ b/sources/c/program/controller/main/entry/preprocess.c
@@ -95,7 +95,7 @@ extern "C" {
           else if (f_compare_dynamic(controller_settings_s, actions->array[cache->ats.array[at_j]].parameters.array[0]) == F_equal_to) continue;
 
           // Walk though each items and check to see if the item actually exists.
-          for (i = 1; i < entry->items.used && controller_thread_enable_is_normal(&main->thread, is_entry); ++i) {
+          for (i = 1; i < entry->items.used; ++i) {
 
             if (f_compare_dynamic(entry->items.array[i].name, actions->array[cache->ats.array[at_j]].parameters.array[0]) == F_equal_to) {
 

diff --git a/sources/c/program/controller/main/entry/process.c b/sources/c/program/controller/main/entry/process.c
index d68110ee19f1d1faa771d0aa261ce8c13f977dfa..be92123cd3e79be8a780ef8b4b815d8bafbb9490 100644 (file)
--- a/sources/c/program/controller/main/entry/process.c
+++ b/sources/c/program/controller/main/entry/process.c
@@ -211,8 +211,6 @@ extern "C" {
             controller_print_message_entry_item_rule(&main->program.message, entry, entry_action, is_entry, alias_rule);
           }
 
-          if (!controller_thread_enable_is_normal(&main->thread, is_entry)) break;
-
           // The Rule is not yet loaded, ensure that it is loaded (but not when using controlfile/initfile).
           if (status != F_true) {
             if (main->setting.flag & controller_main_flag_single_d) {
@@ -265,7 +263,7 @@ extern "C" {
               cache->action.line_action = cache_line_action;
               cache->action.line_item = cache_line_item;
 
-              if (F_status_set_fine(status) == F_interrupt || !controller_thread_enable_is_normal(&main->thread, is_entry)) break;
+              if (F_status_set_fine(status) == F_interrupt) break;
 
               if (F_status_is_error(status)) {
                 if (main->program.error.verbosity > f_console_verbosity_quiet_e) {

diff --git a/sources/c/program/controller/main/instance/prepare.c b/sources/c/program/controller/main/instance/prepare.c
index c30e74e755301e7b65aeb2907d7e3832f27fa2f5..7195ad5850ede39ecdfc4464fbcfa384ca3046db 100644 (file)
--- a/sources/c/program/controller/main/instance/prepare.c
+++ b/sources/c/program/controller/main/instance/prepare.c
@@ -9,8 +9,6 @@ extern "C" {
 
     if (!main) return F_status_set_error(F_parameter);
 
-    if (!controller_thread_enable_is_normal(&main->thread, is_normal)) return F_status_set_error(F_interrupt);
-
     f_status_t status = controller_lock_read_standard(is_normal, controller_lock_check_flag_yes_d, &main->thread, &main->thread.lock.instance);
 
     if (status != F_okay) {

diff --git a/sources/c/program/controller/main/instance/wait.c b/sources/c/program/controller/main/instance/wait.c
index 39885cda1c052f147c2ebea31862f9c7eff8e945..521f8dfe1895aa75dbb080252d9d29a23821914f 100644 (file)
--- a/sources/c/program/controller/main/instance/wait.c
+++ b/sources/c/program/controller/main/instance/wait.c
@@ -8,7 +8,6 @@ extern "C" {
   f_status_t controller_instance_wait(controller_instance_t * const instance) {
 
     if (!instance || !instance->main) return F_status_set_error(F_parameter);
-    if (!controller_thread_is_enabled_instance(instance)) return F_status_set_error(F_interrupt);
 
     f_time_spec_t time;
 
@@ -21,12 +20,6 @@ extern "C" {
       status = controller_mutex_lock_instance(instance, &instance->wait);
       if (F_status_is_error(status)) break;
 
-      if (!controller_thread_is_enabled_instance(instance)) {
-        f_thread_mutex_unlock(&instance->wait.mutex);
-
-        return F_status_set_error(F_interrupt);
-      }
-
       if (count < controller_thread_timeout_wait_1_before_d) {
         controller_time_now(controller_thread_timeout_wait_1_seconds_d, controller_thread_timeout_wait_1_nanoseconds_d, &time);
       }
@@ -81,7 +74,7 @@ extern "C" {
         ++count;
       }
 
-    } while (status == F_time && controller_thread_is_enabled_instance(instance));
+    } while (status == F_time);
 
     return status;
   }

diff --git a/sources/c/program/controller/main/rule/execute.c b/sources/c/program/controller/main/rule/execute.c
index 75ce4395d1635d052ad19a4b504aba28bab6eb8f..81b3fddccf2f7e2e89f0ff2782875763f369ad49 100644 (file)
--- a/sources/c/program/controller/main/rule/execute.c
+++ b/sources/c/program/controller/main/rule/execute.c
@@ -215,7 +215,7 @@ extern "C" {
     // 0x1 = No Item, 0x2 = No action.
     uint8_t execute_nothing = 0x3;
 
-    for (i = 0; i < instance->rule.items.used && controller_thread_is_enabled_instance(instance); ++i) {
+    for (i = 0; i < instance->rule.items.used; ++i) {
 
       if (instance->rule.items.array[i].type == controller_rule_item_type_settings_e) continue;
 
@@ -223,12 +223,6 @@ extern "C" {
 
       for (j = 0; j < instance->rule.items.array[i].actions.used; ++j) {
 
-        if (!controller_thread_is_enabled_instance(instance)) {
-          status = F_status_set_error(F_interrupt);
-
-          break;
-        }
-
         if (instance->rule.items.array[i].actions.array[j].type != action) continue;
 
         execute_nothing &= ~0x2;
@@ -769,9 +763,9 @@ extern "C" {
       controller_t * const main = instance->main;
       controller_rule_rerun_item_t * const rerun_item = result ? &item->reruns[action].failure : &item->reruns[action].success;
 
-      if (!controller_thread_is_enabled_instance(instance)) return -2;
-
       if (!rerun_item->max || rerun_item->count < rerun_item->max) {
+        if (!controller_thread_is_enabled_instance(instance)) return -2;
+
         controller_main_print_debug_rule_execute_rerun(&main->program.output, instance, rerun_item, action, F_status_debug_source_d);
 
         if (rerun_item->delay) {
@@ -789,8 +783,6 @@ extern "C" {
             status = controller_time_sleep_nanoseconds(instance->main, delay);
             if (F_status_is_error(status) || status == F_interrupt) return -1;
           }
-
-          if (!controller_thread_is_enabled_instance(instance)) return -2;
         }
 
         if (item->reruns[action].is & (result ? controller_rule_rerun_is_failure_reset_d : controller_rule_rerun_is_success_reset_d)) {

diff --git a/sources/c/program/controller/main/rule/instance.c b/sources/c/program/controller/main/rule/instance.c
index 1488068b36c1274cb625ecbc57b624b69df37be2..fab05a948ef45ad72e43e66aae2ed67b86603403 100644 (file)
--- a/sources/c/program/controller/main/rule/instance.c
+++ b/sources/c/program/controller/main/rule/instance.c
@@ -124,9 +124,9 @@ extern "C" {
 
       // i==0 is need, i==1 is want, i==2 is wish.
       // Loop through all dependencies: wait for depedency, execute dependency, fail due to missing required dependency, or skip unrequired missing dependencies.
-      for (i = 0; i < 3 && controller_thread_is_enabled_instance(instance); ++i) {
+      for (i = 0; i < 3; ++i) {
 
-        for (j = 0; j < dynamics[i]->used && controller_thread_is_enabled_instance(instance); ++j) {
+        for (j = 0; j < dynamics[i]->used; ++j) {
 
           dependency = 0;
           found = F_false;
@@ -271,18 +271,12 @@ extern "C" {
               }
             }
 
-            if (!controller_thread_is_enabled_instance(instance)) {
-              f_thread_unlock(&dependency->active);
-
-              break;
-            }
-
             if (F_status_is_error(status_lock)) {
               status = status_lock;
 
-              if (F_status_set_fine(status_lock) != F_interrupt) {
-                controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "due to lock failure", F_status_debug_source_d);
-              }
+              if (F_status_set_fine(status_lock) == F_interrupt) break;
+
+              controller_print_error_rule_instance_need_want_wish(&main->program.error, instance, strings[i], alias_other_buffer, "due to lock failure", F_status_debug_source_d);
             }
             else if (controller_rule_status_is_error(instance->action, *rule)) {
               if (i == 0 || i == 1) {
@@ -313,7 +307,6 @@ extern "C" {
     }
 
     if (status == F_child || F_status_set_fine(status) == F_interrupt) return status;
-    if (!controller_thread_is_enabled_instance(instance)) return F_status_set_error(F_interrupt);
 
     if ((instance->options & controller_instance_option_wait_d) && F_status_is_error_not(status) && (instance->options & controller_instance_option_validate_d)) {
       status_lock = controller_rule_wait_all_instance_type(main, instance->type, F_false);
@@ -430,7 +423,6 @@ extern "C" {
   f_status_t controller_rule_instance_begin(controller_t * const main, controller_cache_t * const cache, const uint8_t options_force, const f_string_static_t alias_rule, const uint8_t action, const uint8_t options, const uint8_t type, const controller_rules_t stack) {
 
     if (!main || !cache) return F_status_set_error(F_parameter);
-    if (!controller_thread_is_enabled_instance_type(&main->thread, type)) return F_status_set_error(F_interrupt);
 
     controller_instance_t *instance = 0;
 
@@ -660,8 +652,6 @@ extern "C" {
 
         status = controller_rule_instance_perform_stack_verify(instance, rule);
 
-        if (!controller_thread_is_enabled_instance(instance)) return F_status_set_error(F_interrupt);
-
         if (F_status_is_error_not(status)) {
           status = controller_rule_instance_perform_stack_rule_append(instance, rule);
 

diff --git a/sources/c/program/controller/main/thread/signal.c b/sources/c/program/controller/main/thread/signal.c
index 7ab56139871331a26fbb49428bb501804c089461..eb1c8ffaeb53cceaec0b5a3303bf91c2d13b98f0 100644 (file)
--- a/sources/c/program/controller/main/thread/signal.c
+++ b/sources/c/program/controller/main/thread/signal.c
@@ -8,7 +8,6 @@ extern "C" {
   void controller_thread_signal(controller_t * const main, const uint8_t is_normal, f_thread_attribute_t * const attribute) {
 
     if (!main || !attribute) return;
-    if (!controller_thread_enable_is_normal(&main->thread, is_normal)) return;
     if (!(main->setting.flag & controller_main_flag_interruptible_d)) return;
 
     siginfo_t information;