C++博客-创的技术博客-随笔分类-C\C++

研究了一下SGI STL的内存算法

Tue, 01 Apr 2008 11:55:00 GMT

摘要: 仿SGI STL的内存池算法.
阅读全文

创 2008-04-01 19:55 发表评论

memcache内存池的设计原理

Mon, 21 Jan 2008 15:34:00 GMT

memcache中管理内存的数据结构如下:

typedef struct {
    unsigned int size;      /* sizes of items */
    unsigned int perslab;   /* how many items per slab */

    void **slots;           /* list of item ptrs */
    unsigned int sl_total;  /* size of previous array */
    unsigned int sl_curr;   /* first free slot */

    void *end_page_ptr;         /* pointer to next free item at end of page, or 0 */
    unsigned int end_page_free; /* number of items remaining at end of last alloced page */

    unsigned int slabs;     /* how many slabs were allocated for this class */

    void **slab_list;       /* array of slab pointers */
    unsigned int list_size; /* size of prev array */

    unsigned int killing;  /* index+1 of dying slab, or zero if none */
} slabclass_t;

程序中有一个全局的数组
static slabclass_t slabclass[POWER_LARGEST + 1]用于保存slab,预分配内存池时调用的是void slabs_init(const size_t limit, const double factor) 函数,其中limit是内存池的最大容量,factor是分配时的增长因子.
比方说,加入factor是2,第一个在slabclass数组中的slab的每个item大小是128字节,那么下一个slab每个item的大小就是128*2,再下一个就是128*2*2(注意,为了简化问题的说明,上面没有考虑地址对齐的因素).

在预分配内存池时,最多给每个slab保存item的容量是1M内存,这个数值由#define POWER_BLOCK 1048576决定.
因此,slab中的几个元素在预分配内存时是这么定的:
size有一个起始值,这个值以后的增长由factor决定,增长的过程前面已经阐述过了;
perslab保存的是一个slab存放的item数量,因此perslab = POWER_BLOCK / slabclass[i].size;
如果预先分配一段内存供使用的话,也就是没有定义DONT_PREALLOC_SLABS宏,那么就调用slabs_preallocate进行预分配内存.
其中,end_page_ptr指向这个预分配好的指针,end_page_free表示的是目前空闲可用item的数量,在预分配时,这个值与perslab相同.
在这个内存池模型中,每个page实际上是一个数组,数组中每个元素的大小就是这个slab中item的大小.

另外,slots保存的是释放出来的item指针,sl_total表示总的数量,sl_curr表示的是目前可用的已经释放出来的item数量.

每一次要分配内存的时候,首先根据需要分配的内存大小在slabclass数组中查找索引最小的一个大于所要求内存的slab,如果slots不为空,那么就从这里返回内存,否则去查找end_page_ptr,如果也没有,那么就只能返回NULL了.
每一次释放内存的时候,同样的找到应该返回内存的slab元素,改写前面提到的slot指针和sl_curr数.

有点仓促,以后再完善~~

创 2008-01-21 23:34 发表评论

仿STL中的堆算法的一个实现

Mon, 19 Mar 2007 16:28:00 GMT

摘要: 仿STL中的堆算法的一个实现阅读全文

创 2007-03-20 00:28 发表评论

CGL开发手记之一--参考资料

Sun, 18 Mar 2007 11:40:00 GMT

摘要: 有关CGL写作中经常参考到的资料. 阅读全文

创 2007-03-18 19:40 发表评论

Modern C++ Design(MCD)学习笔记 && 测试代码(二)

Sun, 04 Feb 2007 15:18:00 GMT

摘要: 检查是否可以转换以及是否存在继承关系的类
阅读全文

创 2007-02-04 23:18 发表评论

Modern C++ Design(MCD)学习笔记 && 测试代码(一)

Sun, 04 Feb 2007 07:53:00 GMT

摘要: 编译期断言模版类的技巧~~ 阅读全文

创 2007-02-04 15:53 发表评论

little endian和big endian的概念解释,判定与用途

Tue, 05 Sep 2006 13:04:00 GMT

摘要: little endian和big endian的概念解释,判定与用途阅读全文

创 2006-09-05 21:04 发表评论

测试了一下VC和gcc对关键字export的支持

Tue, 11 Jul 2006 11:04:00 GMT

摘要: 测试了一下VC和gcc对关键字export的支持阅读全文

创 2006-07-11 19:04 发表评论

探索C++的秘密之二:重载,覆盖,和隐藏

Fri, 24 Mar 2006 12:39:00 GMT

摘要: 三个概念重载,覆盖,和隐藏的区别. 阅读全文

创 2006-03-24 20:39 发表评论

使用typename的一个说明

Wed, 22 Mar 2006 15:41:00 GMT

时常看到这样的代码,比如以下这两段代码:

list<int>::iterator iter1;
list<T>::iterator iter1;

前者没有问题可以顺利的编译过去，但是后者时常会报一个警告，为什么呢?
原因如下:
首先,list是一个模板类，在模板实例化以前是无法确定起真正的类型的,也就是说编译阶段是无法知道到底是哪个类的,那么可能出现以下一种情况：某个类中恰好有一个静态成员为iterator，此时就会出错了。
因此为了明确的指出这是一个类型而不是一个成员，我们需要在前面加上typename，也就是:

typename list<T>::iterator iter1;

typename在这里用于说明后面紧跟着的字符串表示的是一个类型。

创 2006-03-22 23:41 发表评论

模板套模板～～

Tue, 21 Mar 2006 16:06:00 GMT

#include < iostream >
#include < map >
#include < string >

using namespace std;

int main()
{
    map < string , int > map1;
    map < string , map < string , int > > map2;
    map1[ " test " ] = 2 ;
    map2[ " test1 " ] = map1;

    cout << map2[ " test1 " ][ " test " ] << endl;
     return 0 ;
}

以上代码简单的实现了map对"二维"形式的支持,很简单,不是么？可是我第一次面对这个问题的时候模板套模板的整糊涂了,记录一个留个念想～～

创 2006-03-22 00:06 发表评论

一个关于临时对象和虚拟析构函数的问题

Thu, 16 Feb 2006 15:24:00 GMT

在CU逛,别人问到这样的一个问题,大致如下:

#include <iostream>
#include <string>
using namespace std;
class base
{
        public:
                virtual void print(){cout<<"base::print()"<<endl;}
                //virtual ~base(){}//增加虚析构函数，将导致输出不一致。
};
class derived :public base
{
        public:
                virtual void print(){cout<<"devrived::print()"<<endl;}
};
int main(int argc, char *argv[])
{
        base* p1=&derived();
        p1->print();

        derived d;
        base* p2=&d;
        p2->print();

        return 0;
}

加入虚拟析构函数后，输出为：
base::print()
devrived::print()
不加入虚拟析构函数，输出则为：
devrived::print()
devrived::print()

我的解释如下:
实际上,第一个赋值指向的是一个临时对象,加入与没有加入虚拟析构函数的区别在于:加入之后,在derived类中会合成一个析构函数以便调用base的虚拟析构函数,如果没有加入的话那么就不会合成这个析构函数,所有的资源在main函数结束之后才回收.

因此,对于代码: base* p1=&derived();
没有加入虚拟析构函数的时候因为derived()函数生成的临时对象没有被销毁,因此对它的调用是对derived的调用;当加入虚拟析构函数之后,derived()函数生成的临时对象在以上的赋值完成之后就会调用析构函数进行析构,这个时候再次对p1调用print函数时,因为临时对象已经析构,那么这个调用就是对base的调用了.

我做了一个实验的代码,加了一些东西,大家看看~~

#include <iostream>
#include <string>
using namespace std;
class base
{
        public:
                virtual void print(){cout<<"base::print()"<<endl;}
                virtual ~base(){cout << "~base()\n";}//增加虚析构函数，将导致输出不一致。
};
class derived :public base
{
        public:
                virtual void print(){cout<<"devrived::print()"<<endl;}
                //virtual ~derived(){cout << "~derived()\n";}//增加虚析构函数，将导致输出不一致。
};

int main(int argc, char *argv[])
{
        derived *t = &derived();
        base* p1 = t;
        p1->print();

        derived d;
        base* p2=&d;
        p2->print();

        // 第一部分相当于以下的代码
        // 用temp模拟临时对象
        derived temp;
        derived *s = &temp;
        base *p3 = s;
        // 这次调用是对derived的函数调用
        p3->print();
        // 显式地对temp进行析构
        temp.base::~base();
        // 析构完后,同样的一个内存,却是用base指针去解释,
        // 因此调用的是base的函数
        p3->print();

        return 0;
}

创 2006-02-16 23:24 发表评论

探索C++的秘密之一详解extern "C"

Sat, 14 Jan 2006 15:52:00 GMT

时常在cpp的代码之中看到这样的代码:

#ifdef __cplusplus
extern "C" {
#endif

//一段代码

#ifdef __cplusplus
}
#endif

这样的代码到底是什么意思呢?首先,__cplusplus是cpp中的自定义宏,那么定义了这个宏的话表示这是一段cpp的代码,也就是说,上面的代码的含义是:如果这是一段cpp的代码,那么加入extern "C"{和}处理其中的代码.

要明白为何使用extern "C",还得从cpp中对函数的重载处理开始说起.在c++中,为了支持重载机制,在编译生成的汇编码中,要对函数的名字进行一些处理,加入比如函数的返回类型等等.而在C中,只是简单的函数名字而已,不会加入其他的信息.也就是说:C++和C对产生的函数名字的处理是不一样的.

比如下面的一段简单的函数,我们看看加入和不加入extern "C"产生的汇编代码都有哪些变化:

int f(void)
{
return 1;
}

在加入extern "C"的时候产生的汇编代码是:

    .file    "test.cxx"
    .text
    .align 2
.globl _f
    .def    _f;    .scl    2;    .type    32;    .endef
_f:
    pushl    %ebp
    movl    %esp, %ebp
    movl    $1, %eax
    popl    %ebp
    ret

但是不加入了extern "C"之后

.file "test.cxx"
.text
.align 2
.globl __Z1fv
.def __Z1fv; .scl 2; .type 32; .endef
__Z1fv:
pushl %ebp
movl %esp, %ebp
movl $1, %eax
popl %ebp
ret

两段汇编代码同样都是使用gcc -S命令产生的,所有的地方都是一样的,
唯独是产生的函数名,一个是_f,一个是__Z1fv.

OK,明白了加入与不加入extern "C"之后对函数名称产生的影响,我们继续我们的讨论:为什么需要使用extern "C"呢?
C++之父在设计C++之时,考虑到当时已经存在了大量的C代码,为了支持原来的C代码和已经写好C库,需要在C++中尽可能的支持C,而extern "C"就是其中的一个策略.

试想这样的情况:一个库文件已经用C写好了而且运行得很良好,这个时候我们需要使用这个库文件,但是我们需要使用C++来写这个新的代码.如果这个代码使用的是C++的方式链接这个C库文件的话,那么就会出现链接错误.我们来看一段代码:首先,我们使用C的处理方式来写一个函数,也就是说假设这个函数当时是用C写成的:

//f1.c
extern "C"
{
void f1()
{
return;
}
}

编译命令是:gcc -c f1.c -o f1.o 产生了一个叫f1.o的库文件.
再写一段代码调用这个f1函数:

// test.cxx
//这个extern表示f1函数在别的地方定义,这样可以通过
//编译,但是链接的时候还是需要
//链接上原来的库文件.
extern void f1();

int main()
{
f1();

return 0;
}

通过gcc -c test.cxx -o test.o 产生一个叫test.o的文件.
然后,我们使用gcc test.o f1.o来链接两个文件,可是出错了,错误的提示是:
test.o(.text + 0x1f):test.cxx: undefine reference to 'f1()'
也就是说,在编译test.cxx的时候编译器是使用C++的方式来处理f1()函数的,但是实际上链接的库文件却是用C的方式来处理函数的,所以就会出现链接过不去的错误:因为链接器找不到函数.
因此,为了在C++代码中调用用C写成的库文件,就需要用extern "C"来告诉编译器:这是一个用C写成的库文件,请用C的方式来链接它们.
比如,现在我们有了一个C库文件,它的头文件是f.h,产生的lib文件是f.lib,那么我们如果要在C++中使用这个库文件,我们需要这样写:

extern "C"
{
#include "f.h"
}

回到上面的问题,如果要改正链接错误,我们需要这样子改写test.cxx:

extern "C"
{
extern void f1();
}

int main()
{
f1();

return 0;
}

重新编译并且链接就可以过去了.

总结:C和C++对函数的处理方式是不同的.extern "C"是使C++能够调用C写作的库文件的一个手段,如果要对编译器提示使用C的方式来处理函数的话,那么就要使用extern "C"来说明.

创 2006-01-14 23:52 发表评论