标签: latency

我有一个在低延迟环境中运行的(java)应用程序,它通常处理大约600微米(+/- 100)的指令.当然,随着我们进一步进入微秒空间,您看到的成本延迟会发生变化,现在我们已经注意到2/3的时间用于分配2个核心域对象.

基准测试已将代码的违规部分与现有引用中的对象构造完全隔离,即基本上是一组引用(每个类中约15个)和一些新的列表,但请参阅下面关于确切测量的内容的注释这里.

每个人一直需要~100微米,这对我来说是莫名其妙的,我试图找出原因.一个快速的基准测试表明,一个类似大小的对象充满了字符串需要大约2-3微米到新的,显然这种基准充满了困难,但认为它可能是有用的基线.

这里有2个Q.

• 如何调查这种行为？
• 缓慢分配的解释是什么？

请注意,所涉及的硬件是Sun X4600上的Solaris 10 x86,带有8*双核opteron @ 3.2GHz

我们看过的东西包括

• 检查PrintTLAB统计信息,显示一些缓慢的分配,因此不存在争用.
• PrintCompilation建议这些代码中的一个不是JIT友好的,虽然Solaris似乎在这里有一些不寻常的行为(即对现代的linux,没有与solaris10类似的老式的Linux现在就可以进行替换)
• LogCompilation ...有点难以解析,至少可以说这是一项持续的工作,到目前为止还没有什么明显的
• JVM版本...在6u6和6u14中保持一致,尚未尝试过6u18或最新版本7

任何和所有的想法赞赏

关于各种帖子的评论摘要,试图让事情更清楚

• 我测量的成本是创造,它通过生成器(像一个内置对象的总成本这些),其私人构造函数调用新的ArrayList几次以及对现有对象设置引用.测量的成本包括设置构建器的成本以及构建器到域对象的转换
• 编译(通过热点)有明显的影响,但它仍然相对较慢(在这种情况下编译从100micros到~60)
• 在我的天真基准测试中编译(通过热点)需要将分配时间从~2micros降低到~300ns
• 延迟不会因年轻的收集算法(ParNew或平行清除)而有所不同

我有一个'服务器'程序,它可以更新共享内存中的许多链表以响应外部事件.我希望客户端程序能够尽快注意到任何列表上的更新(最低延迟).服务器标记链接列表的节点,state_就像FILLED填充数据并将其下一个指针设置为有效位置一样.在那之前,它state_是NOT_FILLED_YET.我使用内存屏障,以确保客户看不到state_的FILLED数据之前,中实际上是准备好(和它似乎工作,我从来没有看到被破坏的数据).此外,state_是易失性的,以确保编译器不会解除客户端的循环检查.

保持服务器代码完全相同,我提出了3种不同的方法让客户端扫描链表以进行更改.问题是:为什么第三种方法最快？

方法1:连续循环遍历所有链接列表(称为"通道"),查看是否有任何节点已更改为"已填充":

void method_one()
{
    std::vector<Data*> channel_cursors;
    for(ChannelList::iterator i = channel_list.begin(); i != channel_list.end(); ++i)
    {
        Data* current_item = static_cast<Data*>(i->get(segment)->tail_.get(segment));
        channel_cursors.push_back(current_item);
    }

    while(true)
    {
        for(std::size_t i = 0; i < channel_list.size(); ++i)
        {   
            Data* current_item = channel_cursors[i];

            ACQUIRE_MEMORY_BARRIER;
            if(current_item->state_ == NOT_FILLED_YET) {
                continue;
            }

            log_latency(current_item->tv_sec_, current_item->tv_usec_);

            channel_cursors[i] = static_cast<Data*>(current_item->next_.get(segment));
        }
    }
}

当通道数量很小时,方法1给出了非常低的延迟.但是当通道数量增加(250K +)时,由于在所有通道上循环,它变得非常慢.所以我试过......

方法2:为每个链接列表提供ID.保留一个单独的"更新列表".每次更新其中一个链接列表时,请将其ID推送到更新列表.现在我们只需要监控单个更新列表,并检查我们从中获取的ID.

void method_two()
{
    std::vector<Data*> channel_cursors;
    for(ChannelList::iterator i = channel_list.begin(); i …

是否有任何协议,系统等实验性的或以其他方式设计用于允许在非常高延迟的链路上进行正常(尽可能正常)的网络操作(电子邮件,DNS,HTML等)？我想的是几分钟到一个小时,或者两个小时.认为太阳系规模的光速滞后.

作为旁注:对社会影响的研究或推测每小时的通信延迟将是有趣的.目前的趋势往往是延迟几秒钟到几分钟(加上人们注意到你的电子邮件需要多长时间)和预先电话时间往往是几天到几周但我想不到任何事情,在最短的时间范围内有最小的时间延迟.

我一直试图在网上寻找解释,但我似乎找不到一个.如果你在Chrome浏览器上访问像youtube.com这样的网站并将鼠标悬停在与文件名"http://www.youtube.com/"相对应的蓝色栏上,你会看到以下四种不同的东西:

-blocking

- 发送

-等候

-接收

我看到,在网络标签中查看其他网站的页面时

-DNS查找

-Connecting

- 发送

-等候

-接收

即使页面非常简单,也需要很长时间才能完成所有这些工作.是什么让我的服务器显示页面加载的不同统计键,我可以做些什么来优化？一般来说,我在哪里可以找到有关网络工具的更全面的信息？

任何人都可以建议如何在网络视图中流式传输视频时处理慢速网络？

当网络强度较差时,会出现空白屏幕或视频无法流式传输.

有没有办法检测这种情况,以便我们可以提醒用户？(除了使用私有API.)

我正在尝试通过WiFi将我的Galaxy Ace连接到我的笔记本电脑.两台设备都通过WiFi连接到路由器,双方都使用Java.

在TCP连接不时给我很高的ping后,我决定将连接建立在UDP上,以便能够控制数据包实际发送的时间.

但是,似乎Android仍然会缓冲UDP数据包并且不会立即发送它们.如果在几分之一秒内没有传输的传出数据,这或者完全关闭WiFi.

首先,只要没有收到应答(覆盖UDP中的数据包丢失),我就会以不规则的间隔大约每秒一次地ping通电话,反复发送ping请求:

    computer -> phone -> computer
    Pinging 192.168.1.40: 148.05968ms
    Pinging 192.168.1.40: 524.41156ms
    Pinging 192.168.1.40: 705.8688ms
    Pinging 192.168.1.40: 3.705367ms
    Pinging 192.168.1.40: 3.872159ms
    Pinging 192.168.1.40: 549.4541ms
    Pinging 192.168.1.40: 479.29843ms
    Pinging 192.168.1.40: 3.89936ms
    Pinging 192.168.1.40: 428.85876ms
    Pinging 192.168.1.40: 739.28125ms

我通过从手机发送数据包到每100毫秒只有1个字节的数据解决了这个问题,除此之外什么都没改变:

    computer -> phone -> computer
    Pinging 192.168.1.40: 4.147753ms
    Pinging 192.168.1.40: 3.738213ms
    Pinging 192.168.1.40: 14.133768ms
    Pinging 192.168.1.40: 4.470561ms
    Pinging 192.168.1.40: 3.628386ms
    Pinging 192.168.1.40: 3.898334ms
    Pinging 192.168.1.40: 3.512401ms
    Pinging 192.168.1.40: 7.907006ms
    Pinging 192.168.1.40: 5.234216ms
    Pinging 192.168.1.40: 5.639137ms

对我的应用程序来说至关重要的是低延迟,所以我会像这样继续发送空数据包(至少只要没有真正的数据传输).我想知道,如果我可以强制android尽快响应,而不需要在网络上扔掉无用的数据.那么,有更优雅的解决方案吗？

顺便说一句,我假设问题是智能手机,而不是计算机,虽然它也可能是计算机等待传入的数据包然后发送其数据包.根据我对网络的了解,这是不太可能的.

谢谢你的帮助!

我正在尝试为目标受众创建一个具有最低延迟的服务器.我得到了区域和可用区域之间的区别(我认为).听起来可用区位于不同的城市？他们到底在哪里？我试着在过去的一小时内搜索谷歌,但我找不到任何东西.

我试图使用ffmpeg将udp流转换为帧.我运行以下命令:

ffmpeg -loglevel debug -strict 2 -re -i "udp://192.168.15.50:3200?fifo_size=1000000&overrun_nonfatal=1" -r 8 -vf scale=432:243 -f image2pipe -vcodec ppm pipe:1

它发生在不同的流类型,mpeg2video和h264.核心处理此特定流的CPU负载低于30%,其低质量sd流的分辨率为640x576.

它适用于大多数时间,但有时,偶尔会发生延迟,帧会在稍后到达.所以我想要8 fps,但有时我会更少,有时甚至更多.

为什么会出现这种延迟？如何减少延迟？

更新:我尝试将其更改为:

ffmpeg -loglevel debug -i "udp://192.168.15.50:3200?fifo_size=1000000&overrun_nonfatal=1" -r 8 -preset ultrafast -fflags nobuffer -vf scale=432:243 -f image2pipe -vcodec ppm pipe:1

但我仍然遇到了这个问题.例如,在ffmpeg日志中我得到:

[2016/02/11 13:32:30] frame= 7477 fps=8.0 q=-0.0 size= 2299638kB time=00:15:34.62 bitrate=20156.4kbits/s dup=7 drop=15867 ^M*** dropping frame 7477 from stream 0 at ts 7475
[2016/02/11 13:32:30] ***dropping frame 7477 from stream 0 at ts 7476
[2016/02/11 13:32:30] ***dropping frame 7478 …

我希望能够手动预测任意算术的长度(即没有分支或内存,尽管这也很好)x86-64汇编代码将采用特定的体系结构,考虑到指令重新排序,超标量,延迟,消费者价格指数等

什么/描述必须遵循的规则才能实现这一目标？

我想我已经找到了一些初步规则,但是我没有找到任何关于将任何示例代码分解为这个详细程度的引用,所以我不得不做一些猜测.(例如,英特尔优化手册甚至几乎没有提到指令重新排序.)

至少,我正在寻找(1)确认每条规则是正确的,或者是每条规则的正确陈述,以及(2)我可能忘记的任何规则的列表.

• 每个循环发出尽可能多的指令,从当前循环开始按顺序开始,并且可能与重新排序缓冲区大小一样远.
• 如果出现以下情况,可以在给定周期发出指令:
  • 没有影响其操作数的指令仍在执行中.和:
  • 如果它是浮点指令,则它之前的每个浮点指令都被发出(浮点指令具有静态指令重新排序).和:
  • 该循环有一个功能单元可用于该指令.每个(？)功能单元是流水线的,这意味着它可以在每个周期接受1个新指令,并且对于给定功能类的CPI,总功能单元的数量是1/CPI(这里模糊不清:可能是例如addps并且subps使用相同的功能) unit？我如何确定？).和:
  • 4此循环已经发出少于超标量宽度(通常)指令的数量.
• 如果不能发出指令,则处理器不会发出任何称为"停顿"的条件.

例如,请考虑以下示例代码(计算交叉产品):

shufps   xmm3, xmm2, 210
shufps   xmm0, xmm1, 201
shufps   xmm2, xmm2, 201
mulps    xmm0, xmm3
shufps   xmm1, xmm1, 210
mulps    xmm1, xmm2
subps    xmm0, xmm1

我试图预测Haswell的延迟看起来像这样:

; `mulps`  Haswell latency=5, CPI=0.5
; `shufps` Haswell latency=1, CPI=1
; `subps`  Haswell latency=3, CPI=1

shufps   xmm3, xmm2, 210   ; cycle  1
shufps   xmm0, xmm1, 201   ; cycle  2
shufps   xmm2, xmm2, 201   ; …

我目前有一个使用 MySQL RDS 数据库的 EC2 实例。它们位于同一区域，但位于不同的可用区。目前我的应用程序遇到了一些滞后，我的直觉是这是由于这个原因。

如何更改 RDS 数据库的可用区以加速我的应用程序？

我在本地运行相同的应用程序，并且速度明显更快。