2009-04-19

东邪西毒终极版


难怪很多人会说,在看了终极版之后,才终于明白东邪西毒再讲述些什么.

确实,相对东邪西毒,终极版的人物事件的脉络清晰了很多.

在古龙式的背景和叙述手段下,其实人物的性格在本质上不会相差很大.
至少,从影片的叙述角度来说,古龙人物说话语气不会差太多,而且表达方式也不是很直接.

在略带灰黄的荧幕上,有时候,真得很难分清那时张国荣还是梁朝伟.

其实现在看来,这应该是部很简单的片子.
一群爱情关系复杂的人,在叙述着彼此交叉而独立的感情过程.

无非是表达着一个古老的命题,所谓的感情是没有原因的.

太过纠缠情感,就像慕容嫣一样,难以自拔.
在情感的似是而非中无从抉择.
明知道结果,却依然不愿意相信,编造着各种理由以给自己期望.

人有时候就是喜欢麻醉自己.
如同影片反复提到的一句话:记性太好,烦恼就会多.
太过执着纠缠,后果通常只是伤神收场.
于事实不会有太大的影响.

单纯才是所谓快乐的源头.
孤女单纯的坚持,洪七为饭而生活,桃花的无忧无虑.
这都是片子里没有纠结的人物.

西毒大嫂的一句话,或许可以为片子人物的情感做一些注脚:
"明明心里想要,但是嘴巴又不肯讲,一定要你送到面前才行."

太过聪明的人,或者太过自信的人,通常有些自负,不愿意轻易求人.
于是,有时候,机会就在眼前,但是他不会去争取.
因为他会去估量,回去推测,他能找到大概自己去争取的话会得到什么结果.
所以,通常结果是他们不会去主动靠近什么.
如同西毒的一句话,如果你不想被人拒绝,那就先拒绝别人.

他用这句话解释自己离开白驼山庄的缘由.
而其实,这也是他最终没对大嫂说出口的理由.
西毒是个聪明人,但是越是聪明的人越怕被拒绝,况且,他知道,她是喜欢他的.

中国有句话叫聪明反被聪明误,说的大概就是这种情况.
偏偏她也是个聪明的女子.
"最初都由着他,渐渐也就不想理他"
在本应该是非理性博弈的感情中,双方都在用猎人的眼光审视对方.
在等待,等待一个合适的时机,而偏偏两个人等的都是对方的先行动.
于是,最后西毒离开白驼山,她成了大嫂.

所以,有时候,许多事情不光是合适就行,重要的还是争取.

另一个占了较大篇幅的角色应该是剑客,也就是梁朝伟那个角色.
从剧情上可以知道,他是桃花的丈夫,而桃花是桃花岛黄药师喜欢的人.
暂且放下黄药师这个人物.

剑客角色想要表达的是等待.
他说自己三十岁前就会失明,在失明的时候,他想回家,回去看看桃花.
但是,他此生在没有回到桃花岛.

在漫长不定的等待里,他终于失去了阳光,失去了再看桃花的机会.
在从他失明的那天起,他角色的使命就已经结束了.
死,只不过强调了等待的意义.

有时候能等不是一件坏事,坏就坏在你不知道在等什么.
或者,你不知道什么时候能等到.
而与此同时,时间对你来说又有着特殊的意义.
时间的流逝,在消耗着你的其他东西.
为了一个不明确的东西,在不断地付出另外一些不可挽回的东西.
这是应该考虑的问题.
考虑值不值得.

终于,他的死为这个考虑做出了最好的解释.
他只能将桃花留在心里.
他再也看不到桃花了.
他不愿放弃,但又不能不放弃.
所以他即使看不见了,依然点着盏灯.
当他去杀马贼的时候,强吻了孤女.
因为他要记住桃花.
因为他要想桃花道歉.

孤女与他来说只是一个替代物而已.

某种程度上说,死在马贼手上是他自己选的归宿.
不能等到自己想要的,至少也要做自己能做的.

再看看东邪.
有些奇怪为何叫东邪西毒.
西毒是故事的主脉络,而东邪呢?
故事是由西毒叙述的,将他的名字挂载影片名字里无可厚非.

但是,东邪本身的出场次数不多,为何要将其放在片名?
仔细想想,如果说西毒是串起了故事,那么东邪就是串起了人物.
东邪喜欢的女人叫桃花,桃花是剑客的妻子.同时,也因为桃花的原因,东邪和西毒的大嫂有接触.
而也因此,东邪将桃花岛和沙漠联系了起来.
在沙漠这边,东邪会定期找西毒,而西毒又将洪七等人物串了起来.

所以,可以说,东邪其实是故事人物线的中心.
同时注意到他往返的两个地方:
沙漠和桃花岛.

这也应该算是个有意思的地方.
故事里,女人主要在桃花岛,而男人主要在沙漠.
就场景意向来说,桃花是一个比较鲜艳柔性的印象,而沙漠则是刚性粗狂的印象.
或许是有意安排吧.

东邪穿插与这两个地方,充当着交流的信使.
注意到东邪在故事中的主要作用.
一是慕容嫣的故事.
另一个是醉生梦死.

东邪调戏了慕容嫣.
最后却又躲开了慕容嫣.
理由是他喜欢的是桃花.

在拿着醉生梦死再次离开桃花岛去沙漠的时候,东邪明白了女人.
跟慕容嫣的对话让他明白,其实自己的下场会跟西毒一样.
虽然,西毒是因为不愿,而他是不能.
如他自己所说,从一开始他就是输的那个.

也因此,他将醉生梦死带到了沙漠,自己喝了一半,将另一半留给了西毒.
希望西毒能明白.
然后回到桃花岛,解开束缚成为东邪.

东邪希望西毒明白的,西毒没有明白.
直到很多年后,西毒接到大嫂死讯的时候,西毒才开始寻找醉生梦死.
也此发觉西毒根本不是因为喝了醉生梦死才忘记的.
而是以为东邪知道,纠缠明知不可挽回的东西,于人于己都没有好处,不如放弃.
西毒也才明白,为什么东邪要告诉他喝了醉生梦死能够忘记很多东西.

以为醉生梦死并不能帮西毒忘掉过去,不能帮西毒逃避.
所以,西毒明白了.
这个世界,根本没有逃避就能解决的问题.

于是,他回到白驼山庄,回到了他曾经逃避的地方,成为西毒.

总的来说,这是一部看似爱情又非爱情的片子.

或者说,其实很多道理都是一样的.
不管放在哪里,道理还是道理.

2009-04-18

Blogger标签云


发现标签云有些意思.
把单调的标签变得不那么死板了.

于是到处找可以用于blogger的插件.
找到一些,但不是很满意.

于是自己动手写一个简单的先用一样.
当然,思路来源于这个Blog的介绍,在此声明一下.

下面是自己写的,或者说改的标签云.


function getColor( _count , _count_upper_limit )
{
var begin_color = 192.0;
var end_color = 26.0;
var count = _count/1.0;
var count_upper_limit = _count_upper_limit/1.0;

var color = begin_color - (count/count_upper_limit) * (begin_color-end_color);
return [ Math.floor(color) , Math.floor(color*20.0/26.0) , Math.floor(color*5.0/26.0) ];
}


function getFontSize( _count , _count_upper_limit )
{
var begin_font_size = 0.4;
var end_font_size = 2.2;
var count = _count/1.0;
var count_upper_limit = _count_upper_limit/1.0;

return ( begin_font_size + (count/count_upper_limit) *( end_font_size - begin_font_size) );
}

// Max label count;
var maxLabelCount = 0;

var LableUrls = new Object;


var LabelObject = new Object;
var name = "";
var count = "";
var url = "";
LabelObject['name'] = name;
LabelObject['count'] = count;
LableUrls[ url ] = LabelObject;


for( url in LableUrls )
{
if( LableUrls[url]['count'] > maxLabelCount )
{
maxLabelCount = LableUrls[url]['count'];
}
}

for( url in LableUrls )
{
font_size = getFontSize( LableUrls[url]['count'] , maxLabelCount );
colors = getColor(LableUrls[url]['count'] , maxLabelCount );
outputString = "<a href='" + url + "'" + "style='padding-right:0.5em;font-size:" + font_size + "em;color:" + colors[0] + "," + colors[1] + "," + colors[2] + ";'>" + LableUrls[url]['name'] + "</a>";
document.write( outputString );
}


使用的时候将blogger的模板展开,并将上面的内容插入到下面的块中.
getColor和getFont是用来产生颜色和字体大小的,可以感觉自己需要改.
两个参数的意义上,_count为传入标签的个数,_count_upper_limit为最大的标签个数.

举个例子,比如有个名为 杂谈 的标签,这个标签下有4个文章,那么_count = 4.
_count_upper_limit就是所有标签中,_count最大的那个值.

上面例子outputString里将诸如"'<>等符号转移了,免得更新模板的时候出问题.

当时写的时候就是因为这个搞了不少时间.
不过算是学了点JavaScript和CSS : ).















WOW代理权之网易


网易从九城手里拿走了WOW.

然后广大的WOWer为网易此举欢呼.
一来,长久以来对九城的怨气终于得到痛快淋漓的发泄.
二来,是以网易的实力,大家都觉得应该会比九城运营地好.

对于网易的实力,或者说财力,应该是不容质疑的.
在正式宣布取得代理权的同时,网易也发话了.
将不购买九城的服务器,而以现在的标准配备投入新的服务器组.
这是一笔大的投入.

一方面显示出了网易的阔绰,另一方面,也算是对暴雪展示实力的一手.

但是,这与能不能争取到WLK无关.
尽管,WLK审批受阻也许是九城知道不久将失去WOW所以没有卖命公关的结果.
但是,能否已经WLK也算是广大玩家对网易的一点小考验.

除此之外,在WOWer对九城的恨慢慢淡去的时候,能否对网易产生爱是一个问题.
网易能否比九城运营得好,这个或许是个认真考虑的问题.

网域与九城不同,网易自己拥有研发实力,而且,其技术力量在国内算是数一数二的.
在网易扎根的WOW,能否服网易的水土,是个需要时间才能回答的问题.

人们之所以对九城有怨言,是因为九城的服务质量不行.
这跟九城作为吸金工具的角色有关.

当WOW到了网易,如果也只是赚钱工具的话,估计也不回比九城好到哪里去.

想想网易手里的其他几款游戏.
以及网易倾入大量心血的天下贰.

很明显,天下贰有着WOW的影子,在收入WOW之后,天下贰将如何?
或者说,WOW将如何.

这是个和微妙的问题.

相同题材,相似体验.
不同的是一个是点卡游戏,一个是道具游戏.

相信,有相当一部分天下贰玩家是从WOW转过去的.
在网易拿到WOW之后,这些玩家会不会回到WOW,这应该是个值得考虑的问题.

回答WOW就意味着离开天下贰.
也就意味着天下贰玩家的流失.

没有玩家玩的游戏,只能寿终正寝.

问题是,网易会让天下贰慢慢死去,死在自己的手上么?
网易会为了别人的孩子,而杀了自己的孩子么?

网易不会.
以丁磊的境界来说,WOW只是他的棋子,不像九城,当成救命稻草.

但是,玩家不是丁磊,不会说,为了支持国产而拒绝网易的WOW.
那么,网易将如何留住天下贰的玩家?

从现在网易对WOW的大手笔来看,网易似乎是在做一种姿态.
就是,我不是九城,别拿我的WOW跟九城的WOW相比.
这是在告诉暴雪,也是在告诉玩家,网易的WOW跟九城的WOW不是一个档次的.

这样的做法一来稳住了现有玩家的心,就是将来数据交接出现问题,玩家也愿意因为网易这个名字而不去太多计较.
二来,想原先因为九城原因离开WOW的玩家发出回归的信号.
三是向之前对九城没信心而徘徊在WOW之外的玩家招手.

网易的如意算盘就是如此打的.
在留住原有资源的基础上,回收丢失的资源,同时不忘开辟新的玩家群.
这样做的直接目的就是尽可能地做大WOW.

做大WOW对网易有什么好处?
明显的好处就是收入的增加.
单靠一个WOW都能将九城扶起来,那么在网易的运营下,WOW带来的收入,更是不可估量.

网易不缺钱,网易也不求钱.
那为何网易要花大力气去将WOW拿过来呢?

难道网易是因为看到九城玩家水生火热的生活想要解救其出来.
自然不是,那么,网易接手WOW的目的并不是要多拿一个游戏代理而已.

回到之前谈到的天下贰.
天下贰和WOW式同一类型的游戏,这在前面提到了.
而WOW的壮大,也必然多少会对天下贰产生影响.

那么,网易愿意用天下贰换WOW的用意就有些明显了.
用天下贰换WOW.
这无论从哪方面来说,都是一个不错的买卖.

首先,盈利能力不是一个档次的.
但,前面也说过,钱对于网易来说不是问题.
网易也不是那种见钱眼开的货色.

网易求的是技术.

黏上暴雪的网易,在运营WOW的时候,必然会和暴雪在一些技术方面有所接触.
至少,在运营经验和方式上能得到不少帮助.
这个是可以消化到自己的其他类型的游戏甚至其他领域去的.

再谈天下贰.
虽然,表面上,天下贰以为WOW牺牲了.
但是,一个天下贰倒下了,会有千千万万个天下贰站起来.

网易的民族网游梦,网易的技术梦,在暴雪和WOW的金钱号召力下,绝对会加速.

所以,对于天下贰和WOW的关系.
对于代理和自主研发的关系.
恰好跟表面上看起来是相反的.

网易是在用WOW养"天下贰".
用代理养自主研发.

所以,网易的WOW绝不是九城的WOW.
这是毫无疑问的.

WOW代理权之九城


网易,九城,暴雪,WOW.
毫无疑问的,这是这几天的热门关键字.

九城失去了WOW,作为广大的WOW玩家,同时也是九城的用户,却鲜少有为九城惋惜的.
一致的论调是九城自作自受.

在网友的打趣中,九城不幸言中了自己的身世,接近九成的收入来源于WOW.
而失去WOW的九城,能否挺过来,尤其是在这个金融冬天里.
失去了WOW这个收入源,依靠其他游戏的九城,是否会逐渐淡出人们的视野,沦为二流代理,甚至消失?

想来,九城的下场或许应了中国的一句古话,得道多助,失道寡助.

但是,话说回来,现在WOWer们的焦点还刚刚从九城身上移开.
对九城的幸灾乐祸,或许只是对过去九城不满的幸灾乐祸而已.

在九城将逝,网易未来的时候,WOW依然还是九城下面的WOW.

期待久远的WLK能否在网易手上通过审批是个未知数,网易能否比九城运营得好也是个未知数.
也许,在不久,就会有人开始怀念九城.

毕竟,网易不同于九城.

九城只是个代理商,尽管有自己的研发团队.
但是,看看朱骏和上海申花.
可以想到,九城或许只是支撑了大部分或者整个申花.
在没有了WOW九成的收入之后,申花将何去何从也是个问题.

纵观九城手里的牌:
FIFA Online,奇迹世界,卓越之剑以及其他几款游戏.
能替代WOW地位的,或许只有依靠EA了.

也许,朱骏很早就已经想摆脱暴雪的束缚了,也或许,很早开始,暴雪就开始考虑寻找新的代理商.
于是九城和EA的合作变得顺理成章.

不管怎样,九城失去WOW的一个结果是,有可能将暴雪和EA这对宿敌的战场带到网游.
毕竟,在自己还没有拿的出手的网游之前,EA是九城的靠山.

值得注意的是,就在网易宣布获得代理权的时候,朱骏放了几句很有意思的话.
说无论研发部门有什么要求都无条件答应.
这可以看为是朱骏的一句气话,也可能是实话.

九城从WOW也赚了不少钱.
可惜错在投在了申花.
也许代理权转移这件事,能让九城明白,不是自己的孩子,总有一天会走的.

想当年,九城也是意气风发地从久游手里拿走了劲舞团.
如今,轮到自己.
不知道九城心里有什么准备.

或者说,九城有什么打算.
现在开始自主研发是来不及了.
很快,6月九会到来,很快,九城的收入就会锐减9成.
这是个很现实,也是很严峻的问题.

从之前九城的动态来看,九城很早就做好了失去WOW的准备,在积极寻找WOW的替代品.
只是,一直没有成功.

或许,我们不久将看到九城末日的回响.

不管怎样,从九城失去WOW这件事里应该看到,在网游大量吸进,运营商在忙着数钱的时候,也改考虑下退路和发展前景.
不然,养大的孩子,最后跑了的时候,那才是欲哭无泪.

2009-04-14

load_defualt


感觉条件,或从默认配置文件里读取参数配置,或从指定配置文件里读取参数.

如果指定了配置文件,则从配置文件里读取参数.
如果指定了使用默认配置文件配置,则从默认配置文件读取参数.
如果以上都没有指定,则从默认的配置目录读取配置文件.

参数读取的方式都是递归的.
也就是说,如果配置文件包含类似 !include 之类的语句的话,会递归调用search_default_file 这个函数(位于 mysys/default.c line 574 )


// mysys/default.c
/*
Read options from configurations files

SYNOPSIS
load_defaults()
conf_file Basename for configuration file to search for.
If this is a path, then only this file is read.
groups Which [group] entrys to read.
Points to an null terminated array of pointers
argc Pointer to argc of original program
argv Pointer to argv of original program

IMPLEMENTATION

Read options from configuration files and put them BEFORE the arguments
that are already in argc and argv. This way the calling program can
easily command line options override options in configuration files

NOTES
In case of fatal error, the function will print a warning and do
exit(1)

To free used memory one should call free_defaults() with the argument
that was put in *argv

RETURN
0 ok
1 The given conf_file didn't exists
*/


int load_defaults(const char *conf_file, const char **groups,
int *argc, char ***argv)
{
DYNAMIC_ARRAY args;
TYPELIB group;
my_bool found_print_defaults= 0;
uint args_used= 0;
int error= 0;
MEM_ROOT alloc;
char *ptr,**res;
struct handle_option_ctx ctx;
DBUG_ENTER("load_defaults");

init_default_directories();
init_alloc_root(&alloc,512,0);
/*
Check if the user doesn't want any default option processing
--no-defaults is always the first option
*/
if (*argc >= 2 && !strcmp(argv[0][1],"--no-defaults"))
{
/* remove the --no-defaults argument and return only the other arguments */
uint i;
if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+
(*argc + 1)*sizeof(char*)))) //申请内存,并将其添加到alloc的free链表里.返回实际可用区间的指针.
goto err;
res= (char**) (ptr+sizeof(alloc)); //上面char* 指针存放的开始位置.位MEM_ROOT结构预留位置
res[0]= **argv; /* Copy program name */
for (i=2 ; i < (uint) *argc ; i++) //存放参数,忽略已有的 --no-defaults 参数
res[i-1]=argv[0][i];
res[i-1]=0; /* End pointer */
(*argc)--; //忽略 --no-defaults 参数
*argv=res; //重置参数列表
*(MEM_ROOT*) ptr= alloc; /* Save alloc root for free */
DBUG_RETURN(0);
} //以上动作是把main的命令行参数存到自己的内存区域里.MEM_ROOT链表.

group.count=0;
group.name= "defaults";
group.type_names= groups; //groups = { "mysql","client",0 }.

for (; *groups ; groups++)
group.count++;
//至此.group结构初始化完毕.
if (my_init_dynamic_array(&args, sizeof(char*),*argc, 32)) //将args指向指定大小的内存区域.
goto err;

ctx.alloc= &alloc;
ctx.args= &args;
ctx.group= &group;
//conf_file = "my".递归将 'my' 的配置项目写入ctx指定的上下文环境中
error= my_search_option_files(conf_file, argc, argv, &args_used,
handle_default_option, (void *) &ctx); //conf_file = "my" 以上动作,handle_default_option 将option插入到指定的上下文中
/*
Here error contains <> 0 only if we have a fully specified conf_file
or a forced default file
*/
if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+
(args.elements + *argc +1) *sizeof(char*)))) // 在alloc指定的上下文环境中,为参数开辟内存区域
goto err;
res= (char**) (ptr+sizeof(alloc)); //偏移内存链表头数据结构位置

/* copy name + found arguments + command line arguments to new array */
res[0]= argv[0][0]; /* Name MUST be set, even by embedded library */
memcpy((uchar*) (res+1), args.buffer, args.elements*sizeof(char*)); //将命令行参数复制到上下文环境
/* Skip --defaults-xxx options */
(*argc)-= args_used;
(*argv)+= args_used;

/*
Check if we wan't to see the new argument list
This options must always be the last of the default options
*/
if (*argc >= 2 && !strcmp(argv[0][1],"--print-defaults"))
{
found_print_defaults=1;
--*argc; ++*argv; /* skip argument */
}
// 经过场面的参数过滤,重新复制参数到上下文环境
if (*argc)
memcpy((uchar*) (res+1+args.elements), (char*) ((*argv)+1),
(*argc-1)*sizeof(char*));
res[args.elements+ *argc]=0; /* last null */

(*argc)+=args.elements; // 更新参数个数,加上从配置文件读取的参数个数
*argv= (char**) res; // 将agrv重形象到上下文环境的参数区域.即现在存放原有参数和配置文件参数的那块区域
*(MEM_ROOT*) ptr= alloc; /* Save alloc root for free */
delete_dynamic(&args); //释放已经不需要的aggrs.其内容已经放置到上下文环境中了.
if (found_print_defaults)
{
int i;
printf("%s would have been started with the following arguments:\n",
**argv);
for (i=1 ; i < *argc ; i++)
printf("%s ", (*argv)[i]);
puts("");
exit(0);
}
DBUG_RETURN(error);

err:
fprintf(stderr,"Fatal error in defaults handling. Program aborted\n");
exit(1);
return 0; /* Keep compiler happy */
}

alloc_root


此函数经由某些宏开关,被分成了两个部分.
而实际,主要是从170行开始.之前的是另一个部分.
这个函数主要做的是,从free链表里面获取lengt大小的内存块.
如果没有合适大小的块,则用my_malloc申请新的块.

得到块之后,并没有讲块从free里移除.依然在free链表里.
内存块的大小也是不固定的.

alloc_root的代码

// mysys/my_alloc.c
void *alloc_root(MEM_ROOT *mem_root, size_t length)
{
#if defined(HAVE_purify) && defined(EXTRA_DEBUG)
reg1 USED_MEM *next;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: 0x%lx", (long) mem_root));

DBUG_ASSERT(alloc_root_inited(mem_root));

length+=ALIGN_SIZE(sizeof(USED_MEM));
if (!(next = (USED_MEM*) my_malloc(length,MYF(MY_WME))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
DBUG_RETURN((uchar*) 0); /* purecov: inspected */
}
next->next= mem_root->used;
next->size= length;
mem_root->used= next; // 将next链接到root链表
DBUG_PRINT("exit",("ptr: 0x%lx", (long) (((char*) next)+
ALIGN_SIZE(sizeof(USED_MEM)))));
DBUG_RETURN((uchar*) (((char*) next)+ALIGN_SIZE(sizeof(USED_MEM))));
#else
size_t get_size, block_size;
uchar* point;
reg1 USED_MEM *next= 0;
reg2 USED_MEM **prev;
DBUG_ENTER("alloc_root");
DBUG_PRINT("enter",("root: 0x%lx", (long) mem_root));
DBUG_ASSERT(alloc_root_inited(mem_root));

length= ALIGN_SIZE(length);
if ((*(prev= &mem_root->free)) != NULL) //有可用内存区域,此时prev与free链表指向相同.
{
if ((*prev)->left < length &&
mem_root->first_block_usage++ >= ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP &&
(*prev)->left < ALLOC_MAX_BLOCK_TO_DROP)
{
next= *prev;
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
for (next= *prev ; next && next->left < length ; next= next->next)
prev= &next->next;
}
if (! next) //上面的例程没找到合适大小的内存块,则申请新的内存区域
{ /* Time to alloc new block */
block_size= mem_root->block_size * (mem_root->block_num >> 2);
get_size= length+ALIGN_SIZE(sizeof(USED_MEM));
get_size= max(get_size, block_size);

if (!(next = (USED_MEM*) my_malloc(get_size,MYF(MY_WME))))
{
if (mem_root->error_handler)
(*mem_root->error_handler)();
return((void*) 0); /* purecov: inspected */
}
mem_root->block_num++;
next->next= *prev; //将新块添加到free链表头部
next->size= get_size;
next->left= get_size-ALIGN_SIZE(sizeof(USED_MEM));
*prev=next; //重新让pre指向free链表头部
}
//获得内存块之后,减去链表数据结构的大小,得到实际可用内存块大小的起点.
point= (uchar*) ((char*) next+ (next->size-next->left));
/*TODO: next part may be unneded due to mem_root->first_block_usage counter*/
if ((next->left-= length) < mem_root->min_malloc)
{ /* Full block */
*prev= next->next; /* Remove block from list */
next->next= mem_root->used;
mem_root->used= next;
mem_root->first_block_usage= 0;
}
DBUG_PRINT("exit",("ptr: 0x%lx", (ulong) point));
DBUG_RETURN((void*) point);// 返回实际可用内存块的起始位置指针.此时内存块已经列入free链表里
#endif
}

init_alloc_root


代码如下
主要是预处理一下相关数据结构的内容.

init_alloc_root的代码

// my_sys/my_alloc.c
/*
Initialize memory root

SYNOPSIS
init_alloc_root()
mem_root - memory root to initialize
block_size - size of chunks (blocks) used for memory allocation
(It is external size of chunk i.e. it should include
memory required for internal structures, thus it
should be no less than ALLOC_ROOT_MIN_BLOCK_SIZE)
pre_alloc_size - if non-0, then size of block that should be
pre-allocated during memory root initialization.

DESCRIPTION
This function prepares memory root for further use, sets initial size of
chunk for memory allocation and pre-allocates first block if specified.
Altough error can happen during execution of this function if
pre_alloc_size is non-0 it won't be reported. Instead it will be
reported as error in first alloc_root() on this memory root.
*/

void init_alloc_root(MEM_ROOT *mem_root, size_t block_size,
size_t pre_alloc_size __attribute__((unused)))
{
DBUG_ENTER("init_alloc_root");
DBUG_PRINT("enter",("root: 0x%lx", (long) mem_root));
//为MEM_ROOT结构各部分置初始值.保持各链表为空.
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc= 32;
mem_root->block_size= block_size - ALLOC_ROOT_MIN_BLOCK_SIZE;
mem_root->error_handler= 0;
mem_root->block_num= 4; /* We shift this with >>2 */
mem_root->first_block_usage= 0;

#if !(defined(HAVE_purify) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
if ((mem_root->free= mem_root->pre_alloc=
(USED_MEM*) my_malloc(pre_alloc_size+ ALIGN_SIZE(sizeof(USED_MEM)),
MYF(0))))
{
mem_root->free->size= pre_alloc_size+ALIGN_SIZE(sizeof(USED_MEM));
mem_root->free->left= pre_alloc_size;
mem_root->free->next= 0;
}
}
#endif
DBUG_VOID_RETURN;
}






相关的数据结构如下.
USED_MEM代表的是一个内存块.
而MEM_ROOT是一个内存链表.意义参见实现.
这两个数据结构会被反复用到.
参见相应的标签

USED_MEM和MEM_ROOT的代码

// include/my_alloc.h
typedef struct st_used_mem
{ /* struct for once_alloc (block) */
struct st_used_mem *next; /* Next block in use */
unsigned int left; /* memory left in block */
unsigned int size; /* size of block */
} USED_MEM;


typedef struct st_mem_root
{
USED_MEM *free; /* blocks with free memory in it */
USED_MEM *used; /* blocks almost without free memory */
USED_MEM *pre_alloc; /* preallocated block */
/* if block have less memory it will be put in 'used' list */
size_t min_malloc;
size_t block_size; /* initial block size */
unsigned int block_num; /* allocated blocks counter */
/*
first free block in queue test counter (if it exceed
MAX_BLOCK_USAGE_BEFORE_DROP block will be dropped in 'used' list)
*/
unsigned int first_block_usage;

void (*error_handler)(void);
} MEM_ROOT;

投其所好

最近看了持械入宋,发觉AI的发展或者说经济化还是非常一日千里的. 虽然说短剧本身也不是什么新事物了. 甚至AI制作也不是最近才有的. 只是从质量上来说,还是看得出来是有区分度,或者说ROI门槛了的. 这片虽然从服化道方面来说还是普通的AI剧,甚至剧情大半夜还是传统的龙王归来模式....