标签: bandwidth

我即将在本地计算机上托管一个小型套接字服务器,我想知道它将使用哪种带宽.在大多数日子里,它将同时连接不超过50个客户端,但每周一次或两次可以同时拥有多达5,000多个客户端.但是,发送的唯一消息将是偶尔向所有连接的客户端发送的单个消息,没有额外的数据或任何内容.

服务器是否会导致其托管的计算机性能显着下降或者降低我的网速？

Server.js:

var app = require('http').createServer(handler)
   , io = require('socket.io').listen(app)
   , fs = require('fs')

 app.listen(8001);

function handler (req, res) {
fs.readFile(__dirname + '/index.html',
  function (err, data) {
    if (err) {
      res.writeHead(500);
      return res.end('Error loading index.html');
    }

    res.writeHead(200);
    res.end(data);
  });
}

io.sockets.on('connection', function (socket) {
  socket.on('SendDefault', function(data) {
    socket.broadcast.emit('GetDefault');
  });
});

Client.js:

setTimeout( function( ){ 
  socket = io.connect('[IP Address]:8001');
  socket.on('GetDefault', function(data) {
    DoStuff( );
  );
} ); }, 10000 );

我从移动应用程序(最多1000个JSON对象)提交相对大量的数据,我通常会像这样编码:

[{
    id: 12,
    score: 34,
    interval: 5678,
    sub: 9012
}, {
    id: ...
}, ...]

我可以通过提交数组数组来减小有效负载:

[[12, 34, 5678, 9012], [...], ...]

在属性名称上保存一些空间,并在服务器上重新创建对象(因为模式已修复,或者至少它是服务器和客户端之间的契约).

然后在POST请求中提交有效载荷,最有可能通过3G连接(或可能是wifi).

看起来我通过使用嵌套数组来节省一些带宽,但我不确定应用gzip时它是否明显,我不确定如何精确和客观地测量差异.

在另一方面,嵌套的数组不觉得是个好主意:他们不太容易阅读,因而更难调试时发现错误.此外,由于我们正在冲洗马桶的可读性,我们可以简化阵列,因为每个子阵列都有固定数量的元素,服务器可以将其切片并再次重建对象.

关于这个主题的任何进一步的阅读材料非常感谢.

我已经意识到Little's Law限制了在给定的延迟和给定的并发级别下数据传输的速度.如果您想更快地传输某些内容,则需要更大的传输,更多的"飞行中"传输或更低的延迟.对于从RAM读取的情况,并发性受到行填充缓冲区数量的限制.

当加载错过L1缓存时,将分配行填充缓冲区.现代英特尔芯片(Nehalem,Sandy Bridge,Ivy Bridge,Haswell)每个核心有10个LFB,因此每个核心限制为10个未完成的缓存未命中.如果RAM延迟为70 ns(似乎合理),并且每次传输为128字节(64B高速缓存线加上其硬件预取双线),则将每个内核的带宽限制为:10*128B/75 ns = ~16 GB/s.诸如单线程Stream之类的基准确认这是相当准确的.

减少延迟的显而易见的方法是使用x64指令(如PREFETCHT0,PREFETCHT1,PREFETCHT2或PREFETCHNTA)预取所需数据,这样就不必从RAM中读取数据.但是我无法通过使用它们加快速度.问题似乎是__mm_prefetch()指令本身消耗LFB,因此它们也受到相同的限制.硬件预取不会触及LFB,也不会跨越页面边界.

但我无法在任何地方找到任何记录.我发现的最接近的是15年前的文章,其中提到Pentium III上的预取使用Line Fill Buffers.我担心事情可能会发生变化.由于我认为LFB与L1缓存相关联,我不确定为什么L2或L3的预取会消耗它们.然而,我测量的速度与这种情况一致.

那么:有没有办法在没有使用这10个线路填充缓冲器中的一个的情况下从存储器中的新位置开始取出,从而通过绕过Little's定律实现更高的带宽？

两个数组的点积

for(int i=0; i<n; i++) {
    sum += x[i]*y[i];
}

不重用数据,因此它应该是一个内存绑定操作.因此,我应该能够从点积测量内存带宽.

使用代码 为什么 - 矢量化 - 循环 - 没有性能改进 我的系统带宽为9.3 GB/s.但是,当我尝试使用点积计算带宽时,我获得单个线程的速率的两倍以及使用多个线程的速率超过三倍(我的系统有四个核心/八个超线程).这对我没有意义,因为内存绑定操作不应该受益于多个线程.以下代码的输出如下:

Xeon E5-1620, GCC 4.9.0, Linux kernel 3.13
dot 1 thread:      1.0 GB, sum 191054.81, time 4.98 s, 21.56 GB/s, 5.39 GFLOPS
dot_avx 1 thread   1.0 GB, sum 191043.33, time 5.16 s, 20.79 GB/s, 5.20 GFLOPS
dot_avx 2 threads: 1.0 GB, sum 191045.34, time 3.44 s, 31.24 GB/s, 7.81 GFLOPS
dot_avx 8 threads: 1.0 GB, sum 191043.34, time 3.26 …

我有一个C#应用程序,它使用本地库,使用UDP通过Internet将视频发送到其他IP.我对该库没有流量控制.

我的应用程序还调用另一台服务器的Web服务,使用WebRequest我可以控制它们.

问题是:

当我的互联网带宽较低时,视频流会占用我所有的带宽.因此,在此期间我无法获得我的Web服务方法的响应.

有没有办法优先考虑WebRequest或为他们节省一些带宽,以便我可以安全地获得响应？

我写了一些应用程序,而不是大量使用网络,我想通过慢速网络测试它.我正在寻找一种模拟这种连接的工具.

我只对Windows工具感兴趣.

减少JSF中viewstate隐藏字段大小的最佳方法是什么？我注意到我的视图状态大约是40k,这会下降到客户端并在每次请求时回到服务器,并且响应通常会发送到服务器,这对用户来说是一个显着的减速.

我的环境JSF 1.2,MyFaces,Tomcat,Tomahawk,RichFaces

我正在开发一个程序,在后台不断发送数据流,我希望允许用户为上传和下载限制设置上限.

我已经阅读了令牌桶和漏桶的算法,看起来后者似乎符合描述,因为这不是最大化网络带宽而是尽可能不引人注目的问题.

然而,我对如何实现这一点有点不确定.一种自然的方法是扩展抽象Stream类,使扩展现有流量变得简单,但是这不需要额外线程的参与来发送数据,同时接收(漏桶)吗？任何有关其他实现的提示都将受到赞赏.

此外,虽然我可以修改程序接收的数据量,但带宽限制在C#级别的工作情况如何？计算机是否仍会接收数据并将其保存,有效取消限制效果还是等到我要求接收更多数据？

编辑:我感兴趣的是限制传入和传出数据,我无法控制流的另一端.

在看到Square使用iPhone上的耳机插孔发送信用卡数据后,我对此感兴趣.

iPhone,普通笔记本电脑和普通移动设备的耳机插孔的平​​均带宽是多少？

可以通过在不同的通道(左/右)上发送不同的数据流来加倍吗？

使用带有带宽检查插件的flowplayer时,您需要说明不同视频质量的比特率.

这是它的样子:

// the bitrates, video width and file names for this clip
      bitrates: [
        { url: "bbb-800.mp4", width: 480, bitrate: 800 },
        { url: "bbb-1200.mp4", width: 720, bitrate: 1200 },
        { url: "bbb-1600.mp4", width: 1080, bitrate: 1600 }
      ],

特定质量的哪个比特率代表youtube？

例如,使用360p质量的YouTube播放视频的比特率是多少？