Changeset 397

Timestamp:

02/16/07 14:40:14 (16 years ago)

Author:

pieterpalmers

Message:

- make timestampedbuffer use floats instead of doubles
- change iso receive back to the efficient case

Files:

• branches/streaming-rework/src/libstreaming/AmdtpStreamProcessor.cpp (modified) (1 diff)
• branches/streaming-rework/src/libstreaming/cycletimer.h (modified) (5 diffs)
• branches/streaming-rework/src/libstreaming/IsoHandler.cpp (modified) (1 diff)
• branches/streaming-rework/src/libstreaming/IsoHandlerManager.cpp (modified) (2 diffs)
• branches/streaming-rework/src/libstreaming/StreamProcessor.cpp (modified) (2 diffs)
• branches/streaming-rework/src/libutil/TimestampedBuffer.cpp (modified) (6 diffs)
• branches/streaming-rework/src/libutil/TimestampedBuffer.h (modified) (1 diff)

branches/streaming-rework/src/libstreaming/AmdtpStreamProcessor.cpp

@@ -36 +36 @@
-#include <assert.h>
-
-0U
+TICKS_PER_CYCLE * 2
-
-// in ticks

branches/streaming-rework/src/libstreaming/cycletimer.h

@@ -46 +46 @@
-#define USECS_PER_CYCLE    (125U)
-
-
-
-
+L
+L
+L
-#define CYCLE_TIMER_TO_TICKS(x) ((CYCLE_TIMER_GET_SECS(x)   * TICKS_PER_SECOND) +\
-                                   (CYCLE_TIMER_GET_CYCLES(x) * TICKS_PER_CYCLE ) +\
@@ -73 +73 @@
-
-DECLARE_GLOBAL_DEBUG_MODULE;
+
+/**
+ * @brief Wraps x to the maximum number of ticks
+ *
+ * The input value is wrapped to the maximum value of the cycle
+ * timer, in ticks (128sec * 24576000 ticks/sec).
+ *
+ * @param x time to wrap
+ * @return wrapped time
+ */
+static inline uint32_t wrapAtMaxTicks(uint64_t x) {
+    if (x >= TICKS_PER_SECOND * 128L) {
+        x -= TICKS_PER_SECOND * 128L;
+    }
+
+#ifdef DEBUG
+        if (x >= TICKS_PER_SECOND * 128L) {
+            debugWarning("insufficient wrapping: %llu\n",x);
+        }
+#endif
+
+    return x;
+}
+
+/**
+ * @brief Wraps both at minimum and maximum value for ticks
+ * @param x value to wrap
+ * @return wrapped value
+ */
+static inline uint32_t wrapAtMinMaxTicks(int64_t x) {
+    
+    if (x < 0) {
+        x += TICKS_PER_SECOND * 128L;
+    } else if (x >= TICKS_PER_SECOND * 128L) {
+        x -= TICKS_PER_SECOND * 128L;
+    }
+
+#ifdef DEBUG
+        if (x >= TICKS_PER_SECOND * 128L) {
+            debugWarning("insufficient wrapping (max): %llu\n",x);
+        }
+        if (x < 0) {
+            debugWarning("insufficient wrapping (min): %lld\n",x);
+        }
+#endif
+    return x;
+
+}
+
+/**
+ * @brief Computes a difference between timestamps
+ *
+ * This function computes a difference between timestamps
+ * such that it respects wrapping.
+ *
+ * If x wraps around, but y doesn't, the result of x-y is 
+ * negative and very large. However the real difference is
+ * not large. It can be calculated by unwrapping x and then
+ * calculating x-y.
+ *
+ * @param x First timestamp 
+ * @param y Second timestamp
+ * @return the difference x-y, unwrapped
+ */
+static inline int32_t substractTicks(uint32_t x, uint32_t y) {
+    int64_t diff=(int64_t)x - (int64_t)y;
+    
+    // the maximal difference we allow (64secs)
+    const int64_t max=TICKS_PER_SECOND*64L;
+    
+    if(diff > max) {
+        // this means that y has wrapped, but
+        // x has not. we should unwrap y
+        // by adding TICKS_PER_SECOND*128L, meaning that we should substract
+        // this value from diff
+        diff -= TICKS_PER_SECOND*128L;
+    } else if (diff < -max) {
+        // this means that x has wrapped, but
+        // y has not. we should unwrap x
+        // by adding TICKS_PER_SECOND*128L, meaning that we should add
+        // this value to diff
+        diff += TICKS_PER_SECOND*128L;
+    }
+    
+    return (int32_t)diff;
+    
+}
+
+/**
+ * @brief Computes a sum of timestamps
+ *
+ * This function computes a sum of timestamps in ticks,
+ * wrapping the result if nescessary.
+ *
+ * @param x First timestamp 
+ * @param y Second timestamp
+ * @return the sum x+y, wrapped
+ */
+static inline uint32_t addTicks(uint32_t x, uint32_t y) {
+    uint64_t sum=x+y;
+
+    return wrapAtMaxTicks(sum);
+}
-
-/**
@@ -143 +246 @@
-    timestamp += CYCLE_TIMER_GET_OFFSET(syt_timestamp);
-    
-+= cc_seconds * TICKS_PER_SECOND
+= addTicks(timestamp, cc_seconds * TICKS_PER_SECOND)
-    
-    #ifdef DEBUG
@@ -229 +332 @@
-    timestamp += CYCLE_TIMER_GET_OFFSET(syt_timestamp);
-    
-+= cc_seconds * TICKS_PER_SECOND
+= addTicks(timestamp, cc_seconds * TICKS_PER_SECOND)
-    
-    #ifdef DEBUG
@@ -243 +346 @@
-
-/**
- * @brief Wraps x to the maximum number of ticks
- *
- * The input value is wrapped to the maximum value of the cycle
- * timer, in ticks (128sec * 24576000 ticks/sec).
- *
- * @param x time to wrap
- * @return wrapped time
- */
-static inline uint32_t wrapAtMaxTicks(uint64_t x) {
-    if (x >= TICKS_PER_SECOND * 128L) {
-        x -= TICKS_PER_SECOND * 128L;
-    }
-
-#ifdef DEBUG
-        if (x >= TICKS_PER_SECOND * 128L) {
-            debugWarning("insufficient wrapping: %llu\n",x);
-        }
-#endif
-
-    return x;
-}
-
-/**
- * @brief Wraps both at minimum and maximum value for ticks
- * @param x value to wrap
- * @return wrapped value
- */
-static inline uint32_t wrapAtMinMaxTicks(int64_t x) {
-    
-    if (x < 0) {
-        x += TICKS_PER_SECOND * 128L;
-    } else if (x >= TICKS_PER_SECOND * 128L) {
-        x -= TICKS_PER_SECOND * 128L;
-    }
-
-#ifdef DEBUG
-        if (x >= TICKS_PER_SECOND * 128L) {
-            debugWarning("insufficient wrapping (max): %llu\n",x);
-        }
-        if (x < 0) {
-            debugWarning("insufficient wrapping (min): %lld\n",x);
-        }
-#endif
-    return x;
-
-}
-
-/**
- * @brief Computes a difference between timestamps
- *
- * This function computes a difference between timestamps
- * such that it respects wrapping.
- *
- * If x wraps around, but y doesn't, the result of x-y is 
- * negative and very large. However the real difference is
- * not large. It can be calculated by unwrapping x and then
- * calculating x-y.
- *
- * @param x First timestamp 
- * @param y Second timestamp
- * @return the difference x-y, unwrapped
- */
-static inline int32_t substractTicks(uint32_t x, uint32_t y) {
-    int64_t diff=(int64_t)x - (int64_t)y;
-    
-    // the maximal difference we allow (64secs)
-    const int64_t max=TICKS_PER_SECOND*64L;
-    
-    if(diff > max) {
-        // this means that y has wrapped, but
-        // x has not. we should unwrap y
-        // by adding TICKS_PER_SECOND*128L, meaning that we should substract
-        // this value from diff
-        diff -= TICKS_PER_SECOND*128L;
-    } else if (diff < -max) {
-        // this means that x has wrapped, but
-        // y has not. we should unwrap x
-        // by adding TICKS_PER_SECOND*128L, meaning that we should add
-        // this value to diff
-        diff += TICKS_PER_SECOND*128L;
-    }
-    
-    return (int32_t)diff;
-    
-}
-
-/**
- * @brief Computes a sum of timestamps
- *
- * This function computes a sum of timestamps in ticks,
- * wrapping the result if nescessary.
- *
- * @param x First timestamp 
- * @param y Second timestamp
- * @return the sum x+y, wrapped
- */
-static inline uint32_t addTicks(uint32_t x, uint32_t y) {
-    uint64_t sum=x+y;
-
-    return wrapAtMaxTicks(sum);
-}
-
-/**
- * @brief Computes a difference between cycles
- *

branches/streaming-rework/src/libstreaming/IsoHandler.cpp

@@ -342 +342 @@
-        debugWarning("raw1394_read_cycle_timer: %s\n", strerror(err));
-    }
-
+(uint32_t)
-
-#else

branches/streaming-rework/src/libstreaming/IsoHandlerManager.cpp

@@ -35 +35 @@
-
-
-4
+2
-#define PACKETS_PER_INTERRUPT          4U
-
@@ -323 +323 @@
-                unsigned int packets_per_period=stream->getPacketsPerPeriod();
-                
-0
+1
-                // hardware interrupts occur when one DMA block is full, and the size of one DMA
-is
+
-                // occurs at a period boundary (optimal CPU use)
-                
-                // NOTE: try and use MINIMUM_INTERRUPTS_PER_PERIOD hardware interrupts
-                //       per period for better latency.
-MINIMUM_INTERRUPTS_PER_PERIOD * getpagesize(
+(MINIMUM_INTERRUPTS_PER_PERIOD * getpagesize()
-                if (max_packet_size < stream->getMaxPacketSize()) {
-                        max_packet_size=stream->getMaxPacketSize();

branches/streaming-rework/src/libstreaming/StreamProcessor.cpp

@@ -227 +227 @@
-    const int64_t max=(int64_t)(TICKS_PER_SECOND/2);
-    
-m_cycle_to_enable_at-
+(int64_t)m_cycle_to_enable_at-(int64_t)
-    
-    if (diff > max) {
@@ -236 +236 @@
-    
-    if (diff<0) {
-
+ll
-            diff,now_cycles,time_to_enable_at);
-    }

branches/streaming-rework/src/libutil/TimestampedBuffer.cpp

@@ -259 +259 @@
-    
-    // init the DLL
-double
-
-double
-double
+float
+
+float
+float
-
-    return true;
@@ -548 +548 @@
-    if (diff < 0) diff += m_wrap_at;
-    
-double
+float
-    
-    if (diff) {
-double)diff / (double
+float)diff / (float
-    } else {
-        rate=m_nominal_rate;
@@ -579 +579 @@
-    
-    m_dll_e2=m_update_period * m_nominal_rate;
-double
+float
-    
-    pthread_mutex_unlock(&m_framecounter_lock);    
@@ -639 +639 @@
-    if (diff < 0) diff += m_wrap_at;
-    
-double rate=(double)diff / (double
+float rate=(float)diff / (float
-    
-    int64_t timestamp;
@@ -709 +709 @@
-    if (diff < 0) diff += m_wrap_at;
-    
-double rate=(double)diff / (double
+float rate=(float)diff / (float
-        
-    int64_t ts=new_timestamp;
@@ -758 +758 @@
-    }
-    
-double
+float
-    
-    debugOutputShort(DEBUG_LEVEL_VERY_VERBOSE, "diff2=%lld err=%f\n",

branches/streaming-rework/src/libutil/TimestampedBuffer.h

@@ -172 +172 @@
-
-    // tracking DLL variables
-double
-double
-double
+float
+float
+float
-    
-    float m_nominal_rate;