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;
	}
}

int main() {
  void *addr;
  char *str;
  int i;

  /* get the current brk point */
  addr = sbrk(0);

  /* create a new brk point that is higher than the current
     and also page aligned */
  addr = (void*)(((int)addr & 0xfffff000)+ 0x2000);
  
  /* set the new brk to addr */
  if (brk(addr) != 0) {
    fprintf(stderr, "brk() failed: %s\n", strerror(errno));
    return -1;
  }

  str = ((char *)addr) - 10;

  /* fill in the string up to the brk point */
  for(i = 0; i < 10; i++)
    str[i] = 'f';

  /* call foo and cross our fingers */
  //printf("%s\n",str );
  foo(str);

  return 0;
}

static bool getYesterdayTodayAndTomorrow(JNIEnv* env, jobject localeData, const Locale& locale, const char* locale_name) {
  UErrorCode status = U_ZERO_ERROR;
  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
  ScopedResourceBundle fields(ures_getByKey(root.get(), "fields", NULL, &status));
  ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));
  ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));
  if (U_FAILURE(status)) {
    return false;
  }

  UnicodeString yesterday(ures_getUnicodeStringByKey(relative.get(), "-1", &status));
  UnicodeString today(ures_getUnicodeStringByKey(relative.get(), "0", &status));
  UnicodeString tomorrow(ures_getUnicodeStringByKey(relative.get(), "1", &status));
  if (U_FAILURE(status)) {
    ALOGE("Error getting yesterday/today/tomorrow for %s: %s", locale_name, u_errorName(status));
    return false;
  }

  // We title-case the strings so they have consistent capitalization (http://b/14493853).
  UniquePtr<BreakIterator> brk(BreakIterator::createSentenceInstance(locale, status));
  if (U_FAILURE(status)) {
    ALOGE("Error getting yesterday/today/tomorrow break iterator for %s: %s", locale_name, u_errorName(status));
    return false;
  }
  yesterday.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
  today.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
  tomorrow.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);

  setStringField(env, localeData, "yesterday", yesterday);
  setStringField(env, localeData, "today", today);
  setStringField(env, localeData, "tomorrow", tomorrow);
  return true;
}

int main () {
  int i;
  int inc_dec;
  int delta;
  intptr_t brk_stat;

  // loop to first increase, then decrease
  for (inc_dec = 1; inc_dec >= -1; inc_dec-=2) {
     // loop to increase(decrease) with small then big delta
     for (delta = 1; delta <= 400; delta+=399) {
        if (0) printf("initial brk value for inc_dec %d delta %d: %p\n",
               inc_dec, delta, sbrk(0));
        for (i=0; i<MAX; i++) {
           brk_stat = (intptr_t)brk(sbrk(0) + inc_dec * delta);
           if (brk_stat == -1) {
              printf("brk value at failure: %p\n", sbrk(0));
              perror ("brk() failed!\n");
              return 0;
           }
        }
        if (0) printf("resulting brk value for inc_dec %d delta %d: %p\n",
               inc_dec, delta, sbrk(0));
     }
  }

  return 0;
} 

void free(void *ptr){
  sum_frees++;
  num_allocated--;

  block_t current;
  if (valid_address(ptr)){
    current = get_block(ptr);
    current->free = 1;
    if(current->prev && current->prev->free){
      //merge with prev block if works
      current = merge_block(current->prev);
    }
    if (current->next){
      //merge with next
      merge_block(current);
    } else {
      if (current->prev){
        current->prev->next = NULL;
      } else {
        //no more blocks
        base = NULL;
      }
      brk(current);
    }
  } else {
    perror("invalid ptr at free");
  }
}

void * _PDCLIB_allocpages( int const n )
{
    if ( membreak == NULL )
    {
        /* first call, make sure end-of-heap is page-aligned */
        intptr_t unaligned = 0;
        membreak = sbrk( 0 );
        unaligned = _PDCLIB_PAGESIZE - (intptr_t)membreak % _PDCLIB_PAGESIZE;
        if ( unaligned < _PDCLIB_PAGESIZE )
        {
            /* end-of-heap not page-aligned - adjust */
            if ( sbrk( unaligned ) != membreak )
            {
                /* error */
                return NULL;
            }
            membreak = (char *)membreak + unaligned;
        }
    }
    /* increasing or decreasing heap - standard operation */
    void * oldbreak = membreak;
    membreak = (void *)( (char *)membreak + ( n * _PDCLIB_PAGESIZE ) );
    if ( brk( membreak ) == 0 )
    {
        /* successful */
        return oldbreak;
    }
    else
    {
        /* out of memory */
        membreak = oldbreak;
        return NULL;
    }
}