<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
		>
<channel>
	<title>Comments on: [分享]从一个小测试来理解 Erlang 的性能特性</title>
	<atom:link href="http://erlang-china.org/misc/little-test_on_erlang-performence.html/feed" rel="self" type="application/rss+xml" />
	<link>http://erlang-china.org/misc/little-test_on_erlang-performence.html</link>
	<description>erlang 中文社区</description>
	<lastBuildDate>Mon, 21 May 2012 07:55:26 +0000</lastBuildDate>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.3.2</generator>
	<item>
		<title>By: mryufeng</title>
		<link>http://erlang-china.org/misc/little-test_on_erlang-performence.html/comment-page-1#comment-14044</link>
		<dc:creator>mryufeng</dc:creator>
		<pubDate>Thu, 03 Sep 2009 15:19:16 +0000</pubDate>
		<guid isPermaLink="false">http://erlang-china.org/?p=569#comment-14044</guid>
		<description>互联网搜是你家局域网？</description>
		<content:encoded><![CDATA[<p>互联网搜是你家局域网？</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: easeliu</title>
		<link>http://erlang-china.org/misc/little-test_on_erlang-performence.html/comment-page-1#comment-14042</link>
		<dc:creator>easeliu</dc:creator>
		<pubDate>Thu, 03 Sep 2009 13:23:40 +0000</pubDate>
		<guid isPermaLink="false">http://erlang-china.org/?p=569#comment-14042</guid>
		<description>广播消息用多播来做比较好一点吧</description>
		<content:encoded><![CDATA[<p>广播消息用多播来做比较好一点吧</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: 美洲豹</title>
		<link>http://erlang-china.org/misc/little-test_on_erlang-performence.html/comment-page-1#comment-13948</link>
		<dc:creator>美洲豹</dc:creator>
		<pubDate>Tue, 01 Sep 2009 09:15:55 +0000</pubDate>
		<guid isPermaLink="false">http://erlang-china.org/?p=569#comment-13948</guid>
		<description>看了你们的讨论，我总结一下
大量的消息广播：
1，使用binary
2，分布到多台处理

考虑到实际应用中这类的消息并不需要很及时，
可以在正常发送给client的时候附带发送
比如每个Node有个ets表存储广播的消息，用户进程记录上次发送的广播ID,以此来对比是否有新的广播</description>
		<content:encoded><![CDATA[<p>看了你们的讨论，我总结一下<br />
大量的消息广播：<br />
1，使用binary<br />
2，分布到多台处理</p>
<p>考虑到实际应用中这类的消息并不需要很及时，<br />
可以在正常发送给client的时候附带发送<br />
比如每个Node有个ets表存储广播的消息，用户进程记录上次发送的广播ID,以此来对比是否有新的广播</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: mryufeng</title>
		<link>http://erlang-china.org/misc/little-test_on_erlang-performence.html/comment-page-1#comment-13686</link>
		<dc:creator>mryufeng</dc:creator>
		<pubDate>Wed, 29 Jul 2009 16:34:11 +0000</pubDate>
		<guid isPermaLink="false">http://erlang-china.org/?p=569#comment-13686</guid>
		<description>rabbitmq就是这么做的， 广播消息发到节点， 由节点负责对该节点的所有组里的进程广播，所以扩展能力很强！</description>
		<content:encoded><![CDATA[<p>rabbitmq就是这么做的， 广播消息发到节点， 由节点负责对该节点的所有组里的进程广播，所以扩展能力很强！</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: jackyz</title>
		<link>http://erlang-china.org/misc/little-test_on_erlang-performence.html/comment-page-1#comment-13683</link>
		<dc:creator>jackyz</dc:creator>
		<pubDate>Wed, 29 Jul 2009 10:50:29 +0000</pubDate>
		<guid isPermaLink="false">http://erlang-china.org/?p=569#comment-13683</guid>
		<description>我的意思是，遵循 Erlang 所提倡的“小消息，大运算”思路，那么是不是有可能找到某种方式/结构，减小“广播”业务之中的消息发送数量，或者说“不依赖于 send 来实现广播”。

现在的广播，是用 for each 的方式来发送，一个广播意味着 X 次 send 调用，这里的 X 等于用户数量。那么，是否有可能采用某种底层设施(比如说 driver)来执行广播，此时，只需要发送一条消息，其内容为：接收者列表＋消息内容，然后交由具体的底层设施来做实际的发送动作(X = 1)。此前 yufeng 提到 C 写的广播也只能做到 6-7w 。那么在发送性能上，两者的差别其实并不是太显著，所以，实际上已经失去了这么做的意义。

另外一个思路是通过多机集群来实现，比如，将每台单机的用户数量控制在一定的数量上(N)，由 M 台机器来实现整个集群。广播时，对每台机器只需发送一条消息(M条)，再由各自的机器分别对 N 个用户广播(X = M * N)。如此，应当可以实现对庞大用户数量的广播。但，如果 N 的值并不够大，在成本的考量上可能并不理想，此乃后话，另当别论。

是否还有其他的思路？不妨讨论讨论。</description>
		<content:encoded><![CDATA[<p>我的意思是，遵循 Erlang 所提倡的“小消息，大运算”思路，那么是不是有可能找到某种方式/结构，减小“广播”业务之中的消息发送数量，或者说“不依赖于 send 来实现广播”。</p>
<p>现在的广播，是用 for each 的方式来发送，一个广播意味着 X 次 send 调用，这里的 X 等于用户数量。那么，是否有可能采用某种底层设施(比如说 driver)来执行广播，此时，只需要发送一条消息，其内容为：接收者列表＋消息内容，然后交由具体的底层设施来做实际的发送动作(X = 1)。此前 yufeng 提到 C 写的广播也只能做到 6-7w 。那么在发送性能上，两者的差别其实并不是太显著，所以，实际上已经失去了这么做的意义。</p>
<p>另外一个思路是通过多机集群来实现，比如，将每台单机的用户数量控制在一定的数量上(N)，由 M 台机器来实现整个集群。广播时，对每台机器只需发送一条消息(M条)，再由各自的机器分别对 N 个用户广播(X = M * N)。如此，应当可以实现对庞大用户数量的广播。但，如果 N 的值并不够大，在成本的考量上可能并不理想，此乃后话，另当别论。</p>
<p>是否还有其他的思路？不妨讨论讨论。</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: mryufeng</title>
		<link>http://erlang-china.org/misc/little-test_on_erlang-performence.html/comment-page-1#comment-13682</link>
		<dc:creator>mryufeng</dc:creator>
		<pubDate>Wed, 29 Jul 2009 08:02:20 +0000</pubDate>
		<guid isPermaLink="false">http://erlang-china.org/?p=569#comment-13682</guid>
		<description>单单写这种程序的话， 平均程序员写的erlang程序至少可以达到c的百分之大几十， 所以应该很有竞争力。</description>
		<content:encoded><![CDATA[<p>单单写这种程序的话， 平均程序员写的erlang程序至少可以达到c的百分之大几十， 所以应该很有竞争力。</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: mryufeng</title>
		<link>http://erlang-china.org/misc/little-test_on_erlang-performence.html/comment-page-1#comment-13681</link>
		<dc:creator>mryufeng</dc:creator>
		<pubDate>Wed, 29 Jul 2009 07:59:21 +0000</pubDate>
		<guid isPermaLink="false">http://erlang-china.org/?p=569#comment-13681</guid>
		<description>发送包的最大开销有3部分 1. send系统调用（30us) 2. 内存拷贝（0.xxxus）  3. 包拼凑。 也是说最大的开销在send。其他的都是小头，优化无意义的。 正确的思路是减少 send调用的次数，积累包，在系统可写的时候一次写出去. erlang已经提供了这个功能。delay_send这个选项就是解决这个问题的。 对于erlang的erts, 如何用proc_bin的refc减少内存copy，gen_tcp的发送是用消息确认发送成功的，这个消息可以和主loop一起处理(rabbitmq和joel的程序里面都这么做了）, 还有io调度和process调度的时间的微调(可以参考erl +T参数，改变ioinput_reduction和context_reds的时间)， gc什么时候参与内存回收， 内存和cpu占用的平衡， 是个值得研究的内容。只有这些问题都能做到最好，那么我们的服务器程序只有顶级的c程序员可以追随。

目前我在研究这些，有兴趣的同学一起来哦。</description>
		<content:encoded><![CDATA[<p>发送包的最大开销有3部分 1. send系统调用（30us) 2. 内存拷贝（0.xxxus）  3. 包拼凑。 也是说最大的开销在send。其他的都是小头，优化无意义的。 正确的思路是减少 send调用的次数，积累包，在系统可写的时候一次写出去. erlang已经提供了这个功能。delay_send这个选项就是解决这个问题的。 对于erlang的erts, 如何用proc_bin的refc减少内存copy，gen_tcp的发送是用消息确认发送成功的，这个消息可以和主loop一起处理(rabbitmq和joel的程序里面都这么做了）, 还有io调度和process调度的时间的微调(可以参考erl +T参数，改变ioinput_reduction和context_reds的时间)， gc什么时候参与内存回收， 内存和cpu占用的平衡， 是个值得研究的内容。只有这些问题都能做到最好，那么我们的服务器程序只有顶级的c程序员可以追随。</p>
<p>目前我在研究这些，有兴趣的同学一起来哦。</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: jackyz</title>
		<link>http://erlang-china.org/misc/little-test_on_erlang-performence.html/comment-page-1#comment-13680</link>
		<dc:creator>jackyz</dc:creator>
		<pubDate>Wed, 29 Jul 2009 07:01:13 +0000</pubDate>
		<guid isPermaLink="false">http://erlang-china.org/?p=569#comment-13680</guid>
		<description>总结一下 yufeng 的观点：

1, erl -smp disable 大有关系(我的古董机为单核，未涉及)。
2, 源码表明 binary &gt; 256 会产生传引用的行为。
3, node 之间的 TCP 传递可以累积，一次发送多个包。

很有营养的认识。:D

把 broadcast 放到 driver 层面来做似乎是个靠谱的想法。然而，以 yufeng 之前的实践经验来看，单机 6w-7w/s 的广播性能，与之前根据 erlang 发包效能所做的性能推测(50K-60K/s)，似乎并没有我想象中的那么高(我的意思是，比如说，我原本以为会快上一两个数量级之类的)。这是否说明：

1，Erlang 的发送其实效率已经非常高，在 for each 的方式下，与底层 driver 方案之间的性能差异已经差别不大(至少不会有一个数量级之类的差异)？
2，现有 for each 的发送方式，无论是在 Erlang 里做还是在 driver 里做，其极限恐怕也差不多就是这么多了？(当然，大小为 1K 的数据包，要在 1s 以内广播给 50K-60K 的客户端，这本身也是一种极端场景)

根据 Erlang 的公平调度原则来推论，这确实很容易导致大面积的延迟(比如，在广播数量大于某个值之后，平均延迟会与之呈现出类似指数曲线的相关性)。

我现在很好奇，除了 driver 层方案(外包给更高效率的底层代码)之外，还有什么方式可供考虑呢？</description>
		<content:encoded><![CDATA[<p>总结一下 yufeng 的观点：</p>
<p>1, erl -smp disable 大有关系(我的古董机为单核，未涉及)。<br />
2, 源码表明 binary &gt; 256 会产生传引用的行为。<br />
3, node 之间的 TCP 传递可以累积，一次发送多个包。</p>
<p>很有营养的认识。:D</p>
<p>把 broadcast 放到 driver 层面来做似乎是个靠谱的想法。然而，以 yufeng 之前的实践经验来看，单机 6w-7w/s 的广播性能，与之前根据 erlang 发包效能所做的性能推测(50K-60K/s)，似乎并没有我想象中的那么高(我的意思是，比如说，我原本以为会快上一两个数量级之类的)。这是否说明：</p>
<p>1，Erlang 的发送其实效率已经非常高，在 for each 的方式下，与底层 driver 方案之间的性能差异已经差别不大(至少不会有一个数量级之类的差异)？<br />
2，现有 for each 的发送方式，无论是在 Erlang 里做还是在 driver 里做，其极限恐怕也差不多就是这么多了？(当然，大小为 1K 的数据包，要在 1s 以内广播给 50K-60K 的客户端，这本身也是一种极端场景)</p>
<p>根据 Erlang 的公平调度原则来推论，这确实很容易导致大面积的延迟(比如，在广播数量大于某个值之后，平均延迟会与之呈现出类似指数曲线的相关性)。</p>
<p>我现在很好奇，除了 driver 层方案(外包给更高效率的底层代码)之外，还有什么方式可供考虑呢？</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: mryufeng</title>
		<link>http://erlang-china.org/misc/little-test_on_erlang-performence.html/comment-page-1#comment-13672</link>
		<dc:creator>mryufeng</dc:creator>
		<pubDate>Tue, 28 Jul 2009 17:00:56 +0000</pubDate>
		<guid isPermaLink="false">http://erlang-china.org/?p=569#comment-13672</guid>
		<description>看了代码才知道 去往IO的binary 只有》256字节的时候是引用计数的. 参看ERL_SMALL_IO_BIN_LIMIT = (4 * ERL_ONHEAP_BIN_LIMIT) = 4 * 64= 256</description>
		<content:encoded><![CDATA[<p>看了代码才知道 去往IO的binary 只有》256字节的时候是引用计数的. 参看ERL_SMALL_IO_BIN_LIMIT = (4 * ERL_ONHEAP_BIN_LIMIT) = 4 * 64= 256</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: mryufeng</title>
		<link>http://erlang-china.org/misc/little-test_on_erlang-performence.html/comment-page-1#comment-13670</link>
		<dc:creator>mryufeng</dc:creator>
		<pubDate>Tue, 28 Jul 2009 10:49:45 +0000</pubDate>
		<guid isPermaLink="false">http://erlang-china.org/?p=569#comment-13670</guid>
		<description>joel的测试是单CPU, 而且是beam模式， 而不是带锁的beam.smp， 这个性能差很多的。。。

http://blog.javaeye.com</description>
		<content:encoded><![CDATA[<p>joel的测试是单CPU, 而且是beam模式， 而不是带锁的beam.smp， 这个性能差很多的。。。</p>
<p><a href="http://blog.javaeye.com" rel="nofollow">http://blog.javaeye.com</a></p>
]]></content:encoded>
	</item>
</channel>
</rss>

