久久99精品久久只有精品,国产国产成人精品久久,欧美亚洲另类久久综合婷婷

core和CallStack

feixuwu — Sun, 10 Apr 2011 06:47:00 GMT

最�q�项目开始集中测试了�Q�服务器�E�序�l�常crash�Q�由于服务器一般情况下都是关闭了core的，所以好几次都只能通过杂�ؕ的日志来定位问题�?br>当然�Q�我们可以通过ulimit来打开core开养I��不过�q�可能带来新的问题：我们的服务器�E�序每个core文�g大概�?G多，��试期间如果频繁crash,没有注意及时清理�Q�一不小心就会把��盘写满�Q?br>而且core文�g毕竟是和�q�程�E�序相关的，有时候找相应版本也是个麻烦事�?br>
能否在程序crash的时候，��callStack以及参数和局部变量都记录到日志里�Q?br>�q�个技术其实在游戏客户端已�l�用了很多年了，一般游戏客��L��crash后，都会弹出一个是否发送错误的选择框，其实��是发送的CallStack的日志和MiniDUmp文�g�?br>要想记录CallStack��必然涉及到Stack的遍历，linux下的Stack遍历使用很简单，��单的backtrace��可以搞定，man backtrace��有现成的例子，
�q�比windows下复杂的头疼的StackWalk好用的多�?br>
解决了Stack遍历问题后，�q�剩下一个问题：如何在程序crash的时候得到通知执行我们自己的dump代码�Q?br>在Windwos下有SEH异常来实现这个功能，而linux下可以通过使用信号在进�E�crash的时候执行自��q��处理代码�?br>
好了�Q�开始写个简单代码测试下:
首先讄��几个主要crash信号的处理函�?br>signal(SIGSEGV, &DumpHelper::OnCrash);
signal(SIGABRT, &DumpHelper::OnCrash);
signal(SIGFPE, &DumpHelper::OnCrash);

在OnCrash里我们用前面提到的backtrace�p�d��函数�Q�来记录堆栈:
void* szStackFrame[100];
int nFrameCount = backtrace(szStackFrame, 100);
char** strFrameInfo = backtrace_symbols(szStackFrame, nFrameCount);
char szDumpFileName[1024] = {0};
snprintf(szDumpFileName, sizeof(szDumpFileName), "dump_%u.log", (unsigned int)time(NULL) );
FILE* pFile = fopen(szDumpFileName, "wb");
if(!pFile) return;
for(int i = 0; i < nFrameCount; i++)
{
fprintf(pFile, "%s\n", strFrameInfo[i]);
}
fclose(pFile);
free(strFrameInfo);

接着�Q�设�|�几个嵌套调用的函数�Q?br>void fun()
{
//assert(0);
int* p = NULL;
*p =3;
}

void fun1()
{
fun();
}

void fun2()
{
fun1();
}

void fun3()
{
fun2();
}

最后，我们在main函数里执行fun3,注意�~�译的时候带�?rdynamic 选项�?span class=Apple-style-span style="WORD-SPACING: 0px; FONT: medium Simsun; TEXT-TRANSFORM: none; COLOR: rgb(0,0,0); TEXT-INDENT: 0px; WHITE-SPACE: normal; LETTER-SPACING: normal; BORDER-COLLAPSE: separate; orphans: 2; widows: 2; webkit-border-horizontal-spacing: 0px; webkit-border-vertical-spacing: 0px; webkit-text-decorations-in-effect: none; webkit-text-size-adjust: auto; webkit-text-stroke-width: 0px">

�q�行下，果然可以打印基本的堆栈，不过马上�Q�发��C��新的问题�Q�这个堆栈信息也太简陋了�Q�只有调用函数的名字�Q�其余的参数、局部变量完全没有，
�q�个和gdb能看到的callStack差距也太大了�?br>解决�q�个问题最��单的办法��是用gdb来打印堆�?在这里，gdb和其他程序有区别�Q�如果你试图通过 echo "bt"|gdb -p XXX>a.txt来获得堆栈，那将会非常失望，
�Ҏ��不�v作用�Q�google了下�Q�基本没什么解军_��法�?br>不过gdb 可以从文件读入指令，例如 gdb XXXsystem("echo \"bt full|gcore\">testcmd");
  char dbx[160]={0};
    sprintf(dbx, "gdb -p %d ./maingdbdump_%d.log", getpid(), getpid() );
  system(dbx);

��试�q�行�Q�发现可以打印详�l�的堆栈�Q�不�q�，要求机器上有gdb.
上面的命令还dump了一个core文�g�Q�不�q�这个core文�g的堆栈信息是错误的，我不知道��Z��么。。。�?br>
多线�E�环境下使用上述办法�Q�只能输��Z��个线�E�的堆栈�Q�需要先获取�U�程数目�Q�然后逐个�U�程打印堆栈�?br>
最后，��Z��避免影响正常的coredump,要在OnCrash的处理函数里��信��L��处理函数讄��为默认�?br>如果我一定要有core呢，setrlimit吧，��L��core限制卛_��?/span>

feixuwu 2011-04-10 14:47 发表评论

GCC��目�~�译速度优化

feixuwu — Sat, 19 Mar 2011 08:39:00 GMT

   我们的新��目是在linux�q�_��下运行的�Q�本人是Linux和windows下都开发过�Q�我呆的2个linux后台��目都是所有代码放在一块，�~�译成一个可
执行文�g�Q�基本不考虑�~�译成动态库�Q�所有代码的头文件依赖也是一团糟�Q�随着��目的增大，�~�译速度��来��慢�Q�到后来�~�译一个项�?�q�程同时�~�译都需�?0来分钟�?br>
其实分析下可以发玎ͼ�主要的编译速度损耗在头文件上�Q�尤其是模板相关的头文�g。VC有一个预�~�译头文件技术，��常用的公共头文件放在一��P��预先�~�译成pch文�g�Q�这�?br>可以加快�~�译速度。gcc到底有没有类似技术呢�Q�打开gcc的手册搜索了precompiled�Q�发现还真有相关介绍�Q��用方法也很简单�?br>
主要是以下步骤：
1、在��目下徏立一�?stdafx.h的文�Ӟ��包含了大部分公共头文件。在每个cpp最开始都#include "stdafx.h"。cpp文�g包含了这个预�~�译头文件后�Q�就可以��原来和
stdafx .h 里头文�g重复的内容删除了�Q�尤其是模板相关的头文�g�Q�另外，非PCH的头文�g里尽量少包含其他头文件�?nbsp;
2、修改makefile文�g, 加入OBJ�?gch的依�?用一个简单的��目做示例，一看就明白

TARGET=TimerTest
PCH=stdafx.h.gch
PCH_H=stdafx.h
OBJ=stdafx.o TimerManager.o TimerTest.o

%.o:%.cpp
    g++ -Wall -c -g $^ -o $@

$(TARGET):$(OBJ)
    g++ -g $^ -o $@

pch.d:stdafx.cpp
    g++ -g -MM stdafx.cpp |sed 's/stdafx.o/stdafx.h.gch/'>$@

-include pch.d

$(OBJ):$(PCH)
$(PCH):
    g++ $(PCH_H)

clean:
    rm -f $(OBJ) $(PCH)

完成以上内容后，make clean,再重新编译，初步估计只需�?分钟�Q�！整整优化�?-5倍�?br>

feixuwu 2011-03-19 16:39 发表评论

定时器的实现

feixuwu — Sun, 13 Mar 2011 14:06:00 GMT

最新换了个��目�l�，阅读代码后，发现Server端代码居然没有事件和定时器。由于没有事�Ӟ��所以各个模块代码互相调用的地方特别多，��D��代码�l�构混�ؕ�Q�所有代码都攑֜�一块，乱成一锅粥了�?br>没有定时器，所有需要定时的��d��Q�都只能��d��c�M��OnUpdate的函敎ͼ�在主循环的时候执行。定旉��求少的时候，看不出明昄��问题�Q�但是一旦这�U�需求多了，��其是很多内部对象有定时需求的时候，
�q�个问题��比较明显了�Q�写好了OnUpdate后，�q�要建立一条从��d�@环MainLoop到自�w�OnUpdate的调用链�?br>
事�g其实��是一个广播和订阅的关�p�，Delegate��是实现�q�样一套机制的利器�Q�目前Delegate的实��C��要有2�U�，一�U�是CodeProject上的一个FastDelegate实现�Q�另外一个比较典型的实现��是boost�?br>实现了，无论采取哪种实现�Ҏ��Q�实现难度都不算太大�?br> Server当前框架对定时器无�Q何支持，只有一个DoMainLoop的函数可以派生来�q�行自己的定旉��辑�?br> 我原来都是用的ACE��装的组�Ӟ��用了一�D�|��间也没发现明��N��题，不过ACE的定时器不太适合在这个新��目用，主要原因有如下几点：
1、ACE库太大了�Q�不想仅仅�ؓ了定时器引入一个这么庞大的库�?br> 2、ACE的定时器需要额外启动一个定时器�U�程�Q�定时�Q务是在定时器�U�程跑的�Q�而我们的��目逻辑其实是在单个�U�程�q�行的，如果直接采用ACE定时器，会给逻辑带来额外的复杂度。由于整个逻辑�U�程的框架是公共模块�Q�手头也没有代码�Q�所以将定时器线�E�的��d��发送到主逻辑�U�程�q�行也是不可行的�?br> 3、ACE的定时器有很多种�Q�TIMER_QUEUE、TIMER_WHELL、TIMER_HEAP�{�，个�h感觉�q�些定时器的插入、取消操作都比较耗时�Q�加以改装放��C��U�程run的带价将会很大�?br>
其实linux内核��有一个比较高性能的定时器�Q�代码在kernel/Timer.c里， 2.6内核的定时器代码更是��z��?br>linux的定时�Q务都是以jiffie 为单位的�Q�linux��所有定时�Q务分�?个阶梯，
struct tvec {
   struct list_head vec[TVN_SIZE];
};

struct tvec_root {
   struct list_head vec[TVR_SIZE];
};

struct tvec_base {
   spinlock_t lock;
   struct timer_list *running_timer;
   unsigned long timer_jiffies;
   struct tvec_root tv1;
   struct tvec tv2;
   struct tvec tv3;
   struct tvec tv4;
   struct tvec tv5;
} ____cacheline_aligned;

对一个新的定时�Q务，处理�Ҏ��如下:
static void internal_add_timer(struct tvec_base *base, struct timer_list *timer)
{
   unsigned long expires = timer->expires;
   unsigned long idx = expires - base->timer_jiffies;
   struct list_head *vec;

   if (idx < TVR_SIZE) {
       int i = expires & TVR_MASK;
       vec = base->tv1.vec + i;
   } else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
       int i = (expires >> TVR_BITS) & TVN_MASK;
       vec = base->tv2.vec + i;
   } else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
       int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
       vec = base->tv3.vec + i;
   } else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
       int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;
       vec = base->tv4.vec + i;
   } else if ((signed long) idx < 0) {
       /*
       * Can happen if you add a timer with expires == jiffies,
       * or you set a timer to go off in the past
       */
       vec = base->tv1.vec + (base->timer_jiffies & TVR_MASK);
   } else {
       int i;
       /* If the timeout is larger than 0xffffffff on 64-bit
       * architectures then we use the maximum timeout:
       */
       if (idx > 0xffffffffUL) {
           idx = 0xffffffffUL;
           expires = idx + base->timer_jiffies;
       }
       i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;
       vec = base->tv5.vec + i;
   }
   /*
   * Timers are FIFO:
   */
   list_add_tail(&timer->entry, vec);
}
从上可以看到Linux对定时器的处理：对即��在TVR_SIZE 个jiffies内到辄��定时��d��Q�将它挂到第一�l�tv1 下，具体��是挂到expires & TVR_MASK 对应的列表上厅R�?br>同一个jiffies到达的定时器是挂在同一个链表的�?br>同理�Q�挂到第二个�l�的�?到期旉��于 1 << (TVR_BITS + TVN_BITS) jiffies的�?br>挂到�W�三个组的是到期旉��于1 << (TVR_BITS + 2 * TVN_BITS) jiffies的�?br>挂到�W�四个组的是到期旉��于 1 << (TVR_BITS + 3 * TVN_BITS) jiffies的�?br>��过1 << (TVR_BITS + 3 * TVN_BITS) 的挂到第五组�?br>�q�样�Q�所有到期的��d��都会在第一�l�。�Q何时刻都可以直接通过当前jiffies&TVR_SIZE 来找到需要运行的定时器�Q务列表，定时器的插入效率��是O(1)�?br>
下面是定时器的运行代码：
static int cascade(struct tvec_base *base, struct tvec *tv, int index)
{
   /* cascade all the timers from tv up one level */
   struct timer_list *timer, *tmp;
   struct list_head tv_list;

   list_replace_init(tv->vec + index, &tv_list);

   /*
   * We are removing _all_ timers from the list, so we
   * don't have to detach them individually.
   */
   list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
       BUG_ON(tbase_get_base(timer->base) != base);
       internal_add_timer(base, timer);
   }

   return index;
}

#define INDEX(N) ((base->timer_jiffies >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)

/**
* __run_timers - run all expired timers (if any) on this CPU.
* @base: the timer vector to be processed.
*
* This function cascades all vectors and executes all expired timer
* vectors.
*/
static inline void __run_timers(struct tvec_base *base)
{
   struct timer_list *timer;

   spin_lock_irq(&base->lock);
   while (time_after_eq(jiffies, base->timer_jiffies)) {
       struct list_head work_list;
       struct list_head *head = &work_list;
       int index = base->timer_jiffies & TVR_MASK;

       /*
       * Cascade timers:
       */
       if (!index &&
           (!cascade(base, &base->tv2, INDEX(0))) &&
               (!cascade(base, &base->tv3, INDEX(1))) &&
                   !cascade(base, &base->tv4, INDEX(2)))
           cascade(base, &base->tv5, INDEX(3));
       ++base->timer_jiffies;
       list_replace_init(base->tv1.vec + index, &work_list);
       while (!list_empty(head)) {
           void (*fn)(unsigned long);
           unsigned long data;

           timer = list_first_entry(head, struct timer_list,entry);
           fn = timer->function;
           data = timer->data;

           timer_stats_account_timer(timer);

           set_running_timer(base, timer);
           detach_timer(timer, 1);
           spin_unlock_irq(&base->lock);
           {
               int preempt_count = preempt_count();
               fn(data);
               if (preempt_count != preempt_count()) {
                   printk(KERN_ERR "huh, entered %p "
                           "with preempt_count %08x, exited"
                           " with %08x?\n",
                           fn, preempt_count,
                           preempt_count());
                   BUG();
               }
           }
           spin_lock_irq(&base->lock);
       }
   }
   set_running_timer(base, NULL);
   spin_unlock_irq(&base->lock);
}
当第一�l�运行完一轮后�Q�需要将tv2的一�l�新的定时�Q务加到第一�l�。这��好比时钟的指针�Q�秒针运行一圈后�Q�分针步�q�一��|��后箋的调整都是类伹{�?
cascade ��是负责��下一�l�的定时��d��d��到前面的��d��阶梯。只有当�W�一轮的定时��d��全部�q�行完毕后，才会需要从�W�二轮调入新的�Q务，只有�W�二�U�别的�Q务都调入完毕后，才需要从�W�三轮的定时��d��调入新的��d��Q?br> if (!index &&
           (!cascade(base, &base->tv2, INDEX(0))) &&
               (!cascade(base, &base->tv3, INDEX(1))) &&
                   !cascade(base, &base->tv4, INDEX(2)))
           cascade(base, &base->tv5, INDEX(3));

�q�就是负责调整的代码�Q�相当的��z��?br>参照上述代码实现一个定时器后，加入4000个定时�Q务：
    for(int i = 1; i < 4000; i++)
   {
       g_TimerHandle[i] = g_timerManager.setTimer(&tmpSink1, i, i*10, "ss");
   }
�?0毫秒�?000*10毫秒,�q�行后，��试下性能�Q?br>函数�?nbsp;                                   执行�ơ数    最��时�?nbsp;    �q�_��旉��       最大时�?br>TimerManager::runTimer    2170566        10              10               3046
可以看到�Q�除了个别时间是因�ؓ�U�程切换��D��数据比较大外,�q�_��每次�q�行runTimer的时间是10微秒�?br>�q�个旉��q�包括每个定时器的执行消耗，效率�q�是不错的�?br>

feixuwu 2011-03-13 22:06 发表评论

feixuwu — Sat, 25 Sep 2010 13:44:00 GMT

最�q�游戏又要封��了�Q�工作比较紧张，晚上下班了比较篏�Q�回家懒得写代码了，不过��Z��倒是�l�箋完成了对新剑侠情�~�（和月�׃��说的资源格式相同�Q�的资源逆向。完成了资源逆向后，�H�然兴致来了�Q�写了个��单的地图查看器，到目前�ؓ止，一切运行正常。后来做了个��单的Demo�Q�实��C��基本的寻路和技能动��L��放，其实新剑侠情�~�原本的技能效果以今天的眼光看��h��也还可以�Q�即便如此，我还是集成了hge的粒子系�l�进去，试了下效果，�q�是挺奇怪的�?br>做完了这些之后，本想为我的PSP山寨一个新剑侠情缘。不料后来连�l�加了好几天班，加了几天班之后，��Z��懒了�Q�山寨游戏的事情也就无疾而终了�?br>前面写过几篇逆向工程的文章，前几天翻出来看了下，感觉像是另一个�h写的天书�Q�我自己看自��q��文章��且如此�Q�别人就更不用说了，其实对大部分��言�Q�关心的只是逆向的成果。对新剑侠情�~�的资源和相��x��染感兴趣的朋友可以单独Email我�?
开始阅读Ogre代码正是在这百无聊赖的状态下开始的�Q�Ogre推出来很多年了，貌似05�q�就听说朋友说�v�q�这个项目，不过我一向是专注服务端开发，对客��L��开发经验不是很多，�?D领域��完全是的新手了�Q�所以一直也没仔�l�研�I�。这几天拿�v原来下蝲的一个版本，��单读了下代码�?br>Ogre的结构还是很清晰的，和手册上说的一��P��主要��是那几个对象，Demo大部分也很简单，代码量不多，看�v来很振奋人心�?br>但是�Ҏ��q�样的新手来��_��首先想了解的当然是渲染流�E��?Ogre的渲染流�E�确实会�?D新手不适应�Q�它是从RenderTarget开始的�Q�一个RenderTarget可以有几个ViewPort�Q�每个ViewPort都有一个独立的摄像机，�q�可以实现同屏幕多个渲染�?br>通过ViewPort对象的update调用
mCamera->_renderScene(this, mShowOverlays);
来执行场景渲染，而场景渲染里�Q�最重要的要��_findVisibleObjects了，
�q�个函数��可见的物体��d��到渲染队列里�Q�这个函数非常的�l�，里面�q�用��C��Vistor,�_��不好�Ҏ��被绕晕，好在我挺住了�Q�熬�q�来了�?br>熟悉了大致的渲染��程后，我觉得该写点东西来实战了�?br>3D教程的开始一般会教大家画三角形，所以我也想用Ogre��M��三角形玩玩，
一开始，我也想从像那些Demo一样从ExampleApplication�l�承�Q�不�q�我发现�q�样启动太慢了，而且我不需要加载那么多的材质，
所以自己手动Configure了，代码如下:
Ogre::LogManager* pLogManager = new Ogre::LogManager;
   Ogre::Log* pLog = pLogManager->createLog("ogreLearn1.log");
   pLog->setDebugOutputEnabled(true);

   Ogre::Root* pRootObject = new Ogre::Root;
   pRootObject->loadPlugin("RenderSystem_Direct3D9_d.dll");
   pRootObject->loadPlugin("Plugin_OctreeSceneManager_d.dll");

    Ogre::RenderSystem* pRenderSystem = pRootObject->getRenderSystemByName("Direct3D9 Rendering Subsystem");
    pRenderSystem->setConfigOption("Full Screen", "False");
    pRootObject->setRenderSystem(pRenderSystem);
    Ogre::RenderWindow* pRenderWindow = pRootObject->initialise(true);

�~�译��试了下�Q�可以正常运行，不过发现屏幕是花的，我还没有创徏场景呢，�l�箋��d��摄像机和ViewPort以及场景
// 创徏场景和摄像机以及ViewPort
   Ogre::SceneManager* pSceneManager = pRootObject->createSceneManager(Ogre::ST_GENERIC, "OgreLearn1");
   Ogre::Camera* pCamera = pSceneManager->createCamera("MainCamara");
   pCamera->setPosition(0.0, 0.0, -20.0);
   pCamera->lookAt(0, 0, 0);
   pCamera->setNearClipDistance(2);

   Ogre::Viewport* pViewPort = pRenderWindow->addViewport(pCamera);
   pViewPort->setBackgroundColour(Ogre::ColourValue(0, 0, 0, 1.0f) );
   pCamera->setAspectRatio(pViewPort->getActualWidth()/pViewPort->getActualHeight() );

最后加上pRootObject->startRendering();
�~�译�q�行�Q�一切正常，屏幕颜色也变成了惌��的黑�Ԍ��恩，下一步该��d��三角形了�Q�我不太喜欢用OgreManualObject�Q�一堆的�J�琐操作。这里用自定义的Mesh来绘�?角�Ş�?br>pSceneManager->setAmbientLight(Ogre::ColourValue(0.2, 0.2, 0.2) );
       Ogre::MeshPtr pMeshData = Ogre::MeshManager::getSingleton().createManual("Learn", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
       Ogre::SubMesh* pSubMesh = pMeshData->createSubMesh();
       pSubMesh->useSharedVertices = false;
       pSubMesh->vertexData = new Ogre::VertexData;
       pSubMesh->vertexData->vertexStart = 0;
       pSubMesh->vertexData->vertexCount = 3;

先设�|�了环境�?其实没啥用，我后面会��止)�Q�然后创��Z��一个自定义的Mesh,
紧接着的是创徏一个SubMesh�Q�要知道Ogre中最��的�|�格��是SubMesh,创徏好SubMesh后，要填充网格结构了�Q?br>创徏了一个VertexData,讄��点数目�?�Q�也��是一个三角�Ş�Q�，下面该定义顶�Ҏ��式了�Q?br>Ogre::VertexDeclaration* pDecle = pSubMesh->vertexData->vertexDeclaration;
       size_t sOffset = 0;
       pDecle->addElement(0, sOffset, Ogre::VET_FLOAT3, Ogre::VES_POSITION);
       sOffset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
       pDecle->addElement(0, sOffset, Ogre::VET_COLOUR, Ogre::VES_DIFFUSE);
       sOffset += Ogre::VertexElement::getTypeSize(Ogre::VET_COLOUR);

上述代码定义了顶�Ҏ��式，只有基本的坐标和颜色�?br>下一步将是申��h��存，填充��点�l�构�?br>Ogre::HardwareVertexBufferSharedPtr vBuf = Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(sOffset, 3, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY);
       float* pReal = static_cast(vBuf->lock(Ogre::HardwareBuffer::HBL_DISCARD));
       Ogre::RGBA* pColor = NULL;

       *pReal++ = -2.0f;
       *pReal++ = 0.0f;
       *pReal++ = 0.0f;
       pColor = (Ogre::RGBA*)pReal;
       pRenderSystem->convertColourValue(Ogre::ColourValue(1.0f, 0.0, 0, 0.0f), pColor);
       pReal = (float*)(pColor+1);

        *pReal++ = 0.0f;
        *pReal++ = 2.0f;
        *pReal++ = 0.0f;
        pColor = (Ogre::RGBA*)pReal;
        pRenderSystem->convertColourValue(Ogre::ColourValue(0.0f, 0, 1.0, 1.0f), pColor);
        pReal = (float*)(pColor+1);

        *pReal++ = 2.0f;
        *pReal++ = 0.0f;
        *pReal++ = 0.0f;
        pColor = (Ogre::RGBA*)pReal;
        pRenderSystem->convertColourValue(Ogre::ColourValue(1.0f, 0, 0, 1.0f), pColor);
        pReal = (float*)(pColor+1);
        vBuf->unlock();
        pSubMesh->vertexData->vertexBufferBinding->setBinding(0, vBuf);

        pMeshData->load();
        pMeshData->_setBounds(Ogre::AxisAlignedBox(-2, 0, -1, 2, 2, 1) );
填充��点后，讄��|�格包围盒，�q�样一个自定义的网格就创徏好了�Q�接下来要创��Z��个��用该�|�格的实体了
    Ogre::Entity* pEntity = pSceneManager->createEntity("TestEntity", "Learn");
       pEntity->setMaterialName("BaseWhiteNoLighting");

       pSceneManager->getRootSceneNode()->createChildSceneNode()->attachObject(pEntity);
       pEntity->getParentNode()->setPosition(3, 0, 0);
       pEntity->getParentNode()->rotate(Ogre::Quaternion(1.0f, 1.0f, 0, 1.0f) );

好了�Q�这样实体也创徏好了�Q�接下来执行渲染吧：
pRootObject->startRendering();

遇到的问�?/h2> 上述代码是运行正常的�Q�但是一开始，我执行的�l�果是看不到��M��东西�Q�跟�t�了下，发现实体每次都被摄像��剪了�Q�才发觉自定义Mesh要自��p��|�包围盒子，
讄��可包围盒子�?br> 讄��了包围盒后，数据已经�q�入了D3D的渲染管道，但是�q�是没看��C��角�Ş�Q�仔�l�观察，原来摄像机对着的是三角形的背面。。�?br>调整摄像机后�Q�终于能看到一个三角�Ş了，不过是白色的。。�?br>从这个症状看�Q�应该是没有关闭光照��D��的，但是我明明主动调用RenderSystem关闭光照了啊�Q�仔�l�跟�t�了下原来是材质在捣乱，
默认的材质是开启了光照的，所以在渲染前的SceneManager::_setPass 的时候，开启了光照�?br>�q�好办，��d��讄��了关闭光照的材质"BaseWhiteNoLighting" 后，�l�于看到了彩色三角�Ş了�?br>

feixuwu 2010-09-25 21:44 发表评论

select �?epoll

feixuwu — Sat, 10 Jul 2010 10:40:00 GMT

最�q�有朋友在面试的时候被问了select 和epoll效率差的原因�Q�和一般�h一��P��大部分都会回�{�select是轮询、epoll是触发式的，所以效率高。这个答案听上去很完��，大致也说��Z��二者的主要区别�?br>今天闲来无事�Q�翻看了下内�总�码，�l�合内核代码和大家分享下我的观点�?br>

一、连接数

我本��Z��曄��在项目中用过select和epoll,对于select�Q�感触最��q��是linux下select最大数目限�?windows 下似乎没有限�?�Q�每个进�E�的select最多能处理FD_SETSIZE个FD(文�g句柄)�Q?br>如果要处理超�q?024个句柄，只能采用多进�E�了�?br>常见的��用slect的多�q�程模型是这��L��Q?一个进�E�专门accept�Q�成功后��fd通过unix socket传递给子进�E�处理，父进�E�可以根据子�q�程负蝲分派。曾�l�用�q?个父�q�程+4个子�q�程承蝲了超�q?000个的负蝲�?br>�q�种模型在我们当时的业务�q�行的非常好。epoll在连接数斚w��没有限制�Q�当然可能需要用戯��用API重现讄��q�程的资源限制�?br>

二、IO差别

1、select的实�?/h2> �q�段可以�l�合linux内核代码描述了，我��用的�?.6.28�Q�其�?.6的代码应该差不多吧�?br>先看看select:
select�pȝ��调用的代码在fs/Select.c下，
asmlinkage long sys_select(int n, fd_set __user inp, fd_set __user outp,
           fd_set user exp, struct timeval user tvp)
{
   struct timespec end_time, to = NULL;
   struct timeval tv;
   int ret;

   if (tvp) {
       if (copy_from_user(&tv, tvp, sizeof(tv)))
           return -EFAULT;

       to = &end_time;
       if (poll_select_set_timeout(to,
               tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),
               (tv.tv_usec % USEC_PER_SEC) NSEC_PER_USEC))
           return -EINVAL;
   }

   ret = core_sys_select(n, inp, outp, exp, to);
   ret = poll_select_copy_remaining(&end_time, tvp, 1, ret);

   return ret;
}
前面是从用户控�g拯��各个fd_set到内核空��_��接下来的具体工作在core_sys_select中，
core_sys_select->do_select,真正的核心内容在do_select里：
int do_select(int n, fd_set_bits fds, struct timespec end_time)
{
   ktime_t expire, to = NULL;
   struct poll_wqueues table;
   poll_table wait;
   int retval, i, timed_out = 0;
   unsigned long slack = 0;

   rcu_read_lock();
   retval = max_select_fd(n, fds);
   rcu_read_unlock();

   if (retval < 0)
       return retval;
   n = retval;

   poll_initwait(&table);
   wait = &table.pt;
   if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {
       wait = NULL;
       timed_out = 1;
   }

   if (end_time && !timed_out)
       slack = estimate_accuracy(end_time);

   retval = 0;
   for (;;) {
       unsigned long rinp, routp, rexp, inp, outp, exp;

       set_current_state(TASK_INTERRUPTIBLE);

       inp = fds->in; outp = fds->out; exp = fds->ex;
       rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;

       for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
           unsigned long in, out, ex, all_bits, bit = 1, mask, j;
           unsigned long res_in = 0, res_out = 0, res_ex = 0;
           const struct file_operations f_op = NULL;
           struct file file = NULL;

           in = inp++; out = outp++; ex = exp++;
           all_bits = in | out | ex;
           if (all_bits == 0) {
               i += NFDBITS;
               continue;
           }

           for (j = 0; j < NFDBITS; ++j, ++i, bit <<= 1) {
               int fput_needed;
               if (i >= n)
                   break;
               if (!(bit & all_bits))
                   continue;
               file = fget_light(i, &fput_needed);
               if (file) {
                   f_op = file->f_op;
                   mask = DEFAULT_POLLMASK;
                   if (f_op && f_op->poll)
                       mask = (f_op->poll)(file, retval ? NULL : wait);
                   fput_light(file, fput_needed);
                   if ((mask & POLLIN_SET) && (in & bit)) {
                       res_in |= bit;
                       retval++;
                   }
                   if ((mask & POLLOUT_SET) && (out & bit)) {
                       res_out |= bit;
                       retval++;
                   }
                   if ((mask & POLLEX_SET) && (ex & bit)) {
                       res_ex |= bit;
                       retval++;
                   }
               }
           }
           if (res_in)
               rinp = res_in;
           if (res_out)
               routp = res_out;
           if (res_ex)
               rexp = res_ex;
           cond_resched();
       }
       wait = NULL;
       if (retval || timed_out || signal_pending(current))
           break;
       if (table.error) {
           retval = table.error;
           break;
       }

       /
       * If this is the first loop and we have a timeout
       * given, then we convert to ktime_t and set the to
       * pointer to the expiry value.
       /
       if (end_time && !to) {
           expire = timespec_to_ktime(end_time);
           to = &expire;
       }

       if (!schedule_hrtimeout_range(to, slack, HRTIMER_MODE_ABS))
           timed_out = 1;
   }
   __set_current_state(TASK_RUNNING);

   poll_freewait(&table);

   return retval;
}
上面的代码很多，其实真正关键的代码是�q�一�?
mask = (f_op->poll)(file, retval ? NULL : wait);
�q�个是调用文件系�l�的 poll函数�Q�不同的文�g�pȝ��poll函数自然不同�Q�由于我们这里关注的是tcp�q�接�Q�而socketfs的注册在 net/Socket.c里�?br>register_filesystem(&sock_fs_type);
socket文�g�pȝ��的函��C��是在net/Socket.c里：
static const struct file_operations socket_file_ops = {
   .owner =   THIS_MODULE,
   .llseek =   no_llseek,
   .aio_read =   sock_aio_read,
   .aio_write =   sock_aio_write,
   .poll =       sock_poll,
   .unlocked_ioctl = sock_ioctl,
#ifdef CONFIG_COMPAT
   .compat_ioctl = compat_sock_ioctl,
#endif
   .mmap =       sock_mmap,
   .open =       sock_no_open,   / special open code to disallow open via /proc /
   .release =   sock_close,
   .fasync =   sock_fasync,
   .sendpage =   sock_sendpage,
   .splice_write = generic_splice_sendpage,
   .splice_read =   sock_splice_read,
};
从sock_poll跟随下去�Q?br>最后可以到 net/ipv4/tcp.c�?br>unsigned int tcp_poll(struct file file, struct socket sock, poll_table wait)
�q�个是最�l�的查询函数�Q?br>也就是说select 的核心功能是调用tcp文�g�pȝ��的poll函数�Q�不停的查询�Q�如果没有想要的数据�Q�主动执行一�ơ调度（防止一直占用cpu�Q�，直到有一个连接有惌��的消息�ؓ止�?br>从这里可以看出select的执行方式基本就是不同的调用poll,直到有需要的消息为止�Q�如果select 处理的socket很多�Q�这其实�Ҏ��个机器的性能也是一个消耗�?br>

2、epoll的实�?/h2> epoll的实��C��码在 fs/EventPoll.c下，
�׃��epoll涉及到几个系�l�调用，�q�里不逐个分析了，仅仅分析几个关键点，
�W�一个关键点�?br>static int ep_insert(struct eventpoll ep, struct epoll_event event,
             struct file tfile, int fd)
�q�是在我们调用sys_epoll_ctl ��d��一个被��理socket的时候调用的函数�Q�关键的几行如下�Q?br>epq.epi = epi;
   init_poll_funcptr(&epq.pt, ep_ptable_queue_proc);

   /
   * Attach the item to the poll hooks and get current event bits.
   * We can safely use the file* here because its usage count has
   * been increased by the caller of this function. Note that after
   * this operation completes, the poll callback can start hitting
   * the new item.
   /
   revents = tfile->f_op->poll(tfile, &epq.pt);
�q�里也是调用文�g�pȝ��的poll函数�Q�不�q�这�ơ初始化了一个结构，�q�个�l�构会带有一个poll函数的callback函数�Q�ep_ptable_queue_proc�Q?br>在调用poll函数的时候，会执行这个callback�Q�这个callback的功能就是将当前�q�程��d��?socket的等待进�E�上�?br>static void ep_ptable_queue_proc(struct file file, wait_queue_head_t whead,
               poll_table pt)
{
   struct epitem epi = ep_item_from_epqueue(pt);
   struct eppoll_entry pwq;

   if (epi->nwait >= 0 && (pwq = kmem_cache_alloc(pwq_cache, GFP_KERNEL))) {
       init_waitqueue_func_entry(&pwq->wait, ep_poll_callback);
       pwq->whead = whead;
       pwq->base = epi;
       add_wait_queue(whead, &pwq->wait);
       list_add_tail(&pwq->llink, &epi->pwqlist);
       epi->nwait++;
   } else {
       /* We have to signal that an error occurred */
       epi->nwait = -1;
   }
}
注意到参�?whead 实际上是 sk->sleep�Q�其实就是将当前�q�程��d��到sk的等待队列里�Q�当该socket收到数据或者其他事件触发时�Q�会调用
sock_def_readable 或者sock_def_write_space 通知函数来唤醒等待进�E�，�q?个函数都是在socket创徏的时候填充在sk�l�构里的�?br>从前面的分析来看�Q�epoll��实是比select聪明的多、轻杄��多，不用再苦哈哈的去轮询了�?br>

feixuwu 2010-07-10 18:40 发表评论

feixuwu — Sat, 10 Jul 2010 09:32:00 GMT

昨天一个同事一大早在群里推荐了一个google project上的开源内存分配器�Q?a swaped="true" target="_blank">http://code.google.com/p/google-perftools/�Q�，据说google的很多��品都用到了这个内存分配库�Q�而且�l�他��试�Q�我们的游戏客户端集成了�q�个最新内存分配器后，FPS��提高了将�q?0帧左叻I��q�可是个了不��L��提升�Q�要知道3D�l�的兄弟忙了几周也没见这么大的性能提升�?br>
如果我们自己本��n用的crt提供的内存分配器�Q�这个提升也��不得什么。问题是我们内部�pȝ��是有一个小内存��理器的�Q�一般来说小内存分配的算法都大同��异�Q�现成的实现也很多，比如linux内核的slab、SGI STL的分配器、ogre自带的内存分配器�Q�我们自��q��内存分配器也和前面列丄��实现差不多。让我们来看看这个项目有什么特别的吧�?br>

一、��用方�?/h1> 打开主页�Q�由于公司网�l�禁止SVN从外部更斎ͼ�所以只能下载了打包的源代码。解压后�Q�看到有个doc目录�Q�进去，打开使用文档�Q�发��C��用方法极为简单：
To use TCMalloc, just link TCMalloc into your application via the "-ltcmalloc" linker flag.再看��法�Q�也没什么特别的�Q�还是和slab以及SGI STL分配器类似的��法�?br>unix环境居然只要链接�q�个tcmalloc库就可以了！�Q�太方便了，不过我手头没有linux环境�Q�文档上也没提到windows环境怎么使用�Q?br>打开源代码包�Q�有个vs2003解决�Ҏ��Q�打开�Q�随便挑选一个测试项目，查看��目属性，发现仅仅�?点不同：
1、链接器命��o行里多了
"..\..\release\libtcmalloc_minimal.lib"�Q�就是链接的时候依赖了�q�个内存优化库�?br>2、链接器->输入->强制�W�号引用多了 __tcmalloc�?br>�q�样��可以正��的使用tcmalloc库了�Q�测试了下，��试��目�q�行OK!

二、如何替换CRT的malloc

从前面的描述可知�Q�项目强制引用了__tcmalloc�Q?搜烦了测试代码，没发现用到_tcmalloc相关的函数和变量,�q�个选项应该是�ؓ了防止dll被优化掉(因�ؓ代码里没有什么地方用到这个dll的符�?�?br>初看��h��Q�链接这个库后，不会影响��M��现有代码:我们没有引用�q�个Lib库的头文�Ӟ��也没有��用过�q�个dll的导出函数。那么这个dll是怎么优化应用�E�序性能的呢�Q?br>实际调试�Q�果然发现问题了�Q�看看如下代�?br>    void* pData = malloc(100);
00401085 6A 64            push        64h
00401087 FF 15 A4 20 40 00 call        dword ptr [__imp__malloc (4020A4h)]
跟踪 call malloc�q�句�Q�step�q�去�Q�发现是
78134D09 E9 D2 37 ED 97   jmp         `anonymous namespace'::LibcInfoWithPatchFunctions<8>::Perftools_malloc (100084E0h)
果然�Q�从�q�里开始，��p��转到libtcmalloc提供的Perftools_malloc了�?br>原来是通过API挂钩来实现无�~�替换系�l�自带的malloc�{�crt函数的，而且�q�是通过大家公认的不推荐的改写函数入口指令来实现的，一般只有在游戏外挂和金��p��怹��cȝ��软�g才会用到�q�样的挂钩技术，
而且金山词霸�l�常需要更新补丁解决不同系�l�兼定w��题�?br>

三、性能差别原因

如前面所�q�ͼ�tcmalloc��实用了很hacker的办法来实现无缝的替换系�l�自带的内存分配函数�Q�本人在使用�q�类技术通常是用来干坏事的。。。）�Q�但是这也不��以解释��Z��么它的效率比我们自己的好那么多�?br>回到tcmalloc 的手册，tcmalloc除了使用常规的小内存��理外，对多�U�程环境做了�Ҏ��处理�Q�这和我原来见到的内存分配器大有不同�Q�一般的内存分配器作者都会偷懒，把多�U�程问题扔给使用者，大多是加
个bool型的模板参数来表�C�是否是多线�E�环境，�q�美其名�?可定�Ӟ��末了�q�得吹嘘下模板的优越性�?br>tcmalloc是怎么做的呢？ �{�案是每�U�程一个ThreadCache�Q�大部分操作�pȝ��都会支持thread local storage ��是传说中的TLS,�q�样��可以实现每�U�程一个分配器了，
�q�样�Q�不同线�E�分配都是在各自的threadCache里分配的。我们的��目的分配器�׃��是多�U�程环境的，所以不��三七二十一�Q�全都加锁了�Q�性能自然��׃��了�?br>
仅仅是如此，�q�是不��以将tcmalloc和ptmalloc2分个高下�Q�后者也是每个线�E�都有threadCache的�?br>关于�q�个问题�Q�doc里有一�D�说明，原文贴出来：
ptmalloc2 also reduces lock contention by using per-thread arenas but there is a big problem with ptmalloc2's use of per-thread arenas. In ptmalloc2 memory can never move from one arena to another. This can lead to huge amounts of wasted space.
大意是这��L��Q�ptmalloc2 也是通过tls来降低线�E�锁�Q�但是ptmalloc2各个�U�程的内存是独立的，也就是说�Q�第一个线�E�申��L��内存�Q�释攄��时候还是必��L��到第一个线�E�池中（不可�U�d��Q�，�q�样可能��D��大量内存��费�?br>

四、代码细�?/h1>

1、无�~�替换malloc�{�crt和系�l�分配函数�?/h2> 前面提到tcmalloc会无�~�的替换掉原有dll中的malloc�Q�这��意味着使用tcmalloc的项目必��L�� MD�Q�多�U�程dll�Q�或者MDd�Q�多�U�程dll调试�Q�。tcmalloc的dll定义了一�?br>static TCMallocGuard module_enter_exit_hook;
的静态变量，�q�个变量会在dll加蝲的时候先于DllMain�q�行�Q�在�q�个�cȝ��构造函敎ͼ�会运行PatchWindowsFunctions来挂钩所有dll�?malloc、free、new�{�分配函敎ͼ��q�样��p��C��替换功能�Q�除此之外，
��Z��保证�pȝ��兼容性，挂钩API的时候还实现了智能分析指令，否则写入�W�一条Jmp指��o的时候可能会破环后箋指��o的完整性�?br>

2、LibcInfoWithPatchFunctions 和ThreadCache�?/h2> LibcInfoWithPatchFunctions模板�c�d��含tcmalloc实现的优化后的malloc�{�一�p�d��函数。LibcInfoWithPatchFunctions的模板参数在我看来没什么用处，tcmalloc默认可以挂钩
最�?0个带有malloc导出函数的库(我想肯定是够用了)。ThreadCache在每个线�E�都会有一个TLS对象�Q?br>__thread ThreadCache* ThreadCache::threadlocal_heap_�?br>

3、可能的问题

设想下这样一个情景：假如有一个dll 在tcmalloc之前加蝲�Q��ƈ且在分配了内存（使用crt提供的malloc�Q�，那么在加载tcmalloc后，tcmalloc会替换所有的free函数�Q�然后，在某个时刻，
在前面的那个dll代码中释放该内存�Q�这岂不是很危险。实际测试发现没有�Q何问题，关键在这里：
span = Static::pageheap()->GetDescriptor(p);
    if (!span) {
      // span can be NULL because the pointer passed in is invalid
      // (not something returned by malloc or friends), or because the
      // pointer was allocated with some other allocator besides
      // tcmalloc. The latter can happen if tcmalloc is linked in via
      // a dynamic library, but is not listed last on the link line.
      // In that case, libraries after it on the link line will
      // allocate with libc malloc, but free with tcmalloc's free.
      (*invalid_free_fn)(ptr); // Decide how to handle the bad free request
      return;
    }
tcmalloc会通过span识别�q�个内存是否自己分配的，如果不是�Q�tcmalloc会调用该dll原始对应函数(�q�个很重�?释放。这样就解决了这个棘手的问题�?br>

五、其�?/h1> 其实tcmalloc使用的每个技术点我从前都用过�Q�但是我从来没想�q�用API挂钩来实现这样一个有��的内存优化库（即��惌��Q�也是一闪而过��否定了�Q��?br>从tcmalloc得到灉|��Q�结合常用的外挂技术，可以很轻杄��开发一个独立工��P��q�个工具可以挂蝲到指定进�E�进行内存优化，在我看来�Q�这可能可以作�ؓ一个外挂辅助工��h��优化那些
内存优化做的很差��D��帧速很低的国��游戏�?br>

feixuwu 2010-07-10 17:32 发表评论