static int _ls_args(SList ** files, SList ** dirs)
{
if((*files = slist_new()) == NULL)
return _ls_error("slist", 1);
if((*dirs = slist_new()) == NULL)
{
slist_delete(*files);
return _ls_error("slist", 1);
}
return 0;
}
void
search_gui_init_tree(search_t *sch)
{
GtkListStore *model;
GtkTreeIter iter;
g_assert(sch);
g_assert(NULL == sch->parents);
sch->parents = htable_create_any(search_gui_file_hash, NULL,
search_gui_file_eq);
g_assert(NULL == sch->queue);
sch->queue = slist_new();
/* Add the search to the TreeView in pane on the left */
model = GTK_LIST_STORE(gtk_tree_view_get_model(tree_view_search));
gtk_list_store_append(model, &iter);
gtk_list_store_set(model, &iter,
c_sl_name, search_gui_query(sch),
c_sl_hit, 0,
c_sl_new, 0,
c_sl_sch, sch,
c_sl_fg, NULL,
c_sl_bg, NULL,
(-1));
}
/**
* Create new message queue capable of holding `maxsize' bytes, and
* owned by the supplied node.
*
* @param maxsize the overall sum of message size that can be held
* @param n the network node to which the message queue is attached
* @oaram nd the top of the TX stack to use to send out messages
* @param uops user-defined operations
*/
mqueue_t *
mq_udp_make(int maxsize,
gnutella_node_t *n, struct txdriver *nd, const struct mq_uops *uops)
{
mqueue_t *q;
node_check(n);
tx_check(nd);
g_assert(uops != NULL);
g_assert(maxsize > 0);
WALLOC0(q);
q->magic = MQ_MAGIC;
q->node = n;
q->tx_drv = nd;
q->maxsize = maxsize;
q->lowat = maxsize >> 2; /* 25% of max size */
q->hiwat = maxsize >> 1; /* 50% of max size */
q->qwait = slist_new();
q->ops = &mq_udp_ops;
q->cops = mq_get_cops();
q->uops = uops;
q->debug = GNET_PROPERTY_PTR(mq_udp_debug);
tx_srv_register(nd, mq_udp_service, q);
return q;
}
char *mod_get_params(module_t *mod)
{
char *buf = NULL, *buf2 = NULL;
slist_t *sl;
int err;
strprintf(&buf, "Enter parameters for \"%s\".", mod->name);
if(mod->param) {
strprintf(&buf, "%s\n\nExample: %s", buf, mod->param);
if(mod->autoload) str_copy(&buf2, mod->param);
}
sl = slist_getentry(config.module.input_params, mod->name);
if(sl && sl->value) str_copy(&buf2, sl->value);
err = dia_input2(buf, &buf2, 30, 0);
str_copy(&buf, NULL);
if(err) return NULL;
if(!sl) {
sl = slist_add(&config.module.input_params, slist_new());
sl->key = strdup(mod->name);
}
if(sl->value) free(sl->value);
sl->value = buf2;
return sl->value;
}
/**
* Initialize RX dumping.
*
* @return TRUE if initialized.
*/
static gboolean
dump_initialize(struct dump *dump)
{
char *pathname;
if (dump->initialized)
return TRUE;
pathname = make_pathname(settings_config_dir(), dump->filename);
dump->fd = file_open_missing(pathname, O_WRONLY | O_APPEND | O_NONBLOCK);
HFREE_NULL(pathname);
/*
* If the dump "file" is actually a named pipe, we'd block quickly
* if there was no reader. So set the file as non-blocking and
* we'll disable dumping as soon as we can't write all the data
* we want.
*/
if (dump->fd < 0) {
g_warning("can't open %s -- disabling dumping", dump->filename);
dump_disable(dump);
return FALSE;
}
fd_set_nonblocking(dump->fd);
dump->slist = slist_new();
dump->fill = 0;
dump->initialized = TRUE;
return TRUE;
}
/* all jobs must have successors except the end job, and all jobs must have predeccessors except the start job */
int check_dependencies(struct rcps_problem *p) {
int result = RCPS_CHECK_OK;
int end_count = 0;
int i, k;
struct rcps_job *start_job;
struct slist *visited;
struct slist *has_predecessor = slist_new(job_compare);
for (i = 0; i < p->job_count; ++i) {
struct rcps_job *j = p->jobs[ i ];
//printf("check_dependencies: job %s successors: %i\n", j->name, j->successor_count);
if (j->successor_count == 0) {
++end_count;
} else {
for (k = 0; k < j->successor_count; ++k) {
//printf("check_dependencies: job %s successor[%i] = %s\n", j->name, k, j->successors[k]->name);
slist_add(has_predecessor, slist_node_new(j->successors[k]));
}
}
}
if (end_count > 1) {
result += RCPS_CHECK_MULTIPLE_END_JOBS;
} else if (end_count == 0) {
result += RCPS_CHECK_END_JOB_MISSING;
}
if (result == RCPS_CHECK_OK) {
start_job = 0;
for (i = 0; i < p->job_count; ++i) {
if (!slist_find(has_predecessor, p->jobs[i])) {
start_job = p->jobs[i];
}
}
if (start_job) {
/* All other jobs should be successors of the start job */
//printf("check_dependencies: check circular\n");
visited = slist_new(job_compare);
result += check_circulardependencies(start_job, visited);
slist_free(visited, NULL);
} else {
result += RCPS_CHECK_START_JOB_MISSING;
}
}
slist_free(has_predecessor, NULL);
//printf("check_dependencies: result=%i\n", result);
return result;
}
/**
* Append line of text to given header field.
* A private copy of the data is made.
*/
static void
hfield_append(header_field_t *h, const char *text)
{
header_field_check(h);
if (!h->lines) {
h->lines = slist_new();
}
slist_append(h->lines, h_strdup(text));
}
/**
* Open stream as memory.
*
* Stream must be closed with ostream_close_memory() to get back the list
* of memory buffers.
*/
ostream_t *
ostream_open_memory(void)
{
ostream_t *os;
os = ostream_alloc(OSTREAM_T_MEM);
os->u.sl = slist_new();
return os;
}
int compute_thread_init(void)
{
int err;
sample_list = slist_new();
assert(sample_list);
assert(!thread_info.thread_id);
err = pthread_create(&thread_info.thread_id, NULL, run, NULL);
assert(!err);
pthread_setname_np(thread_info.thread_id, thread_info.thread_name);
err = sample_thread_init(sample_thread_event_handler);
assert(!err);
return 0;
}
/**
* Setup allocated LRU page cache.
*/
static int
setup_cache(struct lru_cache *cache, long pages, gboolean wdelay)
{
cache->arena = vmm_alloc(pages * DBM_PBLKSIZ);
if (NULL == cache->arena)
return -1;
cache->pagnum = g_hash_table_new(NULL, NULL);
cache->used = hash_list_new(NULL, NULL);
cache->available = slist_new();
cache->pages = pages;
cache->next = 0;
cache->write_deferred = wdelay;
cache->dirty = walloc(cache->pages);
cache->numpag = walloc(cache->pages * sizeof(long));
return 0;
}
/**
* Setup allocated LRU page cache.
*/
static int
setup_cache(struct lru_cache *cache, long pages, bool wdelay)
{
cache->arena = vmm_alloc(pages * DBM_PBLKSIZ);
if (NULL == cache->arena)
return -1;
cache->pagnum = htable_create(HASH_KEY_SELF, 0);
cache->used = hash_list_new(NULL, NULL);
cache->available = slist_new();
cache->pages = pages;
cache->next = 0;
cache->write_deferred = wdelay;
cache->dirty = walloc(cache->pages);
WALLOC_ARRAY(cache->numpag, cache->pages);
return 0;
}
int main(int argc, char *argv[])
{
struct slist *list;
list = slist_new();
assert(list);
assert(0 == slist_size(list));
assert(list == slist_idx(list, 0));
assert(NULL == slist_idx(list, -1));
assert(NULL == slist_idx(list, 1));
/* Build an array and set canary values */
struct slist *nodes1[NODECNT];
for (int i = 0; i < NODECNT; i++) {
nodes1[i] = malloc(sizeof(struct slist));
nodes1[i]->s = malloc(sizeof(struct sample));
nodes1[i]->s->rx_bytes = i;
}
/* Then add array elements to a list */
for (int i = 0; i < NODECNT; i++) {
slist_push(list, nodes1[i]);
assert(1 + i == slist_size(list));
}
/* check slist_size */
assert(NODECNT == slist_size(list));
/* check the list_idx function */
for (int i = 0; i < NODECNT; i++) {
struct slist *n = slist_idx(list, i);
assert(n);
assert(n->s->rx_bytes == i);
}
/* check slist_clear */
slist_clear(list);
assert(0 == slist_size(list));
}
struct rcps_population *new_population(struct rcps_solver *s,
struct rcps_problem *problem) {
struct rcps_population *pop;
struct rcps_individual *ind;
int i;
int lcount = 0;
struct rcps_fitness best_fitness;
best_fitness.group = FITNESS_MAX_GROUP;
best_fitness.weight = 0;
pop = (struct rcps_population*)malloc(sizeof(struct rcps_population));
pop->individuals = slist_new(individual_cmp);
pop->size = 0;
for (i = 0; i < s->pop_size; i++) {
ind = (struct rcps_individual*)malloc(sizeof(struct rcps_individual));
initial(problem, &ind->genome);
if (repair(problem, &ind->genome)) {
struct rcps_phenotype *pheno = decode(s, problem,
&ind->genome);
ind->fitness = fitness(problem, &ind->genome, pheno);
if (rcps_fitness_cmp(&(ind->fitness), &best_fitness) < 0) {
best_fitness = ind->fitness;
}
add_individual(ind, pop);
}
else {
// XXX somehow track this and abort with an error if we never add a
// valid individual
free(ind->genome.schedule);
free(ind->genome.modes);
free(ind->genome.alternatives);
free(ind);
i--;
}
if (s->progress_callback) {
if (i >= (lcount + s->cb_steps)) {
if (s->progress_callback(0, best_fitness, s->cb_arg)) {
return pop;
}
lcount = i;
}
}
}
return pop;
}
slist_t * slist_dup(slist_t const * l)
{
slist_t * new_l = slist_new(l->free, l->dup, l->cmp);
if (new_l == 0)
return 0;
if (l->head)
{
slist_node_t ** new_p = &new_l->head;
slist_node_t const * p = l->head;
while (p)
{
*new_p = slist_node_new(l->dup(p->elt), 0);
p = p->next;
new_p = &((*new_p)->next);
}
}
return new_l;
}
/**
* Create new message queue capable of holding `maxsize' bytes, and
* owned by the supplied node.
*/
mqueue_t *
mq_udp_make(int maxsize, struct gnutella_node *n, struct txdriver *nd)
{
mqueue_t *q;
WALLOC0(q);
q->magic = MQ_MAGIC;
q->node = n;
q->tx_drv = nd;
q->maxsize = maxsize;
q->lowat = maxsize >> 2; /* 25% of max size */
q->hiwat = maxsize >> 1; /* 50% of max size */
q->qwait = slist_new();
q->ops = &mq_udp_ops;
q->cops = mq_get_cops();
q->debug = GNET_PROPERTY_PTR(mq_udp_debug);
tx_srv_register(nd, mq_udp_service, q);
return q;
}
/**
* Append a new line of text at the end of the header.
* A private copy of the text is made.
*
* @return an error code, or HEAD_OK if appending was successful.
*/
int
header_append(header_t *o, const char *text, int len)
{
char buf[MAX_LINE_SIZE];
const char *p = text;
uchar c;
header_field_t *hf;
header_check(o);
g_assert(len >= 0);
if (o->flags & HEAD_F_EOH)
return HEAD_EOH_REACHED;
/*
* If empty line, we reached EOH.
*/
if (len == 0) {
o->flags |= HEAD_F_EOH; /* Mark we reached EOH */
return HEAD_EOH;
}
/*
* Sanity checks.
*/
if (o->size >= HEAD_MAX_SIZE)
return HEAD_TOO_LARGE;
if (++(o->num_lines) >= HEAD_MAX_LINES)
return HEAD_MANY_LINES;
/*
* Detect whether line is a new header or a continuation.
*/
c = *p;
if (is_ascii_space(c)) {
/*
* It's a continuation.
*
* Make sure we already have recorded something, or we have
* an unexpected continuation line.
*/
if (NULL == o->fields)
return HEAD_CONTINUATION; /* Unexpected continuation */
/*
* When a previous header line was malformed, we cannot accept
* further continuation lines.
*/
if (o->flags & HEAD_F_SKIP)
return HEAD_SKIPPED;
/*
* We strip leading spaces of all continuations before storing
* them. If we have to dump the header, we will have to put
* some spaces, but we don't guarantee we'll put the same amount.
*/
p++; /* First char is known space */
while ((c = *p)) {
if (!is_ascii_space(c))
break;
p++;
}
/*
* If we've reached the end of the line, then the continuation
* line was made of spaces only. Weird, but we can ignore it.
* Note that it's not an EOH mark.
*/
if (*p == '\0')
return HEAD_OK;
/*
* Save the continuation line by appending into the last header
* field we handled.
*/
hf = slist_tail(o->fields);
hfield_append(hf, p);
add_continuation(o, hf->name, p);
o->size += len - (p - text); /* Count only effective text */
/*
* Also append the data in the hash table.
*/
} else {
char *b;
bool seen_space = FALSE;
/*
* It's a new header line.
*/
o->flags &= ~HEAD_F_SKIP; /* Assume this line will be OK */
/*
* Parse header field. Must be composed of ascii chars only.
* (no control characters, no space, no ISO Latin or other extension).
* The field name ends with ':', after possible white spaces.
*/
for (b = buf, c = *p; c; c = *(++p)) {
if (c == ':') {
*b++ = '\0'; /* Reached end of field */
break; /* Done, buf[] holds field name */
}
if (is_ascii_space(c)) {
seen_space = TRUE; /* Only trailing spaces allowed */
continue;
}
if (
seen_space || (c != '-' && c != '.' &&
(!isascii(c) || is_ascii_cntrl(c) || is_ascii_punct(c)))
) {
o->flags |= HEAD_F_SKIP;
return HEAD_BAD_CHARS;
}
*b++ = c;
}
/*
* If buf[] does not end with a NUL, we did not fully recognize
* the header: we reached the end of the line without encountering
* the ':' marker.
*
* If the buffer starts with a NUL char, it's also clearly malformed.
*/
g_assert(b > buf || (b == buf && *text == '\0'));
if (b == buf || *(b-1) != '\0') {
o->flags |= HEAD_F_SKIP;
return HEAD_MALFORMED;
}
/*
* We have a valid header field in buf[].
*/
hf = hfield_make(buf);
/*
* Strip leading spaces in the value.
*/
g_assert(*p == ':');
p++; /* First char is field separator */
p = skip_ascii_spaces(p);
/*
* Record field value.
*/
hfield_append(hf, p);
add_header(o, buf, p);
if (!o->fields) {
o->fields = slist_new();
}
slist_append(o->fields, hf);
o->size += len - (p - text); /* Count only effective text */
}
return HEAD_OK;
}
int mod_insmod(char *module, char *param)
{
char buf[512];
int err, cnt;
char *force = config.forceinsmod ? "-f " : "";
slist_t *sl;
driver_t *drv;
if((sl = slist_getentry(config.module.options, module))) {
param = sl->value;
}
log_debug("mod_insmod(%s, %s)\n", module, param ?: "");
if(!module || config.test) return 0;
if(mod_is_loaded(module)) return 0;
if(!config.forceinsmod) {
if(!util_check_exist(module)) {
sprintf(buf, "%s/%s" MODULE_SUFFIX, config.module.dir, module);
if(!util_check_exist(buf)) return -1;
}
}
if(slist_getentry(config.module.broken, module)) {
log_info("%s tagged as broken, not loaded\n", module);
return -1;
}
sprintf(buf, "insmod %s%s/%s" MODULE_SUFFIX, force, config.module.dir, module);
if(param && *param) sprintf(buf + strlen(buf), " '%s'", param);
if(config.run_as_linuxrc) {
util_update_netdevice_list(NULL, 1);
util_update_disk_list(NULL, 1);
util_update_cdrom_list();
if(mod_show_kernel_messages) kbd_switch_tty(4);
}
err = lxrc_run(buf);
if(config.module.delay > 0) sleep(config.module.delay);
cnt = 0;
if(!err) {
for(drv = config.module.drivers; drv; drv = drv->next) {
if(drv->name && !strcmp(drv->name, module)) {
cnt += apply_driverid(drv);
}
}
}
else {
log_info("insmod error: %d\n", err);
}
if(cnt) sleep(config.module.delay + 1);
if(config.run_as_linuxrc) {
scsi_rename();
if(!err && param) {
while(isspace(*param)) param++;
if(*param) {
sl = slist_add(&config.module.used_params, slist_new());
sl->key = strdup(module);
sl->value = strdup(param);
}
}
if(mod_show_kernel_messages) kbd_switch_tty(1);
util_update_kernellog();
if(!err) {
util_update_netdevice_list(module, 1);
util_update_disk_list(module, 1);
util_update_cdrom_list();
}
}
return err;
}
void test_slist( void )
{
unsigned int
loop,
cpu_count;
thread_state_t
*thread_handles;
struct slist_thread_start_state
stss;
/* TRD : 1. one head writer per CPU
2. make one element, then one after writer per CPU
3. make a list, then one list traverser per CPU
4. one head writer and one list traverser per CPU
5. make one element, then one after writer and one list traverser per CPU
6. make a list, then one 100% deleter-traverser per CPU
7. make a list, then one 25% deleter-traverser per CPU
8. one head writer and one 100% deleter-traverse per CPU
9. one head writer and one 25% deleter-traverse per CPU
10. make one element, then one after writer and one 100% deleter-traverser per CPU
11. make one element, then one after writer and one 25% deleter-traverser per CPU
12. one head writer, one after writer, one traverser and one 25% deleter-traverser per CPU
*/
cpu_count = abstraction_cpu_count();
printf( "\n"
"SList Test\n"
"==========\n" );
// TRD : 1. one head writer per CPU
printf( "\n"
"1. one head writer per CPU\n"
"==========================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 1;
stss.se = NULL;
stss.duration = 1;
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 1 );
for( loop = 0 ; loop < cpu_count ; loop++ )
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_head_writer, &stss );
for( loop = 0 ; loop < cpu_count ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
// TRD : 2. make one element, then one after writer per CPU
printf( "\n"
"2. make one element, then one after writer per CPU\n"
"==================================================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 1;
stss.se = slist_new_head( stss.ss, (void *) NULL );
stss.duration = 1;
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 1 );
for( loop = 0 ; loop < cpu_count ; loop++ )
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_after_writer, &stss );
for( loop = 0 ; loop < cpu_count ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
// TRD : 3. make a list, then one list traverser per CPU
printf( "\n"
"3. make a list, then one list traverser per CPU\n"
"===============================================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 1;
stss.se = NULL;
stss.duration = 10;
// TRD : small list so we get collisions
for( loop = 0 ; loop < 10 ; loop++ )
slist_new_head( stss.ss, (void *) 0 );
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 1 );
for( loop = 0 ; loop < cpu_count ; loop++ )
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_traverser, &stss );
for( loop = 0 ; loop < cpu_count ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
// TRD : 4. one head writer and one list traverser per CPU
printf( "\n"
"4. one head writer and one list traverser per CPU\n"
"=================================================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 1;
stss.se = NULL;
stss.duration = 1;
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 2 );
for( loop = 0 ; loop < cpu_count ; loop++ )\
{
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_head_writer, &stss );
abstraction_thread_start( &thread_handles[loop+cpu_count], loop, slist_internal_thread_traverser, &stss );
}
for( loop = 0 ; loop < cpu_count * 2 ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
// TRD : 5. make one element, then one after writer and one list traverser per CPU
printf( "\n"
"5. make one element, then one after writer and one list traverser per CPU\n"
"=========================================================================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 1;
stss.se = slist_new_head( stss.ss, (void *) NULL );
stss.duration = 1;
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 2 );
for( loop = 0 ; loop < cpu_count ; loop++ )\
{
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_after_writer, &stss );
abstraction_thread_start( &thread_handles[loop+cpu_count], loop, slist_internal_thread_traverser, &stss );
}
for( loop = 0 ; loop < cpu_count * 2 ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
// TRD : 6. make a list, then one 100% deleter-traverser per CPU
printf( "\n"
"6. make a list, then one 100%% deleter-traverser per CPU\n"
"=======================================================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 1;
stss.se = NULL;
stss.duration = 1;
for( loop = 0 ; loop < 10000 ; loop++ )
slist_new_head( stss.ss, (void *) 0 );
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 1 );
for( loop = 0 ; loop < cpu_count ; loop++ )
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_deleter_traverser, &stss );
for( loop = 0 ; loop < cpu_count ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
// TRD : 7. make a list, then one 25% deleter-traverser per CPU
printf( "\n"
"7. make a list, then one 25%% deleter-traverser per CPU\n"
"======================================================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 4;
stss.se = NULL;
stss.duration = 1;
for( loop = 0 ; loop < 10000 ; loop++ )
slist_new_head( stss.ss, (void *) 0 );
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 1 );
for( loop = 0 ; loop < cpu_count ; loop++ )
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_deleter_traverser, &stss );
for( loop = 0 ; loop < cpu_count ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
// TRD : 8. one head writer and one 100% deleter-traverse per CPU
printf( "\n"
"8. one head writer and one 100%% deleter-traverse per CPU\n"
"========================================================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 1;
stss.se = NULL;
stss.duration = 10;
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 2 );
for( loop = 0 ; loop < cpu_count ; loop++ )
{
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_head_writer, &stss );
abstraction_thread_start( &thread_handles[loop+cpu_count], loop, slist_internal_thread_deleter_traverser, &stss );
}
for( loop = 0 ; loop < cpu_count * 2 ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
// TRD : 9. one head writer and one 25% deleter-traverse per CPU
printf( "\n"
"9. one head writer and one 25%% deleter-traverse per CPU\n"
"=======================================================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 4;
stss.se = NULL;
stss.duration = 1;
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 2 );
for( loop = 0 ; loop < cpu_count ; loop++ )
{
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_head_writer, &stss );
abstraction_thread_start( &thread_handles[loop+cpu_count], loop, slist_internal_thread_deleter_traverser, &stss );
}
for( loop = 0 ; loop < cpu_count * 2 ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
// TRD : 10. make one element, then one after writer and one 100% deleter-traverser per CPU
printf( "\n"
"10. make one element, then one after writer and one 100%% deleter-traverser per CPU\n"
"==================================================================================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 1;
stss.se = slist_new_head( stss.ss, (void *) NULL );
stss.duration = 10;
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 2 );
for( loop = 0 ; loop < cpu_count ; loop++ )
{
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_after_writer, &stss );
abstraction_thread_start( &thread_handles[loop+cpu_count], loop, slist_internal_thread_deleter_traverser, &stss );
}
for( loop = 0 ; loop < cpu_count * 2 ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
// TRD : 11. make one element, then one after writer and one 25% deleter-traverser per CPU
printf( "\n"
"11. make one element, then one after writer and one 25%% deleter-traverser per CPU\n"
"=================================================================================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 4;
stss.se = slist_new_head( stss.ss, (void *) NULL );
stss.duration = 1;
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 2 );
for( loop = 0 ; loop < cpu_count ; loop++ )
{
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_after_writer, &stss );
abstraction_thread_start( &thread_handles[loop+cpu_count], loop, slist_internal_thread_deleter_traverser, &stss );
}
for( loop = 0 ; loop < cpu_count * 2 ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
// TRD : 12. one head writer, one after writer, one traverser and one 25% deleter-traverser per CPU
printf( "\n"
"12. one head writer, one after writer, one traverser and one 25%% deleter-traverser per CPU\n"
"==========================================================================================\n" );
slist_new( &stss.ss, NULL, NULL );
stss.iteration_modulo = 4;
stss.se = slist_new_head( stss.ss, (void *) NULL );
stss.duration = 1;
thread_handles = (thread_state_t *) malloc( sizeof(thread_state_t) * cpu_count * 4 );
for( loop = 0 ; loop < cpu_count ; loop++ )
{
abstraction_thread_start( &thread_handles[loop], loop, slist_internal_thread_head_writer, &stss );
abstraction_thread_start( &thread_handles[loop+cpu_count], loop, slist_internal_thread_after_writer, &stss );
abstraction_thread_start( &thread_handles[loop+cpu_count*2], loop, slist_internal_thread_traverser, &stss );
abstraction_thread_start( &thread_handles[loop+cpu_count*3], loop, slist_internal_thread_deleter_traverser, &stss );
}
for( loop = 0 ; loop < cpu_count * 4 ; loop++ )
abstraction_thread_wait( thread_handles[loop] );
slist_delete( stss.ss );
free( thread_handles );
return;
}
#include "helpers.h"
TEST(append_sets_both_head_and_tail) {
USING(slist_new(sizeof(int))) {
assertEquals(slist_length(list), 0);
assertEquals(slist_size(list), sizeof(int));
assertEquals(list->head, NULL);
assertEquals(list->tail, NULL);
assertNotEquals(slist_append(list, NULL), NULL);
assertEquals(slist_length(list), 1);
assertEquals(slist_size(list), sizeof(int));
assertNotEquals(list->head, NULL);
assertNotEquals(list->tail, NULL);
assertEquals(list->head, list->tail);
assertNotEquals(slist_append(list, NULL), NULL);
assertEquals(slist_length(list), 2);
assertEquals(slist_size(list), sizeof(int));
assertNotEquals(list->head, NULL);
assertNotEquals(list->tail, NULL);
assertNotEquals(list->head, list->tail);
assertEquals(list->head->next, list->tail);
assertNotEquals(slist_append(list, NULL), NULL);
assertEquals(slist_length(list), 3);
assertEquals(slist_size(list), sizeof(int));
assertNotEquals(list->head, NULL);
