From: Kevin Day <Kevin@kevux.org>
Date: Sat, 22 Nov 2025 14:22:59 +0000 (-0600)
Subject: Update: Reduce the number of lock requests to check if process is interrupted.
X-Git-Tag: 0.7.3~1
X-Git-Url: https://www.git.kevux.org/?a=commitdiff_plain;h=299960c74c4a78c83ab3e2b422e24d49a15c5dab;p=controller

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 e51dcee..7068d68 100644
--- 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 06f31ed..b73418e 100644
--- 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 1ca20b7..e92ccc3 100644
--- 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 d68110e..be92123 100644
--- 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 c30e74e..7195ad5 100644
--- 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 39885cd..521f8df 100644
--- 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 75ce439..81b3fdd 100644
--- 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 1488068..fab05a9 100644
--- 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 7ab5613..eb1c8ff 100644
--- 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;