/*
* Initialize the mbuf allocator.
*/
void
mbinit(void)
{
int i;
#if DIAGNOSTIC
if (mclsizes[0] != MCLBYTES)
panic("mbinit: the smallest cluster size != MCLBYTES");
if (mclsizes[nitems(mclsizes) - 1] != MAXMCLBYTES)
panic("mbinit: the largest cluster size != MAXMCLBYTES");
#endif
pool_init(&mbpool, MSIZE, 0, 0, 0, "mbufpl", NULL);
pool_setipl(&mbpool, IPL_NET);
pool_set_constraints(&mbpool, &kp_dma_contig);
pool_setlowat(&mbpool, mblowat);
pool_init(&mtagpool, PACKET_TAG_MAXSIZE + sizeof(struct m_tag),
0, 0, 0, "mtagpl", NULL);
pool_setipl(&mtagpool, IPL_NET);
for (i = 0; i < nitems(mclsizes); i++) {
snprintf(mclnames[i], sizeof(mclnames[0]), "mcl%dk",
mclsizes[i] >> 10);
pool_init(&mclpools[i], mclsizes[i], 0, 0, 0,
mclnames[i], NULL);
pool_setipl(&mclpools[i], IPL_NET);
pool_set_constraints(&mclpools[i], &kp_dma_contig);
pool_setlowat(&mclpools[i], mcllowat);
}
nmbclust_update();
}
/*
* dmoverioattach:
*
* Pseudo-device attach routine.
*/
void
dmoverioattach(int count)
{
pool_init(&dmio_state_pool, sizeof(struct dmio_state),
0, 0, 0, "dmiostate", NULL, IPL_SOFTCLOCK);
pool_init(&dmio_usrreq_state_pool, sizeof(struct dmio_usrreq_state),
0, 0, 0, "dmiourstate", NULL, IPL_SOFTCLOCK);
}
/*
* Reinitialize inode hash table.
*/
void
nfs_node_init()
{
malloc_type_attach(M_NFSNODE);
pool_init(&nfs_node_pool, sizeof(struct nfsnode), 0, 0, 0, "nfsnodepl",
&pool_allocator_nointr, IPL_NONE);
pool_init(&nfs_vattr_pool, sizeof(struct vattr), 0, 0, 0, "nfsvapl",
&pool_allocator_nointr, IPL_NONE);
}
/*
* Initialize timekeeping.
*/
void
time_init(void)
{
pool_init(&ptimer_pool, sizeof(struct ptimer), 0, 0, 0, "ptimerpl",
&pool_allocator_nointr, IPL_NONE);
pool_init(&ptimers_pool, sizeof(struct ptimers), 0, 0, 0, "ptimerspl",
&pool_allocator_nointr, IPL_NONE);
}
int
ext2fs_init(struct vfsconf *vfsp)
{
pool_init(&ext2fs_inode_pool, sizeof(struct inode), 0, 0, 0,
"ext2inopl", &pool_allocator_nointr);
pool_init(&ext2fs_dinode_pool, sizeof(struct ext2fs_dinode), 0, 0, 0,
"ext2dinopl", &pool_allocator_nointr);
return (ufs_init(vfsp));
}
void
ext2fs_init(void)
{
pool_init(&ext2fs_inode_pool, sizeof(struct inode), 0, 0, 0,
"ext2fsinopl", &pool_allocator_nointr, IPL_NONE);
pool_init(&ext2fs_dinode_pool, sizeof(struct ext2fs_dinode), 0, 0, 0,
"ext2dinopl", &pool_allocator_nointr, IPL_NONE);
ufs_init();
}
int
ext2fs_init(struct vfsconf *vfsp)
{
pool_init(&ext2fs_inode_pool, sizeof(struct inode), 0, 0, PR_WAITOK,
"ext2inopl", NULL);
pool_init(&ext2fs_dinode_pool, sizeof(struct ext2fs_dinode), 0, 0,
PR_WAITOK, "ext2dinopl", NULL);
return (ufs_init(vfsp));
}
int
udf_init(struct vfsconf *foo)
{
pool_init(&udf_trans_pool, MAXNAMLEN * sizeof(unicode_t), 0, 0,
PR_WAITOK, "udftrpl", NULL);
pool_init(&unode_pool, sizeof(struct unode), 0, 0,
PR_WAITOK, "udfndpl", NULL);
pool_init(&udf_ds_pool, sizeof(struct udf_dirstream), 0, 0,
PR_WAITOK, "udfdspl", NULL);
return (0);
}
int
udf_init(struct vfsconf *foo)
{
pool_init(&udf_trans_pool, MAXNAMLEN * sizeof(unicode_t), 0, 0, 0,
"udftrpl", &pool_allocator_nointr);
pool_init(&unode_pool, sizeof(struct unode), 0, 0, 0,
"udfndpl", &pool_allocator_nointr);
pool_init(&udf_ds_pool, sizeof(struct udf_dirstream), 0, 0, 0,
"udfdspl", &pool_allocator_nointr);
return (0);
}
/*
* Reinitialize inode hash table.
*/
void
nfs_node_init(void)
{
pool_init(&nfs_node_pool, sizeof(struct nfsnode), 0, 0, 0, "nfsnodepl",
&pool_allocator_nointr, IPL_NONE);
pool_init(&nfs_vattr_pool, sizeof(struct vattr), 0, 0, 0, "nfsvapl",
&pool_allocator_nointr, IPL_NONE);
if (workqueue_create(&nfs_sillyworkq, "nfssilly", nfs_sillyworker,
NULL, PRI_NONE, IPL_NONE, 0) != 0) {
panic("nfs_node_init");
}
}
int task_dispatcher_init(struct task_dispatcher_t** ptd, uint32_t nthreads)
{
LOGI("Starting task dispatcher with %d threads", nthreads);
struct task_dispatcher_t* td = malloc(sizeof(struct task_dispatcher_t));
memset(td, 0, sizeof(struct task_dispatcher_t));
td->nthreads = nthreads;
td->running = 1;
if (pool_init(&td->tasks, MAX_TASKS, sizeof(struct task_t)) != 0)
{
return -1;
}
pthread_mutex_init(&td->event_lock, NULL);
pthread_cond_init(&td->event, NULL);
pthread_mutexattr_init(&td->lock_attr);
pthread_mutexattr_settype(&td->lock_attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&td->lock, &td->lock_attr);
uint32_t i = 0;
for (i = 0; i < td->nthreads; ++i)
{
pthread_create(&td->threads[i], NULL, working_thread, td);
}
(*ptd) = td;
return 0;
}
int main(int argc,char **argv)
{
/*线程池中最多3个活动线程*/
pool_init(3);
int *workingnum=(int *)malloc(sizeof(int)*10);
/*连续向线程池中投入10个任务*/
int i;
for(i=0;i<10;i++)
{
workingnum[i]=i;
pool_add_worker(myprocess,&workingnum[i]);
}
/*等待所有任务完成*/
sleep(5);
/*销毁线程池*/
pool_destroy();
free(workingnum);
return 0;
}
int main(void)
{
go = false;
finish = false;
pool_init(&pool);
for(int i = 0;i < NUM_PRODUCER;i++)
{
pthread_create(&producer[i], NULL, &producer_runner, (void*)(size_t)i);
}
for(int i = 0;i < NUM_CONSUMER;i++)
{
pthread_create(&producer[i], NULL, &thread_runner, (void*)(size_t)i);
}
go = true;
sleep(1);
finish = true;
for(int i = 0;i < NUM_PRODUCER;i++)
{
pthread_join(producer[i], NULL);
}
for(int i = 0;i < NUM_CONSUMER;i++)
{
pthread_join(consumer[i], NULL);
}
return 0;
}
static void _ensure_pool_cleanup_gracefully_handles_cleaned_up_pool( void )
{
pool_t pool;
pool_init( &pool, 4, 16, allocator_default( ) );
pool_cleanup( &pool );
pool_cleanup( &pool );
}
static void _ensure_pool_is_empty_gracefully_handles_cleaned_up_pool( void )
{
pool_t pool;
pool_init( &pool, 4, 1, allocator_default( ) );
pool_cleanup( &pool );
TEST_REQUIRE( pool_is_empty( &pool ) != 0 );
}
int nfs4_acls_init(void)
{
LogDebug(COMPONENT_NFS_V4_ACL, "Initialize NFSv4 ACLs");
LogDebug(COMPONENT_NFS_V4_ACL,
"sizeof(fsal_ace_t)=%zu, sizeof(fsal_acl_t)=%zu",
sizeof(fsal_ace_t), sizeof(fsal_acl_t));
/* Initialize memory pool of ACLs. */
fsal_acl_pool =
pool_init(NULL, sizeof(fsal_acl_t), pool_basic_substrate, NULL,
NULL, NULL);
/* Create hash table. */
fsal_acl_hash = hashtable_init(&fsal_acl_hash_config);
if (!fsal_acl_hash) {
LogCrit(COMPONENT_NFS_V4_ACL,
"ERROR creating hash table for NFSv4 ACLs");
return NFS_V4_ACL_INTERNAL_ERROR;
}
nfs4_acls_test();
return NFS_V4_ACL_SUCCESS;
}
static void _ensure_pool_is_empty_returns_non_zero_on_empty_legitimate_pool( void )
{
pool_t pool;
pool_init( &pool, 4, 1, allocator_default( ) );
TEST_REQUIRE( pool_is_empty( &pool ) == 0 );
pool_cleanup( &pool );
}
/*
* Initialize buffers and hash links for buffers.
*/
void
bufinit(void)
{
struct buf *bp;
struct bqueues *dp;
int i;
int base, residual;
pool_init(&bufpool, sizeof(struct buf), 0, 0, 0, "bufpl", NULL);
for (dp = bufqueues; dp < &bufqueues[BQUEUES]; dp++)
TAILQ_INIT(dp);
bufhashtbl = hashinit(nbuf, M_CACHE, M_WAITOK, &bufhash);
base = bufpages / nbuf;
residual = bufpages % nbuf;
for (i = 0; i < nbuf; i++) {
bp = &buf[i];
bzero((char *)bp, sizeof *bp);
bp->b_dev = NODEV;
bp->b_vnbufs.le_next = NOLIST;
bp->b_data = buffers + i * MAXBSIZE;
LIST_INIT(&bp->b_dep);
if (i < residual)
bp->b_bufsize = (base + 1) * PAGE_SIZE;
else
bp->b_bufsize = base * PAGE_SIZE;
bp->b_flags = B_INVAL;
if (bp->b_bufsize) {
dp = &bufqueues[BQ_CLEAN];
numfreepages += btoc(bp->b_bufsize);
numcleanpages += btoc(bp->b_bufsize);
} else {
dp = &bufqueues[BQ_EMPTY];
numemptybufs++;
}
binsheadfree(bp, dp);
binshash(bp, &invalhash);
}
hidirtypages = bufpages / 4;
lodirtypages = hidirtypages / 2;
/*
* Reserve 5% of bufpages for syncer's needs,
* but not more than 25% and if possible
* not less then 2 * MAXBSIZE. locleanpages
* value must be not too small, but probably
* there are no reason to set it more than 1-2 MB.
*/
locleanpages = bufpages / 20;
if (locleanpages < btoc(2 * MAXBSIZE))
locleanpages = btoc(2 * MAXBSIZE);
if (locleanpages > bufpages / 4)
locleanpages = bufpages / 4;
if (locleanpages > btoc(2 * 1024 * 1024))
locleanpages = btoc(2 * 1024 * 1024);
#ifdef DEBUG
mincleanpages = locleanpages;
#endif
}
/*
* allocate anons
*/
void
uvm_anon_init()
{
pool_init(&uvm_anon_pool, sizeof(struct vm_anon), 0, 0, 0, "anonpl",
&pool_allocator_nointr);
pool_sethiwat(&uvm_anon_pool, uvmexp.free / 16);
}
/* Initialize the vnode structures and initialize each file system type. */
void
vfsinit(void)
{
int i;
struct vfsconf *vfsconflist;
int vfsconflistlen;
pool_init(&namei_pool, MAXPATHLEN, 0, 0, 0, "namei",
&pool_allocator_nointr);
/* Initialize the vnode table. */
vntblinit();
/* Initialize the vnode name cache. */
nchinit();
#ifdef WAPBL
wapbl_init();
#endif
/*
* Stop using vfsconf and maxvfsconf as a temporary storage,
* set them to their correct values now.
*/
vfsconflist = vfsconf;
vfsconflistlen = maxvfsconf;
vfsconf = NULL;
maxvfsconf = 0;
for (i = 0; i < vfsconflistlen; i++)
vfs_register(&vfsconflist[i]);
}
/******************************************************************
* macho_load_debug_info_from_map
*
* Loads the symbolic information from a Mach-O module.
* Returns
* FALSE if the file doesn't contain symbolic info (or this info
* cannot be read or parsed)
* TRUE on success
*/
static BOOL macho_load_debug_info_from_map(struct module* module,
struct macho_file_map* fmap)
{
BOOL ret = FALSE;
struct macho_debug_info mdi;
int result;
TRACE("(%p, %p/%d)\n", module, fmap, fmap->fd);
module->module.SymType = SymExport;
mdi.fmap = fmap;
mdi.module = module;
pool_init(&mdi.pool, 65536);
hash_table_init(&mdi.pool, &mdi.ht_symtab, 256);
result = macho_enum_load_commands(fmap, LC_SYMTAB, macho_parse_symtab, &mdi);
if (result > 0)
ret = TRUE;
else if (result < 0)
WARN("Couldn't correctly read stabs\n");
macho_finish_stabs(module, &mdi.ht_symtab);
pool_destroy(&mdi.pool);
return ret;
}
// **TODO**: Add an test. This function shows only the usage of `append_cb`.
static char * test_single() {
mpz_t a, b;
mpz_array array1, array2, array_expect;
mpz_pool pool;
pool_init(&pool, 0);
array_init(&array1, 3);
array_init(&array2, 3);
array_init(&array_expect, 3);
// primes: 577, 727, 863
mpz_init_set_str(a, "577", 10);
array_add(&array_expect, a);
mpz_set_str(a, "727", 10);
array_add(&array_expect, a);
mpz_set_str(a, "863", 10);
array_add(&array_expect, a);
// `a = 727 * 577 = 419479`
// `b = 727 * 863 = 627401`
mpz_set_str(a, "419479", 10);
mpz_init_set_str(b, "627401", 10);
append_cb(&pool, &array1, a, b);
if (mpz_cmp_ui(a, 419479) != 0) {
return "append_cb has changed the input value a!";
}
if (mpz_cmp_ui(b, 627401) != 0) {
return "append_cb has changed the input value b!";
}
array_msort(&array1);
if (!array_equal(&array_expect, &array1)) {
return "array1 and array_expect differ!";
}
append_cb(&pool, &array2, b, a);
if (mpz_cmp_ui(a, 419479) != 0) {
return "append_cb has changed the input value a!";
}
if (mpz_cmp_ui(b, 627401) != 0) {
return "append_cb has changed the input value b!";
}
array_msort(&array2);
if (!array_equal(&array_expect, &array2)) {
return "array2 and array_expect differ!";
}
mpz_clear(a);
mpz_clear(b);
array_clear(&array1);
array_clear(&array2);
array_clear(&array_expect);
pool_clear(&pool);
return 0;
}
static int
in6pcb_poolinit(void)
{
pool_init(&in6pcb_pool, sizeof(struct in6pcb), 0, 0, 0, "in6pcbpl",
NULL, IPL_SOFTNET);
return 0;
}
void
v7fs_init(void)
{
DPRINTF("\n");
pool_init(&v7fs_node_pool, sizeof(struct v7fs_node), 0, 0, 0,
"v7fs_node_pool", &pool_allocator_nointr, IPL_NONE);
}
static int
inpcb_poolinit(void)
{
pool_init(&inpcb_pool, sizeof(struct inpcb), IN_CB_COUNT, 0, 0, "inpcbpl", NULL,
IPL_NET);
return 0;
}
void
amap_init(void)
{
/* Initialize the vm_amap pool. */
pool_init(&uvm_amap_pool, sizeof(struct vm_amap), 0, 0, PR_WAITOK,
"amappl", NULL);
pool_sethiwat(&uvm_amap_pool, 4096);
}
/*
* Initialize the mbuf allocator.
*/
void
mbinit(void)
{
pool_init(&mbpool, MSIZE, 0, 0, 0, "mbpl", NULL);
pool_init(&mclpool, MCLBYTES, 0, 0, 0, "mclpl", NULL);
nmbclust_update();
/*
* Set a low water mark for both mbufs and clusters. This should
* help ensure that they can be allocated in a memory starvation
* situation. This is important for e.g. diskless systems which
* must allocate mbufs in order for the pagedaemon to clean pages.
*/
pool_setlowat(&mbpool, mblowat);
pool_setlowat(&mclpool, mcllowat);
}
/**
* @brief Initialize the DRC package.
*/
void dupreq2_pkginit(void)
{
int code __attribute__ ((unused)) = 0;
dupreq_pool = pool_init("Duplicate Request Pool",
sizeof(dupreq_entry_t),
pool_basic_substrate, NULL, NULL, NULL);
if (unlikely(!(dupreq_pool)))
LogFatal(COMPONENT_INIT,
"Error while allocating duplicate request pool");
nfs_res_pool = pool_init("nfs_res_t pool", sizeof(nfs_res_t),
pool_basic_substrate,
NULL, NULL, NULL);
if (unlikely(!(nfs_res_pool)))
LogFatal(COMPONENT_INIT,
"Error while allocating nfs_res_t pool");
tcp_drc_pool = pool_init("TCP DRC Pool", sizeof(drc_t),
pool_basic_substrate,
NULL, NULL, NULL);
if (unlikely(!(tcp_drc_pool)))
LogFatal(COMPONENT_INIT,
"Error while allocating TCP DRC pool");
drc_st = gsh_calloc(1, sizeof(struct drc_st));
/* init shared statics */
gsh_mutex_init(&drc_st->mtx, NULL);
/* recycle_t */
code =
rbtx_init(&drc_st->tcp_drc_recycle_t, drc_recycle_cmpf,
nfs_param.core_param.drc.tcp.recycle_npart,
RBT_X_FLAG_ALLOC);
/* XXX error? */
/* init recycle_q */
TAILQ_INIT(&drc_st->tcp_drc_recycle_q);
drc_st->tcp_drc_recycle_qlen = 0;
drc_st->last_expire_check = time(NULL);
drc_st->expire_delta = nfs_param.core_param.drc.tcp.recycle_expire_s;
/* UDP DRC is global, shared */
init_shared_drc();
}
void
pfi_initialize(void)
{
int s;
int bound;
if (pfi_all != NULL) /* already initialized */
return;
#ifdef __NetBSD__
pool_init(&pfi_addr_pl, sizeof(struct pfi_dynaddr), 0, 0, 0,
"pfiaddrpl", &pool_allocator_nointr, IPL_NONE);
#else
pool_init(&pfi_addr_pl, sizeof(struct pfi_dynaddr), 0, 0, 0,
"pfiaddrpl", &pool_allocator_nointr);
#endif /* !__NetBSD__ */
pfi_buffer_max = 64;
pfi_buffer = malloc(pfi_buffer_max * sizeof(*pfi_buffer),
PFI_MTYPE, M_WAITOK);
if ((pfi_all = pfi_kif_get(IFG_ALL)) == NULL)
panic("pfi_kif_get for pfi_all failed");
#ifdef __NetBSD__
ifnet_t *ifp;
bound = curlwp_bind();
s = pserialize_read_enter();
IFNET_READER_FOREACH(ifp) {
struct psref psref;
psref_acquire(&psref, &ifp->if_psref, ifnet_psref_class);
pserialize_read_exit(s);
pfi_init_groups(ifp);
pfi_attach_ifnet(ifp);
s = pserialize_read_enter();
psref_release(&psref, &ifp->if_psref, ifnet_psref_class);
}
pserialize_read_exit(s);
curlwp_bindx(bound);
pfil_add_hook(pfil_ifnet_wrapper, NULL, PFIL_IFNET, if_pfil);
pfil_add_hook(pfil_ifaddr_wrapper, NULL, PFIL_IFADDR, if_pfil);
#endif /* __NetBSD__ */
}
void
adosfs_init(void)
{
malloc_type_attach(M_ANODE);
mutex_init(&adosfs_hashlock, MUTEX_DEFAULT, IPL_NONE);
pool_init(&adosfs_node_pool, sizeof(struct anode), 0, 0, 0, "adosndpl",
&pool_allocator_nointr, IPL_NONE);
}
