C++ brk函数代码示例

int main(void)
{
   int i;
   void* orig_ds = sbrk(0);
   void* ds = orig_ds;
   void* vals[10];
   void* res;
   void *prev;
#define EOL ((void*)( ~(long)0 ))
   vals[0] = (void*)0;
   vals[1] = (void*)1;
   vals[2] = ds - 0x1;          // small shrink
   vals[3] = ds;
   vals[4] = ds + 0x1000;       // small growth
   vals[5] = ds + 0x40000000;   // too-big growth
   vals[6] = ds + 0x500;        // shrink a little, but still above start size
   vals[7] = ds - 0x1;          // shrink below start size
//   vals[8] = ds - 0x1000;       // shrink a lot below start size (into text)
//   vals[9] = EOL;
   vals[8] = EOL;

   for (i = 0; EOL != vals[i]; i++) {
      res = brk(vals[i]);
   }

   assert( 0 == brk(orig_ds) );  // libc brk()

   for (i = 0; EOL != vals[i]; i++) {
      res = (void*)brk(vals[i]);
   }

   return 0;
}

void *sbrk(intptr_t incr)
{
        uintptr_t oldbrk;

        /* If we don't have a saved break, find it from the kernel */
        if (!__curbrk) {
                if (0 > (long)(__curbrk = (void *) trap(SYS_brk, (uint32_t) NULL))) {
                        return (void *) -1;
                }
        }

        oldbrk = (uintptr_t) __curbrk;

        /* Increment or decrement the saved break */

        if (incr < 0) {
                if ((uintptr_t) - incr > oldbrk) {
                        return (void *) -1;
                } else if (brk((void *)(oldbrk - (uintptr_t) - incr)) < 0) {
                        return (void *) -1;
                }
        } else if (incr > 0) {
                if (brk((void *)(oldbrk + (uintptr_t) incr)) < 0) {
                        return (void *) -1;
                }
        }
        return (void *) oldbrk;
}

void *
sbrk(unsigned int ptrdiff)
{

   void *newend;

   /* have we been initialized yet? */
   if (curheap == 0) {
      curheap = (void *) brk(0);
   }

   /* are they just querying the current heap? */
   if (ptrdiff == 0) {
      return curheap;
   }

   /* where we want our new heap to end */
   newend = curheap + ptrdiff;

   /* can we get the memory? */
   if (brk(newend) < 0) {
      return 0;
   }

   /* we got the memory */
   curheap = newend;
   return curheap - ptrdiff;
}

int
openbsd_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED, size_t off ATTRIBUTE_UNUSED)
{
  void *addr;

  if (size == 0)
    return -1;

  /* sanity check base address */
  addr = sbrk(0);
  if (addr == (void *)-1 || base < addr)
    return -1;

  /* set base for sbrk */
  if (brk(base) != 0)
    return -1;

  /* attempt to get the memory */
  addr = sbrk(size);
  if (addr == (void *)-1)
    return -1;

  /* sanity check the result */
  if (addr != base) {
    brk(base);
    return -1;
  }

  return 0;
}

void *
openbsd_gt_pch_get_address (size_t size, int fd ATTRIBUTE_UNUSED)
{
  void *base, *addr;
  size_t pgsz;

  if (size > INT_MAX)
          return NULL;

  pgsz = sysconf(_SC_PAGESIZE);
  if (pgsz == (size_t)-1)
    return NULL;

  base = sbrk(0);

  /* round up to nearest page */
  base = (void *)(((long)base + (pgsz - 1)) & ~(pgsz - 1));
  if (brk(base) != 0)
    return NULL;

  /* attempt to allocate size */
  addr = sbrk(size);
  if (addr == (void *)-1)
    return NULL;

  /* deallocate the memory */
  if (brk(base) != 0)
    return NULL;

  /* confirm addr is as expected */
  if (addr != base)
    return NULL;

  return base;
}

int main(void)
{
	//获取起始地址
	void* p = sbrk(0);
	printf("p = %p\n",p);

	//申请4个字节内存空间
	int res = brk(p+4);
	if(-1 == res)
	{
		perror("brk"),exit(-1);
	}
	printf("成功申请了4个字节的内存\n");
	void* cur = sbrk(0);
	printf("cur = %p\n",cur);

	//申请了4个字节
	brk(p+8);
	cur = sbrk(0);
	printf("cur = %p\n",cur);

	//释放了4个字节内存
	brk(p+4);
	cur = sbrk(0);
	printf("cur = %p\n",cur);

	//释放所有内存
	brk(p);
	return 0;
}

void free(void *ptr) {
  if (unlikely(!ptr)) {
    return;
  }
  pthread_mutex_lock(&list_lock);
  metadata_t* block_ptr = get_block(ptr);
  merge_block(block_ptr);

  if (unlikely(block_ptr->free != 0 || block_ptr->magic1 != MAGIC_USED || block_ptr->magic1 != block_ptr->magic2)) {
    printf(SEGFAULT);
    exit(-1);
  }
  alloc_count--;
  if (unlikely(alloc_count == 0)){
    brk(base);
    base = 0;
  } else if (block_ptr->next == NULL){
    block_ptr->prev->next = NULL;
    brk(block_ptr);
  } else {
    block_ptr->free = 1;
    block_ptr->magic1 = MAGIC_FREE;
    block_ptr->magic2 = MAGIC_FREE;
  }
  pthread_mutex_unlock(&list_lock);
}

void *sbrk(ssize_t increment)
{
  void *newbrk, *oldbrk;
  oldbrk= brk(0);
  if (!increment) return oldbrk;
  newbrk= brk(oldbrk + increment);
  if (newbrk == oldbrk) return (void *)-1;
  return oldbrk;
}

int main () {
  if (1) {
    if (x > 1 ) { foo(); brk(); }
    } else aaa();
  if (1)
    while (x > 1 ) { foo(); brk(); }
  else aaa();
  foo(); brk();
}

/*
 * Try to spend as much time as possible in kernelspace
 * to elapse ITIMER_PROF.
 */
static void kernel_loop(void)
{
	void *addr = sbrk(0);

	while (!done) {
		brk(addr + 4096);
		brk(addr);
	}
}

/*
 * ----------------------------------------------------------------------------
 * Free space previously allocated by malloc. This memory can now be used again
 * Also, colless any contiguous free nodes into one large free node to make
 * larger spaces available for larger allocation requests
 * ----------------------------------------------------------------------------
 */
void my_free(void *ptr){

  // Mark the node as free
  Node n = (Node)ptr - 1;
  n->free = 1;

  // If contiguous free space nodes exist, combine them into a single node
  // AKA: coalesce!
  // First look and see if a node has extra space behind it
  if (n->prev != NULL){
    if (n->prev->free == 1){
      n->prev->size = n->size + sizeof(struct node);
      n->prev->next = n->next;

      if (last == n)
        last = n->prev;

      if (cur == n)
        cur = n->prev;

      n = n->prev;
    }
  }

  //Now look and see if a node in front of the node is free
  if (n->next != NULL){
    if (n->next->free == 1){
      n->size += n->next->size + sizeof(struct node);
      n->next = n->next->next;
    }
  }

  // When the last node is free, we can cut it off and resize the heap to
  // contain only wnat we need
  // AKA: truncating
  if (n == last){
    if (last == first){
      first = 0;
      cur = 0;
      last = 0;
      brk((void*)(n));
    }

    else if (last == cur){
      cur = cur->prev;
      last = last->prev;
      last->next = NULL;
      brk((void*)(n-1));
    }

    else{
      last = last->prev;
      last->next = NULL;
      brk((void*)(n-1));
    }
  }
}

/*
 * Try to spend as much time as possible in kernelspace
 * to elapse ITIMER_PROF.
 */
static void kernel_loop(void)
{
	void *addr = sbrk(0);
	int err = 0;

	while (!done && !err) {
		err = brk(addr + 4096);
		err |= brk(addr);
	}
}

TEST(UNISTD_TEST, brk) {
  void* initial_break = get_brk();

  // The kernel aligns the break to a page.
  void* new_break = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(initial_break) + 1);
  ASSERT_EQ(0, brk(new_break));
  ASSERT_GE(get_brk(), new_break);

  new_break = page_align(reinterpret_cast<uintptr_t>(initial_break) + sysconf(_SC_PAGE_SIZE));
  ASSERT_EQ(0, brk(new_break));
  ASSERT_EQ(get_brk(), new_break);
}

int main()
{	
	//1.找到空闲空间的首地址
	int* p=(int*)sbrk(0);
	printf("sbrk(0):%p\n",p);
	//2.分配空间
	brk(p+1);
	printf("brk:%p\n",p);
	//3.使用空间
	*p=800;
	//4. 释放空间
	brk(p);
	
	return 0;
}

void testcase(unsigned long long *iterations)
{
	void *addr = sbrk(0);
	unsigned long page_size = getpagesize();

	while (1) {
		addr += page_size;
		brk(addr);

		addr -= page_size;
		brk(addr);

		(*iterations) += 2;
	}
}