DDR4的内存计算方法
刚转到存储这边，对于内存的计算很模糊，整理了一下网上的各种解释，有了自己的理解。记录下来，希望有帮助

----------------------以下是网络上之前给出的解释------------------

DDR3内存计算

bank地址线位宽为3，及bank数目为 2^3=8；

行地址线位宽位13，及A0…A12；

列地址线位宽为10，及A0…A9；

有 2^3 * 2^13 * 2^10 = 2^26 =2^6Mb = 64Mb

再加上数据线，则容量为 64Mb x 16 = 128M Byte = =1G bit

---------------下面是自己的理解--------------------

下面这个DDR4的容量的计算方法如下（料号为：MT40A1G8WE-083E:B）

下面是下载的相关数据手册的截图



如1Gb8这个，8是数据位宽

2^2 X2^2X 2^16 X2^10X8 = 2^30X8 =2^10MbX8 = 1GbX8=8Gb=1GB

这样理解的：

有4个群，每个群有4个块，每个块有 2^16 X 2^10数量的空间，每个空间存8位数据，那么总的位宽就是1GB
如果是n个DDR4挂在CPU上，那么地址空间是不变的，只是读和存的数据位宽变成了nX8，那整个容量即nX1GB

2018-07-18修改

wal_buffers默认值为-1,此时wal_buffers使用的是shared_buffers,wal_buffers大小为shared_buffers的1/32
autovacuum_work_mem默认值为-1,此时使用maintenance_work_mem的值

1 不使用wal_buffers、autovacuum_work_mem
计算公式为:
max_connections*work_mem + max_connections*temp_buffers +shared_buffers+(autovacuum_max_workers * maintenance_work_mem）

假设PostgreSQL的配置如下:
max_connections = 100
temp_buffers=32MB
work_mem=32MB
shared_buffers=19GB
autovacuum_max_workers = 3
maintenance_work_mem=1GB #默认值64MB

select(
	(100*(32*1024*1024)::bigint)
	+ (100*(32*1024*1024)::bigint)
	+ (19*(1024*1024*1024)::bigint)
	+ (3 * (1024*1024*1024)::bigint )
)::float8 / 1024 / 1024 / 1024
--output
28.25

此时pg满载峰值时最多使用28.25GB内存,物理内容为32GB时,还有3.75GB内存给操作系统使用.
2 使用wal_buffers,不使用autovacuum_work_mem
计算公式为:
max_connections*work_mem + max_connections*temp_buffers +shared_buffers+wal_buffers+(autovacuum_max_workers * autovacuum_work_mem）

假设PostgreSQL的配置如下:
max_connections = 100
temp_buffers=32MB
work_mem=32MB
shared_buffers=19GB	
wal_buffers=16MB #--with-wal-segsize的默认值
autovacuum_max_workers = 3	
maintenance_work_mem=1GB

select(
	(100*(32*1024*1024)::bigint)
	+ (100*(32*1024*1024)::bigint)
	+ (19*(1024*1024*1024)::bigint)
	+ (16*1024*1024)::bigint
	+ (3 * (1024*1024*1024)::bigint )
)::float8  / 1024 / 1024 / 1024
--output
28.26

此时pg满载峰值时最多使用28.5GB内存,物理内容为32GB,还有3.5GB内存给操作系统使用.
3 同时使用wal_buffers、autovacuum_work_mem[建议使用]
计算公式为:
max_connections*work_mem + max_connections*temp_buffers +shared_buffers+wal_buffers+(autovacuum_max_workers * autovacuum_work_mem）+ maintenance_work_mem

假设PostgreSQL的配置如下:
max_connections = 100
temp_buffers=32MB
work_mem=32MB
shared_buffers=19GB	
wal_buffers=262143kb
autovacuum_max_workers = 3
autovacuum_work_mem=256MB
maintenance_work_mem=2GB

select(
    (100*(32*1024*1024)::bigint)
    + (100*(32*1024*1024)::bigint)
    + (19*(1024*1024*1024)::bigint)
    + (262143*1024)::bigint
    + (3 * (256*1024*1024)::bigint )
    + ( 2 * (1024*1024*1024)::bigint )
)::float8  / 1024 / 1024 / 1024
--output
28.01

此时pg载峰值时最多使用28.25GB内存,物理内容为32GB时,还有3.75GB内存给操作系统使用.建议所有内存消耗根据硬件配置,也就是使用这个配置.

Android中有四种，分别是：

ALPHA_8：每个像素占用1byte内存

ARGB_4444:每个像素占用2byte内存

ARGB_8888:每个像素占用4byte内存

RGB_565:每个像素占用2byte内存

Android默认的颜色模式为ARGB_8888，这个颜色模式色彩最细腻，显示质量最高。但同样的，占用的内存也最大。




举例说明一个32位的PNG也就是ARGB_8888,像素是1204*1024,那么占用空间是:

1024*1024*(32/8)

因为8bit = 1 byte, 32位就是4byte. 我们在解析图片的时候为了方式oom最好使用ARGB_4444模式. 节省一半的内存空间.




===================================================================




 Android中一张图片（BitMap）占用的内存主要和以下几个因数有关：图片长度，图片宽度，单位像素占用的字节数。

一张图片（BitMap）占用的内存=图片长度*图片宽度*单位像素占用的字节数

注：图片长度和图片宽度的单位是像素。

图片（BitMap）占用的内存应该和屏幕密度(Density)无关，虽然我暂时还拿不出直接证据。

   创建一个BitMap时，其单位像素占用的字节数由其参数BitmapFactory.Options的inPreferredConfig变量决定。

inPreferredConfig为Bitmap.Config类型，

Bitmap.Config类是个枚举类型，它可以为以下值


Enum Values

Bitmap.Config 

ALPHA_8 

Each pixel is stored as a single translucency (alpha) channel. 

This is very useful to efficiently store masks for instance. No color information is stored. With this configuration, each pixel requires 1 byte of memory.

此时图片只有alpha值，没有RGB值，一个像素占用一个字节

Bitmap.Config 

ARGB_4444 

This field is deprecated. Because of the poor quality of this configuration, it is advised to use ARGB_8888instead.  

这种格式的图片，看起来质量太差，已经不推荐使用。

Each pixel is stored on 2 bytes. The three RGB color channels and the alpha channel (translucency) are stored with a 4 bits precision (16 possible values.) This configuration is mostly useful if the application needs to store translucency information but also
 needs to save memory. It is recommended to use ARGB_8888 instead of this configuration.
一个像素占用2个字节，alpha(A)值，Red（R）值，Green(G)值，Blue（B）值各占4个bites,共16bites,即2个字节

Bitmap.Config 

ARGB_8888 

Each pixel is stored on 4 bytes. Each channel (RGB and alpha for translucency) is stored with 8 bits of precision (256 possible values.) This configuration is very flexible and offers the best quality. It should be used whenever possible
一个像素占用4个字节，alpha(A)值，Red（R）值，Green(G)值，Blue（B）值各占8个bites,共32bites,即4个字节

这是一种高质量的图片格式，电脑上普通采用的格式。它也是Android手机上一个BitMap的默认格式。

Bitmap.Config 

RGB_565 

Each pixel is stored on 2 bytes and only the RGB channels are encoded: red is stored with 5 bits of precision (32 possible values), green is stored with 6 bits of precision (64 possible values) and blue is stored with 5 bits of precision. This configuration
 can produce slight visual artifacts depending on the configuration of the source. For instance, without dithering, the result might show a greenish tint. To get better results dithering should be applied. This configuration may be useful when using opaque
 bitmaps that do not require high color fidelity.
一个像素占用2个字节，没有alpha(A)值，即不支持透明和半透明，Red（R）值占5个bites ，Green(G)值占6个bites  ，Blue（B）值占5个bites,共16bites,即2个字节.对于没有透明和半透明颜色的图片来说，该格式的图片能够达到比较的呈现效果，相对于ARGB_8888来说也能减少一半的内存开销。因此它是一个不错的选择。另外我们通过android.content.res.Resources来取得一个张图片时，它也是以该格式来构建BitMap的.
从Android4.0开始，该选项无效。即使设置为该值，系统任然会采用 ARGB_8888来构造图片


注：ARGB指的是一种色彩模式，里面A代表Alpha，R表示red，G表示green，B表示blue，其实所有的可见色都是红绿蓝组成的，所以红绿蓝又称为三原色。

A　　R　　G　　B
透明度　红色　绿色　蓝色

简单点说


 图片格式（Bitmap.Config）


 占用内存的计算方向


 一张100*100的图片占用内存的大小


 ALPHA_8


 图片长度*图片宽度


 100*100=10000字节


 ARGB_4444


 图片长度*图片宽度*2


 100*100*2=20000字节


 ARGB_8888


 图片长度*图片宽度*4


 100*100*4=40000字节


 RGB_565 


 图片长度*图片宽度*2


 100*100*2=20000字节






另外，需要注意这里的图片占用内存是指在Navtive中占用的内存，当然BitMap使用的绝大多数内存就是该内存。

因为我们可以简单的认为它就是BitMap所占用的内存。

  Bitmap对象在不使用时,我们应该先调用recycle()，然后才它设置为null.

虽然Bitmap在被回收时可以通过BitmapFinalizer来回收内存。但是调用recycle()是一个良好的习惯
在Android4.0之前，Bitmap的内存是分配在Native堆中，调用recycle()可以立即释放Native内存。
从Android4.0开始，Bitmap的内存就是分配在dalvik堆中，即JAVA堆中的，调用recycle()并不能立即释放Native内存。但是调用recycle()也是一个良好的习惯。

通过dumpsys meminfo命令可以查看一个进程的内存使用情况，
当然也可以通过它来观察我们创建或销毁一张BitMap图片内存的变化，从而推断出图片占用内存的大小。
示例：adb shell "dumpsys meminfo com.lenovo.robin"
运行结果。
Applications Memory Usage (kB):
Uptime: 18696550 Realtime: 18696541
** MEMINFO in pid 7985 [com.lenovo.robin] **
            native   dalvik    other    total
            size:     4828     5379      N/A    10207
            allocated:     4073     2852      N/A     6925
            free:       10     2527      N/A     2537
            (Pss):      608      317     1603     2528
            (shared dirty):     2240     1896     6056    10192
            (priv dirty):      548       36     1276     1860


 Objects
   Views:        0        ViewRoots:        0
   AppContexts:        0       Activities:        0
   Assets:        2    AssetManagers:        2
   Local Binders:        5    Proxy Binders:       11
   Death Recipients:        1
   OpenSSL Sockets:        0


 SQL
 heap:        0         MEMORY_USED:        0
 PAGECACHE_OVERFLOW:        0         MALLOC_SIZE:        0

原文地址：内存地址的计算方法 作者：But_Bueatiful





内存是按字节编址的，所以单位是字节哈，1字节可是等于8位的。因为计算的范围一般比较小，所以就记住两个就够了。记住几个常用的2的10次方为1024即1KB

2的20次方=（2的10次方）的平方，即1MB就行了

如果要求更大的，那就再记住2的40次方=（2的10次方）的4次方=1GB，一般就够用了。


DFFFF-A0000 = 3FFFF

一眼看不出来大小滴，或许你要用笔算，不过用这个方法两眼就能看出来：

3FFFF展开为2进制就是2的18次方，是吧，即

2的10次方乘以2的8次方=1K*256即256KB

或者直接2的20次方/2的2次方=2的18次方。一般选就近原则。1MB/4=256KB

32K*8bit=256Kb=(256KB/8bit)

在网上找的另外一道题：

计算机SRAM容量为4K x 8，配置地址首地址为：06800H，则其末地址是多少

    a.38800H     B.10800H   C.077FFH   D.07800H 

分析:

    公式:

    内存容量=末地址-首地址+1

4K*8bit = 4KB即2的平方乘以2的10次方，2的12次方，12/4=3（转为16进制）即1000H

01000H=末地址-6800H+1H

    末地址=01000H+6800H-1H

    末地址=077FFH