Changeset 32568

Timestamp:

Oct 27, 2011, 9:59:21 AM (15 years ago)

Author:

eugene

Message:

adding linked list varient for pcontrol

Location:

branches/eam_branches/ipp-20110906/Ohana/src/opihi

Files:

• include/pcontrol.h (modified) (2 diffs)
• pcontrol/CheckIdleHost.c (modified) (1 diff)
• pcontrol/JobOps.c (modified) (1 diff)
• pcontrol/StackOpsLL.c (added)

branches/eam_branches/ipp-20110906/Ohana/src/opihi/include/pcontrol.h

@@ -152 +152 @@
 } Host;
 
+# if (USE_LLIST)
+typedef struct StackItem {
+    StackItem *next;
+    StackItem *prev;
+    void *object;
+    char *name;
+    int   id;
+} StackItem;
+
+/* the Jobs and Hosts are managed in a set of Stacks which define their state */
+typedef struct {
+    StackItem *head;
+    StackItem *tail; // use this?
+    int    Nobject;
+# ifdef THREADED    
+  pthread_mutex_t mutex;
+# endif
+} Stack;
+
+# else
+
 /* the Jobs and Hosts are managed in a set of Stacks which define their state */
 typedef struct {
@@ -163 +184 @@
 # endif
 } Stack;
+# endif
 
 /* XXX if this is hard-wired, we can't change shell name in StartHost */

branches/eam_branches/ipp-20110906/Ohana/src/opihi/pcontrol/CheckIdleHost.c

@@ -5 +5 @@
 // a (temporary?) work-around for the problem that the remote pclient job tends to grow
 // too large over time.
+
+/****
+     
+     queueing strategy:
+
+     We have a problem when the queue contains many jobs of different processing times.  If we
+     start with an equal number of jobs in two classes, fast and slow, eventually, we will end
+     up with all hosts running the slow jobs and the fast jobs completely blocked.  If J1 takes
+     T1 and J2 takes T2, and jobs have equal probability to land in a slot... ??
+
+     It seems like we should boost the probability of the fast jobs over the slow jobs (of
+     course, the end result of that will be all fast jobs draining and the slow jobs hanging
+     around).  
+
+     There is also a problem related to LAP, in that chip stage has a huge number of tasks in
+     the queue (effectively infinite).  Make the probability of the job being selected
+     proportional to something.  In any case, we need a user-controllable way to change the
+     probability of selection
+
+     As things are implemented below, the selection order depends on the queue order.  The
+     easiest way to modify the probabilities is to re-sort based on something.
+
+ ****/
 
 static float MAX_WANTHOST_WAIT = 10.0;

branches/eam_branches/ipp-20110906/Ohana/src/opihi/pcontrol/JobOps.c

@@ -270 +270 @@
   FREE (job);
 }
+
+void ResortJobStack (int StackID) {
+
+  Stack *stack = GetJobStack (StackID);
+  LockStack (stack);
+
+# define SWAPFUNC(A,B){ \
+  void *tmpObject = stack[0].object[A]; \
+  stack[0].object[A] = stack[0].object[B]; \
+  stack[0].object[B] = tmpObject; \
+  void *tmpName = stack[0].name[A]; \
+  stack[0].name[A] = stack[0].name[B]; \
+  stack[0].name[B] = tmpName; \
+  void *tmpID = stack[0].id[A]; \
+  stack[0].id[A] = stack[0].id[B]; \
+  stack[0].id[B] = tmpID; \
+}
+
+# define COMPARE(A,B)(((Job *)stack[0].object[A]).VALUE < ((Job *)stack[0].object[B]).VALUE)
+
+  OHANA_SORT (N, COMPARE, SWAPFUNC);
+
+# undef SWAPFUNC
+# undef COMPARE
+
+  UnlockStack (stack);
+}