打造自己的堆存储分配策略

最新推荐文章于 2024-05-17 11:13:33 发布
最新推荐文章于 2024-05-17 11:13:33 发布
阅读量1.3k 收藏
点赞数
文章标签： 存储 list null table search struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RobinKin/article/details/200208
版权

//作者  RobinKin  from  DevonIT .inc

#ifndef MEMORY_C
#define MEMORY_C


//#define TEST_MEMORY
#define IOS
#define DEBUG
//#define TEST_LITTLE
/*本系统开了一个特定大小的栈区，在这个区域上模拟堆存储管理
 * 提供了两个关键的函数 malloc(int) 和free(void *)
 *
 * *这个版本的系统，使用了一个256k大小的栈
 * 分成256大份，每份1k大小，
 * 如果用户申请大于1k大小的空间，
 * 则直接用伙伴算法通过大的Buddy_table(大表)找到一块合适大小的空闲块；
 *
 * 如果用户申请小于1k大小的空间，
 * 则在一个1k的空闲块上,建立一个小的Buddy_table(小表)
 * 一个小表管理32块，大小是32字节的小块。
 * 一个小表分配完之后，建立新的一个小表，直到大表的空间也满为止
 *
 * 空间分配完的话，再申请空间时候，报memory full错
 * */

#define NULL 0
#ifdef IOS
#include<iostream>
using namespace std;
#endif

#define malloc my_malloc
#define free my_free

#define UCHAR unsigned char
#define USHORT unsigned short

void * malloc(int size); //分配一段空间
void free(void *);  //释放一个指针#define NULL 0


void free_little(void * addr);
void free_big(void * addr);

#define FALSE 0
#define TRUE 1

#define BIG_BLOCK_SIZE  1024 //大块每个1k
#define BIG_BLOCK_MAX 256//有多少个1k的大块
#define STACK_MAX  BIG_BLOCK_SIZE*BIG_BLOCK_MAX //
#define BLOCKID_MAX 2*BIG_BLOCK_MAX  //二叉树结点


//第一个结点分割1024*128+1024*128,第2，3个进一步分割
//1+2+4...+2^8=2^^9-1 ,


#define LITTLE_BLOCK_SIZE 32 //32个字节一个小块
#define LITTLE_BLOCK_MAX  BIG_BLOCK_SIZE/LITTLE_BLOCK_SIZE  //1024/32
#define LITTLE_BLOCKID_MAX 2*LITTLE_BLOCK_MAX
char SYS_STACK[STACK_MAX];//存储池

 

struct Buddy_address_table{
void * address[BIG_BLOCK_MAX];//起始地址
USHORT occu_id[BIG_BLOCK_MAX];//hash位置是否占用,0表示未占用，非0的话指向占用的id

bool semi[BLOCKID_MAX];//是否被部分占用，用这个数组表示一棵二叉
bool occupied[BLOCKID_MAX];//是否被完全占用，用这个数组表示一棵二叉树
};

Buddy_address_table bd={NULL};

struct Little_Buddy{
void * address[LITTLE_BLOCK_MAX];//起始地址
UCHAR occu_id[LITTLE_BLOCK_MAX];//hash位置是否占用,0表示未占用，非0的话指向占用的id

bool semi[LITTLE_BLOCKID_MAX];//是否被部分占用，用这个数组表示一棵二叉树
bool occupied[LITTLE_BLOCKID_MAX];//是否被完全占用，用这个数组表示一棵二叉树

int idx;//小表本身在大表中的idx(释放小表时要用到)
bool full;
};

void *find_little_space(Little_Buddy * lb,int i,int size,void * addr);
void * find_space(int i, int size,void * addr);
void error(int x){
#ifdef DEBUG
#endif
};


int big_size(int idx){

 int s=STACK_MAX;
 int i;
 while(idx!=1){
  s=s/2;
  if(idx%2==0){
   idx=idx/2;
  }
  else{
   idx=(idx-1)/2;
  }
 }
 return s;
}

int little_size(int idx){

 int s=BIG_BLOCK_SIZE;
 int i;
 while(idx!=1){
  s=s/2;
  if(idx%2==0){
   idx=idx/2;
  }
  else{
   idx=(idx-1)/2;
  }
 }
 return s;
}

 

//建立一个释放信息栈，每次受到释放信号的时候，不马上释放，而是先进栈
//栈满或者空间已经满时，一起释放，提高效率
//
Little_Buddy * lb_list[BIG_BLOCK_MAX]={NULL};

//最多BIG_BLOCK_MAX个小表--一个大BUDDY块可以是一个小BUDY表

 

int get_idx_little(Little_Buddy * lb, void *addr){
 int i=(int)addr;
 int k=i%LITTLE_BLOCK_MAX;
 while(lb->occu_id[k]){
  k++;
  if(k==LITTLE_BLOCK_MAX){
   k=0;
  }
 }
 return k;//找到addre的插入位置
}
int get_idx(void *addr){
 int i=(int)addr;
 int k=i%BIG_BLOCK_MAX;
 while(bd.occu_id[k]){
  k++;
  if(k==BIG_BLOCK_MAX){
   k=0;
  }
 }
 return k;//找到addre的插入位置
}


void * malloc(int size){
void * addr;
int idx;//查到的空闲块id

#ifdef DEBUG 
cout<<"target space:"<<size<<endl;
#endif


if(size<=BIG_BLOCK_SIZE){//比较小的块，用小表分配
 int i=0;
 
 while(lb_list[i]!=NULL && lb_list[i]->full!=1){

#ifdef DEBUG
 cout<<"search little"<<endl;
#endif
 
  //已经建立的小表中，未满的表
  if(addr=find_little_space(lb_list[i],1,size,lb_list[i])){
   return addr;
  }
  i++;
 }
 //现有小表中找不到足够空间，建立新的小表

 if(addr=find_space(1,BIG_BLOCK_SIZE,SYS_STACK)){//在大表中找到空间
  
  lb_list[i]=(Little_Buddy*)addr;// 小表本身所占的空间

  //little table initialize
  int j;
  for(j=0;j<LITTLE_BLOCKID_MAX;j++){
   lb_list[i]->occupied[j]=FALSE;
   lb_list[i]->semi[j]=FALSE;
  }

  for(j=0;j<LITTLE_BLOCK_MAX;j++){
   lb_list[i]->occu_id[j]=0;

  }
   
  lb_list[i]->idx=idx;

   //去掉小表本身的空间
  find_little_space(lb_list[i],1,sizeof(Little_Buddy),addr);
   
  //通过小表所描述的空闲块空间查找合适小空闲块
  if(addr=find_little_space(lb_list[i],1,size,addr)){
   return addr;
  }
  else{
   return NULL;
  }
  
 }
}
return  find_space(1,size,SYS_STACK);//从根结点开始找可用空间

}


//
//
void *find_little_space(Little_Buddy * lb,int i,int size,void * addr){

if(LITTLE_BLOCK_SIZE>size){size=LITTLE_BLOCK_SIZE;}
int sz=little_size(i);


 
if(LITTLE_BLOCKID_MAX<i){return NULL;}
if(lb->occupied[i]){return NULL;};


//半可用空间
if(lb->semi[i]){

#ifdef DETAIL
 cout<<"semi"<<i<<" "<<sz<<" "<<size<<endl;
#endif
 
 if(sz<=2*size){
  return NULL;
 }
 else{
  if(!lb->occupied[2*i]){
   void * adr;
   if(adr=find_little_space(lb,2*i,size,addr)){
    return adr;
   }
  }
  else{
   char * ad=(char*)addr;
   return find_little_space(lb,2*i+1,size,ad+sz/2);
  }
 }
}

//是完全可用空间
if(sz>=size){//存在可用空间

#ifdef DETAIL
 cout<<"space:"<<i<<" "<<sz<<" "<<size<<endl;
#endif
 
 if(sz>=2*size ){//还太大，继续分小的
  lb->semi[i]==1;//本身半占
   
  void * adr;
  if (adr= find_little_space(lb,2*i,size,addr)){
   return adr;
  }
  else{
   char * ad=(char*)addr;
   return find_little_space(lb,2*i+1,size,ad+sz/2);
  };
 }

 //找到合适的可用空间

  
 int k=get_idx_little(lb,addr);
  
 lb->address[k]=addr;
 lb->occu_id[k]=i;//记下对应地址的id 小表
 lb->occupied[i]=TRUE;

#ifdef DEBUG
 cout<<"space:"<<i<<" "<<sz<<" "<<size<<endl;
#endif
  
 return addr;//返回存储空间首地址
 
 
}
else{
 //所申请的块的大小已经超过这个小表的最大限度
 lb->full=1;
 return NULL;
  

}
}
//
//


void * find_space(int i, int size,void * addr){// 从 index开始找大小是size 的块

if(BIG_BLOCK_SIZE>size){size=BIG_BLOCK_SIZE;}
int sz=big_size(i);

#ifdef DETAIL
 cout<<i<<" "<<sz<<" "<<size<<endl;
#endif
if(BLOCKID_MAX<i){return NULL;}
if(bd.occupied[i]){
#ifdef DETAIL
 cout<<"occupied:"<<i<<endl;
#endif
 return NULL;
}


//半可用空间
if(bd.semi[i]){
 if(sz<=2*size){
  return NULL;
 }
 else{
  if(!bd.occupied[2*i]){
   void * adr;
   if(adr=find_space(2*i,size,addr)){
    return adr;
   }
  }
  else{
   char * ad=(char*)addr;
   return find_space(2*i+1,size,ad+sz/2);
  }
 }
}

//是完全可用空间
if(sz>=size){//存在可用空间
 if(sz>=2*size ){//还太大，继续分小的
  bd.semi[i]==1;//本身半占
   
  void * adr;
  if (adr= find_space(2*i,size,addr)){
   return adr;
  }
  else{
   char * ad=(char*)addr;
   return find_space(2*i+1,size,ad+sz/2);
  };
 }

 //找到合适的可用空间

  
 int k=get_idx(addr);
  
 bd.address[k]=addr;
 bd.occu_id[k]=i;//记下对应地址的id 小表
 bd.occupied[i]=TRUE;

#ifdef DEBUG
 cout<<i<<" "<<sz<<" "<<size<<endl;
#endif
   
 return addr;//返回存储空间首地址
 
 
}
else{
 //所申请的块的大小已经超过这个表的最大限度
#ifdef DEBUG
 cout<<"memory full"<<endl;
#endif
 return NULL;
  

}

 

#ifdef DETAIL
 cout<<"begin to assign "<<i<<endl;
#endif
 
if(!bd.occupied[i] && sz>size){//存在可用空间
 
 if(sz>2*size){//还太大，继续分小的
  bd.occupied[i]==TRUE;//本身不空
 
#ifdef DETAIL
  cout<<"virtual assign"<<i<<" "<<sz<<endl<<endl;
#endif
   
  void * adr;
  if (adr= find_space(2*i,size,addr)){
  bd.occupied[2*i]=1;//左结点不空
  return adr;
  }
  else{
  char * ad=(char *)addr;
  bd.occupied[2*i+1]=1;//左结点不空
  return find_space(2*i+1,size,ad+sz/2);
  };
 }

 else{ //找到合适的可用空间

 int k=get_idx(addr);
 
 bd.address[k]=addr;
 bd.occu_id[k]=i;//记下对应地址的id 小表
 
#ifdef DETAIL

 cout<<"occu_id: "<<k<<" "<<(int)addr<<endl;
#endif


#ifdef DEBUG
 cout<<"best suit:"<<i<<" "<<sz<<endl;
#endif
 
 return bd.address[k];//返回存储空间首地址和空间大小
 }
 
}
else{
#ifdef DETAIL
 cout<<"begin search sub_node"<<endl;
#endif
 if(bd.occupied[i]){//本块占用
  void * adr;
  if(adr=find_space(2*i,size,addr)){//找左结点
  return adr;
  }    else{
   char * ad=(char*)addr;
  return find_space(2*i+1,size,ad+sz/2);
  }
 
 }


         else{//所申请的块的大小已经超过最大限度
  
  error(98);
#ifdef DEBUG
  if(1==i){
  cout<<"memory full"<<endl;
  }
#endif
  return NULL;
  
 }

}
}
//
//
void free_big_id(int k){//释放上层虚结点

if(0==k){
 
#ifdef DEBUG1 
cout<<"root "<<endl;
#endif
 return;
}

if(1==k){
 
#ifdef DEBUG 
cout<<"root freed"<<endl;
#endif

bd.occupied[1]=FALSE;//清空索引所指向的空间
bd.semi[1]=FALSE;//清空索引所指向的空间
return;
}

 

if(0==k%2){//左结点
 
 #ifdef DETAIL
 cout<<k<<" left virutal freed"<<endl;
 #endif
 
 if(!bd.occupied[k+1]|| !bd.semi[k+1]){//右边也空

 #ifdef DETAIL
 cout<<k+1<<" right blank too"<<endl;
 #endif
 
 free_big_id(k/2); 
 bd.occupied[k]=FALSE;//清空索引所指向的空间
 bd.semi[k]=FALSE;//清空索引所指向的空间
 }
}
else{//是右结点

 #ifdef DETAIL
 cout<<k<<" right virutal freed"<<endl;
 #endif

 if(!bd.occupied[k-1] || !bd.semi[k-1]){//左边也空

 #ifdef DEBUG
 cout<<k-1<<"left blank too"<<endl;
 #endif
 

 free_big_id((k-1)/2); 
 bd.occupied[k]=FALSE;//清空索引所指向的空间
 bd.semi[k]=FALSE;//清空索引所指向的空间
 
 }
 

}
}//end
//
//
int  memory_size_little(void * addr){

int target=(int)addr;
int d;
for(int d=0;d<BIG_BLOCK_MAX;d++){
 int head=(int)lb_list[d];
 int tail=(int)((char*)lb_list[d]+BIG_BLOCK_SIZE);
 if(target>=head &&target<tail){
  int k=target%LITTLE_BLOCK_MAX;

  Little_Buddy * p=lb_list[d];
  while(p->address[k]!=addr ||!p->occu_id[k]){
   k++;
   if(k==BIG_BLOCK_MAX){
    k=0;
   }
  }
 
  return little_size(p->occu_id[k]);
 }
}

 return -1;
  
}

int memory_size_big(void * addr){

int target=(int)addr;

int head=target%BIG_BLOCK_MAX;
int tail=head;

#ifdef DETAIL
cout<<head<<" "<<(int)addr<<endl;
#endif

if(bd.address[head]==addr && bd.occu_id[head]!=0 ){
 ;
}

else{
 head++;
 while(
  tail!=head &&
  (bd.occu_id[head]==0 || bd.address[head]!=addr  )
 ){
 #ifdef DEBUG
 
 //  cout<<(int)bd.address[head]<<" ";
 #endif

 head++;
  if(head==BIG_BLOCK_MAX){
   head=0;
  }
 }
}

 

int k=head;
if(head==tail){
 return memory_size_little(addr);
}

return big_size(bd.occu_id[k]);


}

 


//
void free_big(void * addr){

int target=(int)addr;

int head=target%BIG_BLOCK_MAX;
int tail=head;

#ifdef DETAIL
cout<<head<<" "<<(int)addr<<endl;
#endif

if(bd.address[head]==addr && bd.occu_id[head]!=0 ){
 ;
}

else{
 head++;
 while(
  tail!=head &&
  (bd.occu_id[head]==0 || bd.address[head]!=addr  )
 ){
 #ifdef DEBUG
 
 //  cout<<(int)bd.address[head]<<" ";
 #endif

 head++;
  if(head==BIG_BLOCK_MAX){
   head=0;
  }
 }
}

 

int k=head;
if(head==tail){
 free_little(addr);
}


if(1==bd.occu_id[k]){//不是根结点
 
#ifdef DEBUG
 cout<<"big root freed"<<endl;
#endif

 bd.occupied[1]=FALSE;//清空索引所指向的空间
 bd.semi[1]=FALSE;//清空索引所指向的空间
 bd.occu_id[k]=0;//空出一个索引位置


 return;
}


if(bd.occu_id[k]%2==0 ){//左结点
#ifdef DEBUG
 cout<<bd.occu_id[k]<<"left real  freed"<<endl;
#endif
 
 
 if(!bd.occupied[bd.occu_id[k]+1]){//右边也空
  free_big_id(bd.occu_id[k]/2);
   
 }
 
 
 

}
else{//是右结点
#ifdef DEBUG
 cout<<bd.occu_id[k]<<"right real freed"<<endl;
#endif

 if(!bd.occupied[bd.occu_id[k]-1]){//左边也空
  free_big_id((bd.occu_id[k]-1)/2);
 }
 
}

 bd.occupied[bd.occu_id[k]]=FALSE;//清空索引所指向的空间
 bd.semi[bd.occu_id[k]]=FALSE;//清空索引所指向的空间
 bd.occu_id[k]=0;//空出一个索引位置

 


}
//
void free_little_id(Little_Buddy * p,int k){
 
if(0==k){
 
#ifdef DEBUG
cout<<"root "<<endl;
#endif
 return;
}

if(1==k){
 
#ifdef DEBUG 
cout<<"little root freed "<<endl;
#endif

p->occupied[1]=FALSE;//清空索引所指向的空间
p->semi[1]=FALSE;//清空索引所指向的空间
return;
}

if(0==k%2){//左结点
 
 #ifdef DEBUG1
 cout<<k<<" left virutal freed"<<endl;
 #endif
 
 if(!p->occupied[k+1] || !p->semi[k+1]){//右边也空

 #ifdef DEBUG1
 cout<<k+1<<" right blank too"<<endl;
 #endif
 
 free_little_id(p,k/2); 
 p->occupied[k]=FALSE;//清空索引所指向的空间
 p->semi[k]=FALSE;//清空索引所指向的空间
 }
}
else{//是右结点

 #ifdef DEBUG1
 cout<<k<<" right virutal freed"<<endl;
 #endif

 if(!p->occupied[k-1]||!p->semi[k-1]){//左边也空

 #ifdef DEBUG1
 cout<<k-1<<"left blank too"<<endl;
 #endif
 

 free_little_id(p,(k-1)/2); 
 p->occupied[k]=FALSE;//清空索引所指向的空间
 
 }
 

}
}//end free_little_id
//
//
void free_little(void * addr){

int target=(int)addr;
int d;
for(int d=0;d<BIG_BLOCK_MAX;d++){
 int head=(int)lb_list[d];
 int tail=(int)((char*)lb_list[d]+BIG_BLOCK_SIZE);
 if(target>=head &&target<tail){
  int k=target%LITTLE_BLOCK_MAX;

  Little_Buddy * p=lb_list[d];
  while(p->address[k]!=addr ||!p->occu_id[k]){
   k++;
   if(k==BIG_BLOCK_MAX){
    k=0;
   }
  }
 
  int id=p->occu_id[k];

  p->occupied[id]=FALSE;
  p->semi[id]=FALSE;

#ifdef DEBUG1
  cout<<"idx"<<k<<endl<<endl;
#endif
 
  if(id==1){//是小表根结点
   free(p);//释放掉小表根

#ifdef DEBUG
   cout<<"free little table"<<endl<<endl;
#endif
 
  }

 

  

  if(id%2==0){//左结点

   if(!p->occupied[id+1] &&!p->semi[id+1]){//右边也空
#ifdef DEBUG
    cout<<" right also blank:"<<id<<endl<<endl;
#endif
    free_little_id(p,id/2);//释放上层结点  
    return;
   }
  }


  else{//右结点
   if(!p->occupied[p->occu_id[k]-1]){//左边也空
#ifdef DEBUG
    cout<<"left also blank:"<<p->occu_id[k]<<endl<<endl;
#endif
    free_little_id(p,(id-1)/2);//释放上层结点  
    return;
   }

  }
 }
}
}
//

 

 

 

 


//
void free(void * addr){
 
int target=(int)addr;
int base=(int)SYS_STACK;

if(target<base ||target>base+STACK_MAX){return;}
if((target-base)% BIG_BLOCK_SIZE==0){//是大表上的结点，BIG_BLOCK_SIZE为单位分配
#ifdef DEBUG
 cout<<"free_big"<<endl;
#endif
 free_big(addr);
}

else{//小表
#ifdef DEBUG
 cout<<"free_little"<<endl;
#endif
 
 free_little(addr);
} 


}

int memory_size(void * addr){ // chech that how many space has assign to it
int target=(int)addr;
int base=(int)SYS_STACK;

if(target<base ||target>base+STACK_MAX){return -1;}
if((target-base)% BIG_BLOCK_SIZE==0){//是大表上的结点，BIG_BLOCK_SIZE为单位分配
#ifdef DEBUG
 cout<<"free_big"<<endl;
#endif
 return memory_size_big(addr);
}

else{//小表
#ifdef DEBUG
 cout<<"size_little"<<endl;
#endif
 
 return memory_size_little(addr);
}
}

/*
 *99 未知错误
 98 空间不足
 96 释放一个buddy系统中没有的地址（指针）
 *
 * */
#ifdef TEST_MEMORY
int main(){
 
double * d[10];

#ifdef TEST_BIG
int * a=(int*)malloc(1000*sizeof(int));
a[999]=1;
free(a);

double * d[10];
d[0]=(double *)malloc(2000*sizeof(double));
d[1]=(double *)malloc(2000*sizeof(double));
d[2]=(double *)malloc(4000*sizeof(double));
d[3]=(double *)malloc(8000*sizeof(double));


int i;
for(i=0;i<4;i++){
 free(d[i]);
}

//d[0]=(double *)malloc(8000*sizeof(double));
d[1]=(double *)malloc(16000*sizeof(double));
//d[2]=(double *)malloc(4000*sizeof(double));
//d[3]=(double *)malloc(8000*sizeof(double));
d[1][15999]=1;
free(d[1]);

d[1]=(double *)malloc(32000*sizeof(double));

free(d[1]);

d[1]=(double *)malloc(42000*sizeof(double));
#endif

#ifdef TEST_LITTLE
d[0]=(double *)malloc(2);
d[1]=(double *)malloc(4);
d[2]=(double *)malloc(8);
d[3]=(double *)malloc(16);
d[4]=(double *)malloc(32);
d[5]=(double *)malloc(64);
int i;
for(i=0;i<6;i++){
 free(d[i]);
}
#endif
}

#endif //endif TEST_MEMORY

#endif//endif MEMORY_C

RobinKin
关注
用DNSPod和Squid打造自己的CDN (六) 编译并安装Squid
09-15
- `--enable-removal-policies=heap,lru`：选择移除策略为堆和 LRU（最近最少使用）。 - `--enable-delay-pools`：启用延迟池功能。 运行 configure 命令： ```bash ./configure --prefix=/usr/local/squid --...
标准数据类型宏定义使用
li
09-05 3017
对于一些标准的数据类型，例如unsigned int， unsigned short， unsigned long 等，我们可以将其重命名成为简易拼写的字母，这样在使用的时候，既减少了拼写，又显得清楚明了，下面是我常用的头文件的定义： my_basetype.h #ifndef _BASETYPE_H_ #define _BASETYPE_H_ /*********************...
文章标题
qq_31384627的博客
06-04 254
include <stdio.h>include <stdlib.h>include <string.h>include <unistd.h>include <sys/time.h>include <arpa/inet.h>include <netdb.h>define ICMP_SIZE (sizeof(struct icmp))define ICMP_ECHO 8define ICMP_ECHO
JVM内存分布策略及在堆中的布局
JYYabc的博客
12-07 174
顺序分配，分配与未分配之间添加一个指针，每次分配时，指针往后移动需要的空间即可优点：操作简单缺点：要求堆空间要规整；多线程下效率不高按需分配，需要一张表记录分配情况优点：需要一个列表做存储缺点：产生了空间碎片问题，大对象存入时会出现无连续空间问题在HotSpot虚拟机里，对象在堆内存中的存储布局可以划分为三个部分：2.1.1 Mark Word存储对象自身的运行时数据：哈 希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。使用Mark Word（一个有着动态定义的
【深入理解JVM（二）】：对象揭秘与堆内存分配策略
大志的学习笔记
03-07 685
JVM中对象的创建过程、对象的内存布局、对象的访问以及堆内存分配策略。
JVM内存划分
m0_68642284的博客
03-21 1199
JVM内存划分
64k梦网卡市场推广策略暨品牌建设提案PPT.ppt
11-19
产品分析中，64k梦网卡的特色包括大容量存储（最多可存储1000个联系人信息）、短信群发、一卡双号、动态下载和动态分配等功能。其中，大容量联系人存储被视为最具吸引力的卖点，将通过戏剧性的创意展示和促销活动...
64k梦网卡市场推广策略与品牌建设提案.pptx
10-10
64k梦网卡的产品分析揭示了其四大支持点：大容量存储、短信群发、一卡双号和动态下载及分配功能。其中，大容量号码簿被视作最具吸引力和实用性的卖点。因此，传播策略应聚焦于此，通过戏剧性的创意展示产品优势，...
--XX市级智慧图书馆建设方案.doc
07-10
针对链路利用率低、配置维护复杂以及网络故障率高的问题，方案推荐采用集群+堆叠的无环网络方案，通过冗余链路和智能路由策略，提高网络的可用性和效率，降低故障风险。 二、简化运维与多控 “Easyoperation”理念...
Chibios源码
10-19
Chibios包含堆内存管理，支持动态内存分配和释放，同时也支持静态内存池，提供更高效、可控的内存分配策略。 5. **硬件抽象层（HAL）**：Chibios的硬件抽象层允许开发者在不同的微控制器上复用代码，减少与具体硬件...
堆空间内存分配策略
实践求真知
07-10 413
一点睛 如果对象在 Eden 出生并经过第一次 Minor GC 后仍然存活，并且能被 Survivor 容纳的话，将被移动到 survivor 空间中，并将对象年龄设为1。对象在 survivor 区中每熬过一次 MinorGC，年龄就增加1岁，当它的年龄增加到一定程度（默认为15岁，其实每个 JVM、每个 GC 都有所不同）时，就会被晋升到老年代。 对象晋升老年代的年龄阀值，可以通过选项 -XX:MaxTenuringThreshold 来设置。 二 针对不同年龄段的对象分配原则如下所示 1 .
4.JVM--堆内存分配策略
qq_40134461的博客
02-28 321
一. 堆内存分配策略 我们都知道，java中对象都放在堆中，那么JVM会如何给新生对象分配内存呢？ 内存参数回顾：-Xms初始堆内存大小，-Xmx最大堆内存，相等不可扩展，-Xmn堆中新生代对象的内存大小，剩余的就是老年代内存 有下面几个原则： （1）优先使用Eden区域 新来的要分配内存的对象都属于新生代对象，我们知道，回收新生代对象是复制算法，，分为Eden区和两个survivor区，所以新生...
堆内存的结构和分配策略
最新发布
DKPT的博客
05-17 244
堆内存是Java内存管理的核心区域，一个JVM实例只存在一个堆内存，在JVM启动时被创建并确定空间大小。
34.堆内存分配策略(或对象提升(Promotion)规则)总结(掌握）
simpleGq的专栏
07-13 635
目录1.堆内存分配策略(或对象提升(Promotion)规则) 1.堆内存分配策略(或对象提升(Promotion)规则) 一般情况下的策略： 1.对象会被优先分配到Eden区 2.大对象，如果Eden区放不下，就会被直接放到老年代 3.长期存活的对象(Survivor区中的对象的age超过阈值的对象)，会被放到老年代 4.动态年龄判断。如果Survivor区中的相同年龄的所有对象大小的总和大于Survivor空间的一半，年龄大于或等于该年龄的对象可以直接进入老年代，无须等到MaxTenuringThre
内存分配策略
weishuai528的博客
05-09 880
这里的内存指的是Java堆内存 1.优先分配到Eden区 2.如果有大对象，直接进入老年代 3.长期存活的对象，分配到老年代 4.如果Eden空间不够，需要向老年代借空间，空间担保 5.动态对象年龄判断 1.优先分配到Eden区 public class TestMemory { @Test public void test01() { by...
7.7 堆 - 内存分配策略
u013559614的博客
03-12 205
内存分配策略 如果对象在Eden出生并经过第一次MinorGC 后仍然存活，并且能被Survivor容纳的话，将被移动到Survivor空间中，并将对象年龄设为1。对象在Survivor区中每熬过一次MinorGC ，年龄就增加1 岁，当它的年龄增加到一定程度(默认为15岁，其实每个JVM、每个GC都有所不同)时，就会被晋升到老年代中。 对象晋升老年代的年龄阈值，可以通过选项-xx: MaxTenuringThreshold来设置。 针对不同年龄段的对象分配原则如下所示: 优先分配到Ederi 大对
堆内存空间和内存分配策略
阿宅的技术博客
09-15 3518
堆内存空间和内存分配策略 Java 堆主要分为2个区域-年轻代与老年代，其中年轻代又分 Eden 区和 Survivor 区，而Survivor 区又分 From 和 To 2个区。如下图： Eden区 IBM 公司的专业研究表明，新生代中有98%的对象是“朝生夕死”，对象会在新生代 Eden 区中进行分配，当 Eden 区没有足够空间进行分配时，虚拟机会发起一次 Minor GC，Minor ...
JVM堆内存分配策略
swadian2008的博客
01-05 1181
目录 一、JVM堆内存划分 二、GC流程 三、JAVA堆内存分配与回收策略 1.对象优先在Eden区分配 2.大对象直接进入老年代 3.长期存活的对象将进入老年代 4.动态对象年龄判定 5.空间分配担保 三、逃逸分析与栈上分配 1、相关概念 （1）逃逸分析(Escape Analysis) （2）栈上分配 （3）同步消除 （4）标量替换 2、栈上分配深入分析 （1）...
JVM堆内存分配与回收策略
西瓜游侠的博客
07-29 791
1、堆划分在JDK1.7以及之前的版本中，堆内存通常被分为三块区域：新生代、老年代、永久代。 新生代又分为：Eden区、From Survivor区（S0）、To Survivor区（S1）。默认8:1:1。 而在JDK1.8中情况发生了变化，把存放元数据中的永久内存从堆内存中移到了本地内存(native memory)中。 JDK1.8也提供了一个新的设置Matespace（元空间）内存大小
C语言实现堆分配存储字符串详细教程
"这篇资源详细介绍了如何在C语言中使用堆分配存储表示法来实现数据结构中的串（字符串）。文章通过一系列的函数展示了如何初始化、赋值、打印和获取字符串长度等基本操作。" 在C语言中，数据结构的实现往往需要对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值