Changeset 83

Timestamp:

06/29/05 03:23:09 (4 years ago)

Author:

jtv

Message:

Documented state machine

Files:

• src/state.c (modified) (4 diffs)

src/state.c

@@ -27 +27 @@
-#include "swaps.h"
-
+/* The allocation/deallocation algorithm is driven by a state machine.
+ */
-
-// TODO: Adaptive cooldown_time?
@@ -80 +82 @@
-  timer_tick();
-
-likely(the_state != st_diet) && unlikely(reqbytes > 0
+unlikely(reqbytes > 0) && likely(the_state != st_diet
-  {
+    /* In any state except "diet," where allocation is inhibited, a shortage of
+     * memory means we forget what state we're in and jump straight to "hungry"
+     * mode, allocating a new swapfile along the way.  If the allocation fails,
+     * we bail out into "diet" mode.
+     */
-    if (likely(alloc_swapfile(reqbytes))) state_to(st_hungry);
-    else state_to(st_diet);
@@ -87 +94 @@
-  else if (unlikely(timer_timeout()))
-  {
+    /* All states except "steady" are designed to time out eventually; in every
+     * case that leads back to "steady" so we can make it a general rule that
+     * timeout leads to "steady."
+     * The only other action that accompanies timeout is when timing out of the
+     * "overfed" state, which is where we normally deallocate.
+     */
-    if (the_state == st_overfed) free_swapfile(-reqbytes);
-    state_to(st_steady);
@@ -93 +106 @@
-  {
-  case st_diet:
+    /* If we overallocated and now find ourselves with more swap space than we
+     * think we need, deallocate it right away.  Don't leave "diet" state just
+     * yet in that case, however, or we may invite thrashing.
+     */
-    if (unlikely(reqbytes < 0)) free_swapfile(-reqbytes);
-    break;
-  case st_hungry:
+    /* The "hungry" state can either time out, or allocate more swap space and
+     * loop back to itself, resetting the timer (or if allocation fails, bail
+     * out to "diet").  In other words, all actions for this state have been
+     * handled by the general cases above.
+     */
-    break;
-  case st_steady:
+    /* If we have more swap space than we need, go to "overfed" state which may
+     * eventually lead to deallocation.
+     */
-    if (unlikely(reqbytes < 0)) state_to(st_overfed);
-    break;
-  case st_overfed:
+    /* There are two ways out of "overfed" state: either we find that we no
+     * longer have more memory than we need, in which case we default back to
+     * steady state; or we time out as per the general case described above,
+     * having had excess swap space for an entire timer period and therefore
+     * deallocating swap space.
+     */
-    if (unlikely(reqbytes >= 0)) state_to(st_steady);
-    break;