blocks|key|4092385|text|IMHO，任何以两个人算术运算的精确幂结束的东西，就像一条快车道。对于二次幂的低水平算术运算，比任何其他数字都需要额外的cpu工作，旋转和位操作的次数更少。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4092386|并找到了可能的副本：Is+it+better+to+allocate+memory+in+the+power+of+two?|offset|length|4092387|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3190146/is-it-better-to-allocate-memory-in-the-power-of-two^0|0|A|1G|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

IMHO, anything ending in exact power of two's arithmeric operation is like a fast track. low level arithmeric operation for power of two takes less number of turns and bit manipulations than any other numbers need extra work for cpu.

And found this possible duplicate:<a href="https://stackoverflow.com/questions/3190146/is-it-better-to-allocate-memory-in-the-power-of-two">Is it better to allocate memory in the power of two?</a>

blocks|key|1469619|text|我们在现代编程语言和现代硬件中需要这一点吗？我想这是很好的做法，但原因是什么呢？
|type|blockquote|depth|inlineStyleRanges|entityRanges|data|1469620|unstyled|1469621|那得看情况。这里有两件事需要考虑：|1469622|对于小于内存页大小的大小，在分配空间的功率为2和任意数字之间没有明显的差别；|ordered-list-item|1469623|您主要是在C#中使用托管数据结构，因此您甚至不知道在下面实际分配了多少字节。|1469624|1469625|1469626|假设您正在使用malloc()进行低级别的分配，那么使用页面大小的倍数将被认为是一个好主意，即4096或8192；这是因为它允许更有效的内存管理。|offset|length|style|CODE|1469627|我的建议是只分配您需要的东西，让C#为您处理内存管理和分配。|1469628|entityMap^0|0|0|0|0|0|0|0|7|8|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|-4|5|C|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|C|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$]]|$1|I|3|J|5|H|7|10|8|@]|9|@]|A|$]]|$1|K|3|-4|5|C|7|11|8|@]|9|@]|A|$]]|$1|L|3|-4|5|C|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|C|7|13|8|@$O|14|P|15|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|C|7|16|8|@]|9|@]|A|$]]|$1|U|3|-4|5|C|7|17|8|@]|9|@]|A|$]]]|V|$]]

<blockquote>
 Do we need this in modern programming languages and modern hardware? I guess its good practice, but what's the reason?
</blockquote>

It depends. There are two things to consider here:

<ol>
<li>For sizes less than the memory page size, there's no appreciable difference between a power-of-two and an arbitrary number to allocate space;</li>
<li>You mostly use managed data structures with C#, so you won't even know how many bytes are really allocated underneath.</li>
</ol>

Assuming you're doing low-level allocation with <code>malloc()</code>, using multiples of the page size would be considered a good idea, i.e. 4096 or 8192; this is because it allows for more efficient memory management.

My advice would be to just allocate what you need and let C# handle the memory management and allocation for you.

blocks|key|4092492|text|在某些情况下，这仍然是有意义的，但我更愿意逐个分析我是否需要这种规范，而不是盲目地把它作为良好的实践。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4092493|例如，在某些情况下，您可能希望使用确切的8位信息(1字节)来寻址表。|4092494|在这种情况下，我会让表的大小为2%5E8。|4092495|Object+table+=+new+Object[256];|code-block|syntax|javascript|4092496|这样，您就可以只使用一个byte来处理表中的任何对象。|offset|length|style|CODE|4092497|即使该表实际上较小，并且没有使用所有256个位置，您仍然可以保证从表到索引和从索引到表之间的双向映射，这可以防止出现错误，例如，如果您有：|4092498|Object+table+=+new+Object[100];|4092499|然后有人(可能是其他人)使用超出表范围的字节值访问它。|4092500|也许这种双射行为可能是好的，也许你可以有其他的方法来保证你的约束。|4092501|也许，鉴于当前编译器的智能性增加，这不再是唯一的好做法了。|4092502|entityMap^0|0|0|0|0|C|4|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|16|8|@$M|17|N|18|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|1A|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1D|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

It still makes sense in certain cases, but I would prefer to analyze case-by-case whether I need that kind of specification or not, rather than blindly use it as good practice.

For example, there might be cases where you want to use exactly 8 bits of information (1 byte) to address a table.

In that case, I would let the table have the size of 2^8.

<pre><code>Object table = new Object[256];
</code></pre>

By this, you will be able to address any object of the table using only one <code>byte</code>.

Even if the table is actually smaller and doesn't use all 256 places, you still have the guarantee of bidirectional mapping from table to index and from index to table, which could prevent errors that would appear, for example, if you had:

<pre><code>Object table = new Object[100];
</code></pre>

And then someone (probably someone else) accesses it with a byte value out of table's range.

Maybe this kind of bijective behavior could be good, maybe you could have other ways to guarantee your constraints.

Probably, given the increase in smartness of current compilers, it is not the only good practice anymore.

blocks|key|1469739|text|可悲的是，如果你想把一个内存块保存在一个4k的内存页中，那是相当愚蠢的。人们甚至不知道:-)+(直到10分钟前我才知道.我只有一个预感)..。一个例子..。它是不安全的代码和实现依赖(使用.NET+4.5在32/64位)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1469740|byte[]+arr+=+new+byte[4096];

fixed+(byte*+p+=+arr)
{
++++int+size+=+((int*)p)[IntPtr.Size+==+4+?+-1+:+-2];
}|code-block|syntax|javascript|1469741|因此CLR至少分配了4096+%2B+(1或2)大(Int).所以它已经超过了一个4k内存页。这是合乎逻辑的。它必须保持数组的大小，并且将它与数组放在一起是最明智的事情(对于那些知道Pascal和BSTR是什么的人来说，是的，这是相同的原则)|offset|length|style|CODE|1469742|我要补充的是，.NET中的所有对象都有一个同步数字和一个RuntimeType.它们至少是int+(如果不是IntPtr+)，所以总共有8到16个字节/对象(这在不同的地方都有解释.如果你感兴趣的话，试着去找.net+object+header+)|1469743|entityMap^0|0|0|2O|4|0|S|B|19|3|1I|6|2W|I|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@$I|W|J|X|K|L]|$I|Y|J|Z|K|L]|$I|10|J|11|K|L]|$I|12|J|13|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$]]

Sadly, it's quite stupid if you want to keep a block of memory in a single memory page of 4k... And persons don't even know it :-) (I didn't until 10 minutes ago... I only had an hunch)... An example... It's unsafe code and implementation dependant (using .NET 4.5 at 32/64 bits)

<pre><code>byte[] arr = new byte[4096];

fixed (byte* p = arr)
{
 int size = ((int*)p)[IntPtr.Size == 4 ? -1 : -2];
}
</code></pre>

So the CLR has allocated at least 4096 + (1 or 2) sizeof(int)... So it has gone over one 4k memory page. This is logical... It has to keep the size of the array somewhere, and keeping it together with the array is the most intelligent thing (for those that know what Pascal Strings and <code>BSTR</code> are, yes, it's the same principle)

I'll add that all the objects in .NET have a syncblck number and a <code>RuntimeType</code>... They are at least <code>int</code> if not <code>IntPtr</code>, so a total of between 8 and 16 bytes/object (This is explained in various places... try looking for <code>.net object header</code> if you are interested)

blocks|key|4092571|text|是的，这是很好的做法，而且至少有一个原因。现代处理器具有64字节的L1缓存行大小，如果您将缓冲区大小用作2%5En+(例如，1024、4096、.)，您将使用完整的缓存行，而不会浪费空间。在某些情况下，这将有助于防止错误共享问题(sharing)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4092572|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/False_sharing^0|35|7|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Yes, it's good practice, and it has at least one reason.
The modern processors have L1 cache-line size 64 bytes, and if you will use buffer size as 2^n (for example 1024, 4096,..), you will take fully cache-line, without wasted space. 
In some cases, this will help prevent false sharing problem (<a href="http://en.wikipedia.org/wiki/False_sharing" rel="nofollow">http://en.wikipedia.org/wiki/False_sharing</a>).

15 years ago, while programming with Pascal, I understood why to use power of two's for memory allocation. But this still seems to be state-of-the-art.

C# Examples:

<pre><code>new StringBuilder(256);
new byte[1024];
int bufferSize = 1 &lt;&lt; 12;
</code></pre>

I still see this thousands of times, I use this myself and I'm still questioning: 

Do we need this in modern programming languages and modern hardware? 
I guess its good practice, but what's the reason? 

EDIT 
For example a <code>byte[]</code> array, as stated by answers here, a power of 2 will make no sense: the array itself will use 16 bytes (?), so does it make sense to use 240 (=256-16) for the size to fit a total of 256 bytes?

Why does everyone use 2^n numbers for allocation? -> new StringBuilder(256)

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

15年前，当我使用Pascal编程时，我明白了为什么要使用两个人的能力来分配内存。但这似乎仍然是最先进的。C#示例：new StringBuilder(256);new byte[1024];int bufferSize = 1 << 12;我还是看到了几千次，我自己也用过这个，我还在质疑：我们在现代编程语言和现代硬件...

问为什么每个人都使用2^n号来分配？->新StringBuilder(256)
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么每个人都使用2^n号来分配？->新StringBuilder(256)EN