Exemplo n.º 1
0
struct evg_compute_unit_t *evg_compute_unit_create()
{
	struct evg_compute_unit_t *compute_unit;
	char buf[MAX_STRING_SIZE];

	/* Initialize */
	compute_unit = xcalloc(1, sizeof(struct evg_compute_unit_t));
	compute_unit->wavefront_pool = linked_list_create();

	/* Local memory */
	snprintf(buf, sizeof buf, "LocalMemory[%d]", compute_unit->id);
	compute_unit->local_memory = mod_create(buf, mod_kind_local_memory,
		evg_gpu_local_mem_num_ports, evg_gpu_local_mem_block_size, evg_gpu_local_mem_latency);

	/* Initialize CF Engine */
	compute_unit->cf_engine.complete_queue = linked_list_create();
	compute_unit->cf_engine.fetch_buffer = xcalloc(evg_gpu_max_wavefronts_per_compute_unit, sizeof(void *));
	compute_unit->cf_engine.inst_buffer = xcalloc(evg_gpu_max_wavefronts_per_compute_unit, sizeof(void *));

	/* Initialize ALU Engine */
	compute_unit->alu_engine.pending_queue = linked_list_create();
	compute_unit->alu_engine.finished_queue = linked_list_create();
	compute_unit->alu_engine.fetch_queue = linked_list_create();
	compute_unit->alu_engine.event_queue = heap_create(10);

	/* Initialize TEX Engine */
	compute_unit->tex_engine.pending_queue = linked_list_create();
	compute_unit->tex_engine.finished_queue = linked_list_create();
	compute_unit->tex_engine.fetch_queue = linked_list_create();
	compute_unit->tex_engine.load_queue = linked_list_create();

	/* Return */
	compute_unit->work_groups = xcalloc(evg_gpu_max_work_groups_per_compute_unit, sizeof(void *));
	return compute_unit;
}
Exemplo n.º 2
0
struct x86_loader_t *x86_loader_create(void)
{
	struct x86_loader_t *loader;

	/* Initialize */
	loader = xcalloc(1, sizeof(struct x86_loader_t));
	loader->args = linked_list_create();
	loader->env = linked_list_create();

	/* Return */
	return loader;
}
Exemplo n.º 3
0
Arquivo: emu.c Projeto: ajithcj/miaow
void frm_emu_init(void)
{
	/* Register architecture */
	frm_emu_arch = arch_list_register("Fermi", "frm");
	frm_emu_arch->sim_kind = frm_emu_sim_kind;

        /* Allocate */
        frm_emu = xcalloc(1, sizeof(struct frm_emu_t));
        if (!frm_emu)
                fatal("%s: out of memory", __FUNCTION__);

        /* Initialize */
        frm_emu->const_mem = mem_create();
        frm_emu->const_mem->safe = 0;
        frm_emu->global_mem = mem_create();
        frm_emu->global_mem->safe = 0;
        frm_emu->total_global_mem_size = 1 << 31; /* 2GB */
        frm_emu->free_global_mem_size = frm_emu->total_global_mem_size;
        frm_emu->global_mem_top = 0;

	frm_disasm_init();
	frm_isa_init();

        /* Create device */
        frm_cuda_object_list = linked_list_create();
        frm_cuda_device_create();
}
Exemplo n.º 4
0
void EvgGpuCreate(EvgGpu *self)
{
	struct evg_compute_unit_t *compute_unit;
	int compute_unit_id;

	/* Parent */
	TimingCreate(asTiming(self));

	/* Frequency */
	asTiming(self)->frequency = evg_gpu_frequency;
	asTiming(self)->frequency_domain = esim_new_domain(evg_gpu_frequency);

	/* Initialize */
	self->trash_uop_list = linked_list_create();
	self->compute_units = xcalloc(evg_gpu_num_compute_units, sizeof(void *));
	EVG_GPU_FOREACH_COMPUTE_UNIT(compute_unit_id)
	{
		self->compute_units[compute_unit_id] = evg_compute_unit_create();
		compute_unit = self->compute_units[compute_unit_id];
		compute_unit->id = compute_unit_id;
		DOUBLE_LINKED_LIST_INSERT_TAIL(self, ready, compute_unit);
	}

	/* Virtual functions */
	asObject(self)->Dump = EvgGpuDump;
	asTiming(self)->DumpSummary = EvgGpuDumpSummary;
	asTiming(self)->Run = EvgGpuRun;
	asTiming(self)->MemConfigCheck = EvgGpuMemConfigCheck;
	asTiming(self)->MemConfigDefault = EvgGpuMemConfigDefault;
	asTiming(self)->MemConfigParseEntry = EvgGpuMemConfigParseEntry;
}
Exemplo n.º 5
0
/**
 * see section 3.8.3 of TCG TNC IF-IMC Specification 1.3
 */
TNC_Result TNC_IMC_BeginHandshake(TNC_IMCID imc_id,
								  TNC_ConnectionID connection_id)
{
	TNC_Result result = TNC_RESULT_SUCCESS;

	if (!imc_android)
	{
		DBG1(DBG_IMC, "IMC \"%s\" has not been initialized", imc_name);
		return TNC_RESULT_NOT_INITIALIZED;
	}

	if (lib->settings->get_bool(lib->settings,
								"android.imc.send_os_info", TRUE))
	{
		linked_list_t *attr_list;

		attr_list = linked_list_create();
		add_product_info(attr_list);
		add_string_version(attr_list);
		result = imc_android->send_message(imc_android, connection_id, FALSE, 0,
									  TNC_IMVID_ANY, attr_list);
		attr_list->destroy(attr_list);
	}

	return result;
}
Exemplo n.º 6
0
END_TEST

START_TEST(test_nested_reset)
{
	linked_list_t *list, *l1, *l2, *l3;
	enumerator_t *outer, *enumerator;
	intptr_t x;
	int count = 0;

	l1 = linked_list_create_with_items((void*)1, (void*)2, NULL);
	l2 = linked_list_create();
	l3 = linked_list_create_with_items((void*)3, (void*)4, (void*)5, NULL);
	list = linked_list_create_with_items(l1, l2, l3, NULL);

	outer = list->create_enumerator(list);
	enumerator = enumerator_create_nested(outer, (void*)create_inner,
										 (void*)101, destroy_data);
	while (enumerator->enumerate(enumerator, &x))
	{
		count++;
	}
	ck_assert_int_eq(count, 5);

	list->reset_enumerator(list, outer);
	ck_assert(enumerator->enumerate(enumerator, &x));
	ck_assert_int_eq(x, 1);
	enumerator->destroy(enumerator);

	list->destroy(list);
	l1->destroy(l1);
	l2->destroy(l2);
	l3->destroy(l3);
}
Exemplo n.º 7
0
static void si_gpu_device_init()
{
    struct si_compute_unit_t *compute_unit;
    int compute_unit_id;

    /* Create device */
    si_gpu = calloc(1, sizeof(struct si_gpu_t));
    if (!si_gpu)
        fatal("%s: out of memory", __FUNCTION__);

    /* Initialize */
    si_gpu->trash_uop_list = linked_list_create();

    /* Create compute units */
    si_gpu->compute_units = calloc(si_gpu_num_compute_units, sizeof(void *));
    if (!si_gpu->compute_units)
        fatal("%s: out of memory", __FUNCTION__);

    /* Initialize compute units */
    SI_GPU_FOREACH_COMPUTE_UNIT(compute_unit_id)
    {
        si_gpu->compute_units[compute_unit_id] = si_compute_unit_create();
        compute_unit = si_gpu->compute_units[compute_unit_id];
        compute_unit->id = compute_unit_id;
        DOUBLE_LINKED_LIST_INSERT_TAIL(si_gpu, compute_unit_ready, compute_unit);
    }

    /* Trace */
    si_trace_header("si.init version=\"%d.%d\" num_compute_units=%d\n",
                    SI_TRACE_VERSION_MAJOR, SI_TRACE_VERSION_MINOR,
                    si_gpu_num_compute_units);
}
Exemplo n.º 8
0
/* Initialize GPU kernel */
void gk_init()
{
    /* Open report file */
    if (gpu_kernel_report_file_name[0]) {
        gpu_kernel_report_file = open_write(gpu_kernel_report_file_name);
        if (!gpu_kernel_report_file)
            fatal("%s: cannot open GPU report file ", gpu_kernel_report_file_name);
    }

    /* Initialize kernel */
    gk = calloc(1, sizeof(struct gk_t));
    gk->const_mem = mem_create();
    gk->const_mem->safe = 0;
    gk->global_mem = mem_create();
    gk->global_mem->safe = 0;

    /* Initialize disassembler (decoding tables...) */
    amd_disasm_init();

    /* Initialize ISA (instruction execution tables...) */
    gpu_isa_init();

    /* Create platform and device */
    opencl_object_list = linked_list_create();
    opencl_platform = opencl_platform_create();
    opencl_device_create();
}
Exemplo n.º 9
0
int test_list_int() {
  linked_list_t *list;
  linked_list_cursor_t *cursor;
  int i, data;

  // create a new list
  list = linked_list_create(
	   NULL,		 /* original list		*/
	   linked_list_int_cmp,	 /* default int comparator	*/
	   LINKED_LIST_SORTED	 /* sort list			*/
	 );

  // add 10 entries
  for (i = 0; i < 10; i++) {
    linked_list_append(list, (void *)i, (void *)i);
  } 

  // create a cursor for cycling/searching
  cursor = linked_list_cursor_create(NULL, list);

  // walk trough listh
  for (LINKED_LIST_FORLOOP(cursor, &data)) {
    printf("%d\n", data);
  }

}
Exemplo n.º 10
0
PUBLIC void ui_init(unsigned short screenWidth, unsigned short screenHeight,
							unsigned short canvasWidth, unsigned short canvasHeight) {
	ui.linked_view = linked_list_create(NULL);
	ui.viewWidth = canvasWidth;
	ui.viewHeight = canvasHeight;
	ui.sys = NULL;
	xRaito = ((float)canvasWidth / screenWidth);
	yRaito = ((float)canvasHeight / screenHeight);
	return;
}
Exemplo n.º 11
0
struct linked_list_t *opengl_vertex_array_obj_repo_create()
{
	struct linked_list_t *lst;

	/* Allocate */
	lst = linked_list_create();

	opengl_debug("\tCreated VAO repository [%p]\n", lst);

	/* Return */	
	return lst;
}
int main (int argc, char ** argv) {
	if (argc != 2) {
		fprintf (stderr, "usage: %s <N>\n", argv[0]);
		return 1;
	}

	int N = atoi (argv[1]);

	if (N < 1)
		return 1;

	int count = 0;

	for (int i = 1; i <= N; i++) {
		cf_sqrt_step_t frac;

		frac.num = i;
		frac.step = 0;

		linked_list_t * fractions = linked_list_create ();

		// All quadratic irrationals must eventually reach a cycle
		while (cf_expand_sqrt_continued_fraction (&frac)) {
			cf_sqrt_step_t * f = NULL;

			bool cycle_found = false;

			while ((f = linked_list_next (fractions, cf_sqrt_step_t)) != NULL)
				if (cf_sqrt_steps_identical (f, &frac)) {
					cycle_found = true;

					int cycle_len = frac.step - f->step;

					if (cycle_len % 2 == 1)
						count++;

					linked_list_stop_iteration (fractions);
					break;
				}

			if (!cycle_found)
				linked_list_add_copy (fractions, &frac, cf_sqrt_step_t);
			else
				break;
		}

		linked_list_free (fractions);
	}

	printf ("%d\n", count);

	return 0;
}
Exemplo n.º 13
0
struct arch_t *arch_create(char *name, char *prefix) {
  struct arch_t *arch;

  /* Initialize */
  arch = xcalloc(1, sizeof(struct arch_t));
  arch->name = xstrdup(name);
  arch->prefix = xstrdup(prefix);
  arch->mem_entry_mod_list = linked_list_create();

  /* Return */
  return arch;
}
Exemplo n.º 14
0
void X86CpuCreate(X86Cpu *self, X86Emu *emu) {
  X86Core *core;
  X86Thread *thread;

  char name[MAX_STRING_SIZE];

  int i;
  int j;

  /* Parent */
  TimingCreate(asTiming(self));

  /* Frequency */
  asTiming(self)->frequency = x86_cpu_frequency;
  asTiming(self)->frequency_domain = esim_new_domain(x86_cpu_frequency);

  /* Initialize */
  self->emu = emu;
  self->uop_trace_list = linked_list_create();

  /* Create cores */
  self->cores = xcalloc(x86_cpu_num_cores, sizeof(X86Core *));
  for (i = 0; i < x86_cpu_num_cores; i++) self->cores[i] = new (X86Core, self);

  /* Assign names and IDs to cores and threads */
  for (i = 0; i < x86_cpu_num_cores; i++) {
    core = self->cores[i];
    snprintf(name, sizeof name, "c%d", i);
    X86CoreSetName(core, name);
    core->id = i;
    for (j = 0; j < x86_cpu_num_threads; j++) {
      thread = core->threads[j];
      snprintf(name, sizeof name, "c%dt%d", i, j);
      X86ThreadSetName(thread, name);
      thread->id_in_core = j;
      thread->id_in_cpu = i * x86_cpu_num_threads + j;
    }
  }

  /* Virtual functions */
  asObject(self)->Dump = X86CpuDump;
  asTiming(self)->DumpSummary = X86CpuDumpSummary;
  asTiming(self)->Run = X86CpuRun;
  asTiming(self)->MemConfigCheck = X86CpuMemConfigCheck;
  asTiming(self)->MemConfigDefault = X86CpuMemConfigDefault;
  asTiming(self)->MemConfigParseEntry = X86CpuMemConfigParseEntry;

  /* Trace */
  x86_trace_header("x86.init version=\"%d.%d\" num_cores=%d num_threads=%d\n",
                   X86_TRACE_VERSION_MAJOR, X86_TRACE_VERSION_MINOR,
                   x86_cpu_num_cores, x86_cpu_num_threads);
}
Exemplo n.º 15
0
int test_list_char() {
  linked_list_t *list;
  linked_list_cursor_t *cursor;
  int i;
  char *data;

  // create a new list
  list = linked_list_create(
           NULL,                 /* original list               */
           linked_list_char_cmp, /* default char comparator     */
           LINKED_LIST_SORTED    /* sort list                   */
         );

  // add 5 entries
  for (i = 0; i < 5; i++) {
    data = (char *)malloc(10);
    sprintf(data, "item %i", i);
    linked_list_append(list, (void *)data, (void *)data);
  }

  // create a cursor for cycling/searching
  cursor = linked_list_cursor_create(NULL, list);

  // walk trough listh
  for (LINKED_LIST_FORLOOP(cursor, &data))
    printf("%s\n", data);
  
  // scroll to item 4
  printf("finding 'item 4'\n");
  if (linked_list_cursor_find(cursor, "item 4") != 1) {
    printf("didn't find item item 4\n");
    return;
  }
  
  printf("replacing item 'item 4' with 'item 4 (new)'\n");

  // replace it
  linked_list_cursor_replace(cursor, "item 4", "item 4 (new)");
  printf("done\n");

  // show it again
  for (LINKED_LIST_FORLOOP(cursor, &data))
    printf("%s\n", data);

  printf("deleting 'item 2'\n");
  linked_list_cursor_find(cursor, "item 2");
  linked_list_cursor_delete(cursor); 

  // and again
  for (LINKED_LIST_FORLOOP(cursor, &data)) 
    printf("%s\n", data);
}
Exemplo n.º 16
0
struct si_work_item_t *si_work_item_create()
{
	struct si_work_item_t *work_item;

	/* Initialize */
	work_item = xcalloc(1, sizeof(struct si_work_item_t));
	work_item->write_task_list = linked_list_create();
	work_item->lds_oqa = list_create();
	work_item->lds_oqb = list_create();

	/* Return */
	return work_item;
}
Exemplo n.º 17
0
/* Create a command queue */
struct evg_opencl_command_queue_t *evg_opencl_command_queue_create()
{
	struct evg_opencl_command_queue_t *command_queue;

	/* Initialize */
	command_queue = xcalloc(1, sizeof(struct evg_opencl_command_queue_t));
	command_queue->id = evg_opencl_repo_new_object_id(evg_emu->opencl_repo,
		evg_opencl_object_command_queue);
	command_queue->ref_count = 1;
	command_queue->command_list = linked_list_create();

	/* Return */
	evg_opencl_repo_add_object(evg_emu->opencl_repo, command_queue);
	return command_queue;
}
Exemplo n.º 18
0
static void* testing(void *thread)
{
	int i;
	host_t *addr[ALLOCS];
	identification_t *id[ALLOCS];
	linked_list_t *pools;

	/* prepare identities */
	for (i = 0; i < ALLOCS; i++)
	{
		char buf[256];

		snprintf(buf, sizeof(buf), "*****@*****.**", (uintptr_t)thread, i);
		id[i] = identification_create_from_string(buf);
	}

	pools = linked_list_create();
	pools->insert_last(pools, "test");

	/* allocate addresses */
	for (i = 0; i < ALLOCS; i++)
	{
		addr[i] = hydra->attributes->acquire_address(hydra->attributes,
													 pools, id[i], NULL);
		if (!addr[i])
		{
			pools->destroy(pools);
			return (void*)FALSE;
		}
	}

	/* release addresses */
	for (i = 0; i < ALLOCS; i++)
	{
		hydra->attributes->release_address(hydra->attributes,
										   pools, addr[i], id[i]);
	}

	pools->destroy(pools);

	/* cleanup */
	for (i = 0; i < ALLOCS; i++)
	{
		addr[i]->destroy(addr[i]);
		id[i]->destroy(id[i]);
	}
	return (void*)TRUE;
}
Exemplo n.º 19
0
int main()
{
  linked_list_cell *pos;
  linked_list *lista;
  char *ptr = NULL;
  char *hauki = "hauki!!!";
  register unsigned int beta = 0;

  lista = linked_list_create();

  linked_list_add_data(lista, hauki);
  linked_list_add_data(lista, "kissa");
  linked_list_add_data(lista, "haukka");


  // An example shuffling through the values of the list
  while((pos = linked_list_cycle(lista, pos)) != NULL)
  {
    printf("%d. %s\n", beta, pos->Data);
    beta++;
  }

  // get "precise" data
  printf("yksitellen: %s\n", (char *) linked_list_get_pos(lista, 0));
  printf("yksitellen: %s\n", (char *) linked_list_get_pos(lista, 2));
  printf("yksitellen: %s\n", (char *) linked_list_get_pos(lista, 1));

  linked_list_delete_data(lista, hauki);
  linked_list_add_data(lista, hauki);

  linked_list_add_pos(lista, "lehmä",2);

  beta = 0;
  while(1)
  {
    ptr = linked_list_cycle(lista, ptr);

    if(ptr == NULL)
      break;

    printf("%d. %s\n", beta, ptr);
    beta++;
  }

  linked_list_delete(lista);

  return 0;
}
Exemplo n.º 20
0
void sim_node_define_context(int count, ...){
  va_list context_vars;
  va_start(context_vars, count);

  while(count--){

    uint8_t *context_var;
    context_var = va_arg(context_vars, uint8_t *);

    if(sim_node_context_vars_g == NULL)
      sim_node_context_vars_g = linked_list_create(context_var);
    else
      sim_node_context_vars_g = linked_list_add(sim_node_context_vars_g, context_var);
  }
  va_end(context_vars);
}
Exemplo n.º 21
0
void GlutDriverCreate(GlutDriver *self, X86Emu *emu)
{
	/* Parent */
	DriverCreate(asDriver(self), emu);

	/* Assign driver to host emulator */
	emu->glut_driver = self;

	/* Initialize GLUT global mutex */
	pthread_mutex_init(&glut_mutex, NULL);

	/* Frame buffer */
	glut_frame_buffer_init();

	/* List of events */
	glut_event_list = linked_list_create();
}
Exemplo n.º 22
0
event_list_t * event_check(event_t * event, SYSTEMTIME * ntime, SYSTEMTIME * otime)
{
	linked_list_node_t * node = linked_list_first(event->all_event);

	linked_list_free(event->el.list);
	linked_list_create(&event->el.list);

	for(node; node; node = linked_list_next(node))
	{
		struct event_em_t * em = (struct event_em_t *)linked_list_data(node);
		
		if(event_em_compare(em, ntime, otime))
			linked_list_insert(event->el.list, 0, em);
	}

	return &event->el;
}
Exemplo n.º 23
0
/**
 * Get a TCP or UDP port list from strongswan.conf
 */
static linked_list_t* get_port_list(char *label)
{
    char key[40], *value;
    linked_list_t *list;
    chunk_t port_list, port_item, port_start;
    port_range_t *port_range;

    list = linked_list_create();

    snprintf(key, sizeof(key), "libimcv.plugins.imv-scanner.%s_ports", label);
    value = lib->settings->get_str(lib->settings, key, NULL);
    if (!value)
    {
        DBG1(DBG_IMV, "%s not defined", key);
        return list;
    }
    port_list = chunk_create(value, strlen(value));
    DBG2(DBG_IMV, "list of %s ports that %s:", label,
         closed_port_policy ? "are allowed to be open" : "must be closed");

    while (eat_whitespace(&port_list))
    {
        if (!extract_token(&port_item, ' ', &port_list))
        {
            /* reached last port item */
            port_item = port_list;
            port_list = chunk_empty;
        }
        port_range = malloc_thing(port_range_t);
        port_range->start = atoi(port_item.ptr);

        if (extract_token(&port_start, '-', &port_item) && port_item.len)
        {
            port_range->stop = atoi(port_item.ptr);
        }
        else
        {
            port_range->stop = port_range->start;
        }
        DBG2(DBG_IMV, "%5u - %5u", port_range->start, port_range->stop);
        list->insert_last(list, port_range);
    }

    return list;
}
Exemplo n.º 24
0
linked_list_t *sim_nodes_alloc(int count){

  linked_list_t *sim_nodes = NULL;
  sim_node_t *sim_node = NULL;

  while(count--){
    if(!(sim_node = malloc(sizeof(sim_node_t)))){
      puts("unable to allocate memory for sim_node_t");
      exit(1);
    }

    // TODO
    // node could be abstracted by building
    // a node_init function
    // (having nodes with different hardware...)

    // brightness fifo
    fifo_init(&sim_node->node.brightness_buffer);

    // data fifos
    fifo_init(&sim_node->node.data_rx_buffer);
    fifo_init(&sim_node->node.data_tx_buffer);

    // address
    sim_node->node.address = count;
    sim_node->node.address_max = PIXEL_COUNT;

    // animation register

    // sim node context...
    sim_node->node_context = sim_node_alloc_context();

    // run node setup
    sim_node_load_context(sim_node->node_context);
    node_setup(&sim_node->node);
    sim_node_save_context(sim_node->node_context);

    if(sim_nodes == NULL)
      sim_nodes = linked_list_create(sim_node);
    else
      sim_nodes = linked_list_add(sim_nodes, sim_node);
  }
  return sim_nodes;
}
Exemplo n.º 25
0
void esim_init()
{
	/* Create structures */
	esim_event_info_list = list_create();
	esim_event_heap = heap_create(20);
	esim_end_event_list = linked_list_create();
	
	/* List of frequency domains */
	esim_domain_list = list_create();
	list_add(esim_domain_list, NULL);

	/* Initialize global timer */
	esim_timer = m2s_timer_create(NULL);
	m2s_timer_start(esim_timer);

	/* Register special events */
	ESIM_EV_INVALID = esim_register_event_with_name(NULL, 0, "Invalid");
	ESIM_EV_NONE = esim_register_event_with_name(NULL, 0, "None");
}
Exemplo n.º 26
0
/* Create a command queue */
struct evg_opencl_command_queue_t *evg_opencl_command_queue_create()
{
	struct evg_opencl_command_queue_t *command_queue;

	/* Allocate */
	command_queue = calloc(1, sizeof(struct evg_opencl_command_queue_t));
	if (!command_queue)
		fatal("%s: out of memory", __FUNCTION__);

	/* Initialize */
	command_queue->id = evg_opencl_repo_new_object_id(evg_emu->opencl_repo,
		evg_opencl_object_command_queue);
	command_queue->ref_count = 1;
	command_queue->command_list = linked_list_create();

	/* Return */
	evg_opencl_repo_add_object(evg_emu->opencl_repo, command_queue);
	return command_queue;
}
Exemplo n.º 27
0
int main (int argc, char ** argv) {
	if (argc != 2) {
		fprintf (stderr, "usage: %s <N>\n", argv[0]);
		return 1;
	}

	int N = atoi (argv[1]);

	bool * sieve = eratosthenes_sieve (PRIMES_PRODUCT_LIMIT);

	size_t primes_count = count_primes (sieve, N);

	if (primes_count == 0) {
		printf ("0\n");
		return 0;
	}

	int primes[primes_count];
	int powers[primes_count];

	fill_factor_arrays (primes, powers, sieve, primes_count);

	free (sieve);

	linked_list_t * pseudo_fortunates = linked_list_create ();

	int prime = 0;

	while ((prime = next_prime (primes, powers, primes_count, N)) > 0) {
		int val = find_pseudo_fortunate (prime);

		linked_list_add_sorted (pseudo_fortunates, copy_int (val), int_cmp, true);
	}

	int sum = linked_list_sum_int (pseudo_fortunates);

	printf ("%d\n", sum);

	linked_list_free (pseudo_fortunates);

	return 0;
}
Exemplo n.º 28
0
/* Initialization */
void x86_cpu_init()
{
	int core;

	/* Trace */
	x86_trace_category = trace_new_category();

	/* Register architecture */
	x86_emu_arch->mem_config_check_func = x86_mem_config_check;
	x86_emu_arch->mem_config_default_func = x86_mem_config_default;
	x86_emu_arch->mem_config_parse_entry_func = x86_mem_config_parse_entry;

	/* Analyze CPU configuration file */
	x86_cpu_config_check();

	/* Initialize */
	x86_cpu = xcalloc(1, sizeof(struct x86_cpu_t));
	x86_cpu->uop_trace_list = linked_list_create();

	/* Initialize cores */
	x86_cpu->core = xcalloc(x86_cpu_num_cores, sizeof(struct x86_core_t));
	X86_CORE_FOR_EACH
		x86_cpu_core_init(core);

	/* Components of an x86 CPU */
	x86_reg_file_init();
	x86_bpred_init();
	x86_trace_cache_init();
	x86_fetch_queue_init();
	x86_uop_queue_init();
	x86_rob_init();
	x86_iq_init();
	x86_lsq_init();
	x86_event_queue_init();
	x86_fu_init();

	/* Trace */
	x86_trace_header("x86.init version=\"%d.%d\" num_cores=%d num_threads=%d\n",
		X86_TRACE_VERSION_MAJOR, X86_TRACE_VERSION_MINOR,
		x86_cpu_num_cores, x86_cpu_num_threads);
}
Exemplo n.º 29
0
/**
 * Create a list of currently loaded pools
 */
static linked_list_t* list_pools(vici_conn_t *conn,
								 command_format_options_t format)
{
	linked_list_t *list;
	vici_res_t *res;

	list = linked_list_create();

	res = vici_submit(vici_begin("get-pools"), conn);
	if (res)
	{
		if (format & COMMAND_FORMAT_RAW)
		{
			vici_dump(res, "get-pools reply", format & COMMAND_FORMAT_PRETTY,
					  stdout);
		}
		vici_parse_cb(res, list_pool, NULL, NULL, list);
		vici_free_res(res);
	}
	return list;
}
END_TEST

START_TEST(test_insert_before_empty)
{
	enumerator_t *enumerator;
	intptr_t x;

	list->destroy(list);
	list = linked_list_create();
	enumerator = list->create_enumerator(list);
	list->insert_before(list, enumerator, (void*)1);
	ck_assert_int_eq(list->get_count(list), 1);
	ck_assert(list->get_first(list, (void*)&x) == SUCCESS);
	ck_assert_int_eq(x, 1);
	ck_assert(list->get_last(list, (void*)&x) == SUCCESS);
	ck_assert_int_eq(x, 1);
	ck_assert(enumerator->enumerate(enumerator, &x));
	ck_assert_int_eq(x, 1);
	ck_assert(!enumerator->enumerate(enumerator, NULL));
	enumerator->destroy(enumerator);
}