Merge branch 'cooperative-computing-lab:master' into rename_vine_log

Author: JinZhou5042

dttools/src/debug.c

@@ -34,9 +34,11 @@ extern int debug_file_reopen(void);
 extern int debug_file_close(void);
 
 static void (*debug_write)(int64_t flags, const char *str) = debug_stderr_write;
-static pid_t (*debug_getpid)(void) = getpid;
+static pid_t (*debug_child_getpid)(void) = 0;
 static char debug_program_name[PATH_MAX];
 static int64_t debug_flags = D_NOTICE | D_ERROR | D_FATAL;
+static pid_t debug_cached_pid = 0;
+static int debug_time_zone_cached = 0;
 
 struct flag_info {
 	const char *name;
@@ -182,20 +184,37 @@ static void do_debug(int64_t flags, const char *fmt, va_list args)
 		gettimeofday(&tv, 0);
 		tm = localtime(&tv.tv_sec);
 
+		/*
+		If the TZ environment variable is not set, then every single call
+		to localtime() results in a stat("/etc/localtime") which impacts
+		the minimum latency of a debug event.
+		*/
+
+		if (!debug_time_zone_cached) {
+			if (!getenv("TZ")) {
+				setenv("TZ", tm->tm_zone, 0);
+			}
+			debug_time_zone_cached = 1;
+		}
+
+		/* Fetch the pid just once and use it multiple times. */
+		pid_t pid = getpid();
+
 		buffer_putfstring(&B,
-				"%04d/%02d/%02d %02d:%02d:%02d.%02ld ",
+				"%04d/%02d/%02d %02d:%02d:%02d.%02ld %s[%d]",
 				tm->tm_year + 1900,
 				tm->tm_mon + 1,
 				tm->tm_mday,
 				tm->tm_hour,
 				tm->tm_min,
 				tm->tm_sec,
-				(long)tv.tv_usec / 10000);
-		buffer_putfstring(&B, "%s[%d] ", debug_program_name, getpid());
+				(long)tv.tv_usec / 10000,
+				debug_program_name,
+				pid);
 	}
 	/* Parrot prints debug messages for children: */
-	if (getpid() != debug_getpid()) {
-		buffer_putfstring(&B, "<child:%d> ", (int)debug_getpid());
+	if (debug_child_getpid) {
+		buffer_putfstring(&B, "<child:%d> ", (int)debug_child_getpid());
 	}
 	buffer_putfstring(&B, "%s: ", debug_flags_to_name(flags));
 
@@ -309,16 +328,17 @@ void debug_config_file(const char *path)
 void debug_config(const char *name)
 {
 	strncpy(debug_program_name, path_basename(name), sizeof(debug_program_name) - 1);
+	debug_cached_pid = getpid();
 }
 
 void debug_config_file_size(off_t size)
 {
 	debug_file_size(size);
 }
 
-void debug_config_getpid(pid_t (*getpidf)(void))
+void debug_config_child_getpid(pid_t (*getpidf)(void))
 {
-	debug_getpid = getpidf;
+	debug_child_getpid = getpidf;
 }
 
 int64_t debug_flags_clear()

dttools/src/debug.h

@@ -124,7 +124,7 @@ modify the linker namespace we are using.
 #define debug_config_file      cctools_debug_config_file
 #define debug_config_file_size cctools_debug_config_file_size
 #define debug_config_fatal     cctools_debug_config_fatal
-#define debug_config_getpid    cctools_debug_config_getpid
+#define debug_config_child_getpid    cctools_debug_config_child_getpid
 #define debug_flags_set        cctools_debug_flags_set
 #define debug_flags_print      cctools_debug_flags_print
 #define debug_flags_clear      cctools_debug_flags_clear
@@ -206,7 +206,7 @@ void debug_config_file_size(off_t size);
 
 void debug_config_fatal(void (*callback) (void));
 
-void debug_config_getpid (pid_t (*getpidf)(void));
+void debug_config_child_getpid (pid_t (*getpidf)(void));
 
 /** Set debugging flags to enable output.
 Accepts a debug flag in ASCII form, and enables that subsystem.  For example: <tt>debug_flags_set("chirp");</tt>

dttools/src/priority_queue.c

@@ -13,8 +13,6 @@ See the file COPYING for details.
 #include <float.h>
 
 #define DEFAULT_CAPACITY 127
-#define MAX_PRIORITY DBL_MAX
-#define MIN_PRIORITY DBL_MIN
 
 struct element {
 	void *data;
@@ -27,8 +25,8 @@ struct priority_queue {
 	struct element **elements;
 
 	/* The following three cursors are used to iterate over the elements in the numerical order they are stored in the array, which is
-	   different from the order of priorities.  Each of them has different concerns when traverse the queue Though the tipical priority-based
-	   traversal is done by the repeated invocation of priority_queue_peak_top and priority_queue_pop APIs, rather than using any cursors. */
+	   different from the order of priorities.  Each of them has different concerns when traverse the queue Though the typical priority-based
+	   traversal is done by the repeated invocation of priority_queue_peek_top and priority_queue_pop APIs, rather than using any cursors. */
 	int base_cursor;   // Used in PRIORITY_QUEUE_BASE_ITERATE. It iterates from the first position and never be reset automatically.
 	int static_cursor; // Used in PRIORITY_QUEUE_STATIC_ITERATE. It iterates from the last position and never be reset automatically.
 	int rotate_cursor; // Used in PRIORITY_QUEUE_ROTATE_ITERATE. It iterates from the last position and can be reset when certain events happen.
@@ -101,7 +99,7 @@ static int priority_queue_double_capacity(struct priority_queue *pq)
 
 /****** External Methods ******/
 
-struct priority_queue *priority_queue_create(double init_capacity)
+struct priority_queue *priority_queue_create(int init_capacity)
 {
 	struct priority_queue *pq = (struct priority_queue *)malloc(sizeof(struct priority_queue));
 	if (!pq) {
@@ -142,17 +140,17 @@ int priority_queue_size(struct priority_queue *pq)
 int priority_queue_push(struct priority_queue *pq, void *data, double priority)
 {
 	if (!pq) {
-		return 0;
+		return -1;
 	}
 
 	if (pq->size >= pq->capacity) {
 		if (!priority_queue_double_capacity(pq)) {
-			return 0;
+			return -1;
 		}
 	}
 	struct element *e = (struct element *)malloc(sizeof(struct element));
 	if (!e) {
-		return 0;
+		return -1;
 	}
 	e->data = data;
 	e->priority = priority;
@@ -185,7 +183,7 @@ void *priority_queue_pop(struct priority_queue *pq)
 	return data;
 }
 
-void *priority_queue_peak_top(struct priority_queue *pq)
+void *priority_queue_peek_top(struct priority_queue *pq)
 {
 	if (!pq || pq->size == 0) {
 		return NULL;
@@ -203,7 +201,7 @@ double priority_queue_get_priority(struct priority_queue *pq, int idx)
 	return pq->elements[idx]->priority;
 }
 
-void *priority_queue_peak_at(struct priority_queue *pq, int idx)
+void *priority_queue_peek_at(struct priority_queue *pq, int idx)
 {
 	if (!pq || pq->size < 1 || idx < 0 || idx > pq->size - 1) {
 		return NULL;
@@ -215,7 +213,7 @@ void *priority_queue_peak_at(struct priority_queue *pq, int idx)
 int priority_queue_update_priority(struct priority_queue *pq, void *data, double new_priority)
 {
 	if (!pq) {
-		return 0;
+		return -1;
 	}
 
 	int idx = -1;
@@ -226,8 +224,9 @@ int priority_queue_update_priority(struct priority_queue *pq, void *data, double
 		}
 	}
 
+	/* If the data isn’t already in the queue, enqueue it. */
 	if (idx == -1) {
-		return 0;
+		return priority_queue_push(pq, data, new_priority);
 	}
 
 	double old_priority = pq->elements[idx]->priority;
@@ -247,7 +246,7 @@ int priority_queue_update_priority(struct priority_queue *pq, void *data, double
 int priority_queue_find_idx(struct priority_queue *pq, void *data)
 {
 	if (!pq) {
-		return 0;
+		return -1;
 	}
 
 	for (int i = 0; i < pq->size; i++) {
@@ -256,13 +255,13 @@ int priority_queue_find_idx(struct priority_queue *pq, void *data)
 		}
 	}
 
-	return 0;
+	return -1;
 }
 
 int priority_queue_static_next(struct priority_queue *pq)
 {
 	if (!pq || pq->size == 0) {
-		return 0;
+		return -1;
 	}
 
 	int static_idx = pq->static_cursor;
@@ -291,7 +290,7 @@ Advance the base cursor and return it, should be used only in PRIORITY_QUEUE_BAS
 int priority_queue_base_next(struct priority_queue *pq)
 {
 	if (!pq || pq->size == 0) {
-		return 0;
+		return -1;
 	}
 
 	int base_idx = pq->base_cursor;
@@ -316,7 +315,7 @@ void priority_queue_rotate_reset(struct priority_queue *pq)
 int priority_queue_rotate_next(struct priority_queue *pq)
 {
 	if (!pq || pq->size == 0) {
-		return 0;
+		return -1;
 	}
 
 	int rotate_idx = pq->rotate_cursor;
@@ -335,26 +334,40 @@ int priority_queue_remove(struct priority_queue *pq, int idx)
 		return 0;
 	}
 
-	struct element *e = pq->elements[idx];
-	pq->size--;
-	pq->elements[idx] = pq->elements[pq->size];
-	pq->elements[pq->size] = NULL;
+	struct element *to_delete = pq->elements[idx];
+	struct element *last_elem = pq->elements[pq->size - 1];
+
+	double old_priority = to_delete->priority;
+	double new_priority = last_elem->priority;
 
-	sink(pq, idx);
+	free(to_delete);
 
-	if (pq->static_cursor == idx) {
+	pq->size--;
+	if (idx != pq->size) {
+		pq->elements[idx] = last_elem;
+		pq->elements[pq->size] = NULL;
+
+		if (new_priority > old_priority) {
+			swim(pq, idx);
+		} else if (new_priority < old_priority) {
+			sink(pq, idx);
+		}
+	} else {
+		pq->elements[pq->size] = NULL;
+	}
+
+	if (pq->static_cursor == idx && pq->static_cursor > 0) {
 		pq->static_cursor--;
 	}
-	if (pq->base_cursor == idx) {
+	if (pq->base_cursor == idx && pq->base_cursor > 0) {
 		pq->base_cursor--;
 	}
-	if (pq->rotate_cursor == idx) {
+	if (pq->rotate_cursor == idx && pq->rotate_cursor > 0) {
 		pq->rotate_cursor--;
 	}
-	free(e);
 
+	// reset the rotate cursor if the removed element is before/equal to it
 	if (idx <= pq->rotate_cursor) {
-		// reset the rotate cursor if the removed element is before/equal to it
 		priority_queue_rotate_reset(pq);
 	}
 
@@ -368,7 +381,9 @@ void priority_queue_delete(struct priority_queue *pq)
 	}
 
 	for (int i = 0; i < pq->size; i++) {
-		free(pq->elements[i]);
+		if (pq->elements[i]) {
+			free(pq->elements[i]);
+		}
 	}
 	free(pq->elements);
 	free(pq);

dttools/src/priority_queue.h

@@ -64,13 +64,13 @@ void *data = someDataPointer;
 
 priority_queue_push(pq, data, priority);
 data = priority_queue_pop(pq);
-void *headData = priority_queue_peak_top(pq);
+void *headData = priority_queue_peek_top(pq);
 </pre>
 
 To list all of the items in a priority queue, use a simple loop:
 <pre>
 for (int i = 0; i < priority_queue_size(pq); i++) {
-    void *data = priority_queue_peak_at(pq, i);
+    void *data = priority_queue_peek_at(pq, i);
     printf("Priority queue contains: %p\n", data);
 }
 </pre>
@@ -94,7 +94,7 @@ Element with a higher priority is at the top of the heap.
 @param init_capacity The initial number of elements in the queue. If zero, a default value will be used.
 @return A pointer to a new priority queue.
 */
-struct priority_queue *priority_queue_create(double init_capacity);
+struct priority_queue *priority_queue_create(int init_capacity);
 
 /** Count the elements in a priority queue.
 @param pq A pointer to a priority queue.
@@ -122,15 +122,15 @@ Similar to @ref priority_queue_pop, but the element is not removed.
 @param pq A pointer to a priority queue.
 @return The pointer to the top of the queue if any, failure otherwise
 */
-void *priority_queue_peak_top(struct priority_queue *pq);
+void *priority_queue_peek_top(struct priority_queue *pq);
 
 /** Get an element from a priority queue by a specified index.
 The first accessible element is at index 0.
 @param pq A pointer to a priority queue.
 @param index The index of the element to get.
 @return The pointer to the element if any, failure otherwise
 */
-void *priority_queue_peak_at(struct priority_queue *pq, int index);
+void *priority_queue_peek_at(struct priority_queue *pq, int index);
 
 /** Get the priority of an element at a specified index.
 @param pq A pointer to a priority queue.
@@ -150,15 +150,15 @@ int priority_queue_update_priority(struct priority_queue *pq, void *data, double
 /** Find the index of an element in a priority queue.
 @param pq A pointer to a priority queue.
 @param data The pointer to the element to find.
-@return The index of the element if found, 0 on failure.
+@return The index of the element if found, -1 on failure.
 */
 int priority_queue_find_idx(struct priority_queue *pq, void *data);
 
 /** Advance the static_cursor to the next element and return the index.
 The static_cursor is used to globally iterate over the elements by sequential index.
 The position of the static_cursor is automatically remembered and never reset.
 @param pq A pointer to a priority queue.
-@return The index of the next element if any, 0 on failure.
+@return The index of the next element if any, -1 on failure.
 */
 int priority_queue_static_next(struct priority_queue *pq);
 
@@ -170,7 +170,7 @@ void priority_queue_base_reset(struct priority_queue *pq);
 
 /** Advance the base_cursor to the next element and return the index.
 @param pq A pointer to a priority queue.
-@return The index of the next element if any, 0 on failure.
+@return The index of the next element if any, -1 on failure.
 */
 int priority_queue_base_next(struct priority_queue *pq);
 
@@ -185,7 +185,7 @@ void priority_queue_rotate_reset(struct priority_queue *pq);
 
 /** Advance the rotate_cursor to the next element and return the index.
 @param pq A pointer to a priority queue.
-@return The index of the next element if any, 0 on failure.
+@return The index of the next element if any, -1 on failure.
 */
 int priority_queue_rotate_next(struct priority_queue *pq);
 
@@ -235,16 +235,16 @@ PRIORITY_QUEUE_ROTATE_ITERATE( pq, idx, data, iter_count, iter_depth ) {
 #define PRIORITY_QUEUE_BASE_ITERATE( pq, idx, data, iter_count, iter_depth ) \
     iter_count = 0; \
     priority_queue_base_reset(pq); \
-    while ((iter_count < iter_depth) && ((idx = priority_queue_base_next(pq)) >= 0) && (data = priority_queue_peak_at(pq, idx)) && (iter_count += 1))
+    while ((iter_count < iter_depth) && ((idx = priority_queue_base_next(pq)) >= 0) && (data = priority_queue_peek_at(pq, idx)) && (iter_count += 1))
 
 /* Iterate from last position, never reset. */
 #define PRIORITY_QUEUE_STATIC_ITERATE( pq, idx, data, iter_count, iter_depth ) \
     iter_count = 0; \
-    while ((iter_count < iter_depth) && ((idx = priority_queue_static_next(pq)) >= 0) && (data = priority_queue_peak_at(pq, idx)) && (iter_count += 1))
+    while ((iter_count < iter_depth) && ((idx = priority_queue_static_next(pq)) >= 0) && (data = priority_queue_peek_at(pq, idx)) && (iter_count += 1))
 
 /* Iterate from last position, reset to the begining when needed. */
 #define PRIORITY_QUEUE_ROTATE_ITERATE( pq, idx, data, iter_count, iter_depth ) \
     iter_count = 0; \
-    while ((iter_count < iter_depth) && ((idx = priority_queue_rotate_next(pq)) >= 0) && (data = priority_queue_peak_at(pq, idx)) && (iter_count += 1))
+    while ((iter_count < iter_depth) && ((idx = priority_queue_rotate_next(pq)) >= 0) && (data = priority_queue_peek_at(pq, idx)) && (iter_count += 1))
 
 #endif