int odp_pool_destroy(odp_pool_t pool_hdl)
{
uint32_t pool_id = pool_handle_to_index(pool_hdl);
pool_entry_t *pool = get_pool_entry(pool_id);
int i;
if (pool == NULL)
return -1;
POOL_LOCK(&pool->s.lock);
/* Call fails if pool is not allocated or predefined*/
if (pool->s.pool_shm == ODP_SHM_INVALID ||
pool->s.flags.predefined) {
POOL_UNLOCK(&pool->s.lock);
return -1;
}
/* Make sure local caches are empty */
for (i = 0; i < ODP_THREAD_COUNT_MAX; i++)
flush_cache(&pool->s.local_cache[i], &pool->s);
/* Call fails if pool has allocated buffers */
if (odp_atomic_load_u32(&pool->s.bufcount) < pool->s.buf_num) {
POOL_UNLOCK(&pool->s.lock);
return -1;
}
odp_shm_free(pool->s.pool_shm);
pool->s.pool_shm = ODP_SHM_INVALID;
POOL_UNLOCK(&pool->s.lock);
return 0;
}
int odp_pool_info(odp_pool_t pool_hdl, odp_pool_info_t *info)
{
uint32_t pool_id = pool_handle_to_index(pool_hdl);
pool_entry_t *pool = get_pool_entry(pool_id);
if (pool == NULL || info == NULL)
return -1;
info->name = pool->s.name;
info->params = pool->s.params;
return 0;
}
odp_buffer_t buffer_alloc(odp_pool_t pool_hdl, size_t size)
{
uint32_t pool_id = pool_handle_to_index(pool_hdl);
pool_entry_t *pool = get_pool_entry(pool_id);
uintmax_t totsize = pool->s.headroom + size + pool->s.tailroom;
odp_anybuf_t *buf;
/* Reject oversized allocation requests */
if ((pool->s.flags.unsegmented && totsize > pool->s.seg_size) ||
(!pool->s.flags.unsegmented &&
totsize > pool->s.seg_size * ODP_BUFFER_MAX_SEG))
return ODP_BUFFER_INVALID;
/* Try to satisfy request from the local cache */
buf = (odp_anybuf_t *)(void *)get_local_buf(&local_cache[pool_id],
&pool->s, totsize);
/* If cache is empty, satisfy request from the pool */
if (odp_unlikely(buf == NULL)) {
buf = (odp_anybuf_t *)(void *)get_buf(&pool->s);
if (odp_unlikely(buf == NULL))
return ODP_BUFFER_INVALID;
/* Get blocks for this buffer, if pool uses application data */
if (buf->buf.size < totsize) {
intmax_t needed = totsize - buf->buf.size;
do {
uint8_t *blk = get_blk(&pool->s);
if (blk == NULL) {
ret_buf(&pool->s, &buf->buf);
return ODP_BUFFER_INVALID;
}
buf->buf.addr[buf->buf.segcount++] = blk;
needed -= pool->s.seg_size;
} while (needed > 0);
buf->buf.size = buf->buf.segcount * pool->s.seg_size;
}
}
/* By default, buffers inherit their pool's zeroization setting */
buf->buf.flags.zeroized = pool->s.flags.zeroized;
if (buf->buf.type == ODP_EVENT_PACKET)
packet_init(pool, &buf->pkt, size);
return odp_hdr_to_buf(&buf->buf);
}
static void mmap_fill_ring(struct ring *ring, odp_pool_t pool_hdl, int fanout)
{
/*@todo add Huge Pages support*/
int pz = getpagesize();
uint32_t pool_id;
pool_entry_t *pool_entry;
if (pool_hdl == ODP_POOL_INVALID)
ODP_ABORT("Invalid pool handle\n");
pool_id = pool_handle_to_index(pool_hdl);
pool_entry = get_pool_entry(pool_id);
/* Frame has to capture full packet which can fit to the pool block.*/
ring->req.tp_frame_size = (pool_entry->s.blk_size +
TPACKET_HDRLEN + TPACKET_ALIGNMENT +
+ (pz - 1)) & (-pz);
/* Calculate how many pages do we need to hold all pool packets
* and align size to page boundary.
*/
ring->req.tp_block_size = (ring->req.tp_frame_size *
pool_entry->s.buf_num + (pz - 1)) & (-pz);
if (!fanout) {
/* Single socket is in use. Use 1 block with buf_num frames. */
ring->req.tp_block_nr = 1;
} else {
/* Fanout is in use, more likely taffic split accodring to
* number of cpu threads. Use cpu blocks and buf_num frames. */
ring->req.tp_block_nr = odp_cpu_count();
}
ring->req.tp_frame_nr = ring->req.tp_block_size /
ring->req.tp_frame_size * ring->req.tp_block_nr;
ring->mm_len = ring->req.tp_block_size * ring->req.tp_block_nr;
ring->rd_num = ring->req.tp_frame_nr;
ring->flen = ring->req.tp_frame_size;
}
void odp_pool_print(odp_pool_t pool_hdl)
{
pool_entry_t *pool;
uint32_t pool_id;
pool_id = pool_handle_to_index(pool_hdl);
pool = get_pool_entry(pool_id);
uint32_t bufcount = odp_atomic_load_u32(&pool->s.bufcount);
uint32_t blkcount = odp_atomic_load_u32(&pool->s.blkcount);
uint64_t bufallocs = odp_atomic_load_u64(&pool->s.poolstats.bufallocs);
uint64_t buffrees = odp_atomic_load_u64(&pool->s.poolstats.buffrees);
uint64_t blkallocs = odp_atomic_load_u64(&pool->s.poolstats.blkallocs);
uint64_t blkfrees = odp_atomic_load_u64(&pool->s.poolstats.blkfrees);
uint64_t bufempty = odp_atomic_load_u64(&pool->s.poolstats.bufempty);
uint64_t blkempty = odp_atomic_load_u64(&pool->s.poolstats.blkempty);
uint64_t hiwmct =
odp_atomic_load_u64(&pool->s.poolstats.high_wm_count);
uint64_t lowmct =
odp_atomic_load_u64(&pool->s.poolstats.low_wm_count);
ODP_DBG("Pool info\n");
ODP_DBG("---------\n");
ODP_DBG(" pool %" PRIu64 "\n",
odp_pool_to_u64(pool->s.pool_hdl));
ODP_DBG(" name %s\n",
pool->s.flags.has_name ? pool->s.name : "Unnamed Pool");
ODP_DBG(" pool type %s\n",
pool->s.params.type == ODP_POOL_BUFFER ? "buffer" :
(pool->s.params.type == ODP_POOL_PACKET ? "packet" :
(pool->s.params.type == ODP_POOL_TIMEOUT ? "timeout" :
"unknown")));
ODP_DBG(" pool storage ODP managed shm handle %" PRIu64 "\n",
odp_shm_to_u64(pool->s.pool_shm));
ODP_DBG(" pool status %s\n",
pool->s.quiesced ? "quiesced" : "active");
ODP_DBG(" pool opts %s, %s, %s\n",
pool->s.flags.unsegmented ? "unsegmented" : "segmented",
pool->s.flags.zeroized ? "zeroized" : "non-zeroized",
pool->s.flags.predefined ? "predefined" : "created");
ODP_DBG(" pool base %p\n", pool->s.pool_base_addr);
ODP_DBG(" pool size %lu(k)\n",
pool->s.pool_size / 1024);
ODP_DBG(" pool mdata base %p\n", pool->s.pool_mdata_addr);
ODP_DBG(" udata size %u\n", pool->s.udata_size);
ODP_DBG(" headroom %u\n", pool->s.headroom);
ODP_DBG(" tailroom %u\n", pool->s.tailroom);
if (pool->s.params.type == ODP_POOL_BUFFER) {
ODP_DBG(" buf size %1u\n", pool->s.params.buf.size);
ODP_DBG(" buf align %u requested, %u used\n",
pool->s.params.buf.align, pool->s.buf_align);
} else if (pool->s.params.type == ODP_POOL_PACKET) {
ODP_DBG(" seg length %u requested, %u used\n",
pool->s.params.pkt.seg_len, pool->s.seg_size);
ODP_DBG(" pkt length %u requested, %u used\n",
pool->s.params.pkt.len, pool->s.blk_size);
}
ODP_DBG(" num bufs %u\n", pool->s.buf_num);
ODP_DBG(" bufs available %u %s\n", bufcount,
pool->s.low_wm_assert ? " **low wm asserted**" : "");
ODP_DBG(" bufs in use %u\n", pool->s.buf_num - bufcount);
ODP_DBG(" buf allocs %lu\n", bufallocs);
ODP_DBG(" buf frees %lu\n", buffrees);
ODP_DBG(" buf empty %lu\n", bufempty);
ODP_DBG(" blk size %1u\n",
pool->s.seg_size > ODP_MAX_INLINE_BUF ? pool->s.seg_size : 0);
ODP_DBG(" blks available %u\n", blkcount);
ODP_DBG(" blk allocs %lu\n", blkallocs);
ODP_DBG(" blk frees %lu\n", blkfrees);
ODP_DBG(" blk empty %lu\n", blkempty);
ODP_DBG(" high wm value %u\n", pool->s.high_wm);
ODP_DBG(" high wm count %lu\n", hiwmct);
ODP_DBG(" low wm value %u\n", pool->s.low_wm);
ODP_DBG(" low wm count %lu\n", lowmct);
}
