Changeset 1071:6ca6cadf209c in freeDiameter

Timestamp:

May 2, 2013, 12:22:31 PM (11 years ago)

Author:

Sebastien Decugis <sdecugis@freediameter.net>

Branch:

default

Phase:

public

Message:

Implement the fd_stat_getstats function; changed prototype of fd_fifo_length.

Files:

• extensions/dbg_interactive/queues.i (modified) (1 diff)
• include/freeDiameter/libfdcore.h (modified) (2 diffs)
• include/freeDiameter/libfdproto.h (modified) (1 diff)
• libfdcore/fifo_stats.c (added)
• libfdproto/fifo.c (modified) (2 diffs)
• tests/testfifo.c (modified) (7 diffs)

extensions/dbg_interactive/queues.i

@@ -66 +66 @@
         /* Get the length of the queue (nb elements) */
         int length() {
-                int l;
-                int ret = fd_fifo_length ( $self, &l, NULL );
-                if (ret != 0) {
-                        DI_ERROR(ret, NULL, NULL);
-                }
-                return l;
+                return fd_fifo_length ( $self ) ;
         }
 

include/freeDiameter/libfdcore.h

@@ -1097 +1097 @@
  *  stat          : Which queue is being queried
  *  peer          : (depending on the stat parameter) which peer is being queried
- *  len           : (out) The number of items in the queue currently
- *  max           : (out) The max number of items the queue accepts before becoming blocking -- 0 means no max.
+ *  current_count : (out) The number of items in the queue currently
+ *  limit_count   : (out) The max number of items the queue accepts before becoming blocking -- 0 means no max.
  *  highest_count : (out) The highest count the queue has reached since startup
  *  total_count   : (out) Total number of items that this queue has processed (always growing, use deltas for monitoring)
@@ -1114 +1114 @@
  */
 int fd_stat_getstats(enum fd_stat_type stat, struct peer_hdr * peer, 
-                        int * len, int * max, int * highest_count, long long * total_count, 
+                        int * current_count, int * limit_count, int * highest_count, long long * total_count,
                         struct timespec * total, struct timespec * blocking, struct timespec * last);
 

include/freeDiameter/libfdproto.h

@@ -3032 +3032 @@
 
 /*
+ * FUNCTION:    fd_fifo_getstats
+ *
+ * PARAMETERS:
+ *  queue         : The queue from which to retrieve the information.
+ *  current_count : How many items in the queue at the time of execution. This changes each time an item is pushed or poped.
+ *  limit_count   : The maximum number of items allowed in this queue. This is specified during queue creation.
+ *  highest_count : The maximum number of items this queue has contained. This enables to see if limit_count count was reached.
+ *  total_count   : the total number of items that went through the queue (already pop'd). Always increasing.
+ *  total         : Cumulated time all items spent in this queue, including blocking time (always growing, use deltas for monitoring)
+ *  blocking      : Cumulated time threads trying to post new items were blocked (queue full).
+ *  last          : For the last element retrieved from the queue, how long it take between posting (including blocking) and poping
+ *  
+ * DESCRIPTION: 
+ *  Retrieve the timing information associated with a queue, for monitoring purpose.
+ *
+ * RETURN VALUE:
+ *  0           : The statistics have been updated.
+ *  EINVAL      : A parameter is invalid.
+ */
+int fd_fifo_getstats( struct fifo * queue, int * current_count, int * limit_count, int * highest_count, long long * total_count, 
+                                           struct timespec * total, struct timespec * blocking, struct timespec * last);
+
+/*
  * FUNCTION:    fd_fifo_length
  *
  * PARAMETERS:
  *  queue       : The queue from which to retrieve the number of elements.
- *  length      : Upon success, the current number of elements in the queue is stored here.
- *  max         : the maximum number of elements as specified during creation. Can be NULL.
- *
- * DESCRIPTION: 
- *  Retrieve the number of elements in a queue.
- *
- * RETURN VALUE:
- *  0           : The length of the queue has been written.
- *  EINVAL      : A parameter is invalid.
- */
-int fd_fifo_length ( struct fifo * queue, int * length, int * max);
-int fd_fifo_length_noerr ( struct fifo * queue ); /* no error checking version */
-
-/*
- * FUNCTION:    fd_fifo_getstats
- *
- * PARAMETERS:
- *  queue       : The queue from which to retrieve the timings information.
- *  items       : the total number of items that went through the queue (already pop'd). Always increasing.
- *  total       : Cumulated time all items spent in this queue, including blocking time (always growing, use deltas for monitoring)
- *  blocking    : Cumulated time threads trying to post new items were blocked (queue full).
- *  last        : For the last element retrieved from the queue, how long it take between posting (including blocking) and poping
- *  
- * DESCRIPTION: 
- *  Retrieve the timing information associated with a queue, for monitoring purpose.
- *
- * RETURN VALUE:
- *  0           : The statistics have been updated.
- *  EINVAL      : A parameter is invalid.
- */
-int fd_fifo_getstats( struct fifo * queue, long long *items, struct timespec * total, struct timespec * blocking, struct timespec * last);
-
+ *
+ * DESCRIPTION: 
+ *  Retrieve the number of elements in a queue, without error checking.
+ *
+ * RETURN VALUE:
+ *  The number of items currently queued.
+ */
+int fd_fifo_length ( struct fifo * queue );
 
 /*

libfdproto/fifo.c

@@ -284 +284 @@
 }
 
-/* Get the length of the queue */
-int fd_fifo_length ( struct fifo * queue, int * length, int * max )
-{
-        TRACE_ENTRY( "%p %p %p", queue, length, max );
+/* Get the information on the queue */
+int fd_fifo_getstats( struct fifo * queue, int * current_count, int * limit_count, int * highest_count, long long * total_count, 
+                                           struct timespec * total, struct timespec * blocking, struct timespec * last)
+{
+        TRACE_ENTRY( "%p %p %p %p %p %p %p %p", queue, current_count, limit_count, highest_count, total_count, total, blocking, last);
         
         /* Check the parameters */
-        CHECK_PARAMS( CHECK_FIFO( queue ) && length );
+        CHECK_PARAMS( CHECK_FIFO( queue ) );
         
         /* lock the queue */
         CHECK_POSIX(  pthread_mutex_lock( &queue->mtx )  );
         
-        /* Retrieve the count */
-        *length = queue->count;
-        
-        if (max)
-                *max = queue->max;
+        if (current_count)
+                *current_count = queue->count;
+        
+        if (limit_count)
+                *limit_count = queue->max;
+        
+        if (highest_count)
+                *highest_count = queue->highest_ever;
+        
+        if (total_count)
+                *total_count = queue->total_items;
+        
+        if (total)
+                memcpy(total, &queue->total_time, sizeof(struct timespec));
+        
+        if (blocking)
+                memcpy(blocking, &queue->blocking_time, sizeof(struct timespec));
+        
+        if (last)
+                memcpy(last, &queue->last_time, sizeof(struct timespec));
         
         /* Unlock */
@@ -308 +324 @@
 }
 
-/* Get the timings */
-int fd_fifo_getstats( struct fifo * queue, long long *items, struct timespec * total, struct timespec * blocking, struct timespec * last)
-{
-        TRACE_ENTRY( "%p %p %p %p %p", queue, items, total, blocking, last);
-        
-        /* Check the parameters */
-        CHECK_PARAMS( CHECK_FIFO( queue ) );
-        
-        /* lock the queue */
-        CHECK_POSIX(  pthread_mutex_lock( &queue->mtx )  );
-        
-        if (items)
-                *items = queue->total_items;
-        
-        if (total)
-                memcpy(total, &queue->total_time, sizeof(struct timespec));
-        
-        if (blocking)
-                memcpy(blocking, &queue->blocking_time, sizeof(struct timespec));
-        
-        if (last)
-                memcpy(last, &queue->last_time, sizeof(struct timespec));
-        
-        /* Unlock */
-        CHECK_POSIX(  pthread_mutex_unlock( &queue->mtx )  );
-        
-        /* Done */
-        return 0;
-}
-
 
 /* alternate version with no error checking */
-int fd_fifo_length_noerr ( struct fifo * queue )
+int fd_fifo_length ( struct fifo * queue )
 {
         if ( !CHECK_FIFO( queue ) )

tests/testfifo.c

@@ -217 +217 @@
         {
                 struct fifo * queue = NULL;
-                int count, max;
                 struct msg * msg  = NULL;
+                int max;
+                long long count;
                 
                 /* Create the queue */
@@ -224 +225 @@
                 
                 /* Check the count is 0 */
-                CHECK( 0, fd_fifo_length(queue, &count, &max) );
-                CHECK( 0, count);
-                CHECK( 0, max);
+                CHECK( 0, fd_fifo_length(queue) );
                 
                 /* Now enqueue */
@@ -237 +236 @@
                 
                 /* Check the count is 3 */
-                CHECK( 0, fd_fifo_length(queue, &count, &max) );
-                CHECK( 3, count);
-                CHECK( 0, max);
+                CHECK( 3, fd_fifo_length(queue) );
                 
                 /* Retrieve the first message using fd_fifo_get */
                 CHECK( 0, fd_fifo_get(queue, &msg) );
                 CHECK( msg1, msg);
-                CHECK( 0, fd_fifo_length(queue, &count, NULL) );
-                CHECK( 2, count);
+                CHECK( 2, fd_fifo_length(queue) );
                 
                 /* Retrieve the second message using fd_fifo_timedget */
@@ -252 +248 @@
                 CHECK( 0, fd_fifo_timedget(queue, &msg, &ts) );
                 CHECK( msg2, msg);
-                CHECK( 0, fd_fifo_length(queue, &count, NULL) );
-                CHECK( 1, count);
+                CHECK( 1, fd_fifo_length(queue) );
                 
                 /* Retrieve the third message using meq_tryget */
                 CHECK( 0, fd_fifo_tryget(queue, &msg) );
                 CHECK( msg3, msg);
-                CHECK( 0, fd_fifo_length(queue, &count, NULL) );
-                CHECK( 0, count);
+                CHECK( 0, fd_fifo_length(queue) );
                 
                 /* Check that another meq_tryget does not block */
                 CHECK( EWOULDBLOCK, fd_fifo_tryget(queue, &msg) );
-                CHECK( 0, fd_fifo_length(queue, &count, NULL) );
-                CHECK( 0, count);
+                CHECK( 0, fd_fifo_length(queue) );
                 
                 /* Check the timedget actually timesout */
@@ -274 +267 @@
                 }
                 CHECK( ETIMEDOUT, fd_fifo_timedget(queue, &msg, &ts) );
-                CHECK( 0, fd_fifo_length(queue, &count, NULL) );
-                CHECK( 0, count);
+                CHECK( 0, fd_fifo_length(queue) );
+                
+                /* Post & get another message */
+                msg = msg1;
+                CHECK( 0, fd_fifo_post(queue, &msg) );
+                CHECK( 0, fd_fifo_timedget(queue, &msg, &ts) );
+                CHECK( msg1, msg);              
+                
+                /* Check some statistics */
+                CHECK( 0, fd_fifo_getstats(queue, NULL, NULL, &max, &count, NULL, NULL, NULL) );
+                CHECK( 3, max );
+                CHECK( 4, count );      
                 
                 /* We're done for basic tests */
@@ -292 +295 @@
                 pthread_t                thr [NBR_THREADS * 2];
                 struct dict_object      *dwr_model = NULL;
-                int                      count;
                 int                      i;
                 int                      nbr_threads;
@@ -363 +365 @@
                 
                 /* Check the count of the queue is back to 0 */
-                CHECK( 0, fd_fifo_length(queue, &count, NULL) );
-                CHECK( 0, count);
+                CHECK( 0, fd_fifo_length(queue) );
                 
                 /* Destroy this queue and the messages */