标签: latency

我试图理解破坏者的模式.我看过InfoQ视频,试图阅读他们的论文.我知道有一个环形缓冲区,它被初始化为一个非常大的数组,以利用缓存局部性,消除新内存的分配.

听起来有一个或多个原子整数可以跟踪位置.每个"事件"似乎都得到一个唯一的id,它在环中的位置是通过找到与模数相关的模数等来找到的.

不幸的是,我没有直观的感觉它是如何工作的.我做了很多交易应用程序并研究了演员模型,看过SEDA等.

在他们的演讲中他们提到这种模式基本上是路由器的工作方式; 但是我还没有找到路由器如何工作的任何好的描述.

是否有一些更好解释的好指示？

我需要模拟与服务器的低带宽,高延迟连接,以便模拟远程站点上VPN的条件.带宽和延迟应该是可调整的,因此我可以发现最佳组合以运行我们的软件包.

任何人都可以给我大概的时间(以纳秒为单位)来访问L1,L2和L3缓存,以及Intel i7处理器上的主内存吗？

虽然这不是一个特别的编程问题,但是对于某些低延迟编程挑战而言,了解这些速度细节是必要的.

我们正在开发一个程序,它接收和转发"消息",同时保留这些消息的临时历史记录,以便它可以告诉您消息历史记录(如果请求).消息以数字方式标识,通常大小约为1千字节,我们需要保留数十万条这些消息.

我们希望优化此程序的延迟:发送和接收消息之间的时间必须低于10毫秒.

该程序是用Haskell编写的,并用GHC编译.但是,我们发现垃圾收集暂停对于我们的延迟要求来说太长了:在我们的实际程序中超过100毫秒.

以下程序是我们的应用程序的简化版本.它使用a Data.Map.Strict来存储消息.消息ByteString由a标识Int.以递增的数字顺序插入1,000,000条消息,并且不断删除最旧的消息以使历史记录最多保留200,000条消息.

module Main (main) where

import qualified Control.Exception as Exception
import qualified Control.Monad as Monad
import qualified Data.ByteString as ByteString
import qualified Data.Map.Strict as Map

data Msg = Msg !Int !ByteString.ByteString

type Chan = Map.Map Int ByteString.ByteString

message :: Int -> Msg
message n = Msg n (ByteString.replicate 1024 (fromIntegral n))

pushMsg :: Chan -> Msg -> IO Chan
pushMsg chan (Msg msgId msgContent) =
  Exception.evaluate $
    let
      inserted = Map.insert …

我有一个Java应用程序,通过TCP套接字连接到用C/C++开发的"服务器".

app和server都运行在同一台机器上,一个Solaris机箱(但我们最终考虑迁移到Linux).交换的数据类型是简单的消息(登录,登录ACK,然后客户端要求的东西,服务器回复).每条消息长约300字节.

目前我们正在使用套接字,一切正常,但我正在寻找一种更快的方式来交换数据(更低的延迟),使用IPC方法.

我一直在研究网络,并提出了以下技术的参考:

• 共享内存
• 管道
• 队列
• 以及所谓的DMA(直接内存访问)

但我无法找到他们各自的性能适当的分析,无论是如何实现它们在Java和C/C++(这样他们可以互相交谈),也许除了管我能想象该怎么办.

在这种情况下,任何人都可以评论每种方法的表现和可行性吗？任何有用的实现信息的指针/链接？

编辑/更新

按照我在这里的评论和答案,我发现了有关Unix域套接字的信息,它似乎是通过管道构建的,并且可以节省整个TCP堆栈.它是特定于平台的,因此我计划使用JNI或者juds或junixsocket进行测试.

接下来可能的步骤是直接实现管道,然后共享内存,虽然我已被警告过额外的复杂程度......

谢谢你的帮助

我是Amazon RDS的客户,并且每天都遇到亚马逊RDS写入延迟峰值,大致相当于备份窗口.我还会在快照结束时看到尖峰(例如:运行快照需要1小时,在最后5分钟内,写入延迟峰值).我正在运行多AZ m1.large部署.

Stack上有没有人可以解释Amazon RDS备份实际上是如何工作的？我已经阅读了亚马逊RDS文档,据我所知,亚马逊RDS的行为并不符合规范.具体来说,这些备份/快照操作应该是我的副本,因此不会导致任何停机/性能损失,或者我认为.

我可以将我的问题提炼成六个问题:

• 快照和备份过程中技术上发生了什么,它们有何不同？(如果您回答这个问题,请告诉我您是否能够凭经验确认您的答案,或者只是引用我的文档).
• 在多可用区部署的备份窗口期间,预期写入延迟会出现峰值吗？
• 在多可用区部署的快照结束时,预计会出现写入延迟的峰值吗？
• 如果我不是多AZ,我的写入延迟峰值会更高吗？
• 在架构上,如果我在两个m1.large EC2实例上运行我自己的数据库,我是否能够避免这些写入延迟峰值？
• 是否有任何我可以使用的配置可以避免这些写入延迟峰值,同时仍然使用RDS托管我的数据库,或者我是否真的受亚马逊的支配？

奖金问题:你在哪里以及如何托管你的mysql数据库？

我可以说除了这些每日写入延迟问题外,我一直对RDS感到满意.我喜欢内置的数据库监控,设置和开始都相当简单.

谢谢!

在使用Monitor.PulseAll()进行线程同步的库中,我注意到从PulseAll(...)被调用到线程被唤醒的时间的延迟似乎遵循"踩台阶"分布 - 极其大步.被唤醒的线程几乎没有工作; 并几乎立即回到监视器上等待.例如,在具有12个核心的盒子上,24个线程在监视器上等待(2x Xeon5680/Gulftown;每个处理器6个物理核心; HT禁用),Pulse和线程唤醒之间的延迟是这样的:

前12个线程(注意我们有12个内核)需要30到60微秒才能响应.然后我们开始获得非常大的跳跃; 高原在700,1300,1900和2600微秒左右.

我能够使用下面的代码成功地独立于第三方库重新创建此行为.这段代码的作用是启动大量线程(更改numThreads参数),只需在监视器上等待,读取时间戳,将其记录到ConcurrentSet,然后立即返回Waiting.一旦第二个PulseAll()唤醒所有线程.它执行此操作20次,并将第10次迭代的延迟报告给控制台.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Concurrent;
using System.Diagnostics;

namespace PulseAllTest
{
    class Program
    {
        static long LastTimestamp;
        static long Iteration;
        static object SyncObj = new object();
        static Stopwatch s = new Stopwatch();
        static ConcurrentBag<Tuple<long, long>> IterationToTicks = new ConcurrentBag<Tuple<long, long>>();

        static void Main(string[] args)
        {
            long numThreads = 32;

            for (int i = 0; i < numThreads; ++i)
            {
                Task.Factory.StartNew(ReadLastTimestampAndPublish, TaskCreationOptions.LongRunning);
            }

            s.Start(); …

我正在尝试预取训练数据以隐藏I/O延迟.我想编写自定义Python代码,从磁盘加载数据并预处理数据(例如,通过添加上下文窗口).换句话说,一个线程进行数据预处理,另一个线程进行训练.这在TensorFlow中可行吗？

更新:我有一个基于@ mrry的例子的工作示例.

import numpy as np
import tensorflow as tf
import threading

BATCH_SIZE = 5
TRAINING_ITERS = 4100

feature_input = tf.placeholder(tf.float32, shape=[128])
label_input = tf.placeholder(tf.float32, shape=[128])

q = tf.FIFOQueue(200, [tf.float32, tf.float32], shapes=[[128], [128]])
enqueue_op = q.enqueue([label_input, feature_input])

label_batch, feature_batch = q.dequeue_many(BATCH_SIZE)
c = tf.reshape(feature_batch, [BATCH_SIZE, 128]) + tf.reshape(label_batch, [BATCH_SIZE, 128])

sess = tf.Session()

def load_and_enqueue(sess, enqueue_op, coord):
  with open('dummy_data/features.bin') as feature_file, open('dummy_data/labels.bin') as label_file:
    while not coord.should_stop():
      feature_array = np.fromfile(feature_file, np.float32, 128)
      if feature_array.shape[0] == 0:
        print('reach end of …

当我们讨论分布式系统的性能时,我们使用术语tp50,tp90,tp99.99 TPS.有人可以解释一下我们的意思吗？

在Linux上,C++应用程序进程之间发送消息的最快技术是什么？我隐约知道桌面上有以下技巧:

• TCP
• UDP
• 套接字
• 管道
• 命名管道
• 内存映射文件

有没有更多的方法,最快的是什么？