流媒体比特率与实际传输速率不同

你好！
我在C语言中建立了一个应用程序，从StAut6 FPGA获取数据，并将它们放入TXT文件中。
我正在测试从FIFO接口（32位）。
虽然流光显示的比特率为180Mb/s，实际传输速率约为8Mb/s。
这是显示比特率的流线型的C代码。
公共不安全空隙XFEDATA（字节[]CBUFS，字节[]]XBUFS，字节[][OLAPS，ISO-PKtiOFIMP[]]PKTSHINFO）
{
INT K＝0；
In LeN＝0；
成功率＝0；
故障＝0；
xFixBy数＝0；
T1= DATETIME.现在；
为（布伦宁；）
{
/ WaitForXfer
固定（字节*tMPOVLAP＝OLAPS[k]）
{
重叠* OVLAP状态=（重叠*）TMPOVLAP；
如果（！）端点WaitForXfer（OVLAP STATION & GT；HEVER，500）
{
端点。
PInvoke . WaitForSingleObject（OVLAP Stand & GT；HEVER，500）；
}
}
If（EndoPositAt=＝1）
{
CysCon点ISOCO=端点为CysCo终点；
/ FinishDataXfer
如果（ISOC.FinishDataXfer（REF CBUFS [K]，REF XBUFS [K]，REF LeN，REF OLAPS[K]，REF PKTSHIFO[K]））
{
ISO-PKTIONF[]PKPS= PKTSHIFO[K]；
对于（int j＝0；j& lt；ppx；j++）
{
如果（PKTs[j]，状态＝0）
{
XFelByth++PKTs[j]长度；
成功+++；
}
其他的
故障+ +；
PKTs [J]。长度＝0；
}
}
其他的
故障+ +；
}
其他的
{
/ FinishDataXfer
If（端点FinishDataXfer（REF CBUFS [K]，REF XBUFS [K]，REF LeN，REF OLAPS[K]））
{
XFelByth++LeN；
成功+++；
}
其他的
故障+ +；
}
K++；
如果（k=＝QueLeSZ）//每次只通过队列更新显示统计数据一次
{
K＝0；
T2= DATETIME.现在；
经过时间= T2-T1；
xFrRe= =（long）（xFixByth/EaspPo.TimeMyLimeNDS）；
xFrRe= xFrRAT/（int）100 *（int）100；
//在主线程中调用StaseUpDeDeO（）
这是调用（UpDATEUI）；
//对于小队列或PPX，循环太紧，UI线程无法得到服务。
//没有这个，应用程序挂在这些场景中。
线程：睡眠（1）；
}
//将此缓冲区重新提交到队列中
Lee＝BufSz；
端点BeginDataXfer（REF CBUFS [K]，REF XBUFS [K]，REF LEN，REF OLAPS [K]）；
} / /端无限环
}
这是我用来写文件的代码：
公共不安全空隙写入文件（）
{
int字节＝16384；
字节[]缓冲器=新字节[字节]；
BOL BXFEXCENTALL = FALSE；
BoL ISPKT＝FALSE；
CyBulkEndotBurFrd=端点为CyBurkEndoPoT；
如果（炮制）！=空）
BxFrExt=＝Bulrest.XFEDATA（REF缓冲区，REF字节，IsPkt）；
尝试
{
虽然（真）
写入数据（缓冲器，字节，BXFEALTER）；
}
catch（null参考异常）
{
E.GETBaseExabVIEW（）；
调用。
}
}
问题是什么？
谢谢您！



     以下为原文
  Hi!
    I've build an application in C# wich takes data from a Spartan6 FPGA and put them into a txt file.
    I am testing the slave fifo interface (32 bit).
    While the Streamer shows a bitrate of 180MB/s, the actual transfer rate is around 8MB/s.
    This is the C# code of Streamer that show the bitrate:
    public unsafe void XferData(byte[][] cBufs, byte[][] xBufs, byte[][] oLaps, ISO_PKT_INFO[][] pktsInfo)
            {
                int k = 0;
                int len = 0;
   

                Successes = 0;
                Failures = 0;
   

                XferBytes = 0;
                t1 = DateTime.Now;
   

                for (; bRunning; )
                {
                    // WaitForXfer
                    fixed (byte* tmpOvlap = oLaps[k])
                    {
                        OVERLAPPED* ovLapStatus = (OVERLAPPED*)tmpOvlap;
                        if (!EndPoint.WaitForXfer(ovLapStatus->hEvent, 500))
                        {
                            EndPoint.Abort();
                            PInvoke.WaitForSingleObject(ovLapStatus->hEvent, 500);
                        }
                    }
   

                    if (EndPoint.Attributes == 1)
                    {
                        CyIsocEndPoint isoc = EndPoint as CyIsocEndPoint;
                        // FinishDataXfer
                        if (isoc.FinishDataXfer(ref cBufs[k], ref xBufs[k], ref len, ref oLaps[k], ref pktsInfo[k]))
                        {
                            ISO_PKT_INFO[] pkts = pktsInfo[k];
   

                            for (int j = 0; j < PPX; j++)
                            {
                                if (pkts[j].Status == 0)
                                {
                                    XferBytes += pkts[j].Length;
                                    Successes++;
                                }
                                else
                                    Failures++;
   

                                pkts[j].Length = 0;
                            }
   

                        }
                        else
                            Failures++;
                    }
                    else
                    {
                        // FinishDataXfer
                        if (EndPoint.FinishDataXfer(ref cBufs[k], ref xBufs[k], ref len, ref oLaps[k]))
                        {
                            XferBytes += len;
                            Successes++;
                        }
                        else
                            Failures++;
                    }
   

                    k++;
                    if (k == QueueSz)  // Only update displayed stats once each time through the queue
                    {
                        k = 0;
                        t2 = DateTime.Now;
                        elapsed = t2 - t1;
   

                        xferRate = (long)(XferBytes / elapsed.TotalMilliseconds);
                        xferRate = xferRate / (int)100 * (int)100;
   

                        // Call StatusUpdate() in the main thread
                        this.Invoke(updateUI);
   

                        // For small QueueSz or PPX, the loop is too tight for UI thread to ever get service.   
                        // Without this, app hangs in those scenarios.
                        Thread.Sleep(1);
                    }
                    // Re-submit this buffer into the queue
                    len = BufSz;
                    EndPoint.BeginDataXfer(ref cBufs[k], ref xBufs[k], ref len, ref oLaps[k]);
                } // End infinite loop
            }
     
    And this is the code that I use to write into file:
     
            public unsafe void WriteToFileThread()
            {
   

                int bytes = 16384;
                byte[] buffer = new byte[bytes];
                bool bXferCompleted = false;
                bool IsPkt = false;
   

                CyBulkEndPoint bulkEpt = EndPoint as CyBulkEndPoint;
                if (bulkEpt != null)
                    bXferCompleted = bulkEpt.XferData(ref buffer, ref bytes, IsPkt);
                try
                {
                    while(true)
                    WriteXferData(buffer, bytes, bXferCompleted);
                }
                catch (NullReferenceException e)
                {
                    e.GetBaseException();
                    this.Invoke(handleException);
                }
            }
     
    What is the problem?
     
    Thank you!