Ejemplo n.º 1
0
// allocate s bytes within region r
void * _reap_malloc(struct _ReapHandle *r, _AliasQualHandle_t aq, unsigned int s) {
  void *result;
  if(r->curr == NULL) { 
    //grab a page, and hold onto a ref. We need to free it later
    void *p =malloc(default_region_page_size+sizeof(struct _ReapPage));
    if(!p)
      throw(1)
    r->curr = (struct _ReapPage*)p;
    r->curr->bget_page = (p + sizeof(struct _ReapPage));
    r->curr->next = NULL;
    //pass the page to bget
    r->bkey = bget_init_region(r->curr->bget_page, default_region_page_size);
    if(!r->bkey) 
      throw(2)
    r->bkey->priv = r;
    // direct allocation for large buffers is a pain ... revisit
    // no direct allocation means there is no need for a release function
    // no compaction, default size for acquisition request is page_size+
    bectl(r->bkey, NULL, _acquire_reap_page, NULL, default_region_page_size);
  }
  if(aq == CYC_CORE_REFCNT_AQUAL) {
    result = bgetz(r->bkey, (bufsize)(s + sizeof(int)));
    if(!result)
      throw(3)
    *((int*)result) = 1;
    result += sizeof(int);
    return (void*)result;
  }
  else {
    result = bgetz(r->bkey, (bufsize)s);
    if(!result)
      throw(4)
    return (void*)result;
  }
}
Ejemplo n.º 2
0
laser_packet* lp_alloc(packet_data* data)
{
	if (data == NULL)
	{
		return NULL;
	}

	uint16_t aligned_size = align_size(sizeof(laser_packet));
	laser_packet* lp = bgetz(aligned_size);

	if (lp == NULL)
	{
		return NULL;
	}

	lp->data = data;
	lp->data_size = data->total_size;

	return lp;
}
Ejemplo n.º 3
0
static void *raw_calloc(size_t hdr_size, size_t ftr_size, size_t pl_nmemb,
		size_t pl_size)
{
	size_t s = hdr_size + ftr_size + pl_nmemb * pl_size;
	void *ptr = NULL;

	raw_malloc_validate_pools();

	/* Check wrapping */
	if (s < pl_nmemb || s < pl_size)
		goto out;

	/* BGET doesn't like 0 sized allocations */
	if (!s)
		s++;

	ptr = bgetz(s);
out:
	raw_malloc_return_hook(ptr, pl_nmemb * pl_size);

	return ptr;
}
Ejemplo n.º 4
0
inline void *calloc(size_t n, size_t size)
{
  return bgetz((long long int)n * size);
}