Linux下Redis内存优化

最近使用Redis，由于它属于内存数据库，所以调优都集中到了内存上。
根据Redis官方说法：

需要将vm.overcommit设置为1
```
sysctl vm.overcommit_memory=1
```
确保设置了一定量的swap，最好和内存一样大，否则内核的OOM（out-of-memory）killer会干掉Redis进程
若Redis是大量写入的应用，持久化的RDB或者AOF会按比例使用，或很有可能使用redis使用量的一样多的内存.

使用和Redis一样多的内存做持久化，那我岂不是都得让一半的内存出来给它？还有那个overcommit是几个意思也不解释一样？搞砸了其他进程肿么办？
好吧，得研究一下内存是如何管理的：
内核会将物理内存分割成动态虚拟的内存页（page），然后在malloc时按overcommit_memory和overcommit_ratio的设置来确定是否允许分配虚拟内存页。
翻看Linux Kernel的文档/资料才发现，有三种值：

overcommit_memory=0，默认，智能超发，每次要求分配内存时，kernel都会比较请求的空间和空余的空间是否足以分配
overcommit_memory=1，请求分配内存时，永远假装还有足够的内存
overcommit_memory=2，不允许超发内存，即允许分配的大小小于

overcommit_ratio*物理内存+swap大小

好吧，Redis要大家假装还有空余内存…也就是说会有很大的几率触发Swap造成性能急剧下降，不过，性能下降总比不能用好。
说到swap，大家肯定给Redis服务器设定过swappiness=0，然后祈祷奇迹的发生，但是还是触发了swap。为什么呢？
首先，Linux十分注重读写性能，尽量避免磁盘IO，你从磁盘上读取的文件会被放入内存，就算程序结束了，还是存在的，这部分内存被称为file
buffer（或者file page），是swap重点照顾的回收对象。其次，Linux上的用户态进程所有页（也就是redis运行时占用的）也是可以回收的。
其实，swap的触发机制是这样的：根据swap倾向（swap_tendency）决定回收用户态页还是file
buffer，最后把LRU队列中用得最少的放入swap空间中。摘自LWN
以下是内核计算其 “swap倾向"的公式：

swap_tendency = mapped_ratio/2 + distress + vm_swappiness

其中：

distress 值是内核在释放内存时遇到的问题数。当内核第一次决定收回内存页面时, distress将为0；尝试次数越多，这个值也越大。
mapped_ratio值是mapped page与总page比例，即
```
mapped ratio = (nr mapped * 100) / total memory
```

nr_mapped可以从下面的命令行获得

 grep nr_mapped /proc/vmstat

vm_swappiness 就是大家设定的swappniness值

当swap_tendency超过100时，swap就开始收集最近较少用的页。而且swappiness设置为0，PRFA就不会回收用户态页，
设置为100时，总是回收用户态页，当然这不是我们想看到的。最后回到之前的问题，怎么避免触发swap？
其实调整好swapiness之后，只需要监测/proc/zoneinfo中的pages free/high
之间的差值即可，high是当前zone中计算出来的高水位值，当pages free低于pages high才会触发swap回收页，就是这么简单啦~
实在担心的话可以用

redis-server --test-memory 需要测试的内存（MB）

测试一下，系统就会在给定的内存下跑测试。

SSDP协议笔记

发表评论

近来在研究SSDP，Simple Service Discovery Protocol (简单服务发现协议)。
这是用来实现无配置，自发现局域网内部服务的协议。由IPv4下有固定的239.255.255.250:1900这一固定的地址来负责多播数据。
不过，从我的学习经历来说，要啃这种东西，最好的方法还是用例子搞懂名词，并实践一次。其实SSDP协议的请求就三种： byebye, alive,
discovery

byebye请求

NOTIFY * HTTP/1.1
Host: 239.255.255.250:1900
NT: someunique:idscheme3
NTS: ssdp:byebye
USN: someunique:idscheme3

NOTIFY 通知所有广播域的机器
HOST 值是固定的（IPv4），算是协议的一部分
NT （Notification Type）这个是GENA的定义，即通知类型,值一般是当前设备的类型
NTS (Notification Sub-Type)通知子类型，如果要遵守SSDP，这个值就代表了请求的类型，但是为什么NTS和NT搞混了呢……协议中写得非常明白

5.3.5. Shouldn’t the NT and NTS values be switched? Yes, they should.
Commands such as ssdp:alive and ssdp:byebye should be NT values and the
service type, where necessary, should be the NTS. The current mix-up is a
consequence of a previous design where the NT header was used in a manner much
like we use the USN today. This really needs to change.

USN 这个设备的UUID，防止设备的IP或者网络环境改变后，连接至错误的设备。

alive（服务上线/广播存活/心跳包）

NOTIFY * HTTP/1.1
HOST: 239.255.255.250:1900
CACHE-CONTROL: max-age=100
LOCATION: http://10.5.4.81:49155/TxMediaRenderer_desc.xml
NT: upnp:rootdevice
NTS: ssdp:alive
USN: uuid:001e4fd3fa0e0000_MR::upnp:rootdevice

CACHE-CONTROL说明这个设备状态至少在100秒内不会过期，过期时，所有设备就必须要刷新这信息，如果得不到新的数据，则认为此设备不可用。如果不提供CACHE-CONTROL或者EXPIRES，此设备的信息将不允许缓存，超时机制由接受端决定
LOCATION此设备的控制点或描述文件所在地

discovery请求

M-SEARCH * HTTP/1.1
Host:239.255.255.250:1900
ST:urn:schemas-upnp-org:device:InternetGatewayDevice:1
Man:"ssdp:discover"
MX:3

M-SEARCH 说明这是强制的搜索方法(由Mandatory Extensions in HTTP中的Mandatory HTTP Requests确定)
ST （search term)搜索条件，指明需要搜索的设备，可以是类型，服务，甚至是UUID，至于怎么回应嘛……那是服务端的事了
Man M-SEARCH请求必须带的数据项，值必须为"ssdp:discover"
MX 优先级，数字越高，优先级越低

服务发现的现实流程

 +---------+ +---------+ +-----------+
| Client | | Server | | Multicast |
+---------+ +---------+ +-----------+
---------------\ | | |
| Initialized |-| | |
---------------- | | |
| | |
| discovery | |
|------------------------------------->|
| | |
| | Client wants ST |
| |< ------------------------|
| | -------------------\ |
| |-| In discovery ST? | |
| | -------------------- |
| | |
| | (In ST) alive |
| |------------------------->|
| | |
| | Here is Server |
|< ------------------------------------|
| | |

好了，这个协议就这么Simple~

跟着Django学设计模式[1]

发表评论

Django作为传说中的又大又重的开源项目，自然而然地使用了很多优秀的设计模式，就让我们看看Django吸收了哪些优秀的设计模式吧。如果没有特殊说明，本文的Django均指Django
1.6 创建模式中Django使用了：

工厂方法模式
惰性初始模式

工厂方法模式

最著名的就是[inlineformset_factory](https://docs.djangoproject.com/en/dev/topics/forms/modelforms
/#inline-formsets)这函数。
应用场景是这样的：假设有两个Model:Book和Author。Book有外键指向Author，这时，如果需要写个关于Author和Book的model表单组（model
formset）时，顿时头疼了有没有，要判断Author是否是新创建的，Book的外键是否符合限制条件等等问题……重新写一个form把它们组合起来？太费事了
BookFormSet = inlineformset_factory(Author, Book) 搞定收工。
这就是工厂方法，根据给定参数产出新的类。

惰性初始模式

用过Django的人都知道settings很重要，但是每次遇到 from django.conf import settings
时，有没有人好奇地看看这个对象到底是什么呢

In [1]: from django.conf import settings
In [2]: type(settings)
Out[2]: django.conf.LazySettings

怎么算个惰性对象呢？假设我们有个需要挺多时间才能得到结果的函数sleepy

def sleepy():
import time
time.sleep(3)
print "Slept 3 seconds"
return True

直接调用sleepy肯定是会等上3秒才有结果的，而当settings里面引入这个函数，

SLEEPY=sleepy()

在from django.conf import settings时并没有暂停3秒，而是调用settings.SLEEPY时才会暂停。
也就是说，你要是永远不用settings.SLEEPY的话，这个函数就永远不会执行，这就是懒–>惰性初始模式啦

小结

Django最常见的设计模式，

工厂方法模式
惰性初始模式

大家应该是经常用的了，只是没有注意到这是"设计模式"，充分证明了"大道至简"，Django简化到了大家都没注意到的地步，可真是成功啊！

Python标准库小窥[1]:weakref

发表评论

平时工作经常能碰到一部分标准库的代码，但是常常因为琐事没有细细地研究这些标准库，直到最近发觉Python不愧是battery
included的语言，因此决定从PyMOTW好好学学。那么就从最常见，但最容易忽略的weakref开始吧！
先让我们看看weakref想解决什么问题。 PyMOTW是这样说的：

Refer to an “expensive” object, but allow it to be garbage collected if
there are no other non-weak references.

引用一个"开销大"的对象，并在只剩下弱引用时允许垃圾回收机制回收这个对象。 PyMOTW中的例子
当obj被显式地删除后（模拟gc回收了），弱引用的proxy和ref的引用对象消失了，不能再取回了。达到了之前希望的只剩下弱引用时允许回收。
如果还有强引用，这些弱引用仍能正常获取值。问题就来了，这个蛋疼的东西到底有什么用？那就是当个智能Cache
比如你有一堆图片文件buffer，你希望通过字典类组成一个cache来存储它们，以获得可观的O(1)读取速度。但是，当这个cache中的图片越来越多时，由于Python自带的gc（垃圾回收机制）没办法收回字典内引用了的项，导致cache越来越大，内存消耗加大，可你又不想用其他方法暂存这些数据到硬盘（因为慢啊！），这时，如果有种方法让这些存储项能自动清除，并能该有多好！
这就是PyMOTW中的Cache例子
可以看到，使用dict的例子中，如果删除了所有引用(all_refs)，cache仍然保留着这些"开销大"的对象，而用WeakValueDictionary就完成了正常回收的过程，保证了cache不会过多地占用系统空间。
还有一种用途，就是保证循环引用可回收 比如有以下节点 A B C，他们相互有指向下个节点的引用（->）表示

A->B
B->C
C->A
即A->B->C->A

当这个引用形成了环形时，如果把其中两个节点（B、C）删除掉，这个环仍能正常工作，

A->B->C->A

但是当我们删掉最后的A节点后，gc就不明白该不该回收这些节点，因此，造成了内存泄漏(leaking) 这个情况正如PyMOTW所示：

After 2 references removed:

one->two->three->one

Collecting...

Unreachable objects: 0

Garbage:[]

Removing last reference:

Collecting...

gc: uncollectable

gc: uncollectable

gc: uncollectable

gc: uncollectable

gc: uncollectable

gc: uncollectable

Unreachable objects: 6

Garbage:[Graph(one),

 Graph(two),

 Graph(three),

 {'name': 'one', 'other': Graph(two)},

 {'name': 'two', 'other': Graph(three)},

 {'name': 'three', 'other': Graph(one)}]

如果使用弱引用的dict就没有这个问题啦～注意，由于WeakDict是构建于dict之上的，因此，不要遍历（iter）这个对象，因为里面的值随时发生变化

Python如何查找Follow关系

发表评论

Twitter中Follower和Followee，现需要找到互相关注的两个人（不关心顺序）例如：现有列表

 l = [(1, 2), (2, 3), (3, 2), (3, 4), (4, 1),
(4, 3), (4, 3)]

可以通过下列函数生成

def gen_pairs():
return (random.randint(0, 30), random.randint(0, 30))
l = [gen_pairs() for x in xrange(20)]

解法一：

import collections
[x for x, y in collections.Counter([tuple(sorted(x)) for x in l]).iteritems() if y > 1]

[tuple(sorted(x)) for x in l] 首先是将列表的内容按小到大重新排列
通过计数器collections.Counter，来统计重复的数量
if y > 1 将大于一个的放入结果集中

最后统计用时best of 3: 38.9 µs per loop ~~老湿，还能给力点吗？~~ 解法二：
[Stackover上的解答](http://stackoverflow.com/questions/22161370/algorithm-to-find-
follow-relationship-like-twitter/22161585#22161585 “Stackover上的解答” )

[x for x in set_l if x[::-1] in set(l)]

快了6倍……答主说到这个算法最快也就是O(n)了，因为必须遍历所有项有木有啊！