Changeset 393

Timestamp:

02/13/07 09:22:14 (16 years ago)

Author:

pieterpalmers

Message:

- fixed some bugs in the timestampedbuffer
- cleaned up the amdtpstreamprocessor
- updated test-sytmonitor and test-cycletimer

to the new threading structure

- implemented test for timestampedbuffer

Files:

• branches/streaming-rework/src/libstreaming/AmdtpStreamProcessor.cpp (modified) (24 diffs)
• branches/streaming-rework/src/libstreaming/cycletimer.h (modified) (2 diffs)
• branches/streaming-rework/src/libutil/TimestampedBuffer.cpp (modified) (10 diffs)
• branches/streaming-rework/tests/test-cycletimer.cpp (modified) (6 diffs)
• branches/streaming-rework/tests/test-sytmonitor.cpp (modified) (5 diffs)
• branches/streaming-rework/tests/test-timestampedbuffer.cpp (modified) (15 diffs)

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

@@ -91 +91 @@
-    
-    struct iec61883_packet *packet = (struct iec61883_packet *) data;
-    unsigned int nevents=0;
-    
-    m_last_cycle=cycle;
@@ -103 +102 @@
-    }
-#endif
+    
+    // calculate & preset common values
-    
-    /* Our node ID can change after a bus reset, so it is best to fetch
@@ -116 +117 @@
-    packet->eoh1 = 2;
-    packet->fmt = IEC61883_FMT_AMDTP;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-    
-    // determine if we want to send a packet or not
@@ -166 +131 @@
-    // the difference between 'now' and the cycle this
-    // packet is intended for
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    
-#ifdef DEBUG
@@ -189 +139 @@
-    }
-#endif
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    // we send a packet some cycles in advance, to avoid the
@@ -212 +220 @@
-    // packet is sent, unless TRANSFER_DELAY > 3072.
-    // this means that we need at least one cycle of extra buffering.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-#ifdef DEBUG
@@ -253 +238 @@
-            timestamp, cycle_timer, fc
-            );
-, UTN2=%11lld
-, utn2
+
+
-            );
+        debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "    CY_NOW=%04d, CY_TARGET=%04d, CY_DIFF=%04d\n",
+            now_cycles, cycle, cycle_diff
+            );
-    }
-#endif
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    // don't process the stream when it is not enabled, not running
-    // or when the next sample is not due yet.
@@ -338 +252 @@
-    // we do have to generate (semi) valid packets
-    // that means that we'll send NODATA packets.
-    // we don't add payload because DICE devices don't like that.
-    if((until_next>0) || m_is_disabled || !m_running) {
-        // no-data packets have syt=0xFFFF
@@ -345 +258 @@
-        packet->syt = 0xffff;
-        
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        m_dbc += m_syt_interval;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-        *length = nevents*sizeof(quadlet_t)*m_dimension + 8;
-
@@ -377 +300 @@
-        }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-        debugWarning("Transmit buffer underrun (now %d, queue %d, target %d)\n", 
-                 now_cycles, cycle, TICKS_TO_CYCLES(ts));
-
-        nevents=0;
-
-        // TODO: we have to be a little smarter here
-        //       because we have some slack on the device side (TRANSFER_DELAY)
-        //       we can allow some skipped packets
-        // signal underrun
-        m_xruns++;
@@ -426 +323 @@
-        // compose a no-data packet, we should always
-        // send a valid packet
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-        return RAW1394_ISO_DEFER;
@@ -462 +366 @@
-
-bool AmdtpTransmitStreamProcessor::prefill() {
+
+    debugOutput( DEBUG_LEVEL_VERBOSE, "Prefill transmit buffers...\n");
+    
-    if(!transferSilence(m_ringbuffer_size_frames)) {
-        debugFatal("Could not prefill transmit stream\n");
-        return false;
-    }
-
-    // when the buffer is prefilled, we should
-    // also initialize the base timestamp
-    // this base timestamp is the timestamp of the
-    // last buffer transfer.
-//     uint64_t ts;
-//     uint64_t fc;
-//     m_SyncSource->m_data_buffer->getBufferHeadTimestamp(&ts, &fc); // thread safe
-
-    // update the frame counter such that it reflects the buffer content,
-    // the buffer tail timestamp is initialized when the SP is enabled
-    // done in the SP base class
-//     if (!StreamProcessor::putFrames(m_ringbuffer_size_frames, ts)) {
-//         debugError("Could not do StreamProcessor::putFrames(%d, %011llu)\n",
-//             m_ringbuffer_size_frames,ts);
-//         return false;
-//     }
-
-    return true;
@@ -678 +568 @@
-        return false;
-    }
-
-
-
-
-
-
-
-
-
-
-
-
+
-    debugOutput( DEBUG_LEVEL_VERBOSE, "Prepared for:\n");
-    debugOutput( DEBUG_LEVEL_VERBOSE, " Samplerate: %d, FDF: %d, DBS: %d, SYT: %d\n",
@@ -752 +631 @@
-    m_PeriodStat.mark(m_data_buffer->getBufferFill());
-    
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-    m_data_buffer->blockProcessWriteFrames(nbframes, ts);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-
-    return true;
@@ -1050 +906 @@
-        m_running,m_disabled,m_is_disabled);
-
-
+
+
+
+
+
+
-        unsigned int nevents=((length / sizeof (quadlet_t)) - 2)/packet->dbs;
-
@@ -1056 +917 @@
-        m_last_timestamp2=m_last_timestamp;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-        
-        // we have to keep in mind that there are also
-
+,
-        // at most x=m_handler->getWakeupInterval()
-        // these contain at most x*syt_interval
@@ -1130 +939 @@
-        
-        // the receive processing delay indicates how much
-need
+use
-        m_last_timestamp += RECEIVE_PROCESSING_DELAY;
-        
-        // wrap if nescessary
-
-
-
+
-        
-        //=> now estimate the device frame rate
@@ -1156 +963 @@
-            float f=measured_difference;
-            float err = f / (1.0*m_syt_interval) - m_ticks_per_frame;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-            // integrate the error
-            m_ticks_per_frame += RECEIVE_DLL_INTEGRATION_COEFFICIENT*err;
-            
-        }
-        
-         debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"R-SYT for cycle (%2d %2d)=>%2d: %5uT (%04uC + %04uT) %04X %04X %d\n",
-            cycle,now_cycle_masked,delta_cycles,
-            (m_last_timestamp),
-            TICKS_TO_CYCLES(m_last_timestamp),
-            TICKS_TO_OFFSET(m_last_timestamp),
-            ntohs(packet->syt),TICKS_TO_CYCLE_TIMER(m_last_timestamp)&0xFFFF, dropped
-         );
-
-        //=> signal that we're running (if we are)
@@ -1200 +983 @@
-                // the previous timestamp is the one we need to start with
-                // because we're going to update the buffer again this loop
+                // using writeframes
-                m_data_buffer->setBufferTailTimestamp(m_last_timestamp2);
-
+
-            } else {
-
+
+
+
-            }
-        } else if (m_disabled && !m_is_disabled) {
@@ -1223 +1009 @@
-            
-            // wrap if nescessary
-if (ts >= TICKS_PER_SECOND * 128L) {
-
-}
-set the timestamps
+ts=wrapAtMaxTicks(ts);
+
+// set the timestamp as if there will be a sample put into
+the buffer by the next packet.
-            m_data_buffer->setBufferTailTimestamp(ts);
-            
@@ -1257 +1043 @@
-
-            retval=RAW1394_ISO_DEFER;
-            
-        }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-    return retval;
-}
@@ -1292 +1054 @@
-    uint64_t cycle_timer=m_handler->getCycleTimerTicks();
-    
-
-
-
-
+
+
-    
-    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "=> TAP=%11llu, CTR=%11llu, UTN=%11lld, TPUS=%f\n",
-        time_at_period, cycle_timer, until_next, m_handler->getTicksPerUsec()
-        );
-        
-    if(until_next > max) {
-        // this means that cycle_timer has wrapped, but
-        // time_at_period has not. we should unwrap cycle_timer
-        // by adding TICKS_PER_SECOND*128L, meaning that we should substract
-        // this value from until_next            
-        until_next -= TICKS_PER_SECOND*128L;
-    } else if (until_next < -max) {
-        // this means that time_at_period has wrapped, but
-        // cycle_timer has not. we should unwrap time_at_period
-        // by adding TICKS_PER_SECOND*128L, meaning that we should add
-        // this value from until_next
-        until_next += TICKS_PER_SECOND*128L;
-    }
-    
-    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "   TAP=%11llu, CTR=%11llu, UTN=%11lld, TPUS=%f\n",
-        time_at_period, cycle_timer, until_next, m_handler->getTicksPerUsec()
-        );
@@ -1375 +1117 @@
-        next_period_boundary, m_last_timestamp, fc, m_ticks_per_frame
-        );
-
-
+
+
+
-    // frames in the buffer. We should add the wraparound value of the ticks
-    // counter
-
-
-
-
+
+
+
-    // m_framecounter is low.
-    // this means: m_last_timestamp is near wrapping and have just had
-    // a getPackets() from the client side. the projected next_period
-    // boundary lies beyond the wrap value.
+    
-    // the action is to wrap the value.
-
-
-
-
-
-
-
-
+
+
-    return next_period_boundary;
-}
@@ -1611 +1348 @@
-    m_data_buffer->blockProcessReadFrames(nbframes);
-
-    // update the frame counter such that it reflects the new value,
-    // done in the SP base class
-/*    
-    if (!StreamProcessor::getFrames(nbframes)) {
-        debugError("Could not do StreamProcessor::getFrames(%d)\n", nbframes);
-        return false;
-    }*/
-
-    return true;
-}

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

@@ -31 +31 @@
-#ifndef __CYCLETIMER_H__
-#define __CYCLETIMER_H__
+
+#include <inttypes.h>
+#include "debugmodule/debugmodule.h"
-
-#define CSR_CYCLE_TIME            0x200
@@ -69 +72 @@
-#define CYCLE_TIMER_WRAP_TICKS(x) ((x % TICKS_PER_SECOND))
-
+DECLARE_GLOBAL_DEBUG_MODULE;
+
+/**
+ * @brief Converts a SYT timestamp to a full timestamp in ticks.
+ *
+ * 
+ *
+ * @param syt_timestamp The SYT timestamp as present in the packet
+ * @param rcv_cycle The cycle this timestamp was received on
+ * @param ctr_now The current value of the cycle timer ('now')
+ * @return 
+ */
+static inline uint32_t sytToFullTicks(uint32_t syt_timestamp, unsigned int rcv_cycle, uint32_t ctr_now) {
+    uint32_t timestamp;
+    
+    // reconstruct the full cycle
+    uint32_t cc_cycles=CYCLE_TIMER_GET_CYCLES(ctr_now);
+    uint32_t cc_seconds=CYCLE_TIMER_GET_SECS(ctr_now);
+    
+    // the cycletimer has wrapped since this packet was received
+    // we want cc_seconds to reflect the 'seconds' at the point this 
+    // was received
+    if (rcv_cycle>cc_cycles) {
+        if (cc_seconds) {
+            cc_seconds--;
+        } else {
+            // seconds has wrapped around, so we'd better not substract 1
+            // the good value is 127
+            cc_seconds=127;
+        }
+    }
+    
+    // reconstruct the top part of the timestamp using the current cycle number
+    uint32_t rcv_cycle_masked=rcv_cycle & 0xF;
+    uint32_t syt_cycle=CYCLE_TIMER_GET_CYCLES(syt_timestamp);
+    
+    // if this is true, wraparound has occurred, undo this wraparound
+    if(syt_cycle<rcv_cycle_masked) syt_cycle += 0x10;
+    
+    // this is the difference in cycles wrt the cycle the
+    // timestamp was received
+    uint32_t delta_cycles=syt_cycle-rcv_cycle_masked;
+    
+    // reconstruct the cycle part of the timestamp
+    uint32_t new_cycles=rcv_cycle + delta_cycles;
+    
+    // if the cycles cause a wraparound of the cycle timer,
+    // perform this wraparound
+    // and convert the timestamp into ticks
+    if(new_cycles<8000) {
+        timestamp  = new_cycles * TICKS_PER_CYCLE;
+    } else {
+        debugOutput(DEBUG_LEVEL_VERY_VERBOSE,
+            "Detected wraparound: %d + %d = %d\n",
+            rcv_cycle,delta_cycles,new_cycles);
+        
+        new_cycles-=8000; // wrap around
+#ifdef DEBUG
+        if (new_cycles >= 8000) {
+            debugWarning("insufficient unwrapping\n");
+        }
+#endif
+        timestamp  = new_cycles * TICKS_PER_CYCLE;
+        // add one second due to wraparound
+        timestamp += TICKS_PER_SECOND;
+    }
+    
+    timestamp += CYCLE_TIMER_GET_OFFSET(syt_timestamp);
+    timestamp += cc_seconds * TICKS_PER_SECOND;
+    return timestamp;
+}
+
+/**
+ * @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
+ *
+ * This function computes a difference between cycles
+ * such that it respects wrapping (at 8000 cycles).
+ *
+ * See substractTicks
+ *
+ * @param x First cycle value 
+ * @param y Second cycle value
+ * @return the difference x-y, unwrapped
+ */
+static inline int substractCycles(unsigned int x, unsigned int y) {
+    int diff = x - y;
+    
+    // the maximal difference we allow (64secs)
+    const int max=CYCLES_PER_SECOND/2;
+    
+    if(diff > max) {
+        diff -= CYCLES_PER_SECOND;
+    } else if (diff < -max) {
+        diff += CYCLES_PER_SECOND;
+    }
+    
+    return diff;
+}
+
-#endif // __CYCLETIMER_H__

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

@@ -524 +524 @@
-void TimestampedBuffer::setBufferTailTimestamp(uint64_t new_timestamp) {
-    
+#ifdef DEBUG
+    if (new_timestamp >= 128L*TICKS_PER_SECOND) {
+        debugWarning("timestamp not wrapped: %llu\n",new_timestamp);
+    }
+#endif
+    
-    pthread_mutex_lock(&m_framecounter_lock);
-    
@@ -533 +539 @@
-    pthread_mutex_unlock(&m_framecounter_lock);    
-    
-
+Y_VER
-                this, new_timestamp, m_buffer_next_tail_timestamp, m_dll_e2);
-
@@ -549 +555 @@
- */
-void TimestampedBuffer::getBufferHeadTimestamp(uint64_t *ts, uint64_t *fc) {
-
-
+
+
+
+
-    
-    int64_t timestamp;
@@ -560 +568 @@
-    //         (m_buffer_next_tail_timestamp - m_buffer_tail_timestamp)/(samples_between_updates)*(x)
-    
--1
+
-    timestamp=(int64_t)m_buffer_tail_timestamp - (int64_t)((m_framecounter) * rate);
-
-    pthread_mutex_unlock(&m_framecounter_lock);
-    
-
-
+
+
+
+
+
+
+
-    
-    if(timestamp >= (int64_t)m_wrap_at) {
@@ -576 +589 @@
-    *ts=timestamp;
-    
-
-
+
+
+
+
+
+
-
-}
@@ -593 +610 @@
-void TimestampedBuffer::getBufferTailTimestamp(uint64_t *ts, uint64_t *fc) {
-    pthread_mutex_lock(&m_framecounter_lock);
-
+(uint64_t)
-    *ts = m_buffer_tail_timestamp;
-    pthread_mutex_unlock(&m_framecounter_lock);
@@ -627 +644 @@
- */
-void TimestampedBuffer::incrementFrameCounter(int nbframes, uint64_t new_timestamp) {
-
+Y_VER
-                this, new_timestamp);
+    
+#ifdef DEBUG
+    if (new_timestamp >= 128L*TICKS_PER_SECOND) {
+        debugWarning("timestamp not wrapped: %llu\n",new_timestamp);
+    }
+#endif
-    
-    pthread_mutex_lock(&m_framecounter_lock);
@@ -662 +685 @@
-    m_buffer_next_tail_timestamp += (uint64_t)(m_dll_b * err + m_dll_e2);
-    
+    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "U: FC=%10u, TS=%011llu, NTS=%011llu\n",
+                    m_framecounter, m_buffer_tail_timestamp, m_buffer_next_tail_timestamp);
+    
-    if (m_buffer_next_tail_timestamp >= m_wrap_at) {
-        m_buffer_next_tail_timestamp -= m_wrap_at;
@@ -671 +697 @@
-    m_dll_e2 += m_dll_c*err;
-    
-
+Y_VER
-                m_buffer_tail_timestamp, m_buffer_next_tail_timestamp, m_dll_e2);
-    
@@ -706 +732 @@
-    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Buffer tail timestamp : %011llu\n",m_buffer_tail_timestamp);
-    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Head - Tail           : %011lld\n",diff);
-l
+
-}
-

branches/streaming-rework/tests/test-cycletimer.cpp

@@ -158 +158 @@
-    }
-    
+    int32_t subs;
+    subs=substractTicks(10, 8);
+    if (subs != 2) {
+         debugOutput(DEBUG_LEVEL_NORMAL, "  substractTicks(10, 8) != 2 : %ld\n",
+            subs);
+        failures++;   
+    }
+    
+    subs=substractTicks(10, 12);
+    if (subs != -2) {
+         debugOutput(DEBUG_LEVEL_NORMAL, "  substractTicks(10, 12) != -2 : %ld\n",
+            subs);
+        failures++;   
+    }
+    
+    subs=substractTicks(TICKS_PER_SECOND*128L + 10, 8);
+    if (subs != 2) {
+         debugOutput(DEBUG_LEVEL_NORMAL, "  substractTicks(TICKS_PER_SECOND*128L + 10, 8) != 2 : %ld\n",
+            subs);
+        failures++;   
+    }
+    
+    subs=substractTicks(TICKS_PER_SECOND*128L + 10, 12);
+    if (subs != -2) {
+         debugOutput(DEBUG_LEVEL_NORMAL, "  substractTicks(TICKS_PER_SECOND*128L + 10, 12) != -2 : %ld\n",
+            subs);
+        failures++;   
+    }
+    
+    subs=substractTicks(10, TICKS_PER_SECOND*128L + 8);
+    if (subs != 2) {
+         debugOutput(DEBUG_LEVEL_NORMAL, "  substractTicks(10, TICKS_PER_SECOND*128L + 8) != 2 : %ld\n",
+            subs);
+        failures++;   
+    }
+    
+    subs=substractTicks(10, TICKS_PER_SECOND*128L + 12);
+    if (subs != -2) {
+         debugOutput(DEBUG_LEVEL_NORMAL, "  substractTicks(10, TICKS_PER_SECOND*128L + 12) != -2 : %ld\n",
+            subs);
+        failures++;   
+    }    
+    
-    if (failures) {
-        debugOutput(DEBUG_LEVEL_NORMAL, " %d failures\n",failures);
@@ -173 +216 @@
-        
-        IsoHandlerManager *m_isoManager=NULL;
-
-
+
-#ifdef TEST_PORT_0      
-    IsoStream *s=NULL;
@@ -208 +250 @@
-        
-        m_isoManager->setVerboseLevel(DEBUG_LEVEL_VERBOSE);
+        
+        if(!m_isoManager->init()) {
+                debugOutput(DEBUG_LEVEL_NORMAL, "Could not init() IsoHandlerManager\n");
+                goto finish;
+        }
-                
-
-
-
-
-
-
-
-
-
-
-
+
-#ifdef TEST_PORT_0      
-        // add a stream to the manager so that it has something to do
@@ -298 +335 @@
-        }
-
-        debugOutput(DEBUG_LEVEL_NORMAL,   "Starting ISO manager sync update thread...\n");
-        // start the runner thread
-        m_isoManagerThread->Start();
-        
-        debugOutput(DEBUG_LEVEL_NORMAL,   "Starting IsoHandler...\n");
-        if (!m_isoManager->startHandlers(0)) {
@@ -319 +352 @@
-        }
-        
-        // stop the sync thread
-        debugOutput(DEBUG_LEVEL_NORMAL,   "Stopping ISO manager sync update thread...\n");
-        m_isoManagerThread->Stop();
-        
-#ifdef TEST_PORT_0      
-        if(!m_isoManager->unregisterStream(s)) {
@@ -347 +376 @@
-#endif
-        
-        delete m_isoManagerThread;
-    delete m_isoManager;
-

branches/streaming-rework/tests/test-sytmonitor.cpp

@@ -170 +170 @@
-    
-    IsoHandlerManager *m_isoManager=NULL;
-    PosixThread * m_isoManagerThread=NULL;
-    
-    SytMonitor *monitors[128];
@@ -212 +211 @@
-    m_isoManager->setVerboseLevel(DEBUG_LEVEL_VERBOSE);
-            
-
-
-
-
-
-
-
-
+
+
-        goto finish;
-    }
-
+
-        // register monitors
-        for (i=0;i<arguments.nb_combos;i++) {
@@ -270 +263 @@
-                goto finish;
-        }
-        
-        // start the runner thread
-        m_isoManagerThread->Start();
-        
-        if (arguments.realtime) {
@@ -458 +448 @@
-        }
-        
-        // stop the sync thread
-        debugOutput(DEBUG_LEVEL_NORMAL,   "Stopping ISO manager sync update thread...\n");
-        m_isoManagerThread->Stop();
-        
-        // unregister monitors
-        for (i=0;i<arguments.nb_combos;i++) {
@@ -473 +459 @@
-    }
-        
-        delete m_isoManagerThread;
-    delete m_isoManager;
-

branches/streaming-rework/tests/test-timestampedbuffer.cpp

@@ -73 +73 @@
-    uint64_t total_cycles;
-    uint64_t buffersize;
+    uint64_t start_at_cycle;
-};
-
@@ -84 +85 @@
-    {"cycles",        'c',    "n",    0,  "Total cycles to run (2000)" },
-    {"buffersize",        'b',    "n",    0,  "Buffer size (in frames) (1024)" },
+    {"startcycle",        's',    "n",    0,  "Start at cycle (0)" },
-    { 0 }
-};
@@ -101 +103 @@
-        case 'v':
-            if (arg) {
-
+l
-                if ( errno ) {
-                    fprintf( stderr, "Could not parse 'verbose' argument\n" );
@@ -115 +117 @@
-        case 'w':
-            if (arg) {
-
+l
-                if ( errno ) {
-                    fprintf( stderr, "Could not parse 'wrap' argument\n" );
@@ -129 +131 @@
-        case 'f':
-            if (arg) {
-
+l
-                if ( errno ) {
-                    fprintf( stderr, "Could not parse 'fpp' argument\n" );
@@ -143 +145 @@
-        case 'e':
-            if (arg) {
-
+l
-                if ( errno ) {
-                    fprintf( stderr, "Could not parse 'epf' argument\n" );
@@ -157 +159 @@
-        case 'c':
-            if (arg) {
-
+l
-                if ( errno ) {
-                    fprintf( stderr, "Could not parse 'cycles' argument\n" );
@@ -169 +171 @@
-            }
-            break;
+        case 's':
+            if (arg) {
+                arguments->start_at_cycle = strtoll( arg, &tail, 0 );
+                if ( errno ) {
+                    fprintf( stderr, "Could not parse 'startcycle' argument\n" );
+                    return ARGP_ERR_UNKNOWN;
+                }
+            } else {
+                if ( errno ) {
+                    fprintf( stderr, "Could not parse 'startcycle' argument\n" );
+                    return ARGP_ERR_UNKNOWN;
+                }
+            }
+            break;
-        case 'b':
-            if (arg) {
-
+l
-                if ( errno ) {
-                    fprintf( stderr, "Could not parse 'buffersize' argument\n" );
@@ -228 +244 @@
-    arguments.total_cycles = 2000;
-    arguments.buffersize = 1024;
+    arguments.start_at_cycle = 0;
-    
-    // Parse our arguments; every option seen by `parse_opt' will
@@ -275 +292 @@
-    
-    usleep(1000);
+    
+    debugOutput(DEBUG_LEVEL_NORMAL, "Start test 1...\n");
-
-    int dummyframe_in[arguments.events_per_frame*arguments.frames_per_packet];
@@ -283 +302 @@
-    }
-    
-
+
+
+
+
+
+
+
+
-    t->setBufferTailTimestamp(timestamp);
+    
-    timestamp += (uint64_t)(arguments.rate * arguments.frames_per_packet);
-
-
+
+
+
-   
-
+
+
+
+
-        // simulate the rate adaptation
-time
+(time%arguments.wrap_at)
-        
-        if (diff>(int64_t)arguments.wrap_at/2) {
@@ -302 +333 @@
-        
-        if(diff>0) {
+            uint64_t ts_head, fc_head;
+            uint64_t ts_tail, fc_tail;
+            
-            // write one packet
-            t->writeFrames(arguments.frames_per_packet, (char *)&dummyframe_in, timestamp);
-
+
+
+
+
+
+
+
+
+
+
+
-            // read one packet
-            t->readFrames(arguments.frames_per_packet, (char *)&dummyframe_out);
-
+
+
+
+
+
+
+
+
+
+
+
-            // check
-            bool pass=true;
@@ -315 +369 @@
-            if (!pass) {
-                debugOutput(DEBUG_LEVEL_NORMAL, "write/read check for cycle %d failed\n",cycle);
+            }
+
+            // update the timestamp
+            timestamp += (uint64_t)(arguments.rate * arguments.frames_per_packet);
+            if (timestamp >= arguments.wrap_at) {
+                timestamp -= arguments.wrap_at;
+            }
+        }
+
+        // simulate the cycle timer clock in ticks
+        time += 3072;
+        if (time >= arguments.wrap_at) {
+            time -= arguments.wrap_at;
+        }
+        
+        // allow for the messagebuffer thread to catch up
+        usleep(200);
+        
+        if(!run) break;
+    }
+
+    // second run, now do block processing
+    debugOutput(DEBUG_LEVEL_NORMAL, "Start test 2...\n");
+    unsigned int blocksize=32;
+    int dummyframe_out_block[arguments.events_per_frame*arguments.frames_per_packet*blocksize];
+    
+    time=arguments.start_at_cycle*3072;
+    
+    // initialize the timestamp
+    timestamp=time;
+    if (timestamp >= arguments.wrap_at) {
+        // here we need a modulo because start_at_cycle can be large
+        timestamp %= arguments.wrap_at;
+    }
+    t->setBufferTailTimestamp(timestamp);
+    
+    timestamp += (uint64_t)(arguments.rate * arguments.frames_per_packet);
+    if (timestamp >= arguments.wrap_at) {
+        timestamp -= arguments.wrap_at;
+    }
+   
+    for(unsigned int cycle=arguments.start_at_cycle;
+        cycle < arguments.start_at_cycle+arguments.total_cycles; 
+        cycle++) {
+        
+        // simulate the rate adaptation
+        int64_t diff=(time%arguments.wrap_at)-timestamp;
+        
+        if (diff>(int64_t)arguments.wrap_at/2) {
+            diff -= arguments.wrap_at;
+        } else if (diff<(-(int64_t)arguments.wrap_at)/2){
+            diff += arguments.wrap_at;
+        }
+        
+        debugOutput(DEBUG_LEVEL_NORMAL, "Simulating cycle %d @ time=%011llu, diff=%lld\n",cycle,time,diff);
+        
+        if(diff>0) {
+            uint64_t ts_head, fc_head;
+            uint64_t ts_tail, fc_tail;
+            
+            // write one packet
+            t->writeFrames(arguments.frames_per_packet, (char *)&dummyframe_in, timestamp);
+
+            // read the buffer head timestamp
+            t->getBufferHeadTimestamp(&ts_head, &fc_head);
+            t->getBufferTailTimestamp(&ts_tail, &fc_tail);
+            debugOutput(DEBUG_LEVEL_NORMAL, 
+                    " TS after write: HEAD: %011llu, FC=%04u\n",
+                    ts_head,fc_head);
+            debugOutput(DEBUG_LEVEL_NORMAL, 
+                    "                 TAIL: %011llu, FC=%04u\n",
+                    ts_tail,fc_tail);
+
+            if (fc_head > blocksize) {
+                debugOutput(DEBUG_LEVEL_NORMAL,"Reading one block (%u frames)\n",blocksize);
+                
+                // read one block
+                t->readFrames(blocksize, (char *)&dummyframe_out_block);
+    
+                // read the buffer head timestamp
+                t->getBufferHeadTimestamp(&ts_head, &fc_head);
+                t->getBufferTailTimestamp(&ts_tail, &fc_tail);
+                debugOutput(DEBUG_LEVEL_NORMAL, 
+                        " TS after read: HEAD: %011llu, FC=%04u\n",
+                        ts_head,fc_head);
+                debugOutput(DEBUG_LEVEL_NORMAL, 
+                        "                TAIL: %011llu, FC=%04u\n",
+                        ts_tail,fc_tail);
-            }
-            
@@ -323 +465 @@
-            }
-        }
-
+
-        // simulate the cycle timer clock in ticks
-        time += 3072;
@@ -332 +474 @@
-        // allow for the messagebuffer thread to catch up
-        usleep(200);
-
-
+
+
+
+
-
-    delete t;